| /** |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| */ |
| 'use strict'; |
| |
| AppServices.Services.factory('ug', function(configuration, $rootScope, utility, |
| $q, $http, $resource, $log, $location) { |
| |
| var requestTimes = [], |
| running = false, |
| currentRequests = {}; |
| |
| function reportError(data, config) { |
| console.error(data) |
| }; |
| var getAccessToken = function() { |
| return sessionStorage.getItem('accessToken'); |
| }; |
| |
| return { |
| get: function(prop, isObject) { |
| return isObject ? this.client().getObject(prop) : this.client().get( |
| prop); |
| }, |
| set: function(prop, value) { |
| this.client().set(prop, value); |
| |
| }, |
| getUrls: function(qs) { |
| var host = $location.host(); |
| var BASE_URL = ''; |
| var DATA_URL = ''; |
| var use_sso = false; |
| switch (true) { |
| case host === 'usergrid.dev': |
| //development |
| DATA_URL = 'https://api.usergrid.com'; |
| break; |
| default: |
| DATA_URL = Usergrid.overrideUrl; |
| break; |
| } |
| //override with querystring |
| DATA_URL = qs['api_url'] || DATA_URL; |
| DATA_URL = DATA_URL.lastIndexOf('/') === DATA_URL.length - 1 ? DATA_URL.substring(0,DATA_URL.length-1) : DATA_URL; |
| return { |
| DATA_URL: DATA_URL, |
| LOGIN_URL: BASE_URL + '/accounts/sign_in', |
| PROFILE_URL: BASE_URL + '/accounts/my_account', |
| LOGOUT_URL: BASE_URL + '/accounts/sign_out', |
| apiUrl: DATA_URL, |
| use_sso: use_sso |
| }; |
| }, |
| orgLogin: function(username, password) { |
| var self = this; |
| this.client().set('email', username); |
| this.client().set('token', null); |
| this.client().orgLogin(username, password, function(err, data, user, |
| organizations, applications) { |
| if (err) { |
| $rootScope.$broadcast('loginFailed', err, data); |
| } else { |
| self.initializeCurrentUser(function() { |
| $rootScope.$broadcast('loginSuccesful', user, organizations, |
| applications); |
| }); |
| } |
| }); |
| }, |
| checkAuthentication: function(force) { |
| var ug = this; |
| var client = ug.client(); |
| |
| var initialize = function() { |
| ug.initializeCurrentUser(function() { |
| $rootScope.userEmail = client.get('email'); |
| $rootScope.organizations = client.getObject('organizations'); |
| $rootScope.applications = client.getObject('applications'); |
| $rootScope.currentOrg = client.get('orgName'); |
| $rootScope.currentApp = client.get('appName'); |
| var size = 0, |
| key; |
| for (key in $rootScope.applications) { |
| if ($rootScope.applications.hasOwnProperty(key)) size++; |
| } |
| $rootScope.$broadcast('checkAuthentication-success', client.getObject( |
| 'organizations'), client.getObject('applications'), client.get( |
| 'orgName'), client.get('appName'), client.get('email')); |
| }); |
| }, |
| isAuthenticated = function() { |
| var authenticated = client.get('token') !== null && client.get( |
| 'organizations') !== null; |
| if (authenticated) { |
| initialize(); |
| } |
| return authenticated; |
| }; |
| if (!isAuthenticated() || force) { |
| if (!client.get('token')) { |
| return $rootScope.$broadcast('checkAuthentication-error', |
| 'no token', {}, client.get('email')); |
| } |
| this.client().reAuthenticateLite(function(err) { |
| var missingData = err || (!client.get('orgName') || !client.get( |
| 'appName') || !client.getObject('organizations') || !client |
| .getObject('applications')); |
| var email = client.get('email'); |
| if (err || missingData) { |
| $rootScope.$broadcast('checkAuthentication-error', err, |
| missingData, email); |
| } else { |
| initialize(); |
| } |
| }); |
| } |
| }, |
| reAuthenticate: function(email, eventOveride) { |
| var ug = this; |
| this.client().reAuthenticate(email, function(err, data, user, |
| organizations, applications) { |
| if (!err) { |
| $rootScope.currentUser = user; |
| } |
| if (!err) { |
| $rootScope.userEmail = user.get('email'); |
| $rootScope.organizations = organizations; |
| $rootScope.applications = applications; |
| $rootScope.currentOrg = ug.get('orgName'); |
| $rootScope.currentApp = ug.get('appName'); |
| $rootScope.currentUser = data; |
| $rootScope.currentUser.profileImg = utility.get_gravatar( |
| $rootScope.currentUser.email); |
| } |
| $rootScope.$broadcast((eventOveride || 'reAuthenticate') + '-' + ( |
| err ? 'error' : 'success'), err, data, user, organizations, |
| applications); |
| |
| }); |
| }, |
| logoutCallback: function() { |
| $rootScope.$broadcast('userNotAuthenticated'); |
| }, |
| logout: function() { |
| $rootScope.activeUI = false; |
| $rootScope.userEmail = 'user@apigee.com'; |
| $rootScope.organizations = { |
| "noOrg": { |
| name: "No Orgs Found" |
| } |
| }; |
| $rootScope.applications = { |
| "noApp": { |
| name: "No Apps Found" |
| } |
| }; |
| $rootScope.currentOrg = 'No Org Found'; |
| $rootScope.currentApp = 'No App Found'; |
| sessionStorage.setItem('accessToken', null); |
| sessionStorage.setItem('userUUID', null); |
| sessionStorage.setItem('userEmail', null); |
| |
| this.client().logout(); |
| this._client = null; |
| }, |
| client: function() { |
| var options = { |
| buildCurl: Usergrid.options.client.buildCurl || false, |
| logging: Usergrid.options.client.logging || false |
| }; |
| if (Usergrid.options && Usergrid.options.client) { |
| options.keys = Usergrid.options.client; |
| } |
| |
| this._client = this._client || new Usergrid.Client(options, |
| $rootScope.urls().DATA_URL |
| ); |
| return this._client; |
| }, |
| setClientProperty: function(key, value) { |
| this.client().set(key, value); |
| }, |
| getTopCollections: function() { |
| var options = { |
| method: 'GET', |
| endpoint: '' |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error getting collections'); |
| } else { |
| var collections = data.entities[0].metadata.collections; |
| $rootScope.$broadcast('top-collections-received', collections); |
| } |
| }); |
| }, |
| createCollection: function(collectionName) { |
| var collections = {}; |
| collections[collectionName] = {}; |
| var metadata = { |
| metadata: { |
| collections: collections |
| } |
| } |
| var options = { |
| method: 'PUT', |
| body: metadata, |
| endpoint: '' |
| } |
| var self = this; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| console.error(err); |
| return $rootScope.$broadcast('alert', 'error', |
| 'error creating collection'); |
| } |
| self.client().createEntity({ |
| type: collectionName, |
| testData: 'test' |
| }, function(err, entity) { |
| if (err) { |
| console.error(err); |
| return $rootScope.$broadcast('alert', 'error', |
| 'error creating collection'); |
| } |
| entity.destroy(function() { |
| self.getTopCollections(function(err, collections) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error creating collection'); |
| } else { |
| $rootScope.$broadcast('collection-created', |
| collections); |
| } |
| }); |
| }); |
| |
| }) |
| |
| |
| }); |
| }, |
| createCollectionWithEntity: function(collectionName, entityData) { |
| try{ |
| entityData=JSON.parse(entityData); |
| }catch(e){ |
| $rootScope.$broadcast('alert', 'error', 'JSON is not valid'); |
| return; |
| } |
| var options = { |
| method: 'POST', |
| endpoint: collectionName, |
| body: entityData |
| } |
| var self = this; |
| self.client().request(options, function(err, entity) { |
| if (err) { |
| console.error(err); |
| return $rootScope.$broadcast('alert', 'error', |
| 'error creating collection'); |
| } |
| self.getTopCollections(function(err, collections) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error creating collection'); |
| } else { |
| $rootScope.$broadcast('alert', 'success', 'Collection created successfully.'); |
| $rootScope.$broadcast('collection-created', |
| collections); |
| } |
| }); |
| }); |
| }, |
| getApplications: function() { |
| this.client().getApplications(function(err, applications) { |
| if (err) { |
| applications && console.error(applications); |
| } else { |
| $rootScope.$broadcast('applications-received', applications); |
| } |
| }); |
| }, |
| getAdministrators: function() { |
| this.client().getAdministrators(function(err, administrators) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error getting administrators'); |
| } |
| $rootScope.$broadcast('administrators-received', administrators); |
| }); |
| }, |
| createApplication: function(appName) { |
| this.client().createApplication(appName, function(err, applications) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error creating application'); |
| } else { |
| $rootScope.$broadcast('applications-created', applications, |
| appName); |
| $rootScope.$broadcast('applications-received', applications); |
| } |
| }); |
| }, |
| createAdministrator: function(adminName) { |
| this.client().createAdministrator(adminName, function(err, |
| administrators) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error creating administrator'); |
| } |
| $rootScope.$broadcast('administrators-received', administrators); |
| }); |
| }, |
| getFeed: function() { |
| var options = { |
| method: 'GET', |
| endpoint: 'management/organizations/' + this.client().get('orgName') + |
| '/feed', |
| mQuery: true |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error getting feed'); |
| } else { |
| var feedData = data.entities; |
| var feed = []; |
| var i = 0; |
| for (i = 0; i < feedData.length; i++) { |
| var date = (new Date(feedData[i].created)).toUTCString(); |
| |
| var title = feedData[i].title; |
| |
| var n = title.indexOf(">"); |
| title = title.substring(n + 1, title.length); |
| |
| n = title.indexOf(">"); |
| title = title.substring(n + 1, title.length); |
| |
| if (feedData[i].actor) { |
| title = feedData[i].actor.displayName + ' ' + title; |
| } |
| feed.push({ |
| date: date, |
| title: title |
| }); |
| } |
| if (i === 0) { |
| feed.push({ |
| date: "", |
| title: "No Activities found." |
| }); |
| } |
| |
| $rootScope.$broadcast('feed-received', feed); |
| } |
| }); |
| |
| }, |
| createGroup: function(path, title) { |
| var options = { |
| path: path, |
| title: title |
| } |
| var self = this; |
| this.groupsCollection.addEntity(options, function(err) { |
| if (err) { |
| $rootScope.$broadcast('groups-create-error', err); |
| } else { |
| $rootScope.$broadcast('groups-create-success', self.groupsCollection); |
| $rootScope.$broadcast('groups-received', self.groupsCollection); |
| } |
| }); |
| }, |
| createRole: function(name, title) { |
| var options = { |
| name: name, |
| title: title |
| }, |
| self = this; |
| this.rolesCollection.addEntity(options, function(err) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error creating role'); |
| } else { |
| $rootScope.$broadcast('roles-received', self.rolesCollection); |
| } |
| }); |
| }, |
| createUser: function(username, name, email, password) { |
| var options = { |
| username: username, |
| name: name, |
| email: email, |
| password: password |
| } |
| var self = this; |
| this.usersCollection.addEntity(options, function(err, data) { |
| if (err) { |
| if (typeof data === 'string') { |
| $rootScope.$broadcast("alert", "error", "error: " + data); |
| } else { |
| $rootScope.$broadcast("alert", "error", |
| "error creating user. the email address might already exist." |
| ); |
| } |
| } else { |
| $rootScope.$broadcast('users-create-success', self.usersCollection); |
| |
| $rootScope.$broadcast('users-received', self.usersCollection); |
| } |
| }); |
| }, |
| getCollection: function(type, path, orderBy, query, limit) { |
| var options = { |
| type: path, |
| qs: {} |
| } |
| if (query) { |
| options.qs['ql'] = query; |
| } |
| |
| //force order by 'created desc' if none exists |
| if (options.qs.ql) { |
| options.qs['ql'] = options.qs.ql + ' order by ' + (orderBy || |
| 'created desc'); |
| } else { |
| options.qs['ql'] = ' order by ' + (orderBy || 'created desc'); |
| } |
| |
| if (limit) { |
| options.qs['limit'] = limit; |
| } |
| this.client().createCollection(options, function(err, collection, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error getting ' + |
| collection._type + ': ' + data.error_description); |
| $rootScope.$broadcast(type + '-error', collection); |
| } else { |
| $rootScope.$broadcast(type + '-received', collection); |
| } |
| //temporarily adding scope.apply to get working in prod, otherwise the events won't get broadcast |
| //todo - we need an apply strategy for 3rd party ug calls! |
| if (!$rootScope.$$phase) { |
| $rootScope.$apply(); |
| } |
| }); |
| }, |
| runDataQuery: function(queryPath, searchString, queryLimit) { |
| this.getCollection('query', queryPath, null, searchString, queryLimit); |
| }, |
| runDataPOSTQuery: function(queryPath, body) { |
| var self = this; |
| var options = { |
| method: 'POST', |
| endpoint: queryPath, |
| body: body |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error: ' + data.error_description); |
| $rootScope.$broadcast('error-running-query', data); |
| } else { |
| |
| var queryPath = data.path; |
| //remove preceeding slash |
| queryPath = queryPath.replace(/^\//, ''); |
| self.getCollection('query', queryPath, null, 'order by modified DESC', null); |
| |
| } |
| }); |
| }, |
| runDataPutQuery: function(queryPath, searchString, queryLimit, body) { |
| var self = this; |
| var options = { |
| method: 'PUT', |
| endpoint: queryPath, |
| body: body |
| }; |
| |
| if (searchString) { |
| options.qs['ql'] = searchString; |
| } |
| if (queryLimit) { |
| options.qs['queryLimit'] = queryLimit; |
| } |
| |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error: ' + data.error_description); |
| } else { |
| |
| var queryPath = data.path; |
| self.getCollection('query', queryPath, null, |
| 'order by modified DESC', null); |
| |
| } |
| }); |
| }, |
| runDataDeleteQuery: function(queryPath, searchString, queryLimit) { |
| var self = this; |
| var options = { |
| method: 'DELETE', |
| endpoint: queryPath |
| }; |
| |
| if (searchString) { |
| options.qs['ql'] = searchString; |
| } |
| if (queryLimit) { |
| options.qs['queryLimit'] = queryLimit; |
| } |
| |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error: ' + data.error_description); |
| } else { |
| |
| var queryPath = data.path; |
| self.getCollection('query', queryPath, null, |
| 'order by modified DESC', null); |
| |
| } |
| }); |
| }, |
| getUsers: function() { |
| this.getCollection('users', 'users', 'username'); |
| var self = this; |
| $rootScope.$on("users-received", function(evt, users) { |
| self.usersCollection = users; |
| }) |
| }, |
| getGroups: function() { |
| this.getCollection('groups', 'groups', 'title'); |
| var self = this; |
| $rootScope.$on('groups-received', function(event, roles) { |
| self.groupsCollection = roles; |
| }); |
| |
| }, |
| getRoles: function() { |
| this.getCollection('roles', 'roles', 'name'); |
| var self = this; |
| $rootScope.$on('roles-received', function(event, roles) { |
| self.rolesCollection = roles |
| }); |
| }, |
| getNotifiers: function() { |
| var query = '', |
| limit = '100', |
| self = this; |
| this.getCollection('notifiers', 'notifiers', 'created', query, limit); |
| $rootScope.$on('notifiers-received', function(event, notifiers) { |
| self.notifiersCollection = notifiers; |
| }); |
| }, |
| getNotificationHistory: function(type) { |
| var query = null; |
| if (type) { |
| query = "select * where state = '" + type + "'"; |
| } |
| this.getCollection('notifications', 'notifications', 'created desc', |
| query); |
| var self = this; |
| $rootScope.$on('notifications-received', function(event, notifications) { |
| self.notificationCollection = notifications; |
| }); |
| }, |
| getNotificationReceipts: function(uuid) { |
| this.getCollection('receipts', 'receipts', 'created desc', |
| 'notificationUUID=' + uuid); |
| var self = this; |
| $rootScope.$on('receipts-received', function(event, receipts) { |
| self.receiptsCollection = receipts; |
| }); |
| }, |
| getIndexes: function(path) { |
| var options = { |
| method: 'GET', |
| endpoint: path.split('/').concat('indexes').filter(function(bit) { |
| return bit && bit.length |
| }).join('/') |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Problem getting indexes: ' + data.error); |
| } else { |
| $rootScope.$broadcast('indexes-received', data.data); |
| } |
| }); |
| }, |
| sendNotification: function(path, body) { |
| var options = { |
| method: 'POST', |
| endpoint: path, |
| body: body |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Problem creating notification: ' + data.error); |
| } else { |
| $rootScope.$broadcast('send-notification-complete'); |
| } |
| }); |
| }, |
| getRolesUsers: function(username) { |
| var self = this; |
| var options = { |
| type: 'roles/users/' + username, |
| qs: { |
| ql: 'order by username' |
| } |
| } |
| this.client().createCollection(options, function(err, users) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error getting users'); |
| } else { |
| $rootScope.$broadcast('users-received', users); |
| |
| } |
| }); |
| }, |
| getTypeAheadData: function(type, searchString, searchBy, orderBy) { |
| |
| var self = this; |
| var search = ''; |
| var qs = { |
| limit: 100 |
| }; |
| if (searchString) { |
| search = "select * where " + searchBy + " = '" + searchString + "'"; |
| } |
| if (orderBy) { |
| search = search + " order by " + orderBy; |
| } |
| if (search) { |
| qs.ql = search; |
| } |
| var options = { |
| method: 'GET', |
| endpoint: type, |
| qs: qs |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error getting ' + type); |
| } else { |
| var entities = data.entities; |
| $rootScope.$broadcast(type + '-typeahead-received', entities); |
| } |
| }); |
| }, |
| getUsersTypeAhead: function(searchString) { |
| this.getTypeAheadData('users', searchString, 'username', 'username'); |
| }, |
| getGroupsTypeAhead: function(searchString) { |
| this.getTypeAheadData('groups', searchString, 'path', 'path'); |
| }, |
| getRolesTypeAhead: function(searchString) { |
| this.getTypeAheadData('roles', searchString, 'name', 'name'); |
| }, |
| getGroupsForUser: function(user) { |
| var self = this; |
| var options = { |
| type: 'users/' + user + '/groups' |
| } |
| this.client().createCollection(options, function(err, groups) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error getting groups'); |
| } else { |
| |
| $rootScope.$broadcast('user-groups-received', groups); |
| |
| } |
| }); |
| }, |
| addUserToGroup: function(user, group) { |
| var self = this; |
| var options = { |
| type: 'users/' + user + '/groups/' + group |
| } |
| this.client().createEntity(options, function(err, entity) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error adding user to group'); |
| } else { |
| $rootScope.$broadcast('user-added-to-group-received'); |
| } |
| }); |
| }, |
| addUserToRole: function(user, role) { |
| var options = { |
| method: 'POST', |
| endpoint: 'roles/' + role + '/users/' + user |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error adding user to role'); |
| } else { |
| $rootScope.$broadcast('role-update-received'); |
| } |
| }); |
| }, |
| addGroupToRole: function(group, role) { |
| var options = { |
| method: 'POST', |
| endpoint: 'roles/' + role + '/groups/' + group |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error adding group to role'); |
| } else { |
| $rootScope.$broadcast('role-update-received'); |
| } |
| }); |
| }, |
| followUser: function(user) { |
| var self = this; |
| var username = $rootScope.selectedUser.get('uuid'); |
| var options = { |
| method: 'POST', |
| endpoint: 'users/' + username + '/following/users/' + user |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error following user'); |
| } else { |
| $rootScope.$broadcast('follow-user-received'); |
| } |
| }); |
| }, |
| newPermission: function(permission, type, entity) { //"get,post,put:/mypermission" |
| var options = { |
| method: 'POST', |
| endpoint: type + '/' + entity + '/permissions', |
| body: { |
| "permission": permission |
| } |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'error adding permission'); |
| } else { |
| $rootScope.$broadcast('permission-update-received'); |
| } |
| }); |
| }, |
| newUserPermission: function(permission, username) { |
| this.newPermission(permission, 'users', username) |
| }, |
| newGroupPermission: function(permission, path) { |
| this.newPermission(permission, 'groups', path) |
| }, |
| newRolePermission: function(permission, name) { |
| this.newPermission(permission, 'roles', name) |
| }, |
| |
| deletePermission: function(permission, type, entity) { //"get,post,put:/mypermission" |
| var options = { |
| method: 'DELETE', |
| endpoint: type + '/' + entity + '/permissions', |
| qs: { |
| permission: permission |
| } |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error deleting permission'); |
| } else { |
| $rootScope.$broadcast('permission-update-received'); |
| } |
| }); |
| }, |
| deleteUserPermission: function(permission, user) { |
| this.deletePermission(permission, 'users', user); |
| }, |
| deleteGroupPermission: function(permission, group) { |
| this.deletePermission(permission, 'groups', group); |
| }, |
| deleteRolePermission: function(permission, rolename) { |
| this.deletePermission(permission, 'roles', rolename); |
| }, |
| removeUserFromRole: function(user, role) { //"get,post,put:/mypermission" |
| var options = { |
| method: 'DELETE', |
| endpoint: 'roles/' + role + '/users/' + user |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error removing user from role'); |
| } else { |
| $rootScope.$broadcast('role-update-received'); |
| } |
| }); |
| }, |
| removeUserFromGroup: function(group, role) { //"get,post,put:/mypermission" |
| var options = { |
| method: 'DELETE', |
| endpoint: 'roles/' + role + '/groups/' + group |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', |
| 'error removing role from the group'); |
| } else { |
| $rootScope.$broadcast('role-update-received'); |
| } |
| }); |
| }, |
| createWinNotifier: function(name,sid,apiKey, logging){ |
| var options = { |
| method: 'POST', |
| endpoint: 'notifiers', |
| body: { |
| "sid": sid, |
| "apiKey": apiKey, |
| "name": name, |
| "logging": logging, |
| "provider": "windows" |
| } |
| }; |
| this.client().request(options, this.notifierResponseReceived); |
| }, |
| createAndroidNotifier: function(name, APIkey) { |
| var options = { |
| method: 'POST', |
| endpoint: 'notifiers', |
| body: { |
| "apiKey": APIkey, |
| "name": name, |
| "provider": "google" |
| } |
| }; |
| this.client().request(options, this.notifierResponseReceived); |
| }, |
| createAppleNotifier: function(file, name, environment, |
| certificatePassword) { |
| |
| var provider = 'apple'; |
| |
| var formData = new FormData(); |
| formData.append("p12Certificate", file); |
| |
| formData.append('name', name); |
| formData.append('provider', provider); |
| formData.append('environment', environment); |
| formData.append('certificatePassword', certificatePassword || ""); |
| |
| var options = { |
| method: 'POST', |
| endpoint: 'notifiers', |
| formData: formData |
| }; |
| this.client().request(options, this.notifierResponseReceived); |
| }, |
| notifierResponseReceived:function(err, data) { |
| if (err) { |
| console.error(data); |
| $rootScope.$broadcast('alert', 'error', data.error_description || 'error creating notifier'); |
| } else { |
| $rootScope.$broadcast('alert', 'success', |
| 'New notifier created successfully.'); |
| $rootScope.$broadcast('notifier-update'); |
| } |
| }, |
| initializeCurrentUser: function(callback) { |
| callback = callback || function() {}; |
| if ($rootScope.currentUser && !$rootScope.currentUser.reset) { |
| callback($rootScope.currentUser); |
| return $rootScope.$broadcast('current-user-initialized', ''); |
| } |
| var options = { |
| method: 'GET', |
| endpoint: 'management/users/' + this.client().get('email'), |
| mQuery: true |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('alert', 'error', 'Error getting user info'); |
| } else { |
| $rootScope.currentUser = data.data; |
| $rootScope.currentUser.profileImg = utility.get_gravatar( |
| $rootScope.currentUser.email); |
| $rootScope.userEmail = $rootScope.currentUser.email; |
| callback($rootScope.currentUser); |
| $rootScope.$broadcast('current-user-initialized', $rootScope.currentUser); |
| } |
| }); |
| }, |
| |
| updateUser: function(user) { |
| var body = {}; |
| body.username = user.username; |
| body.name = user.name; |
| body.email = user.email; |
| var options = { |
| method: 'PUT', |
| endpoint: 'management/users/' + user.uuid + '/', |
| mQuery: true, |
| body: body |
| }; |
| var self = this; |
| this.client().request(options, function(err, data) { |
| self.client().set('email', user.email); |
| self.client().set('username', user.username); |
| if (err) { |
| return $rootScope.$broadcast('user-update-error', data); |
| } |
| $rootScope.currentUser.reset = true; |
| self.initializeCurrentUser(function() { |
| $rootScope.$broadcast('user-update-success', $rootScope.currentUser); |
| }); |
| }); |
| }, |
| |
| resetUserPassword: function(user) { |
| var body = {}; |
| body.oldpassword = user.oldPassword; |
| body.newpassword = user.newPassword; |
| body.username = user.username; |
| var options = { |
| method: 'PUT', |
| endpoint: 'management/users/' + user.uuid + '/', |
| body: body, |
| mQuery: true |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| return $rootScope.$broadcast('alert', 'error', |
| 'Error resetting password'); |
| } |
| //remove old and new password fields so they don't end up as part of the entity object |
| $rootScope.currentUser.oldPassword = ''; |
| $rootScope.currentUser.newPassword = ''; |
| $rootScope.$broadcast('user-reset-password-success', $rootScope.currentUser); |
| }); |
| |
| }, |
| getOrgCredentials: function() { |
| var options = { |
| method: 'GET', |
| endpoint: 'management/organizations/' + this.client().get('orgName') + |
| '/credentials', |
| mQuery: true |
| }; |
| this.client().request(options, function(err, data) { |
| if (err && data.credentials) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Error getting credentials'); |
| } else { |
| $rootScope.$broadcast('org-creds-updated', data.credentials); |
| } |
| }); |
| }, |
| regenerateOrgCredentials: function() { |
| var self = this; |
| var options = { |
| method: 'POST', |
| endpoint: 'management/organizations/' + this.client().get('orgName') + |
| '/credentials', |
| mQuery: true |
| }; |
| this.client().request(options, function(err, data) { |
| if (err && data.credentials) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Error regenerating credentials'); |
| } else { |
| $rootScope.$broadcast('alert', 'success', |
| 'Regeneration of credentials complete.'); |
| $rootScope.$broadcast('org-creds-updated', data.credentials); |
| } |
| }); |
| }, |
| getAppCredentials: function() { |
| var options = { |
| method: 'GET', |
| endpoint: 'credentials' |
| }; |
| this.client().request(options, function(err, data) { |
| if (err && data.credentials) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Error getting credentials'); |
| } else { |
| $rootScope.$broadcast('app-creds-updated', data.credentials); |
| } |
| }); |
| }, |
| |
| regenerateAppCredentials: function() { |
| var self = this; |
| var options = { |
| method: 'POST', |
| endpoint: 'credentials' |
| }; |
| this.client().request(options, function(err, data) { |
| if (err && data.credentials) { |
| $rootScope.$broadcast('alert', 'error', |
| 'Error regenerating credentials'); |
| } else { |
| $rootScope.$broadcast('alert', 'success', |
| 'Regeneration of credentials complete.'); |
| $rootScope.$broadcast('app-creds-updated', data.credentials); |
| } |
| }); |
| }, |
| |
| signUpUser: function(orgName, userName, name, email, password) { |
| var formData = { |
| "organization": orgName, |
| "username": userName, |
| "name": name, |
| "email": email, |
| "password": password |
| }; |
| var options = { |
| method: 'POST', |
| endpoint: 'management/organizations', |
| body: formData, |
| mQuery: true |
| }; |
| var client = this.client(); |
| client.request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('register-error', data); |
| } else { |
| $rootScope.$broadcast('register-success', data); |
| } |
| }); |
| }, |
| resendActivationLink: function(id) { |
| var options = { |
| method: 'GET', |
| endpoint: 'management/users/' + id + '/reactivate', |
| mQuery: true |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('resend-activate-error', data); |
| } else { |
| $rootScope.$broadcast('resend-activate-success', data); |
| } |
| }); |
| }, |
| getAppSettings: function() { |
| $rootScope.$broadcast('app-settings-received', {}); |
| }, |
| getActivities: function() { |
| this.client().request({ |
| method: 'GET', |
| endpoint: 'activities', |
| qs: { |
| limit: 200 |
| } |
| }, function(err, data) { |
| if (err) return $rootScope.$broadcast('app-activities-error', data); |
| var entities = data.entities; |
| //set picture if there is none and change gravatar to secure |
| entities.forEach(function(entity) { |
| if (!entity.actor.picture) { |
| entity.actor.picture = window.location.protocol + "//" + |
| window.location.host + window.location.pathname + |
| "img/user_profile.png" |
| } else { |
| entity.actor.picture = entity.actor.picture.replace( |
| /^http:\/\/www.gravatar/i, 'https://secure.gravatar'); |
| //note: changing this to use the image on apigee.com - since the gravatar default won't work on any non-public domains such as localhost |
| //this_data.picture = this_data.picture + encodeURI("?d="+window.location.protocol+"//" + window.location.host + window.location.pathname + "images/user_profile.png"); |
| if (~entity.actor.picture.indexOf('http')) { |
| entity.actor.picture = entity.actor.picture; |
| } else { |
| entity.actor.picture = |
| 'https://apigee.com/usergrid/img/user_profile.png'; |
| } |
| } |
| }); |
| $rootScope.$broadcast('app-activities-received', data.entities); |
| }); |
| }, |
| getEntityActivities: function(entity, isFeed) { |
| var route = isFeed ? 'feed' : 'activities' |
| var endpoint = entity.get('type') + '/' + entity.get('uuid') + '/' + |
| route; |
| var options = { |
| method: 'GET', |
| endpoint: endpoint, |
| qs: { |
| limit: 200 |
| } |
| }; |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast(entity.get('type') + '-' + route + '-error', |
| data); |
| } |
| data.entities.forEach(function(entityInstance) { |
| entityInstance.createdDate = (new Date(entityInstance.created)) |
| .toUTCString(); |
| }); |
| $rootScope.$broadcast(entity.get('type') + '-' + route + |
| '-received', data.entities); |
| }); |
| }, |
| addUserActivity: function(user, content) { |
| var options = { |
| "actor": { |
| "displayName": user.get('username'), |
| "uuid": user.get('uuid'), |
| "username": user.get('username') |
| }, |
| "verb": "post", |
| "content": content |
| }; |
| this.client().createUserActivity(user.get('username'), options, |
| function(err, activity) { //first argument can be 'me', a uuid, or a username |
| if (err) { |
| $rootScope.$broadcast('user-activity-add-error', err); |
| } else { |
| $rootScope.$broadcast('user-activity-add-success', activity); |
| } |
| }); |
| }, |
| runShellQuery: function(method, path, payload) { |
| var path = path.replace(/^\//, ''); //remove leading slash if it does |
| var options = { |
| "method": method, |
| "endpoint": path |
| }; |
| if (payload) { |
| options["body"] = payload; |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('shell-error', data); |
| } else { |
| $rootScope.$broadcast('shell-success', data); |
| } |
| }); |
| }, |
| addOrganization: function(user, orgName) { |
| var options = { |
| method: 'POST', |
| endpoint: 'management/users/' + user.uuid + '/organizations', |
| body: { |
| organization: orgName |
| }, |
| mQuery: true |
| }, |
| client = this.client(), |
| self = this; |
| client.request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('user-add-org-error', data); |
| } else { |
| $rootScope.$broadcast('user-add-org-success', $rootScope.organizations); |
| } |
| }); |
| }, |
| leaveOrganization: function(user, org) { |
| var options = { |
| method: 'DELETE', |
| endpoint: 'management/users/' + user.uuid + '/organizations/' + org |
| .uuid, |
| mQuery: true |
| } |
| this.client().request(options, function(err, data) { |
| if (err) { |
| $rootScope.$broadcast('user-leave-org-error', data); |
| } else { |
| delete $rootScope.organizations[org.name]; |
| $rootScope.$broadcast('user-leave-org-success', $rootScope.organizations); |
| } |
| }); |
| }, |
| /** |
| * Retrieves page data |
| * @param {string} id the name of the single page item to get (a key in the JSON) can be null. |
| * @param {string} url location of the file/endpoint. |
| * @return {Promise} Resolves to JSON. |
| */ |
| httpGet: function(id, url) { |
| var items, deferred; |
| |
| deferred = $q.defer(); |
| |
| $http.get((url || configuration.ITEMS_URL)). |
| success(function(data, status, headers, config) { |
| var result; |
| if (id) { |
| angular.forEach(data, function(obj, index) { |
| if (obj.id === id) { |
| result = obj; |
| } |
| }); |
| } else { |
| result = data; |
| } |
| deferred.resolve(result); |
| }). |
| error(function(data, status, headers, config) { |
| $log.error(data, status, headers, config); |
| reportError(data, config); |
| deferred.reject(data); |
| }); |
| |
| return deferred.promise; |
| }, |
| |
| /** |
| * Retrieves page data via jsonp |
| * @param {string} url the location of the JSON/RESTful endpoint. |
| * @param {string} successCallback function called on success. |
| */ |
| |
| jsonp: function(objectType, criteriaId, params, successCallback) { |
| if (!params) { |
| params = {}; |
| } |
| params.demoApp = $rootScope.demoData; |
| params.access_token = getAccessToken(); |
| params.callback = 'JSON_CALLBACK'; |
| var uri = $rootScope.urls().DATA_URL + '/' + $rootScope.currentOrg + |
| '/' + $rootScope.currentApp + '/apm/' + objectType + '/' + criteriaId; |
| return this.jsonpRaw(objectType, criteriaId, params, uri, |
| successCallback); |
| }, |
| |
| jsonpSimple: function(objectType, appId, params) { |
| var uri = $rootScope.urls().DATA_URL + '/' + $rootScope.currentOrg + |
| '/' + $rootScope.currentApp + '/apm/' + objectType + "/" + appId; |
| return this.jsonpRaw(objectType, appId, params, uri); |
| }, |
| calculateAverageRequestTimes: function() { |
| if (!running) { |
| var self = this; |
| running = true; |
| setTimeout(function() { |
| running = false; |
| var length = requestTimes.length < 10 ? requestTimes.length : 10; |
| var sum = requestTimes.slice(0, length).reduce(function(a, b) { |
| return a + b |
| }); |
| var avg = sum / length; |
| self.averageRequestTimes = avg / 1000; |
| if (self.averageRequestTimes > 5) { |
| $rootScope.$broadcast('request-times-slow', self.averageRequestTimes); |
| } |
| }, 3000); |
| } |
| }, |
| jsonpRaw: function(objectType, appId, params, uri, successCallback) { |
| if (typeof successCallback !== 'function') { |
| successCallback = null; |
| } |
| uri = uri || ($rootScope.urls().DATA_URL + '/' + $rootScope.currentOrg + |
| '/' + $rootScope.currentApp + '/' + objectType); |
| |
| if (!params) { |
| params = {}; |
| } |
| |
| var start = new Date().getTime(), |
| self = this; |
| |
| params.access_token = getAccessToken(); |
| params.callback = 'JSON_CALLBACK'; |
| |
| var deferred = $q.defer(); |
| |
| var diff = function() { |
| currentRequests[uri]--; |
| requestTimes.splice(0, 0, new Date().getTime() - start); |
| self.calculateAverageRequestTimes(); |
| }; |
| |
| successCallback && $rootScope.$broadcast("ajax_loading", objectType); |
| var reqCount = currentRequests[uri] || 0; |
| if (self.averageRequestTimes > 5 && reqCount > 1) { |
| setTimeout(function() { |
| deferred.reject(new Error('query in progress')); |
| }, 50); |
| return deferred; |
| } |
| currentRequests[uri] = (currentRequests[uri] || 0) + 1; |
| |
| $http.jsonp(uri, { |
| params: params |
| }). |
| success(function(data, status, headers, config) { |
| diff(); |
| if (successCallback) { |
| successCallback(data, status, headers, config); |
| $rootScope.$broadcast("ajax_finished", objectType); |
| } |
| deferred.resolve(data); |
| }). |
| error(function(data, status, headers, config) { |
| diff(); |
| $log.error("ERROR: Could not get jsonp data. " + uri); |
| reportError(data, config); |
| deferred.reject(data); |
| }); |
| |
| return deferred.promise; |
| }, |
| |
| resource: function(params, isArray) { |
| //temporary url for REST endpoints |
| |
| return $resource($rootScope.urls().DATA_URL + |
| '/:orgname/:appname/:username/:endpoint', { |
| |
| }, { |
| get: { |
| method: 'JSONP', |
| isArray: isArray, |
| params: params |
| }, |
| login: { |
| method: 'GET', |
| url: $rootScope.urls().DATA_URL + '/management/token', |
| isArray: false, |
| params: params |
| }, |
| save: { |
| url: $rootScope.urls().DATA_URL + '/' + params.orgname + '/' + |
| params.appname, |
| method: 'PUT', |
| isArray: false, |
| params: params |
| } |
| }); |
| }, |
| |
| httpPost: function(url, callback, payload, headers) { |
| |
| var accessToken = getAccessToken(); |
| |
| if (payload) { |
| payload.access_token = accessToken; |
| } else { |
| payload = { |
| access_token: accessToken |
| } |
| } |
| |
| if (!headers) { |
| headers = { |
| Bearer: accessToken |
| }; |
| } |
| |
| $http({ |
| method: 'POST', |
| url: url, |
| data: payload, |
| headers: headers |
| }). |
| success(function(data, status, headers, config) { |
| callback(data) |
| }). |
| error(function(data, status, headers, config) { |
| reportError(data, config); |
| callback(data) |
| }); |
| |
| } |
| } |
| }); |