@app-connect/core 1.7.36 → 1.7.38

package/connector/proxy/engine.js

@@ -1,165 +0,0 @@
-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 accessToken = user?.accessToken ?? inputs?.apiKey ?? '';
-  const context = Object.assign({}, inputs, {
-    user: 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: 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, opName = 'findContact' }) {
-  const map = config.operations?.[opName]?.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') || "",
-      createdDate: getByPath(it, itemMap.createdDatePath || 'createdDate') || undefined,
-      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

@@ -1,500 +0,0 @@
-/* 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');
-const logger = require('../../lib/logger');
-const { handleDatabaseError } = require('../../lib/errorHandler');
-
-async function loadPlatformConfig(proxyId) {
-  if (!proxyId) {
-    return null;
-  }
-  try {
-    const proxyConfig = await Connector.getProxyConfig(proxyId);
-    return proxyConfig;
-  } catch (error) {
-    logger.error('Error getting proxy config: ', { proxyId, stack: error.stack });
-    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 } = {}) {
-  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, userEmail } = {}) {
-  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,
-      userEmail,
-    },
-    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 = '';
-  try {
-    await user.save();
-  }
-  catch (error) {
-    return handleDatabaseError(error, 'Error saving user');
-  }
-  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, opName: 'findContact' });
-  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, opName: 'findContactWithName' });
-  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;