@app-connect/core 1.7.5 → 1.7.10

package/handlers/admin.js

@@ -5,6 +5,8 @@ const oauth = require('../lib/oauth');
 const { RingCentral } = require('../lib/ringcentral');
 const { Connector } = require('../models/dynamo/connectorSchema');
 
+const CALL_AGGREGATION_GROUPS = ["Company", "CompanyNumbers", "Users", "Queues", "IVRs", "IVAs", "SharedLines", "UserGroups", "Sites", "Departments"]
+
 async function validateAdminRole({ rcAccessToken }) {
     const rcExtensionResponse = await axios.get(
         'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
@@ -72,7 +74,7 @@ async function updateServerLoggingSettings({ user, additionalFieldValues }) {
     return {};
 }
 
-async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo }) {
+async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo, groupBy }) {
     try {
         if (!process.env.RINGCENTRAL_SERVER || !process.env.RINGCENTRAL_CLIENT_ID || !process.env.RINGCENTRAL_CLIENT_SECRET) {
             return {
@@ -99,29 +101,39 @@ async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo }) {
             token: { access_token: adminConfig.adminAccessToken, token_type: 'Bearer' },
             timezone,
             timeFrom,
-            timeTo
+            timeTo,
+            groupBy: groupBy == 'undefined' ? CALL_AGGREGATION_GROUPS[0] : groupBy
         });
-        var dataCounter = callsAggregationData.data.records[0].counters;
-        var inboundCallCount = dataCounter.callsByDirection.values.inbound;
-        var outboundCallCount = dataCounter.callsByDirection.values.outbound;
-        var answeredCallCount = dataCounter.callsByResponse.values.answered;
-        // keep 2 decimal places
-        var answeredCallPercentage = inboundCallCount === 0 ? '0%' : `${((answeredCallCount / inboundCallCount) * 100).toFixed(2)}%`;
-
-        var dataTimer = callsAggregationData.data.records[0].timers;
-        // keep 2 decimal places
-        var totalTalkTime = (dataTimer.allCalls.values / 60).toFixed(2);
-        // keep 2 decimal places
-        var averageTalkTime = (totalTalkTime / (inboundCallCount + outboundCallCount)).toFixed(2);
-        return {
-            callLogStats: {
+        var callLogStats = [];
+        var itemKeys = [];
+        for (const record of callsAggregationData.data.records) {
+            if(!record?.info?.name){
+                continue;
+            }
+            itemKeys.push(record.info.name);
+            var dataCounter = record.counters;
+            var inboundCallCount = dataCounter.callsByDirection.values.inbound;
+            var outboundCallCount = dataCounter.callsByDirection.values.outbound;
+            var answeredCallCount = dataCounter.callsByResponse.values.answered;
+            // keep 2 decimal places
+            var answeredCallPercentage = inboundCallCount === 0 ? '0%' : `${((answeredCallCount / inboundCallCount) * 100).toFixed(2)}%`;
+            var totalTalkTime = Number(record.timers.allCalls.values) === 0 ? 0 : Number(record.timers.allCalls.values).toFixed(2);
+            var averageTalkTime = Number(totalTalkTime) === 0 ? 0 : (Number(totalTalkTime) / (inboundCallCount + outboundCallCount)).toFixed(2);
+            callLogStats.push({
+                name: record.info.name,
                 inboundCallCount,
                 outboundCallCount,
                 answeredCallCount,
                 answeredCallPercentage,
                 totalTalkTime,
                 averageTalkTime
-            }
+            });
+        }
+        return {
+            callLogStats,
+            itemKeys,
+            groupedBy: callsAggregationData.data.groupedBy,
+            groupKeys: CALL_AGGREGATION_GROUPS
         };
     } catch (error) {
         console.error(error);

package/handlers/auth.js

@@ -6,13 +6,18 @@ const { RingCentral } = require('../lib/ringcentral');
 const adminCore = require('./admin');
 const { Connector } = require('../models/dynamo/connectorSchema');
 
-async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiUrl, username, query, proxyId }) {
+async function onOAuthCallback({ platform, hostname, tokenUrl, query }) {
+    const callbackUri = query.callbackUri;
+    const apiUrl = query.apiUrl;
+    const username = query.username;
+    const proxyId = query.proxyId;
+    const userEmail = query.userEmail;
     const platformModule = connectorRegistry.getConnector(platform);
     let proxyConfig = null;
     if (proxyId) {
         proxyConfig = await Connector.getProxyConfig(proxyId);
     }
-    const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId, proxyId, proxyConfig });
+    const oauthInfo = await platformModule.getOauthInfo({ tokenUrl, hostname, rcAccountId: query.rcAccountId, proxyId, proxyConfig, userEmail });
 
     if (oauthInfo.failMessage) {
         return {
@@ -27,12 +32,13 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiU
     // Some platforms require different oauth queries, this won't affect normal OAuth process unless CRM module implements getOverridingOAuthOption() method
     let overridingOAuthOption = null;
     if (platformModule.getOverridingOAuthOption != null) {
-        overridingOAuthOption = platformModule.getOverridingOAuthOption({ code: callbackUri.split('code=')[1] });
+        const code = new URL(callbackUri).searchParams.get('code');
+        overridingOAuthOption = platformModule.getOverridingOAuthOption({ code });
     }
     const oauthApp = oauth.getOAuthApp(oauthInfo);
     const { accessToken, refreshToken, expires } = await oauthApp.code.getToken(callbackUri, overridingOAuthOption);
     const authHeader = `Bearer ${accessToken}`;
-    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl, apiUrl, hostname, platform, username, callbackUri, query, proxyId, proxyConfig });
+    const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl, apiUrl, hostname, platform, username, callbackUri, query, proxyId, proxyConfig, userEmail });
 
     if (successful) {
         let userInfo = await saveUserInfo({

package/handlers/calldown.js

@@ -53,8 +53,41 @@ async function markCalled({ jwtToken, id, lastCallAt }) {
     return { successful: true };
 }
 
+async function update({ jwtToken, id, updateData }) {
+    const unAuthData = jwt.decodeJwt(jwtToken);
+    if (!unAuthData?.id) throw new Error('Unauthorized');
+    
+    // Prepare the update object with only valid fields
+    const allowedFields = ['contactId', 'contactType', 'contactName', 'phoneNumber', 'status', 'scheduledAt', 'lastCallAt', 'note'];
+    const updateObject = {};
+    
+    // Filter and prepare update data
+    Object.keys(updateData).forEach(key => {
+        if (allowedFields.includes(key)) {
+            let value = updateData[key];
+            
+            // Handle date fields
+            if ((key === 'scheduledAt' || key === 'lastCallAt') && value) {
+                value = new Date(value);
+            }
+            
+            updateObject[key] = value;
+        }
+    });
+    
+    // If no valid fields to update, throw error
+    if (Object.keys(updateObject).length === 0) {
+        throw new Error('No valid fields to update');
+    }
+    
+    const [affected] = await CallDownListModel.update(updateObject, { where: { id, userId: unAuthData.id } });
+    if (!affected) throw new Error('Not found');
+    return { successful: true };
+}
+
 exports.schedule = schedule;
 exports.list = list;
 exports.remove = remove;
 exports.markCalled = markCalled;
+exports.update = update;
 

package/handlers/contact.js

@@ -3,8 +3,11 @@ const { UserModel } = require('../models/userModel');
 const errorMessage = require('../lib/generalErrorMessage');
 const connectorRegistry = require('../connector/registry');
 const { Connector } = require('../models/dynamo/connectorSchema');
+const { DebugTracer } = require('../lib/debugTracer');
+const { AccountDataModel } = require('../models/accountDataModel');
 
-async function findContact({ platform, userId, phoneNumber, overridingFormat, isExtension }) {
+async function findContact({ platform, userId, phoneNumber, overridingFormat, isExtension, tracer, isForceRefreshAccountData = false }) {
+    tracer?.trace('handler.findContact:entered', { platform, userId, phoneNumber });
     try {
         let user = await UserModel.findOne({
             where: {
@@ -12,7 +15,10 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                 platform
             }
         });
+        tracer?.trace('handler.findContact:userFound', { user });
+
         if (!user || !user.accessToken) {
+            tracer?.trace('handler.findContact:noUser', { userId });
             return {
                 successful: false,
                 returnMessage: {
@@ -22,30 +28,73 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                 }
             };
         }
+        // find cached contact by composite key; findByPk expects raw PK values, so use where clause
+        const existingMatchedContactInfo = await AccountDataModel.findOne({
+            where: {
+                rcAccountId: user.rcAccountId,
+                platformName: platform,
+                dataKey: `contact-${phoneNumber}`
+            }
+        })
+        if (!isForceRefreshAccountData) {
+            if (existingMatchedContactInfo) {
+                console.log('found existing matched contact info in account data');
+                return { successful: true, returnMessage: null, contact: existingMatchedContactInfo.data, extraDataTracking: null };
+            }
+        }
         const proxyId = user.platformAdditionalInfo?.proxyId;
         let proxyConfig = null;
         if (proxyId) {
             proxyConfig = await Connector.getProxyConfig(proxyId);
+            tracer?.trace('handler.findContact:proxyConfig', { proxyConfig });
         }
         const platformModule = connectorRegistry.getConnector(platform);
         const authType = await platformModule.getAuthType({ proxyId, proxyConfig });
+        tracer?.trace('handler.findContact:authType', { authType });
+
         let authHeader = '';
         switch (authType) {
             case 'oauth':
                 const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname, proxyId, proxyConfig })));
                 user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
                 authHeader = `Bearer ${user.accessToken}`;
+                tracer?.trace('handler.findContact:oauthAuth', { authHeader });
                 break;
             case 'apiKey':
                 const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
                 authHeader = `Basic ${basicAuth}`;
+                tracer?.trace('handler.findContact:apiKeyAuth', {});
                 break;
         }
-        const { successful, matchedContactInfo, returnMessage, extraDataTracking } = await platformModule.findContact({ user, authHeader, phoneNumber, overridingFormat, isExtension, proxyConfig });
+
+        const { successful, matchedContactInfo, returnMessage, extraDataTracking } = await platformModule.findContact({ user, authHeader, phoneNumber, overridingFormat, isExtension, proxyConfig, tracer, isForceRefreshAccountData });
+        tracer?.trace('handler.findContact:platformFindResult', { successful, matchedContactInfo });
+
         if (matchedContactInfo != null && matchedContactInfo?.filter(c => !c.isNewContact)?.length > 0) {
+            tracer?.trace('handler.findContact:contactsFound', { count: matchedContactInfo.length });
+            // save in org data
+            // Danger: it does NOT support one RC account mapping to multiple CRM platforms, because contacts will be shared
+            if (user.rcAccountId) {
+                if(existingMatchedContactInfo)
+                {
+                    await existingMatchedContactInfo.update({
+                        data: matchedContactInfo
+                    });
+                }
+                else{
+                    await AccountDataModel.create({
+                        rcAccountId: user.rcAccountId,
+                        platformName: platform,
+                        dataKey: `contact-${phoneNumber}`,
+                        data: matchedContactInfo
+                    });
+                }
+                console.log('store new matched contact info in account data');
+            }
             return { successful, returnMessage, contact: matchedContactInfo, extraDataTracking };
         }
         else {
+            tracer?.trace('handler.findContact:noContactsMatched', { matchedContactInfo });
             if (returnMessage) {
                 return {
                     successful,
@@ -78,6 +127,8 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
         }
     } catch (e) {
         console.error(`platform: ${platform} \n${e.stack} \n${JSON.stringify(e.response?.data)}`);
+        tracer?.traceError('handler.findContact:error', e, { platform, statusCode: e.response?.status });
+
         if (e.response?.status === 429) {
             return {
                 successful: false,
@@ -161,7 +212,7 @@ async function createContact({ platform, userId, phoneNumber, newContactName, ne
             return { successful: false, returnMessage };
         }
     } catch (e) {
-        console.log(`platform: ${platform} \n${e.stack}`);
+        console.error(`platform: ${platform} \n${e.stack}`);
         if (e.response?.status === 429) {
             return {
                 successful: false,

package/handlers/log.js

@@ -194,7 +194,7 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
         }
         let logs = [];
         let returnMessage = null;
-        let extraDataTracking = {};;
+        let extraDataTracking = {};
 
         // Handle undefined or null sessionIds
         if (!sessionIds) {
@@ -303,7 +303,7 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
                             {
                                 id: '1',
                                 type: 'text',
-                                text: `Please check if your account has permission to CREATE logs.`
+                                text: `Please check if your account has permission to READ logs.`
                             }
                         ]
                     }
@@ -483,7 +483,7 @@ async function updateCallLog({ platform, userId, incomingData, hashedAccountId,
 async function createMessageLog({ platform, userId, incomingData }) {
     try {
         let returnMessage = null;
-        let extraDataTracking = {};;
+        let extraDataTracking = {};
         if (incomingData.logInfo.messages.length === 0) {
             return {
                 successful: false,
@@ -625,7 +625,7 @@ async function createMessageLog({ platform, userId, incomingData }) {
         return { successful: true, logIds, returnMessage, extraDataTracking };
     }
     catch (e) {
-        console.log(`platform: ${platform} \n${e.stack}`);
+        console.error(`platform: ${platform} \n${e.stack}`);
         if (e.response?.status === 429) {
             return {
                 successful: false,