<!DOCTYPE html>
<html ng-app="BasicHttpAuthExample">
<head>
<meta charset="utf-8" />
<title>AngularJS Basic HTTP Authentication Example</title>
<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" />
</head>
<body>
<div class="jumbotron">
<div class="container">
<nav class="row">
<ul class="nav nav-pills nav-justified">
<li><a href="#/details">User Details </a>
</li>
<li ng-if="!globals.currentUser"><a href="#/login">Login</a>
</li>
<li ng-if="globals.currentUser"><a href="#/logout">Logout</a>
</li>
</ul>
</nav>
<div class="col-xs-offset-2 col-xs-8">
<div ng-view></div>
</div>
</div>
</div>
<script src="//code.jquery.com/jquery-2.0.3.min.js"></script>
<script src="//code.angularjs.org/1.2.20/angular.js"></script>
<script src="//code.angularjs.org/1.2.20/angular-route.js"></script>
<script src="//code.angularjs.org/1.2.13/angular-cookies.js"></script>
<script src="bower_components/angular-translate/angular-translate.js"></script>
<script src="bower_components/angular-translate-storage-cookie/angular-translate-storage-cookie.js"></script>
<script src="bower_components/angular-translate-loader-static-files/angular-translate-loader-static-files.js"></script>
<script src="bower_components/angular-dynamic-locale/src/tmhDynamicLocale.js"></script> <script src="scripts/app.js"></script>
<script src="modules/authentication/services.js"></script>
<script src="modules/authentication/controllers.js"></script>
<script src="modules/home/controllers.js"></script>
<script src="modules/authentication/detailsController.js"></script>
</body>
</html>
'use strict';
// declare modules
angular.module('Authentication', []);
angular.module('Home', []);
angular.module('BasicHttpAuthExample', [
'Authentication',
'Home',
'ngRoute','pascalprecht.translate',
'ngCookies'
])
.config(['$routeProvider', function ($routeProvider,$translateProvider,tmhDynamicLocaleProvider) {
$routeProvider
.when('/login', {
controller: 'LoginController',
templateUrl: 'modules/authentication/views/login.html',
hideMenus: true
}).when('/details',{
controller : 'DetailsController',
templateUrl : 'modules/views/details.html'
}).when('/', {
controller: 'HomeController',
templateUrl: 'modules/home/views/home.html'
})
.otherwise({ redirectTo: '/login' });
// Initialize angular-translate
$translateProvider.useStaticFilesLoader({
prefix: 'i18n/',
suffix: '.json'
});
$translateProvider.preferredLanguage('en');
$translateProvider.useCookieStorage();
tmhDynamicLocaleProvider.localeLocationPattern('bower_components/angular-i18n/angular-locale_{{locale}}.js')
tmhDynamicLocaleProvider.useCookieStorage('NG_TRANSLATE_LANG_KEY');
}])
.run(['$rootScope', '$location', '$cookieStore', '$http',
function ($rootScope, $location, $cookieStore, $http) {
// keep user logged in after page refresh
$rootScope.globals = $cookieStore.get('globals') || {};
if ($rootScope.globals.currentUser) {
$http.defaults.headers.common['Authorization'] = 'Basic ' + $rootScope.globals.currentUser.authdata; // jshint ignore:line
}
$rootScope.$on('$locationChangeStart', function (event, next, current) {
// redirect to login page if not logged in
if ($location.path() !== '/login' && !$rootScope.globals.currentUser) {
$location.path('/login');
}
});
}]);
'use strict';
angular.module('Authentication')
.factory('AuthenticationService',
['Base64', '$http', '$cookieStore', '$rootScope', '$timeout',
function (Base64, $http, $cookieStore, $rootScope, $timeout) {
var service = {};
service.Login = function (username, password, callback) {
/* Dummy authentication for testing, uses $timeout to simulate api call
----------------------------------------------*/
$timeout(function(){
var response = { success: username === 'test' && password === 'test' };
if(!response.success) {
response.message = 'Username or password is incorrect';
}
callback(response);
}, 1000);
/* Use this for real authentication
----------------------------------------------*/
//$http.post('/api/authenticate', { username: username, password: password })
// .success(function (response) {
// callback(response);
// });
};
service.SetCredentials = function (username, password) {
var authdata = Base64.encode(username + ':' + password);
$rootScope.globals = {
currentUser: {
username: username,
authdata: authdata
}
};
$http.defaults.headers.common['Authorization'] = 'Basic ' + authdata; // jshint ignore:line
$cookieStore.put('globals', $rootScope.globals);
};
service.ClearCredentials = function () {
$rootScope.globals = {};
$cookieStore.remove('globals');
$http.defaults.headers.common.Authorization = 'Basic ';
};
return service;
}])
.factory('Base64', function () {
/* jshint ignore:start */
var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
return {
encode: function (input) {
var output = "";
var chr1, chr2, chr3 = "";
var enc1, enc2, enc3, enc4 = "";
var i = 0;
do {
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
} else if (isNaN(chr3)) {
enc4 = 64;
}
output = output +
keyStr.charAt(enc1) +
keyStr.charAt(enc2) +
keyStr.charAt(enc3) +
keyStr.charAt(enc4);
chr1 = chr2 = chr3 = "";
enc1 = enc2 = enc3 = enc4 = "";
} while (i < input.length);
return output;
},
decode: function (input) {
var output = "";
var chr1, chr2, chr3 = "";
var enc1, enc2, enc3, enc4 = "";
var i = 0;
// remove all characters that are not A-Z, a-z, 0-9, +, /, or =
var base64test = /[^A-Za-z0-9\+\/\=]/g;
if (base64test.exec(input)) {
window.alert("There were invalid base64 characters in the input text.\n" +
"Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='\n" +
"Expect errors in decoding.");
}
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
do {
enc1 = keyStr.indexOf(input.charAt(i++));
enc2 = keyStr.indexOf(input.charAt(i++));
enc3 = keyStr.indexOf(input.charAt(i++));
enc4 = keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 != 64) {
output = output + String.fromCharCode(chr2);
}
if (enc4 != 64) {
output = output + String.fromCharCode(chr3);
}
chr1 = chr2 = chr3 = "";
enc1 = enc2 = enc3 = enc4 = "";
} while (i < input.length);
return output;
}
};
/* jshint ignore:end */
});
'use strict';
angular.module('Authentication')
.controller('LoginController',
['$scope', '$rootScope', '$location', 'AuthenticationService',
function ($scope, $rootScope, $location, AuthenticationService) {
// reset login status
AuthenticationService.ClearCredentials();
$scope.login = function () {
$scope.dataLoading = true;
AuthenticationService.Login($scope.username, $scope.password, function(response) {
if(response.success) {
AuthenticationService.SetCredentials($scope.username, $scope.password);
$location.path('/');
} else {
$scope.error = response.message;
$scope.dataLoading = false;
}
});
};
}]);
<div class="alert alert-info">
Username: test<br />
Password: test
</div>
<div ng-show="error" class="alert alert-danger">{{error}}</div>
<form name="form" ng-submit="login()" role="form">
<div class="form-group">
<label for="username">Username</label>
<i class="fa fa-key"></i>
<input type="text" name="username" id="username" class="form-control" ng-model="username" required />
<span ng-show="form.username.$dirty && form.username.$error.required" class="help-block">Username is required</span>
</div>
<div class="form-group">
<label for="password">Password</label>
<i class="fa fa-lock"></i>
<input type="password" name="password" id="password" class="form-control" ng-model="password" required />
<span ng-show="form.password.$dirty && form.password.$error.required" class="help-block">Password is required</span>
</div>
<div class="form-actions">
<button type="submit" ng-disabled="form.$invalid || dataLoading" class="btn btn-danger">Login</button>
<img ng-if="dataLoading" src="data:image/gif;base64,R0lGODlhEAAQAPIAAP///wAAAMLCwkJCQgAAAGJiYoKCgpKSkiH/C05FVFNDQVBFMi4wAwEAAAAh/hpDcmVhdGVkIHdpdGggYWpheGxvYWQuaW5mbwAh+QQJCgAAACwAAAAAEAAQAAADMwi63P4wyklrE2MIOggZnAdOmGYJRbExwroUmcG2LmDEwnHQLVsYOd2mBzkYDAdKa+dIAAAh+QQJCgAAACwAAAAAEAAQAAADNAi63P5OjCEgG4QMu7DmikRxQlFUYDEZIGBMRVsaqHwctXXf7WEYB4Ag1xjihkMZsiUkKhIAIfkECQoAAAAsAAAAABAAEAAAAzYIujIjK8pByJDMlFYvBoVjHA70GU7xSUJhmKtwHPAKzLO9HMaoKwJZ7Rf8AYPDDzKpZBqfvwQAIfkECQoAAAAsAAAAABAAEAAAAzMIumIlK8oyhpHsnFZfhYumCYUhDAQxRIdhHBGqRoKw0R8DYlJd8z0fMDgsGo/IpHI5TAAAIfkECQoAAAAsAAAAABAAEAAAAzIIunInK0rnZBTwGPNMgQwmdsNgXGJUlIWEuR5oWUIpz8pAEAMe6TwfwyYsGo/IpFKSAAAh+QQJCgAAACwAAAAAEAAQAAADMwi6IMKQORfjdOe82p4wGccc4CEuQradylesojEMBgsUc2G7sDX3lQGBMLAJibufbSlKAAAh+QQJCgAAACwAAAAAEAAQAAADMgi63P7wCRHZnFVdmgHu2nFwlWCI3WGc3TSWhUFGxTAUkGCbtgENBMJAEJsxgMLWzpEAACH5BAkKAAAALAAAAAAQABAAAAMyCLrc/jDKSatlQtScKdceCAjDII7HcQ4EMTCpyrCuUBjCYRgHVtqlAiB1YhiCnlsRkAAAOwAAAAAAAAAAAA=="/>
</div>
</form>
<h1>Home</h1>
<p>You're logged in!!</p>
<p><a href="#/login">Logout</a></a></p>
'use strict';
angular.module('Home')
.controller('HomeController',
['$scope',
function ($scope) {
}]);
'use strict';
angular.module('Authentication')
.controller('DetailsController',['$scope', function($scope){
$scope.person=[
{name:"Vijayender", position:"Brother"},
{name:"Janardhan Rao", position:"Father"},
{name:"Manohara Devi", position:"Mother"},
{name:"Mahesh", position:"Brother"}
];
}])
<div class="container">
<div class="panel panel-primary">
<div class="panel-heading">Family Members</div>
<div class="panel-body">
<table class="table table-striped">
<thead>
<tr>
<th>Family Members</th>
<th>Position</th>
<th><a href><i class="glyphicon glyphicon-plus-sign"></i></a>
</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="names in person">
<td>{{names.name}}</td>
<td>{{names.position}}</td>
<td><a href><i class="glyphicon glyphicon-edit"></i></a>
</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
( function(window) {
'use strict';
angular.module('tmh.dynamicLocale', []).config(['$provide', function ($provide) {
function makeStateful($delegate) {
$delegate.$stateful = true;
return $delegate;
}
$provide.decorator('dateFilter', ['$delegate', makeStateful]);
$provide.decorator('numberFilter', ['$delegate', makeStateful]);
$provide.decorator('currencyFilter', ['$delegate', makeStateful]);
}]).provider('tmhDynamicLocale', function() {
var defaultLocale,
localeLocationPattern = 'angular/i18n/angular-locale_{{locale}}.js',
storageFactory = 'tmhDynamicLocaleStorageCache',
storage,
storeKey = 'tmhDynamicLocale.locale',
promiseCache = {},
activeLocale;
/**
* Loads a script asynchronously
*
* @param {string} url The url for the script
@ @param {function) callback A function to be called once the script is loaded
*/
function loadScript(url, callback, errorCallback, $timeout) {
var script = document.createElement('script'),
body = document.getElementsByTagName('body')[0],
removed = false;
script.type = 'text/javascript';
if (script.readyState) { // IE
script.onreadystatechange = function () {
if (script.readyState === 'complete' ||
script.readyState === 'loaded') {
script.onreadystatechange = null;
$timeout(
function () {
if (removed) return;
removed = true;
body.removeChild(script);
callback();
}, 30, false);
}
};
} else { // Others
script.onload = function () {
if (removed) return;
removed = true;
body.removeChild(script);
callback();
};
script.onerror = function () {
if (removed) return;
removed = true;
body.removeChild(script);
errorCallback();
};
}
script.src = url;
script.async = false;
body.appendChild(script);
}
/**
* Loads a locale and replaces the properties from the current locale with the new locale information
*
* @param localeUrl The path to the new locale
* @param $locale The locale at the curent scope
*/
function loadLocale(localeUrl, $locale, localeId, $rootScope, $q, localeCache, $timeout) {
function overrideValues(oldObject, newObject) {
if (activeLocale !== localeId) {
return;
}
angular.forEach(oldObject, function(value, key) {
if (!newObject[key]) {
delete oldObject[key];
} else if (angular.isArray(newObject[key])) {
oldObject[key].length = newObject[key].length;
}
});
angular.forEach(newObject, function(value, key) {
if (angular.isArray(newObject[key]) || angular.isObject(newObject[key])) {
if (!oldObject[key]) {
oldObject[key] = angular.isArray(newObject[key]) ? [] : {};
}
overrideValues(oldObject[key], newObject[key]);
} else {
oldObject[key] = newObject[key];
}
});
}
if (promiseCache[localeId]) return promiseCache[localeId];
var cachedLocale,
deferred = $q.defer();
if (localeId === activeLocale) {
deferred.resolve($locale);
} else if ((cachedLocale = localeCache.get(localeId))) {
activeLocale = localeId;
$rootScope.$evalAsync(function() {
overrideValues($locale, cachedLocale);
$rootScope.$broadcast('$localeChangeSuccess', localeId, $locale);
storage.put(storeKey, localeId);
deferred.resolve($locale);
});
} else {
activeLocale = localeId;
promiseCache[localeId] = deferred.promise;
loadScript(localeUrl, function () {
// Create a new injector with the new locale
var localInjector = angular.injector(['ngLocale']),
externalLocale = localInjector.get('$locale');
overrideValues($locale, externalLocale);
localeCache.put(localeId, externalLocale);
delete promiseCache[localeId];
$rootScope.$apply(function () {
$rootScope.$broadcast('$localeChangeSuccess', localeId, $locale);
storage.put(storeKey, localeId);
deferred.resolve($locale);
});
}, function () {
delete promiseCache[localeId];
$rootScope.$apply(function () {
if (activeLocale === localeId) activeLocale = $locale.id;
$rootScope.$broadcast('$localeChangeError', localeId);
deferred.reject(localeId);
});
}, $timeout);
}
return deferred.promise;
}
this.localeLocationPattern = function(value) {
if (value) {
localeLocationPattern = value;
return this;
} else {
return localeLocationPattern;
}
};
this.useStorage = function(storageName) {
storageFactory = storageName;
};
this.useCookieStorage = function() {
this.useStorage('$cookieStore');
};
this.defaultLocale = function (value) {
defaultLocale = value;
};
this.$get = ['$rootScope', '$injector', '$interpolate', '$locale', '$q', 'tmhDynamicLocaleCache', '$timeout', function($rootScope, $injector, interpolate, locale, $q, tmhDynamicLocaleCache, $timeout) {
var localeLocation = interpolate(localeLocationPattern);
storage = $injector.get(storageFactory);
$rootScope.$evalAsync(function () {
var initialLocale;
if ((initialLocale = (storage.get(storeKey) || defaultLocale))) {
loadLocale(localeLocation({locale: initialLocale}), locale, initialLocale, $rootScope, $q, tmhDynamicLocaleCache, $timeout);
}
});
return {
/**
* @ngdoc method
* @description
* @param {string=} value Sets the locale to the new locale. Changing the locale will trigger
* a background task that will retrieve the new locale and configure the current $locale
* instance with the information from the new locale
*/
set: function(value) {
return loadLocale(localeLocation({locale: value}), locale, value, $rootScope, $q, tmhDynamicLocaleCache, $timeout);
},
/**
* @ngdoc method
* @description Returns the configured locale
*/
get: function() {
return activeLocale;
}
};
}];
}).provider('tmhDynamicLocaleCache', function() {
this.$get = ['$cacheFactory', function($cacheFactory) {
return $cacheFactory('tmh.dynamicLocales');
}];
}).provider('tmhDynamicLocaleStorageCache', function() {
this.$get = ['$cacheFactory', function($cacheFactory) {
return $cacheFactory('tmh.dynamicLocales.store');
}];
}).run(['tmhDynamicLocale', angular.noop]);
}(window) );
/*!
* angular-translate - v2.4.2 - 2014-10-21
* http://github.com/angular-translate/angular-translate
* Copyright (c) 2014 ; Licensed MIT
*/
angular.module('pascalprecht.translate', ['ng']).run([
'$translate',
function ($translate) {
var key = $translate.storageKey(), storage = $translate.storage();
if (storage) {
if (!storage.get(key)) {
if (angular.isString($translate.preferredLanguage())) {
$translate.use($translate.preferredLanguage());
} else {
storage.set(key, $translate.use());
}
} else {
$translate.use(storage.get(key));
}
} else if (angular.isString($translate.preferredLanguage())) {
$translate.use($translate.preferredLanguage());
}
}
]);
angular.module('pascalprecht.translate').provider('$translate', [
'$STORAGE_KEY',
function ($STORAGE_KEY) {
var $translationTable = {}, $preferredLanguage, $availableLanguageKeys = [], $languageKeyAliases, $fallbackLanguage, $fallbackWasString, $uses, $nextLang, $storageFactory, $storageKey = $STORAGE_KEY, $storagePrefix, $missingTranslationHandlerFactory, $interpolationFactory, $interpolatorFactories = [], $interpolationSanitizationStrategy = false, $loaderFactory, $cloakClassName = 'translate-cloak', $loaderOptions, $notFoundIndicatorLeft, $notFoundIndicatorRight, $postCompilingEnabled = false, NESTED_OBJECT_DELIMITER = '.', loaderCache;
var version = '2.4.2';
var getLocale = function () {
var nav = window.navigator;
return ((angular.isArray(nav.languages) ? nav.languages[0] : nav.language || nav.browserLanguage || nav.systemLanguage || nav.userLanguage) || '').split('-').join('_');
};
var indexOf = function (array, searchElement) {
for (var i = 0, len = array.length; i < len; i++) {
if (array[i] === searchElement) {
return i;
}
}
return -1;
};
var trim = function () {
return this.replace(/^\s+|\s+$/g, '');
};
var negotiateLocale = function (preferred) {
var avail = [], locale = angular.lowercase(preferred), i = 0, n = $availableLanguageKeys.length;
for (; i < n; i++) {
avail.push(angular.lowercase($availableLanguageKeys[i]));
}
if (indexOf(avail, locale) > -1) {
return preferred;
}
if ($languageKeyAliases) {
var alias;
for (var langKeyAlias in $languageKeyAliases) {
var hasWildcardKey = false;
var hasExactKey = Object.prototype.hasOwnProperty.call($languageKeyAliases, langKeyAlias) && angular.lowercase(langKeyAlias) === angular.lowercase(preferred);
if (langKeyAlias.slice(-1) === '*') {
hasWildcardKey = langKeyAlias.slice(0, -1) === preferred.slice(0, langKeyAlias.length - 1);
}
if (hasExactKey || hasWildcardKey) {
alias = $languageKeyAliases[langKeyAlias];
if (indexOf(avail, angular.lowercase(alias)) > -1) {
return alias;
}
}
}
}
var parts = preferred.split('_');
if (parts.length > 1 && indexOf(avail, angular.lowercase(parts[0])) > -1) {
return parts[0];
}
return preferred;
};
var translations = function (langKey, translationTable) {
if (!langKey && !translationTable) {
return $translationTable;
}
if (langKey && !translationTable) {
if (angular.isString(langKey)) {
return $translationTable[langKey];
}
} else {
if (!angular.isObject($translationTable[langKey])) {
$translationTable[langKey] = {};
}
angular.extend($translationTable[langKey], flatObject(translationTable));
}
return this;
};
this.translations = translations;
this.cloakClassName = function (name) {
if (!name) {
return $cloakClassName;
}
$cloakClassName = name;
return this;
};
var flatObject = function (data, path, result, prevKey) {
var key, keyWithPath, keyWithShortPath, val;
if (!path) {
path = [];
}
if (!result) {
result = {};
}
for (key in data) {
if (!Object.prototype.hasOwnProperty.call(data, key)) {
continue;
}
val = data[key];
if (angular.isObject(val)) {
flatObject(val, path.concat(key), result, key);
} else {
keyWithPath = path.length ? '' + path.join(NESTED_OBJECT_DELIMITER) + NESTED_OBJECT_DELIMITER + key : key;
if (path.length && key === prevKey) {
keyWithShortPath = '' + path.join(NESTED_OBJECT_DELIMITER);
result[keyWithShortPath] = '@:' + keyWithPath;
}
result[keyWithPath] = val;
}
}
return result;
};
this.addInterpolation = function (factory) {
$interpolatorFactories.push(factory);
return this;
};
this.useMessageFormatInterpolation = function () {
return this.useInterpolation('$translateMessageFormatInterpolation');
};
this.useInterpolation = function (factory) {
$interpolationFactory = factory;
return this;
};
this.useSanitizeValueStrategy = function (value) {
$interpolationSanitizationStrategy = value;
return this;
};
this.preferredLanguage = function (langKey) {
setupPreferredLanguage(langKey);
return this;
};
var setupPreferredLanguage = function (langKey) {
if (langKey) {
$preferredLanguage = langKey;
}
return $preferredLanguage;
};
this.translationNotFoundIndicator = function (indicator) {
this.translationNotFoundIndicatorLeft(indicator);
this.translationNotFoundIndicatorRight(indicator);
return this;
};
this.translationNotFoundIndicatorLeft = function (indicator) {
if (!indicator) {
return $notFoundIndicatorLeft;
}
$notFoundIndicatorLeft = indicator;
return this;
};
this.translationNotFoundIndicatorRight = function (indicator) {
if (!indicator) {
return $notFoundIndicatorRight;
}
$notFoundIndicatorRight = indicator;
return this;
};
this.fallbackLanguage = function (langKey) {
fallbackStack(langKey);
return this;
};
var fallbackStack = function (langKey) {
if (langKey) {
if (angular.isString(langKey)) {
$fallbackWasString = true;
$fallbackLanguage = [langKey];
} else if (angular.isArray(langKey)) {
$fallbackWasString = false;
$fallbackLanguage = langKey;
}
if (angular.isString($preferredLanguage) && indexOf($fallbackLanguage, $preferredLanguage) < 0) {
$fallbackLanguage.push($preferredLanguage);
}
return this;
} else {
if ($fallbackWasString) {
return $fallbackLanguage[0];
} else {
return $fallbackLanguage;
}
}
};
this.use = function (langKey) {
if (langKey) {
if (!$translationTable[langKey] && !$loaderFactory) {
throw new Error('$translateProvider couldn\'t find translationTable for langKey: \'' + langKey + '\'');
}
$uses = langKey;
return this;
}
return $uses;
};
var storageKey = function (key) {
if (!key) {
if ($storagePrefix) {
return $storagePrefix + $storageKey;
}
return $storageKey;
}
$storageKey = key;
};
this.storageKey = storageKey;
this.useUrlLoader = function (url, options) {
return this.useLoader('$translateUrlLoader', angular.extend({ url: url }, options));
};
this.useStaticFilesLoader = function (options) {
return this.useLoader('$translateStaticFilesLoader', options);
};
this.useLoader = function (loaderFactory, options) {
$loaderFactory = loaderFactory;
$loaderOptions = options || {};
return this;
};
this.useLocalStorage = function () {
return this.useStorage('$translateLocalStorage');
};
this.useCookieStorage = function () {
return this.useStorage('$translateCookieStorage');
};
this.useStorage = function (storageFactory) {
$storageFactory = storageFactory;
return this;
};
this.storagePrefix = function (prefix) {
if (!prefix) {
return prefix;
}
$storagePrefix = prefix;
return this;
};
this.useMissingTranslationHandlerLog = function () {
return this.useMissingTranslationHandler('$translateMissingTranslationHandlerLog');
};
this.useMissingTranslationHandler = function (factory) {
$missingTranslationHandlerFactory = factory;
return this;
};
this.usePostCompiling = function (value) {
$postCompilingEnabled = !!value;
return this;
};
this.determinePreferredLanguage = function (fn) {
var locale = fn && angular.isFunction(fn) ? fn() : getLocale();
if (!$availableLanguageKeys.length) {
$preferredLanguage = locale;
} else {
$preferredLanguage = negotiateLocale(locale);
}
return this;
};
this.registerAvailableLanguageKeys = function (languageKeys, aliases) {
if (languageKeys) {
$availableLanguageKeys = languageKeys;
if (aliases) {
$languageKeyAliases = aliases;
}
return this;
}
return $availableLanguageKeys;
};
this.useLoaderCache = function (cache) {
if (cache === false) {
loaderCache = undefined;
} else if (cache === true) {
loaderCache = true;
} else if (typeof cache === 'undefined') {
loaderCache = '$translationCache';
} else if (cache) {
loaderCache = cache;
}
return this;
};
this.$get = [
'$log',
'$injector',
'$rootScope',
'$q',
function ($log, $injector, $rootScope, $q) {
var Storage, defaultInterpolator = $injector.get($interpolationFactory || '$translateDefaultInterpolation'), pendingLoader = false, interpolatorHashMap = {}, langPromises = {}, fallbackIndex, startFallbackIteration;
var $translate = function (translationId, interpolateParams, interpolationId) {
if (angular.isArray(translationId)) {
var translateAll = function (translationIds) {
var results = {};
var promises = [];
var translate = function (translationId) {
var deferred = $q.defer();
var regardless = function (value) {
results[translationId] = value;
deferred.resolve([
translationId,
value
]);
};
$translate(translationId, interpolateParams, interpolationId).then(regardless, regardless);
return deferred.promise;
};
for (var i = 0, c = translationIds.length; i < c; i++) {
promises.push(translate(translationIds[i]));
}
return $q.all(promises).then(function () {
return results;
});
};
return translateAll(translationId);
}
var deferred = $q.defer();
if (translationId) {
translationId = trim.apply(translationId);
}
var promiseToWaitFor = function () {
var promise = $preferredLanguage ? langPromises[$preferredLanguage] : langPromises[$uses];
fallbackIndex = 0;
if ($storageFactory && !promise) {
var langKey = Storage.get($storageKey);
promise = langPromises[langKey];
if ($fallbackLanguage && $fallbackLanguage.length) {
var index = indexOf($fallbackLanguage, langKey);
fallbackIndex = index === 0 ? 1 : 0;
if (indexOf($fallbackLanguage, $preferredLanguage) < 0) {
$fallbackLanguage.push($preferredLanguage);
}
}
}
return promise;
}();
if (!promiseToWaitFor) {
determineTranslation(translationId, interpolateParams, interpolationId).then(deferred.resolve, deferred.reject);
} else {
promiseToWaitFor.then(function () {
determineTranslation(translationId, interpolateParams, interpolationId).then(deferred.resolve, deferred.reject);
}, deferred.reject);
}
return deferred.promise;
};
var applyNotFoundIndicators = function (translationId) {
if ($notFoundIndicatorLeft) {
translationId = [
$notFoundIndicatorLeft,
translationId
].join(' ');
}
if ($notFoundIndicatorRight) {
translationId = [
translationId,
$notFoundIndicatorRight
].join(' ');
}
return translationId;
};
var useLanguage = function (key) {
$uses = key;
$rootScope.$emit('$translateChangeSuccess', { language: key });
if ($storageFactory) {
Storage.set($translate.storageKey(), $uses);
}
defaultInterpolator.setLocale($uses);
angular.forEach(interpolatorHashMap, function (interpolator, id) {
interpolatorHashMap[id].setLocale($uses);
});
$rootScope.$emit('$translateChangeEnd', { language: key });
};
var loadAsync = function (key) {
if (!key) {
throw 'No language key specified for loading.';
}
var deferred = $q.defer();
$rootScope.$emit('$translateLoadingStart', { language: key });
pendingLoader = true;
var cache = loaderCache;
if (typeof cache === 'string') {
cache = $injector.get(cache);
}
var loaderOptions = angular.extend({}, $loaderOptions, {
key: key,
$http: angular.extend({}, { cache: cache }, $loaderOptions.$http)
});
$injector.get($loaderFactory)(loaderOptions).then(function (data) {
var translationTable = {};
$rootScope.$emit('$translateLoadingSuccess', { language: key });
if (angular.isArray(data)) {
angular.forEach(data, function (table) {
angular.extend(translationTable, flatObject(table));
});
} else {
angular.extend(translationTable, flatObject(data));
}
pendingLoader = false;
deferred.resolve({
key: key,
table: translationTable
});
$rootScope.$emit('$translateLoadingEnd', { language: key });
}, function (key) {
$rootScope.$emit('$translateLoadingError', { language: key });
deferred.reject(key);
$rootScope.$emit('$translateLoadingEnd', { language: key });
});
return deferred.promise;
};
if ($storageFactory) {
Storage = $injector.get($storageFactory);
if (!Storage.get || !Storage.set) {
throw new Error('Couldn\'t use storage \'' + $storageFactory + '\', missing get() or set() method!');
}
}
if (angular.isFunction(defaultInterpolator.useSanitizeValueStrategy)) {
defaultInterpolator.useSanitizeValueStrategy($interpolationSanitizationStrategy);
}
if ($interpolatorFactories.length) {
angular.forEach($interpolatorFactories, function (interpolatorFactory) {
var interpolator = $injector.get(interpolatorFactory);
interpolator.setLocale($preferredLanguage || $uses);
if (angular.isFunction(interpolator.useSanitizeValueStrategy)) {
interpolator.useSanitizeValueStrategy($interpolationSanitizationStrategy);
}
interpolatorHashMap[interpolator.getInterpolationIdentifier()] = interpolator;
});
}
var getTranslationTable = function (langKey) {
var deferred = $q.defer();
if (Object.prototype.hasOwnProperty.call($translationTable, langKey)) {
deferred.resolve($translationTable[langKey]);
} else if (langPromises[langKey]) {
langPromises[langKey].then(function (data) {
translations(data.key, data.table);
deferred.resolve(data.table);
}, deferred.reject);
} else {
deferred.reject();
}
return deferred.promise;
};
var getFallbackTranslation = function (langKey, translationId, interpolateParams, Interpolator) {
var deferred = $q.defer();
getTranslationTable(langKey).then(function (translationTable) {
if (Object.prototype.hasOwnProperty.call(translationTable, translationId)) {
Interpolator.setLocale(langKey);
deferred.resolve(Interpolator.interpolate(translationTable[translationId], interpolateParams));
Interpolator.setLocale($uses);
} else {
deferred.reject();
}
}, deferred.reject);
return deferred.promise;
};
var getFallbackTranslationInstant = function (langKey, translationId, interpolateParams, Interpolator) {
var result, translationTable = $translationTable[langKey];
if (Object.prototype.hasOwnProperty.call(translationTable, translationId)) {
Interpolator.setLocale(langKey);
result = Interpolator.interpolate(translationTable[translationId], interpolateParams);
Interpolator.setLocale($uses);
}
return result;
};
var translateByHandler = function (translationId) {
if ($missingTranslationHandlerFactory) {
var resultString = $injector.get($missingTranslationHandlerFactory)(translationId, $uses);
if (resultString !== undefined) {
return resultString;
} else {
return translationId;
}
} else {
return translationId;
}
};
var resolveForFallbackLanguage = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator) {
var deferred = $q.defer();
if (fallbackLanguageIndex < $fallbackLanguage.length) {
var langKey = $fallbackLanguage[fallbackLanguageIndex];
getFallbackTranslation(langKey, translationId, interpolateParams, Interpolator).then(deferred.resolve, function () {
resolveForFallbackLanguage(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator).then(deferred.resolve);
});
} else {
deferred.resolve(translateByHandler(translationId));
}
return deferred.promise;
};
var resolveForFallbackLanguageInstant = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator) {
var result;
if (fallbackLanguageIndex < $fallbackLanguage.length) {
var langKey = $fallbackLanguage[fallbackLanguageIndex];
result = getFallbackTranslationInstant(langKey, translationId, interpolateParams, Interpolator);
if (!result) {
result = resolveForFallbackLanguageInstant(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator);
}
}
return result;
};
var fallbackTranslation = function (translationId, interpolateParams, Interpolator) {
return resolveForFallbackLanguage(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator);
};
var fallbackTranslationInstant = function (translationId, interpolateParams, Interpolator) {
return resolveForFallbackLanguageInstant(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator);
};
var determineTranslation = function (translationId, interpolateParams, interpolationId) {
var deferred = $q.defer();
var table = $uses ? $translationTable[$uses] : $translationTable, Interpolator = interpolationId ? interpolatorHashMap[interpolationId] : defaultInterpolator;
if (table && Object.prototype.hasOwnProperty.call(table, translationId)) {
var translation = table[translationId];
if (translation.substr(0, 2) === '@:') {
$translate(translation.substr(2), interpolateParams, interpolationId).then(deferred.resolve, deferred.reject);
} else {
deferred.resolve(Interpolator.interpolate(translation, interpolateParams));
}
} else {
var missingTranslationHandlerTranslation;
if ($missingTranslationHandlerFactory && !pendingLoader) {
missingTranslationHandlerTranslation = translateByHandler(translationId);
}
if ($uses && $fallbackLanguage && $fallbackLanguage.length) {
fallbackTranslation(translationId, interpolateParams, Interpolator).then(function (translation) {
deferred.resolve(translation);
}, function (_translationId) {
deferred.reject(applyNotFoundIndicators(_translationId));
});
} else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
deferred.resolve(missingTranslationHandlerTranslation);
} else {
deferred.reject(applyNotFoundIndicators(translationId));
}
}
return deferred.promise;
};
var determineTranslationInstant = function (translationId, interpolateParams, interpolationId) {
var result, table = $uses ? $translationTable[$uses] : $translationTable, Interpolator = interpolationId ? interpolatorHashMap[interpolationId] : defaultInterpolator;
if (table && Object.prototype.hasOwnProperty.call(table, translationId)) {
var translation = table[translationId];
if (translation.substr(0, 2) === '@:') {
result = determineTranslationInstant(translation.substr(2), interpolateParams, interpolationId);
} else {
result = Interpolator.interpolate(translation, interpolateParams);
}
} else {
var missingTranslationHandlerTranslation;
if ($missingTranslationHandlerFactory && !pendingLoader) {
missingTranslationHandlerTranslation = translateByHandler(translationId);
}
if ($uses && $fallbackLanguage && $fallbackLanguage.length) {
fallbackIndex = 0;
result = fallbackTranslationInstant(translationId, interpolateParams, Interpolator);
} else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
result = missingTranslationHandlerTranslation;
} else {
result = applyNotFoundIndicators(translationId);
}
}
return result;
};
$translate.preferredLanguage = function (langKey) {
if (langKey) {
setupPreferredLanguage(langKey);
}
return $preferredLanguage;
};
$translate.cloakClassName = function () {
return $cloakClassName;
};
$translate.fallbackLanguage = function (langKey) {
if (langKey !== undefined && langKey !== null) {
fallbackStack(langKey);
if ($loaderFactory) {
if ($fallbackLanguage && $fallbackLanguage.length) {
for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
if (!langPromises[$fallbackLanguage[i]]) {
langPromises[$fallbackLanguage[i]] = loadAsync($fallbackLanguage[i]);
}
}
}
}
$translate.use($translate.use());
}
if ($fallbackWasString) {
return $fallbackLanguage[0];
} else {
return $fallbackLanguage;
}
};
$translate.useFallbackLanguage = function (langKey) {
if (langKey !== undefined && langKey !== null) {
if (!langKey) {
startFallbackIteration = 0;
} else {
var langKeyPosition = indexOf($fallbackLanguage, langKey);
if (langKeyPosition > -1) {
startFallbackIteration = langKeyPosition;
}
}
}
};
$translate.proposedLanguage = function () {
return $nextLang;
};
$translate.storage = function () {
return Storage;
};
$translate.use = function (key) {
if (!key) {
return $uses;
}
var deferred = $q.defer();
$rootScope.$emit('$translateChangeStart', { language: key });
var aliasedKey = negotiateLocale(key);
if (aliasedKey) {
key = aliasedKey;
}
if (!$translationTable[key] && $loaderFactory && !langPromises[key]) {
$nextLang = key;
langPromises[key] = loadAsync(key).then(function (translation) {
translations(translation.key, translation.table);
deferred.resolve(translation.key);
useLanguage(translation.key);
if ($nextLang === key) {
$nextLang = undefined;
}
}, function (key) {
if ($nextLang === key) {
$nextLang = undefined;
}
$rootScope.$emit('$translateChangeError', { language: key });
deferred.reject(key);
$rootScope.$emit('$translateChangeEnd', { language: key });
});
} else {
deferred.resolve(key);
useLanguage(key);
}
return deferred.promise;
};
$translate.storageKey = function () {
return storageKey();
};
$translate.isPostCompilingEnabled = function () {
return $postCompilingEnabled;
};
$translate.refresh = function (langKey) {
if (!$loaderFactory) {
throw new Error('Couldn\'t refresh translation table, no loader registered!');
}
var deferred = $q.defer();
function resolve() {
deferred.resolve();
$rootScope.$emit('$translateRefreshEnd', { language: langKey });
}
function reject() {
deferred.reject();
$rootScope.$emit('$translateRefreshEnd', { language: langKey });
}
$rootScope.$emit('$translateRefreshStart', { language: langKey });
if (!langKey) {
var tables = [], loadingKeys = {};
if ($fallbackLanguage && $fallbackLanguage.length) {
for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
tables.push(loadAsync($fallbackLanguage[i]));
loadingKeys[$fallbackLanguage[i]] = true;
}
}
if ($uses && !loadingKeys[$uses]) {
tables.push(loadAsync($uses));
}
$q.all(tables).then(function (tableData) {
angular.forEach(tableData, function (data) {
if ($translationTable[data.key]) {
delete $translationTable[data.key];
}
translations(data.key, data.table);
});
if ($uses) {
useLanguage($uses);
}
resolve();
});
} else if ($translationTable[langKey]) {
loadAsync(langKey).then(function (data) {
translations(data.key, data.table);
if (langKey === $uses) {
useLanguage($uses);
}
resolve();
}, reject);
} else {
reject();
}
return deferred.promise;
};
$translate.instant = function (translationId, interpolateParams, interpolationId) {
if (translationId === null || angular.isUndefined(translationId)) {
return translationId;
}
if (angular.isArray(translationId)) {
var results = {};
for (var i = 0, c = translationId.length; i < c; i++) {
results[translationId[i]] = $translate.instant(translationId[i], interpolateParams, interpolationId);
}
return results;
}
if (angular.isString(translationId) && translationId.length < 1) {
return translationId;
}
if (translationId) {
translationId = trim.apply(translationId);
}
var result, possibleLangKeys = [];
if ($preferredLanguage) {
possibleLangKeys.push($preferredLanguage);
}
if ($uses) {
possibleLangKeys.push($uses);
}
if ($fallbackLanguage && $fallbackLanguage.length) {
possibleLangKeys = possibleLangKeys.concat($fallbackLanguage);
}
for (var j = 0, d = possibleLangKeys.length; j < d; j++) {
var possibleLangKey = possibleLangKeys[j];
if ($translationTable[possibleLangKey]) {
if (typeof $translationTable[possibleLangKey][translationId] !== 'undefined') {
result = determineTranslationInstant(translationId, interpolateParams, interpolationId);
}
}
if (typeof result !== 'undefined') {
break;
}
}
if (!result && result !== '') {
result = defaultInterpolator.interpolate(translationId, interpolateParams);
if ($missingTranslationHandlerFactory && !pendingLoader) {
result = translateByHandler(translationId);
}
}
return result;
};
$translate.versionInfo = function () {
return version;
};
$translate.loaderCache = function () {
return loaderCache;
};
if ($loaderFactory) {
if (angular.equals($translationTable, {})) {
$translate.use($translate.use());
}
if ($fallbackLanguage && $fallbackLanguage.length) {
var processAsyncResult = function (translation) {
translations(translation.key, translation.table);
$rootScope.$emit('$translateChangeEnd', { language: translation.key });
};
for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
langPromises[$fallbackLanguage[i]] = loadAsync($fallbackLanguage[i]).then(processAsyncResult);
}
}
}
return $translate;
}
];
}
]);
angular.module('pascalprecht.translate').factory('$translateDefaultInterpolation', [
'$interpolate',
function ($interpolate) {
var $translateInterpolator = {}, $locale, $identifier = 'default', $sanitizeValueStrategy = null, sanitizeValueStrategies = {
escaped: function (params) {
var result = {};
for (var key in params) {
if (Object.prototype.hasOwnProperty.call(params, key)) {
result[key] = angular.element('<div></div>').text(params[key]).html();
}
}
return result;
}
};
var sanitizeParams = function (params) {
var result;
if (angular.isFunction(sanitizeValueStrategies[$sanitizeValueStrategy])) {
result = sanitizeValueStrategies[$sanitizeValueStrategy](params);
} else {
result = params;
}
return result;
};
$translateInterpolator.setLocale = function (locale) {
$locale = locale;
};
$translateInterpolator.getInterpolationIdentifier = function () {
return $identifier;
};
$translateInterpolator.useSanitizeValueStrategy = function (value) {
$sanitizeValueStrategy = value;
return this;
};
$translateInterpolator.interpolate = function (string, interpolateParams) {
if ($sanitizeValueStrategy) {
interpolateParams = sanitizeParams(interpolateParams);
}
return $interpolate(string)(interpolateParams || {});
};
return $translateInterpolator;
}
]);
angular.module('pascalprecht.translate').constant('$STORAGE_KEY', 'NG_TRANSLATE_LANG_KEY');
angular.module('pascalprecht.translate').directive('translate', [
'$translate',
'$q',
'$interpolate',
'$compile',
'$parse',
'$rootScope',
function ($translate, $q, $interpolate, $compile, $parse, $rootScope) {
return {
restrict: 'AE',
scope: true,
compile: function (tElement, tAttr) {
var translateValuesExist = tAttr.translateValues ? tAttr.translateValues : undefined;
var translateInterpolation = tAttr.translateInterpolation ? tAttr.translateInterpolation : undefined;
var translateValueExist = tElement[0].outerHTML.match(/translate-value-+/i);
var interpolateRegExp = '^(.*)(' + $interpolate.startSymbol() + '.*' + $interpolate.endSymbol() + ')(.*)';
return function linkFn(scope, iElement, iAttr) {
scope.interpolateParams = {};
scope.preText = '';
scope.postText = '';
iAttr.$observe('translate', function (translationId) {
if (angular.equals(translationId, '') || !angular.isDefined(translationId)) {
var interpolateMatches = iElement.text().match(interpolateRegExp);
if (angular.isArray(interpolateMatches)) {
scope.preText = interpolateMatches[1];
scope.postText = interpolateMatches[3];
scope.translationId = $interpolate(interpolateMatches[2])(scope.$parent);
} else {
scope.translationId = iElement.text().replace(/^\s+|\s+$/g, '');
}
} else {
scope.translationId = translationId;
}
});
iAttr.$observe('translateDefault', function (value) {
scope.defaultText = value;
});
if (translateValuesExist) {
iAttr.$observe('translateValues', function (interpolateParams) {
if (interpolateParams) {
scope.$parent.$watch(function () {
angular.extend(scope.interpolateParams, $parse(interpolateParams)(scope.$parent));
});
}
});
}
if (translateValueExist) {
var fn = function (attrName) {
iAttr.$observe(attrName, function (value) {
scope.interpolateParams[angular.lowercase(attrName.substr(14, 1)) + attrName.substr(15)] = value;
});
};
for (var attr in iAttr) {
if (Object.prototype.hasOwnProperty.call(iAttr, attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') {
fn(attr);
}
}
}
var applyElementContent = function (value, scope, successful) {
if (!successful && typeof scope.defaultText !== 'undefined') {
value = scope.defaultText;
}
iElement.html(scope.preText + value + scope.postText);
var globallyEnabled = $translate.isPostCompilingEnabled();
var locallyDefined = typeof tAttr.translateCompile !== 'undefined';
var locallyEnabled = locallyDefined && tAttr.translateCompile !== 'false';
if (globallyEnabled && !locallyDefined || locallyEnabled) {
$compile(iElement.contents())(scope);
}
};
var updateTranslationFn = function () {
if (!translateValuesExist && !translateValueExist) {
return function () {
var unwatch = scope.$watch('translationId', function (value) {
if (scope.translationId && value) {
$translate(value, {}, translateInterpolation).then(function (translation) {
applyElementContent(translation, scope, true);
unwatch();
}, function (translationId) {
applyElementContent(translationId, scope, false);
unwatch();
});
}
}, true);
};
} else {
return function () {
var updateTranslations = function () {
if (scope.translationId && scope.interpolateParams) {
$translate(scope.translationId, scope.interpolateParams, translateInterpolation).then(function (translation) {
applyElementContent(translation, scope, true);
}, function (translationId) {
applyElementContent(translationId, scope, false);
});
}
};
scope.$watch('interpolateParams', updateTranslations, true);
scope.$watch('translationId', updateTranslations);
};
}
}();
var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslationFn);
updateTranslationFn();
scope.$on('$destroy', unbind);
};
}
};
}
]);
angular.module('pascalprecht.translate').directive('translateCloak', [
'$rootScope',
'$translate',
function ($rootScope, $translate) {
return {
compile: function (tElement) {
var applyCloak = function () {
tElement.addClass($translate.cloakClassName());
}, removeCloak = function () {
tElement.removeClass($translate.cloakClassName());
}, removeListener = $rootScope.$on('$translateChangeEnd', function () {
removeCloak();
removeListener();
removeListener = null;
});
applyCloak();
return function linkFn(scope, iElement, iAttr) {
if (iAttr.translateCloak && iAttr.translateCloak.length) {
iAttr.$observe('translateCloak', function (translationId) {
$translate(translationId).then(removeCloak, applyCloak);
});
}
};
}
};
}
]);
angular.module('pascalprecht.translate').filter('translate', [
'$parse',
'$translate',
function ($parse, $translate) {
var translateFilter = function (translationId, interpolateParams, interpolation) {
if (!angular.isObject(interpolateParams)) {
interpolateParams = $parse(interpolateParams)(this);
}
return $translate.instant(translationId, interpolateParams, interpolation);
};
translateFilter.$stateful = true;
return translateFilter;
}
]);
/*!
* angular-translate - v2.4.2 - 2014-10-21
* http://github.com/angular-translate/angular-translate
* Copyright (c) 2014 ; Licensed MIT
*/
angular.module('pascalprecht.translate').factory('$translateCookieStorage', [
'$cookieStore',
function ($cookieStore) {
var $translateCookieStorage = {
get: function (name) {
return $cookieStore.get(name);
},
set: function (name, value) {
$cookieStore.put(name, value);
}
};
return $translateCookieStorage;
}
]);
/*!
* angular-translate - v2.4.2 - 2014-10-21
* http://github.com/angular-translate/angular-translate
* Copyright (c) 2014 ; Licensed MIT
*/
angular.module('pascalprecht.translate').factory('$translateStaticFilesLoader', [
'$q',
'$http',
function ($q, $http) {
return function (options) {
if (!options || (!angular.isString(options.prefix) || !angular.isString(options.suffix))) {
throw new Error('Couldn\'t load static files, no prefix or suffix specified!');
}
var deferred = $q.defer();
$http(angular.extend({
url: [
options.prefix,
options.key,
options.suffix
].join(''),
method: 'GET',
params: ''
}, options.$http)).success(function (data) {
deferred.resolve(data);
}).error(function (data) {
deferred.reject(options.key);
});
return deferred.promise;
};
}
]);