@app-connect/core 1.6.9 → 1.7.0-beta.2

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,6 +71,123 @@ 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);
@@ -188,6 +321,9 @@ async function getUserMapping({ user, hashedRcAccountId, rcExtensionList }) {
 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/index.js

@@ -4,6 +4,8 @@ const bodyParser = require('body-parser');
 const dynamoose = require('dynamoose');
 const axios = require('axios');
 const { UserModel } = require('./models/userModel');
+const { CallDownListModel } = require('./models/callDownListModel');
+const { Op } = require('sequelize');
 const { CallLogModel } = require('./models/callLogModel');
 const { MessageLogModel } = require('./models/messageLogModel');
 const { AdminConfigModel } = require('./models/adminConfigModel');
@@ -20,6 +22,7 @@ const releaseNotes = require('./releaseNotes.json');
 const analytics = require('./lib/analytics');
 const util = require('./lib/util');
 const adapterRegistry = require('./adapter/registry');
+const calldown = require('./handlers/calldown');
 
 let packageJson = null;
 try {
@@ -44,6 +47,7 @@ async function initDB() {
         await MessageLogModel.sync();
         await AdminConfigModel.sync();
         await CacheModel.sync();
+        await CallDownListModel.sync();
     }
 }
 
@@ -1000,7 +1004,7 @@ function createCoreRouter() {
                 }
                 const { id: userId, platform } = decodedToken;
                 platformName = platform;
-                const { successful, logId, returnMessage, extraDataTracking } = await logCore.createCallLog({ platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.logInfo?.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL'});
+                const { successful, logId, returnMessage, extraDataTracking } = await logCore.createCallLog({ platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.logInfo?.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL' });
                 if (extraDataTracking) {
                     extraData = extraDataTracking;
                 }
@@ -1199,6 +1203,174 @@ function createCoreRouter() {
         });
     });
 
+    router.post('/calldown', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        let statusCode = 200;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const jwtToken = req.query.jwtToken;
+            if (!jwtToken) {
+                res.status(400).send('Please go to Settings and authorize CRM platform');
+                return;
+            }
+            const { id } = await calldown.schedule({ jwtToken, rcAccessToken: req.query.rcAccessToken, body: req.body });
+            success = true;
+            res.status(200).send({ successful: true, id });
+        } catch (e) {
+            console.log(`platform: ${platformName} \n${e.stack}`);
+            statusCode = e.response?.status ?? 'unknown';
+            res.status(400).send(e);
+            success = false;
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Schedule call down',
+            interfaceName: 'scheduleCallDown',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            extras: {
+                statusCode
+            },
+            eventAddedVia
+        });
+    });
+
+
+    router.get('/calldown', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        let statusCode = 200;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const jwtToken = req.query.jwtToken;
+            if (!jwtToken) {
+                res.status(400).send('Please go to Settings and authorize CRM platform');
+                return;
+            }
+            const { items } = await calldown.list({ jwtToken, status: req.query.status });
+            success = true;
+            res.status(200).send({ successful: true, items });
+        } catch (e) {
+            console.log(`platform: ${platformName} \n${e.stack}`);
+            statusCode = e.response?.status ?? 'unknown';
+            res.status(400).send(e);
+            success = false;
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Get call down list',
+            interfaceName: 'getCallDownList',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            extras: { statusCode },
+            eventAddedVia
+        });
+    });
+
+
+    router.delete('/calldown/:id', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        let statusCode = 200;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const jwtToken = req.query.jwtToken;
+            const id = req.query.id;
+            if (!jwtToken) {
+                res.status(400).send('Please go to Settings and authorize CRM platform');
+                return;
+            }
+            const rid = req.params.id || id;
+            if (!rid) {
+                res.status(400).send('Missing id');
+                return;
+            }
+            await calldown.remove({ jwtToken, id: rid });
+            success = true;
+            res.status(200).send({ successful: true });
+        } catch (e) {
+            console.log(`platform: ${platformName} \n${e.stack}`);
+            statusCode = e.response?.status ?? 'unknown';
+            res.status(400).send(e);
+            success = false;
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Delete call down item',
+            interfaceName: 'deleteCallDownItem',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            extras: { statusCode },
+            eventAddedVia
+        });
+    });
+
+
+    router.patch('/calldown/:id', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        let statusCode = 200;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const jwtToken = req.query.jwtToken;
+            if (!jwtToken) {
+                res.status(400).send('Please go to Settings and authorize CRM platform');
+                return;
+            }
+            const id = req.params.id || req.body?.id;
+            if (!id) {
+                res.status(400).send('Missing id');
+                return;
+            }
+            await calldown.markCalled({ jwtToken, id, lastCallAt: req.body?.lastCallAt });
+            success = true;
+            res.status(200).send({ successful: true });
+        } catch (e) {
+            console.log(`platform: ${platformName} \n${e.stack}`);
+            statusCode = e.response?.status ?? 'unknown';
+            res.status(400).send(e);
+            success = false;
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Mark call down called',
+            interfaceName: 'markCallDownCalled',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            extras: { statusCode },
+            eventAddedVia
+        });
+    });
+
     router.get('/custom/contact/search', async function (req, res) {
         const requestStartTime = new Date().getTime();
         let platformName = null;
@@ -1243,8 +1415,108 @@ function createCoreRouter() {
                 statusCode
             }
         });
+    });
+
+    router.get('/ringcentral/admin/report', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        const jwtToken = req.query.jwtToken;
+        try {
+            if (jwtToken) {
+                const unAuthData = jwt.decodeJwt(jwtToken);
+                const user = await UserModel.findByPk(unAuthData?.id);
+                if (!user) {
+                    res.status(400).send('User not found');
+                    return;
+                }
+                const report = await adminCore.getAdminReport({ rcAccountId: user.rcAccountId, timezone: req.query.timezone, timeFrom: req.query.timeFrom, timeTo: req.query.timeTo });
+                res.status(200).send(report);
+                success = true;
+                return;
+            }
+            res.status(400).send('Invalid request');
+            success = false;
+        }
+        catch (e) {
+            console.log(`${e.stack}`);
+            res.status(400).send(e);
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Get admin report',
+            interfaceName: 'getAdminReport',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            eventAddedVia
+        });
+    });
+
+    router.get('/ringcentral/admin/userReport', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        let platformName = null;
+        let success = false;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        const jwtToken = req.query.jwtToken;
+        try {
+            if (jwtToken) {
+                const unAuthData = jwt.decodeJwt(jwtToken);
+                const user = await UserModel.findByPk(unAuthData?.id);
+                if (!user) {
+                    res.status(400).send('User not found');
+                    return;
+                }
+                const report = await adminCore.getUserReport({ rcAccountId: user.rcAccountId, rcExtensionId: req.query.rcExtensionId, timezone: req.query.timezone, timeFrom: req.query.timeFrom, timeTo: req.query.timeTo });
+                res.status(200).send(report);
+                return;
+            }
+            res.status(400).send('Invalid request');
+            success = false;
+        }
+        catch (e) {
+            console.log(`${e.stack}`);
+            res.status(400).send(e);
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Get user report',
+            interfaceName: 'getUserReport',
+            adapterName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            eventAddedVia
+        });
+    });
 
+    router.get('/ringcentral/oauth/callback', async function (req, res) {
+        const jwtToken = req.query.jwtToken;
+        if (jwtToken) {
+            const unAuthData = jwt.decodeJwt(jwtToken);
+            const { code } = req.query;
+            const user = await UserModel.findByPk(unAuthData?.id);
+            if (!user) {
+                res.status(400).send('User not found');
+                return;
+            }
+            await authCore.onRingcentralOAuthCallback({ code, rcAccountId: user.rcAccountId });
+            res.status(200).send('OK');
+            return;
+        }
+        res.status(400).send('Invalid request');
     });
+
     if (process.env.IS_PROD === 'false') {
         router.post('/registerMockUser', async function (req, res) {
             const secretKey = req.query.secretKey;
@@ -1306,7 +1578,7 @@ function createCoreMiddleware() {
     return [
         bodyParser.json(),
         cors({
-            methods: ['GET', 'POST', 'PATCH', 'PUT']
+            methods: ['GET', 'POST', 'PATCH', 'PUT', 'DELETE']
         })
     ];
 }

package/lib/ringcentral.js

@@ -0,0 +1,275 @@
+
+const fetch = require('node-fetch');
+
+const DEFAULT_RENEW_HANDICAP_MS = 60 * 1000; // 1 minute
+
+function stringifyQuery(query) {
+  const queryParams = new URLSearchParams(query);
+  return queryParams.toString();
+}
+
+const REFRESH_RENEW_HANDICAP_MS = 10 * 1000; // 10s
+function isRefreshTokenValid(token, handicap = REFRESH_RENEW_HANDICAP_MS) {
+  const expireTime = token.refresh_token_expire_time;
+  return expireTime - handicap > Date.now();
+}
+
+function isAccessTokenValid(token, handicap = DEFAULT_RENEW_HANDICAP_MS) {
+  const expireTime = token.expire_time;
+  return expireTime - handicap > Date.now();
+}
+
+class RingCentral {
+  constructor(options) {
+    this._options = options;
+  }
+
+  loginUrl({
+    state,
+  }) {
+    const query = {
+      response_type: 'code',
+      redirect_uri: this._options.redirectUri,
+      client_id: this._options.clientId,
+      response_hint: 'brand_id contracted_country_code',
+    };
+    if (state) {
+      query.state = state;
+    }
+    return `${this._options.server}/restapi/oauth/authorize?${stringifyQuery(query)}`;
+  }
+
+  async generateToken({ code }) {
+    const body = {
+      code,
+      grant_type: 'authorization_code',
+      redirect_uri: this._options.redirectUri,
+    };
+    const response = await this._tokenRequest('/restapi/oauth/token', body);
+    if (Number.parseInt(response.status, 10) >= 400) {
+      throw new Error('Generate Token error', response.status);
+    }
+    const {
+      expires_in,
+      refresh_token_expires_in,
+      scope,
+      endpoint_id, // do no save this field into db to reduce db size
+      ...token
+    } = await response.json();
+    return {
+      ...token,
+      expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
+      refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000,
+    };
+  }
+
+  async refreshToken(token) {
+    const body = {
+      grant_type: 'refresh_token',
+      refresh_token: token.refresh_token,
+      access_token_ttl: token.expires_in,
+      refresh_token_ttl: token.refresh_token_expires_in,
+    };
+    const response = await this._tokenRequest('/restapi/oauth/token', body);
+    if (Number.parseInt(response.status, 10) >= 400) {
+      const error = new Error('Refresh Token error', response.status);
+      error.response = response;
+      throw error;
+    }
+    const {
+      expires_in,
+      refresh_token_expires_in,
+      scope,
+      endpoint_id, // do no save this field into db to reduce db size
+      ...newToken
+    } = await response.json();
+    return {
+      ...newToken,
+      expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
+      refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000,
+    }
+  }
+
+  async revokeToken(token) {
+    const body = {
+      token: token.access_token,
+    };
+    const response = await this._tokenRequest('/restapi/oauth/revoke', body);
+    if (Number.parseInt(response.status, 10) >= 400) {
+      throw new Error('Revoke Token error', response.status);
+    }
+  }
+
+  async _tokenRequest(path, body) {
+    const authorization = `${this._options.clientId}:${this._options.clientSecret}`;
+    const response = await fetch(
+      `${this._options.server}${path}`, {
+      method: 'POST',
+      body: stringifyQuery(body),
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': `Basic ${Buffer.from(authorization).toString('base64')}`
+      },
+    }
+    );
+    return response;
+  }
+
+  async request({
+    server = this._options.server,
+    path,
+    query,
+    body,
+    method,
+    accept = 'application/json',
+  }, token) {
+    let uri = `${server}${path}`;
+    if (query) {
+      uri = uri + (uri.includes('?') ? '&' : '?') + stringifyQuery(query);
+    }
+    const response = await fetch(uri, {
+      method,
+      body: body ? JSON.stringify(body) : body,
+      headers: {
+        'Accept': accept,
+        'Content-Type': 'application/json',
+        'Authorization': `${token.token_type} ${token.access_token}`,
+      },
+    });
+    if (Number.parseInt(response.status, 10) >= 400) {
+      const error = new Error(`request data error ${response.status}`);
+      const errorText = await response.text();
+      error.message = errorText;
+      error.response = response;
+      throw error;
+    }
+    return response;
+  }
+
+  async createSubscription({
+    eventFilters,
+    webhookUri,
+  }, token) {
+    const response = await this.request({
+      method: 'POST',
+      path: '/restapi/v1.0/subscription',
+      body: {
+        eventFilters,
+        deliveryMode: {
+          transportType: 'WebHook',
+          address: webhookUri,
+        },
+        expiresIn: 7 * 24 * 3600, // 7 days
+      },
+    }, token);
+    const {
+      uri,
+      creationTime,
+      deliveryMode,
+      status, // do no save those field into db to reduce db size
+      ...subscription
+    } = await response.json();
+    return subscription;
+  }
+
+  async getExtensionInfo(extensionId, token) {
+    const response = await this.request({
+      method: 'GET',
+      path: `/restapi/v1.0/account/~/extension/${extensionId}`,
+    }, token);
+    return response.json();
+  }
+
+  async getAccountInfo(token) {
+    const response = await this.request({
+      method: 'GET',
+      path: `/restapi/v1.0/account/~`,
+    }, token);
+    return response.json();
+  }
+
+  async getCallsAggregationData({ token, timezone, timeFrom, timeTo }) {
+    const body = {
+      grouping: {
+        groupBy: "Company"
+      },
+      timeSettings: {
+        timeZone: timezone,
+        timeRange: {
+          timeFrom: timeFrom,
+          timeTo: timeTo
+        }
+      },
+      responseOptions: {
+        counters: {
+          callsByDirection: {
+            aggregationType: "Sum"
+          },
+          callsByResponse: {
+            aggregationType: "Sum"
+          }
+        },
+        timers: {
+          allCallsDuration: {
+            aggregationType: "Sum"
+          }
+        }
+      }
+    }
+    const response = await this.request({
+      method: 'POST',
+      path: `/analytics/calls/v1/accounts/~/aggregation/fetch`,
+      body,
+      accept: 'application/json'
+    }, token);
+    return response.json();
+  }
+
+  async getCallLogData({ extensionId = '~', token, timezone, timeFrom, timeTo }) {
+    let pageStart = 1;
+    let isFinalPage = false;
+    let callLogResponse = null;
+    let result = { records: [] };
+    while (!isFinalPage) {
+      callLogResponse = await this.request({
+        method: 'GET',
+        path: `/restapi/v1.0/account/~/extension/${extensionId}/call-log?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&view=Simple&perPage=1000`,
+      }, token);
+      const resultJson = await callLogResponse.json();
+      result.records.push(...resultJson.records);
+      if (resultJson.navigation?.nextPage) {
+        pageStart++;
+      }
+      else {
+        isFinalPage = true;
+      }
+    }
+    return result;
+  }
+  async getSMSData({ extensionId = '~', token, timezone, timeFrom, timeTo }) {
+    let pageStart = 1;
+    let isFinalPage = false;
+    let smsLogResponse = null;
+    let result = { records: [] };
+    while (!isFinalPage) {
+      smsLogResponse = await this.request({
+        method: 'GET',
+        path: `/restapi/v1.0/account/~/extension/${extensionId}/message-store?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&perPage=100`,
+      }, token);
+      const resultJson = await smsLogResponse.json();
+      result.records.push(...resultJson.records);
+      if (resultJson.navigation?.nextPage) {
+        pageStart++;
+      }
+      else {
+        isFinalPage = true;
+      }
+    }
+    return result;
+  }
+}
+
+exports.RingCentral = RingCentral;
+exports.isRefreshTokenValid = isRefreshTokenValid;
+exports.isAccessTokenValid = isAccessTokenValid;

package/lib/util.js

@@ -37,6 +37,20 @@ function secondsToHoursMinutesSeconds(seconds) {
     return resultString;
 }
 
+function getMostRecentDate({ allDateValues }) {
+    var result = 0;
+    for (const date of allDateValues) {
+        if(!date)
+        {
+            continue;
+        }
+        if (date > result) {
+            result = date;
+        }
+    }
+    return result;
+}
+
 // media reader link: https://ringcentral.github.io/ringcentral-media-reader/?media=https://media.ringcentral.com/restapi/v1.0/account/{accountId}/extension/{extensionId}/message-store/{messageId}/content/{contentId}
 // platform media link: https://media.ringcentral.com/restapi/v1.0/account/{accountId}/extension/{extensionId}/message-store/{messageId}/content/{contentId}
 function getMediaReaderLinkByPlatformMediaLink(platformMediaLink){
@@ -50,4 +64,5 @@ function getMediaReaderLinkByPlatformMediaLink(platformMediaLink){
 exports.getTimeZone = getTimeZone;
 exports.getHashValue = getHashValue;
 exports.secondsToHoursMinutesSeconds = secondsToHoursMinutesSeconds;
+exports.getMostRecentDate = getMostRecentDate;
 exports.getMediaReaderLinkByPlatformMediaLink = getMediaReaderLinkByPlatformMediaLink;

package/models/adminConfigModel.js

@@ -1,7 +1,7 @@
 const Sequelize = require('sequelize');
 const { sequelize } = require('./sequelize');
 
-// Model for User data
+// Model for Admin data
 exports.AdminConfigModel = sequelize.define('adminConfigs', {
   // hashed rc account ID
   id: {
@@ -14,7 +14,16 @@ exports.AdminConfigModel = sequelize.define('adminConfigs', {
   customAdapter: {
     type: Sequelize.JSON
   },
-  // Array of:
+  adminAccessToken: {
+    type: Sequelize.STRING(512),
+  },
+  adminRefreshToken: {
+    type: Sequelize.STRING(512),
+  },
+  adminTokenExpiry: {
+    type: Sequelize.DATE
+  },
+    // Array of:
   // {
   //   crmUserId: string,
   //   rcExtensionId: array of strings

package/models/callDownListModel.js

@@ -0,0 +1,35 @@
+const Sequelize = require('sequelize');
+const { sequelize } = require('./sequelize');
+
+exports.CallDownListModel = sequelize.define('callDownLists', {
+    id: {
+        type: Sequelize.STRING,
+        primaryKey: true,
+    },
+    userId: {
+        type: Sequelize.STRING,
+    },
+    contactId: {
+        type: Sequelize.STRING,
+    },
+    contactType: {
+        type: Sequelize.STRING,
+    },
+    status: {
+        type: Sequelize.STRING,
+    },
+    scheduledAt: {
+        type: Sequelize.DATE,
+    },
+    lastCallAt: {
+        type: Sequelize.DATE,
+    }
+}, {
+    timestamps: true,
+    indexes: [
+        { fields: ['userId'] },
+        { fields: ['status'] },
+        { fields: ['scheduledAt'] },
+        { fields: ['userId', 'status'] }
+    ]
+});

package/models/userModel.js

@@ -3,6 +3,7 @@ const { sequelize } = require('./sequelize');
 
 // Model for User data
 exports.UserModel = sequelize.define('users', {
+  // id = {crmName}-{crmUserId}
   id: {
     type: Sequelize.STRING,
     primaryKey: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.6.9",
+  "version": "1.7.0-beta.2",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,28 +1,4 @@
 {
-    "1.6.9": {
-        "global": [
-            {
-                "type": "New",
-                "description": "- Server-side logging now supports multiple RingCentral users to be mapped under one CRM user"
-            },
-            {
-                "type": "Fix",
-                "description": "- Server-side logging user mapping not working properly when running under multi-site scenarios"
-            }
-        ]
-    },
-    "1.6.8": {
-        "global": [
-            {
-                "type": "Fix",
-                "description": "- Server-side logging, if it's created by one admin, the other admin will be able to see its status"
-            },
-            {
-                "type": "Fix",
-                "description": "- Conference calls show wrong warning message"
-            }
-        ]
-    },
     "1.6.7": {
         "global": [
             {