@app-connect/core 1.7.18 → 1.7.20

package/connector/proxy/index.js

@@ -51,7 +51,7 @@ function getBasicAuth({ apiKey }) {
   return Buffer.from(`${apiKey}:`).toString('base64');
 }
 
-async function getUserInfo({ authHeader, hostname, additionalInfo, platform, apiKey, proxyId, proxyConfig } = {}) {
+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
@@ -72,6 +72,7 @@ async function getUserInfo({ authHeader, hostname, additionalInfo, platform, api
       apiKey,
       hostname,
       platform,
+      userEmail,
     },
     user: {},
     authHeader

package/handlers/auth.js

@@ -7,7 +7,7 @@ const adminCore = require('./admin');
 const { Connector } = require('../models/dynamo/connectorSchema');
 const { handleDatabaseError } = require('../lib/errorHandler');
 
-async function onOAuthCallback({ platform, hostname, tokenUrl, query, isFromMCP = false }) {
+async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcExtensionId, isFromMCP = false }) {
     const callbackUri = query.callbackUri;
     const apiUrl = query.apiUrl;
     const username = query.username;
@@ -54,6 +54,7 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, isFromMCP
                 refreshToken,
                 tokenExpiry: isNaN(expires) ? null : expires,
                 rcAccountId: query?.rcAccountId,
+                hashedRcExtensionId,
                 proxyId
             });
         }
@@ -76,7 +77,7 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, isFromMCP
     }
 }
 
-async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, additionalInfo }) {
+async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId, hashedRcExtensionId, additionalInfo }) {
     const platformModule = connectorRegistry.getConnector(platform);
     const basicAuth = platformModule.getBasicAuth({ apiKey });
     const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader: `Basic ${basicAuth}`, hostname, platform, additionalInfo, apiKey, proxyId });
@@ -88,6 +89,8 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, additionalIn
                 platform,
                 hostname,
                 proxyId,
+                hashedRcExtensionId,
+                rcAccountId,
                 accessToken: platformUserInfo.overridingApiKey ?? apiKey
             });
         }
@@ -110,7 +113,7 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, additionalIn
     }
 }
 
-async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken, refreshToken, tokenExpiry, rcAccountId, proxyId }) {
+async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken, refreshToken, tokenExpiry, rcAccountId, hashedRcExtensionId, proxyId }) {
     const id = platformUserInfo.id;
     const name = platformUserInfo.name;
     const existingUser = await UserModel.findByPk(id);
@@ -130,6 +133,7 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
                     refreshToken,
                     tokenExpiry,
                     rcAccountId,
+                    hashedRcExtensionId,
                     platformAdditionalInfo: {
                         ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
                         ...platformAdditionalInfo,
@@ -143,57 +147,20 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
     }
     else {
         try {
-            // TEMP: replace user with old ID
-            if (id.endsWith(`-${platform}`)) {
-                const oldID = id.split('-');
-                const userWithOldID = await UserModel.findByPk(oldID[0]);
-                if (userWithOldID) {
-                    await UserModel.create({
-                        id,
-                        hostname,
-                        timezoneName,
-                        timezoneOffset,
-                        platform,
-                        accessToken,
-                        refreshToken,
-                        tokenExpiry,
-                        rcAccountId,
-                        platformAdditionalInfo,
-                        userSettings: userWithOldID.userSettings
-                    });
-                    await userWithOldID.destroy();
-                }
-                else {
-                    await UserModel.create({
-                        id,
-                        hostname,
-                        timezoneName,
-                        timezoneOffset,
-                        platform,
-                        accessToken,
-                        refreshToken,
-                        tokenExpiry,
-                        rcAccountId,
-                        platformAdditionalInfo,
-                        userSettings: {}
-                    });
-                }
-            }
-            else {
-                await UserModel.create({
-                    id,
-                    hostname,
-                    timezoneName,
-                    timezoneOffset,
-                    platform,
-                    accessToken,
-                    refreshToken,
-                    tokenExpiry,
-                    rcAccountId,
-                    platformAdditionalInfo,
-                    userSettings: {}
-                });
-            }
+            await UserModel.create({
+                id,
+                hostname,
+                timezoneName,
+                timezoneOffset,
+                platform,
+                accessToken,
+                refreshToken,
+                tokenExpiry,
+                rcAccountId,
+                hashedRcExtensionId,
+                platformAdditionalInfo,
+                userSettings: {}
+            });
         }
         catch (error) {
             return handleDatabaseError(error, 'Error saving user info');
@@ -206,8 +173,16 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
 }
 
 async function getLicenseStatus({ userId, platform }) {
+    const user = await UserModel.findByPk(userId);
+    if (!user) {
+        return {
+            isLicenseValid: false,
+            licenseStatus: 'Invalid (User not found)',
+            licenseStatusDescription: ''
+        }
+    }
     const platformModule = connectorRegistry.getConnector(platform);
-    const licenseStatus = await platformModule.getLicenseStatus({ userId, platform });
+    const licenseStatus = await platformModule.getLicenseStatus({ userId, platform, user });
     return licenseStatus;
 }
 

package/handlers/log.js

@@ -2,6 +2,7 @@ const Op = require('sequelize').Op;
 const { CallLogModel } = require('../models/callLogModel');
 const { MessageLogModel } = require('../models/messageLogModel');
 const { UserModel } = require('../models/userModel');
+const { CacheModel } = require('../models/cacheModel');
 const oauth = require('../lib/oauth');
 const { composeCallLog } = require('../lib/callLogComposer');
 const { composeSharedSMSLog } = require('../lib/sharedSMSComposer');
@@ -11,11 +12,14 @@ const { NoteCache } = require('../models/dynamo/noteCacheSchema');
 const { Connector } = require('../models/dynamo/connectorSchema');
 const moment = require('moment');
 const { getMediaReaderLinkByPlatformMediaLink } = require('../lib/util');
+const axios = require('axios');
+const { getPluginsFromUserSettings } = require('../lib/util');
 const logger = require('../lib/logger');
 const { handleApiError, handleDatabaseError } = require('../lib/errorHandler');
+const { v4: uuidv4 } = require('uuid');
 const { AccountDataModel } = require('../models/accountDataModel');
 
-async function createCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
+async function createCallLog({ jwtToken, platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         let existingCallLog = null;
         try {
@@ -55,6 +59,7 @@ async function createCallLog({ platform, userId, incomingData, hashedAccountId,
                 }
             };
         }
+
         const platformModule = connectorRegistry.getConnector(platform);
         const callLog = incomingData.logInfo;
         const additionalSubmission = incomingData.additionalSubmission;
@@ -115,6 +120,64 @@ async function createCallLog({ platform, userId, incomingData, hashedAccountId,
             name: incomingData.contactName ?? ""
         };
 
+
+        const pluginAsyncTaskIds = [];
+        // Plugins
+        const loggingPlugins = getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'call' });
+        for (const pluginSetting of loggingPlugins) {
+            const pluginId = pluginSetting.id;
+            let pluginDataResponse = null;
+            switch (pluginSetting.value.access) {
+                case 'public':
+                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?type=plugin`);
+                    break;
+                case 'private':
+                case 'shared':
+                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
+                    break;
+                default:
+                    throw new Error('Invalid plugin access');
+            }
+            const pluginData = pluginDataResponse.data;
+            const pluginManifest = pluginData.platforms[pluginSetting.value.name];
+            let pluginEndpointUrl = pluginManifest.endpointUrl;
+            if (!pluginEndpointUrl) {
+                throw new Error('Plugin URL is not set');
+            }
+            else {
+                // check if endpoint has query params already
+                if (pluginEndpointUrl.includes('?')) {
+                    pluginEndpointUrl += `&jwtToken=${jwtToken}`;
+                }
+                else {
+                    pluginEndpointUrl += `?jwtToken=${jwtToken}`;
+                }
+            }
+            if (pluginSetting.value.isAsync) {
+                const asyncTaskId = `${userId}-${uuidv4()}`;
+                pluginAsyncTaskIds.push(asyncTaskId);
+                await CacheModel.create({
+                    id: asyncTaskId,
+                    status: 'initialized',
+                    userId,
+                    cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                    expiry: moment().add(1, 'hour').toDate()
+                });
+                axios.post(pluginEndpointUrl, {
+                    data: incomingData,
+                    asyncTaskId
+                });
+            }
+            else {
+                const processedResultResponse = await axios.post(pluginEndpointUrl, {
+                    data: incomingData
+                });
+                // eslint-disable-next-line no-param-reassign
+                incomingData = processedResultResponse.data;
+                note = incomingData.note;
+            }
+        }
+
         // Compose call log details centrally
         const logFormat = platformModule.getLogFormatType ? platformModule.getLogFormatType(platform, proxyConfig) : LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT;
         let composedLogDetails = '';
@@ -179,8 +242,8 @@ async function createCallLog({ platform, userId, incomingData, hashedAccountId,
             catch (error) {
                 return handleDatabaseError(error, 'Error creating call log');
             }
+            return { successful: !!logId, logId, returnMessage, extraDataTracking, pluginAsyncTaskIds };
         }
-        return { successful: !!logId, logId, returnMessage, extraDataTracking };
     } catch (e) {
         return handleApiError(e, platform, 'createCallLog', { userId });
     }
@@ -285,7 +348,7 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
     }
 }
 
-async function updateCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
+async function updateCallLog({ jwtToken, platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         let existingCallLog = null;
         try {
@@ -299,11 +362,11 @@ async function updateCallLog({ platform, userId, incomingData, hashedAccountId,
             return handleDatabaseError(error, 'Error finding existing call log');
         }
         if (existingCallLog) {
-            const platformModule = connectorRegistry.getConnector(platform);
             let user = await UserModel.findByPk(userId);
             if (!user || !user.accessToken) {
                 return { successful: false, message: `Contact not found` };
             }
+            const platformModule = connectorRegistry.getConnector(platform);
             const proxyId = user.platformAdditionalInfo?.proxyId;
             let proxyConfig = null;
             if (proxyId) {
@@ -334,6 +397,61 @@ async function updateCallLog({ platform, userId, incomingData, hashedAccountId,
                     break;
             }
 
+            const pluginAsyncTaskIds = [];
+            // Plugins
+            const plugins = getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'call' });
+            for (const pluginSetting of plugins) {
+                const pluginId = pluginSetting.id;
+                let pluginDataResponse = null;
+                switch (pluginSetting.value.access) {
+                    case 'public':
+                        pluginDataResponse = await axios.get(`${process.env.DEV_PORTAL_URL}/public-api/connectors/${pluginId}/manifest?type=plugin`);
+                        break;
+                    case 'private':
+                    case 'shared':
+                        pluginDataResponse = await axios.get(`${process.env.DEV_PORTAL_URL}/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
+                        break;
+                    default:
+                        throw new Error('Invalid plugin access');
+                }
+                const pluginData = pluginDataResponse.data;
+                const pluginManifest = pluginData.platforms[pluginSetting.value.name];
+                let pluginEndpointUrl = pluginManifest.endpointUrl;
+                if (!pluginEndpointUrl) {
+                    throw new Error('Plugin URL is not set');
+                }
+                else {
+                    if (pluginEndpointUrl.includes('?')) {
+                        pluginEndpointUrl += `&jwtToken=${jwtToken}`;
+                    }
+                    else {
+                        pluginEndpointUrl += `?jwtToken=${jwtToken}`;
+                    }
+                }
+                if (pluginSetting.value.isAsync) {
+                    const asyncTaskId = `${userId}-${uuidv4()}`;
+                    pluginAsyncTaskIds.push(asyncTaskId);
+                    await CacheModel.create({
+                        id: asyncTaskId,
+                        status: 'initialized',
+                        userId,
+                        cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                        expiry: moment().add(1, 'hour').toDate()
+                    });
+                    axios.post(pluginEndpointUrl, {
+                        data: { logInfo: incomingData },
+                        asyncTaskId
+                    });
+                }
+                else {
+                    const processedResultResponse = await axios.post(pluginEndpointUrl, {
+                        data: incomingData
+                    });
+                    // eslint-disable-next-line no-param-reassign
+                    incomingData = processedResultResponse.data;
+                }
+            }
+
             // Fetch existing call log details once to avoid duplicate API calls
             let existingCallLogDetails = null;    // Compose updated call log details centrally
             const logFormat = platformModule.getLogFormatType ? platformModule.getLogFormatType(platform, proxyConfig) : LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT;
@@ -416,12 +534,7 @@ async function updateCallLog({ platform, userId, incomingData, hashedAccountId,
                 isFromSSCL,
                 proxyConfig,
             });
-            if (!extraDataTracking) {
-                extraDataTracking = {};
-            }
-            extraDataTracking.withSmartNoteLog = !!incomingData.aiNote;
-            extraDataTracking.withTranscript = !!incomingData.transcript;
-            return { successful: true, logId: existingCallLog.thirdPartyLogId, updatedNote, returnMessage, extraDataTracking };
+            return { successful: true, logId: existingCallLog.thirdPartyLogId, updatedNote, returnMessage, extraDataTracking, pluginAsyncTaskIds };
         }
         return { successful: false };
     } catch (e) {
@@ -518,6 +631,65 @@ async function createMessageLog({ platform, userId, incomingData }) {
         const ownerName = incomingData.logInfo.owner?.name;
         const isSharedSMS = !!ownerName;
 
+        const pluginAsyncTaskIds = [];
+        // Plugins
+        const isSMS = incomingData.logInfo.messages.some(m => m.type === 'SMS');
+        const isFax = incomingData.logInfo.messages.some(m => m.type === 'Fax');
+        const smsPlugins = isSMS ? getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'sms' }) : [];
+        const faxPlugins = isFax ? getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'fax' }) : [];
+        const plugins = [...smsPlugins, ...faxPlugins];
+        for (const pluginSetting of plugins) {
+            const pluginId = pluginSetting.id;
+            let pluginDataResponse = null;
+            switch (pluginSetting.value.access) {
+                case 'public':
+                    pluginDataResponse = await axios.get(`${process.env.DEV_PORTAL_URL}/public-api/connectors/${pluginId}/manifest?type=plugin`);
+                    break;
+                case 'private':
+                case 'shared':
+                    pluginDataResponse = await axios.get(`${process.env.DEV_PORTAL_URL}/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
+                    break;
+                default:
+                    throw new Error('Invalid plugin access');
+            }
+            const pluginData = pluginDataResponse.data;
+            const pluginManifest = pluginData.platforms[pluginSetting.value.name];
+            let pluginEndpointUrl = pluginManifest.endpointUrl;
+            if (!pluginEndpointUrl) {
+                throw new Error('Plugin URL is not set');
+            }
+            else {
+                if (pluginEndpointUrl.includes('?')) {
+                    pluginEndpointUrl += `&jwtToken=${jwtToken}`;
+                }
+                else {
+                    pluginEndpointUrl += `?jwtToken=${jwtToken}`;
+                }
+            }
+            if (pluginSetting.value.isAsync) {
+                const asyncTaskId = `${userId}-${uuidv4()}`;
+                pluginAsyncTaskIds.push(asyncTaskId);
+                await CacheModel.create({
+                    id: asyncTaskId,
+                    status: 'initialized',
+                    userId,
+                    cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                    expiry: moment().add(1, 'hour').toDate()
+                });
+                axios.post(pluginEndpointUrl, {
+                    data: { logInfo: incomingData },
+                    asyncTaskId
+                });
+            }
+            else {
+                const processedResultResponse = await axios.post(pluginEndpointUrl, {
+                    data: incomingData
+                });
+                // eslint-disable-next-line no-param-reassign
+                incomingData = processedResultResponse.data;
+            }
+        }
+
         let messageIds = [];
         const correspondents = [];
         if (isGroupSMS) {

package/handlers/plugin.js

@@ -0,0 +1,27 @@
+const { CacheModel } = require('../models/cacheModel');
+const { Op } = require('sequelize');
+
+async function getPluginAsyncTasks({ asyncTaskIds }) {
+    const caches = await CacheModel.findAll({
+        where: {
+            id: {
+                [Op.in]: asyncTaskIds
+            }
+        }
+    });
+    const result = caches.map(cache => ({
+        cacheKey: cache.cacheKey,
+        status: cache.status
+    }));
+    const toRemoveCaches = caches.filter(cache => cache.status === 'completed' || cache.status === 'failed');
+    await CacheModel.destroy({
+        where: {
+            id: {
+                [Op.in]: toRemoveCaches.map(cache => cache.id)
+            }
+        }
+    });
+    return result;
+}
+
+exports.getPluginAsyncTasks = getPluginAsyncTasks;

package/handlers/user.js

@@ -49,7 +49,10 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
             const keys = Object.keys(userSettingsByAdmin.userSettings).concat(Object.keys(userSettings));
             // distinct keys
             for (const key of new Set(keys)) {
-                // from user's own settings
+                // marked as removed
+                if (userSettingsByAdmin.userSettings[key]?.isRemoved) {
+                    continue;
+                }
                 if ((userSettingsByAdmin.userSettings[key] === undefined || userSettingsByAdmin.userSettings[key].customizable) && userSettings[key] !== undefined) {
                     result[key] = {
                         customizable: true,
@@ -57,6 +60,27 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
                         defaultValue: userSettings[key].defaultValue,
                         options: userSettings[key].options
                     };
+                    // Special case: plugins
+                    if (key.startsWith('plugin_')) {
+                        const config = Object.keys(result[key].value.config)?.length === 0 ? null : result[key].value.config;
+                        if (config) {
+                            const configFromadminSettings = userSettingsByAdmin.userSettings[key].value.config ?? {};
+                            for (const k in config) {
+                                // use admin setting to replace, if not customizable
+                                if (configFromadminSettings[k] && !configFromadminSettings[k].customizable || !config[k].value && configFromadminSettings[k].value) {
+                                    config[k] = configFromadminSettings[k];
+                                }
+                                else {
+                                    config[k].customizable = configFromadminSettings[k].customizable;
+                                }
+                            }
+                            result[key].value.config = config;
+                        }
+                        //Case: no config at all, use admin setting directly
+                        else {
+                            result[key].value.config = userSettingsByAdmin.userSettings[key].value.config;
+                        }
+                    }
                 }
                 // from admin settings
                 else {
@@ -68,7 +92,7 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
     return result;
 }
 
-async function updateUserSettings({ user, userSettings, platformName }) {
+async function updateUserSettings({ user, userSettings, settingKeysToRemove, platformName }) {
     const keys = Object.keys(userSettings || {});
     let updatedSettings = {
         ...(user.userSettings || {})
@@ -76,6 +100,11 @@ async function updateUserSettings({ user, userSettings, platformName }) {
     for (const k of keys) {
         updatedSettings[k] = userSettings[k];
     }
+    for (const k of settingKeysToRemove) {
+        if (updatedSettings[k]) {
+            delete updatedSettings[k];
+        }
+    }
     const platformModule = connectorRegistry.getConnector(platformName);
     if (platformModule.onUpdateUserSettings) {
         const { successful, returnMessage } = await platformModule.onUpdateUserSettings({ user, userSettings, updatedSettings });