ironwing/dist/core/model.js

Ironwing is a lightweight front-end data library for model like data representations

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _utils = require('./utils');

var _storage = require('./storage');

var _storage2 = _interopRequireDefault(_storage);

var _q = require('q');

var _q2 = _interopRequireDefault(_q);

var _lodashLangClone = require('lodash/lang/clone');

var _lodashLangClone2 = _interopRequireDefault(_lodashLangClone);

var original = {};
var Defer = _q2['default'].defer;

var Model = (function () {
  function Model(type, id, attr, adapter) {
    _classCallCheck(this, Model);

    var models = [],
        p = new Defer(),
        self = this;

    // Check if resource or collection
    this.address = id ? type + '/' + id : type;
    this.type = type;
    this.__adapter = adapter;

    if (!attr) {
      /**
       * GET request case
       * Either fetching a collection
       * Either fetching a resource
       */
      this.__adapter.onDone(function (model) {
        if (model.length) {
          /**
           * GET Collection case
           */
          model.forEach(function (item) {
            models.push(new Model(type, item.id, item, self.__adapter));
          });
          p.resolve(models);
        } else {
          /**
           * GET Resource case
           */
          self.attr = (0, _utils.toCamel)((0, _lodashLangClone2['default'])(model, true));
          _storage2['default'].store(self);
          original[self.type + self.__unique] = model;

          p.resolve(self);
        }
      }).onFail(function () {
        p.reject('GET HTTP request failed for the resource: [' + self.type + ']');
      }).ajax('get', this.address, false);
    } else {
      /**
       * Create a new Model based on an given ATTR
       * NO REQUEST here
       */
      this.attr = (0, _utils.toCamel)((0, _lodashLangClone2['default'])(attr, true));
      _storage2['default'].store(this);
      original[this.type + this.__unique] = attr;

      if (!this.attr.id) {
        this.attr.id = id;
      }
    }

    /**
     * return collection
     */
    if (models.length) {
      return p.promise;
    }

    /**
     * return resource
     */
    if (!attr) {
      return p.promise;
    }
  }

  /**
  * Creates a new model of the type given with the specified attr, if the attr aren't matched the model will not be created
  * @param  {String} type The model type
  * @param  {Object} attr The model's attributes
  */

  /**
   * The update method, sends all attributes via API and if the request was a success it recieves them back
   * also syncs the same models
   * @return {Promise}
   */

  _createClass(Model, [{
    key: 'update',
    value: function update() {
      var self = this,
          defer = new Defer(),
          originalObj = original[this.type + this.__unique],
          syncedOriginal = (0, _utils.syncObjects)(originalObj, this.attr);

      this.__adapter.onDone(function (attr) {
        self.attr = (0, _utils.toCamel)((0, _lodashLangClone2['default'])(attr, true));
        _storage2['default'].store(self);
        original[self.type + self.__unique] = attr;

        defer.resolve(self);
      }).onFail(function () {
        defer.reject('A problem has accoured while trying to update the [' + self.type + '] model');
      }).ajax('put', this.address, false, syncedOriginal);

      return defer.promise;
    }
  }, {
    key: 'get',
    value: function get() {
      var self = this,
          defer = new Defer();

      this.__adapter.onDone(function (attr) {
        /**
         * GET Resource case
         */
        self.attr = (0, _utils.toCamel)((0, _lodashLangClone2['default'])(attr, true));
        _storage2['default'].store(self);
        original[self.type + self.__unique] = attr;

        defer.resolve(self);
      }).ajax('get', this.address, false);

      return defer.promise;
    }
  }, {
    key: 'delete',
    value: function _delete() {
      var defer = new Defer();

      this.__adapter.onDone(function () {
        defer.resolve();
      }).onFail(function () {
        defer.reject();
      }).ajax('delete', this.address, false);

      delete original[this.type + this.__unique];

      _storage2['default']['delete'](this);

      this.attr = {};

      return defer.promise;
    }
  }]);

  return Model;
})();

exports['default'] = Model;
Model.create = function (type, attr, __adapter) {
  var _this = this;

  var defer = new Defer();

  __adapter.onDone(function (newAttr) {
    defer.resolve(new Model(type, newAttr.id, newAttr, __adapter));
  }).onFail(function () {
    defer.reject('A problem has accoured while trying to create a [' + _this.type + '] model');
  }).ajax('post', type, false, attr);

  return defer.promise;
};
module.exports = exports['default'];