@wazo/sdk 0.43.14 → 0.44.0

package/esm/domain/Voicemail.js

@@ -1,76 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-export const VoicemailFolder = {
-    NEW: 'new',
-    OLD: 'old',
-    URGENT: 'urgent',
-    OTHER: 'other',
-};
-const VoicemailFolderMapping = {
-    [VoicemailFolder.NEW]: 1,
-    [VoicemailFolder.OLD]: 2,
-    [VoicemailFolder.URGENT]: 3,
-    [VoicemailFolder.OTHER]: 4,
-};
-export default class Voicemail {
-    type;
-    id;
-    date;
-    duration;
-    unread;
-    caller;
-    static parse(plain) {
-        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) {
-        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) {
-        return newFrom(profile, Voicemail);
-    }
-    static getFolderMappingFromType(folder) {
-        return VoicemailFolderMapping[folder];
-    }
-    constructor({ id, date, duration, caller, unread, }) {
-        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) {
-        return other && this.id === other.id;
-    }
-    acknowledge() {
-        this.unread = false;
-        return this;
-    }
-    makeAsUnRead() {
-        this.unread = true;
-        return this;
-    }
-    contains(query) {
-        if (!query) {
-            return true;
-        }
-        return this.caller.name.toUpperCase().includes(query.toUpperCase()) || this.caller.number.includes(query);
-    }
-}

package/esm/domain/__tests__/Agent.test.js

@@ -1,37 +0,0 @@
-import Agent from '../Agent';
-const fieldMap = {
-    context: 'context',
-    extension: 'extension',
-    id: 'id',
-    logged: 'logged',
-    number: 'number',
-    paused: 'paused',
-    pausedReason: 'paused_reason',
-};
-const plain = {
-    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 = {};
-Object.keys(fieldMap).forEach((field) => {
-    formatted[field] = plain[fieldMap[field]];
-});
-describe('Call Center Agent domain', () => {
-    it('should keep its values', () => {
-        const agent = new Agent(formatted);
-        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);
-        expect(agent).toEqual(new Agent(formatted));
-    });
-});

package/esm/domain/__tests__/Call.test.js

@@ -1,25 +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));
-        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',
-        });
-        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',
-        });
-        expect(call.hasNumber('418-222-5555')).toBeFalsy();
-    });
-});

package/esm/domain/__tests__/CallLog.test.js

@@ -1,181 +0,0 @@
-import moment from 'moment';
-import CallLog, { 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 = {
-    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) => 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',
-                    }],
-            })],
-    }),
-    ...(opts || {}),
-});
-const BOB_SESSION = generateBobSession();
-describe('CallLog Domain', () => {
-    describe('parseMany', () => {
-        it('can parse a plain call log to domain', () => {
-            const 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/esm/domain/__tests__/CallSession.test.js

@@ -1,78 +0,0 @@
-import CallSession from '../CallSession';
-const stringify = (cs) => 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,
-        });
-        const anotherCallSession = new CallSession({
-            callId: 345,
-            callerNumber: '8008',
-            number: '8008',
-            isCaller: false,
-            dialedExtension: undefined,
-        });
-        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,
-        });
-        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,
-        });
-        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,
-        });
-        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);
-    });
-});