@app-connect/core 1.6.4-beta.0 → 1.7.0-beta.1

package/handlers/admin.js

@@ -2,6 +2,7 @@ const axios = require('axios');
 const { AdminConfigModel } = require('../models/adminConfigModel');
 const adapterRegistry = require('../adapter/registry');
 const oauth = require('../lib/oauth');
+const { RingCentral } = require('../lib/ringcentral');
 
 async function validateAdminRole({ rcAccessToken }) {
     const rcExtensionResponse = await axios.get(
@@ -36,6 +37,21 @@ async function getAdminSettings({ hashedRcAccountId }) {
     return existingAdminConfig;
 }
 
+async function updateAdminRcTokens({ hashedRcAccountId, adminAccessToken, adminRefreshToken, adminTokenExpiry }) {
+    const existingAdminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
+    if (existingAdminConfig) {
+        await existingAdminConfig.update({ adminAccessToken, adminRefreshToken, adminTokenExpiry });
+    }
+    else {
+        await AdminConfigModel.create({
+            id: hashedRcAccountId,
+            adminAccessToken,
+            adminRefreshToken,
+            adminTokenExpiry
+        });
+    }
+}
+
 async function getServerLoggingSettings({ user }) {
     const platformModule = adapterRegistry.getAdapter(user.platform);
     if (platformModule.getServerLoggingSettings) {
@@ -55,8 +71,259 @@ async function updateServerLoggingSettings({ user, additionalFieldValues }) {
     return {};
 }
 
+async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo }) {
+    try {
+        const rcSDK = new RingCentral({
+            server: process.env.RINGCENTRAL_SERVER,
+            clientId: process.env.RINGCENTRAL_CLIENT_ID,
+            clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
+            redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
+        });
+        let adminConfig = await AdminConfigModel.findByPk(rcAccountId);
+        const isTokenExpired = adminConfig.adminTokenExpiry < new Date();
+        if (isTokenExpired) {
+            const { access_token, refresh_token, expire_time } = await rcSDK.refreshToken({
+                refresh_token: adminConfig.adminRefreshToken,
+                expires_in: adminConfig.adminTokenExpiry,
+                refresh_token_expires_in: adminConfig.adminTokenExpiry
+            });
+            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: rcAccountId } });
+        }
+        const callsAggregationData = await rcSDK.getCallsAggregationData({
+            token: { access_token: adminConfig.adminAccessToken, token_type: 'Bearer' },
+            timezone,
+            timeFrom,
+            timeTo
+        });
+        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: {
+                inboundCallCount,
+                outboundCallCount,
+                answeredCallCount,
+                answeredCallPercentage,
+                totalTalkTime,
+                averageTalkTime
+            }
+        };
+    } catch (error) {
+        console.error(error);
+        return {
+            callLogStats: {}
+        };
+    }
+}
+
+async function getUserReport({ rcAccountId, rcExtensionId, timezone, timeFrom, timeTo }) {
+    try {
+        const rcSDK = new RingCentral({
+            server: process.env.RINGCENTRAL_SERVER,
+            clientId: process.env.RINGCENTRAL_CLIENT_ID,
+            clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
+            redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
+        });
+        let adminConfig = await AdminConfigModel.findByPk(rcAccountId);
+        const isTokenExpired = adminConfig.adminTokenExpiry < new Date();
+        if (isTokenExpired) {
+            const { access_token, refresh_token, expire_time } = await rcSDK.refreshToken({
+                refresh_token: adminConfig.adminRefreshToken,
+                expires_in: adminConfig.adminTokenExpiry,
+                refresh_token_expires_in: adminConfig.adminTokenExpiry
+            });
+            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: rcAccountId } });
+        }
+        const callLogData = await rcSDK.getCallLogData({
+            extensionId: rcExtensionId,
+            token: { access_token: adminConfig.adminAccessToken, token_type: 'Bearer' },
+            timezone,
+            timeFrom,
+            timeTo
+        });
+        // phone activity
+        const inboundCallCount = callLogData.records.filter(call => call.direction === 'Inbound').length;
+        const outboundCallCount = callLogData.records.filter(call => call.direction === 'Outbound').length;
+        const answeredCallCount = callLogData.records.filter(call => call.direction === 'Inbound' && (call.result === 'Call connected' || call.result === 'Accepted' || call.result === 'Answered Not Accepted')).length;
+        const answeredCallPercentage = answeredCallCount === 0 ? '0%' : `${((answeredCallCount / (inboundCallCount || 1)) * 100).toFixed(2)}%`;
+        // phone engagement
+        const totalTalkTime = Math.round(callLogData.records.reduce((acc, call) => acc + (call.duration || 0), 0) / 60) || 0;
+        const averageTalkTime = Math.round(totalTalkTime / (inboundCallCount + outboundCallCount)) || 0;
+        const smsLogData = await rcSDK.getSMSData({
+            extensionId: rcExtensionId,
+            token: { access_token: adminConfig.adminAccessToken, token_type: 'Bearer' },
+            timezone,
+            timeFrom,
+            timeTo
+        });
+        const smsSentCount = smsLogData.records.filter(sms => sms.direction === 'Outbound').length;
+        const smsReceivedCount = smsLogData.records.filter(sms => sms.direction === 'Inbound').length;
+        const reportStats = {
+            callLogStats: {
+                inboundCallCount,
+                outboundCallCount,
+                answeredCallCount,
+                answeredCallPercentage,
+                totalTalkTime,
+                averageTalkTime
+            },
+            smsLogStats: {
+                smsSentCount,
+                smsReceivedCount
+            }
+        };
+        return reportStats;
+    } catch (error) {
+        console.error(error);
+        return null;
+    }
+}
+
+async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
+    const adminConfig = await getAdminSettings({ hashedRcAccountId });
+    const platformModule = adapterRegistry.getAdapter(user.platform);
+    if (platformModule.getUserList) {
+        const authType = platformModule.getAuthType();
+        let authHeader = '';
+        switch (authType) {
+            case 'oauth':
+                const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
+                // eslint-disable-next-line no-param-reassign
+                user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
+                authHeader = `Bearer ${user.accessToken}`;
+                break;
+            case 'apiKey':
+                const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
+                authHeader = `Basic ${basicAuth}`;
+                break;
+        }
+        const crmUserList = await platformModule.getUserList({ user, authHeader });
+        const userMappingResult = [];
+        const newUserMappings = [];
+        for (const crmUser of crmUserList) {
+            const existingMapping = adminConfig?.userMappings?.find(u => u.crmUserId == crmUser.id);
+            let existingMappingRcExtensionIds = [];
+            // TEMP: backward compatibility for string value
+            if (existingMapping?.rcExtensionId) {
+                if (typeof (existingMapping.rcExtensionId) === 'string') {
+                    existingMappingRcExtensionIds = [existingMapping.rcExtensionId];
+                }
+                else {
+                    existingMappingRcExtensionIds = existingMapping.rcExtensionId;
+                }
+            }
+            const rcExtension = rcExtensionList.filter(e => existingMappingRcExtensionIds.includes(e.id));
+            // Case: existing mapping
+            if (existingMapping) {
+                userMappingResult.push({
+                    crmUser: {
+                        id: crmUser.id,
+                        name: crmUser.name ?? '',
+                        email: crmUser.email ?? '',
+                    },
+                    rcUser: rcExtension.map(e => ({
+                        extensionId: e.id,
+                        name: e?.name || `${e.firstName} ${e.lastName}`,
+                        extensionNumber: e?.extensionNumber ?? '',
+                        email: e?.email ?? ''
+                    }))
+                });
+            }
+            // Case: new mapping
+            else {
+                const rcExtensionForNewMapping = rcExtensionList.find(u =>
+                    u.email === crmUser.email ||
+                    u.name === crmUser.name ||
+                    (`${u.firstName} ${u.lastName}` === crmUser.name)
+                );
+                if (rcExtensionForNewMapping) {
+                    userMappingResult.push({
+                        crmUser: {
+                            id: crmUser.id,
+                            name: crmUser.name ?? '',
+                            email: crmUser.email ?? '',
+                        },
+                        rcUser: [{
+                            extensionId: rcExtensionForNewMapping.id,
+                            name: rcExtensionForNewMapping.name || `${rcExtensionForNewMapping.firstName} ${rcExtensionForNewMapping.lastName}`,
+                            extensionNumber: rcExtensionForNewMapping?.extensionNumber ?? '',
+                            email: rcExtensionForNewMapping?.email ?? ''
+                        }]
+                    });
+                    newUserMappings.push({
+                        crmUserId: crmUser.id.toString(),
+                        rcExtensionId: [rcExtensionForNewMapping.id.toString()]
+                    });
+                }
+                else {
+                    userMappingResult.push({
+                        crmUser: {
+                            id: crmUser.id,
+                            name: crmUser.name ?? '',
+                            email: crmUser.email ?? '',
+                        },
+                        rcUser: []
+                    });
+                }
+            }
+        }
+        // One-time init
+        if (!adminConfig?.userMappings) {
+            const initialUserMappings = [];
+            for (const userMapping of userMappingResult) {
+                if (userMapping.rcUser?.extensionId) {
+                    initialUserMappings.push({
+                        crmUserId: userMapping.crmUser.id.toString(),
+                        rcExtensionId: [userMapping.rcUser.extensionId.toString()]
+                    });
+                }
+            }
+            await upsertAdminSettings({
+                hashedRcAccountId,
+                adminSettings: {
+                    userMappings: initialUserMappings
+                }
+            });
+        }
+        // Incremental update
+        if (newUserMappings.length > 0) {
+            // TEMP: convert string to array
+            if (adminConfig?.userMappings) {
+                adminConfig.userMappings = adminConfig.userMappings.map(u => ({
+                    ...u,
+                    rcExtensionId: [u.rcExtensionId]
+                }));
+            }
+            else {
+                adminConfig.userMappings = [];
+            }
+            await upsertAdminSettings({
+                hashedRcAccountId,
+                adminSettings: {
+                    userMappings: [...adminConfig.userMappings, ...newUserMappings]
+                }
+            });
+        }
+        return userMappingResult;
+    }
+    return [];
+}
+
 exports.validateAdminRole = validateAdminRole;
 exports.upsertAdminSettings = upsertAdminSettings;
 exports.getAdminSettings = getAdminSettings;
+exports.updateAdminRcTokens = updateAdminRcTokens;
 exports.getServerLoggingSettings = getServerLoggingSettings;
 exports.updateServerLoggingSettings = updateServerLoggingSettings;
+exports.getAdminReport = getAdminReport;
+exports.getUserReport = getUserReport;
+exports.getUserMapping = getUserMapping;

package/handlers/auth.js

@@ -2,6 +2,8 @@ const oauth = require('../lib/oauth');
 const { UserModel } = require('../models/userModel');
 const adapterRegistry = require('../adapter/registry');
 const Op = require('sequelize').Op;
+const { RingCentral } = require('../lib/ringcentral');
+const adminCore = require('./admin');
 
 async function onOAuthCallback({ platform, hostname, tokenUrl, callbackUri, apiUrl, username, query }) {
     const platformModule = adapterRegistry.getAdapter(platform);
@@ -92,6 +94,7 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
     if (existingUser) {
         await existingUser.update(
             {
+                platform,
                 hostname,
                 timezoneName,
                 timezoneOffset,
@@ -204,7 +207,25 @@ async function authValidation({ platform, userId }) {
     }
 }
 
+// Ringcentral
+async function onRingcentralOAuthCallback({ code, rcAccountId }) {
+    const rcSDK = new RingCentral({
+        server: process.env.RINGCENTRAL_SERVER,
+        clientId: process.env.RINGCENTRAL_CLIENT_ID,
+        clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
+        redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
+    });
+    const { access_token, refresh_token, expire_time } = await rcSDK.generateToken({ code });
+    await adminCore.updateAdminRcTokens({
+        hashedRcAccountId: rcAccountId,
+        adminAccessToken: access_token,
+        adminRefreshToken: refresh_token,
+        adminTokenExpiry: expire_time
+    });
+}
+
 exports.onOAuthCallback = onOAuthCallback;
 exports.onApiKeyLogin = onApiKeyLogin;
 exports.authValidation = authValidation;
-exports.getLicenseStatus = getLicenseStatus;
+exports.getLicenseStatus = getLicenseStatus;
+exports.onRingcentralOAuthCallback = onRingcentralOAuthCallback;

package/handlers/calldown.js

@@ -0,0 +1,60 @@
+const { UserModel } = require('../models/userModel');
+const { CallDownListModel } = require('../models/callDownListModel');
+const { Op } = require('sequelize');
+const jwt = require('../lib/jwt');
+
+async function schedule({ jwtToken, rcAccessToken, body }) {
+    const unAuthData = jwt.decodeJwt(jwtToken);
+    if (!unAuthData?.id) throw new Error('Unauthorized');
+    const user = await UserModel.findByPk(unAuthData.id);
+    if (!user) throw new Error('User not found');
+    const crypto = require('crypto');
+    const recordId = crypto.randomBytes(16).toString('hex');
+    const payload = {
+        id: recordId,
+        userId: user.id,
+        contactId: body.contactId?.toString?.() ?? body.contactId,
+        contactType: body.contactType ?? 'contact',
+        contactName: body.contactName ?? '',
+        phoneNumber: body.phoneNumber ?? '',
+        status: 'scheduled',
+        scheduledAt: body.scheduledAt ? new Date(body.scheduledAt) : null,
+        lastCallAt: null
+    };
+    await CallDownListModel.create(payload);
+    return { id: recordId };
+}
+
+async function list({ jwtToken, status }) {
+    const unAuthData = jwt.decodeJwt(jwtToken);
+    if (!unAuthData?.id) throw new Error('Unauthorized');
+    const statusParam = (status || 'All').toString().toLowerCase();
+    const whereClause = { userId: unAuthData.id };
+    if (statusParam === 'called') whereClause.status = 'called';
+    else if (['not called', 'not_called', 'notcalled'].includes(statusParam)) whereClause.status = { [Op.ne]: 'called' };
+    const items = await CallDownListModel.findAll({ where: whereClause, order: [["scheduledAt", "ASC"]] });
+    return { items };
+}
+
+async function remove({ jwtToken, id }) {
+    const unAuthData = jwt.decodeJwt(jwtToken);
+    if (!unAuthData?.id) throw new Error('Unauthorized');
+    const deleted = await CallDownListModel.destroy({ where: { id, userId: unAuthData.id } });
+    if (!deleted) throw new Error('Not found');
+    return { successful: true };
+}
+
+async function markCalled({ jwtToken, id, lastCallAt }) {
+    const unAuthData = jwt.decodeJwt(jwtToken);
+    if (!unAuthData?.id) throw new Error('Unauthorized');
+    const when = lastCallAt ? new Date(lastCallAt) : new Date();
+    const [affected] = await CallDownListModel.update({ status: 'called', lastCallAt: when }, { 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;
+

package/handlers/log.js

@@ -9,8 +9,9 @@ const adapterRegistry = require('../adapter/registry');
 const { LOG_DETAILS_FORMAT_TYPE } = require('../lib/constants');
 const { NoteCache } = require('../models/dynamo/noteCacheSchema');
 const moment = require('moment');
+const { getMediaReaderLinkByPlatformMediaLink } = require('../lib/util');
 
-async function createCallLog({ platform, userId, incomingData, isFromSSCL }) {
+async function createCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         const existingCallLog = await CallLogModel.findOne({
             where: {
@@ -42,7 +43,7 @@ async function createCallLog({ platform, userId, incomingData, isFromSSCL }) {
         const callLog = incomingData.logInfo;
         const additionalSubmission = incomingData.additionalSubmission;
         let note = incomingData.note;
-        if (isFromSSCL) {
+        if (process.env.USE_CACHE && isFromSSCL) {
             const noteCache = await NoteCache.get({ sessionId: incomingData.logInfo.sessionId });
             if (noteCache) {
                 note = noteCache.note;
@@ -113,6 +114,7 @@ async function createCallLog({ platform, userId, incomingData, isFromSSCL }) {
             aiNote,
             transcript,
             composedLogDetails,
+            hashedAccountId,
             isFromSSCL
         });
         if (logId) {
@@ -209,6 +211,11 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
                 }
             });
             for (const sId of sessionIdsArray) {
+                if(sId == 0)
+                {
+                    logs.push({ sessionId: sId, matched: false });
+                    continue;
+                }
                 const callLog = callLogs.find(c => c.sessionId === sId);
                 if (!callLog) {
                     logs.push({ sessionId: sId, matched: false });
@@ -288,7 +295,7 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
     }
 }
 
-async function updateCallLog({ platform, userId, incomingData, isFromSSCL }) {
+async function updateCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         const existingCallLog = await CallLogModel.findOne({
             where: {
@@ -347,7 +354,8 @@ async function updateCallLog({ platform, userId, incomingData, isFromSSCL }) {
                         result: incomingData.result,
                         direction: incomingData.direction,
                         from: incomingData.from,
-                        to: incomingData.to
+                        to: incomingData.to,
+                        legs: incomingData.legs || [],
                     },
                     contactInfo: null, // Not needed for updates
                     user,
@@ -375,9 +383,11 @@ async function updateCallLog({ platform, userId, incomingData, isFromSSCL }) {
                 result: incomingData.result,
                 aiNote: incomingData.aiNote,
                 transcript: incomingData.transcript,
+                legs: incomingData.legs || [],
                 additionalSubmission: incomingData.additionalSubmission,
                 composedLogDetails,
                 existingCallLogDetails,  // Pass the fetched details to avoid duplicate API calls
+                hashedAccountId,
                 isFromSSCL
             });
             return { successful: true, logId: existingCallLog.thirdPartyLogId, updatedNote, returnMessage, extraDataTracking };
@@ -515,6 +525,18 @@ async function createMessageLog({ platform, userId, incomingData }) {
                 faxDocLink = message.attachments.find(a => a.type === 'RenderedDocument').link;
                 faxDownloadLink = message.attachments.find(a => a.type === 'RenderedDocument').uri + `?access_token=${incomingData.logInfo.rcAccessToken}`
             }
+            let imageLink = null;
+            let videoLink = null;
+            if (message.attachments && message.attachments.some(a => a.type === 'MmsAttachment')) {
+                const imageAttachment = message.attachments.find(a => a.type === 'MmsAttachment' && a.contentType.startsWith('image/'));
+                if (imageAttachment) {
+                    imageLink = getMediaReaderLinkByPlatformMediaLink(imageAttachment?.uri);
+                }
+                const videoAttachment = message.attachments.find(a => a.type === 'MmsAttachment' && a.contentType.startsWith('video/'));
+                if (videoAttachment) {
+                    videoLink = getMediaReaderLinkByPlatformMediaLink(videoAttachment?.uri);
+                }
+            }
             const existingSameDateMessageLog = await MessageLogModel.findOne({
                 where: {
                     conversationLogId: incomingData.logInfo.conversationLogId
@@ -522,12 +544,12 @@ async function createMessageLog({ platform, userId, incomingData }) {
             });
             let crmLogId = ''
             if (existingSameDateMessageLog) {
-                const updateMessageResult = await platformModule.updateMessageLog({ user, contactInfo, existingMessageLog: existingSameDateMessageLog, message, authHeader, additionalSubmission });
+                const updateMessageResult = await platformModule.updateMessageLog({ user, contactInfo, existingMessageLog: existingSameDateMessageLog, message, authHeader, additionalSubmission, imageLink, videoLink });
                 crmLogId = existingSameDateMessageLog.thirdPartyLogId;
                 returnMessage = updateMessageResult?.returnMessage;
             }
             else {
-                const createMessageLogResult = await platformModule.createMessageLog({ user, contactInfo, authHeader, message, additionalSubmission, recordingLink, faxDocLink, faxDownloadLink });
+                const createMessageLogResult = await platformModule.createMessageLog({ user, contactInfo, authHeader, message, additionalSubmission, recordingLink, faxDocLink, faxDownloadLink, imageLink, videoLink });
                 crmLogId = createMessageLogResult.logId;
                 returnMessage = createMessageLogResult?.returnMessage;
                 extraDataTracking = createMessageLogResult.extraDataTracking;