我們如何自定義轉換的數據執行回滾

Question

我使用自定義轉換在像這樣我的模型之一：

App.Question = DS.Model.extend({ 
     questionName: DS.attr('string'), 
     parentQuestionId: DS.attr('number'), 
     position: DS.attr('number'), 
     questionLayoutId: DS.attr('number'), 
     questionLayoutName: DS.attr('string'), 
     attributes: DS.attr('raw'), 
     childQuestions: DS.hasMany('question', {async: true}) 
    }); 

和我的變換定義爲：

App.RawTransform = DS.Transform.extend({ 

     deserialize: function (serialized) { 
      var obbj = Ember.Object.create(); 
      for (var key in serialized) { 
       obbj.set(key, serialized[key]); 
      } 
      return obbj; 
     }, 
     serialize: function (deserialized) { 
      return JSON.stringify(deserialized); 
     } 
    }); 

在這種設置中，回滾對於轉換的屬性不起作用。這裏是一個jsBin鏈接來演示這個問題：http://jsbin.com/uBAZOfO/1/

所以如果你改變輸入字段並命中回滾，只有名字被回滾。是否有任何解決方法來實現轉換數據的回滾？

感謝， 迪

Answer 1

的轉換不會得到應用除了在查找/保存。

問題是ED不知道如何跟蹤生活在您的記錄上的pojo，所以它不會顯示爲髒屬性，除非您更改了整個pojo，而不僅僅是pojo上的屬性。

你可能會考慮把它變成某種關係，或不POJO數據類型

Answer 2

希望這將節省一些時間的人誰正在努力實現同樣的，我通過寫作以下通用轉型做回滾：

AS.RawTransform = DS.Transform.extend({ 
/** 
* Recursively read through the json object/array and convert it into Ember.Object and Ember.ArrayProxy respectively 
* 
* @param {Object} Javascript object 
* @returns {Object} Ember Object or ArrayProxy 
*/ 
deserialize: function (serialized) { 

    if (!(serialized)) { 
     serialized = {}; 
    } 

    var recursiveDeserializer = function (object, data) { 
     if (!(object)) { 
      if (Object.prototype.toString.call(data) === '[object Array]') { 
       object = Ember.ArrayProxy.createWithMixins(Ember.SortableMixin, { content: Ember.A()}); 
      } else if (Object.prototype.toString.call(data) === '[object Object]') { 
       object = Ember.Object.create(); 
      } 
     } else { 
      //used when rolling back 
      if (Object.prototype.toString.call(data) === '[object Array]') { 
       var all = object.toArray(); 
       all.forEach(function (item) { 
        object.removeObject(item); 
       }); 
      } 
     } 

     if (Object.prototype.toString.call(data) === '[object Object]') { 
      for (var _key in data) { 
       object.set(_key, recursiveDeserializer(null, data[_key])); 
      } 
     } else if (Object.prototype.toString.call(data) === '[object Array]') { 
      for (var i = 0, len = data.length; i < len; i++) { 
       object.get('content').push(recursiveDeserializer(null, data[i])); 
      } 
     } else { 
      return data; 
     } 
     return object; 
    }; 

    var ret = recursiveDeserializer(null, serialized); 

    ret.reopen({ 
     /** 
     * This function reverts back changes made to the content of Ember Object/Array 
     * */ 

     rollback: function() { 
      var self = this; 
      Ember.run(function() { 
       recursiveDeserializer(self, serialized); 
      }); 

     } 
    }); 
    return ret; 
}, 

/** 
* Recursively read through the Ember.Object/Ember.ArrayProxy and convert it into javascript array or object 
* 
* @param {Object} Ember ArrayProxy or Object 
* @return {Object} Javascript object 
* */ 
serialize: function (deserialized) { 

    var recursiveSerializer = function (object, data) { 
     if (!(object)) { 
      if (data instanceof Ember.ArrayProxy) { 
       object = []; 
      } else if (data instanceof Ember.Object) { 
       object = {}; 
      } 
     } 

     /** 
     * Couldn't use instanceof command to check the type 
     * because for some reason at this point the data 
     * is seen as Object even if it is an array 
     * */ 

     if (Object.prototype.toString.call(object) === '[object Object]') { 
      for (var _key in data) { 
       if (data.hasOwnProperty(_key) && 
        _key.indexOf('__ember') < 0 && 
        _key.indexOf('_super') < 0 && 
        Ember.typeOf(data.get(_key)) !== 'function' 
        ) { 
        object[_key] = recursiveSerializer(null, data[_key]); 
       } 
      } 
     } else if (Object.prototype.toString.call(object) === '[object Array]') { 
      data.forEach(function (d) { 
       object[object.length] = (recursiveSerializer(null, d)); 
      }); 
     } else { 
      return data; 
     } 
     return object; 
    }; 

    return recursiveSerializer(null, deserialized); 
} 
}); 

這裏唯一的缺點是我不能只做model.rollback，我必須對每個'raw'數據類型執行回滾。例如：model.get（'tranformedData'）。rollback（）

但我認爲這至少是一個開始。如果數據很髒，也可以在這裏添加觀察者來檢查 。