JSONAPI 序列化嵌套的 hasMany 关系

Question

我们在此项目中使用 JSONAPI，但由于 [原因] 我们无法在 API 中处理其推荐的关系结构，因此我们将它们作为嵌套对象提供并期望它们改为嵌套对象，格式如下：

{
  "data":{
    "type":"video",
    "id":"55532284a1f9f909b0d11d73",

    "attributes":{
      "title":"Test",

      "transcriptions":{
        "type": "embedded",

        "data":[
          {
            "type":"transcription",
            "id":"203dee25-4431-42d1-a0ba-b26ea6938e75",

            "attributes":{
              "transcriptText":"Some transcription text here. And another sentence after it.",

              "cuepoints":{
                "type":"embedded",

                "data":[
                  {
                    "type":"cuepoint",
                    "id":"bb6b0434-bdc4-43e4-8010-66bdef5c432a",

                    "attributes":{
                      "text":"Some transcription text here."
                    }
                  },
                  {
                    "type":"cuepoint",
                    "id":"b663ee00-0ebc-4cf4-96fc-04d904bc1baf",

                    "attributes":{
                      "text":"And another sentence after it."
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  }
}

我的模型结构如下：

// models/video
export default DS.Model.extend({
  transcriptions: DS.hasMany('transcription')
)};

// models/transcription
export default DS.Model.extend({
  video: DS.belongsTo('video'),
  cuepoints: DS.hasMany('cuepoint')
});

// models/cuepoint
export default DS.Model.extend({
  transcription: DS.belongsTo('transcription')
);

现在，我们要做的是保存video 记录，并让它序列化其中包含的transcriptions 和cuepoints。我有以下序列化程序，它可以很好地将transcription 嵌入到video 中，即。一个级别，但我需要它然后将cuepoints 也嵌入其中。

export default DS.JSONAPISerializer.extend({
    serializeHasMany: function(record, json, relationship) {
      var hasManyRecords, key;
          key = relationship.key;
          hasManyRecords = Ember.get(record, key);

      if (hasManyRecords) {
        json.attributes[key] = {};

        hasManyRecords.forEach(function(item) {
          json.attributes[key].data = json.attributes[key].data || [];

          json.attributes[key].data.push({
            attributes: item._attributes,
            id: item.get('id'),
            type: item.get('type')
          });
        });
      } else {
        this._super(record, json, relationship);
      }
    }
  });

检查serializeHasMany 方法中的record、json 和relationship 属性，我看不到任何有关嵌套关系的信息，所以我什至不确定我是否使用了正确的方法。

有什么想法我会出错吗？

Answer 1

您必须为每个模型添加序列化程序，并根据需要在正确的序列化程序中调整有效负载。上面的序列化程序会产生您在描述中提供的确切有效负载。

app/serializers/cuepoint.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend({

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        return this._super(record, options).data;
    },

    serializeBelongsTo () {}

});

app/serializers/transcription.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend(DS.EmbeddedRecordsMixin, {

    attrs: {
        cuepoints: {
            serialize: 'records',
            deserialize: 'records'
        }
    },

    keyForAttribute (key, method) {
        return key;
    },

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        let json = this._super(record, options);
        json.data.attributes.cuepoints = {
            type: 'embedded',
            data: json.data.cuepoints
        }
        delete json.data.cuepoints;
        return json.data;
    },

    serializeBelongsTo () {}

});

app/serializers/video.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend(DS.EmbeddedRecordsMixin, {

    attrs: {
        transcriptions: {
            serialize: 'records',
            deserialize: 'records'
        }
    },

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        let json = this._super(record, options);
        json.data.attributes.transcriptions = {
            type: 'embedded',
            data: json.data.transcriptions
        }
        delete json.data.transcriptions;
        return json;
    },

    serializeBelongsTo () {}

});

Answer 2

我想我已经弄清楚了。有一些我不知道循环关系的方法，我需要编写一个自定义的serialize 方法，而不是仅仅覆盖默认的serializeHasMany 方法。

serialize(record) {
  // Set up the main data structure for the record to be serialized
  var JSON = {
    data: {
      id: record.id,
      type: record.modelName,
      attributes: {}
    }
  };

  // Find relationships in the record and serialize them into the JSON.data.attributes object
  JSON.data.attributes = this.serializeRelationships(JSON.data.attributes, record);

  // Loop through the record's attributes and insert them into the JSON.data.attributes object
  record.eachAttribute((attr) => {
    JSON.data.attributes[attr] = record.attr(attr);
  });

  // Return the fully serialized JSON data
  return JSON;
},

// Take a parent JSON object and an individual record, loops through any relationships in the record, and creates a JSONAPI resource object
serializeRelationships(JSON, record) {
  record.eachRelationship((key, relationship) => {
    if (relationship.kind === 'hasMany') {

      // Set up the relationship data structure
      JSON[relationship.key] = {
        data: []
      };

      // Gran any relationships in the record
      var embeddedRecords = record.hasMany(relationship.key);

      // Loop through the relationship's records and build a resource object
      if (embeddedRecords) {
        embeddedRecords.forEach((embeddedRecord) => {
          var obj = {
            id: embeddedRecord.id,
            type: embeddedRecord.modelName,
            attributes: {}
          }

          // Recursively check for relationships in the record
          obj.attributes = this.serializeRelationships(obj.attributes, embeddedRecord);

          // Loop through the standard attributes and populate the record.data.attributes object
          embeddedRecord.eachAttribute((attr) => {
            obj.attributes[attr] = embeddedRecord.attr(attr);
          });

          JSON[relationship.key].data.push(obj);
        });
      }
    }
  });

  return JSON;
}