@app-connect/core 1.7.35 → 1.7.37

package/test/handlers/admin.test.js

@@ -29,6 +29,7 @@ const oauth = require('../../lib/oauth');
 const { RingCentral } = require('../../lib/ringcentral');
 const { Connector } = require('../../models/dynamo/connectorSchema');
 const { sequelize } = require('../../models/sequelize');
+const { getHashValue } = require('../../lib/util');
 
 describe('Admin Handler', () => {
   beforeAll(async () => {
@@ -612,5 +613,348 @@ describe('Admin Handler', () => {
       expect(result[0].rcUser[0].extensionId).toBe('ext-existing');
     });
   });
+
+  describe('reports and mapping branch coverage', () => {
+    beforeEach(() => {
+      process.env.RINGCENTRAL_SERVER = 'https://platform.example.com';
+      process.env.RINGCENTRAL_CLIENT_ID = 'client-id';
+      process.env.RINGCENTRAL_CLIENT_SECRET = 'client-secret';
+      process.env.APP_SERVER = 'https://app.example.com';
+      process.env.HASH_KEY = 'hash-key';
+    });
+
+    afterEach(() => {
+      delete process.env.RINGCENTRAL_SERVER;
+      delete process.env.RINGCENTRAL_CLIENT_ID;
+      delete process.env.RINGCENTRAL_CLIENT_SECRET;
+      delete process.env.APP_SERVER;
+      delete process.env.HASH_KEY;
+    });
+
+    test('getAdminReport builds aggregation rows and skips unnamed records', async () => {
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      const getCallsAggregationData = jest.fn().mockResolvedValue({
+        data: {
+          groupedBy: 'Users',
+          records: [
+            {},
+            {
+              info: { name: 'Agent 1' },
+              counters: {
+                callsByDirection: { values: { inbound: 2, outbound: 1 } },
+                callsByResponse: { values: { answered: 1 } }
+              },
+              timers: {
+                allCalls: { values: 90 }
+              }
+            },
+            {
+              info: { name: 'Agent 2' },
+              counters: {
+                callsByDirection: { values: { inbound: 0, outbound: 0 } },
+                callsByResponse: { values: { answered: 0 } }
+              },
+              timers: {
+                allCalls: { values: 0 }
+              }
+            }
+          ]
+        }
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallsAggregationData
+      }));
+
+      const result = await adminHandler.getAdminReport({
+        rcAccountId: 'account',
+        timezone: 'UTC',
+        timeFrom: '2026-07-01T00:00:00Z',
+        timeTo: '2026-07-31T23:59:59Z',
+        groupBy: 'undefined'
+      });
+
+      expect(result.groupedBy).toBe('Users');
+      expect(result.itemKeys).toEqual(['Agent 1', 'Agent 2']);
+      expect(result.callLogStats[0]).toMatchObject({
+        name: 'Agent 1',
+        inboundCallCount: 2,
+        outboundCallCount: 1,
+        answeredCallCount: 1,
+        answeredCallPercentage: '50.00%',
+        totalTalkTime: '90.00',
+        averageTalkTime: '30.00'
+      });
+      expect(result.callLogStats[1]).toMatchObject({
+        name: 'Agent 2',
+        answeredCallPercentage: '0%',
+        totalTalkTime: 0,
+        averageTalkTime: 0
+      });
+      expect(getCallsAggregationData).toHaveBeenCalledWith(expect.objectContaining({
+        groupBy: 'Company'
+      }));
+    });
+
+    test('getUserReport builds call and SMS stats', async () => {
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallLogData: jest.fn().mockResolvedValue({
+          records: [
+            { direction: 'Inbound', result: 'Call connected', duration: 120 },
+            { direction: 'Inbound', result: 'Missed', duration: 0 },
+            { direction: 'Outbound', result: 'Accepted', duration: 60 }
+          ]
+        }),
+        getSMSData: jest.fn().mockResolvedValue({
+          records: [
+            { direction: 'Outbound' },
+            { direction: 'Inbound' },
+            { direction: 'Inbound' }
+          ]
+        })
+      }));
+
+      const result = await adminHandler.getUserReport({
+        rcAccountId: 'account',
+        rcExtensionId: '101',
+        timezone: 'UTC',
+        timeFrom: '2026-07-01T00:00:00Z',
+        timeTo: '2026-07-31T23:59:59Z'
+      });
+
+      expect(result).toEqual({
+        callLogStats: {
+          inboundCallCount: 2,
+          outboundCallCount: 1,
+          answeredCallCount: 1,
+          answeredCallPercentage: '50.00%',
+          totalTalkTime: 3,
+          averageTalkTime: 1
+        },
+        smsLogStats: {
+          smsSentCount: 1,
+          smsReceivedCount: 2
+        }
+      });
+    });
+
+    test('report helpers return empty data on missing env or provider errors', async () => {
+      delete process.env.RINGCENTRAL_SERVER;
+      await expect(adminHandler.getAdminReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+      await expect(adminHandler.getUserReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+
+      process.env.RINGCENTRAL_SERVER = 'https://platform.example.com';
+      const hashedAccountId = getHashValue('account', process.env.HASH_KEY);
+      await AdminConfigModel.create({
+        id: hashedAccountId,
+        adminAccessToken: 'admin-token',
+        adminRefreshToken: 'refresh-token',
+        adminTokenExpiry: new Date(Date.now() + 60 * 60 * 1000)
+      });
+      RingCentral.mockImplementation(() => ({
+        getCallsAggregationData: jest.fn().mockRejectedValue(new Error('aggregation failed')),
+        getCallLogData: jest.fn().mockRejectedValue(new Error('call log failed'))
+      }));
+
+      await expect(adminHandler.getAdminReport({ rcAccountId: 'account' })).resolves.toEqual({
+        callLogStats: {}
+      });
+      await expect(adminHandler.getUserReport({ rcAccountId: 'account', rcExtensionId: '101' })).resolves.toBeNull();
+    });
+
+    test('getUserMapping updates existing mappings, creates new matches, and handles oauth revocation', async () => {
+      await AdminConfigModel.create({
+        id: 'hashed-branch-mapping',
+        userMappings: [
+          { crmUserId: 'crm-user-1', rcExtensionId: 'ext-existing' }
+        ]
+      });
+      const user = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+      const connector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key'),
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-1', name: 'Existing User', email: 'existing@example.com' },
+          { id: 'crm-user-2', name: 'Jane Smith', email: 'jane@example.com' },
+          { id: 'crm-user-3', name: 'No Match', email: 'nomatch@example.com' }
+        ])
+      };
+      connectorRegistry.getConnector.mockReturnValue(connector);
+
+      const result = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-branch-mapping',
+        rcExtensionList: [
+          { id: 'ext-existing', name: 'Existing RC', email: 'existing@example.com', extensionNumber: '100' },
+          { id: 'ext-jane', firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com', extensionNumber: '101' }
+        ]
+      });
+
+      expect(result).toHaveLength(3);
+      expect(result[0].rcUser[0].extensionId).toBe('ext-existing');
+      expect(result[1].rcUser[0].extensionId).toBe('ext-jane');
+      expect(result[2].rcUser).toEqual([]);
+      const updatedConfig = await AdminConfigModel.findByPk('hashed-branch-mapping');
+      expect(updatedConfig.userMappings).toEqual(expect.arrayContaining([
+        expect.objectContaining({ crmUserId: 'crm-user-2', rcExtensionId: ['ext-jane'] })
+      ]));
+
+      connectorRegistry.getConnector.mockReturnValue({
+        getUserList: jest.fn(),
+        getAuthType: jest.fn().mockResolvedValue('oauth'),
+        getOauthInfo: jest.fn().mockResolvedValue({})
+      });
+      oauth.checkAndRefreshAccessToken.mockResolvedValueOnce(null);
+      await expect(adminHandler.getUserMapping({
+        user: {
+          platform: 'testCRM',
+          hostname: 'crm.example.com',
+          accessToken: 'expired-token',
+          platformAdditionalInfo: {}
+        },
+        hashedRcAccountId: 'hashed-branch-mapping',
+        rcExtensionList: []
+      })).resolves.toMatchObject({
+        successful: false,
+        isRevokeUserSession: true
+      });
+    });
+
+    test('getUserMapping initializes mappings when no admin config exists and reports database errors', async () => {
+      const user = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+      connectorRegistry.getConnector.mockReturnValue({
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key'),
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-10', name: 'Alex Agent', email: 'alex@example.com' }
+        ])
+      });
+
+      const result = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-new-mapping',
+        rcExtensionList: [
+          { id: 'ext-alex', firstName: 'Alex', lastName: 'Agent', email: 'alex@example.com', extensionNumber: '201' }
+        ]
+      });
+
+      expect(result[0].rcUser[0].extensionId).toBe('ext-alex');
+      const newConfig = await AdminConfigModel.findByPk('hashed-new-mapping');
+      expect(newConfig.userMappings).toEqual([
+        { crmUserId: 'crm-user-10', rcExtensionId: ['ext-alex'] }
+      ]);
+
+      jest.spyOn(AdminConfigModel, 'findByPk').mockRejectedValueOnce(new Error('read failed'));
+      const errorResult = await adminHandler.getUserMapping({
+        user,
+        hashedRcAccountId: 'hashed-error',
+        rcExtensionList: []
+      });
+      expect(errorResult.successful).toBe(false);
+      AdminConfigModel.findByPk.mockRestore();
+    });
+
+    test('reinitializeUserMapping handles missing capability, proxy limits, oauth revoke, apiKey remap, and update failure', async () => {
+      const baseUser = {
+        platform: 'testCRM',
+        accessToken: 'api-key',
+        platformAdditionalInfo: {}
+      };
+
+      connectorRegistry.getConnector.mockReturnValueOnce({});
+      await expect(adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({ getUserList: jest.fn() });
+      Connector.getProxyConfig.mockResolvedValueOnce({ operations: {} });
+      await expect(adminHandler.reinitializeUserMapping({
+        user: {
+          ...baseUser,
+          platformAdditionalInfo: { proxyId: 'proxy-1' }
+        },
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn(),
+        getAuthType: jest.fn().mockResolvedValue('oauth'),
+        getOauthInfo: jest.fn().mockResolvedValue({})
+      });
+      oauth.checkAndRefreshAccessToken.mockResolvedValueOnce(null);
+      await expect(adminHandler.reinitializeUserMapping({
+        user: {
+          ...baseUser,
+          hostname: 'crm.example.com'
+        },
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: []
+      })).resolves.toMatchObject({
+        successful: false,
+        isRevokeUserSession: true
+      });
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn().mockResolvedValue([
+          { id: 'crm-user-20', name: 'Matched User', email: 'matched@example.com' },
+          { id: 'crm-user-21', name: 'Unmatched User', email: 'unmatched@example.com' }
+        ]),
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key')
+      });
+      const result = await adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit',
+        rcExtensionList: [
+          { id: 'ext-20', firstName: 'Matched', lastName: 'User', email: 'matched@example.com', extensionNumber: '301' }
+        ]
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].rcUser[0].extensionId).toBe('ext-20');
+      expect(result[1].rcUser).toEqual([]);
+
+      connectorRegistry.getConnector.mockReturnValueOnce({
+        getUserList: jest.fn().mockResolvedValue([]),
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn(() => 'encoded-key')
+      });
+      jest.spyOn(AdminConfigModel, 'create').mockRejectedValueOnce(new Error('write failed'));
+      const failure = await adminHandler.reinitializeUserMapping({
+        user: baseUser,
+        hashedRcAccountId: 'hashed-reinit-fail',
+        rcExtensionList: []
+      });
+      expect(failure.successful).toBe(false);
+      AdminConfigModel.create.mockRestore();
+    });
+  });
 });
 

package/test/handlers/appointment.test.js

@@ -0,0 +1,260 @@
+jest.mock('../../models/userModel', () => ({
+  UserModel: {
+    findByPk: jest.fn()
+  }
+}));
+jest.mock('../../connector/registry', () => ({
+  getConnector: jest.fn()
+}));
+jest.mock('../../lib/oauth', () => ({
+  getOAuthApp: jest.fn(() => ({ app: true })),
+  checkAndRefreshAccessToken: jest.fn()
+}));
+jest.mock('../../models/dynamo/connectorSchema', () => ({
+  Connector: {
+    getProxyConfig: jest.fn()
+  }
+}));
+
+const appointmentHandler = require('../../handlers/appointment');
+const { UserModel } = require('../../models/userModel');
+const connectorRegistry = require('../../connector/registry');
+const oauth = require('../../lib/oauth');
+const { Connector } = require('../../models/dynamo/connectorSchema');
+
+describe('Appointment Handler', () => {
+  const baseUser = {
+    id: 'user-1',
+    hostname: 'crm.example.com',
+    accessToken: 'access-token',
+    platformAdditionalInfo: {}
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  function mockApiKeyConnector(overrides = {}) {
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('apiKey'),
+      getBasicAuth: jest.fn(() => 'encoded-key'),
+      listAppointments: jest.fn().mockResolvedValue({ appointments: [{ id: 'appt-1' }] }),
+      createAppointment: jest.fn().mockResolvedValue({ appointmentId: 'appt-2', appointment: { id: 'appt-2' } }),
+      updateAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-3' } }),
+      refreshAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-4' } }),
+      confirmAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-5' } }),
+      cancelAppointment: jest.fn().mockResolvedValue({ appointment: { id: 'appt-6' } }),
+      ...overrides
+    };
+    connectorRegistry.getConnector.mockReturnValue(connector);
+    return connector;
+  }
+
+  test('returns database warning when user lookup fails', async () => {
+    UserModel.findByPk.mockRejectedValueOnce(new Error('db unavailable'));
+
+    const result = await appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'user-1'
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.messageType).toBe('warning');
+    expect(result.returnMessage.message).toBe('Database operation failed');
+  });
+
+  test('returns warning when user is missing or session has no token', async () => {
+    UserModel.findByPk.mockResolvedValueOnce(null);
+
+    await expect(appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'missing-user'
+    })).resolves.toMatchObject({
+      successful: false,
+      returnMessage: {
+        message: 'User not found'
+      }
+    });
+
+    UserModel.findByPk.mockResolvedValueOnce({ id: 'user-1' });
+    const noTokenResult = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Meeting' }
+    });
+
+    expect(noTokenResult.successful).toBe(false);
+    expect(noTokenResult.returnMessage.message).toBe('User not found');
+  });
+
+  test('listAppointments resolves oauth auth with proxy config and returns connector result', async () => {
+    const user = {
+      ...baseUser,
+      platformAdditionalInfo: {
+        proxyId: 'proxy-1',
+        tokenUrl: 'https://token.example.com'
+      }
+    };
+    const refreshedUser = {
+      ...user,
+      accessToken: 'fresh-token'
+    };
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({ tokenUrl: 'https://token.example.com' }),
+      listAppointments: jest.fn().mockResolvedValue({
+        appointments: [{ id: 'appt-1' }],
+        returnMessage: {
+          messageType: 'success',
+          message: 'Listed'
+        }
+      })
+    };
+    UserModel.findByPk.mockResolvedValue(user);
+    Connector.getProxyConfig.mockResolvedValue({ id: 'proxy-1' });
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(refreshedUser);
+    connectorRegistry.getConnector.mockReturnValue(connector);
+
+    const result = await appointmentHandler.listAppointments({
+      platform: 'testCRM',
+      userId: 'user-1',
+      range: { startDate: '2026-07-01' },
+      mineOnly: true,
+      forceSync: true
+    });
+
+    expect(connector.getOauthInfo).toHaveBeenCalledWith({
+      tokenUrl: 'https://token.example.com',
+      hostname: 'crm.example.com',
+      proxyId: 'proxy-1',
+      proxyConfig: { id: 'proxy-1' }
+    });
+    expect(connector.listAppointments).toHaveBeenCalledWith({
+      user: refreshedUser,
+      authHeader: 'Bearer fresh-token',
+      range: { startDate: '2026-07-01' },
+      mineOnly: true,
+      forceSync: true,
+      proxyConfig: { id: 'proxy-1' }
+    });
+    expect(result).toMatchObject({
+      successful: true,
+      appointments: [{ id: 'appt-1' }]
+    });
+  });
+
+  test('oauth auth returns revoke response when token refresh fails', async () => {
+    const connector = {
+      getAuthType: jest.fn().mockResolvedValue('oauth'),
+      getOauthInfo: jest.fn().mockResolvedValue({})
+    };
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    connectorRegistry.getConnector.mockReturnValue(connector);
+    oauth.checkAndRefreshAccessToken.mockResolvedValue(null);
+
+    const result = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Meeting' }
+    });
+
+    expect(result).toMatchObject({
+      successful: false,
+      isRevokeUserSession: true,
+      returnMessage: {
+        message: 'User session expired. Please connect again.'
+      }
+    });
+  });
+
+  test('apiKey auth is used by create, update, refresh, confirm, and cancel operations', async () => {
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    const connector = mockApiKeyConnector();
+
+    const createResult = await appointmentHandler.createAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      payload: { title: 'Create' }
+    });
+    const updateResult = await appointmentHandler.updateAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' }
+    });
+    const refreshResult = await appointmentHandler.refreshAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-3'
+    });
+    const confirmResult = await appointmentHandler.confirmAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-4'
+    });
+    const cancelResult = await appointmentHandler.cancelAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-5'
+    });
+
+    expect(createResult.appointmentId).toBe('appt-2');
+    expect(updateResult.appointment).toEqual({ id: 'appt-3' });
+    expect(refreshResult.appointment).toEqual({ id: 'appt-4' });
+    expect(confirmResult.appointment).toEqual({ id: 'appt-5' });
+    expect(cancelResult.appointment).toEqual({ id: 'appt-6' });
+    expect(connector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'access-token' });
+    expect(connector.createAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      payload: { title: 'Create' },
+      proxyConfig: null
+    });
+    expect(connector.updateAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' },
+      proxyConfig: null
+    });
+    expect(connector.refreshAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-3',
+      proxyConfig: null
+    });
+    expect(connector.confirmAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-4',
+      proxyConfig: null
+    });
+    expect(connector.cancelAppointment).toHaveBeenCalledWith({
+      user: baseUser,
+      authHeader: 'Basic encoded-key',
+      appointmentId: 'appt-5',
+      proxyConfig: null
+    });
+  });
+
+  test('operation errors are mapped through API error handler', async () => {
+    UserModel.findByPk.mockResolvedValue(baseUser);
+    mockApiKeyConnector({
+      updateAppointment: jest.fn().mockRejectedValue({
+        response: {
+          status: 429
+        }
+      })
+    });
+
+    const result = await appointmentHandler.updateAppointment({
+      platform: 'testCRM',
+      userId: 'user-1',
+      appointmentId: 'appt-2',
+      patchBody: { title: 'Update' }
+    });
+
+    expect(result.successful).toBe(false);
+    expect(result.returnMessage.messageType).toBe('warning');
+  });
+});