@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/src/domain/{Voicemail.js → Voicemail.ts}

@@ -1,50 +1,51 @@
-// @flow
 import moment from 'moment';
-
 import newFrom from '../utils/new-from';
 
 type MessageResponse = {
-  caller_id_name: string,
-  caller_id_num: string,
-  duration: number,
-  id: string,
-  folder?: Object,
-  timestamp: number,
+  caller_id_name: string;
+  caller_id_num: string;
+  duration: number;
+  id: string;
+  folder?: Record<string, any>;
+  timestamp: number;
 };
 
-type Response = {
-  id: string,
-  name: string,
-  number: string,
+export type Response = {
+  id: string;
+  name: string;
+  number: string;
   folders: Array<{
-    id: string,
-    name: string,
-    type: string,
-    messages: Array<MessageResponse>,
-  }>,
+    id: string;
+    name: string;
+    type: string;
+    messages: Array<MessageResponse>;
+  }>;
 };
 
 type VoicemailArguments = {
-  id: string,
-  date: Date,
-  duration: number,
+  id: string;
+  date: Date;
+  duration: number;
   caller: {
-    name: string,
-    number: string,
-  },
-  unread?: ?boolean,
+    name: string;
+    number: string;
+  };
+  unread?: boolean | null | undefined;
 };
-
 export default class Voicemail {
   type: string;
 
   id: string;
+
   date: Date;
+
   duration: number;
-  unread: ?boolean;
+
+  unread: boolean | null | undefined;
+
   caller: {
-    name: string,
-    number: string,
+    name: string;
+    number: string;
   };
 
   static parse(plain: MessageResponse): Voicemail {
@@ -64,12 +65,11 @@ export default class Voicemail {
     if (!plain) {
       return [];
     }
+
     const plainUnread = plain.folders.filter(folder => folder.type === 'new')[0].messages;
     const plainRead = plain.folders.filter(folder => folder.type === '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];
   }
 
@@ -77,13 +77,18 @@ export default class Voicemail {
     return newFrom(profile, Voicemail);
   }
 
-  constructor({ id, date, duration, caller, unread }: VoicemailArguments = {}) {
+  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';
   }
@@ -94,13 +99,11 @@ export default class Voicemail {
 
   acknowledge() {
     this.unread = false;
-
     return this;
   }
 
   makeAsUnRead() {
     this.unread = true;
-
     return this;
   }
 
@@ -111,4 +114,5 @@ export default class Voicemail {
 
     return this.caller.name.toUpperCase().includes(query.toUpperCase()) || this.caller.number.includes(query);
   }
+
 }

package/src/domain/__tests__/{Agent.test.js → Agent.test.ts}

@@ -1,6 +1,6 @@
-import Agent from '../Agent';
+import Agent, { AgentResponse } from '../Agent';
 
-const fieldMap = {
+const fieldMap: Record<string, any> = {
   context: 'context',
   extension: 'extension',
   id: 'id',
@@ -9,8 +9,7 @@ const fieldMap = {
   paused: 'paused',
   pausedReason: 'paused_reason',
 };
-
-const plain = {
+const plain: Record<string, any> = {
   context: 'bogus_context',
   extension: 'bogus_extension',
   id: 1234,
@@ -22,27 +21,20 @@ const plain = {
   state_interface: 'undefined_state_interface',
   tenant_uuid: '3fa85f64-5717-4562-b3fc-2c963f66afa6',
 };
-
-const formatted = {};
-Object.keys(fieldMap).forEach(field => {
+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);
-
+    // @ts-expect-error
+    const agent = new Agent(formatted) as any;
     expect(agent).toBeInstanceOf(Agent);
-
-    Object.keys(fieldMap).map(key =>
-      expect(agent[key]).toBe(formatted[key]));
+    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);
-
-    expect(agent).toEqual(
-      new Agent(formatted),
-    );
+    const agent = Agent.parse(plain as AgentResponse);
+    // @ts-expect-error
+    expect(agent).toEqual(new Agent(formatted));
   });
 });

package/src/domain/__tests__/{Call.test.js → Call.test.ts}

@@ -1,24 +1,27 @@
+// @ts-nocheck
 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));
-    const call = new Call({ startingTime: new Date(2012, 7, 28, 12, 30, 0) });
-
+    const call = new Call({
+      startingTime: new Date(2012, 7, 28, 12, 30, 0),
+    });
     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' });
-
+    const call = new Call({
+      calleeName: 'John Doe',
+      calleeNumber: '911',
+    });
     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' });
-
+    const call = new Call({
+      calleeName: 'John Doe',
+      calleeNumber: '911',
+    });
     expect(call.hasNumber('418-222-5555')).toBeFalsy();
   });
 });

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

@@ -0,0 +1,65 @@
+// @ts-nocheck
+
+import moment from 'moment';
+import CallLog from '../CallLog';
+import Recording from '../Recording';
+
+describe('CallLog domain', () => {
+  it('can parse a plain call log to domain', () => {
+    const response = {
+      filtered: 6,
+      items: [{
+        answer: moment('2017-08-07T13:51:18.892002+00:00').toDate(),
+        answered: true,
+        call_direction: 'outbound',
+        source_extension: '8020',
+        source_name: 'Jonathan Lessard',
+        source_user_uuid: '123',
+        destination_extension: '4182250459',
+        destination_name: null,
+        destination_user_uuid: '456',
+        duration: 4,
+        start: '2017-08-06T13:50:55.819057+00:00',
+        end: '2017-08-08T13:51:23.822529+00:00',
+        requested_extension: '',
+        requested_name: '',
+        id: 215,
+        recordings: [{
+          deleted: false,
+          end_time: '2021-08-11T13:22:50.519733+00:00',
+          filename: '2021-08-11T13_22_45UTC-61886-xxxx-5c72-4072-8503-e3ad9a41c0a0.wav',
+          start_time: '2021-08-11T13:22:45.161954+00:00',
+          uuid: '0394ad6f-5c72-4072-8503-e3ad9a41c0a0',
+        }],
+      }],
+      total: 233,
+    };
+    const logs = CallLog.parseMany(response);
+    expect(logs).toEqual([new CallLog({
+      answer: moment('2017-08-07T13:51:18.892002+00:00').toDate(),
+      answered: true,
+      callDirection: 'outbound',
+      destination: {
+        extension: '4182250459',
+        name: '',
+        uuid: '456',
+      },
+      source: {
+        extension: '8020',
+        name: 'Jonathan Lessard',
+        uuid: '123',
+      },
+      id: 215,
+      duration: 4000,
+      start: moment('2017-08-06T13:50:55.819057+00:00').toDate(),
+      end: moment('2017-08-08T13:51:23.822529+00:00').toDate(),
+      recordings: [new Recording({
+        deleted: false,
+        end: moment('2021-08-11T13:22:50.519733+00:00').toDate(),
+        fileName: '2021-08-11T13_22_45UTC-61886-xxxx-5c72-4072-8503-e3ad9a41c0a0.wav',
+        start: moment('2021-08-11T13:22:45.161954+00:00').toDate(),
+        uuid: '0394ad6f-5c72-4072-8503-e3ad9a41c0a0',
+      })],
+    })]);
+  });
+});

package/src/domain/__tests__/{CallSession.test.js → CallSession.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import CallSession from '../CallSession';
 
 const stringify = cs => JSON.parse(JSON.stringify(cs));
@@ -19,9 +20,7 @@ describe('CallSession domain', () => {
       isCaller: false,
       dialedExtension: undefined,
     });
-
     callSession.updateFrom(anotherCallSession);
-
     expect(callSession.callId).toBe(345);
     expect(callSession.sipCallId).toBe(123);
     expect(callSession.paused).toBe(false);
@@ -31,54 +30,51 @@ describe('CallSession domain', () => {
     expect(callSession.isCaller).toBe(false);
     expect(callSession.dialedExtension).toBe('');
   });
-
   it('should compare 2 callSession', () => {
-    const cs1 = new CallSession({ callId: 123, sipCallId: 456 });
-    const cs2 = new CallSession({ callId: 123, sipCallId: null });
-
+    const cs1 = new CallSession({
+      callId: 123,
+      sipCallId: 456,
+    });
+    const cs2 = new CallSession({
+      callId: 123,
+      sipCallId: null,
+    });
     expect(cs1.is(cs2)).toBeTruthy();
     expect(cs2.is(cs1)).toBeTruthy();
   });
-
   it('should set answerTime when setting answered to true', () => {
     const cs1 = new CallSession({});
     cs1.answered = true;
-
     const cs2 = new CallSession({});
     cs2.answer();
-
-    const cs3 = new CallSession({ answered: true });
-
+    const cs3 = new CallSession({
+      answered: true,
+    });
     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({});
     cs1.answered = false;
-
-    const cs2 = new CallSession({ answered: false });
-
+    const cs2 = new CallSession({
+      answered: false,
+    });
     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);
   });

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

@@ -0,0 +1,238 @@
+import Contact from '../Contact';
+
+describe('Contact domain', () => {
+  it('is extern when given no uuid', () => {
+    const boba = new Contact({});
+    expect(boba.isIntern()).toBeFalsy();
+  });
+  it('is intern when given a uuid', () => {
+    const boba = new Contact({
+      uuid: '123',
+    });
+    expect(boba.isIntern()).toBeTruthy();
+  });
+  it('is the same contact when it has the same uuid and sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact when it has the same uuid and no sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: undefined,
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: undefined,
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact when it has the same uuid and no sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: undefined,
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: undefined,
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact when one is missing a uuid but they have the same sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: undefined,
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact when one is missing a sourceId but they have the same sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: undefined,
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact even when it has different uuid', () => {
+    const john = new Contact({
+      uuid: 'abc',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('is the same contact even when it has different sourceId', () => {
+    const john = new Contact({
+      uuid: '12345',
+      sourceId: '100',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    const sam = new Contact({
+      uuid: '12345',
+      sourceId: '800',
+      backend: 'some-backend',
+      source: 'wazo',
+    });
+    expect(john.is(sam)).toBe(true);
+  });
+  it('has the id given the same uuid', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+    });
+    expect(contact.hasId('uuid-12345')).toBeTruthy();
+  });
+  it('does not have the id given a different uuid', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+    });
+    expect(contact.hasId('uuid-dummy')).toBeFalsy();
+  });
+  it('does separate names with a single space', () => {
+    const contact = new Contact({
+      name: 'John Smith',
+    });
+    const {
+      firstName,
+      lastName,
+    } = contact.separateName();
+    expect(firstName).toBe('John');
+    expect(lastName).toBe('Smith');
+  });
+  it('does separate names with multiple spaces', () => {
+    const contact = new Contact({
+      name: 'John  Smith',
+    });
+    const {
+      firstName,
+      lastName,
+    } = contact.separateName();
+    expect(firstName).toBe('John');
+    expect(lastName).toBe('Smith');
+  });
+  it('is available given an available state', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+      state: 'available',
+    });
+    expect(contact.isAvailable()).toBeTruthy();
+  });
+  it('is not available given a non available state', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+      state: 'donotdisturb',
+    });
+    expect(contact.isAvailable()).toBeFalsy();
+  });
+  it('is not available given no state', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+    });
+    expect(contact.isAvailable()).toBeFalsy();
+  });
+  it('can parse a plain contact to domain', () => {
+    const response = {
+      column_types: ['name', 'number', 'callable', 'voicemail', 'favorite', 'email', 'personal'],
+      term: 'a',
+      column_headers: ['Nom', 'Num\u00e9ro', 'Mobile', 'Bo\u00eete vocale', 'Favoris', 'E-mail', 'Personnel'],
+      results: [{
+        source: 'internal',
+        column_values: ['Jonathan Lessard', '8020', '06800880', null, false, 'contact@nexapp.ca', false],
+        backend: 'wazo',
+        relations: {
+          user_id: 8,
+          xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
+          agent_id: null,
+          endpoint_id: 8,
+          user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+          source_entry_id: '8',
+        },
+      }],
+    };
+    const contact = Contact.parse(response.results[0], response.column_types);
+    expect(contact).toEqual(new Contact({
+      name: 'Jonathan Lessard',
+      number: '8020',
+      numbers: [{
+        label: 'primary',
+        number: '8020',
+      }, {
+        label: 'secondary',
+        number: '06800880',
+      }],
+      favorited: false,
+      email: 'contact@nexapp.ca',
+      emails: [{
+        label: 'primary',
+        email: 'contact@nexapp.ca',
+      }],
+      address: '',
+      entreprise: '',
+      birthday: '',
+      note: '',
+      endpointId: 8,
+      personal: false,
+      source: 'internal',
+      sourceId: '8',
+      uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+      backend: 'wazo',
+    }));
+  });
+  it('should merge 2 contact', () => {
+    const contact = new Contact({
+      uuid: 'uuid-12345',
+      lastActivity: 'yesterday',
+      // @ts-expect-error
+      birthday: null,
+    });
+    const contact2 = new Contact({
+      uuid: 'uuid-12345',
+      // @ts-expect-error
+      lastActivity: null,
+      birthday: 'tomorrow',
+    });
+    const result = contact.merge(contact2);
+    expect(result.lastActivity).toBe('yesterday');
+    expect(result.birthday).toBe('tomorrow');
+  });
+});