barrageapi
Version:
A library for sending data to Barrage, an advanced streaming analytics service from MIOsoft
1,379 lines (1,292 loc) • 55.9 kB
JavaScript
var CryptoJS = require("crypto-js");
var Q = require('q');
var WebSocket = require('websocket').w3cwebsocket;
var WebSocketFactory = require('./WebSocketFactory');
var RuntimeTypeChecker = require('./RuntimeTypeChecker');
var ws;
var additionalWebsockets = {};
var rttc = new RuntimeTypeChecker();
var loggedIn = false;
var log = require("./log.js")();
function resolver (deferred) {
return function (result) {
if (result.status !== 0) {
deferred.reject(result.msg);
log(result.msg);
return;
}
else if (result.msg !== "") {
log(result.msg);
}
deferred.resolve(result.result);
};
}
function errResolver (deferred) {
return function (err) {
deferred.reject(err);
log(err);
};
}
//TODO make it so no requests go out before socket connected
//noinspection JSUnusedGlobalSymbols
module.exports = exports = {
/** HELPERS **/
/**
* Returns true if currently connected.
*/
IsConnected : function () {
if (!ws) { return false; }
return ws.ws.readyState === 1;
},
/**
* Returns true if currently logged in.
*/
IsLoggedIn : function () {
if (!ws) { return false; }
return ws.ws.readyState === 1 && loggedIn;
},
/**
* Adds or changes the websocket used by the API
* @param wsURL {String} The websocket that the API will use
*/
SetWebsocket: function (wsURL) {
loggedIn = false;
if (ws) { if (ws.ws instanceof WebSocket) {
ws.ws.close(); } }
ws = new WebSocketFactory(wsURL, "default");
var deferred = Q.defer();
if (!ws.checkSocketConnected()) {
ws.initializeSocket().then(function () {
deferred.resolve();
}, function (err) {
deferred.reject(err); });
}
else {
deferred.resolve();
}
return deferred.promise;
},
AddWebsocket :function (name, wsURL) {
//Check if a websocket already exists for this name. If it has a different url, close it.
var newWs;
if (additionalWebsockets[name] && wsURL !== additionalWebsockets[name].url) {
additionalWebsockets[name].ws.close();
}
//Check if there is an existing websocket with the url
for (var key in additionalWebsockets) {
if (additionalWebsockets.hasOwnProperty(key)) {
if (additionalWebsockets[key].url === wsURL) {
newWs = additionalWebsockets[key];
newWs.addID(name);
break;
}
}
}
//If we didn't find an existing socket make a new one
if (!newWs) { newWs = new WebSocketFactory(wsURL, name); }
var deferred = Q.defer();
//If the socket is already connected, resolve the promise
if (newWs.ws.readyState === 0 || newWs.ws.readyState === 1) {
deferred.resolve();
}
else {
newWs.initializeSocket().then(function () {
newWs.makeRequest(ws.loginObject).then(function (result) {
if (result.status !== 0) {
newWs.loginObject = ws.loginObject = {};
deferred.reject(result.msg);
return;
}
newWs.loginObject = ws.loginObject;
deferred.resolve(result.result);
}, errResolver(deferred));
}, function (err) {
deferred.reject(err);
});
}
//Add the socket to our map
additionalWebsockets[name] = newWs;
return deferred.promise;
},
CloseWebSocket : function () {
if (ws) {
if (ws.ws instanceof WebSocket) {
loggedIn = false;
ws.ws.close();
}
}
},
CloseAdditionalWebsockets : function () {
for (var key in additionalWebsockets) {
if (additionalWebsockets.hasOwnProperty(key)) {
additionalWebsockets[key].ws.close();
}
}
additionalWebsockets = {};
},
CancelAllRequests : function () {
var promises = [];
for (var key in additionalWebsockets) {
if (additionalWebsockets.hasOwnProperty(key)) {
promises.push(additionalWebsockets[key].ws.cancelAllRequests());
}
}
promises.push(ws.cancelAllRequests());
return Q.all(promises);
},
/** USER APIS **/
/**
* Login in to the API
* @param {String} login Username
* @param {String} password Password
*/
Login : function (login, password, shouldHash) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['string', 'string', 'boolean'])) { deferred.reject(); return deferred.promise; }
if (shouldHash) { password = CryptoJS.SHA512(password).toString(CryptoJS.enc.Hex); }
var serviceObject = {service : "login", login: login, password: password};
ws.makeRequest(serviceObject).then(function (result) {
if (result.status !== 0) {
ws.loginObject = {};
deferred.reject(result.msg);
return;
}
loggedIn = true;
ws.loginObject = serviceObject;
deferred.resolve(result.result);
}, errResolver(deferred));
return deferred.promise;
},
Logout : function () {
var deferred = Q.defer();
var serviceObject = {service : "logout"};
ws.makeRequest(serviceObject).then(function (result) {
loggedIn = false;
ws.loginObject = {};
deferred.resolve(result.msg);
}, errResolver(deferred));
exports.CloseAdditionalWebsockets();
return deferred.promise;
},
/*
* Get the server id for the current web session
*
* @method "getSessionID"
* @type "SessionManager"
* @connection "WebSocket"
* @login "false"
* @returns JSON
*/
GetSessionID : function () {
var deferred = Q.defer();
var serviceObject = {service : "getSessionID"};
ws.makeRequest(serviceObject).then(function (resp) {
ws.reconnectObject = {service : "reconnectToSession", sessionID : resp};
resolver(deferred)(resp);
}, errResolver(deferred));
return deferred.promise;
},
/*
* Reconnect to the web session with the given session id given the
* session is still active
*
* @method "reconnectToSession"
* @type "SessionManager"
* @connection "WebSocket"
* @login "false"
* @param "sessionID" "string" (required)
* the session id to attempt to reconnect to
* @returns JSON
*/
ReconnectToSession : function (sessionID) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['string'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "reconnectToSession", sessionID : sessionID};
ws.makeRequest(serviceObject).then(function (result) {
if (result.status !== 0) {
deferred.reject(result.msg);
return;
}
deferred.resolve(result.result);
}, errResolver(deferred));
return deferred.promise;
},
/**** Reset Password ****/
RequestResetQuestions : function (resetKey) {
var deferred = Q.defer();
var serviceObject = {service : "requestResetQuestions", resetKey : resetKey};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
CheckQuestions : function (securityQuestions) {
var deferred = Q.defer();
var serviceObject = {service : "checkQuestions", securityQuestions : securityQuestions};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
ChangePassword : function (pass,key) {
var serviceObject = {service : "changePassword", newPassword : pass, sessionResetKey : key};
return ws.makeRequest(serviceObject);
},
/**** Account ****/
/*
* Edit the standard fields on the account
*
* @method "editAccount"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "accountName" "string" (required)
* The nickname for the account
* @param "contactName" "string" (required)
* The name of the point of contact for the account
* @param "contactEmail" "string" (required)
* The email of the point of contact for the account
* @param "contactPhone" "string" (required)
* The contact phone number for the point of contact for the account
* @returns JSON
*/
EditAccount : function (accountName, contactName, contactEmail, contactPhone, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "editAccount", accountName : accountName, contactName : contactName, contactEmail : contactEmail, contactPhone : contactPhone, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Close the account. This makes the account "inactive". It
* removes all User relationships to the account type except the
* owner account.
*
* @method "closeAcct"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "hashedPassword" "string" (required)
* The logged in user's hashed password used as secondary confirmation
* @returns JSON
*/
CloseAcct : function (hashedPassword, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "closeAcct", hashedPassword : hashedPassword, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Add a user given an email. If the email is not associated
* with an account, an email will be sent to that address inviting
* the user to join
*
* @method "addUserByEmail"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "userEmail" "string" (required)
* The email of the user to add
* @param "permissionProfile" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* The permissions for this user
* @returns JSON
*/
AddUserByEmail : function (userEmail, permissionProfile, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "addUserByEmail", userEmail : userEmail, permissionProfile : permissionProfile, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Remove the indicated user from the account
*
* @method "removeUserLoginName"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "userLoginName" "string" (required)
* The login name of the user to remove
* @returns JSON
*/
RemoveUserLoginName : function (userLoginName, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "removeUserLoginName", userLoginName : userLoginName, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Obtain the given member's permission profile
*
* @method "getPermissionProfile"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "userLoginName" "string" (required)
* The login name of the member profile to get
* @returns JSON
*/
GetPermissionProfile : function (userLoginName, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getPermissionProfile", userLoginName : userLoginName, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Cancel the indicated Stripe subscriptions
*
* @method "cancelSubscriptions"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "subscriptionIDs" (required) "min of 1-element array of nonempty string"
* The list of subscriptionIDs to unsubscribe to
* @returns JSON
*/
CancelSubscriptions : function (subscriptionIDs, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "cancelSubscriptions", subscriptionIDs : subscriptionIDs, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Change the Stripe account payor's card
*
* @method "changeCard"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "id" "string" (required)
* The card token obtained from Stripe
* @returns JSON
*/
ChangeCard : function (id, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "changeCard", id : id, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Charge the account's default Stripe card
*
* @method "createCharge"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "amount" "integer" (required)
* The amount to charge in cents
* @param "description" "string" (required)
* a description of this particular charge
* @returns JSON
*/
CreateCharge : function (amount, description, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "createCharge", amount : amount, description : description, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Add Stripe subscriptions to this account
*
* @method "addSubscriptions"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "planIDs" (required) "min of 1-element array of nonempty string"
* The list of planIDs to subscribe to
* @returns JSON
*/
AddSubscriptions : function (planIDs, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "addSubscriptions", planIDs : planIDs, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Create a payor account linked to Stripe which allows credit card
* payments from this account to the single Stripe VendorAccount in
* this MIOapp
*
* @method "createStripePayorAccount"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "token" "string" (required)
* The Stripe provided credit card token
* @returns JSON
*/
CreateStripePayorAccount : function (token, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "createStripePayorAccount", token : token, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of Stripe charges for this account
*
* @method "getCharges"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetCharges : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getCharges", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of account Stripe plans
*
* @method "getPlans"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetPlans : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getPlans", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of members of this account
*
* @method "getMemberList"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetMemberList : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getMemberList", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of account permission profile templates
*
* @method "getPermissionProfileTemplates"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetPermissionProfileTemplates : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getPermissionProfileTemplates", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Edit the given profile template
*
* @method "editPermissionTemplate"
* @type "AccountPermissionProfileTemplate"
* @connection "WebSocket"
* @login "true"
* @param "template" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* The updated template
* @returns JSON
*/
EditPermissionTemplate : function (template, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "editPermissionTemplate", template : template, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Change the permissions of this profile using those in the
* provided template
*
* @method "changePermissionProfile"
* @type "AccountPermissionProfile"
* @connection "WebSocket"
* @login "true"
* @param "template" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* The updated template
* @returns JSON
*/
ChangePermissionProfile : function (template, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "changePermissionProfile", template : template, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Create a profile template using the provided template
*
* @method "createTemplate"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @param "template" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* A new template
* @returns JSON
*/
CreateTemplate : function (template, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "createTemplate", template : template, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Directly edit the user's permission profile for this account
*
* @method "editUserPermission"
* @type "AccountPermissionProfile"
* @connection "WebSocket"
* @login "true"
* @param "newPermissionProfile" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* The updated permission profile
* @returns JSON
*/
EditUserPermission : function (newPermissionProfile, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "customizeUserPermissionProfile", newPermissionProfile : newPermissionProfile, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of API rules registered with this API endopoint.
* These rules provide the authority to call certain services.
*
* @method "getAvailableSessionRules"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetAvailableSessionRules : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getAvailableSessionRules", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Directly edit the user's permission profile for this account to a
* custom profile. If the result is a template already on file,
* the server will opt to use the pre-existing template.
*
* @method "customizeUserPermissionProfile"
* @type "AccountPermissionProfile"
* @connection "WebSocket"
* @login "true"
* @rules "Account Management"
* @param "newPermissionProfile" "AccountPermissionProfile" (required) ("addUser" : "bool", "changePaymentMethod" : "bool", "closeAccount" : "bool", "editGeneralAccount" : "bool", "editUsersPermission" : "bool", "purchaseAuthority" : "bool", "removeUser" : "bool", "editPermissionTemplate" : "bool", "memberView" : "bool", "templateName" : "string", "forbiddenRules" : "array of string")
* The updated permission profile
* @returns JSON
*/
CustomizeUserPermissionProfile : function (newPermissionProfile, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "customizeUserPermissionProfile", newPermissionProfile : newPermissionProfile, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/**** User ****/
/*
* Obtain all the Account names of the accounts this user is linked
* to
*
* @method "getAccountNames"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetAccountNames : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getAccountNames", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Obtain all the inactive Account names this user is linked to
*
* @method "getInactiveAccountNames"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
GetInactiveAccountNames : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getInactiveAccountNames", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Set the default account accessed by the user upon login
*
* @method "setDefaultAccount"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "defaultAccountName" "string" (required)
* The named account to set as the default
* @returns JSON
*/
SetDefaultAccount : function (defaultAccountName, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "setDefaultAccount", defaultAccountName : defaultAccountName, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Switch the active account to the named account. Note that this
* will completely clear the server-side web session cache as well
* as unsubscribe all context subscription notifications in the
* session cache.
*
* @method "switchActiveAccount"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "accountName" "string" (required)
* The named account to switch to
* @returns JSON
*/
SwitchActiveAccount : function (accountName, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "switchActiveAccount", accountName : accountName, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Access the currently active account
*
* @method "accessAccount"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @returns JSON
*/
AccessAccount : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "accessAccount", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Remove the indicated account from the list of accounts a user is
* a member of. Cannot be used on Individual accounts
*
* @method "removeAccount"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "accountName" "string" (required)
* The name of the account to remove
* @returns JSON
*/
RemoveAccount : function (accountName, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "removeAccount", accountName : accountName, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/**** SignupRequestSession ****/
/*
* Creates a signup request to send an email to the provided email.
* This email contains a link that is used to create a new user.
*
* @method "signup"
* @type "SignupRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "email" "nonempty string" (required)
* @returns JSON
*/
Signup : function (email) {
var deferred = Q.defer();
var serviceObject = {service : "signup", email : email};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Creates a signup request for a user login linked to an
* individual account. The request sends an email to the provided
* email. This email contains a link that is used to create a
* new user and account.
*
* @method "signupIndividualAccount"
* @type "SignupRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "email" "nonempty string" (required)
* @param "accountName" "nonempty string" (required)
* @returns JSON
*/
SignupIndividualAccount : function (email, accountName) {
var serviceObject = {service : "signupIndividualAccount", email : email, accountName : accountName};
return ws.makeRequest(serviceObject);
},
/*
* Creates a signup request for a user login linked to an
* organizational account. The request sends an email to the provided
* email. This email contains a link that is used to create a
* new user and account.
*
* @method "signupOrganizationalAccount"
* @type "SignupRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "email" "nonempty string" (required)
* @param "accountName" "nonempty string" (required)
* @returns JSON
*/
SignupOrganizationalAccount : function (email, accountName) {
var serviceObject = {service : "signupOrganizationalAccount", email : email, accountName : accountName};
return ws.makeRequest(serviceObject);
},
/**** SignupSession ****/
/*
* Create a new user using the standard login roles provided in the
* system configurations. The password provided by the client is
* expected to be hashed. The websocket session terminates once
* completed. If the signup involves the creation of an Account,
* an account will be created and linked to this user at the time
* of user creation.
*
* @method "createUser"
* @type "SignupRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "login" "string"
* @param "password" "nonempty string" (required)
* @param "securityQuestions" (required) "min of 3-element array of SecurityQuestion" ("question" : "nonempty string", "answer" : "nonempty string")
* @param "name" "nonempty string" (required)
* @param "phone" "string"
* @param "requestKey" "nonempty string" (required)
* @returns JSON
*/
CreateUser : function (login, password, securityQuestions, name, phone, requestKey) {
var serviceObject = {service : "createUser", login : login, password : password, securityQuestions : securityQuestions, name : name, phone : phone, requestKey : requestKey};
return ws.makeRequest(serviceObject);
},
GetLoggedInUser : function () {
var deferred = Q.defer();
var serviceObject = {service : "getLoggedInUser"};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Edit the contact/login information of a self. This can only be
* done over a logged in (secure) websocket connection.
*
* @method "editUser"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "login" "nonempty string" (required)
* @param "email" "nonempty string" (required)
* @param "name" "string" (required)
* @param "phone" "string"
* @returns JSON
*/
EditUser : function (login, email, name, phone, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "editUser", login : login, email : email, name : name, phone : phone, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Change the password of a self. The self must provide the old
* password to change the password in this way. This can only be
* done over a logged in (secure) websocket connection.
*
* @method "changeUserPasswordLocally"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "oldPassword" "nonempty string" (required)
* @param "newPassword" "nonempty string" (required)
* @returns JSON
*/
ChangeUserPassword : function (oldPassword, newPassword, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "changeUserPasswordLocally", oldPassword : oldPassword, newPassword : newPassword, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Update all the self's security questions used for resetting the
* self password. The update replaces all the questions on file.
* Check with the system administrator to determine the minumum
* number of questions required. This can only be done over a
* logged in (secure) websocket connection.
*ch
* @method "updateUserSecurityQuestions"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "securityQuestions" (required) "min of 3-element array of SecurityQuestion" (
* question : nonempty string,
* answer : nonempty string)
* The new securtiy questions for resetting the user password on
* this account
* @returns JSON
*/
UpdateUserSecurityQuestions : function (securityQuestions, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "updateUserSecurityQuestions", securityQuestions : securityQuestions, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Change the UserRoles on this self account. This is a restricted
* operation not available to standard selfs. This can only be
* done over a logged in (secure) websocket connection.
*
* @method "updateUserRoles"
* @type "User"
* @connection "WebSocket"
* @login "true"
* @param "roles" (required) "array of string"
* @returns JSON
*/
UpdateUserRoles : function (roles, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "updateUserRoles", roles : roles, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Look up a user account by the user email and send an email to
* the user to initiate the reset password process
*
* @method "resetByEmail"
* @type "PasswordResetRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "email" "nonempty string" (required)
* @returns JSON
*/
ResetByEmail : function (email) {
var deferred = Q.defer();
var serviceObject = {service : "resetByEmail", email : email};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Look up a user account by the user login and send an email to
* the user to initiate the reset password process
*
* @method "resetByLogin"
* @type "PasswordResetRequestSession"
* @connection "WebSocket"
* @login "false"
* @param "login" "nonempty string" (required)
* @returns JSON
*/
ResetByLogin : function (login) {
var deferred = Q.defer();
var serviceObject = {service : "resetByLogin", login : login};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Add the indicated account option to the account. Requires purchase
* authority
*
* @method "addOption"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @rules "Account Management"
* @param "accountOptionKey" string - one of:
* ("BarrageTier1", "BarrageTier2", "BarrageTier0") (required)
* @returns JSON
*/
AddOption : function (accountOptionKey, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "addOption", accountOptionKey : accountOptionKey, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Remove the indicated account option to the account. Requires
* purchase authority
*
* @method "removeOption"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @rules "Account Management"
* @param "accountOptionKey" string - one of:
* ("BarrageTier1", "BarrageTier2", "BarrageTier0") (required)
* @returns JSON
*/
RemoveOption : function (accountOptionKey, objectID) {
var deferred = Q.defer();
var serviceObject = {service : "removeOption", accountOptionKey : accountOptionKey, objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Get the list of account options available on this account
*
* @method "getAccountOptions"
* @type "Account"
* @connection "WebSocket"
* @login "true"
* @rules "Account Management"
* @returns JSON
*/
GetAccountOptions : function (objectID) {
var deferred = Q.defer();
var serviceObject = {service : "getAccountOptions", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/** BARAGE APIS **/
/*
* Adds records to an existing Barrage Database
*
* @method "AddRecords"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "data" "untyped" (required)
* @param "progress" "integer" (required)
*/
AddRecords : function (dbId, data, progress, portalName) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'untyped', 'integer', 'string?'])) {
deferred.reject(); return deferred.promise; }
var serviceObject = {service : "AddRecords", dbId : dbId, data : data, progress : progress};
if (!portalName) {
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
}
else if (additionalWebsockets[portalName]) {
additionalWebsockets[portalName].makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
}
return deferred.promise;
},
/*
* Returns an array of all available Barrage Databases
*
* @method "AvailableBarrageDBs"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
*/
AvailableBarrageDBs : function () {
var deferred = Q.defer();
var serviceObject = {service : "AvailableBarrageDBs" };
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Creates a new Barrage Database
*
* @method "CreateBarrageDB"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "true"
* @param "name" "string" (required)
* @param "externalId" "string"
* @returns JSON
*/
CreateBarrageDB : function CreateBarrageDB(name, externalId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['string', 'string?'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "CreateBarrageDB", name : name, externalId : externalId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Deletes an existing Barrage Database
*
* @method "DeleteBarrageDB"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
*/
DeleteBarrageDB : function (dbId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "DeleteBarrageDB", dbId : dbId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Duplicates the structure of an existing Barrage Database
*
* @method "DuplicateBarrageDB"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "true"
* @param "dbId" "integer" (required)
* @returns JSON
*/
DuplicateBarrageDB : function (dbId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "DuplicateBarrageDB", dbId : dbId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Deletes the data inside an existing Barrage Database but leaves the database structure intact
*
* @method "EmptyBarrageDB"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
*/
EmptyBarrageDB : function (dbId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "EmptyBarrageDB", dbId : dbId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns all the configuration, barrage code and notifications of a Barrage Database
*
* @method "GetBarrageDBDetails:"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
*/
GetBarrageDBDetails : function (dbId, portalName) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'string?'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetBarrageDBDetails", dbId : dbId};
if (!portalName) {
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
}
else if (additionalWebsockets[portalName]) {
additionalWebsockets[portalName].makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
}
return deferred.promise;
},
/*
* Returns the position of the record in a Barrage Database that is at the specified time or if there is no record at exactly that time, then the position of the first record immediately after.
*
* @method "GetFirstRecordNumberAtOrAfter"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "timeUTC" "integer" (required)
*/
GetFirstRecordNumberAtOrAfter : function (dbId, timeUTC) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetFirstRecordNumberAtOrAfter", dbId : dbId, timeUTC : timeUTC};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns the records between startTime & endTime (inclusive) from a Barrage Database using the current zoom level
*
* @method "GetMoreRecordsDuring"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "startTime" "integer" (required)
* @param "endTime" "integer" (required)
*/
GetMoreRecordsDuring : function (dbId, startTime, endTime) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'integer', 'integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetMoreRecordsDuring", dbId : dbId, startTime : startTime, endTime : endTime };
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns the number of records in a Barrage Database
*
* @method "GetRecordCount"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
*/
GetRecordCount : function (dbId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetRecordCount", dbId : dbId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns all records between start & end (inclusive) from a Barrage Database
*
* @method "GetRecords"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "start" "integer" (required)
* @param "end" "integer" (required)
*/
GetRecords : function (dbId, start, end) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'integer', 'integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetRecords", dbId : dbId, start : start, end : end};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns the records between startTime & endTime (inclusive) from a Barrage Database. The best zoom level is automatically chosen so that the best number of records are returned. Future calls to GetMoreRecordsDuring will use the zoom level determined here
*
* @method "GetRecordsDuring"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "startTime" "integer" (required)
* @param "endTime" "integer" (required)
*/
GetRecordsDuring : function (dbId, startTime, endTime) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'integer', 'integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetRecordsDuring", dbId : dbId, startTime : startTime, endTime : endTime};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Initiates a new search from the start of a Barrage Database
*
* @method "NewSearch"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "searchOrNotification" "string" (required)
* @param "elements" "array of string" (required)
* @param "startingAt" "integer" (optional)
* @param "endingAt" "integer" (optional)
* @param "pushNotifications" "boolean" (optional)
*/
NewSearch : function (dbId, searchOrNotification, elements, startingAt, endingAt, pushNotifications) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'string', 'array', 'integer?', 'integer?', 'boolean?'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "NewSearch", dbId : dbId, searchOrNotification : searchOrNotification, elements : elements, startingAt : startingAt, endingAt: endingAt, pushNotifications: pushNotifications};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Find next match
*
* @method "FindNextMatch"
* @type "SearchQuery"
* @connection "WebSocket"
* @login "false"
* @returns JSON
*/
FindNextMatch : function (objectID) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "FindNextMatch", objectID : objectID};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Updates Barrage language code in an existing Barrage Database
*
* @method "UpdateBarrageCode"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "barageCode" "string" (required)
*/
UpdateBarrageCode : function (dbId, barageCode) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'string'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "UpdateBarrageCode", dbId : dbId, barageCode : barageCode};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Updates Barrage language code in an existing Barrage Database
*
* @method "UpdateBarrageSearchCode"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "barageCode" "string" (required)
*/
UpdateBarrageSearchCode : function (dbId, barageCode) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'string'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "UpdateBarrageSearchCode", dbId : dbId, barageCode : barageCode};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Updates the configuration of an existing Barrage Database
*
* @method "UpdateConfiguration"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "false"
* @param "dbId" "integer" (required)
* @param "name" "string"
* @param "captureRawData" "bool"
* @param outOfOrderDelay [0,60] (required)
* @param displayTimezone [-12,12] (required)
*/
UpdateConfiguration : function (dbId, name, captureRawData, outOfOrderDelay, displayTimezone, recordDefinition) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'string', 'boolean', 'number', 'string', 'object'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "UpdateConfiguration", dbId : dbId, name : name, captureRawData : captureRawData, outOfOrderDelay : outOfOrderDelay, displayTimezone : displayTimezone, recordDefinition : recordDefinition};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns all raw records between start & end (inclusive) from a
* Barrage Database
*
* @method "GetRawRecords"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "true"
* @param "dbId" "integer" (required)
* @param "start" "integer" (required)
* @param "end" "integer" (required)
* @returns JSON
*/
GetRawRecords : function (dbId, start, end) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer', 'integer', 'integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetRawRecords", dbId : dbId, start : start, end : end};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Returns the number of raw records in a Barrage Database
*
* @method "GetRawRecordCount"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "true"
* @param "dbId" "integer" (required)
* @returns JSON
*/
GetRawRecordCount : function (dbId) {
var deferred = Q.defer();
if (!rttc.checkArguments(arguments, ['integer'])) { deferred.reject(); return deferred.promise; }
var serviceObject = {service : "GetRawRecordCount", dbId : dbId};
ws.makeRequest(serviceObject).then(resolver(deferred), errResolver(deferred));
return deferred.promise;
},
/*
* Add or (if any are already present) update fields in an existing
* Barrage Database's record definition
*
* @method "AddOrUpdateFields"
* @type "BarrageDB"
* @connection "WebSocket"
* @login "true"
* @param "dbId" "integer" (required)
* @param "fields" (required) "array of Field" (IntegerField, StringField, BooleanField, FloatField)
* "IntegerField" (
*