Summary Table

Categories	Total Count
PII	0
URL	0
DNS	0
EKL	0
IP	0
PORT	0
VsID	0
CF	0
AI	0
VPD	0
PL	0
Other	0

File Content

define(['angular', 'app', 'BaseCRUDService'], function (angular, app) {
"use strict";
app.service('CollectionCRUDService', function ($rootScope, $http, $q, $parse, $filter, BaseCRUDService) {

//expected use
//fetch > save/delete
//list will not be initialized properly if a save is done without a fetch

var sort = function (list, sortComparator) {

if (angular.isFunction(sortComparator)) {
return list.sort(sortComparator);
} else if (angular.isArray(sortComparator)) {

var isUndefined = angular.isUndefined;

return list.sort(function (left, right) {
var resolvedOrder = 0;
for(var i = 0; i < sortComparator.length; i++) {
var getter = $parse(sortComparator[i].key);
var leftVal = getter(left);
var rightVal = getter(right);

if(angular.isString(leftVal) && angular.isString(rightVal)) {
leftVal = leftVal.toLowerCase();
rightVal = rightVal.toLowerCase();
}

if(leftVal === rightVal) {
resolvedOrder = 0;
} else {
if(angular.isUndefined(leftVal) && angular.isDefined(rightVal)) {
resolvedOrder = -1;
} else if(angular.isDefined(leftVal) && angular.isUndefined(rightVal)) {
resolvedOrder = 1;
} else {
resolvedOrder = leftVal > rightVal ? 1 : -1;
resolvedOrder = sortComparator[i].reverse ? -1 * resolvedOrder : resolvedOrder;
}
break;
}
}
return resolvedOrder;
});
}

return list;
};

//Constructor
var CollectionCRUDService = function(config) {

var that = this;

that.config = config;

that.BaseCRUDService = new BaseCRUDService(config);

that.dataPointers = {
list: null,
filters: null,
link: null,
unfilteredItemCount: null
};

that.compiledSorters = [];

$rootScope.$on("$stateChangeSuccess", function(event, toState, toParams, fromState){
if(fromState.name === "" || toState.data.moduleName !== fromState.data.moduleName) {
that.reset();
}
});
};

//Methods
CollectionCRUDService.prototype = {};

CollectionCRUDService.prototype.transformResponse = function(item) {
return this.config.object.responseTransform ? this.config.object.responseTransform(item) : item;
};

CollectionCRUDService.prototype._onRequestComplete = function (promise) {
var that = this;
var defer = $q.defer();

promise.then(function(success){
var response = success.data;
var code = success.status;
if(response['object-type'] !== undefined && code != 204) {
if(response['object-type'] === that.config.collection.objectType) {
if (response[that.config.collection.name]) {
response[that.config.collection.name].forEach(function (item) {
that.transformResponse(item);
});
} else {
response[that.config.collection.name] = [];
}
} else {
response = that.transformResponse(response);
}
} else if (code == 204) {
response = {};
response[that.config.collection.name] = [];
response.size = 0;
}
defer.resolve(response);
},function(error){
defer.reject(error.data);
});

return defer.promise;
};

CollectionCRUDService.prototype._deleteFromLocalList = function (item) {
var list = this.dataPointers.list;
var expectedId = this.idGetter(item);
if (expectedId && list) {
item = this.localGetById(this.idGetter(item));
var deleteIndex = list.indexOf(item);
if(deleteIndex !== -1) {
list.splice(deleteIndex, 1);
}
}
};

CollectionCRUDService.prototype.idGetter = function(item){
return this.BaseCRUDService.idGetter(item);
};

CollectionCRUDService.prototype.localGetById = function(id) {
var that = this;
var list = that.dataPointers.list;
var listLength = list ? that.dataPointers.list.length : 0;

for(var i = 0; i < listLength; i++) {
if(angular.equals(id, that.idGetter(list[i]))){
return list[i];
}
}
};

CollectionCRUDService.prototype.createEmpty = function() {
return this.BaseCRUDService.createEmpty();
};


CollectionCRUDService.prototype.fetch = function (queryParams) {
var that = this;
var requestPromise = that._onRequestComplete(that.BaseCRUDService.fetch(queryParams));
requestPromise.then(function (response) {
that.dataPointers.filters = angular.copy(queryParams);
that.dataPointers.list = sort(response[that.config.collection.name], that.config.collection.sortComparator);
that.dataPointers.link = response.link;
if (angular.isDefined(response.unfilteredCount)) {
that.dataPointers.unfilteredItemCount = response.unfilteredCount;
}
});
return requestPromise;
};

CollectionCRUDService.prototype.fetchLatest = function (queryParams) {
var that = this;
var requestPromise = that.BaseCRUDService.fetchLatest(queryParams);
requestPromise.then(function (status) {
var response = status.data;
var code = status.status;
if(response['object-type'] !== undefined && code != 204) {
that.latest = that.transformResponse(response);
}
});
return requestPromise;
};

CollectionCRUDService.prototype.save = function (item) {
var that = this;
var requestPromise = that._onRequestComplete(that.BaseCRUDService.save(angular.copy(item)));

requestPromise.then(function (responseItem) {
if(that.dataPointers.list) {
that._deleteFromLocalList(item);
var scopedList = angular.copy(that.dataPointers.list);
scopedList.push(responseItem);
scopedList = that.config.collection.filter ? that.config.collection.filter(scopedList, that.dataPointers.filters) : scopedList;
that.dataPointers.list = sort(scopedList, that.config.collection.sortComparator);
if (!item.link && that.dataPointers.unfilteredItemCount !== null) {
that.dataPointers.unfilteredItemCount++;
}
that.latest = null;
if (that.dataPointers.list.length > 0)
that.latest = that.dataPointers.list[0];
} else if (that.latest) {
that.latest = null;
that.fetchLatest();
}
});
return requestPromise;
};

CollectionCRUDService.prototype.delete = function (item) {
var that = this;

var requestPromise = that.BaseCRUDService.delete(item);
requestPromise.then(function () {
that._deleteFromLocalList(item);
if (that.dataPointers.unfilteredItemCount !== null && that.dataPointers.unfilteredItemCount > 0) {
that.dataPointers.unfilteredItemCount--;
}
if (that.config.object.supportsLatest && that.latest && that.idGetter(item) == that.idGetter(that.latest)) {
that.latest = null;
that.fetchLatest();
}
});
return requestPromise;
};

CollectionCRUDService.prototype.reset = function() {
this.dataPointers.list = null;
this.dataPointers.filters = null;
this.dataPointers.link = null;
this.dataPointers.unfilteredItemCount = null;
};

return CollectionCRUDService;
});
});