@wazo/sdk 0.43.15 → 0.44.0

package/esm/checker/checks/webrtc.js

@@ -1,40 +0,0 @@
-/* global MediaStream */
-import WebRTCClient from '../../web-rtc-client';
-export default {
-    name: 'WebRTC',
-    check: (server, session) => new Promise((resolve, reject) => {
-        if (typeof MediaStream === 'undefined') {
-            return resolve('Skipped on node');
-        }
-        const [host, port = 443] = server.split(':');
-        const client = new WebRTCClient({
-            host,
-            port,
-            media: {
-                audio: true,
-            },
-        }, session);
-        const handleError = (message) => {
-            client.close();
-            reject(new Error(message));
-        };
-        const handleSuccess = async () => {
-            client.stopHeartbeat();
-            await client.close();
-            resolve();
-        };
-        client.on(client.TRANSPORT_ERROR, error => {
-            handleError(`Transport error : ${error}`);
-        });
-        client.on(client.REGISTERED, () => {
-            const sipSession = client.call('*10');
-            if (!sipSession || !client.getSipSessionId(sipSession)) {
-                return handleError('Unable to make call through WebRTC');
-            }
-            setTimeout(() => {
-                client.hangup(sipSession);
-                handleSuccess();
-            }, 1000);
-        });
-    }),
-};

package/esm/constants.js

@@ -1,11 +0,0 @@
-export const AUTH_VERSION = '0.1';
-export const APPLICATION_VERSION = '1.0';
-export const CONFD_VERSION = '1.1';
-export const CTIDNG_VERSION = '1.0';
-export const DIRD_VERSION = '0.1';
-export const CALL_LOGD_VERSION = '1.0';
-export const CHATD_VERSION = '1.0';
-export const CALLD_VERSION = '1.0';
-export const AGENTD_VERSION = '1.0';
-export const WEBHOOKD_VERSION = '1.0';
-export const AMID_VERSION = '1.0';

package/esm/domain/AdHocAPIConference.js

@@ -1,102 +0,0 @@
-import getApiClient from '../service/getApiClient';
-export default class AdHocAPIConference {
-    phone;
-    host;
-    participants;
-    started;
-    finished;
-    conferenceId;
-    answerTime;
-    muted;
-    paused;
-    constructor({ phone, host, participants, started, finished, answerTime, conferenceId, muted, paused, }) {
-        this.phone = phone;
-        this.host = host;
-        this.participants = participants || {};
-        this.started = started || false;
-        this.finished = finished || false;
-        this.answerTime = answerTime;
-        this.conferenceId = conferenceId || '';
-        this.muted = muted || false;
-        this.paused = paused || false;
-        if (this.host) {
-            this.host.setIsConference(true);
-        }
-    }
-    async start() {
-        this.started = true;
-        // @ts-ignore: date / number
-        this.answerTime = Object.values(this.participants).length ? Object.values(this.participants)[0].answerTime : null;
-        const participantIds = Object.keys(this.participants);
-        const conference = await getApiClient().calld.createAdHocConference(this.host.callId, participantIds);
-        this.conferenceId = conference.conference_id;
-        return this;
-    }
-    getParticipants() {
-        return Object.values(this.participants);
-    }
-    async addParticipant(newParticipant) {
-        const participantCallId = newParticipant.getTalkingToIds()[0];
-        const participants = { ...this.participants,
-            [participantCallId]: newParticipant,
-        };
-        await getApiClient().calld.addAdHocConferenceParticipant(this.conferenceId, participantCallId);
-        return new AdHocAPIConference({ ...this,
-            participants,
-        });
-    }
-    participantHasLeft(leaver) {
-        delete this.participants[leaver.getId()];
-        return new AdHocAPIConference({ ...this,
-            participants: this.participants,
-        });
-    }
-    hasParticipants() {
-        return Object.keys(this.participants).length > 0;
-    }
-    mute() {
-        this.muted = true;
-        this.phone.mute(this.host);
-        return new AdHocAPIConference({ ...this,
-        });
-    }
-    unmute() {
-        this.muted = false;
-        this.phone.unmute(this.host);
-        return new AdHocAPIConference({ ...this,
-        });
-    }
-    hold() {
-        this.paused = true;
-        this.phone.hold(this.host);
-        return new AdHocAPIConference({ ...this,
-        });
-    }
-    resume() {
-        this.paused = false;
-        this.phone.resume(this.host);
-        return new AdHocAPIConference({ ...this,
-        });
-    }
-    isOnHold() {
-        return this.paused;
-    }
-    isMuted() {
-        return this.muted;
-    }
-    async hangup() {
-        await getApiClient().calld.deleteAdHocConference(this.conferenceId);
-        return new AdHocAPIConference({ ...this,
-            finished: true,
-            participant: [],
-        });
-    }
-    async removeParticipant(participantToRemove) {
-        const callId = participantToRemove.getTalkingToIds()[0];
-        delete this.participants[callId];
-        await getApiClient().calld.removeAdHocConferenceParticipant(this.conferenceId, callId);
-        return new AdHocAPIConference({ ...this,
-            participants: this.participants,
-        });
-    }
-}

package/esm/domain/Agent.js

@@ -1,30 +0,0 @@
-class Agent {
-    context;
-    extension;
-    id;
-    logged;
-    number;
-    paused;
-    pausedReason;
-    static parse(plain) {
-        return new Agent({
-            context: plain.context,
-            extension: plain.extension,
-            id: plain.id,
-            logged: plain.logged,
-            number: plain.number,
-            paused: plain.paused,
-            pausedReason: plain.paused_reason,
-        });
-    }
-    constructor({ context, extension, id, logged, number, paused, pausedReason, }) {
-        this.context = context;
-        this.extension = extension;
-        this.id = id;
-        this.logged = logged;
-        this.number = number;
-        this.paused = paused;
-        this.pausedReason = pausedReason;
-    }
-}
-export default Agent;

package/esm/domain/BadResponse.js

@@ -1,21 +0,0 @@
-export default class BadResponse extends Error {
-    static fromResponse(error, status) {
-        return new BadResponse(error.message || JSON.stringify(error), status, error.timestamp, error.error_id, error.details, error);
-    }
-    static fromText(response, status) {
-        return new BadResponse(response, status);
-    }
-    status;
-    timestamp;
-    errorId;
-    details;
-    error;
-    constructor(message, status, timestamp = null, errorId = null, details = null, error = null) {
-        super(message);
-        this.timestamp = timestamp;
-        this.status = status;
-        this.errorId = errorId;
-        this.details = details;
-        this.error = error;
-    }
-}

package/esm/domain/Call.js

@@ -1,123 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-const RECORD_STATE_ACTIVE = 'active';
-export default class Call {
-    type;
-    id;
-    sipCallId;
-    callerName;
-    callerNumber;
-    calleeName;
-    calleeNumber;
-    dialedExtension;
-    lineId;
-    isCaller;
-    isVideo;
-    onHold;
-    muted;
-    status;
-    startingTime;
-    talkingToIds;
-    recording;
-    static parseMany(plain) {
-        if (!plain) {
-            return [];
-        }
-        return plain.map((plainCall) => Call.parse(plainCall));
-    }
-    static parse(plain) {
-        return new Call({
-            id: plain.call_id,
-            sipCallId: plain.sip_call_id,
-            callerName: plain.caller_id_name,
-            callerNumber: plain.caller_id_number,
-            calleeName: plain.peer_caller_id_name,
-            calleeNumber: plain.peer_caller_id_number,
-            dialedExtension: plain.dialed_extension,
-            isCaller: plain.is_caller,
-            isVideo: plain.is_video,
-            muted: plain.muted,
-            onHold: plain.on_hold,
-            status: plain.status,
-            lineId: plain.line_id,
-            startingTime: moment(plain.creation_time).toDate(),
-            talkingToIds: Object.keys(plain.talking_to || {}),
-            recording: plain.record_state === RECORD_STATE_ACTIVE,
-        });
-    }
-    static newFrom(call) {
-        return newFrom(call, Call);
-    }
-    constructor({ id, sipCallId, callerName, callerNumber, calleeName, calleeNumber, dialedExtension, isCaller, isVideo, lineId, muted, onHold, status, startingTime, talkingToIds, recording, }) {
-        this.id = id;
-        this.sipCallId = sipCallId;
-        this.callerName = callerName;
-        this.callerNumber = callerNumber;
-        this.calleeName = calleeName;
-        this.calleeNumber = calleeNumber;
-        this.dialedExtension = dialedExtension;
-        this.muted = muted;
-        this.onHold = onHold;
-        this.isCaller = isCaller;
-        this.lineId = lineId;
-        this.status = status;
-        this.startingTime = startingTime;
-        this.talkingToIds = talkingToIds || [];
-        this.recording = recording;
-        this.isVideo = !!isVideo;
-        // Useful to compare instead of instanceof with minified code
-        this.type = 'Call';
-    }
-    getElapsedTimeInSeconds() {
-        const now = Date.now();
-        return (now - +this.startingTime) / 1000;
-    }
-    separateCalleeName() {
-        const names = this.calleeName.split(' ');
-        const firstName = names[0];
-        const lastName = names.slice(1).join(' ');
-        return {
-            firstName,
-            lastName,
-        };
-    }
-    is(other) {
-        return !!other && this.id === other.id;
-    }
-    hasACalleeName() {
-        return this.calleeName.length > 0;
-    }
-    hasNumber(number) {
-        return this.calleeNumber === number;
-    }
-    isUp() {
-        return this.status === 'Up';
-    }
-    isDown() {
-        return this.status === 'Down';
-    }
-    isRinging() {
-        return this.isRingingIncoming() || this.isRingingOutgoing();
-    }
-    isRingingIncoming() {
-        return this.status === 'Ringing';
-    }
-    isRingingOutgoing() {
-        return this.status === 'Ring';
-    }
-    isFromTransfer() {
-        return this.status === 'Down' || this.status === 'Ringing';
-    }
-    isOnHold() {
-        return this.onHold;
-    }
-    putOnHold() {
-        this.onHold = true;
-    }
-    resume() {
-        this.onHold = false;
-    }
-    isRecording() {
-        return this.recording;
-    }
-}

package/esm/domain/CallLog.js

@@ -1,157 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-import Recording from './Recording';
-// note: 24.14 fixes requested (first contact reached) and destination (last contact reached)
-export const CALL_LOG_VALID_REQUESTED_VERSION = '24.14';
-export default class CallLog {
-    type;
-    answer;
-    answered;
-    newMissedCall;
-    callDirection;
-    destination;
-    requested;
-    recordings;
-    source;
-    id;
-    duration;
-    start;
-    end;
-    static merge(current, toMerge) {
-        const onlyUnique = (value, index, self) => self.indexOf(value) === index;
-        const allLogs = current.concat(toMerge);
-        const onlyUniqueIds = allLogs.map(c => c.id).filter(onlyUnique);
-        return onlyUniqueIds.map(id => allLogs.find(log => log && log.id === id));
-    }
-    static parseMany(plain) {
-        if (!plain || !plain.items) {
-            return [];
-        }
-        return plain.items.map(item => CallLog.parse(item));
-    }
-    static parse(plain) {
-        return new CallLog({
-            answer: plain.answer ? moment(plain.answer).toDate() : null,
-            answered: plain.answered,
-            callDirection: plain.call_direction,
-            destination: {
-                // @TEMP: Temporarily assuming empty numbers are meetings
-                // which is admittedly a very dangerous assumption. Did i mention it was temporary?
-                uuid: plain.destination_user_uuid,
-                name: plain.requested_name || plain.destination_name || '',
-                extension: plain.requested_extension || plain.destination_extension || `meeting-${plain.requested_name || plain.destination_name || ''}`,
-                plainExtension: plain.destination_extension,
-                plainName: plain.destination_name,
-            },
-            requested: {
-                uuid: plain.requested_user_uuid,
-                name: plain.requested_name || '',
-                extension: plain.requested_extension,
-            },
-            source: {
-                uuid: plain.source_user_uuid,
-                name: plain.source_name,
-                extension: plain.source_extension,
-            },
-            id: plain.id,
-            duration: (plain.duration || 0) * 1000,
-            // duration is in seconds
-            start: moment(plain.start).toDate(),
-            end: plain.end ? moment(plain.end).toDate() : null,
-            recordings: Recording.parseMany(plain.recordings || []),
-        });
-    }
-    static parseNew(plain, session) {
-        const callLog = CallLog.parse(plain);
-        callLog.newMissedCall = session && plain.destination_user_uuid === session.uuid && !plain.answered;
-        return callLog;
-    }
-    static newFrom(profile) {
-        return newFrom(profile, CallLog);
-    }
-    constructor({ answer, answered, callDirection, destination, requested, source, id, duration, start, end, recordings, }) {
-        this.answer = answer;
-        this.answered = answered;
-        this.callDirection = callDirection;
-        this.destination = destination;
-        this.requested = requested;
-        this.source = source;
-        this.id = id;
-        this.duration = duration;
-        this.start = start;
-        this.end = end;
-        this.recordings = recordings || [];
-        // Useful to compare instead of instanceof with minified code
-        this.type = 'CallLog';
-    }
-    isFromSameParty(other, session) {
-        return this.theOtherParty(session).extension === other.theOtherParty(session).extension;
-    }
-    theOtherParty(session) {
-        if (this.callDirection === 'inbound') {
-            return this.source;
-        }
-        if (this.callDirection === 'outbound') {
-            return this.destination;
-        }
-        return session?.hasExtension(this.source.extension) ? this.destination : this.source;
-    }
-    isNewMissedCall() {
-        return this.newMissedCall;
-    }
-    acknowledgeCall() {
-        this.newMissedCall = false;
-        return this;
-    }
-    isAcknowledged() {
-        return this.newMissedCall;
-    }
-    isAnswered() {
-        return this.answered;
-    }
-    isOutgoing(session) {
-        if (this.callDirection === 'internal') {
-            return session.hasExtension(this.source.extension);
-        }
-        return this.callDirection === 'outbound';
-    }
-    isIncoming(session) {
-        if (this.callDirection === 'internal') {
-            return session.hasExtension(this.destination.plainExtension)
-                || session.hasExtension(this.requested.extension)
-                || session.uuid === this.destination.uuid
-                || session.uuid === this.requested.uuid;
-        }
-        return this.callDirection === 'inbound';
-    }
-    // Example of call flow: User A => User B (No anwser forward) => User C or external number
-    isIncomingAndForwarded(session) {
-        if (!session.hasEngineVersionGte(CALL_LOG_VALID_REQUESTED_VERSION) || !this.isIncoming(session)) {
-            return false;
-        }
-        return this.requested.extension !== this.destination.plainExtension;
-    }
-    isAnOutgoingCall(session) {
-        console.warn(`@wazo/sdk
-      CallLog.isAnOutgoingcall(session) method is obsolete.
-      Please use CallLog.isOutgoing(session).
-    `);
-        return session.hasExtension(this.source.extension) && this.answered;
-    }
-    isAMissedOutgoingCall(session) {
-        return session.hasExtension(this.source.extension) && !this.answered;
-    }
-    isAnIncomingCall(session) {
-        console.warn(`@wazo/sdk
-      CallLog.isAnIncomingCall(session) method is obsolete.
-      Please use CallLog.isIncoming(session).
-    `);
-        return session.hasExtension(this.destination.extension) && this.answered;
-    }
-    isADeclinedCall(session) {
-        return !this.answered && session.hasExtension(this.destination.extension);
-    }
-    getRecordings() {
-        return this.recordings;
-    }
-}