begin promises management

src/lubusy.css

@@ -0,0 +1,285 @@
+.lu-busy{
+    position:absolute;
+    top:0px;
+    left:0px;
+    right:0px;
+    bottom:0px;
+    z-index:1001;
+}
+
+.lu-busy-animation.ng-hide-add,
+.lu-busy-animation.ng-hide-remove {
+    -webkit-transition:all .3s ease;
+    -moz-transition:all .3s ease;
+    -o-transition:all .3s ease;
+    transition:all .3s ease;
+    display:block !important;
+}
+.lu-busy-animation.ng-hide-remove {
+    opacity:0;
+    -webkit-transform:translate(0px,-40px);
+    -moz-transform:translate(0px,-40px);
+    -ms-transform:translate(0px,-40px);
+    -o-transform:translate(0px,-40px);
+    transform:translate(0px,-40px);
+}
+.lu-busy-animation.ng-hide-remove.ng-hide-remove-active {
+    opacity:1;
+    -webkit-transform:translate(0px,0px);
+    -moz-transform:translate(0px,0px);
+    -ms-transform:translate(0px,0px);
+    -o-transform:translate(0px,0px);
+    transform:translate(0px,0px);
+}
+.lu-busy-animation.ng-hide-add {
+    opacity:1;
+    -webkit-transform:translate(0px,0px);
+    -moz-transform:translate(0px,0px);
+    -ms-transform:translate(0px,0px);
+    -o-transform:translate(0px,0px);
+    transform:translate(0px,0px);
+}
+.lu-busy-animation.ng-hide-add.ng-hide-add-active {
+    opacity:0;
+    -webkit-transform:translate(0px,-40px);
+    -moz-transform:translate(0px,-40px);
+    -ms-transform:translate(0px,-40px);
+    -o-transform:translate(0px,-40px);
+    transform:translate(0px,-40px);
+}
+
+.lu-busy-backdrop {
+    background-color:white;
+    opacity:.7;
+}
+
+.lu-busy-backdrop-animation.ng-hide-add,
+.lu-busy-backdrop-animation.ng-hide-remove {
+    -webkit-transition:opacity .3s ease;
+    -moz-transition:opacity .3s ease;
+    -o-transition:opacity .3s ease;
+    transition:opacity .3s ease;
+    display:block !important;
+}
+
+.lu-busy-backdrop-animation.ng-hide {
+    opacity:0;
+}
+
+/* All styles below are for the default template. */
+
+.lu-busy-default-wrapper {
+    text-align:center;
+}
+
+.lu-busy-default-sign{
+    display: inline-block;
+    position:relative;
+    z-index:1002;
+    padding-bottom: 6px;
+    color:#333333;
+    text-shadow:0 1px 1px rgba(255, 255, 255, 0.75);
+    background-color:#e9eeee;
+    border:1px solid #dddddd;
+    border-top-width:0;
+    -webkit-border-radius:7px;
+    -moz-border-radius:7px;
+    border-radius:7px;
+    border-top-left-radius:0;
+    border-top-right-radius:0;
+    -webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+    -moz-box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+    box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+}
+.lu-busy-default-text{
+    margin:13px 12px 6px 49px;
+    font-size:16px;
+    color:#555;
+    text-align: left;
+    max-width: 400px;
+}
+.lu-busy-default-spinner{
+    position:absolute;
+    width:25px;
+    height:25px;
+    display:inline-block;
+    top:12px;
+    left:14px;
+}
+.lu-busy-default-spinner div{
+    width:12%;
+    height:26%;
+    background:#000;
+    position:absolute;
+    left:44.5%;
+    top:37%;
+    opacity:0;
+    -webkit-animation:lu-busy-spinner-anim 1s linear infinite;
+    -moz-animation:lu-busy-spinner-anim 1s linear infinite;
+    -ms-animation:lu-busy-spinner-anim 1s linear infinite;
+    -o-animation:lu-busy-spinner-anim 1s linear infinite;
+    animation:lu-busy-spinner-anim 1s linear infinite;
+    -webkit-border-radius:50px;
+    -moz-border-radius:50px;
+    border-radius:50px;
+    -webkit-box-shadow:0 0 3px rgba(0,0,0,0.2);
+    -moz-box-shadow:0 0 3px rgba(0,0,0,0.2);
+    box-shadow:0 0 3px rgba(0,0,0,0.2);
+}
+.lu-busy-default-spinner div.bar1{
+    -webkit-transform:rotate(0deg) translate(0, -142%);
+    -moz-transform:rotate(0deg) translate(0, -142%);
+    -ms-transform:rotate(0deg) translate(0, -142%);
+    -o-transform:rotate(0deg) translate(0, -142%);
+    transform:rotate(0deg) translate(0, -142%);
+    -webkit-animation-delay:0s;
+    -moz-animation-delay:0s;
+    -ms-animation-delay:0s;
+    -o-animation-delay:0s;
+    animation-delay:0s;
+}
+.lu-busy-default-spinner div.bar2{
+    -webkit-transform:rotate(30deg) translate(0, -142%);
+    -moz-transform:rotate(30deg) translate(0, -142%);
+    -ms-transform:rotate(30deg) translate(0, -142%);
+    -o-transform:rotate(30deg) translate(0, -142%);
+    transform:rotate(30deg) translate(0, -142%);
+    -webkit-animation-delay:-0.9167s;
+    -moz-animation-delay:-0.9167s;
+    -ms-animation-delay:-0.9167s;
+    -o-animation-delay:-0.9167s;
+    animation-delay:-0.9167s;
+}
+.lu-busy-default-spinner div.bar3{
+    -webkit-transform:rotate(60deg) translate(0, -142%);
+    -moz-transform:rotate(60deg) translate(0, -142%);
+    -ms-transform:rotate(60deg) translate(0, -142%);
+    -o-transform:rotate(60deg) translate(0, -142%);
+    transform:rotate(60deg) translate(0, -142%);
+    -webkit-animation-delay:-0.833s;
+    -moz-animation-delay:-0.833s;
+    -ms-animation-delay:-0.833s;
+    -o-animation-delay:-0.833s;
+    animation-delay:-0.833s;
+}
+.lu-busy-default-spinner div.bar4{
+    -webkit-transform:rotate(90deg) translate(0, -142%);
+    -moz-transform:rotate(90deg) translate(0, -142%);
+    -ms-transform:rotate(90deg) translate(0, -142%);
+    -o-transform:rotate(90deg) translate(0, -142%);
+    transform:rotate(90deg) translate(0, -142%);
+    -webkit-animation-delay:-0.75s;
+    -moz-animation-delay:-0.75s;
+    -ms-animation-delay:-0.75s;
+    -o-animation-delay:-0.75s;
+    animation-delay:-0.75s;
+}
+.lu-busy-default-spinner div.bar5{
+    -webkit-transform:rotate(120deg) translate(0, -142%);
+    -moz-transform:rotate(120deg) translate(0, -142%);
+    -ms-transform:rotate(120deg) translate(0, -142%);
+    -o-transform:rotate(120deg) translate(0, -142%);
+    transform:rotate(120deg) translate(0, -142%);
+    -webkit-animation-delay:-0.667s;
+    -moz-animation-delay:-0.667s;
+    -ms-animation-delay:-0.667s;
+    -o-animation-delay:-0.667s;
+    animation-delay:-0.667s;
+}
+.lu-busy-default-spinner div.bar6{
+    -webkit-transform:rotate(150deg) translate(0, -142%);
+    -moz-transform:rotate(150deg) translate(0, -142%);
+    -ms-transform:rotate(150deg) translate(0, -142%);
+    -o-transform:rotate(150deg) translate(0, -142%);
+    transform:rotate(150deg) translate(0, -142%);
+    -webkit-animation-delay:-0.5833s;
+    -moz-animation-delay:-0.5833s;
+    -ms-animation-delay:-0.5833s;
+    -o-animation-delay:-0.5833s;
+    animation-delay:-0.5833s;
+}
+.lu-busy-default-spinner div.bar7{
+    -webkit-transform:rotate(180deg) translate(0, -142%);
+    -moz-transform:rotate(180deg) translate(0, -142%);
+    -ms-transform:rotate(180deg) translate(0, -142%);
+    -o-transform:rotate(180deg) translate(0, -142%);
+    transform:rotate(180deg) translate(0, -142%);
+    -webkit-animation-delay:-0.5s;
+    -moz-animation-delay:-0.5s;
+    -ms-animation-delay:-0.5s;
+    -o-animation-delay:-0.5s;
+    animation-delay:-0.5s;
+}
+.lu-busy-default-spinner div.bar8{
+    -webkit-transform:rotate(210deg) translate(0, -142%);
+    -moz-transform:rotate(210deg) translate(0, -142%);
+    -ms-transform:rotate(210deg) translate(0, -142%);
+    -o-transform:rotate(210deg) translate(0, -142%);
+    transform:rotate(210deg) translate(0, -142%);
+    -webkit-animation-delay:-0.41667s;
+    -moz-animation-delay:-0.41667s;
+    -ms-animation-delay:-0.41667s;
+    -o-animation-delay:-0.41667s;
+    animation-delay:-0.41667s;
+}
+.lu-busy-default-spinner div.bar9{
+    -webkit-transform:rotate(240deg) translate(0, -142%);
+    -moz-transform:rotate(240deg) translate(0, -142%);
+    -ms-transform:rotate(240deg) translate(0, -142%);
+    -o-transform:rotate(240deg) translate(0, -142%);
+    transform:rotate(240deg) translate(0, -142%);
+    -webkit-animation-delay:-0.333s;
+    -moz-animation-delay:-0.333s;
+    -ms-animation-delay:-0.333s;
+    -o-animation-delay:-0.333s;
+    animation-delay:-0.333s;
+}
+.lu-busy-default-spinner div.bar10{
+    -webkit-transform:rotate(270deg) translate(0, -142%);
+    -moz-transform:rotate(270deg) translate(0, -142%);
+    -ms-transform:rotate(270deg) translate(0, -142%);
+    -o-transform:rotate(270deg) translate(0, -142%);
+    transform:rotate(270deg) translate(0, -142%);
+    -webkit-animation-delay:-0.25s;
+    -moz-animation-delay:-0.25s;
+    -ms-animation-delay:-0.25s;
+    -o-animation-delay:-0.25s;
+    animation-delay:-0.25s;
+}
+.lu-busy-default-spinner div.bar11{
+    -webkit-transform:rotate(300deg) translate(0, -142%);
+    -moz-transform:rotate(300deg) translate(0, -142%);
+    -ms-transform:rotate(300deg) translate(0, -142%);
+    -o-transform:rotate(300deg) translate(0, -142%);
+    transform:rotate(300deg) translate(0, -142%);
+    -webkit-animation-delay:-0.1667s;
+    -moz-animation-delay:-0.1667s;
+    -ms-animation-delay:-0.1667s;
+    -o-animation-delay:-0.1667s;
+    animation-delay:-0.1667s;
+}
+.lu-busy-default-spinner div.bar12{
+    -webkit-transform:rotate(330deg) translate(0, -142%);
+    -moz-transform:rotate(330deg) translate(0, -142%);
+    -ms-transform:rotate(330deg) translate(0, -142%);
+    -o-transform:rotate(330deg) translate(0, -142%);
+    transform:rotate(330deg) translate(0, -142%);
+    -webkit-animation-delay:-0.0833s;
+    -moz-animation-delay:-0.0833s;
+    -ms-animation-delay:-0.0833s;
+    -o-animation-delay:-0.0833s;
+    animation-delay:-0.0833s;
+}
+
+@-webkit-keyframes lu-busy-spinner-anim{
+    from {opacity: 1;}
+    to {opacity: 0.25;}
+}
+@-moz-keyframes lu-busy-spinner-anim{
+    from {opacity: 1;}
+    to {opacity: 0.25;}
+}
+@keyframes lu-busy-spinner-anim{
+    from {opacity: 1;}
+    to {opacity: 0.25;}
+}

src/lubusy.js

@@ -0,0 +1,344 @@
+/**
+ * Created by robin on 10/24/15.
+ */
+
+
+angular.module('luticateUtils')
+    .directive('luBusy', ['$compile', 'luticatePromises', function($compile, luticatePromises){
+        return {
+            restrict: 'A',
+            scope: {},
+            link: function($scope, element, attrs) {
+
+                var position = element.css('position');
+                if (position === 'static' || position === '' || typeof position === 'undefined'){
+                    element.css('position','relative');
+                }
+                var group = attrs.luBusy;
+
+                $scope.isLoading = false;
+                $scope.hasError = false;
+
+                $scope.update = function()
+                {
+                    var loaders = luticatePromises.getLoadersGroup(group);
+                    $scope.isLoading = false;
+                    if (loaders != null) {
+                        $scope.isLoading = loaders.some(function (promise) {
+                            return promise.status == 0;
+                        });
+                    }
+                    var errors = luticatePromises.getLoadersGroup(group);
+                    $scope.hasError = false;
+                    if (loaders != null) {
+                        $scope.hasError = errors.some(function (promise) {
+                            return promise.status == 2;
+                        });
+                    }
+                };
+
+                $scope.loaderSplashIsActive = function() {
+                    $scope.update();
+                    return $scope.isLoading && !$scope.hasError;
+                };
+                $scope.errorSplashIsActive = function() {
+                    $scope.update();
+                    return $scope.hasError;
+                };
+
+                var backdrop = '<div class="lu-busy lu-busy-backdrop lu-busy-backdrop-animation ng-hide" ng-show="loaderSplashIsActive()"></div>';
+                var backdropElement = $compile(backdrop)($scope);
+                element.append(backdropElement);
+
+                var template = '<div class="lu-busy lu-busy-animation ng-hide" ng-show="loaderSplashIsActive()"><div class="lu-busy-default-wrapper">' +
+                    '<div class="lu-busy-default-sign">' +
+                    '<div class="lu-busy-default-text">Please wait...</div>' +
+                    '</div>' +
+                    '</div></div>';
+                var templateElement = $compile(template)($scope);
+
+                angular.element(templateElement.children()[0])
+                    .css('position','absolute')
+                    .css('top',0)
+                    .css('left',0)
+                    .css('right',0)
+                    .css('bottom',0);
+                element.append(templateElement);
+            }
+        };
+    }
+    ]);
+
+/*
+angular.module('luticateUtils').factory('_luBusyTrackerFactory',['$timeout','$q',function($timeout,$q){
+
+    return function(){
+
+        var tracker = {};
+        tracker.promises = [];
+        tracker.delayPromise = null;
+        tracker.durationPromise = null;
+        tracker.delayJustFinished = false;
+
+        tracker.reset = function(options){
+            tracker.minDuration = options.minDuration;
+
+            tracker.promises = [];
+            angular.forEach(options.promises,function(p){
+                if (!p || p.$luBusyFulfilled) {
+                    return;
+                }
+                addPromiseLikeThing(p);
+            });
+
+            if (tracker.promises.length === 0) {
+                //if we have no promises then dont do the delay or duration stuff
+                return;
+            }
+
+            tracker.delayJustFinished = false;
+            if (options.delay) {
+                tracker.delayPromise = $timeout(function(){
+                    tracker.delayPromise = null;
+                    tracker.delayJustFinished = true;
+                },parseInt(options.delay,10));
+            }
+            if (options.minDuration) {
+                tracker.durationPromise = $timeout(function(){
+                    tracker.durationPromise = null;
+                },parseInt(options.minDuration,10) + (options.delay ? parseInt(options.delay,10) : 0));
+            }
+        };
+
+        tracker.isPromise = function(promiseThing){
+            var then = promiseThing && (promiseThing.then || promiseThing.$then ||
+                (promiseThing.$promise && promiseThing.$promise.then));
+
+            return typeof then !== 'undefined';
+        };
+
+        tracker.callThen = function(promiseThing,success,error){
+            var promise;
+            if (promiseThing.then || promiseThing.$then){
+                promise = promiseThing;
+            } else if (promiseThing.$promise){
+                promise = promiseThing.$promise;
+            } else if (promiseThing.denodeify){
+                promise = $q.when(promiseThing);
+            }
+
+            var then = (promise.then || promise.$then);
+
+            then.call(promise,success,error);
+        };
+
+        var addPromiseLikeThing = function(promise){
+
+            if (!tracker.isPromise(promise)) {
+                throw new Error('luBusy expects a promise (or something that has a .promise or .$promise');
+            }
+
+            if (tracker.promises.indexOf(promise) !== -1){
+                return;
+            }
+            tracker.promises.push(promise);
+
+            tracker.callThen(promise, function(){
+                promise.$luBusyFulfilled = true;
+                if (tracker.promises.indexOf(promise) === -1) {
+                    return;
+                }
+                tracker.promises.splice(tracker.promises.indexOf(promise),1);
+            },function(){
+                promise.$luBusyFulfilled = true;
+                if (tracker.promises.indexOf(promise) === -1) {
+                    return;
+                }
+                tracker.promises.splice(tracker.promises.indexOf(promise),1);
+            });
+        };
+
+        tracker.active = function(){
+            if (tracker.delayPromise){
+                return false;
+            }
+
+            if (!tracker.delayJustFinished){
+                if (tracker.durationPromise){
+                    return true;
+                }
+                return tracker.promises.length > 0;
+            } else {
+                //if both delay and min duration are set,
+                //we don't want to initiate the min duration if the
+                //promise finished before the delay was complete
+                tracker.delayJustFinished = false;
+                if (tracker.promises.length === 0) {
+                    tracker.durationPromise = null;
+                }
+                return tracker.promises.length > 0;
+            }
+        };
+
+        return tracker;
+
+    };
+}]);
+
+angular.module('luticateUtils').value('luBusyDefaults',{});
+
+angular.module('luticateUtils').directive('luBusy',['$compile','$templateCache','luBusyDefaults','$http','_luBusyTrackerFactory',
+    function($compile,$templateCache,luBusyDefaults,$http,_luBusyTrackerFactory){
+        return {
+            restrict: 'A',
+            link: function(scope, element, attrs, fn) {
+
+                //Apply position:relative to parent element if necessary
+                var position = element.css('position');
+                if (position === 'static' || position === '' || typeof position === 'undefined'){
+                    element.css('position','relative');
+                }
+
+                var templateElement;
+                var backdropElement;
+                var currentTemplate;
+                var templateScope;
+                var backdrop;
+                var tracker = _luBusyTrackerFactory();
+
+                var defaults = {
+                    templateUrl: 'luticate-busy.html',
+                    delay:0,
+                    minDuration:0,
+                    backdrop: true,
+                    message:'Please Wait...',
+                    wrapperClass: 'lu-busy lu-busy-animation'
+                };
+
+                angular.extend(defaults,luBusyDefaults);
+
+                scope.$watchCollection(attrs.luBusy,function(options){
+
+                    if (!options) {
+                        options = {promise:null};
+                    }
+
+                    if (angular.isString(options)) {
+                        throw new Error('Invalid value for lu-busy. luBusy no longer accepts string ids to represent promises/trackers.');
+                    }
+
+                    //is it an array (of promises) or one promise
+                    if (angular.isArray(options) || tracker.isPromise(options)) {
+                        options = {promise:options};
+                    }
+
+                    options = angular.extend(angular.copy(defaults),options);
+
+                    if (!options.templateUrl){
+                        options.templateUrl = defaults.templateUrl;
+                    }
+
+                    if (!angular.isArray(options.promise)){
+                        options.promise = [options.promise];
+                    }
+
+                    // options.promise = angular.isArray(options.promise) ? options.promise : [options.promise];
+                    // options.message = options.message ? options.message : 'Please Wait...';
+                    // options.template = options.template ? options.template : luBusyTemplateName;
+                    // options.minDuration = options.minDuration ? options.minDuration : 0;
+                    // options.delay = options.delay ? options.delay : 0;
+
+                    if (!templateScope) {
+                        templateScope = scope.$new();
+                    }
+
+                    templateScope.$message = options.message;
+
+                    if (!angular.equals(tracker.promises,options.promise)) {
+                        tracker.reset({
+                            promises:options.promise,
+                            delay:options.delay,
+                            minDuration: options.minDuration
+                        });
+                    }
+
+                    templateScope.$luBusyIsActive = function() {
+                        return tracker.active();
+                    };
+
+
+                    if (!templateElement || currentTemplate !== options.templateUrl || backdrop !== options.backdrop) {
+
+                        if (templateElement) {
+                            templateElement.remove();
+                        }
+                        if (backdropElement){
+                            backdropElement.remove();
+                        }
+
+                        currentTemplate = options.templateUrl;
+                        backdrop = options.backdrop;
+
+                        $http.get(currentTemplate,{cache: $templateCache}).success(function(indicatorTemplate){
+
+                            options.backdrop = typeof options.backdrop === 'undefined' ? true : options.backdrop;
+
+                            if (options.backdrop){
+                                var backdrop = '<div class="lu-busy lu-busy-backdrop lu-busy-backdrop-animation ng-hide" ng-show="$luBusyIsActive()"></div>';
+                                backdropElement = $compile(backdrop)(templateScope);
+                                element.append(backdropElement);
+                            }
+
+                            var template = '<div class="'+options.wrapperClass+' ng-hide" ng-show="$luBusyIsActive()">' + indicatorTemplate + '</div>';
+                            templateElement = $compile(template)(templateScope);
+
+                            angular.element(templateElement.children()[0])
+                                .css('position','absolute')
+                                .css('top',0)
+                                .css('left',0)
+                                .css('right',0)
+                                .css('bottom',0);
+                            element.append(templateElement);
+
+                        }).error(function(data){
+                            throw new Error('Template specified for luBusy ('+options.templateUrl+') could not be loaded. ' + data);
+                        });
+                    }
+
+                },true);
+            }
+        };
+    }
+]);
+
+angular.module('luticateUtils').run(['$templateCache', function($templateCache) {
+    'use strict';
+
+    $templateCache.put('luticate-busy.html',
+        "<div class=\"lu-busy-default-wrapper\">\n" +
+        "\n" +
+        "   <div class=\"lu-busy-default-sign\">\n" +
+        "\n" +
+        "      <div class=\"lu-busy-default-spinner\">\n" +
+        "         <div class=\"bar1\"></div>\n" +
+        "         <div class=\"bar2\"></div>\n" +
+        "         <div class=\"bar3\"></div>\n" +
+        "         <div class=\"bar4\"></div>\n" +
+        "         <div class=\"bar5\"></div>\n" +
+        "         <div class=\"bar6\"></div>\n" +
+        "         <div class=\"bar7\"></div>\n" +
+        "         <div class=\"bar8\"></div>\n" +
+        "         <div class=\"bar9\"></div>\n" +
+        "         <div class=\"bar10\"></div>\n" +
+        "         <div class=\"bar11\"></div>\n" +
+        "         <div class=\"bar12\"></div>\n" +
+        "      </div>\n" +
+        "\n" +
+        "      <div class=\"lu-busy-default-text\">{{$message}}</div>\n" +
+        "\n" +
+        "   </div>\n" +
+        "\n" +
+        "</div>"
+    );
+
+}]);*/

src/luticateutils.js

@@ -0,0 +1,7 @@
+/**
+ * Created by robin on 10/25/15.
+ */
+
+(function() {
+    angular.module("luticateUtils", []);
+})();

src/promises.js

@@ -0,0 +1,89 @@
+/**
+ * Created by robin on 10/24/15.
+ */
+
+(function () {
+    'use strict';
+    angular.module('luticateUtils')
+        .factory('luticatePromises', [function() {
+
+            var luticatePromises = {};
+
+            luticatePromises.promises = {};
+
+            luticatePromises.loaders = [];
+
+            luticatePromises.errors = [];
+
+            luticatePromises.build = function(array)
+            {
+                luticatePromises[array] = {};
+                for (var id in luticatePromises.promises) {
+                    var promise = luticatePromises.promises[id];
+                    promise[array].forEach(function(group) {
+                        if (luticatePromises[array][group] == null) {
+                            luticatePromises[array][group] = [];
+                        }
+                        luticatePromises[array][group].push(promise);
+                    });
+                }
+            };
+
+            luticatePromises.initPromise = function(data) {
+                var p = {
+                    loaders : [],
+                    errors: [],
+                    status: 0,
+                    id: data.id
+                };
+                if (data.groups) {
+                    data.groups.forEach(function (group){
+                        p.loaders.push(group);
+                        p.errors.push(group);
+                    });
+                }
+                if (data.loaderGroups) {
+                    data.loaderGroups.forEach(function(group)
+                    {
+                        p.loaders.push(group);
+                    });
+                }
+                if (data.errorGroups) {
+                    data.errorGroups.forEach(function(group)
+                    {
+                        p.errors.push(group);
+                    });
+                }
+                luticatePromises.promises[data.id] = p;
+
+                luticatePromises.build("loaders");
+                luticatePromises.build("errors");
+            };
+
+            luticatePromises.getLoadersGroup = function(group) {
+                if (luticatePromises.loaders[group] == null) {
+                    return null;
+                }
+                return luticatePromises.loaders[group];
+            };
+
+            luticatePromises.getErrorsGroup = function(group) {
+                if (luticatePromises.errors[group] == null) {
+                    return null;
+                }
+                return luticatePromises.errors[group];
+            };
+
+            luticatePromises.reject = function(promise, error) {
+                luticatePromises.promises[promise.id].status = 2;
+                luticatePromises.promises[promise.id].value = error;
+            };
+
+            luticatePromises.resolve = function(promise, data) {
+                luticatePromises.promises[promise.id].status = 1;
+                luticatePromises.promises[promise.id].value = data;
+            };
+
+            return luticatePromises;
+        }]);
+})();

src/request.js

@@ -2,36 +2,58 @@
  * Created by robin on 10/24/15.
  */
 
-angular.module('luticate', []);
 (function () {
     'use strict';
-    angular.module('luticate')
-        .factory('luticateUtils', ['$q', '$http', function ($q, $http) {
+    angular.module('luticateUtils')
+        .factory('luticateRequest', ['$q', '$http', 'luticatePromises', function ($q, $http, luticatePromises) {
 
             var coPlanningServices = {};
 
-            coPlanningServices.get = function(url, dataGet)
+            coPlanningServices.get = function(url, dataGet, promise)
             {
-                return coPlanningServices.request(url, 'GET', dataGet, null);
+                return coPlanningServices.request(url, 'GET', dataGet, null, promise);
             };
 
-            coPlanningServices.post = function(url, dataPost, dataGet)
+            coPlanningServices.post = function(url, dataPost, dataGet, promise)
             {
-                return coPlanningServices.request(url, 'POST', dataGet, dataPost);
+                return coPlanningServices.request(url, 'POST', dataGet, dataPost, promise);
             };
 
-            coPlanningServices.put = function(url, dataPost, dataGet)
+            coPlanningServices.put = function(url, dataPost, dataGet, promise)
             {
-                return coPlanningServices.request(url, 'PUT', dataGet, dataPost);
+                return coPlanningServices.request(url, 'PUT', dataGet, dataPost, promise);
             };
 
-            coPlanningServices.delete = function(url, dataPost, dataGet)
+            coPlanningServices.delete = function(url, dataPost, dataGet, promise)
             {
-                return coPlanningServices.request(url, 'DELETE', dataGet, dataPost);
+                return coPlanningServices.request(url, 'DELETE', dataGet, dataPost, promise);
             };
 
-            coPlanningServices.request = function(url, method, dataGet, dataPost)
+            function reject(defered, data, status, promise)
             {
+                var obj = {
+                    data: data,
+                    status: status
+                };
+                defered.reject(obj);
+                if (promise != null) {
+                    luticatePromises.reject(promise, obj);
+                }
+            }
+
+            function resolve(defered, data, promise)
+            {
+                defered.resolve(data);
+                if (promise != null) {
+                    luticatePromises.resolve(promise, data);
+                }
+            }
+
+            coPlanningServices.request = function(url, method, dataGet, dataPost, promise)
+            {
+                if (promise != null) {
+                    luticatePromises.initPromise(promise);
+                }
                 var defered = $q.defer();
 
                 var params = {
@@ -44,27 +66,18 @@ angular.module('luticate', []);
                 $http(params)
                     .success(function (result, status) {
                         if (result.Message != null) {
-                            defered.reject({
-                                data: result.Message,
-                                status: status
-                            });
+                            reject(defered, result.Message, status, promise);
                         }
                         else {
-                            defered.resolve(result.Data);
+                            resolve(defered, result.Data, promise);
                         }
                     })
                     .error(function (result, status) {
                         if (result.Message != null) {
-                            defered.reject({
-                                data: result.Message,
-                                status: status
-                            });
+                            reject(defered, result.Message, status, promise);
                         }
                         else {
-                            defered.reject({
-                                data: result,
-                                status: status
-                            });
+                            reject(defered, result, status, promise);
                         }
                     });
                 return defered.promise;