entityManager.js

(function() {
    'use strict';

    angular.module('app.common')
        .service('entityManager', entityManagerService);

    entityManagerService.$inject = ['$http', '$q'];
    function entityManagerService($http, $q) {

        function EntityManager() {}
        EntityManager.prototype = {
            init: init,
            _pool: {},
            _retrieveInstance: retrieveInstance,
            _search: search,
            _load: load,
            _set: set,
            all: all,
            find: find,
            store: store,
            save: save,
            update: update,
            destroy: destroy
        };

        return EntityManager;

        ////////////////////////////////////////////

        function init(model, url) {
            var vm = this;
            vm.model = model;
            vm.url = url;
        }

        function retrieveInstance (id, data) {
            var vm = this;
            var instance = vm._pool[id];
            if (instance) {
                instance.setData(data);
            } else {
                instance = new vm.model(data);
                vm._pool[id] = instance;
            }
            return instance;
        }

        function search(id) {
            var vm = this;
            return vm._pool[id];
        }

        function load(id, deferred) {
            var vm = this;

            $http.get(vm.url + '/' + id)
                .success(function(response) {
                    var instance = vm._retrieveInstance(response.data.id, response.data);
                    deferred.resolve(instance);
                }).error(function() {
                    deferred.reject();
                });
        }

        function set(data) {
            var vm = this;
            var entity = vm._search(data.id);

            if (entity) {
                entity.setData(data);
            } else {
                entity = vm._retrieveInstance(data.id, data);
            }

            return entity;
        }

        function all() {
            var vm = this;
            var deferred = $q.defer();
            $http.get(vm.url)
                .success(function(data) {
                    var entities = [];
                    angular.forEach(data.data, function(value, key) {
                        var entity = vm._retrieveInstance(value.id, value);
                        entities.push(entity);
                    });
                    deferred.resolve(entities);
                }).error(function () {
                    deferred.reject();
                });
            return deferred.promise;
        }

        function find(id) {
            var vm = this;
            var entity = vm._search(id);
            var deferred = $q.defer();
            if (entity) {
                deferred.resolve(entity);
            } else {
                vm._load(id, deferred);
            }
            return deferred.promise;
        }

        function store(data) {
            var vm = this;
            var entity = vm._search(data.id);
            if (entity) {
                entity.setData(data);
            } else {
                entity = vm._retrieveInstance(data.id, data);
            }
            return entity;
        }

        function save(data) {
            var vm = this;
            var deferred = $q.defer();

            $http.post(vm.url, data)
                .success(function(response) {
                    var instance = vm._retrieveInstance(response.data.id, response.data);
                    deferred.resolve(instance);
                }).error(function() {
                    deferred.reject();
                });

            return deferred.promise;
        }

        function update(data) {
            var vm = this;
            var deferred = $q.defer();

            $http.put(vm.url + '/' + data.id, data)
                .success(function(response) {
                    deferred.resolve(response);
                }).error(function() {
                    deferred.reject();
                });
                return deferred.promise;
        }

        function destroy(id) {
            var vm = this;
            var deferred = $q.defer();

            $http.delete(vm.url + '/' + id)
                .success(function(response) {
                    delete vm._pool[id];
                    deferred.resolve(response);
                }).error(function(response) {
                    deferred.reject();
                });
            return deferred.promise;
        }

    }
})();

listingProvider.js

(function(){
    'use strict';

    angular.module('listing-provider', ['env.vars', 'app.common'])
        .factory('Listing', ListingFactory)
        .factory('listingManager', listingManagerFactory);

        ListingFactory.$inject = [];
        function ListingFactory() {

            function Listing(modelData) {
                if (modelData) {
                    this.setData(modelData);
                }
            };
            Listing.prototype = {
                setData: function(modelData) {
                    angular.extend(this, modelData);
                }
            };
            return Listing;
        }

        // The Listing manager object
        listingManagerFactory.$inject = ['Listing', 'nodeEntityManager', 'getenv'];
        function listingManagerFactory(Listing, nodeEntityManager, getenv) {
            var url = getenv.apiEndpoint + '/listings';
            var listingManager = new nodeEntityManager;
            listingManager.init(Listing, url);

            return listingManager;
        }
})();

nodeEntityManager.js

(function() {
    'use strict';

    angular.module('app.common')
        .service('nodeEntityManager', nodeEntityManagerService);

    nodeEntityManagerService.$inject = ['$http', '$q', 'entityManager', 'getenv'];
    function nodeEntityManagerService($http, $q, entityManager, getenv) {

        function NodeEntityManager() {
            entityManager.call(this);
        }
        NodeEntityManager.prototype = Object.create(entityManager.prototype);
        NodeEntityManager.prototype.constructor = NodeEntityManager;
        NodeEntityManager.prototype.getByPage = getByPage;
        NodeEntityManager.prototype.revision = revision;
        NodeEntityManager.prototype.moderate = moderate;

        return NodeEntityManager;

        ////////////////////////////////////////////

        function getByPage(i) {
            var vm = this;
            var deferred = $q.defer();

            $http.get(vm.url + '?page=' + i)
                .success(function(data) {
                    var entities = [];
                    angular.forEach(data.data, function(value, key) {
                        var entity = vm._retrieveInstance(value.id, value);
                        entities.push(entity);
                    });
                    deferred.resolve(entities);
                }, function () {
                    deferred.reject();
                });
            return deferred.promise;
        }

        function revision(id) {
            var vm = this;
            var deferred = $q.defer();

            $http.get(vm.url + '/' + id + '/revision')
                .success(function(response) {
                    deferred.resolve(response);
                }, function() {
                    deferred.reject();
                });

            return deferred.promise;
        }

        function moderate(id, data) {
            var vm = this;
            var deferred = $q.defer();

            $http.post(getenv.apiEndpoint + '/moderate/' + id, data)
                .success(function(response) {
                    deferred.resolve(response);
                }, function() {
                    deferred.reject();
                });

            return deferred.promise;
        }
    }
})();