@wazo/sdk 1.0.0-alpha.0 → 1.0.0-alpha.10

package/esm/__tests__/__voice__/call.test.js

@@ -2,8 +2,9 @@
 import { Inviter, UserAgent } from 'sip.js';
 import softphone from '../../voice/softphone';
 import Call from '../../voice/call';
-import { Actions, States } from '../../state-machine/call-state-machine';
+import { Actions, EstablishedStates, States } from '../../state-machine/call-state-machine';
 import { Actions as SoftphoneActions } from '../../state-machine/softphone-state-machine';
+import ApiCall from '../../domain/Call';
 import InvalidStateTransition from '../../domain/InvalidStateTransition';
 const uaOptions = {
     logBuiltinEnabled: false,
@@ -28,6 +29,7 @@ jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
     answer: jest.fn(() => Promise.resolve()),
     hangup: jest.fn(() => Promise.resolve()),
     register: jest.fn(() => Promise.resolve()),
+    onCallEnded: jest.fn(() => Promise.resolve()),
     setOnHeartbeatTimeout: jest.fn(() => Promise.resolve()),
     setOnHeartbeatCallback: jest.fn(() => Promise.resolve()),
     on: jest.fn(),
@@ -35,22 +37,61 @@ jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
 const ua = new UserAgent(uaOptions);
 const sipCall = new Inviter(ua, UserAgent.makeURI('sip:1234@my.stack.io'));
 softphone.connect();
+// @ts-ignore: private method
 softphone._sendAction(SoftphoneActions.REGISTER_DONE);
 const invalidStateTransition = (state, action) => new InvalidStateTransition(`Invalid state transition from ${state} with action ${action}`, state, action);
 describe('Call', () => {
+    describe('parsing an API call', () => {
+        it('Should parse an API call and transform it to a Call instance', async () => {
+            const apiCall = new ApiCall({
+                id: '1234',
+                sipCallId: 'abcd',
+                isCaller: false,
+                isVideo: true,
+                recording: true,
+                callerName: '',
+                callerNumber: '',
+                calleeName: '',
+                calleeNumber: '0123423223',
+                dialedExtension: '',
+                lineId: null,
+                muted: true,
+                onHold: false,
+                startingTime: new Date(),
+                status: 'Up',
+                talkingToIds: [],
+            });
+            const call = Call.parseCall(apiCall);
+            expect(call.recording).toBeTruthy();
+            expect(call.id).toBe(apiCall.sipCallId);
+            expect(call.apiId).toBe(apiCall.id);
+            expect(call.number).toBe(apiCall.calleeNumber);
+            expect(call.answerTime).toStrictEqual(apiCall.startingTime);
+            expect(call.isMuted()).toBeTruthy();
+            expect(call.state).toStrictEqual({ [States.ESTABLISHED]: EstablishedStates.MUTED });
+            expect(call.isEstablished()).toBeTruthy();
+        });
+    });
     describe('accept', () => {
         it('Should throw an error when accepting a not ringing call', async () => {
             const call = new Call(sipCall, softphone);
             await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.IDLE, Actions.ACCEPT));
         });
-        it.only('Should throw an error when the softphone is not registered', async () => {
+        it('Should throw an error when the softphone is not registered', async () => {
             const call = new Call(sipCall, softphone);
+            // @ts-ignore: private method
             call._sendAction(Actions.INCOMING_CALL);
+            // @ts-ignore: private method
             softphone._sendAction(SoftphoneActions.TRANSPORT_CLOSED);
             await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.RINGING, Actions.ACCEPT));
+            // Revert softphone state
+            softphone.connect();
+            // @ts-ignore: private method
+            softphone._sendAction(SoftphoneActions.REGISTER_DONE);
         });
         it('Should not throw an error when accepting a not ringing call', async () => {
             const call = new Call(sipCall, softphone);
+            // @ts-ignore: private method
             call._sendAction(Actions.INCOMING_CALL);
             await call.accept();
             expect(softphone.client.answer).toHaveBeenCalled();
@@ -63,10 +104,24 @@ describe('Call', () => {
         });
         it('Should not throw an error when terminating an established call', async () => {
             const call = new Call(sipCall, softphone);
+            // @ts-ignore: private method
             call._sendAction(Actions.MAKE_CALL);
+            // @ts-ignore: private method
             call._sendAction(Actions.REMOTLY_ACCEPTED);
             await call.hangup();
             expect(softphone.client.hangup).toHaveBeenCalled();
         });
     });
+    describe('state propagation', () => {
+        it('Should update the call state in events', (done) => {
+            const call = new Call(sipCall, softphone);
+            // @ts-ignore: private method
+            call._sendAction(Actions.MAKE_CALL);
+            call.on('remotelyAccepted', () => {
+                expect(call.state).toStrictEqual({ [States.ESTABLISHED]: EstablishedStates.ONGOING });
+                done();
+            });
+            call.onAccepted();
+        });
+    });
 });

package/esm/__tests__/api-client.test.js

@@ -113,7 +113,6 @@ describe('With correct API results', () => {
                 body: JSON.stringify({ saml_session_id: samlSessionId }),
                 signal: expect.any(Object),
                 headers: {
-                    'X-Auth-Token': token,
                     'Content-Type': 'application/json',
                     Accept: 'application/json',
                 },
@@ -121,6 +120,26 @@ describe('With correct API results', () => {
             });
         });
     });
+    describe('samlLogIn mobile test', () => {
+        it('should retrieve user token', async () => {
+            Wazo.Auth.mobile = true;
+            const samlSessionId = 'a1b2C3d4';
+            const result = await client.auth.samlLogIn(samlSessionId);
+            expect(result).toBeInstanceOf(Session);
+            expect(result?.token).toBe(1);
+            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
+                method: 'post',
+                body: JSON.stringify({ saml_session_id: samlSessionId }),
+                signal: expect.any(Object),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Wazo-Session-Type': 'mobile',
+                    Accept: 'application/json',
+                },
+                agent: null,
+            });
+        });
+    });
     describe('logOut test', () => {
         it('should delete the specified token', async () => {
             const oldToken = 123;

package/esm/api/auth.js

@@ -33,10 +33,24 @@ export default ((client, baseUrl) => ({
     },
     logOut: (token) => client.delete(`${baseUrl}/token/${token}`, null, {}, ApiRequester.successResponseParser),
     samlLogIn: async (samlSessionId) => {
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
         const body = {
             saml_session_id: samlSessionId,
         };
-        return client.post(`${baseUrl}/token`, body).then(Session.parse);
+        if (client.clientId) {
+            body.access_type = 'offline';
+            body.client_id = client.clientId;
+        }
+        if (Wazo.Auth.mobile) {
+            headers['Wazo-Session-Type'] = 'mobile';
+        }
+        return client.post(`${baseUrl}/token`, body, headers).then(Session.parse);
+    },
+    samlLogOut() {
+        return client.get(`${baseUrl}/saml/logout`, null, null);
     },
     initiateIdpAuthentication: async (domain, redirectUrl) => {
         const body = {
@@ -47,7 +61,7 @@ export default ((client, baseUrl) => ({
             Accept: 'application/json',
             'Content-Type': 'application/json',
         };
-        return client.post(`${baseUrl}/saml/sso`, body, headers, (response) => response);
+        return client.post(`${baseUrl}/saml/sso`, body, headers);
     },
     refreshToken: (refreshToken, backend, expiration, isMobile, tenantId, domainName) => {
         const body = {

package/esm/checker/checks/webrtc.js

@@ -1,5 +1,5 @@
 /* global MediaStream */
-import { getSipSessionId } from '../../utils/sdp';
+import { getSipCallId } from '../../utils/sdp';
 import WebRTCClient from '../../web-rtc-client';
 export default {
     name: 'WebRTC',
@@ -29,7 +29,7 @@ export default {
         });
         client.on(client.REGISTERED, () => {
             const sipSession = client.call('*10');
-            if (!sipSession || !getSipSessionId(sipSession)) {
+            if (!sipSession || !getSipCallId(sipSession)) {
                 return handleError('Unable to make call through WebRTC');
             }
             setTimeout(() => {

package/esm/domain/CallLog.js

@@ -53,8 +53,7 @@ export default class CallLog {
     }
     static parseNew(plain, session) {
         const callLog = CallLog.parse(plain);
-        // @TODO: FIXME add verification declined vs missed call
-        callLog.newMissedCall = session && session.hasExtension((plain.requested_extension || plain.destination_extension)) && !plain.answered;
+        callLog.newMissedCall = session && plain.destination_user_uuid === session.uuid && !plain.answered;
         return callLog;
     }
     static newFrom(profile) {
@@ -112,7 +111,7 @@ export default class CallLog {
         return this.callDirection === 'inbound';
     }
     isAnOutgoingCall(session) {
-        console.warn(`@wazo/sdk 
+        console.warn(`@wazo/sdk
       CallLog.isAnOutgoingcall(session) method is obsolete.
       Please use CallLog.isOutgoing(session).
     `);

package/esm/domain/Phone/CTIPhone.js

@@ -105,7 +105,7 @@ export default class CTIPhone extends Emitter {
             number: callSession.number,
         });
         try {
-            await CallApi.cancelCall(callSession);
+            await CallApi.cancelCall({ apiId: callSession.getId() });
             if (this.currentCall && callSession.callId === this.currentCall.id) {
                 this.endCurrentCall(callSession);
             }
@@ -127,7 +127,7 @@ export default class CTIPhone extends Emitter {
             callId: callSession.getId(),
             number: callSession.number,
         });
-        await CallApi.cancelCall(callSession);
+        await CallApi.cancelCall({ id: callSession.getId() });
         this.eventEmitter.emit('onCallEnded', callSession);
     }
     async transfer(callSession, number) {