att-dhs
Version:
AT&T Developer Hosted Server Library
380 lines (328 loc) • 9.28 kB
JavaScript
/*jslint browser: true, devel: true, node: true, debug: true, todo: true, indent: 2, maxlen: 150, unparam: true*/
/*global exports, require*/
;
var pkg = require('../package.json'),
attLogger = require('./att.dhs.logger'),
http = require('http'),
grantTypesMap,
config,
express_server,
logger,
config_uri = '/config',
tokens_uri = '/tokens',
e911ids_uri = '/e911ids',
getConfigRoute,
postTokensRoute,
postE911idsRoute,
createSocket;
// initialize the default configuration
config = {
api_endpoint: 'https://api.att.com',
authorize_uri: '/oauth/v4/authorize',
info: {
dhs_name: pkg.name,
dhs_version: pkg.version,
dhs_platform: 'node',
token_uri: '/oauth/v4/token',
e911id_uri: '/emergencyServices/v1/e911Locations',
ewebrtc_uri: '/RTC/v1',
scope_map: {
'MOBILE_NUMBER': 'WEBRTCMOBILE,EMERGENCYSERVICES',
'VIRTUAL_NUMBER': 'WEBRTC,EMERGENCYSERVICES',
'ACCOUNT_ID': 'WEBRTC',
'E911': 'EMERGENCYSERVICES'
}
}
};
grantTypesMap = {
'MOBILE_NUMBER': 'authorization_code',
'VIRTUAL_NUMBER': 'client_credentials',
'ACCOUNT_ID': 'client_credentials',
'E911': 'client_credentials',
'REFRESH': 'refresh_token'
};
function getGrantType(app_scope) {
if (undefined !== grantTypesMap) {
return grantTypesMap[app_scope];
}
}
function getScope(app_scope) {
if (undefined !== config
&& undefined !== config.info
&& undefined !== config.info.scope_map) {
return config.info.scope_map[app_scope];
}
}
/**
* @public
* @function
* configure
* @summary
* Configures application with provided AT&T key and secret any any additional information
* @desc
* A DHS method to configure application with the passed AT&T
* application key and secret and any additional information
*
* @param {object} options
* @param {string} options.app_key - AT&T application key.
* @param {string} options.app_secret - AT&T application secret.
* @param {string} [options.virtual_numbers_pool] - Array pool of virtual numbers.
* @param {string} [options.ewebrtc_domain] - AT&T EWebRTC domain.
*
* @example
* var myDHS = require("att-dhs"),
* options = {
* app_key: '<your-app-key>',
* app_secret: '<your-app-secret>',
* };
*
* myDHS.configure(options);
*
* @example
* var myDHS = require("att-dhs"),
* options = {
* app_key: '<your-app-key>',
* app_secret: '<your-app-secret>',
* virtual_numbers_pool: ['1234567890', '9876543210'],
* ewebrtc_domain: '<your-domain-name>'
* };
*
* myDHS.configure(options);
*
* @example
* // providing <your_app_url> with /tokens and /e911ids endpoints
* var myDHS = require("att-dhs");
* options = {
* app_key: '<your-app-key>',
* app_secret: '<your-app-secret>',
* virtual_numbers_pool: ['1234567890', '9876543210'],
* ewebrtc_domain: '<your-domain-name>',
* app_token_uri: '<your_app_url>/tokens',
* app_e911ids_uri: '<your_app_url>/e911ids'
* };
*
* myDHS.configure(options);
*
* @example
* // To define your own logging tool it must contain the following methods:
* // 1) logError
* // 2) logWarn
* // 3) logInfo
* // 4) logDebug
* // 5) logTrace
*
* var myDHS = require("att-dhs"),
* myLogger = require("my-own-logger");
*
* myDHS.configure({
* ...
* });
*
* myDHS.use('logger', myLogger);
*
* @example
* // To get default routes from DHS
*
* // DHS predefined default routes:
* // 1) GET '/config'
* // 2) POST '/tokens'
* // 3) POST '/e911ids'
*
* var myDHS = require("att-dhs"),
* express = require("express");
*
* myDHS.configure({
* ...
* app: express
* });
*
* @example
* // To change the DHS default routes
*
* var myDHS = require("att-dhs"),
* express = require("express");
*
* myDHS.configure({
* ...
* config_uri: '/my-config-uri',
* tokens_uri: '/my-tokens-uri',
* e911ids_uri: '/my-e911ids-uri'
* },
* express);
*/
function configure(options, app) {
if (undefined === options
|| Object.keys(options).length === 0) {
throw new Error('No options provided');
}
if (undefined === options.app_key) {
throw new Error('No app_key provided');
}
if (undefined === options.app_secret) {
throw new Error('No app_secret provided');
}
if (undefined === options.host) {
throw new Error('No host provided');
}
if (undefined === options.port) {
throw new Error('No port provided');
}
var key;
if ('object' !== typeof config) {
config = {};
}
if ('object' !== typeof config.info) {
config.info = {};
}
for (key in options) {
if (options.hasOwnProperty(key)) {
if ('api_env' === key
|| 'scope_map' === key) {
config.info[key] = options[key];
} else {
config[key] = options[key];
}
}
}
if (undefined !== options.config_uri) {
config_uri = options.config_uri;
}
if (undefined !== options.tokens_uri) {
tokens_uri = options.tokens_uri;
}
if (undefined !== options.e911ids_uri) {
e911ids_uri = options.e911ids_uri;
}
config.config_url = 'https://' + config.host + ':' + config.port + config_uri;
config.app_tokens_url = 'https://' + config.host + ':' + config.port + tokens_uri;
config.app_e911ids_url = 'https://' + config.host + ':' + config.port + e911ids_uri;
}
/**
* @public
* @function
* getConfiguration
* @summary
* Returns the environment configuration.
* @desc
* A DHS method to return environment configuration like `app_key`, `virtual_numbers_pool`
* and `ewebrtc_domain`
*
* @example
* var myDHS = require("att-dhs"),
* config = myDHS.getConfiguration();
*
* @returns {EnvConfig}
*/
function getConfiguration() {
var key,
result;
logger.logInfo('dhs.config: getConfiguration');
result = {};
for (key in config) {
if (config.hasOwnProperty(key)) {
if (key !== 'app_secret') {
result[key] = config[key];
}
}
}
logger.logTrace('result:', result);
/**
* @typedef {Object} EnvConfig
*
* @property {String} app_key 'thirty_two_character_application_key'
* @property {String} api_endpoint API endpoint e.g. 'https://api.att.com'
* @property {String} ewebrtc_uri EWebRTC domain e.g. '/RTC/v1'
* @property {Array} virtual_numbers_pool Virtual number e.g. ['1234567890', '9876543210']
* @property {String} ewebrtc_domain EWebRTC domain e.g. 'yourdomain.com'
*/
return result;
}
function getAppConfiguration() {
return config;
}
function getLogger() {
return logger;
}
function useServer(server) {
logger.logInfo('dhs.config: useServer');
if (undefined !== server) {
logger.logDebug('Creating routes...');
server.get(config_uri, getConfigRoute);
server.post(tokens_uri, postTokensRoute);
server.post(e911ids_uri, postE911idsRoute);
} else {
throw new Error('No server object provided, cannot set routes');
}
logger.logInfo('dhs.config: useServer: Complete');
}
function useLogger(logger) {
//if (undefined === options.logLevel) {
// log_level = 'info';
//}
if (undefined === logger
|| undefined === logger.logError
|| undefined === logger.logWarn
|| undefined === logger.logInfo
|| undefined === logger.logDebug
|| undefined === logger.logTrace) {
// TODO: Use our att.logger hosted on npm registry? or attached in DHS package?
//if (undefined !== logUtility
// && 'function' === typeof logUtility) {
// logger.setLogUtility(logUtility);
//
// logger.logInfo('Found new log utility, testing...');
//}
logger.logWarn('Cannot use custom logger, running ATT\'s instead');
}
//logger.setLogLevel(log_level);
logger.logInfo('dhs.config: useLogger: Complete');
}
function useWebSocket(server) {
logger.logInfo('dhs.config: useWebSocket');
logger.logDebug('Creating http server...');
if (undefined === server) {
throw new Error('Server object was not provided');
}
logger.logDebug('Creating Web Socket');
createSocket({
server: server,
success: function () {
logger.logInfo('Successfully created Web Socket');
config['websocket.eventchannel'] = {
endpoint: 'wss://' + server.address().address + ':' + server.address().port
};
}
});
logger.logInfo('dhs.config: useWebSocket: Complete');
}
function use(plugin, options) {
logger.logInfo('dhs.config: use');
logger.logTrace('plugin', plugin);
logger.logTrace('options', options);
if ('websocket.eventchannel' === plugin) {
useWebSocket(options.server);
} else if ('logger' === plugin) {
useLogger(options.logger);
} else if ('router' === plugin) {
useServer(options.server);
}
logger.logInfo('dhs.config: use: Complete');
}
function initialize(options) {
getConfigRoute = options.config_route;
postTokensRoute = options.tokens_route;
postE911idsRoute = options.e911ids_route;
createSocket = options.create_socket;
logger = attLogger.attLogManager.createLogger('dhs');
logger.logInfo('dhs.config: initialize: Complete');
}
exports.config = {
configure: configure,
getConfiguration: getConfiguration,
getAppConfiguration: getAppConfiguration,
getGrantType: getGrantType,
getScope: getScope,
initialize: initialize,
use: use,
getLogger: getLogger
};