环回 - 获取函数而不是值

Question

对于某些端点，我在调用时返回一个函数而不是实际值（最后的代码）。看起来它只通过我的Patient模型出现在嵌套端点上。

E.g。 localhost:3000/api/Patients/{id}/MeasDescPatRels

但是这样可以正常工作：localhost:3000/api/Patients/{id}/MeasuredDataPoints

在我的webapp中，这不是一个真正的问题，显然返回的函数只是由JS调用并给我正确的数据。但是我有一个Android应用程序调用完全相同的端点。

编辑：我也不确定这种行为何时开始。有时在创建患者模型后，但有时它可以工作数小时甚至数天。

返回功能：

function (condOrRefresh, options, cb) {
    if (arguments.length === 0) {
      if (typeof f.value === 'function') {
        return f.value(self);
      } else if (self.__cachedRelations) {
        return self.__cachedRelations[name];
      }
    } else {
      if (typeof condOrRefresh === 'function' &&
          options === undefined && cb === undefined) {
        // customer.orders(cb)
        cb = condOrRefresh;
        options = {};
        condOrRefresh = undefined;
      } else if (typeof options === 'function' && cb === undefined) {
        // customer.orders(condOrRefresh, cb);
        cb = options;
        options = {};
      }
      options = options || {};
      // Check if there is a through model
      // see https://github.com/strongloop/loopback/issues/1076
      if (f._scope.collect &&
        condOrRefresh !== null && typeof condOrRefresh === 'object') {
        //extract the paging filters to the through model
        ['limit', 'offset', 'skip', 'order'].forEach(function(pagerFilter) {
          if (typeof(condOrRefresh[pagerFilter]) !== 'undefined') {
            f._scope[pagerFilter] = condOrRefresh[pagerFilter];
            delete condOrRefresh[pagerFilter];
          }
        });
        // Adjust the include so that the condition will be applied to
        // the target model
        f._scope.include = {
          relation: f._scope.collect,
          scope: condOrRefresh,
        };
        condOrRefresh = {};
      }
      return definition.related(self, f._scope, condOrRefresh, options, cb);
    }
  }

MeasDescPatRels模型（不工作）：

{
    "name": "MeasDescPatRel",
    "base": "PersistedModel",
    "strict": false,
    "idInjection": false,
    "options": {
      "validateUpsert": true
    },
    "properties": {
      "reminderData": {
        "type": "object"
      },
      "alarmData": {
        "type": "object"
      }
    },
    "validations": [],
    "relations": {
      "patient": {
        "type": "belongsTo",
        "model": "Patient",
        "foreignKey": "patientId"
      },
      "measurementDescription": {
        "type": "belongsTo",
        "model": "MeasurementDescription",
        "foreignKey": ""
      }
    },
    "acls": [
      {
        "accessType": "*",
        "principalType": "ROLE",
        "principalId": "$everyone",
        "permission": "ALLOW"
      },
      {
        "accessType": "WRITE",
        "principalType": "ROLE",
        "principalId": "$everyone",
        "permission": "ALLOW"
      }
    ],
    "methods": {}
  }

HomeGateway模型（不工作）：

{
  "name": "HomeGateWay",
  "base": "PersistedModel",
  "idInjection": true,
  "options": {
    "validateUpsert": true
  },
  "properties": {
    "model": {
      "type": "string",
      "required": true
    },
    "version": {
      "type": "string",
      "required": true
    },
    "onlineStatus": {
      "type": "boolean",
      "required": true
    },
    "macAdress": {
      "type": "string",
      "id": true,
      "required": true
    }
  },
  "validations": [],
  "relations": {
    "patient": {
      "type": "belongsTo",
      "model": "Patient",
      "foreignKey": ""
    }
  },
  "acls": [
    {
      "accessType": "*",
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "ALLOW"
    }
  ],
  "methods": {}
}

MeasuredDataPoint模型（工作）：

    {
  "name": "MeasuredDataPoint",
  "base": "PersistedModel",
  "strict": false,
  "idInjection": true,
  "options": {
    "validateUpsert": true
  },
  "properties": {
    "created": {
      "type": "date",
      "required": false
    },
    "timestamp": {
      "type": "date",
      "required": false
    },
    "lastUpdated": {
      "type": "date",
      "required": false
    }
  },
  "validations": [],
  "relations": {
    "measurementDescription": {
      "type": "belongsTo",
      "model": "MeasurementDescription",
      "foreignKey": ""
    },
    "patient": {
      "type": "belongsTo",
      "model": "Patient",
      "foreignKey": "patientId"
    }
  },
  "acls": [
    {
      "accessType": "*",
      "principalType": "ROLE",
      "principalId": "$everyone",
      "permission": "ALLOW"
    }
  ],
  "methods": {}
}

Answer 1

我转载了这个错误：

SomeModel.find({ where: { userId: userId }, include : ['otherModel'] }, (err, response) => {
    var someArray = response;
    for (var x in someArray) {
      var otherModel = someArray[x].otherModel;
      console.log(otherModel);
    }
 });

otherModel的控制台输出为：

function (condOrRefresh, options, cb) {
        if (arguments.length === 0) {
          if (typeof f.value === 'function') {
            return f.value(self);
          } else if (self.__cachedRelations) {
            return self.__cachedRelations[name];
          }
        } else {
          const condOrRefreshIsCallBack = typeof condOrRefresh === 'function' &&
            options === undefined &&
            cb === undefined;
          if (condOrRefreshIsCallBack) {
            // customer.orders(cb)
            cb = condOrRefresh;
            options = {};
            condOrRefresh = undefined;
          } else if (typeof options === 'function' && cb === undefined) {
            // customer.orders(condOrRefresh, cb);
            cb = options;
            options = {};
          }
          options = options || {};
          // Check if there is a through model
          // see https://github.com/strongloop/loopback/issues/1076
          if (f._scope.collect &&
            condOrRefresh !== null && typeof condOrRefresh === 'object') {
            f._scope.include = {
              relation: f._scope.collect,
              scope: condOrRefresh,
            };
            condOrRefresh = {};
          }
          return definition.related(self, f._scope, condOrRefresh, options, cb);
        }
      }

由于otherModel的输出是一个函数。我尝试用以下方式调用它： var otherModel = batchArray[x].otherModel()作为函数而不是var otherModel = batchArray[x].otherModel。它会提供所需的输出。

此行为说明，include过滤器返回模型的函数，该函数将被执行并作为对象传递给前端，但在后端则需要将其称为函数。

我仍在尝试弄清楚它如何将所需的对象返回到前端以及将函数返回到后端。任何线索都将有所帮助。