@wazo/sdk 0.43.14 → 0.44.0

package/src/domain/Voicemail.ts

@@ -1,138 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-
-export const VoicemailFolder = {
-  NEW: 'new',
-  OLD: 'old',
-  URGENT: 'urgent',
-  OTHER: 'other',
-} as const;
-
-const VoicemailFolderMapping = {
-  [VoicemailFolder.NEW]: 1,
-  [VoicemailFolder.OLD]: 2,
-  [VoicemailFolder.URGENT]: 3,
-  [VoicemailFolder.OTHER]: 4,
-} as const;
-
-export type VoicemailFolderType = typeof VoicemailFolder[keyof typeof VoicemailFolder];
-
-type MessageResponse = {
-  caller_id_name: string;
-  caller_id_num: string;
-  duration: number;
-  id: string;
-  folder?: Record<string, any>;
-  timestamp: number;
-};
-
-export type Response = {
-  id: string;
-  name: string;
-  number: string;
-  folders: Array<{
-    id: string;
-    name: string;
-    type: VoicemailFolderType;
-    messages: Array<MessageResponse>;
-  }>;
-};
-
-type VoicemailArguments = {
-  id: string;
-  date: Date;
-  duration: number;
-  caller: {
-    name: string;
-    number: string;
-  };
-  unread?: boolean | null | undefined;
-};
-export default class Voicemail {
-  type: string;
-
-  id: string;
-
-  date: Date;
-
-  duration: number;
-
-  unread: boolean | null | undefined;
-
-  caller: {
-    name: string;
-    number: string;
-  };
-
-  static parse(plain: MessageResponse): Voicemail {
-    return new Voicemail({
-      id: plain.id,
-      date: moment(plain.timestamp * 1000).toDate(),
-      duration: plain.duration * 1000,
-      caller: {
-        name: plain.caller_id_name,
-        number: plain.caller_id_num,
-      },
-      unread: plain.folder ? plain.folder.type === VoicemailFolder.NEW : null,
-    });
-  }
-
-  static parseMany(plain: Response): Array<Voicemail> {
-    if (!plain) {
-      return [];
-    }
-
-    const plainUnread = plain.folders.filter(folder => folder.type === VoicemailFolder.NEW)[0].messages;
-    const plainRead = plain.folders.filter(folder => folder.type === VoicemailFolder.OLD)[0].messages;
-    const unread = plainUnread.map(message => Voicemail.parse(message)).map(voicemail => voicemail.makeAsUnRead());
-    const read = plainRead.map(message => Voicemail.parse(message)).map(voicemail => voicemail.acknowledge());
-    return [...unread, ...read];
-  }
-
-  static newFrom(profile: Voicemail) {
-    return newFrom(profile, Voicemail);
-  }
-
-  static getFolderMappingFromType(folder: VoicemailFolderType) {
-    return VoicemailFolderMapping[folder];
-  }
-
-  constructor({
-    id,
-    date,
-    duration,
-    caller,
-    unread,
-  }: VoicemailArguments) {
-    this.id = id;
-    this.date = date;
-    this.duration = duration;
-    this.caller = caller;
-    this.unread = unread;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'Voicemail';
-  }
-
-  is(other: Voicemail): boolean {
-    return other && this.id === other.id;
-  }
-
-  acknowledge() {
-    this.unread = false;
-    return this;
-  }
-
-  makeAsUnRead() {
-    this.unread = true;
-    return this;
-  }
-
-  contains(query: string): boolean {
-    if (!query) {
-      return true;
-    }
-
-    return this.caller.name.toUpperCase().includes(query.toUpperCase()) || this.caller.number.includes(query);
-  }
-
-}

package/src/domain/__tests__/Agent.test.ts

@@ -1,38 +0,0 @@
-import Agent, { AgentArguments, AgentResponse } from '../Agent';
-
-const fieldMap: Record<string, any> = {
-  context: 'context',
-  extension: 'extension',
-  id: 'id',
-  logged: 'logged',
-  number: 'number',
-  paused: 'paused',
-  pausedReason: 'paused_reason',
-};
-const plain: Record<string, any> = {
-  context: 'bogus_context',
-  extension: 'bogus_extension',
-  id: 1234,
-  logged: true,
-  number: 'number',
-  origin_uuid: '3fa85f64-5717-4562-b3fc-2c963f66afa6',
-  paused: true,
-  paused_reason: 'this is a reason',
-  state_interface: 'undefined_state_interface',
-  tenant_uuid: '3fa85f64-5717-4562-b3fc-2c963f66afa6',
-};
-const formatted: Record<string, any> = {};
-Object.keys(fieldMap).forEach((field: string) => {
-  formatted[field] = plain[fieldMap[field]];
-});
-describe('Call Center Agent domain', () => {
-  it('should keep its values', () => {
-    const agent = new Agent(formatted as AgentArguments) as any;
-    expect(agent).toBeInstanceOf(Agent);
-    Object.keys(fieldMap).map(key => expect(agent[key]).toBe(formatted[key]));
-  });
-  it('can parse a plain call center agent to domain', () => {
-    const agent = Agent.parse(plain as AgentResponse);
-    expect(agent).toEqual(new Agent(formatted as AgentArguments));
-  });
-});

package/src/domain/__tests__/Call.test.ts

@@ -1,26 +0,0 @@
-import Call from '../Call';
-
-describe('Call domain', () => {
-  it('can return the elapsed time since its creation in seconds', () => {
-    Date.now = jest.fn(() => new Date(2012, 7, 28, 13, 0, 0)) as any;
-    const call = new Call({
-      startingTime: new Date(2012, 7, 28, 12, 30, 0),
-    } as any);
-    const elapsedTimeInSeconds = call.getElapsedTimeInSeconds();
-    expect(elapsedTimeInSeconds).toBe(30 * 60);
-  });
-  it('has the number provided it is the same number', () => {
-    const call = new Call({
-      calleeName: 'John Doe',
-      calleeNumber: '911',
-    } as any);
-    expect(call.hasNumber('911')).toBeTruthy();
-  });
-  it('does not have the number provided it is a different number', () => {
-    const call = new Call({
-      calleeName: 'John Doe',
-      calleeNumber: '911',
-    } as any);
-    expect(call.hasNumber('418-222-5555')).toBeFalsy();
-  });
-});

package/src/domain/__tests__/CallLog.test.ts

@@ -1,203 +0,0 @@
-import moment from 'moment';
-import CallLog, { Response, CallLogResponse, CALL_LOG_VALID_REQUESTED_VERSION } from '../CallLog';
-import Recording from '../Recording';
-import Session from '../Session';
-import Profile from '../Profile';
-import Line from '../Line';
-
-const ALICE_EXTENSION = '41';
-const ALICE_UUID = '11111111-1111-1111-1111-111111111111';
-
-const BOB_EXTENSION = '42';
-const BOB_UUID = '22222222-2222-2222-2222-222222222222';
-
-const CHARLIE_EXTENSION = '43';
-const CHARLIE_UUID = '33333333-3333-3333-3333-333333333333';
-
-// Default scenario: Alice > Bob (No anwser forward) > Charlie
-const CALL_LOG_RESPONSE: CallLogResponse = {
-  id: 1,
-  answer: '2024-01-02T00:00:00.000000+00:00',
-  answered: true,
-  call_direction: 'internal',
-  source_name: 'Alice',
-  source_extension: ALICE_EXTENSION,
-  source_user_uuid: ALICE_UUID,
-  requested_name: 'Bob',
-  requested_extension: BOB_EXTENSION,
-  requested_user_uuid: BOB_UUID,
-  destination_name: 'Charlie',
-  destination_extension: CHARLIE_EXTENSION,
-  destination_user_uuid: CHARLIE_UUID,
-  duration: 4,
-  start: '2024-01-01T00:00:00.000000+00:00',
-  end: '2024-01-01T00:00:04.000000+00:00',
-  recordings: [{
-    uuid: '0394ad6f-5c72-4072-8503-e3ad9a41c0a0',
-    start_time: '2024-01-01T00:00:00.000000+00:00',
-    end_time: '2024-01-01T00:00:04.000000+00:00',
-    filename: '2024-01-01T00_00_04UTC-61886-0394ad6f-5c72-4072-8503-e3ad9a41c0a0.wav',
-    deleted: false,
-  }],
-};
-const CALL_LOG = CallLog.parse(CALL_LOG_RESPONSE);
-
-const generateBobSession = (opts?: Partial<Session>): Session =>
-  new Session({
-    acl: [],
-    token: 'ref-12345',
-    uuid: BOB_UUID,
-    expiresAt: new Date(9999, 0, 1),
-    engineVersion: CALL_LOG_VALID_REQUESTED_VERSION,
-    profile: new Profile({
-      lines: [new Line({
-        id: 1,
-        extensions: [{
-          id: 1,
-          exten: BOB_EXTENSION,
-          context: 'internal',
-        }],
-      })],
-    } as any),
-    ...(opts || {}),
-  });
-
-const BOB_SESSION = generateBobSession();
-
-describe('CallLog Domain', () => {
-  describe('parseMany', () => {
-    it('can parse a plain call log to domain', () => {
-      const response: Response = {
-        filtered: 6,
-        items: [CALL_LOG_RESPONSE],
-        total: 233,
-      };
-
-      const logs = CallLog.parseMany(response);
-      expect(logs).toEqual([new CallLog({
-        id: 1,
-        answer: moment(CALL_LOG_RESPONSE.answer).toDate(),
-        answered: true,
-        callDirection: 'internal',
-        source: {
-          uuid: ALICE_UUID,
-          name: 'Alice',
-          extension: ALICE_EXTENSION,
-        },
-        requested: {
-          uuid: BOB_UUID,
-          name: 'Bob',
-          extension: BOB_EXTENSION,
-        },
-        destination: {
-          uuid: CHARLIE_UUID,
-          name: 'Bob',
-          extension: BOB_EXTENSION,
-          plainExtension: CHARLIE_EXTENSION,
-          plainName: 'Charlie',
-        },
-        duration: 4000,
-        start: moment(CALL_LOG_RESPONSE.start).toDate(),
-        end: moment(CALL_LOG_RESPONSE.end).toDate(),
-        recordings: [new Recording({
-          uuid: CALL_LOG_RESPONSE.recordings[0].uuid,
-          start: moment(CALL_LOG_RESPONSE.recordings[0].start_time).toDate(),
-          end: moment(CALL_LOG_RESPONSE.recordings[0].end_time).toDate(),
-          fileName: CALL_LOG_RESPONSE.recordings[0].filename,
-          deleted: false,
-        })],
-      })]);
-    });
-  });
-
-  describe('isIconming', () => {
-    it('should be TRUE', () => {
-      // When requested is set to the same user session extension
-      expect(CALL_LOG.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-      // When destination is set to the same user session extension
-      const destinationCallLog = CallLog.parse({
-        ...CALL_LOG_RESPONSE,
-        destination_extension: CALL_LOG_RESPONSE.requested_extension,
-        destination_name: CALL_LOG_RESPONSE.requested_name,
-        destination_user_uuid: CALL_LOG_RESPONSE.requested_user_uuid,
-        requested_extension: CALL_LOG_RESPONSE.destination_extension,
-        requested_name: CALL_LOG_RESPONSE.destination_name,
-        requested_user_uuid: CALL_LOG_RESPONSE.destination_user_uuid,
-      });
-      expect(destinationCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-      // When destination is set to the same user with a changed extension
-      const destinationExtensionChangedCallLog = CallLog.parse({
-        ...CALL_LOG_RESPONSE,
-        destination_extension: `${CALL_LOG_RESPONSE.requested_extension}9`,
-        destination_name: CALL_LOG_RESPONSE.requested_name,
-        destination_user_uuid: CALL_LOG_RESPONSE.requested_user_uuid,
-        requested_extension: `${CALL_LOG_RESPONSE.destination_extension}9`,
-        requested_name: CALL_LOG_RESPONSE.destination_name,
-        requested_user_uuid: CALL_LOG_RESPONSE.destination_user_uuid,
-      });
-      expect(destinationExtensionChangedCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-      // When call direction is inbound
-      const inboundCallLog = CallLog.parse({ ...CALL_LOG_RESPONSE, call_direction: 'inbound' });
-      expect(inboundCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-    });
-
-    it('should be FALSE', () => {
-      // When call direction is outbound
-      const outboundCallLog = CallLog.parse({ ...CALL_LOG_RESPONSE, call_direction: 'outbound' });
-      expect(outboundCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(false);
-    });
-  });
-
-  describe('isIncomingAndForwarded', () => {
-    it('should be TRUE when requested is current user extension and destination is another extesnion', () => {
-      // Internal call (requested contact)
-      expect(CALL_LOG.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-      // Inbound call (requested contact)
-      const inboundCallLog = CallLog.parse({
-        ...CALL_LOG_RESPONSE,
-        call_direction: 'inbound',
-        source_extension: '18004444444',
-        source_name: '',
-        source_user_uuid: null,
-      });
-      expect(inboundCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-
-      // Current user is the final destination
-      const destinationCallLog = CallLog.parse({
-        ...CALL_LOG_RESPONSE,
-        destination_extension: CALL_LOG_RESPONSE.requested_extension,
-        destination_name: CALL_LOG_RESPONSE.requested_name,
-        destination_user_uuid: CALL_LOG_RESPONSE.requested_user_uuid,
-        requested_extension: CALL_LOG_RESPONSE.destination_extension,
-        requested_name: CALL_LOG_RESPONSE.destination_name,
-        requested_user_uuid: CALL_LOG_RESPONSE.destination_user_uuid,
-      });
-      expect(destinationCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(true);
-    });
-
-    it('should be FALSE', () => {
-      // Requested and destination are same
-      const directCallLog = CallLog.parse({
-        ...CALL_LOG_RESPONSE,
-        requested_extension: CALL_LOG_RESPONSE.destination_extension,
-        requested_name: CALL_LOG_RESPONSE.destination_name,
-        requested_user_uuid: CALL_LOG_RESPONSE.destination_user_uuid,
-      });
-
-      expect(directCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(false);
-
-      // Not incoming call
-      const outboundCallLog = CallLog.parse({ ...CALL_LOG_RESPONSE, call_direction: 'outbound' });
-      expect(outboundCallLog.isIncomingAndForwarded(BOB_SESSION)).toBe(false);
-
-      // Stack version
-      const oldStackSession = generateBobSession({ engineVersion: CALL_LOG_VALID_REQUESTED_VERSION.replace('14', '10') });
-      expect(CALL_LOG.isIncomingAndForwarded(oldStackSession)).toBe(false);
-    });
-  });
-});

package/src/domain/__tests__/CallSession.test.ts

@@ -1,80 +0,0 @@
-import CallSession from '../CallSession';
-
-const stringify = (cs: any) => JSON.parse(JSON.stringify(cs));
-
-describe('CallSession domain', () => {
-  it('should update from another CallSession without data loss', () => {
-    const callSession = new CallSession({
-      callId: null,
-      sipCallId: 123,
-      paused: false,
-      number: '8001',
-      isCaller: true,
-      dialedExtension: null,
-    } as any);
-    const anotherCallSession = new CallSession({
-      callId: 345,
-      callerNumber: '8008',
-      number: '8008',
-      isCaller: false,
-      dialedExtension: undefined,
-    } as any);
-    callSession.updateFrom(anotherCallSession);
-    expect(callSession.callId).toBe(345);
-    expect(callSession.sipCallId).toBe(123);
-    expect(callSession.paused).toBe(false);
-    expect(callSession.ringing).toBe(undefined);
-    expect(callSession.callerNumber).toBe('8008');
-    expect(callSession.number).toBe('8008');
-    expect(callSession.isCaller).toBe(false);
-    expect(callSession.dialedExtension).toBe('');
-  });
-  it('should compare 2 callSession', () => {
-    const cs1 = new CallSession({
-      callId: 123,
-      sipCallId: 456,
-    } as any);
-    const cs2 = new CallSession({
-      callId: 123,
-      sipCallId: null,
-    } as any);
-    expect(cs1.is(cs2)).toBeTruthy();
-    expect(cs2.is(cs1)).toBeTruthy();
-  });
-  it('should set answerTime when setting answered to true', () => {
-    const cs1 = new CallSession({} as any);
-    cs1.answered = true;
-    const cs2 = new CallSession({} as any);
-    cs2.answer();
-    const cs3 = new CallSession({
-      answered: true,
-    } as any);
-    expect(cs1.answered).toEqual(true);
-    expect(cs1.answerTime).not.toBeNull();
-    expect(cs2.answered).toEqual(true);
-    expect(cs2.answerTime).not.toBeNull();
-    expect(cs3.answered).toEqual(true);
-    expect(cs3.answerTime).not.toBeNull();
-    const cs4 = stringify(cs1);
-    const cs5 = stringify(cs2);
-    const cs6 = stringify(cs3);
-    expect(cs4.answered).toEqual(true);
-    expect(cs5.answered).toEqual(true);
-    expect(cs6.answered).toEqual(true);
-  });
-  it('should reset answerTime when setting answered to false', () => {
-    const cs1 = new CallSession({} as any);
-    cs1.answered = false;
-    const cs2 = new CallSession({
-      answered: false,
-    } as any);
-    expect(cs1.answered).toEqual(false);
-    expect(cs1.answerTime).toBeNull();
-    expect(cs2.answered).toEqual(false);
-    expect(cs2.answerTime).toBeNull();
-    const cs4 = stringify(cs1);
-    const cs5 = stringify(cs2);
-    expect(cs4.answered).toEqual(false);
-    expect(cs5.answered).toEqual(false);
-  });
-});