/*!
* @license NgModel for AngularJS
* (c) 2015 AyeCue
* License: MIT
* This is inspired by:
* ExtJS modellayer (https://docs.sencha.com/extjs/5.1/5.1.0-apidocs/#!/api/Ext.data.Model),
* ActiveRecord (http://github.com/bfanger/angular-activerecord)
*/
s
s
s
s
s
s
s
s
/**
* Batch for NgModel operations
*
* @class Batch
* @constructor
* @param {NgModel} model Model to use in batch.
* @param {String} operation Operation type like 'read' or 'delete'.
* @param {Object} [options] Extra options for batch.
* @private
*/
function Batch(model,operation,options){
var me = this;
angular.extend(me,{
model: model,
operation: operation,
options: options || {}
});
me.initOptions();
};
Batch.prototype = {
/**
* Initialize all options for batch.
*
* @method initOptions
* @return {Object}
* @private
*/
initOptions: function(){
var me = this,
model = me.model,
options = me.options;
options.data = options.data || {};
if (model.appendData[me.operation]) {
angular.extend(options.data,model.getRequestData());
angular.forEach(model.notPersist,function(toExclude) {
removeNamespace(options.data,toExclude,true);
});
}
if (!options.headers) {
options.headers = model.headers;
} else {
angular.extend(options.headers,model.headers);
}
if (!options.method) {
options.method = model.actionMethods[me.operation];
}
if (!options.url) {
options.url = model.buildUrl(me.operation,options);
}
return options;
},
/**
* Get if batch is reading.
*
* @method isReading
* @return {Boolean}
* @private
*/
isReading: function(){
return this.operation === 'read';
},
/**
* Get if batch is writing.
*
* @method isWriting
* @return {Boolean}
* @private
*/
isWriting: function(){
return this.operation === 'create' || this.operation === 'update';
},
/**
* Get options property of batch.
*
* @method get
* @return {Object}
* @private
*/
get: function(){
return this.options;
}
};
/**
* Process filters through data object.
*
* @param {Object} [filters] Collection of filters you want to apply.
* @param {Object} [properties] Object of the data.
* @private
*/
function applyFilters (filters, properties) {
if (!filters) {
return;
}
angular.forEach(filters, function (filter,namespace) {
var value = getNamespace(properties,namespace),
newValue;
if (isDefined(value)) {
newValue = angular.isFunction(filter) ? filter(value) : $parse(namespace + '|' + filter)(properties);
setNamespace(properties,namespace,newValue);
}
});
}
/**
* Check if value is defined.
*
* @param {Mixed} obj Value to check if it's defined.
* @return Boolean
* @private
*/
function isDefined (obj) {
return obj !== undefined && obj !== null;
}
/**
* Extend properties to target class.
*
* @param {Object} properties Properties to extend.
* @param {Mixed} to Target class.
* @private
*/
function extendTo(properties,to){
angular.forEach(properties,function(value,key){
if (!properties.hasOwnProperty(key)) {
return;
}
if (angular.isFunction(value)) {
value.$previous = to[key];
}
to[key] = value;
});
}
/**
* Call parent class method
*
* @param {Mixed} [args] Arguments you need in the parent method.
* @param {String} [method] If you use strict mode you may have to this argument to define the method you want to call.
* @return Mixed
* @private
*/
function callParent(args,method){
var caller = this[method] || this.callParent.caller || arguments.callee.caller || arguments.caller;
if (!caller) {
if (isStrict()) {
throw new Error('You are in strict mode use the second parameter in "callParent".');
}
throw new Error('The method "callParent" failed because cannot identify caller.');
}
return caller.$previous.apply(this,args);
}
/**
* Check if strict
*
* @return Boolean
* @private
*/
function isStrict() {
return !this;
}
/**
* Set namespace in object.
*
* @param {Object} obj Object you want to manipulate.
* @param {String} id Namespace for value you want to set.
* @param {Mixed} value Value for namespace.
* @private
*/
function setNamespace(obj,id,value){
$parse(id).assign(obj,value);
}
/**
* Get namespace in object.
*
* @param {Object} obj Object you want to search through.
* @param {String} id Namespace for value you want to get.
* @return {Mixed}
* @private
*/
function getNamespace(obj,id){
return $parse(id)(obj);
}
/**
* Remove namespace in object.
*
* @param {Object} obj Object you want to manipulate.
* @param {String} id Namespace for value you want to remove.
* @param {Boolean} [autoDelete] Auto delete parent if object is empty.
* @private
*/
function removeNamespace(obj,id,autoDelete){
var parts = id.split('.'),
last = parts.pop(),
pre = parts.join('.'),
root = getNamespace(obj,pre);
root[last] = null;
delete root[last];
if (autoDelete) {
for (var key in root) {
if (root.hasOwnProperty(key)) {
return;
}
}
removeNamespace(obj,pre,autoDelete);
}
}
/**
* Modellayer for AngularJS
*
* @class NgModel
* @constructor
* @param {Object} [properties] Start properties of record.
*/
function NgModel (properties){
var me = this;
me.response = null;
me.data = angular.extend({},me.defaultData,properties);
me.initialize.apply(me, arguments);
}
/**
* Create new child type of model.
*
* @method create
* @static
* @param {Object} [properties] prototypeProperties for child model prototype.
* @param {Object} [statics] staticProperties for child model static properties.
* @return {Function} Constructor
*/
NgModel.create = function(properties,statics){
var extend = this,
sub;
properties = properties || {};
statics = statics || {};
if (properties.hasOwnProperty('constructor')) {
sub = properties.constructor;
properties.constructor = null;
delete properties.constructor;
} else {
sub = function(){
return extend.apply(this,arguments);
};
}
sub.constructor.$previous = extend.constructor;
sub.prototype = Object.create(extend.prototype);
sub.$super = extend;
angular.extend(sub,extend);
extendTo(properties,sub.prototype);
extendTo(statics,sub);
return sub;
};
/**
* Fetch one record.
*
* @method fetchOne
* @static
* @param {Mixed} id
* @param {Object} [options] Additional options for request.
* @return $q.promise
*/
NgModel.fetchOne = function (id,options){
var model = new this();
model.setId(id);
return model.fetch(options);
};
/**
* Fetch collection of records.
*
* @method fetchAll
* @static
* @param {Object} [options] Additional options for request.
* @return $q.promise
*/
NgModel.fetchAll = function (options){
var model = this,
instance = new model(),
deferred = $q.defer();
instance.sync('read',instance,options).then(function (response){
var data = instance.parse(response.data, options),
models, filters;
if (angular.isArray(data)) {
models = [];
filters = model.prototype.readFilters;
angular.forEach(data, function (item) {
applyFilters(filters, item);
models.push(new model(item));
});
deferred.resolve(models);
} else {
deferred.reject('Not a valid response, expecting an array');
}
}, deferred.reject);
return deferred.promise;
};
/**
* Call parent class method
*
* @method callParent
* @static
* @private
* @param {Mixed} [args] Arguments you need in the parent method.
* @return {Mixed}
*/
NgModel.callParent = callParent;
NgModel.prototype = {
/**
* The default namespace for the id property.
*
* @property idProperty
* @type String
* @default "id"
*/
idProperty: 'id',
/**
* The default propertiers of a record.
*
* @property defaultData
* @type Object
* @default {}
*/
defaultData: {},
/**
* The default headers for a request.
*
* @property headers
* @type Object
* @default {}
*/
headers: {},
/**
* The root namespace which contain the data.
*
* @property resultRoot
* @type String
* @default null
*/
resultRoot: null,
/**
* The main request url.
*
* @property url
* @type String
* @default null
*/
url: null,
/**
* Filter for data processing when reading.
*
* @property readFilters
* @type Object
* @default null
*/
readFilters: null,
/**
* Filter for data processing when writing.
*
* @property writeFilters
* @type Object
* @default null
*/
writeFilters: null,
/**
* Exclude non persit data from request.
*
* @property notPersist
* @type Array<String>
* @default []
*/
notPersist: [],
/**
* Define your model crud schema.
*
* @property actionMethods
* @type Object
* @default {'create': 'POST','read': 'GET','update': 'PUT','delete': 'DELETE'}
*/
actionMethods: {
'create': 'POST',
'read': 'GET',
'update': 'PUT',
'delete': 'DELETE'
},
/**
* Specify certain url for certain operations (optional).
*
* @property api
* @type Object
* @default {'create': null,'read': null,'update': null,'delete': null}
*/
api: {
'create': null,
'read': null,
'update': null,
'delete': null
},
/**
* Specify for which operation your model should append data to the request.
*
* @property appendData
* @type Object
* @default {'create': true,'read': false,'update': true,'delete': false}
*/
appendData: {
'create': true,
'read': false,
'update': true,
'delete': false
},
/**
* Model initialization
*
* @method initialize
* @private
* @param {Object} [properties] Start properties of record.
* @param {Object} [options] Additional options for model.
*/
initialize: function (properties, options) {
var me = this;
options = options || {};
if (properties) {
if (options.parse) {
properties = me.parse(properties);
}
if (options.readFilters) {
applyFilters(me.readFilters, properties);
}
me.extend(properties);
me.previousProperties = function () {
return properties;
};
}
if (options.url) {
me.url = options.url;
}
},
/**
* Check if model data has changed since the last sync.
*
* @method hasChanged
* @param {String} [property] Property to control.
* @return {Boolean}
*/
hasChanged: function (property) {
var me = this,
changed = me.changedProperties();
if (property) {
return property in changed;
}
for (var i in changed) {
return true;
}
return false;
},
/**
* Create object which contains all changed properties.
*
* @method changedProperties
* @param {Object} [diff] An object to diff against, determining if there would be a change.
* @return {Object}
*/
changedProperties: function (diff) {
var me = this,
current = diff || me.data,
changed = {},
previousProperties = me.previousProperties();
if (!isDefined(diff)) {
angular.forEach(previousProperties,function(value,property){
if (!isDefined(value)) {
changed[property] = value;
}
});
}
angular.forEach(current,function(value,property){
if (current.hasOwnProperty(property) && !angular.equals(value, previousProperties[property]) === false) {
changed[property] = value;
}
});
return changed;
},
/**
* Get the state of a property before the last change.
*
* @method previous
* @param {String} property Property which you want to get.
* @return {Mixed}
*/
previous: function (property) {
var me = this,
previous = me.previousProperties();
return getNamespace(previous,property);
},
/**
* Get the state of data before the last change.
*
* @method previousProperties
* @return {Object}
*/
previousProperties: function () {
return {};
},
/**
* Read a record.
*
* @method fetch
* @param {Object} [options] Additonal request options.
* @return $q.promise
*/
fetch: function (options) {
var me = this,
deferred = $q.defer();
me.sync('read', me, options).then(function (response) {
var data = me.parse(response.data, options),
status = response.status,
success = status < 400;
me.response = response;
if (success && angular.isObject(data)) {
applyFilters(me.readFilters, data);
me.extend(data);
me.previousProperties = function () {
return data;
};
deferred.resolve(me);
} else if (success) {
deferred.resolve(me);
} else {
deferred.reject(me);
}
},function(response){
me.response = response;
deferred.reject(me);
});
return deferred.promise;
},
/**
* Save/Update a record.
*
* @method save
* @param {Object} [options] Additonal request options.
* @return $q.promise
*/
save: function (options) {
var me = this,
operation = me.isNew() ? 'create' : 'update',
deferred = $q.defer();
me.sync(operation, me, options).then(function (response) {
var data = me.parse(response.data, options),
status = response.status,
success = status < 400;
me.response = response;
if (success && angular.isObject(data)) {
applyFilters(me.readFilters, data);
me.extend(data);
me.previousProperties = function () {
return data;
};
deferred.resolve(me);
} else if (success) {
deferred.resolve(me);
} else {
deferred.reject(me);
}
},function(response){
me.response = response;
deferred.reject(me);
});
return deferred.promise;
},
/**
* Delete a record.
*
* @method destroy
* @param {Object} [options] Additonal request options.
* @return $q.promise
*/
destroy: function (options) {
var me = this,
deferred = $q.defer();
if (me.isNew()) {
deferred.resolve(me);
return deferred.promise;
}
me.sync('delete', me, options).then(function (response) {
me.response = response;
deferred.resolve(me);
}, function(response){
me.response = response;
deferred.reject(me);
});
return deferred.promise;
},
/**
* Sync a record.
*
* @method sync
* @private
* @param {String} operation Indicates which operation should be done.
* @param {NgModel} model Record used for request.
* @param {Object} [options] Additonal request options.
* @return $q.promise
*/
sync: function (operation, model, options) {
var me = this,
batch = new Batch(model,operation,options);
options = batch.get();
if (batch.isWriting()) {
applyFilters(me.writeFilters,options.data);
}
return $http(options);
},
/**
* Put together url for request.
*
* @method buildUrl
* @private
* @param {String} operation Indicates which operation should be done.
* @param {Object} [options] Batch options.
* @return {String}
*/
buildUrl: function (operation,options){
var me = this,
url = me.api[operation] || me.url,
data = angular.extend({},me.data,options.data),
formatedUrl = $interpolate(url)(data);
if (!isDefined(data[me.idProperty])) {
return formatedUrl;
}
if (!isDefined(formatedUrl)) {
throw 'Implement this.buildUrl() or specify this.url';
}
return $interpolate('{{root}}{{end}}{{id}}')({
root: formatedUrl,
end: formatedUrl.charAt(formatedUrl.length - 1) === '/' ? '' : '/',
id: encodeURIComponent(data[me.idProperty])
});
},
/**
* Parse raw data from request response.
*
* @method parse
* @private
* @param {Object} data Raw request response data.
* @param {Object} [options] Request options.
* @return {Object}
*/
parse: function (data, options) {
if (!isDefined(this.resultRoot)) {
return data;
}
return getNamespace(data,this.resultRoot);
},
/**
* Indicates if record is new or not (important for save/update operation).
*
* @method isNew
* @return {Boolean}
*/
isNew: function () {
return !isDefined(this.getId());
},
/**
* Getter for data property.
*
* @method toJSON
* @return {Object}
*/
toJSON: function (){
return this.data;
},
/**
* Easy way to extend model to a scope.
*
* @method toScope
* @param {Object} scope Scope you want to add the model.
* @param {String} key Property where you want to add the model to.
* @return {NgModel}
*/
toScope: function(scope,key){
scope[key] = this.data;
return this;
},
/**
* Process data for batch (advised to extend as soon as you want extended data processing for requests).
*
* @method getRequestData
* @private
* @return {Object}
*/
getRequestData: function (){
return this.data;
},
/**
* Get id of record.
*
* @method getId
* @return {Mixed}
*/
getId: function (){
return this.data[this.idProperty];
},
/**
* Change id of record.
*
* @method setId
* @param {Mixed} id Id value for record.
* @return {Mixed}
*/
setId: function (id){
this.data[this.idProperty] = id;
return this;
},
/**
* Getter for certain data properties.
*
* @method get
* @param {String} key Namespace for value you want to get.
* @return {Mixed}
*/
get: function (key){
return getNamespace(this.data,key);
},
/**
* Setter for certain data properties.
*
* @method set
* @param {String} key Namespace for value you want to set.
* @param {Mixed} value Value you want to set.
* @return {Mixed}
*/
set: function (key,value){
setNamespace(this.data,key,value);
return this;
},
/**
* Create a new object which all filtered data wanted.
*
* @method range
* @param {Mixed} [...] Property string you want to export or object with from/to information like {'myProp':'myNewProp'}.
* @return {Object}
*/
range: function (){
var me = this,
result = {};
angular.forEach(arguments,function(item){
var from = item,
to = item;
if (angular.isObject(item)) {
from = item.from;
to = item.to;
}
result[from] = me.data[to];
});
return result;
},
/**
* Easily extend the data object of your model.
*
* @method extend
* @param {Object} data Data to extend.
* @return {NgModel}
*/
extend: function (data){
angular.extend(this.data,data);
return this;
},
/**
* Call parent class method
*
* @method callParent
* @private
* @param {Mixed} [args] Arguments you need in the parent method.
* @return {Mixed}
*/
callParent: callParent
};
s
s
s
