imported luticate1 utils; tests

Gruntfile.js

+/**
+ * Created by robin on 11/10/15.
+ */
+
+module.exports = function(grunt) {
+
+    grunt.initConfig({
+        uglify: {
+            demo: {
+                files: {
+                    'dist/luticate-utils.min.js': [
+                        'src/luticateutils.js',
+                        'src/**/*.js'
+                    ]
+                }
+            }
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+
+    grunt.registerTask('default', ['uglify']);
+
+};

bower.json

+{
+  "name": "luticate2-utils",
+  "version": "0.1.0",
+  "authors": [
+    "Robin THONI <robin@rthoni.com>"
+  ],
+  "description": "Luticate front utils",
+  "license": "MIT",
+  "dependencies": {
+  },
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}

dist/luticate-utils.min.js

+!function(){angular.module("luticate2-utils",[])}(),function(){"use strict";angular.module("luticateUtils").factory("luPromise",[function(){var a={};return a.promises={},a.loaders=[],a.errors=[],a.STATUS_RUNNING=0,a.STATUS_RESOLVED=1,a.STATUS_REJECTED=2,a.build=function(b){a[b]={};for(var c in a.promises)if(a.promises.hasOwnProperty(c)){var d=a.promises[c];d[b].forEach(function(c){null==a[b][c]&&(a[b][c]=[]),a[b][c].push(d)})}},a.newPromise=function(a,b,c,d){return{id:a,groups:b,loaderGroups:c,errorGroups:d}},a.initPromise=function(b){var c={loaders:[],errors:[],status:a.STATUS_RUNNING,id:b.id};b.groups instanceof Array?b.groups.forEach(function(a){c.loaders.push(a),c.errors.push(a)}):"string"==typeof b.groups&&(c.loaders.push(b.groups),c.errors.push(b.groups)),b.loaderGroups instanceof Array?b.loaderGroups.forEach(function(a){c.loaders.push(a)}):"string"==typeof b.loaderGroups&&c.loaders.push(b.loaderGroups),b.errorGroups instanceof Array?b.errorGroups.forEach(function(a){c.errors.push(a)}):"string"==typeof b.errorGroups&&c.errors.push(b.errorGroups),a.promises[b.id]=c,a.build("loaders"),a.build("errors")},a.getLoadersGroup=function(b){return null==a.loaders[b]?null:a.loaders[b]},a.getErrorsGroup=function(b){return null==a.errors[b]?null:a.errors[b]},a.reject=function(b,c){a.promises[b.id].status=a.STATUS_REJECTED,a.promises[b.id].value=c},a.resolve=function(b,c){a.promises[b.id].status=a.STATUS_RESOLVED,a.promises[b.id].value=c},a}])}(),function(){"use strict";angular.module("luticateUtils").factory("luRequest",["$q","$http","luPromise",function(a,b,c){function d(a,b,d,e){var f={Data:b,Status:d};a.reject(f),null!=e&&c.reject(e,f)}function e(a,b,d){a.resolve(b),null!=d&&c.resolve(d,b)}var f={};return f.get=function(a,b,c){return f.request(a,"GET",b,null,c)},f.post=function(a,b,c,d){return f.request(a,"POST",b,c,d)},f.put=function(a,b,c,d){return f.request(a,"PUT",b,c,d)},f["delete"]=function(a,b,c,d){return f.request(a,"DELETE",b,c,d)},f.request=function(f,g,h,i,j){null!=j&&c.initPromise(j);var k=a.defer();f=f.replace(/\/+$/,"");var l={url:f,method:g,params:h,data:null==i?null:$.param(i),headers:{"Content-Type":"application/x-www-form-urlencoded"}};return b(l).success(function(a,b){if(null==a||null!=a.Message){var c=null==a?"Failed to parse response":a.Message;d(k,c,b,j)}else e(k,a.Data,j)}).error(function(a,b){if(null==a||null!=a.Message){var c=null==a?"Failed to parse response":a.Message;d(k,c,b,j)}else d(k,a,b,j)}),k.promise},f}])}();

karma.conf.js

+// Karma configuration
+// Generated on Sun Dec 11 2016 16:29:58 GMT-0500 (EST)
+
+module.exports = function(config) {
+  config.set({
+
+    // base path that will be used to resolve all patterns (eg. files, exclude)
+    basePath: '',
+
+
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ['jasmine'],
+
+
+    // list of files / patterns to load in the browser
+    files: [
+        './node_modules/angular/angular.js',
+        './node_modules/angular-ui-router/release/angular-ui-router.js',
+        './node_modules/angular-mocks/angular-mocks.js',
+        './src/luticate2-utils.js',
+        './src/**/*.js',
+        './tests/**/*.spec.js'
+    ],
+
+
+    // list of files to exclude
+    exclude: [
+    ],
+
+
+    // preprocess matching files before serving them to the browser
+    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+    preprocessors: {
+    },
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress'
+    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+    reporters: ['progress'],
+
+
+    // web server port
+    port: 9876,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: true,
+
+
+    // start these browsers
+    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+    browsers: ['Chrome'],
+
+
+    // Continuous Integration mode
+    // if true, Karma captures browsers, runs the tests and exits
+    singleRun: false,
+
+    // Concurrency level
+    // how many browser should be started simultaneous
+    concurrency: Infinity
+  })
+}

package.json

+{
+  "name": "luticate2-utils",
+  "version": "0.1.0",
+  "description": "Luticate front utils",
+  "main": "dist/luticate-utils.min.js",
+  "dependencies": {
+    "grunt": "~0.4.5",
+    "grunt-contrib-uglify": "~0.10.0"
+  },
+  "devDependencies": {
+    "angular": "^1.6.0",
+    "angular-mocks": "^1.6.0",
+    "angular-ui-router": "^0.3.2",
+    "jasmine-core": "^2.5.2",
+    "karma": "^1.3.0",
+    "karma-chrome-launcher": "^2.0.0",
+    "karma-jasmine": "^1.1.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.rthoni.com/luticate2/front-utils"
+  },
+  "author": "",
+  "license": "MIT"
+}

src/Business/lu-promise.js

+/**
+ * Created by robin on 10/24/15.
+ */
+
+(function () {
+    'use strict';
+    angular.module('luticate2Utils')
+        .factory('luPromise', [function() {
+
+            var luPromise = {};
+            luPromise.promises = {};
+            luPromise.loaders = [];
+            luPromise.errors = [];
+
+            luPromise.STATUS_RUNNING = 0;
+            luPromise.STATUS_RESOLVED = 1;
+            luPromise.STATUS_REJECTED = 2;
+
+            luPromise.build = function(array)
+            {
+                luPromise[array] = {};
+                for (var id in luPromise.promises) {
+                    if (luPromise.promises.hasOwnProperty(id)) {
+                        var promise = luPromise.promises[id];
+                        promise[array].forEach(function (group) {
+                            if (luPromise[array][group] == null) {
+                                luPromise[array][group] = [];
+                            }
+                            luPromise[array][group].push(promise);
+                        });
+                    }
+                }
+            };
+
+            luPromise.newPromise = function(id, groups, loaderGroups, errorGroups) {
+                return {
+                    id: id,
+                    groups: groups,
+                    loaderGroups: loaderGroups,
+                    errorGroups: errorGroups
+                };
+            };
+
+            luPromise.initPromise = function(data) {
+                var p = {
+                    loaders : [],
+                    errors: [],
+                    status: luPromise.STATUS_RUNNING,
+                    id: data.id
+                };
+
+                if (data.groups instanceof Array) {
+                    data.groups.forEach(function (group) {
+                        p.loaders.push(group);
+                        p.errors.push(group);
+                    });
+                }
+                else if (typeof data.groups === 'string') {
+                    p.loaders.push(data.groups);
+                    p.errors.push(data.groups);
+                }
+
+                if (data.loaderGroups instanceof Array) {
+                    data.loaderGroups.forEach(function (group) {
+                        p.loaders.push(group);
+                    });
+                }
+                else if (typeof data.loaderGroups === 'string') {
+                    p.loaders.push(data.loaderGroups);
+                }
+
+                if (data.errorGroups instanceof Array) {
+                    data.errorGroups.forEach(function (group) {
+                        p.errors.push(group);
+                    });
+                }
+                else if (typeof data.errorGroups === 'string') {
+                    p.errors.push(data.errorGroups);
+                }
+
+                luPromise.promises[data.id] = p;
+
+                luPromise.build("loaders");
+                luPromise.build("errors");
+            };
+
+            luPromise.getLoadersGroup = function(group) {
+                if (luPromise.loaders[group] == null) {
+                    return null;
+                }
+                return luPromise.loaders[group];
+            };
+
+            luPromise.getErrorsGroup = function(group) {
+                if (luPromise.errors[group] == null) {
+                    return null;
+                }
+                return luPromise.errors[group];
+            };
+
+            luPromise.reject = function(promise, error) {
+                luPromise.promises[promise.id].status = luPromise.STATUS_REJECTED;
+                luPromise.promises[promise.id].value = error;
+            };
+
+            luPromise.resolve = function(promise, data) {
+                luPromise.promises[promise.id].status = luPromise.STATUS_RESOLVED;
+                luPromise.promises[promise.id].value = data;
+            };
+
+            return luPromise;
+        }]);
+})();

src/DataAccess/lu-dataaccess.js

+/**
+ * Created by robin on 12/11/16.
+ */
+
+(function () {
+    'use strict';
+    angular.module('luticate2Utils')
+        .factory('luDataAccess', ['$q', 'luRequest', function ($q, luRequest) {
+
+            var luDataAccess = {};
+
+            luDataAccess.create = function (entry_point) {
+                var da = {};
+
+                da.entry_point = entry_point;
+                if (da.entry_point.substr(-1) !== '/') {
+                    da.entry_point += '/';
+                }
+
+                da.get = function(url, dataGet, promise)
+                {
+                    return luRequest.get(da.entry_point + url, dataGet, promise);
+                };
+
+                da.post = function(url, dataGet, dataPost, promise)
+                {
+                    return luRequest.post(da.entry_point + url, dataGet, dataPost, promise);
+                };
+
+                da.put = function(url, dataGet, dataPost, promise)
+                {
+                    return luRequest.put(da.entry_point + url, dataGet, dataPost, promise);
+                };
+
+                da.delete = function(url, dataGet, dataPost, promise)
+                {
+                    return luRequest.delete(da.entry_point + url, dataGet, dataPost, promise);
+                };
+
+                return da;
+            };
+
+            return luDataAccess;
+
+        }]);
+})();

src/DataAccess/lu-request.js

+/**
+ * Created by robin on 10/24/15.
+ */
+
+(function () {
+    'use strict';
+    angular.module('luticate2Utils')
+        .factory('luRequest', ['$q', '$http', 'luPromise', function ($q, $http, luPromise) {
+
+            var luRequest = {};
+
+            luRequest.get = function(url, dataGet, promise)
+            {
+                return luRequest.request(url, 'GET', dataGet, null, promise);
+            };
+
+            luRequest.post = function(url, dataGet, dataPost, promise)
+            {
+                return luRequest.request(url, 'POST', dataGet, dataPost, promise);
+            };
+
+            luRequest.put = function(url, dataGet, dataPost, promise)
+            {
+                return luRequest.request(url, 'PUT', dataGet, dataPost, promise);
+            };
+
+            luRequest.delete = function(url, dataGet, dataPost, promise)
+            {
+                return luRequest.request(url, 'DELETE', dataGet, dataPost, promise);
+            };
+
+            function reject(deferred, data, status, promise)
+            {
+                var obj = {
+                    Data: data,
+                    Status: status
+                };
+                deferred.reject(obj);
+                if (promise != null) {
+                    luPromise.reject(promise, obj);
+                }
+            }
+
+            function resolve(deferred, data, promise)
+            {
+                deferred.resolve(data);
+                if (promise != null) {
+                    luPromise.resolve(promise, data);
+                }
+            }
+
+            luRequest.request = function(url, method, dataGet, dataPost, promise)
+            {
+                if (promise != null) {
+                    luPromise.initPromise(promise);
+                }
+                var deferred = $q.defer();
+
+                url = url.replace(/\/+$/, '');
+
+                var params = {
+                    url: url,
+                    method: method,
+                    params: dataGet,
+                    data: dataPost == null ? null : $.param(dataPost),
+                    headers: {
+                        'Content-Type': "application/json"
+                    }
+                };
+
+                $http(params)
+                    .success(function (result, status) {
+                        if (result == null || result.Message != null) {
+                            var message = result == null ? "Failed to parse response" : result.Message;
+                            reject(deferred, message, status, promise);
+                        }
+                        else {
+                            resolve(deferred, result.Data, promise);
+                        }
+                    })
+                    .error(function (result, status) {
+                        if (result == null || result.Message != null) {
+                            var message = result == null ? "Failed to parse response" : result.Message;
+                            reject(deferred, message, status, promise);
+                        }
+                        else {
+                            reject(deferred, result, status, promise);
+                        }
+                    });
+                return deferred.promise;
+            };
+
+            return luRequest;
+        }]);
+})();

src/luticate2-utils.js

+/**
+ * Created by robin on 10/25/15.
+ */
+
+(function() {
+    angular.module("luticate2Utils", []);
+})();

tests/Business/lu-promise.spec.js

+/**
+ * Created by robin on 12/11/16.
+ */
+
+describe('lu-promise factory', function() {
+    var luPromise;
+
+    // Before each test load our api.users module
+    beforeEach(angular.mock.module('luticate2Utils'));
+
+    // Before each test set our injected Users factory (_Users_) to our local Users variable
+    beforeEach(inject(function(_luPromise_) {
+        luPromise = _luPromise_;
+    }));
+
+    it('should init a simple promise', function()
+    {
+        var p  = luPromise.newPromise('my-id', 'all-groups', 'loader-groups', 'error-groups');
+        luPromise.initPromise(p);
+        expect(Object.keys(luPromise.promises).length).toEqual(1);
+
+        var d = luPromise.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'error-groups']);
+        expect(d.status).toBe(luPromise.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luPromise.errors).length).toEqual(2);
+        expect(luPromise.errors['all-groups'].length).toEqual(1);
+        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.errors['error-groups'].length).toEqual(1);
+        expect(luPromise.errors['error-groups'][0]['id']).toEqual('my-id');
+
+        expect(Object.keys(luPromise.loaders).length).toEqual(2);
+        expect(luPromise.loaders['all-groups'].length).toEqual(1);
+        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
+        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init a more complex promise 1', function()
+    {
+        var p  = luPromise.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
+        luPromise.initPromise(p);
+        expect(Object.keys(luPromise.promises).length).toEqual(1);
+
+        var d = luPromise.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'another-group']);
+        expect(d.status).toBe(luPromise.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luPromise.errors).length).toEqual(2);
+        expect(luPromise.errors['all-groups'].length).toEqual(1);
+        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.errors['another-group'].length).toEqual(1);
+        expect(luPromise.errors['another-group'][0]['id']).toEqual('my-id');
+
+        expect(Object.keys(luPromise.loaders).length).toEqual(3);
+        expect(luPromise.loaders['all-groups'].length).toEqual(1);
+        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.loaders['another-group'].length).toEqual(1);
+        expect(luPromise.loaders['another-group'][0]['id']).toEqual('my-id');
+        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
+        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init a more complex promise 2', function()
+    {
+        var p  = luPromise.newPromise('my-id', null, 'loader-groups');
+        luPromise.initPromise(p);
+        expect(Object.keys(luPromise.promises).length).toEqual(1);
+
+        var d = luPromise.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['loader-groups']);
+        expect(d.errors).toEqual([]);
+        expect(d.status).toBe(luPromise.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        expect(Object.keys(luPromise.errors).length).toEqual(0);
+
+        expect(Object.keys(luPromise.loaders).length).toEqual(1);
+        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
+        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+
+    it('should init multiple more complex promise 1', function()
+    {
+        var p1  = luPromise.newPromise('my-id', ['all-groups', 'another-group'], 'loader-groups');
+        luPromise.initPromise(p1);
+        var p2  = luPromise.newPromise('my-id2', ['all-groups', 'another-group'], null, 'an-error-group');
+        luPromise.initPromise(p2);
+        expect(Object.keys(luPromise.promises).length).toEqual(2);
+
+        var d = luPromise.promises['my-id'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group', 'loader-groups']);
+        expect(d.errors).toEqual(['all-groups', 'another-group']);
+        expect(d.status).toBe(luPromise.STATUS_RUNNING);
+        expect(d.id).toBe('my-id');
+
+        d = luPromise.promises['my-id2'];
+        expect(d).not.toBe(null);
+        expect(d).not.toBe(undefined);
+        expect(d.loaders).toEqual(['all-groups', 'another-group']);
+        expect(d.errors).toEqual(['all-groups', 'another-group', 'an-error-group']);
+        expect(d.status).toBe(luPromise.STATUS_RUNNING);
+        expect(d.id).toBe('my-id2');
+
+        expect(Object.keys(luPromise.errors).length).toEqual(3);
+        expect(luPromise.errors['all-groups'].length).toEqual(2);
+        expect(luPromise.errors['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.errors['all-groups'][1]['id']).toEqual('my-id2');
+        expect(luPromise.errors['another-group'].length).toEqual(2);
+        expect(luPromise.errors['another-group'][0]['id']).toEqual('my-id');
+        expect(luPromise.errors['another-group'][1]['id']).toEqual('my-id2');
+        expect(luPromise.errors['an-error-group'].length).toEqual(1);
+        expect(luPromise.errors['an-error-group'][0]['id']).toEqual('my-id2');
+
+        expect(Object.keys(luPromise.loaders).length).toEqual(3);
+        expect(luPromise.loaders['all-groups'].length).toEqual(2);
+        expect(luPromise.loaders['all-groups'][0]['id']).toEqual('my-id');
+        expect(luPromise.loaders['all-groups'][1]['id']).toEqual('my-id2');
+        expect(luPromise.loaders['another-group'].length).toEqual(2);
+        expect(luPromise.loaders['another-group'][0]['id']).toEqual('my-id');
+        expect(luPromise.loaders['another-group'][1]['id']).toEqual('my-id2');
+        expect(luPromise.loaders['loader-groups'].length).toEqual(1);
+        expect(luPromise.loaders['loader-groups'][0]['id']).toEqual('my-id');
+    });
+});