pip-webui
Version:
HTML5 UI for LOB applications
1,387 lines (1,112 loc) • 130 kB
JavaScript
/**
* @file Announces data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipAnnouncesCache', ['pipAnnouncesData']);
thisModule.service('pipAnnouncesCache',
['pipEnums', 'pipDataCache', 'pipTagsCache', function (pipEnums, pipDataCache, pipTagsCache) {
return {
readAnnounces: readAnnounces,
onAnnounceCreate: onAnnounceCreate,
onAnnounceUpdate: onAnnounceUpdate,
onAnnounceDelete: onAnnounceDelete
};
function readAnnounces(params, successCallback, errorCallback) {
params = params || {};
params.resource = 'announces';
params.item = params.item || {};
return pipDataCache.retrieveOrLoad(params, successCallback, errorCallback);
}
function onAnnounceCreate(params, successCallback) {
return pipDataCache.addDecorator(
'announces', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
}
function onAnnounceUpdate(params, successCallback) {
return pipDataCache.updateDecorator(
'announces', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
}
function onAnnounceDelete(params, successCallback) {
return pipDataCache.removeDecorator('announces', params, successCallback);
}
}]
);
})();
/**
* @file Global application data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global _, angular */
(function () {
'use strict';
var thisModule = angular.module('pipDataCache', ['pipDataModel']);
thisModule.provider('pipDataCache', function () {
var
CACHE_TIMEOUT = 5 * 60000, // 5 mins or make it configurable
cache = {};
this.timeout = timeout;
this.$get = ['$q', 'pipDataModel', function ($q, pipDataModel) {
return {
timeout: timeout,
clear: clear,
retrieve: retrieve,
retrieveOrLoad: retrieveOrLoad,
store: store,
storePermanent: storePermanent,
remove: remove,
removeItem: removeItem,
removeDecorator: removeDecorator,
// OBSOLETE - will be removed
addDecorator: addDecorator,
updateDecorator: updateDecorator,
};
//-------------
// Converts a string value into a numeric hash code
function hash(data) {
var filteredData = {};
// Filter only the generic parameters that can be relevant to the query
if(data != null) {
filteredData.item = data.item;
filteredData.party_id = data.party_id;
filteredData.search = data.search;
filteredData.paging = data.paging;
filteredData.take = data.take;
filteredData.skip = data.skip;
}
filteredData = angular.toJson(filteredData);
var h = 0, i, chr, len;
if (filteredData == null || filteredData.length === 0) return h;
for (i = 0, len = filteredData.length; i < len; i++) {
chr = filteredData.charCodeAt(i);
h = ((h << 5) - h) + chr;
h |= 0; // Convert to 32bit integer
}
return h;
};
// Generates parameterized key
function generateKey(name, params) {
var h = hash(params);
return name + (h != 0 ? '_' + h : '');
};
// Clear the cache, globally or selectively
function clear(name) {
if (name == null) {
cache = {};
console.log('****** Invalidated cache');
} else {
for (var key in cache) {
if (key == name || key.startsWith(name + '_')) {
console.log('****** Invalidated cache ' + key);
delete cache[key];
}
}
}
};
// Try to retrieve collection from the cache
function retrieve(name, params) {
if (name == null) throw new Error('name cannot be null');
if (name == '') throw new Error('name cannot be empty');
var key = generateKey(name, params);
var holder = cache[key];
if (holder == null) return null;
// If expired then cleanup and return null
if (holder.expire
&& _.now() - holder.expire > CACHE_TIMEOUT) {
delete cache[key];
return null;
}
return holder.data;
};
// Store collection into the cache
function store(name, data, params) {
if (name == null) throw new Error('name cannot be null');
if (name == '') throw new Error('name cannot be empty');
cache[generateKey(name, params)] = {
expire: _.now(),
data: data
};
};
// Store collection into the cache without expiration
function storePermanent(name, data, params) {
if (name == null) throw new Error('name cannot be null');
if (name == '') throw new Error('name cannot be empty');
cache[generateKey(name, params)] = {
expire: null,
data: data
};
};
// Remove collection from the cache
function remove(name, params) {
if (name == null) throw new Error('name cannot be null');
if (name == '') throw new Error('name cannot be empty');
delete cache[generateKey(name, params)];
};
function updateItem(name, item, params) {
if (name == null) throw new Error('name cannot be null');
if (item == null) return;
var data = retrieve(name, params);
if (data != null) {
var isAdded = false;
for (var i = 0; i < data.length; i++) {
if (data[i].id == item.id) {
data[i] = item;
isAdded = true;
return;
}
}
if (!isAdded) data.push(item);
store(name, data, params);
}
};
// Tries to retrieve collection from the cache, otherwise load it from server
function retrieveOrLoad(params, successCallback, errorCallback) {
if (params == null) throw new Error('params cannot be null');
// todo add check params?
var name = (params.cache || params.resource);
// Retrieve data from cache
var filter = params.filter,
force = !!params.force,
result = !force ? retrieve(name, params) : null,
deferred = $q.defer();
// Return result if it exists
if (result) {
console.log('***** Loaded from cache ' + name, result);
if (filter) result = filter(result);
if (successCallback) successCallback(result);
deferred.resolve(result);
return deferred.promise;
}
// Load data from server
pipDataModel[params.singleResult ? 'readOne' : 'read'](
params,
function (data) {
// Store data in cache and return
params.singleResult ?
updateItem(name, data, params) :
store(name, data, params);
if (filter) data = filter(data);
deferred.resolve(data);
console.log('***** Loaded from server ' + name, data);
if (successCallback) successCallback(data);
},
function (err) {
// Return error
console.log('***** FAILED to load from server ' + name);
deferred.reject(err);
if (errorCallback) errorCallback(err);
}
);
// Return deferred object
return deferred.promise;
};
function removeItem(name, item) {
if (name == null) throw new Error('name cannot be null');
if (item == null) return;
for (var key in cache) {
if (key == name || key.startsWith(name + '_')) {
var data = cache[key].data;
if (angular.isArray(data)) {
for (var i = 0; i < data.length; i++) {
if (data[i].id == item.id) {
data.splice(i, 1);
i--;
}
}
}
}
}
};
function removeDecorator(resource, params, successCallback) {
return function (item) {
removeItem(resource, params);
if (successCallback) successCallback(item);
};
};
function updateDecorator(resource, params, successCallback) {
return function (item) {
for (var key in cache) {
if (key == resource || key.startsWith(resource + '_')) {
var data = cache[key].data;
if (angular.isArray(data)) {
for (var i = 0; i < data.length; i++) {
if (data[i].id == item.id) {
data[i] = item;
}
}
}
}
}
if (successCallback) successCallback(item);
};
};
// OBSOLETE - WILL BE REMOVED ONCE CODE IS REFACTORED
function addDecorator(resource, params, successCallback) {
return function (item) {
if (!params || !params.notClearedCache) clear(resource);
if (successCallback) successCallback(item);
};
};
}];
//-----------------------
function timeout(newTimeout) {
if (newTimeout) {
CACHE_TIMEOUT = newTimeout;
}
return CACHE_TIMEOUT;
};
});
})();
/**
* @file Guides data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipGuidesCache', ['pipGuidesData']);
thisModule.service('pipGuidesCache',
['pipEnums', 'pipDataCache', 'pipTagsCache', function (pipEnums, pipDataCache, pipTagsCache) {
return {
readGuides: readGuides,
onGuideCreate: onGuideCreate,
onGuideUpdate: onGuideUpdate,
onGuideDelete: onGuideDelete
};
function readGuides(params, successCallback, errorCallback) {
params = params || {};
params.resource = 'guides';
params.item = params.item || {};
return pipDataCache.retrieveOrLoad(params, successCallback, errorCallback);
};
function onGuideCreate(params, successCallback) {
return pipDataCache.addDecorator(
'guides', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
};
function onGuideUpdate(params, successCallback) {
return pipDataCache.updateDecorator(
'guides', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
};
function onGuideDelete(params, successCallback) {
return pipDataCache.removeDecorator('guides', params, successCallback);
};
}]
);
})();
/**
* @file Session data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipSessionCache', ['pipCore', 'pipRest', 'pipDataCache']);
thisModule.run(['$rootScope', 'pipSessionCache', function ($rootScope, pipSessionCache) {
$rootScope.$on('pipSessionOpened', pipSessionCache.init);
$rootScope.$on('pipSessionClosed', pipSessionCache.clear);
}]);
thisModule.service('pipSessionCache',
['$rootScope', '$stateParams', '$q', 'pipTranslate', 'pipRest', 'localStorageService', 'pipAccess', 'pipEnums', 'pipSession', 'pipDataCache', function ($rootScope, $stateParams, $q, pipTranslate, pipRest, localStorageService,
pipAccess, pipEnums, pipSession, pipDataCache) {
return {
init: init,
clear: clear,
readUser: readUser,
readParty: readParty,
readConnection: readConnection,
readSettings: readSettings,
onSettingsUpdate: onSettingsUpdate
};
//-------------
function init(event, data) {
if (data == null)
throw new Error('Unexpected error: issues in openning session');
clear();
if (data.serverUrl) $rootScope.$serverUrl = data.serverUrl;
storeUser(data.user, null);
};
function clear() {
// Clear data cache
pipDataCache.clear();
// Clear global variables
delete $rootScope.$user;
delete $rootScope.$party;
delete $rootScope.$serverUrl;
delete $rootScope.$connection;
delete $rootScope.$settings;
};
function updateUserRights(user, party) {
// Get parameters from cache if they are not defined
user = user || pipDataCache.retrieve('user');
party = party || pipDataCache.retrieve('party');
// Exit if user is not defined
if (user == null) return;
// Update user access rights
if (party == null)
user = pipAccess.asOwner(user);
else if (user.id == party.id)
user = pipAccess.asOwner(user);
else
user = pipAccess.toParty(user, party);
// Save user with new rights back to cache
pipDataCache.storePermanent('user', user);
$rootScope.$user = user;
};
function storeUserTheme(user) {
if (!user) return;
var userTheme = user.theme || 'blue';
if (user && $rootScope.$party) {
if ($rootScope.$party.id == user.id) userTheme = user.theme;
else userTheme = 'navy';
}
$rootScope.$theme = userTheme;
localStorageService.set('theme', userTheme);
};
function storeUser(user) {
if (user == null) return;
pipDataCache.storePermanent('user', user);
$rootScope.$user = user;
storeUserTheme(user);
// Activate user language
pipTranslate.use(user.language, false, true);
updateUserRights(user, null);
};
function readUser(successCallback, errorCallback) {
// Avoid broken session
if (!pipSession.opened())
throw new Error('User is not authenticated.');
var
userId = pipSession.userId(),
user = pipDataCache.retrieve('user');
// Return user from cache
if (user) {
if (user.id != userId)
throw new Error('Unexpected error: issues in opening session');
if (successCallback) successCallback(user);
var deferred = $q.defer();
deferred.resolve(user);
return deferred.promise;
}
// Read user from server
return pipRest.users().get(
{id: userId},
function (user) {
// Double check
if (user.id != userId)
user == null;
storeUser(user);
if (successCallback) successCallback(use);
},
errorCallback
).$promise;
};
function readParty(stateParams, successCallback, errorCallback) {
// Avoid broken session
if (!pipSession.opened())
throw new Error('User is not authenticated.');
var
userId = pipSession.userId(),
partyId = stateParams.party_id || userId,
party = pipDataCache.retrieve('party');
// Skip if party already retrieved
if (party && party.id == partyId) {
$rootScope.$party = party;
storeUserTheme($rootScope.$user);
if (successCallback) successCallback(party);
var deferred = $q.defer();
deferred.resolve(party);
return deferred.promise;
}
// Read party from server
return pipRest.parties().get(
{id: partyId},
function (party) {
updateUserRights(null, party);
pipDataCache.storePermanent('party', party);
$rootScope.$party = party;
storeUserTheme($rootScope.$user);
if (successCallback) successCallback(party);
},
errorCallback
).$promise;
};
function readConnection(stateParams, successCallback, errorCallback) {
// Avoid broken session
if (!pipSession.opened())
throw new Error('User is not authenticated.');
var
userId = pipSession.userId(),
partyId = stateParams.party_id || userId,
connection = pipDataCache.retrieve('connection');
// Clear connection it does not match user or party
if (connection
&& (connection.party_id != userId
|| connection.to_party_id != partyId)) {
connection = null;
pipDataCache.remove('connection');
delete $rootScope.$connection;
}
// For owner connection is not defined
if (userId == partyId) {
if (successCallback) successCallback(connection);
var deferred = $q.defer();
deferred.resolve(connection);
return deferred.promise;
}
// Read connection from server
return pipRest.connections().query(
{
party_id: userId,
to_party_id: partyId,
accept: pipEnums.ACCEPTANCE.ACCEPTED
},
function (connections) {
// There are shall not be more than one active connection
if (connections && connections.length > 0)
connection = connections[0];
else connection = null;
pipDataCache.storePermanent('connection', connection);
$rootScope.$connection = connection;
if (successCallback) successCallback(connection);
},
errorCallback
).$promise;
};
function readSettings(successCallback, errorCallback) {
// Avoid broken session
if (!pipSession.opened())
throw new Error('User is not authenticated.');
var
userId = pipSession.userId(),
settings = pipDataCache.retrieve('settings' + '_' + userId);
if (settings) {
if (successCallback) successCallback(settings);
var deferred = $q.defer();
deferred.resolve(settings);
return deferred.promise;
}
// Read settings from server
return pipRest.partySettings().get(
{
party_id: userId
},
function (settings) {
settings = settings || {};
pipDataCache.storePermanent('settings' + '_' + userId, settings);
$rootScope.$settings = settings;
if (successCallback) successCallback(settings);
},
errorCallback
).$promise;
};
function onSettingsUpdate(item, successCallback) {
// return function(item) {
if (item == null) return;
var userId = pipSession.userId(),
settings = pipDataCache.retrieve('settings' + '_' + userId);
// If tags are stored
if (settings) {
settings = _.extend(settings, item);
pipDataCache.storePermanent('settings' + '_' + userId, settings);
$rootScope.$settings = settings;
}
if (successCallback) successCallback(item);
};
}]
);
})();
/**
* @file Tags data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipTagsCache', ['pipUtils', 'pipDataCache']);
thisModule.service('pipTagsCache',
['pipTags', 'pipDataCache', function(pipTags, pipDataCache) {
return {
readTags: readTags,
// Todo: Add updateTags method
onTagsUpdate: onTagsUpdate,
tagsUpdateDecorator: tagsUpdateDecorator
};
//------------------------------
function tagsUpdate(params, item) {
// Extract tag from updated entity
var tags = item ? pipTags.extractTags(item) : [];
if (tags.length == 0) return;
var cacheName = 'partyTags';
if (params && params.party_id !== null && params.party_id !== undefined)
cacheName = cacheName + '_' + params.party_id;
else if (params && params.item && params.item.party_id !== null && params.item.party_id !== undefined)
cacheName = cacheName + '_' + params.item.party_id;
// Todo: this is a wrong way to get party_id (contributor) from entities
var data = pipDataCache.retrieve(cacheName);
// If tags are stored
if (data) {
_.each(tags, function(tag) {
// Find if tag already exists
var t = _.find(data.tags, function(t) {
return pipTags.equalTags(t.tag, tag);
});
// Otherwise add a new tag
if (t) {
t.tag = tag;
t.count = t.count + 1;
t.used = new Date();
} else {
if (!data.tags)
data.tags = [];
data.tags.push({
tag: tag,
count: 1,
used: new Date()
});
}
});
pipDataCache.store(cacheName, data);
}
};
function tagsUpdateDecorator(params, successCallback) {
return function(item) {
tagsUpdate(params, item);
if (successCallback) successCallback(item);
};
};
function readTags(params, successCallback, errorCallback) {
params.resource = 'partyTags';
params.singleResult = true;
return pipDataCache.retrieveOrLoad(params, successCallback, errorCallback);
};
// Todo: Add updateTags method
function onTagsUpdate(params, successCallback) {
return tagsUpdateDecorator(params, successCallback);
};
}]
);
})();
/**
* @file Tips data cache
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipTipsCache', ['pipTipsData']);
thisModule.service('pipTipsCache',
['pipEnums', 'pipDataCache', 'pipTagsCache', function (pipEnums, pipDataCache, pipTagsCache) {
return {
readTips: readTips,
onTipCreate: onTipCreate,
onTipUpdate: onTipUpdate,
onTipDelete: onTipDelete
};
function readTips(params, successCallback, errorCallback) {
params = params || {};
params.resource = 'tips';
params.item = params.item || {};
return pipDataCache.retrieveOrLoad(params, successCallback, errorCallback);
};
function onTipCreate(params, successCallback) {
return pipDataCache.addDecorator(
'tips', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
};
function onTipUpdate(params, successCallback) {
return pipDataCache.updateDecorator(
'tips', params,
pipTagsCache.tagsUpdateDecorator(params, successCallback)
);
};
function onTipDelete(params, successCallback) {
return pipDataCache.removeDecorator('tips', params, successCallback);
};
}]
);
})();
/**
* @file User access permissions service
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global _, angular */
(function () {
'use strict';
var thisModule = angular.module('pipRest.Access', ['pipUtils', 'pipRest.Enums']);
thisModule.factory('pipAccess', ['pipUtils', 'pipEnums', function (pipUtils, pipEnums) {
function defaultAccess(account) {
// Clone and set default values
var user = _.defaults(
{
// Fix id
id: account.id || account._id,
party_id: null,
party_name: null,
type: null,
owner: false,
manager: false,
contributor: false,
share_level: pipEnums.SHARE_LEVEL.WORLD
},
account
);
delete user._id;
return user;
};
function fixAccess(user) {
// Owner acts as his own manager
user.manager = user.manager || user.owner;
// Manager has contributor rights
user.contributor = user.contributor || user.manager;
// Managers and contributors can access at private level
if (user.contributor)
user.share_level = pipEnums.SHARE_LEVEL.PRIVATE;
return user;
}
function overrideAccess(user, access) {
// Copy over override
user.party_id = access.party_id;
user.party_name = access.party_name;
user.type = access.type;
user.owner = !!access.owner;
user.manager = !!access.manager;
user.contributor = !!access.contributor;
user.share_level = access.share_level || pipEnums.SHARE_LEVEL.WORLD;
// Party can be set as an object
if (access.party) {
user.party_id = access.party.id || access.party._id;
user.party_name = access.party.name;
}
// Make access settings consistent and return
return fixAccess(user);
};
function asOwner(account) {
// Skip if no account set
if (account == null) return undefined;
// Construct default user
var user = defaultAccess(account);
// Set owner access rights
user.party_id = user.id;
user.party_name = user.name;
user.type = null;
user.owner = true;
user.manager = true;
user.contributor = true;
user.share_level = pipEnums.SHARE_LEVEL.PRIVATE;
return user;
};
function toParty(account, party) {
// Skip if no account set
if (account == null) return undefined;
// If no party set then assume owner access
if (party == null) return asOwner(account);
var
userId = account.id || account._id,
partyId = party.id || party._id || party,
partyName = party.name || account.name;
// If user and party are the same then
if (userId == partyId) return asOwner(account);
// Set default values
var user = defaultAccess(account);
user.party_id = partyId;
user.party_name = partyName;
// Identify maximum access level
_.each(user.party_access, function (access) {
if (pipUtils.equalObjectIds(partyId, access.party_id)) {
user.party_name = access.party_name;
user.type = access.type;
user.manager = user.manager || access.manager;
user.contributor = user.contributor || access.contributor;
user.share_level = Math.max(user.share_level, access.share_level);
}
});
// Make access settings consistent and return
return fixAccess(user);
};
// Can be used for testing
function override(account, access) {
// Skip if no account set
if (account == null) return undefined;
// Set default values
var user = defaultAccess(account);
// If no override return plain user
if (access) overrideAccess(user, access);
return user;
};
// Can be used for testing
function toPartyWithOverride(account, party, access) {
var user = toParty(account, party);
// If no override return plain user
if (access) overrideAccess(user, access);
return user;
};
return {
asOwner: asOwner,
toParty: toParty,
override: override,
toPartyWithOverride: toPartyWithOverride
};
}]);
})();
/**
* @file Application secure router
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global angular */
(function () {
'use strict';
var thisModule = angular.module('pipRest.State', ['pipState', 'pipRest.Session', 'pipRest.Access', 'pipSessionCache']);
thisModule.config(
['$locationProvider', '$httpProvider', function($locationProvider, $httpProvider) {
// Attach interceptor to react on unauthorized errors
$httpProvider.interceptors.push('pipAuthHttpResponseInterceptor');
}]
);
thisModule.run(
['$rootScope', 'pipState', 'pipSession', 'pipAuthState', function($rootScope, pipState, pipSession, pipAuthState) {
// Intercept routes
$rootScope.$on('$stateChangeStart', stateChangeStart);
// Process unauthorized access error
$rootScope.$on('pipUnauthorizedRedirect', unauthorizedRedirect);
// Handle other errors
$rootScope.$on('pipMaintenanceError', maintenanceError);
$rootScope.$on('pipNoConnectionError', noConnectionError);
$rootScope.$on('pipMissingRouteError', missingRouteError);
$rootScope.$on('pipUnknownError', unknownError);
function stateChangeStart(event, toState, toParams, fromState, fromParams) {
// Implement redirect mechanism
if (pipAuthState.redirect(event, toState, toParams, $rootScope)) {
return;
}
// todo apply in all tool
// If user is not authorized then switch to signin
if ((toState.auth || toState.auth === undefined) && !pipSession.opened()) {
event.preventDefault();
var redirectTo = pipState.href(toState.name, toParams);
// Remove hashtag
if (redirectTo.length > 0 && redirectTo[0] == '#') {
redirectTo = redirectTo.substring(1);
}
pipAuthState.goToSignin({ redirect_to: redirectTo, toState: toState, toParams: toParams});
return;
}
// Signout and move to unauthorized page
if (toState.name == pipAuthState.signoutState()) {
event.preventDefault();
pipSession.signout();
pipAuthState.goToUnauthorized({});
return;
}
// Move user to authorized page
if (toState.name == pipAuthState.unauthorizedState()
&& pipSession.opened()) {
event.preventDefault();
pipAuthState.goToAuthorized({});
return;
}
}
function unauthorizedRedirect(event, params) {
pipSession.close();
pipAuthState.goToSignin(params);
}
function maintenanceError(event, params) {
pipAuthState.goToErrors('errors_maintenance', params);
}
function noConnectionError(event, params) {
pipAuthState.goToErrors('errors_no_connection', params);
}
function missingRouteError(event, params) {
pipAuthState.goToErrors('errors_missing_route', params);
}
function unknownError(event, params) {
pipAuthState.goToErrors('errors_unknown', params);
}
}]
);
thisModule.factory('pipAuthHttpResponseInterceptor',
['$q', '$location', '$rootScope', function ($q, $location, $rootScope) {
return {
response: function (response) {
// When server sends Non-authenticated response
if (response.status === 401) {
console.error("Response 401");
}
return response || $q.when(response);
},
responseError: function (rejection) {
var toState = $rootScope.$state && $rootScope.$state.name ? $rootScope.$state.name : null,
toParams = $rootScope.$state && $rootScope.$state.params ? $rootScope.$state.params : null;
// When server sends Non-authenticated response
switch (rejection.status) {
case 401:
case 440:
console.error("Response Error 401", rejection);
// Redirect to unauthorized state
$rootScope.$emit('pipUnauthorizedRedirect', {
redirect_to: toState && toParams && toParams.redirect_to ? '': $location.url(),
toState: toState,
toParams: toParams
});
break;
case 503:
//available (maintenance)
$rootScope.$emit('pipMaintenanceError', {
error: rejection
});
console.error("errors_maintenance", rejection);
break;
case -1:
if (!$rootScope.$user || !$rootScope.$party)
$rootScope.$emit('pipNoConnectionError', {
error: rejection
});
console.error("errors_no_connection", rejection);
break;
default:
// unhandled error (internal)
//var code = rejection.code || (rejection.data || {}).code || null;
//
//// if not our server error generate errorEvent
//if (!code) {
// $rootScope.$emit('pipUnknownError', {
// error: rejection
// });
//}
console.error("errors_unknown", rejection);
break;
}
return $q.reject(rejection);
}
}
}]
);
thisModule.provider('pipAuthState', ['pipStateProvider', function(pipStateProvider) {
// Configuration of redirected states
userResolver.$inject = ['pipSessionCache'];
partyResolver.$inject = ['pipSessionCache', '$stateParams'];
connectionResolver.$inject = ['pipSessionCache', '$stateParams'];
settingsResolver.$inject = ['pipSessionCache'];
var
signinState = null,
signoutState = null,
authorizedState = '/',
unauthorizedState = '/';
this.signinState = setSigninState;
this.signoutState = setSignoutState;
this.authorizedState = setAuthorizedState;
this.unauthorizedState = setUnauthorizedState;
this.redirect = pipStateProvider.redirect;
this.state = stateOverride;
this.$get = ['pipState', function (pipState) {
pipState.signinState = function() { return signinState; };
pipState.signoutState = function() { return signoutState; };
pipState.authorizedState = function() { return authorizedState; };
pipState.unauthorizedState = function() { return unauthorizedState; };
pipState.goToErrors = function(toState, params) {
if (toState == null)
throw new Error('Error state was not defined');
pipState.go(toState, params);
};
pipState.goToSignin = function(params) {
if (signinState == null)
throw new Error('Signin state was not defined');
pipState.go(signinState, params);
};
pipState.goToSignout = function(params) {
if (signoutState == null)
throw new Error('Signout state was not defined');
pipState.go(signoutState, params);
};
pipState.goToAuthorized = function(params) {
if (authorizedState == null)
throw new Error('Authorized state was not defined');
pipState.go(authorizedState, params);
};
pipState.goToUnauthorized = function(params) {
if (unauthorizedState == null)
throw new Error('Unauthorized state was not defined');
pipState.go(unauthorizedState, params);
};
return pipState;
}];
return;
//--------------------------------
function setSigninState(newSigninState) {
if (newSigninState)
signinState = newSigninState;
return signinState;
}
function setSignoutState(newSignoutState) {
if (newSignoutState)
signoutState = newSignoutState;
return signoutState;
}
function setAuthorizedState(newAuthorizedState) {
if (newAuthorizedState)
authorizedState = newAuthorizedState;
return authorizedState;
}
function setUnauthorizedState(newUnauthorizedState) {
if (newUnauthorizedState)
unauthorizedState = newUnauthorizedState;
return unauthorizedState;
}
// Overriding state configuration in ui-router to add auth resolves
function stateOverride(stateName, stateConfig) {
if (stateName == null)
throw new Error('stateName cannot be null');
if (stateConfig == null)
throw new Error('stateConfig cannot be null');
// todo apply in all tool
if (stateConfig.auth || stateConfig.authenticate) {
stateConfig.resolve = stateConfig.resolve || {};
stateConfig.resolve.user = /* @ngInject */ userResolver;
stateConfig.resolve.party = /* @ngInject */ partyResolver;
stateConfig.resolve.connection = /* @ngInject */ connectionResolver;
stateConfig.resolve.setting = /* @ngInject */ settingsResolver;
}
pipStateProvider.state(stateName, stateConfig);
return this;
}
function userResolver(pipSessionCache) {
return pipSessionCache.readUser();
}
function partyResolver(pipSessionCache, $stateParams) {
return pipSessionCache.readParty($stateParams);
}
function connectionResolver(pipSessionCache, $stateParams) {
return pipSessionCache.readConnection($stateParams);
}
function settingsResolver(pipSessionCache) {
return pipSessionCache.readSettings();
}
}]);
})();
/**
* @file Rest API enumerations service
* @copyright Digital Living Software Corp. 2014-2016
*/
/* global _, angular */
(function () {
'use strict';
var thisModule = angular.module('pipRest.Enums', []);
thisModule.factory('pipEnums', function () {
var enums = {};
// Converts enumeration values to string array
function enumToArray(obj) {
var result = [];
for (var key in obj)
if (obj.hasOwnProperty(key))
result.push(obj[key]);
return result;
};
enums.SHARE_LEVEL = {
WORLD: 0, // Everyone
OUTER: 1, // Familiar
INNER: 2, // Trusted
PRIVATE: 3 // Private
};
enums.URGENCY = {
LOW: 1,
NORMAL: 500,
HIGH: 1000,
MIN: 0,
MAX: 1000
};
enums.URGENCIES = enumToArray(enums.URGENCY);
enums.IMPORTANCE = {
LOW: 1,
NORMAL: 500,
HIGH: 1000,
MIN: 0,
MAX: 1000
};
enums.IMPORTANCES = enumToArray(enums.IMPORTANCE);
enums.CONFIDENTIALITY = {
PUBLIC: 0, // No sharing restrictions level - ANY, groups = yes, parties = yes
SENSITIVE: 1, // No public sharing - level >= OUTER, groups = yes, parties = yes
CLASSIFIED: 2, // Only selected parties - level = PRIVATE, groups = yes, parties = yes
SECRET: 3 // No sharing - level = PRIVATE, groups = no, parties = no
};
enums.CONFIDENTIALITIES = enumToArray(enums.CONFIDENTIALITY);
enums.LEVEL = {
NONE: 0,
LOW: 1,
LOW_MEDIUM: 250,
MEDIUM: 500,
MEDIUM_HIGH: 750,
HIGH: 1000,
MIN: 0,
MAX: 1000
};
enums.LANGUAGE = {
ENGLISH: 'en',
SPANISH: 'es',
PORTUGUESE: 'pt',
FRENCH: 'fr',
GERMAN: 'de',
RUSSIAN: 'ru'
};
enums.LANGUAGES = enumToArray(enums.LANGUAGE);
enums.STAT_TYPE = {
DAILY: 'daily',
MONTHLY: 'monthly',
YEARLY: 'yearly',
TOTAL: 'total'
};
enums.STAT_TYPES = enumToArray(enums.STAT_TYPE);
enums.STAT_BATCH_OPERATION = {
RECORD_SYSTEM_STATS: 'record system stats',
RECORD_PARTY_STATS: 'record party stats'
};
enums.SERVER_TYPE = {
REALTIME_DB: 'r/t db master',
HISTORIAN_DB: 'db slave',
ANALYTICS: 'analytics',
BUSINESS_LOGIC: 'business logic',
REST_API: 'rest api',
STATIC_CONTENT: 'static content',
BACKUP_STORAGE: 'backup storage'
};
enums.SERVER_TYPES = enumToArray(enums.SERVER_TYPE);
enums.SYSTEM_LOG_TYPE = {
INFO: 'info',
STOP: 'stop',
START: 'start',
RESTART: 'restart',
UPGRADE: 'upgrade',
MAINTENANCE: 'maintenance',
WARNING: 'warning',
ERROR: 'error'
};
enums.SYSTEM_LOG_TYPES = enumToArray(enums.SYSTEM_LOG_TYPE);
enums.ACTIVITY_TYPE = {
SIGNUP: 'signup',
SIGNIN: 'signin',
PASSWORD_CHANGED: 'password changed',
PWD_RECOVERED: 'pwd recovered',
EMAIL_VERIFIED: 'email verified',
SETTINGS_CHANGED: 'settings changed',
PARTNERED: 'partnered',
TEAMED_UP: 'teamed up',
FOLLOWED: 'followed',
DISCONNECTED: 'disconnected',
CREATED: 'created',
UPDATED: 'updated',
DELETED: 'deleted',
ACCEPTED: 'accepted',
REJECTED: 'rejected',
JOINED: 'joined',
COMPLETED: 'completed',
CANCELED: 'canceled',
PROGRESS: 'progress',