@app-connect/core 1.7.37 → 1.7.38

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;