View difference between Paste ID: Jy2mzLgj and BY39pJEM

 /* interceptor.js (angularjs 1.2.x version) */
 angular.module('security.interceptor', ['security.retryQueue'])
 .factory('securityInterceptor', ['$injector', 'securityRetryQueue', '$cookieStore', function ($injector, queue, $cookieStore) {
 	return {
 		response: function(originalResponse)
 		{
 			return originalResponse;
 		},
 		responseError: function (originalResponse) {
 			var exception;
 			if (originalResponse.headers){
 				exception = originalResponse.headers('x-eva-api-exception');
 			}
 			if (originalResponse.status === 401 && (exception === 'token_not_found' || exception === 'token_expired')){
 				queue.pushRetryFn(exception, function retryRequest() {
 					return $injector.get('$http')(originalResponse.config);
 				});
 			}
 			return originalResponse;
 		}
 	};
 }])
 .config(['$httpProvider', function($httpProvider) {
 	$httpProvider.interceptors.push('securityInterceptor');
 }]);
 
 
 /* interceptor.js (angularjs 1.0.8 version) */
 
 angular.module('security.interceptor', ['security.retryQueue'])
 .factory('securityInterceptor', ['$injector', 'securityRetryQueue', function($injector, queue) {
 	return function(promise) {
 		return promise.then(null, function(originalResponse) {
 			var exception;
 			if(originalResponse.headers) {
 				exception = originalResponse.headers('x-eva-api-exception');
 			}
 			if(originalResponse.status === 401 && (exception === 'token_not_found' || exception === 'token_expired')) {
 				promise = queue.pushRetryFn(exception, function retryRequest() {
 					return $injector.get('$http')(originalResponse.config);
 				});
 			}
 			return promise;
 		});
 	};
 }])
 .config(['$httpProvider', function($httpProvider) {
 	$httpProvider.responseInterceptors.push('securityInterceptor');
 }])
 
 /* retryQueue.js */
 angular.module('security.retryQueue', [])
 .factory('securityRetryQueue', ['$q', '$log', function($q, $log) {
 	var retryQueue = [];
 	var service = {
 		// The security service puts its own handler in here!
 		onItemAddedCallbacks: [],
 		hasMore: function() {
 			console.log('retryQueue.js -> hasMore: ' + retryQueue.length);
 			return retryQueue.length > 0;
 		},
 		push: function(retryItem) {
 			retryQueue.push(retryItem);
 			// Call all the onItemAdded callbacks
 			angular.forEach(service.onItemAddedCallbacks, function(cb) {
 				try {
 					console.log('retryQueue.js -> push: ' + retryItem.reason);
 					cb(retryItem);
 				} catch(e) {
 					$log.error('securityRetryQueue.push(retryItem): callback threw an error' + e);
 				}
 			});
 		},
 		pushRetryFn: function(reason, retryFn) {
 			console.log('retryQueue.js -> pushRetryFn called');
 			console.log('retryQueue.js -> pushRetryFn reason: ' + reason);
 			console.log('retryQueue.js -> pushRetryFn retryFn: ' + retryFn);
 			// The reason parameter is optional
 			console.log('retryQueue.js -> arguments: ' + arguments);
 			console.log('retryQueue.js -> arguments: ' + arguments.length);
 			if ( arguments.length === 1) {
 				console.log('retryQueue.js -> reason in pushRetryFn: ' + reason);
 				retryFn = reason;
 				reason = undefined;
 			}
 
 			// The deferred object that will be resolved or rejected by calling retry or cancel
 			var deferred = $q.defer();
 			var retryItem = {
 				reason: reason,
 				retry: function() {
 					console.log('retryQueue.js -> pushRetryFn with reason ' + reason);
 					// Wrap the result of the retryFn into a promise if it is not already
 					$q.when(retryFn()).then(function(value) {
 						console.log('retryQueue.js -> resolve pushRetryFn with retry and value: ' + value);
 						// If it was successful then resolve our deferred
 						deferred.resolve(value);
 					}, function(value) {
 						// Othewise reject it
 						console.log('retryQueue.js -> reject pushRetryFn with reject and value: ' + value);
 						deferred.reject(value);
 					});
 				},
 				cancel: function() {
 					// Give up on retrying and reject our deferred
 					deferred.reject();
 				}
 			};
 			console.log('retryQueue.js -> pushRetryFn push retryItem: ' + retryItem.reason);
 			service.push(retryItem);
 			return deferred.promise;
 		},
 		retryReason: function() {
 			return service.hasMore() && retryQueue[0].reason;
 		},
 		cancelAll: function() {
 			while(service.hasMore()) {
 				retryQueue.shift().cancel();
 			}
 		},
 		retryAll: function() {
 			while(service.hasMore()) {
 				retryQueue.shift().retry();
 			}
 		}
 	};
 	return service;
 }]);
 
 
 /* security.js  */
 angular.module('security.service', ['session.service', 'security.signin', 'security.retryQueue', 'security.tokens', 'ngCookies'])
 .factory('security', ['$location', 'securityRetryQueue', '$q', 'TokenHandler', '$cookieStore', 'Session', 'i18nNotifications', 'User', function($location, queue, $q, TokenHandler, $cookieStore, Session, i18nNotifications, User) {
 	function redirect(url) {
 		url = url || '/';
 		$location.path(url);
 	}
 
 	var skipRequests = false;
 
 	// Register a handler for when an item is added to the retry queue
 	queue.onItemAddedCallbacks.push(function(retryItem) {
 		if ( queue.hasMore() ) {
 			if(skipRequests) {return;}
 			// make sure only one token is created by skiping subsequant authentication requests
 			console.log('security.js -> set skipRequests to true');
 			skipRequests = true;
 			if(retryItem.reason === 'token_expired') {
 				service.refreshToken().then(function(result) {
 					if(result) {
 						var currentToken = TokenHandler.get();
 						console.log('security.js -> currentToken before queue.retryAll() call:' + currentToken);
 						console.log('security.js ->  result before queue.retryAll() call:' + currentToken);
 						queue.retryAll();
 					}
 					// user has to authorize with credentials
 					else
 					{
 						service.signout();
 					}
 					skipRequests = false;
 					console.log('security.js -> set skipRequests to false');
 				});
 			} else {
 				// user has to authorize with credentials
 				skipRequests = false;
 				console.log('security.js -> set skipRequests to false before signout');
 				service.signout();
 			}
 		}
 	});
 
 	var service = {
 		// get a new valid token using the refresh token
 		refreshToken: function() {
 			console.log('security.js -> refreshToken called, d created');
 			var d = $q.defer();
 			var token = TokenHandler.getRefreshToken();
 			// cannot refresh token if not found on the client
 			if(!token) {
 				console.log('security.js -> token not found on a client');
 				d.resolve(false);
 			}
 
 			console.log('security.js -> token found on a client: ' + token);
 			var session = new Session({
 				refreshToken: token
 			});
 
 			console.log('security.js -> calling session.tokenRefresh');
 			session.tokenRefresh(function(result) {
 				if(result) {
 					console.log('security.js -> result OK, d.resolve(true), setting token with a accessToken: ' + result.accessToken + ' and refresh token: ' + result.refreshToken);
 					d.resolve(true);
 					TokenHandler.set(result);
 				} else {
 					console.log('security.js -> result NOT ok, d.resolve(false)');
 					d.resolve(false);
 				}
 			});
 
 			console.log('security.js -> returning d.promise');
 			return d.promise;
 		}
 	};
 
 	return service;
 }]);
 
 /* httpHeaders.js */
 angular.module('services.httpHeaders', [])
 .factory('HttpHeaders', ['$injector', function($injector) {
 	var http = $injector.get('$http');
 	var service = {
 		initHeaders: function() {
 		},
 		// set session token used to authorize the user against the api
 		setAuthorizationToken: function(token) {
 			console.log('httpHeaders.js -> setting authorization token: ' + token);
 			http.defaults.headers.common['Authorization'] = 'Bearer ' + token;
 		},
 
 		clearAuthorizationHeader: function()  {
 			http.defaults.headers.common['Authorization'] = null;
 		}
 	};
 	return service;
 }]);
 
 /* tokenHandler.js */
 angular.module('security.tokens', ['ngResource'])
 .factory('TokenHandler', ['HttpHeaders', '$cookieStore', function(HttpHeaders, $cookieStore) {
 	var token = null;
 
 	function initToken() {
 		if(!token) {
 			token = $cookieStore.get('authorization-token');
 		}
 	}
 
 	var service = {
 		// set a new token and save to cookies
 		set: function(newToken) {
 			token = newToken;
 			$cookieStore.put('authorization-token', token);
 			HttpHeaders.setAuthorizationToken(token.accessToken);
 		},
 
 		// try to init the token from cookies
 		init: function() {
 			initToken();
 			if(!token) {return;}
 			HttpHeaders.setAuthorizationToken(token.accessToken);
 		},
 
 		// clear token and remove it from cookies
 		clear: function() {
 			$cookieStore.remove('authorization-token');
 			token = {};
 			HttpHeaders.clearAuthorizationHeader();
 		},
 
 		// return currently active token
 		get: function() {
 			initToken();
 			if(token) {return token.accessToken;}
 			else {return null;}
 		},
 
 		// return the refresth token
 		getRefreshToken: function() {
 			initToken();
 			if(token) {
 				console.log('tokenHandler.js -> getRefreshToken: ' + token);
 				return token.refreshToken;
 			}
 			else {
 				console.log('token was not found, returning null');
 				return null;
 			}
 		}
 	};
 	service.init();
 	return service;
 }]);