configbackuprestore/vnfconfigbackupservice/src/main/webapp/node_modules/angular-growl-v2/build/angular-growl.js

   1 /**
   2  * angular-growl-v2 - v0.7.5 - 2015-06-17
   3  * http://janstevens.github.io/angular-growl-2
   4  * Copyright (c) 2015 Marco Rinck,Jan Stevens; Licensed MIT
   5  */
   6 angular.module('angular-growl', []);
   7 angular.module('angular-growl').directive('growl', [function () {
   8     'use strict';
   9     return {
  10       restrict: 'A',
  11       templateUrl: 'templates/growl/growl.html',
  12       replace: false,
  13       scope: {
  14         reference: '@',
  15         inline: '=',
  16         limitMessages: '='
  17       },
  18       controller: [
  19         '$scope',
  20         '$timeout',
  21         'growl',
  22         'growlMessages',
  23         function ($scope, $timeout, growl, growlMessages) {
  24           $scope.referenceId = $scope.reference || 0;
  25           growlMessages.initDirective($scope.referenceId, $scope.limitMessages);
  26           $scope.growlMessages = growlMessages;
  27           $scope.inlineMessage = angular.isDefined($scope.inline) ? $scope.inline : growl.inlineMessages();
  28           $scope.$watch('limitMessages', function (limitMessages) {
  29             var directive = growlMessages.directives[$scope.referenceId];
  30             if (!angular.isUndefined(limitMessages) && !angular.isUndefined(directive)) {
  31               directive.limitMessages = limitMessages;
  32             }
  33           });
  34           $scope.stopTimeoutClose = function (message) {
  35             if (!message.clickToClose) {
  36               angular.forEach(message.promises, function (promise) {
  37                 $timeout.cancel(promise);
  38               });
  39               if (message.close) {
  40                 growlMessages.deleteMessage(message);
  41               } else {
  42                 message.close = true;
  43               }
  44             }
  45           };
  46           $scope.alertClasses = function (message) {
  47             return {
  48               'alert-success': message.severity === 'success',
  49               'alert-error': message.severity === 'error',
  50               'alert-danger': message.severity === 'error',
  51               'alert-info': message.severity === 'info',
  52               'alert-warning': message.severity === 'warning',
  53               'icon': message.disableIcons === false,
  54               'alert-dismissable': !message.disableCloseButton
  55             };
  56           };
  57           $scope.showCountDown = function (message) {
  58             return !message.disableCountDown && message.ttl > 0;
  59           };
  60           $scope.wrapperClasses = function () {
  61             var classes = {};
  62             classes['growl-fixed'] = !$scope.inlineMessage;
  63             classes[growl.position()] = true;
  64             return classes;
  65           };
  66           $scope.computeTitle = function (message) {
  67             var ret = {
  68                 'success': 'Success',
  69                 'error': 'Error',
  70                 'info': 'Information',
  71                 'warn': 'Warning'
  72               };
  73             return ret[message.severity];
  74           };
  75         }
  76       ]
  77     };
  78   }]);
  79 angular.module('angular-growl').run([
  80   '$templateCache',
  81   function ($templateCache) {
  82     'use strict';
  83     if ($templateCache.get('templates/growl/growl.html') === undefined) {
  84       $templateCache.put('templates/growl/growl.html', '<div class="growl-container" ng-class="wrapperClasses()">' + '<div class="growl-item alert" ng-repeat="message in growlMessages.directives[referenceId].messages" ng-class="alertClasses(message)" ng-click="stopTimeoutClose(message)">' + '<button type="button" class="close" data-dismiss="alert" aria-hidden="true" ng-click="growlMessages.deleteMessage(message)" ng-show="!message.disableCloseButton">&times;</button>' + '<button type="button" class="close" aria-hidden="true" ng-show="showCountDown(message)">{{message.countdown}}</button>' + '<h4 class="growl-title" ng-show="message.title" ng-bind="message.title"></h4>' + '<div class="growl-message" ng-bind-html="message.text"></div>' + '</div>' + '</div>');
  85     }
  86   }
  87 ]);
  88 angular.module('angular-growl').provider('growl', function () {
  89   'use strict';
  90   var _ttl = {
  91       success: null,
  92       error: null,
  93       warning: null,
  94       info: null
  95     }, _messagesKey = 'messages', _messageTextKey = 'text', _messageTitleKey = 'title', _messageSeverityKey = 'severity', _onlyUniqueMessages = true, _messageVariableKey = 'variables', _referenceId = 0, _inline = false, _position = 'top-right', _disableCloseButton = false, _disableIcons = false, _reverseOrder = false, _disableCountDown = false, _translateMessages = true;
  96   this.globalTimeToLive = function (ttl) {
  97     if (typeof ttl === 'object') {
  98       for (var k in ttl) {
  99         if (ttl.hasOwnProperty(k)) {
 100           _ttl[k] = ttl[k];
 101         }
 102       }
 103     } else {
 104       for (var severity in _ttl) {
 105         if (_ttl.hasOwnProperty(severity)) {
 106           _ttl[severity] = ttl;
 107         }
 108       }
 109     }
 110     return this;
 111   };
 112   this.globalTranslateMessages = function (translateMessages) {
 113     _translateMessages = translateMessages;
 114     return this;
 115   };
 116   this.globalDisableCloseButton = function (disableCloseButton) {
 117     _disableCloseButton = disableCloseButton;
 118     return this;
 119   };
 120   this.globalDisableIcons = function (disableIcons) {
 121     _disableIcons = disableIcons;
 122     return this;
 123   };
 124   this.globalReversedOrder = function (reverseOrder) {
 125     _reverseOrder = reverseOrder;
 126     return this;
 127   };
 128   this.globalDisableCountDown = function (countDown) {
 129     _disableCountDown = countDown;
 130     return this;
 131   };
 132   this.messageVariableKey = function (messageVariableKey) {
 133     _messageVariableKey = messageVariableKey;
 134     return this;
 135   };
 136   this.globalInlineMessages = function (inline) {
 137     _inline = inline;
 138     return this;
 139   };
 140   this.globalPosition = function (position) {
 141     _position = position;
 142     return this;
 143   };
 144   this.messagesKey = function (messagesKey) {
 145     _messagesKey = messagesKey;
 146     return this;
 147   };
 148   this.messageTextKey = function (messageTextKey) {
 149     _messageTextKey = messageTextKey;
 150     return this;
 151   };
 152   this.messageTitleKey = function (messageTitleKey) {
 153     _messageTitleKey = messageTitleKey;
 154     return this;
 155   };
 156   this.messageSeverityKey = function (messageSeverityKey) {
 157     _messageSeverityKey = messageSeverityKey;
 158     return this;
 159   };
 160   this.onlyUniqueMessages = function (onlyUniqueMessages) {
 161     _onlyUniqueMessages = onlyUniqueMessages;
 162     return this;
 163   };
 164   this.serverMessagesInterceptor = [
 165     '$q',
 166     'growl',
 167     function ($q, growl) {
 168       function checkResponse(response) {
 169         if (response !== undefined && response.data && response.data[_messagesKey] && response.data[_messagesKey].length > 0) {
 170           growl.addServerMessages(response.data[_messagesKey]);
 171         }
 172       }
 173       return {
 174         'response': function (response) {
 175           checkResponse(response);
 176           return response;
 177         },
 178         'responseError': function (rejection) {
 179           checkResponse(rejection);
 180           return $q.reject(rejection);
 181         }
 182       };
 183     }
 184   ];
 185   this.$get = [
 186     '$rootScope',
 187     '$interpolate',
 188     '$sce',
 189     '$filter',
 190     '$timeout',
 191     'growlMessages',
 192     function ($rootScope, $interpolate, $sce, $filter, $timeout, growlMessages) {
 193       var translate;
 194       growlMessages.onlyUnique = _onlyUniqueMessages;
 195       growlMessages.reverseOrder = _reverseOrder;
 196       try {
 197         translate = $filter('translate');
 198       } catch (e) {
 199       }
 200       function broadcastMessage(message) {
 201         if (translate && message.translateMessage) {
 202           message.text = translate(message.text, message.variables) || message.text;
 203           message.title = translate(message.title) || message.title;
 204         } else {
 205           var polation = $interpolate(message.text);
 206           message.text = polation(message.variables);
 207         }
 208         var addedMessage = growlMessages.addMessage(message);
 209         $rootScope.$broadcast('growlMessage', message);
 210         $timeout(function () {
 211         }, 0);
 212         return addedMessage;
 213       }
 214       function sendMessage(text, config, severity) {
 215         var _config = config || {}, message;
 216         message = {
 217           text: text,
 218           title: _config.title,
 219           severity: severity,
 220           ttl: _config.ttl || _ttl[severity],
 221           variables: _config.variables || {},
 222           disableCloseButton: _config.disableCloseButton === undefined ? _disableCloseButton : _config.disableCloseButton,
 223           disableIcons: _config.disableIcons === undefined ? _disableIcons : _config.disableIcons,
 224           disableCountDown: _config.disableCountDown === undefined ? _disableCountDown : _config.disableCountDown,
 225           position: _config.position || _position,
 226           referenceId: _config.referenceId || _referenceId,
 227           translateMessage: _config.translateMessage === undefined ? _translateMessages : _config.translateMessage,
 228           destroy: function () {
 229             growlMessages.deleteMessage(message);
 230           },
 231           setText: function (newText) {
 232             message.text = $sce.trustAsHtml(String(newText));
 233           },
 234           onclose: _config.onclose,
 235           onopen: _config.onopen
 236         };
 237         return broadcastMessage(message);
 238       }
 239       function warning(text, config) {
 240         return sendMessage(text, config, 'warning');
 241       }
 242       function error(text, config) {
 243         return sendMessage(text, config, 'error');
 244       }
 245       function info(text, config) {
 246         return sendMessage(text, config, 'info');
 247       }
 248       function success(text, config) {
 249         return sendMessage(text, config, 'success');
 250       }
 251       function general(text, config, severity) {
 252         severity = (severity || 'error').toLowerCase();
 253         return sendMessage(text, config, severity);
 254       }
 255       function addServerMessages(messages) {
 256         if (!messages || !messages.length) {
 257           return;
 258         }
 259         var i, message, severity, length;
 260         length = messages.length;
 261         for (i = 0; i < length; i++) {
 262           message = messages[i];
 263           if (message[_messageTextKey]) {
 264             severity = (message[_messageSeverityKey] || 'error').toLowerCase();
 265             var config = {};
 266             config.variables = message[_messageVariableKey] || {};
 267             config.title = message[_messageTitleKey];
 268             sendMessage(message[_messageTextKey], config, severity);
 269           }
 270         }
 271       }
 272       function onlyUnique() {
 273         return _onlyUniqueMessages;
 274       }
 275       function reverseOrder() {
 276         return _reverseOrder;
 277       }
 278       function inlineMessages() {
 279         return _inline;
 280       }
 281       function position() {
 282         return _position;
 283       }
 284       return {
 285         warning: warning,
 286         error: error,
 287         info: info,
 288         success: success,
 289         general: general,
 290         addServerMessages: addServerMessages,
 291         onlyUnique: onlyUnique,
 292         reverseOrder: reverseOrder,
 293         inlineMessages: inlineMessages,
 294         position: position
 295       };
 296     }
 297   ];
 298 });
 299 angular.module('angular-growl').service('growlMessages', [
 300   '$sce',
 301   '$timeout',
 302   function ($sce, $timeout) {
 303     'use strict';
 304     var self = this;
 305     this.directives = {};
 306     var preloadDirectives = {};
 307     function preLoad(referenceId) {
 308       var directive;
 309       if (preloadDirectives[referenceId]) {
 310         directive = preloadDirectives[referenceId];
 311       } else {
 312         directive = preloadDirectives[referenceId] = { messages: [] };
 313       }
 314       return directive;
 315     }
 316     function directiveForRefId(referenceId) {
 317       var refId = referenceId || 0;
 318       return self.directives[refId] || preloadDirectives[refId];
 319     }
 320     this.initDirective = function (referenceId, limitMessages) {
 321       if (preloadDirectives[referenceId]) {
 322         this.directives[referenceId] = preloadDirectives[referenceId];
 323         this.directives[referenceId].limitMessages = limitMessages;
 324       } else {
 325         this.directives[referenceId] = {
 326           messages: [],
 327           limitMessages: limitMessages
 328         };
 329       }
 330       return this.directives[referenceId];
 331     };
 332     this.getAllMessages = function (referenceId) {
 333       referenceId = referenceId || 0;
 334       var messages;
 335       if (directiveForRefId(referenceId)) {
 336         messages = directiveForRefId(referenceId).messages;
 337       } else {
 338         messages = [];
 339       }
 340       return messages;
 341     };
 342     this.destroyAllMessages = function (referenceId) {
 343       var messages = this.getAllMessages(referenceId);
 344       for (var i = messages.length - 1; i >= 0; i--) {
 345         messages[i].destroy();
 346       }
 347       var directive = directiveForRefId(referenceId);
 348       if (directive) {
 349         directive.messages = [];
 350       }
 351     };
 352     this.addMessage = function (message) {
 353       var directive, messages, found, msgText;
 354       if (this.directives[message.referenceId]) {
 355         directive = this.directives[message.referenceId];
 356       } else {
 357         directive = preLoad(message.referenceId);
 358       }
 359       messages = directive.messages;
 360       if (this.onlyUnique) {
 361         angular.forEach(messages, function (msg) {
 362           msgText = $sce.getTrustedHtml(msg.text);
 363           if (message.text === msgText && message.severity === msg.severity && message.title === msg.title) {
 364             found = true;
 365           }
 366         });
 367         if (found) {
 368           return;
 369         }
 370       }
 371       message.text = $sce.trustAsHtml(String(message.text));
 372       if (message.ttl && message.ttl !== -1) {
 373         message.countdown = message.ttl / 1000;
 374         message.promises = [];
 375         message.close = false;
 376         message.countdownFunction = function () {
 377           if (message.countdown > 1) {
 378             message.countdown--;
 379             message.promises.push($timeout(message.countdownFunction, 1000));
 380           } else {
 381             message.countdown--;
 382           }
 383         };
 384       }
 385       if (angular.isDefined(directive.limitMessages)) {
 386         var diff = messages.length - (directive.limitMessages - 1);
 387         if (diff > 0) {
 388           messages.splice(directive.limitMessages - 1, diff);
 389         }
 390       }
 391       if (this.reverseOrder) {
 392         messages.unshift(message);
 393       } else {
 394         messages.push(message);
 395       }
 396       if (typeof message.onopen === 'function') {
 397         message.onopen();
 398       }
 399       if (message.ttl && message.ttl !== -1) {
 400         var self = this;
 401         message.promises.push($timeout(angular.bind(this, function () {
 402           self.deleteMessage(message);
 403         }), message.ttl));
 404         message.promises.push($timeout(message.countdownFunction, 1000));
 405       }
 406       return message;
 407     };
 408     this.deleteMessage = function (message) {
 409       var messages = this.getAllMessages(message.referenceId), index = messages.indexOf(message);
 410       if (index > -1) {
 411         messages[index].close = true;
 412         messages.splice(index, 1);
 413       }
 414       if (typeof message.onclose === 'function') {
 415         message.onclose();
 416       }
 417     };
 418   }
 419 ]);