Ember Data Saving / Rolling back / Dirty tracking

application.js

/* app/routes/application.js */
cancel(model, transitionToRoute) {
      // relationshipsIsDirty is custom.  hasDirtyAttributes comes with Ember Data
      if (model.get('hasDirtyAttributes') || model.get('relationshipsIsDirty')) {
        Ember.$('#crud').openModal();
        // other stuff....attach the model and transitionToRoute to a transition service to be used when user clicks yes/no in modal
      } else {
        if (model.get('isNew')) {
          model.deleteRecord();
        }
        this.transitionTo(transitionToRoute);
      }
},

dirty-check.js

/* app/mixins/dirty-check.js */
import Ember from ‘ember’;

var RelationshipDirtyCheck = Ember.Mixin.create({
 relationshipDirtyCheck: Ember.computed(‘location’, ‘locationId’, ‘interests.[]’, ‘interestsIds’, function() {
   const model = this;
   let _dirty = false;
   this.eachRelationship((name, meta) => {
     if (meta.kind === ‘belongsTo’){
       if (model.get(name) && model.get(name).get(‘id’) !== this.get(`${name}Id`)) {
         _dirty = true;
       }
     }
     else if (meta.kind === ‘hasMany’) {
       const m2m_ids = this.get(`${name}Ids`) || [];
       const current_m2m_ids = this.get(name).mapBy(‘id’);
       if(m2m_ids.length !== current_m2m_ids.length) { 
         _dirty = true; 
       }
       m2m_ids.forEach((id) => {
         if(!current_m2m_ids.includes(id)) {
           _dirty = true;
         }
       });
     }
   });
   return _dirty;
 }),
 relationshipsIsDirty: Ember.computed(‘relationshipDirtyCheck’, function(){
     return this.get(‘relationshipDirtyCheck’);
 }),
 relationshipsIsNotDirty:   Ember.computed.not(‘relationshipsIsDirty’),
});
export default RelationshipDirtyCheck;

rollback-related.js

/* app/mixins/rollback.js */
import Ember from 'ember';
const { run } = Ember;

var Rollback = Ember.Mixin.create({
  rollbackRelationships() {
    const model = this;
    this.eachRelationship((name, meta) => {
      const related_model = model.get(name);
      if(meta.kind === 'belongsTo'){
        const belongsToId = related_model && related_model.get('id');
        const oldId = model.get(`${name}Id`);
        if(belongsToId !== oldId){
          const originalRecord = model.store.peekRecord(meta.type, oldId);
          run(() => {
            // reset 'location' to old
            model.set(name, originalRecord);
          });
        } 
      }
      else if(meta.kind === 'hasMany') {
        const m2mIds = this.get(`${name}Ids`) || [];
        const current_m2mIds = this.get(name).mapBy('id');
        let updated_arr = [];
        m2mIds.forEach((oldId) => {
          if(!current_m2mIds.includes(oldId)){
            // if not in array, then removed and need to add back
            const originalRecord = model.store.peekRecord(meta.type, oldId);
            updated_arr.push(originalRecord);
          } else {
            //if in array, then added
            const record = model.store.peekRecord(meta.type, oldId);
            updated_arr.push(record);
          }
        });
        model.set(name, updated_arr);
      }
    });
  },
});
export default Rollback;

save-related.js

/* app/mixins/save-related.js */
import Ember from 'ember';
import equal from 'example-app/utils/equal';
const { run } = Ember;

var SaveRelated = Ember.Mixin.create({
  saveRelated() {
    const model = this;
    this.eachRelationship((name, meta) => {
      const related_model = model.get(name);
      if(meta.kind === 'belongsTo'){
        const belongsToId = related_model && related_model.get('id');
        const oldId = model.get(`${name}Id`);
        if(belongsToId !== oldId) {
          run(() => {
            model.set(`${name}Id`, belongsToId);
          });
        } 
      }
      else if(meta.kind === 'hasMany'){
        const current_m2m_ids = model.get(name).mapBy('id');
        const m2m_ids = this.get(`${name}Ids`);
        if(!equal(current_m2m_ids, m2m_ids)) {
          run(() => {
            model.set(`${name}Ids`, current_m2m_ids);
          });
        } 
      }
    });
  },
});
export default SaveRelated;

serializers...application.js

/* app/serializers/application.js */
normalizeFindRecordResponse(store, primaryModelClass, payload) {
 const _p = payload.data;
 const relationships = _p.relationships;
 if (relationships) {
   Object.keys(_p.relationships).forEach((related_key) => {
     // m2m
     if (Array.isArray(relationships[related_key].data)) {
       _p.attributes[`${related_key}-ids`] =  relationships[related_key].data.mapBy(‘id’);
     // belongs_to
     } else if (relationships[related_key].data) {
       _p.attributes[`${related_key}-id`] = relationships[related_key].data.id;
     }
   });
 }
 return this._super(…arguments);
}

user.js

export default DS.Model.extend(DirtyCheck, SaveRelated, Rollback, {
  interests: hasMany(),
  interestsIds: attr(),
  location: belongsTo(),
  locationId: attr(),
});