@app-connect/core 1.7.0 → 1.7.3

package/README.md

@@ -274,7 +274,7 @@ Gets comprehensive information about an connector including its capabilities and
 **Parameters:**
 - `platformName` (String): Platform identifier
 
-**Returns:** Object with connector capabilities information
+**Returns:** Promise with Object with connector capabilities information
 
 ### Exported Components
 

package/connector/proxy/engine.js

@@ -0,0 +1,163 @@
+const axios = require('axios');
+
+function getByPath(obj, path) {
+  if (!path || path === '$') return obj;
+  const parts = path.split('.');
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function renderTemplateString(template, context) {
+  if (typeof template !== 'string') return template;
+  // if only template value, return value with stringify
+  const onlyVarName = template.match(/^\{\{\s*([^}]+?)\s*\}\}$/);
+  if (onlyVarName) {
+    return getByPath(context, onlyVarName[1]);
+  }
+  return template.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_, expr) => {
+    const value = getByPath(context, expr.trim());
+    return value == null ? '' : String(value);
+  });
+}
+
+function renderDeep(input, context) {
+  if (input == null) return input;
+  if (typeof input === 'string') return renderTemplateString(input, context);
+  if (Array.isArray(input)) return input.map(v => renderDeep(v, context));
+  if (typeof input === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+      out[k] = renderDeep(v, context);
+    }
+    return out;
+  }
+  return input;
+}
+
+function joinUrl(baseUrl, path) {
+  if (!baseUrl) return path;
+  if (!path) return baseUrl;
+  if (path.startsWith('http://') || path.startsWith('https://')) return path;
+  return `${baseUrl.replace(/\/$/, '')}/${path.replace(/^\//, '')}`;
+}
+
+function getAuthHeaderFromAuthConfig({ auth, context, authHeader }) {
+  const authHeaders = {};
+  const headerName = auth?.headerName || 'Authorization';
+  if (auth && auth.credentialTemplate) {
+    const credentials = renderTemplateString(auth.credentialTemplate, context);
+    const encode = auth.encode === 'none' ? false : true;
+    const token = encode ? Buffer.from(credentials).toString('base64') : credentials;
+    authHeaders[headerName] = auth.scheme ? `${auth.scheme} ${token}` : token;
+  } else if (authHeader) {
+    authHeaders[headerName] = authHeader;
+  } else if (auth && auth.type === 'oauth' && context.user) {
+    authHeaders[headerName] = `${auth.scheme || 'Bearer'} ${context.user.accessToken}`;
+  }
+  return authHeaders;
+}
+
+function buildHeaders({ config, operation, authHeader, context }) {
+  const headers = renderDeep(Object.assign({}, config.requestDefaults?.defaultHeaders || {}), context);
+  const renderedOpHeaders = renderDeep(operation?.headers || {}, context);
+  for (const [k, v] of Object.entries(renderedOpHeaders)) headers[k] = v;
+
+  // Per-operation auth override
+  const authHeaders = getAuthHeaderFromAuthConfig({
+    auth: operation?.auth || config.auth,
+    context,
+    authHeader
+  });
+  for (const [k, v] of Object.entries(authHeaders)) headers[k] = v;
+  return headers;
+}
+
+async function performRequest({ config, opName, inputs, user, authHeader }) {
+  const op = config.operations?.[opName];
+  if (!op) return null;
+  const context = Object.assign({}, inputs, {
+    user: user ? {
+      accessToken: user.accessToken,
+      id: user.id?.split('-')[0],
+      hostname: user.hostname,
+      timezoneName: user.timezoneName,
+      timezoneOffset: user.timezoneOffset,
+      platform: user.platform,
+      platformAdditionalInfo: user.platformAdditionalInfo,
+      refreshToken: user.refreshToken,
+      tokenExpiry: user.tokenExpiry,
+    } : {
+      accessToken: '',
+    },
+    authHeader,
+    apiKey: user?.accessToken,
+    secretKey: config.secretKey,
+  });
+  const url = joinUrl(config.requestDefaults?.baseUrl, renderTemplateString(op.url, context));
+  const method = (op.method || 'GET').toUpperCase();
+  const headers = buildHeaders({ config, operation: op, authHeader, context });
+  const params = renderDeep(op.query || {}, context);
+  const data = renderDeep(op.body || {}, context);
+  const timeout = (config.requestDefaults?.timeoutSeconds || 30) * 1000;
+  const axiosParams = { url, method, headers, params, data, timeout };
+  const response = await axios(axiosParams);
+  return response;
+}
+
+function mapFindContactResponse({ config, response }) {
+  const map = config.operations?.findContact?.responseMapping;
+  if (!map) return [];
+  const __ctx = { body: response.data };
+  const list = getByPath(__ctx, map.listPath || 'body') || [];
+  const itemMap = map.item || {};
+  return list.map(it => {
+    return {
+      id: getByPath(it, itemMap.idPath || 'id'),
+      name: getByPath(it, itemMap.namePath || 'name') || '',
+      phone: getByPath(it, itemMap.phonePath || 'phone') || undefined,
+      type: getByPath(it, itemMap.typePath || 'type') || 'Contact',
+      title: getByPath(it, itemMap.titlePath || 'title') || "",
+      company: getByPath(it, itemMap.companyPath || 'company') || "",
+      mostRecentActivityDate: getByPath(it, itemMap.mostRecentActivityDatePath || 'mostRecentActivityDate') || undefined,
+      additionalInfo: getByPath(it, itemMap.additionalInfoPath || 'additionalInfo') || null
+    };
+  });
+}
+
+function mapCreateCallLogResponse({ config, response }) {
+  const map = config.operations?.createCallLog?.responseMapping;
+  if (!map) return { logId: undefined };
+  const __ctx = { body: response.data };
+  const logId = getByPath(__ctx, map.idPath || 'body.id');
+
+  return { logId: logId ? String(logId) : undefined };
+}
+
+function mapGetCallLogResponse({ config, response }) {
+  const map = config.operations?.getCallLog?.responseMapping || {};
+  const __ctx = { body: response.data };
+  const subject = getByPath(__ctx, map.subjectPath || 'body.subject');
+  const note = getByPath(__ctx, map.notePath || 'body.note');
+  const fullBody = getByPath(__ctx, map.fullBodyPath || 'body.note');
+  const fullLogResponse = response.data;
+  return {
+    callLogInfo: { subject, note, fullBody, fullLogResponse }
+  };
+}
+
+module.exports = {
+  getByPath,
+  renderTemplateString,
+  renderDeep,
+  joinUrl,
+  performRequest,
+  mapFindContactResponse,
+  mapCreateCallLogResponse,
+  mapGetCallLogResponse
+};
+
+

package/connector/proxy/index.js

@@ -0,0 +1,492 @@
+/* eslint-disable no-param-reassign */
+const { parsePhoneNumber } = require('awesome-phonenumber');
+const moment = require('moment');
+const {
+  performRequest,
+  mapFindContactResponse,
+  mapCreateCallLogResponse,
+  mapGetCallLogResponse,
+  getByPath,
+} = require('./engine');
+const { Connector } = require('../../models/dynamo/connectorSchema');
+const { UserModel } = require('../../models/userModel');
+
+async function loadPlatformConfig(proxyId) {
+  if (!proxyId) {
+    return null;
+  }
+  try {
+    const proxyConfig = await Connector.getProxyConfig(proxyId);
+    return proxyConfig;
+  } catch (error) {
+    console.error('Error getting proxy config: ', proxyId);
+    return null;
+  }
+}
+
+async function getAuthType({ proxyId, proxyConfig } = {}) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(proxyId));
+  if (!cfg) {
+    return 'apiKey';
+  }
+  return cfg.auth.type || 'apiKey';
+}
+
+async function getOauthInfo({ proxyId, proxyConfig, tokenUrl, hostname } = {}) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(proxyId));
+  if (!cfg) {
+    return {};
+  }
+  return {
+    clientId: cfg.auth.clientId,
+    clientSecret: cfg.auth.clientSecret,
+    accessTokenUri: tokenUrl || cfg.auth.tokenUrl,
+    redirectUri: cfg.auth.redirectUri,
+  };
+}
+
+function getBasicAuth({ apiKey }) {
+  return Buffer.from(`${apiKey}:`).toString('base64');
+}
+
+async function getUserInfo({ authHeader, hostname, additionalInfo, platform, apiKey, proxyId, proxyConfig } = {}) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(proxyId));
+  if (!cfg || !cfg.operations?.getUserInfo) {
+    // Fallback if no getUserInfo operation defined
+    return {
+      successful: false,
+      returnMessage: {
+        messageType: 'warning',
+        message: `Could not load user information. The platform does not support getUserInfo operation.`,
+        ttl: 1000
+      }
+    };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'getUserInfo',
+    inputs: {
+      additionalInfo,
+      apiKey,
+      hostname,
+      platform,
+    },
+    user: {},
+    authHeader
+  });
+  const map = cfg.operations.getUserInfo.responseMapping || {};
+  const responseCtx = {
+    body: response.data,
+    additionalInfo,
+    apiKey,
+    hostname,
+    platform,
+  };
+  const rawUserId = map.idPath ? getByPath(responseCtx, map.idPath) : undefined;
+  const id = `${rawUserId}-${platform}`;
+  const name = map.namePath ? getByPath(responseCtx, map.namePath) : rawUserId;
+  const timezoneName = map.timezoneNamePath ? getByPath(responseCtx, map.timezoneNamePath) : undefined;
+  const overridingApiKey = map.overridingApiKeyPath ? getByPath(responseCtx, map.overridingApiKeyPath) : undefined;
+  // platformAdditionalInfo mapping and cleanup
+  const platformAdditionalInfo = Object.assign({}, additionalInfo || {});
+  if (platformAdditionalInfo.password) delete platformAdditionalInfo.password;
+  if (map.platformAdditionalInfoPaths && typeof map.platformAdditionalInfoPaths === 'object') {
+    for (const [key, expr] of Object.entries(map.platformAdditionalInfoPaths)) {
+      platformAdditionalInfo[key] = getByPath(responseCtx, expr);
+    }
+  }
+  const message = map.messagePath ? (getByPath(responseCtx, map.messagePath) || `Connected to ${platform}.`) : `Connected to ${platform}.`;
+  return {
+    successful: true,
+    platformUserInfo: Object.assign(
+      { id, name },
+      timezoneName ? { timezoneName } : {},
+      overridingApiKey ? { overridingApiKey } : {},
+      Object.keys(platformAdditionalInfo).length ? { platformAdditionalInfo } : {}
+    ),
+    returnMessage: {
+      messageType: 'success',
+      message,
+      ttl: 1000
+    }
+  };
+}
+
+async function getUserList({ user, authHeader, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.getUserList) {
+    return [];
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'getUserList',
+    inputs: { user },
+    user,
+    authHeader
+  });
+  const map = cfg.operations.getUserList.responseMapping || {};
+  const responseCtx = { body: response.data };
+  const userList = map.listPath ? getByPath(responseCtx, map.listPath) : [];
+  return (userList || []).map(item => ({
+    id: getByPath(item, map.idPath || 'id'),
+    name: getByPath(item, map.namePath || 'name'),
+    email: getByPath(item, map.emailPath || 'email'),
+  }));
+}
+
+async function unAuthorize({ user }) {
+  const cfg = await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId);
+  if (cfg?.operations?.unAuthorize) {
+    await performRequest({
+      config: cfg,
+      opName: 'unAuthorize',
+      inputs: {},
+      user,
+    });
+  }
+  user.accessToken = '';
+  user.refreshToken = '';
+  await user.save();
+  return {
+    successful: true,
+    returnMessage: {
+      messageType: 'success',
+      message: 'Logged out',
+      ttl: 1000
+    }
+  };
+}
+
+async function findContact({ user, authHeader, phoneNumber, overridingFormat, isExtension, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.findContact) {
+    return { successful: true, matchedContactInfo: [] };
+  }
+  let formattedPhoneNumber = phoneNumber.replace(' ', '+')
+  const parsedPhoneNumber = parsePhoneNumber(formattedPhoneNumber);
+  const response = await performRequest({
+    config: cfg,
+    opName: 'findContact',
+    inputs: { phoneNumber, parsedPhoneNumber, overridingFormat, isExtension },
+    user,
+    authHeader
+  });
+  const matchedContactInfo = mapFindContactResponse({ config: cfg, response });
+  return {
+    successful: true,
+    matchedContactInfo,
+    returnMessage: {
+      messageType: 'success',
+      message: `Found ${matchedContactInfo.length} contacts`,
+      ttl: 3000
+    }
+  };
+}
+
+async function createContact({ user, authHeader, phoneNumber, newContactName, newContactType, additionalSubmission, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.createContact) {
+    return { contactInfo: null, returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'createContact',
+    inputs: { phoneNumber, newContactName, newContactType, additionalSubmission },
+    user,
+    authHeader
+  });
+  const map = cfg.operations.createContact.responseMapping || {};
+  const responseCtx = { body: response.data };
+  const contactInfo = map.idPath ? {
+    id: getByPath(responseCtx, map.idPath || 'body.id'),
+    name: getByPath(responseCtx, map.namePath || 'body.name'),
+    type: getByPath(responseCtx, map.typePath || 'body.type') || 'Contact',
+  } : null;
+  return { contactInfo, returnMessage: { message: 'Contact created', messageType: 'success', ttl: 2000 } };
+}
+
+async function findContactWithName({ user, authHeader, name, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.findContactWithName) {
+    return { successful: true, matchedContactInfo: [] };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'findContactWithName',
+    inputs: { name },
+    user,
+    authHeader
+  });
+  const matchedContactInfo = mapFindContactResponse({ config: cfg, response });
+  return {
+    successful: true,
+    matchedContactInfo,
+    returnMessage: {
+      messageType: 'success',
+      message: `Found ${matchedContactInfo.length} contacts`,
+      ttl: 3000
+    }
+  };
+}
+
+function getLogFormatType(platform, proxyConfig) {
+  return proxyConfig ? proxyConfig.meta?.logFormat : 'custom';
+}
+
+async function createCallLog({
+  user,
+  contactInfo,
+  authHeader,
+  callLog,
+  note,
+  additionalSubmission,
+  aiNote,
+  transcript,
+  ringSenseTranscript = '',
+  ringSenseSummary = '',
+  ringSenseAIScore = '',
+  ringSenseBulletedSummary = '',
+  ringSenseLink = '',
+  composedLogDetails,
+  hashedAccountId,
+  isFromSSCL,
+  proxyConfig = null,
+}) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg || !cfg.operations?.createCallLog) {
+    return { logId: undefined, returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'createCallLog',
+    inputs: {
+      contactInfo,
+      callLog,
+      note,
+      additionalSubmission,
+      aiNote,
+      transcript,
+      composedLogDetails,
+      hashedAccountId,
+      isFromSSCL,
+      subject: callLog.customSubject ?? `${callLog.direction} Call ${callLog.direction === 'Outbound' ? 'to' : 'from'} ${contactInfo.name}`,
+      startTime: moment(callLog.startTime).utc().toISOString(),
+      endTime: moment(callLog.startTime).utc().add(callLog.duration, 'seconds').toISOString(),
+      ringSenseTranscript,
+      ringSenseSummary,
+      ringSenseAIScore,
+      ringSenseBulletedSummary,
+      ringSenseLink,
+    },
+    user,
+    authHeader
+  });
+  const { logId } = mapCreateCallLogResponse({ config: cfg, response });
+  return {
+    logId,
+    returnMessage: {
+      message: 'Call logged',
+      messageType: 'success',
+      ttl: 2000
+    }
+  };
+}
+
+async function getCallLog({ user, callLogId, contactId, authHeader, proxyConfig = null }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg || !cfg.operations?.getCallLog) {
+    return { callLogInfo: null, returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'getCallLog',
+    inputs: { thirdPartyLogId: callLogId, contactId },
+    user,
+    authHeader
+  });
+  const mapped = mapGetCallLogResponse({ config: cfg, response });
+  return Object.assign(mapped, { returnMessage: { message: 'Call log fetched.', messageType: 'success', ttl: 3000 } });
+}
+
+async function updateCallLog({
+  user,
+  existingCallLog,
+  authHeader,
+  recordingLink,
+  recordingDownloadLink,
+  subject,
+  note,
+  startTime,
+  duration,
+  result,
+  aiNote,
+  transcript,
+  legs,
+  ringSenseTranscript = '',
+  ringSenseSummary = '',
+  ringSenseAIScore = '',
+  ringSenseBulletedSummary = '',
+  ringSenseLink = '',
+  additionalSubmission,
+  composedLogDetails,
+  existingCallLogDetails,
+  hashedAccountId,
+  isFromSSCL,
+  proxyConfig = null,
+}) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg || !cfg.operations?.updateCallLog) {
+    return { returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  await performRequest({
+    config: cfg,
+    opName: 'updateCallLog',
+    inputs: {
+      thirdPartyLogId: existingCallLog?.thirdPartyLogId,
+      existingCallLog,
+      recordingLink,
+      recordingDownloadLink,
+      subject,
+      note,
+      startTime: moment(startTime).utc().toISOString(),
+      endTime: moment(startTime).utc().add(duration, 'seconds').toISOString(),
+      duration,
+      result,
+      aiNote,
+      transcript,
+      legs,
+      additionalSubmission,
+      composedLogDetails,
+      existingCallLogDetails,
+      hashedAccountId,
+      isFromSSCL,
+      ringSenseTranscript,
+      ringSenseSummary,
+      ringSenseAIScore,
+      ringSenseBulletedSummary,
+      ringSenseLink,
+    },
+    user,
+    authHeader
+  });
+  return {
+    updatedNote: null,
+    returnMessage: {
+      message: 'Call log updated.',
+      messageType: 'success',
+      ttl: 3000
+    }
+  };
+}
+
+async function upsertCallDisposition({ user, existingCallLog, authHeader, dispositions, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.upsertCallDisposition) {
+    return { returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  await performRequest({
+    config: cfg,
+    opName: 'upsertCallDisposition',
+    inputs: { existingCallLog, dispositions, thirdPartyLogId: existingCallLog?.thirdPartyLogId },
+    user,
+    authHeader
+  });
+  return { logId: existingCallLog.thirdPartyLogId, returnMessage: { message: 'Disposition updated', messageType: 'success', ttl: 2000 } };
+}
+
+async function createMessageLog({ user, contactInfo, authHeader, message, additionalSubmission, recordingLink, faxDocLink, faxDownloadLink, imageLink, videoLink, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.createMessageLog) {
+    return { logId: undefined, returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'createMessageLog',
+    inputs: {
+      contactInfo,
+      message,
+      additionalSubmission,
+      recordingLink,
+      faxDocLink,
+      faxDownloadLink,
+      imageLink,
+      videoLink,
+      creationTime: moment(message.creationTime).utc().toISOString(),
+    },
+    user,
+    authHeader
+  });
+  const map = cfg.operations.createMessageLog.responseMapping || {};
+  const responseCtx = { body: response.data };
+  const logId = getByPath(responseCtx, map.idPath || 'body.id');
+  return {
+    logId: logId ? String(logId) : undefined,
+    returnMessage: { message: 'Message logged', messageType: 'success', ttl: 1000 }
+  };
+}
+
+async function updateMessageLog({ user, contactInfo, existingMessageLog, message, authHeader, additionalSubmission, imageLink, videoLink, proxyConfig }) {
+  const cfg = proxyConfig ? proxyConfig : (await loadPlatformConfig(user?.platformAdditionalInfo?.proxyId));
+  if (!cfg.operations?.updateMessageLog) {
+    return { returnMessage: { message: 'Not supported', messageType: 'warning', ttl: 2000 } };
+  }
+  await performRequest({
+    config: cfg,
+    opName: 'updateMessageLog',
+    inputs: {
+      contactInfo,
+      existingMessageLog,
+      thirdPartyLogId: existingMessageLog?.thirdPartyLogId,
+      message,
+      additionalSubmission,
+      imageLink,
+      videoLink,
+      creationTime: moment(message.creationTime).utc().toISOString(),
+    },
+    user,
+    authHeader
+  });
+  return { returnMessage: { message: 'Message log updated', messageType: 'success', ttl: 3000 } };
+}
+
+async function getLicenseStatus({ userId, platform }) {
+  const user = await UserModel.findByPk(userId);
+  if (!user || !user.accessToken) {
+    return { isLicenseValid: false, licenseStatus: 'Invalid (User not found)', licenseStatusDescription: '' };
+  }
+  const proxyId = user.platformAdditionalInfo?.proxyId;
+  const cfg = await loadPlatformConfig(proxyId);
+  if (!cfg.operations?.getLicenseStatus) {
+    return { isLicenseValid: true, licenseStatus: 'Basic', licenseStatusDescription: '' };
+  }
+  const response = await performRequest({
+    config: cfg,
+    opName: 'getLicenseStatus',
+    inputs: { userId, platform },
+    user,
+  });
+  const map = cfg.operations.getLicenseStatus.responseMapping || {};
+  const responseCtx = { body: response.data };
+  const isLicenseValid = getByPath(responseCtx, map.isLicenseValidPath || 'body.isLicenseValid');
+  const licenseStatus = getByPath(responseCtx, map.licenseStatusPath || 'body.licenseStatus');
+  const licenseStatusDescription = getByPath(responseCtx, map.licenseStatusDescriptionPath || 'body.licenseStatusDescription');
+  return { isLicenseValid, licenseStatus, licenseStatusDescription };
+}
+
+exports.getAuthType = getAuthType;
+exports.getOauthInfo = getOauthInfo;
+exports.getBasicAuth = getBasicAuth;
+exports.getUserInfo = getUserInfo;
+exports.createCallLog = createCallLog;
+exports.updateCallLog = updateCallLog;
+exports.getCallLog = getCallLog;
+exports.createMessageLog = createMessageLog;
+exports.updateMessageLog = updateMessageLog;
+exports.findContact = findContact;
+exports.createContact = createContact;
+exports.findContactWithName = findContactWithName;
+exports.unAuthorize = unAuthorize;
+exports.getLicenseStatus = getLicenseStatus;
+exports.upsertCallDisposition = upsertCallDisposition;
+exports.getUserList = getUserList;
+exports.getLogFormatType = getLogFormatType;