@wazo/sdk 0.43.14 → 0.44.0

package/src/checker/Checker.ts

@@ -1,73 +0,0 @@
-import type Session from '../domain/Session';
-import WazoApiClient from '../api-client';
-import IssueReporter from '../service/IssueReporter';
-import checks from './checks/index';
-
-const logger = IssueReporter.loggerFor('engine-check');
-
-class Checker {
-  session: Session;
-
-  server: string;
-
-  externalAppConfig: Record<string, any>;
-
-  checks: Record<string, any>[];
-
-  constructor(server: string, session: Session, externalAppConfig: Record<string, any> = {}) {
-    this.server = server;
-    this.session = session;
-    this.externalAppConfig = externalAppConfig;
-    this.checks = [...checks];
-  }
-
-  async check(onCheckBegin: (...args: Array<any>) => any = () => {}, onCheckResult: (...args: Array<any>) => any = () => {}) {
-    await this._addEngineVersion();
-    logger.info('Engine check starting');
-
-    for (let i = 0; i < this.checks.length; i++) {
-      const {
-        name,
-        check,
-      } = this.checks[i];
-      logger.info(`Checking ${name} ...`);
-      onCheckBegin(name);
-
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        const result = await check(this.server, this.session, this.externalAppConfig);
-        logger.info(`Checking ${name} success.`, {
-          result,
-        });
-        onCheckResult(name, result);
-      } catch (e: any) {
-        logger.info(`Checking ${name} failure`, {
-          message: e.message,
-        });
-        onCheckResult(name, e);
-      }
-    }
-
-    logger.info('Engine check done.');
-  }
-
-  addCheck(check: Record<string, any>) {
-    this.checks.push(check);
-  }
-
-  async _addEngineVersion() {
-    if (!this.session.engineVersion) {
-      const apiClient = new WazoApiClient({
-        server: this.server,
-      });
-      apiClient.setToken(this.session.token);
-      const {
-        wazo_version: engineVersion,
-      } = await apiClient.confd.getInfos();
-      this.session.engineVersion = engineVersion;
-    }
-  }
-
-}
-
-export default Checker;

package/src/checker/checks/aor.ts

@@ -1,34 +0,0 @@
-import WazoApiClient from '../../api-client';
-
-export default {
-  name: 'List of AOR',
-  check: async (server: string, session: any) => {
-    const apiClient = new WazoApiClient({
-      server,
-    });
-    apiClient.setToken(session.token);
-    apiClient.disableErrorLogging();
-    const line = session.primaryWebRtcLine();
-
-    if (!line) {
-      return 'No WebRTC line for this user';
-    }
-
-    const {
-      username,
-    } = line;
-
-    try {
-      const aors = await apiClient.amid.getAors(username);
-      const nbAors = aors.length;
-      const availableAors = aors.filter(aor => aor.status === 'Reachable');
-      return `Number of AOR: ${nbAors} (${availableAors.length} Avail, ${nbAors - availableAors.length} Unavail)`;
-    } catch (e: any) {
-      if (e.status === 401) {
-        return 'Not available for this user';
-      }
-
-      throw e;
-    }
-  },
-};

package/src/checker/checks/api.ts

@@ -1,78 +0,0 @@
-import WazoApiClient from '../../api-client';
-import ServerError from '../../domain/ServerError';
-
-export default {
-  name: 'API',
-  check: async (server: string, session: any) => {
-    const client = new WazoApiClient({
-      server,
-    });
-    client.setToken(session.token);
-    client.disableErrorLogging();
-
-    const handleApiError = (apiName: string, error: any) => {
-      const statusText = error instanceof ServerError ? 'server error' : 'api error';
-      throw new Error(`${apiName} fails with status (${error.status}, ${statusText}) : ${error.message}`);
-    };
-
-    // Check simple API call
-    try {
-      await client.auth.getPushNotificationSenderId(session.uuid as string);
-      await client.auth.getProviders(session.uuid as string);
-    } catch (e: any) {
-      handleApiError('wazo-auth', e);
-    }
-
-    try {
-      await client.callLogd.listCallLogs();
-    } catch (e: any) {
-      handleApiError('wazo-callogd', e);
-    }
-
-    try {
-      await client.calld.listCalls();
-    } catch (e: any) {
-      handleApiError('wazo-calld', e);
-    }
-
-    try {
-      await client.calld.listVoicemails();
-    } catch (e: any) {
-      // API throws a 404 when no voicemail
-      if (e.status !== 404) {
-        handleApiError('wazo-calld', e);
-      }
-    }
-
-    try {
-      await client.chatd.getState(session.uuid as string);
-      await client.chatd.getContactStatusInfo(session.uuid as string);
-      await client.chatd.getUserRooms();
-    } catch (e: any) {
-      handleApiError('wazo-chatd', e);
-    }
-
-    try {
-      await client.confd.getInfos();
-      await client.confd.getUser(session.uuid as string);
-    } catch (e: any) {
-      handleApiError('wazo-confd', e);
-    }
-
-    try {
-      await client.dird.listPersonalContacts();
-      await client.dird.listFavorites(session.primaryContext());
-      await client.dird.fetchWazoSource(session.primaryContext());
-      const conferenceSource = await client.dird.fetchConferenceSource(session.primaryContext());
-      await client.dird.fetchConferenceContacts(conferenceSource.items[0]);
-    } catch (e: any) {
-      handleApiError('wazo-dird', e);
-    }
-
-    try {
-      await client.webhookd.getSubscriptions();
-    } catch (e: any) {
-      handleApiError('wazo-webhookd', e);
-    }
-  },
-};

package/src/checker/checks/ice-ipv4.ts

@@ -1,80 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-import isMobile from '../../utils/isMobile';
-
-const checkIsIPV4 = (ip: string) => {
-  const blocks = ip.split('.');
-
-  if (blocks.length !== 4) {
-    return false;
-  }
-
-  return blocks.every(block => parseInt(block, 10) >= 0 && parseInt(block, 10) <= 255);
-};
-
-export default {
-  name: 'Non IP v4 ice',
-  check: (server: string, session: any, externalAppConfig: Record<string, any>) => new Promise((resolve, reject) => {
-    if (typeof MediaStream === 'undefined') {
-      resolve('Skipped on node');
-      return;
-    }
-
-    const mobile = isMobile();
-    const offerOptions = {
-      offerToReceiveAudio: 1,
-    };
-    const ips: string[] = [];
-    const config: RTCConfiguration = {
-      iceServers: [{
-        urls: 'stun:stun1.l.google.com:19302',
-      }, {
-        urls: 'stun:stun2.l.google.com:19302',
-      }],
-    };
-    let hasSrflxOrRelay = false;
-
-    if (externalAppConfig && externalAppConfig.stun_servers) {
-      config.iceServers = { ...externalAppConfig.stun_servers.split(',').map((url: string) => ({
-        urls: url,
-      })),
-      ...config.iceServers,
-      };
-    }
-
-    if (externalAppConfig && externalAppConfig.turn_servers) {
-      config.iceServers = [...JSON.parse(externalAppConfig.turn_servers), ...(config.iceServers || [])];
-      // Force to use TURN when defined in config
-      config.iceTransportPolicy = 'relay';
-    }
-
-    const pc = new RTCPeerConnection(config);
-    pc.createDataChannel('wazo-check-ipv4');
-
-    pc.onicecandidate = e => {
-      if (e.candidate) {
-        const rawCandidate = e.candidate.candidate;
-
-        if (rawCandidate.indexOf('srflx') !== -1 || rawCandidate.indexOf('relay') !== -1) {
-          hasSrflxOrRelay = true;
-          const candidate = parseCandidate(e.candidate.candidate);
-          ips.push(candidate.ip);
-        }
-      } else if (!e.candidate) {
-        if (!hasSrflxOrRelay) {
-          return reject(new Error('No `srflx` or `relay` found in candidate. Please consider using a TURN server.'));
-        }
-
-        if (ips.every(checkIsIPV4)) {
-          resolve(null);
-        } else {
-          const nonIPV4 = ips.find(ip => !checkIsIPV4(ip));
-          reject(new Error(`Non IPv4 ice candidate found : ${nonIPV4}.`));
-        }
-      }
-    };
-
-    // @ts-ignore
-    pc.createOffer(offerOptions).then(offer => pc.setLocalDescription(offer)).then(description => (mobile ? pc.createOffer(offerOptions) : description)).then(sessionDescription => (mobile ? pc.setLocalDescription(sessionDescription) : sessionDescription));
-  }),
-};

package/src/checker/checks/index.ts

@@ -1,9 +0,0 @@
-import api from './api';
-import aor from './aor';
-import wazoWebsocket from './wazo-websocket';
-import webrtcTransport from './webrtc-transport';
-import webrtc from './webrtc';
-import SymmetricNat from './symmetric-nat';
-import iceIpv4 from './ice-ipv4';
-
-export default [aor, api, wazoWebsocket, webrtcTransport, webrtc, SymmetricNat, iceIpv4];

package/src/checker/checks/symmetric-nat.ts

@@ -1,69 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-
-const timeoutDuration = 8000; // @see https://webrtchacks.com/symmetric-nat/
-
-export default {
-  name: 'Symmetric NAT',
-  check: (): Promise<string | void> => new Promise((resolve, reject) => {
-    if (typeof MediaStream === 'undefined') {
-      return resolve('Skipped on node');
-    }
-
-    const candidates: Record<string, any> = {};
-    const rawCandidates: any[] = [];
-    let nbCandidates = 0;
-    const pc = new RTCPeerConnection({
-      iceServers: [{
-        urls: 'stun:stun.wazo.io:443',
-      }, {
-        urls: 'stun:stun1.l.google.com:19302',
-      }, {
-        urls: 'stun:stun2.l.google.com:19302',
-      }],
-    });
-    let timeout: string | number | NodeJS.Timeout | undefined;
-
-    const onEnded = () => {
-      clearTimeout(timeout);
-
-      if (Object.keys(candidates).length === 0) {
-        reject(new Error(`Timed out (${timeoutDuration}ms), ${nbCandidates} candidates : ${rawCandidates.join(', ')}`));
-        return;
-      }
-
-      const ports = candidates[Object.keys(candidates)[0]];
-
-      if (ports.length === 1) {
-        resolve();
-      } else {
-        reject(new Error('Symmetric NAT detected, you should use a TURN server.'));
-      }
-    };
-
-    timeout = setTimeout(onEnded, timeoutDuration);
-    pc.createDataChannel('wazo-check-nat');
-
-    pc.onicecandidate = (e: RTCPeerConnectionIceEvent) => {
-      nbCandidates++;
-
-      if (e.candidate) {
-        rawCandidates.push(e.candidate.candidate);
-      }
-
-      if (e.candidate && e.candidate.candidate.indexOf('srflx') !== -1) {
-        const cand = parseCandidate(e.candidate.candidate);
-        if (cand.relatedPort) {
-          if (!candidates[cand.relatedPort]) {
-            candidates[cand.relatedPort] = [];
-          }
-          candidates[cand.relatedPort].push(cand.port);
-        }
-      } else if (!e.candidate) {
-        onEnded();
-      }
-    };
-
-    pc.createOffer().then(offer => pc.setLocalDescription(offer));
-  }),
-};

package/src/checker/checks/wazo-websocket.ts

@@ -1,41 +0,0 @@
-import WebSocketClient, { SOCKET_EVENTS, HEARTBEAT_ENGINE_VERSION } from '../../websocket-client';
-
-export default {
-  name: 'Event transport (WS)',
-  check: (server: string, session: any) => new Promise<void>((resolve, reject) => {
-    const client = new WebSocketClient({
-      host: server,
-      token: session.token,
-      version: 2,
-    });
-
-    const handleError = (message: any) => {
-      client.close();
-      reject(new Error(message));
-    };
-
-    const handleSuccess = () => {
-      client.stopHeartbeat();
-      client.close();
-      resolve();
-    };
-
-    client.on(SOCKET_EVENTS.ON_ERROR, error => {
-      handleError(`Connection error : ${error}`);
-    });
-    client.on(SOCKET_EVENTS.ON_OPEN, () => {
-      if (session.hasEngineVersionGte(HEARTBEAT_ENGINE_VERSION)) {
-        client.setOnHeartbeatTimeout(() => {
-          handleError('No response to heartbeat');
-        });
-        client.setOnHeartbeatCallback(() => {
-          handleSuccess();
-        });
-        client.startHeartbeat();
-      } else {
-        handleSuccess();
-      }
-    });
-    client.connect();
-  }),
-};

package/src/checker/checks/webrtc-transport.ts

@@ -1,42 +0,0 @@
-import WebRTCClient from '../../web-rtc-client';
-import { WazoSession } from '../../domain/types';
-
-export default {
-  name: 'WebRTC Transport (WS) ~30s',
-  check: (server: string, session: WazoSession): Promise<void> => new Promise((resolve, reject) => {
-    const [host, port = 443] = server.split(':');
-
-    const client = new WebRTCClient({
-      host,
-      port,
-      media: {
-        audio: true,
-      },
-    }, session);
-
-    const handleError = (message: any) => {
-      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, () => {
-      client.setOnHeartbeatTimeout(() => {
-        handleError('No response to heartbeat');
-      });
-      client.setOnHeartbeatCallback(() => {
-        handleSuccess();
-      });
-      client.startHeartbeat();
-    });
-  }),
-};

package/src/checker/checks/webrtc.ts

@@ -1,48 +0,0 @@
-/* global MediaStream */
-import WebRTCClient from '../../web-rtc-client';
-
-export default {
-  name: 'WebRTC',
-  check: (server: string, session: any) => new Promise<void | string>((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: any) => {
-      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/src/domain/AdHocAPIConference.ts

@@ -1,166 +0,0 @@
-import CallSession from './CallSession';
-import type WebRTCPhone from './Phone/WebRTCPhone';
-import getApiClient from '../service/getApiClient';
-
-export type ConferenceParticipant = {
-  admin: boolean;
-  call_id: string;
-  caller_id_name: string;
-  caller_id_number: string;
-  id: string;
-  join_time: number;
-  language: string;
-  muted: boolean;
-  user_uuid: string;
-};
-export type ConferenceParticipants = {
-  items: Array<ConferenceParticipant>;
-  total: number;
-};
-export type ConferenceArguments = {
-  phone: WebRTCPhone;
-  host: CallSession;
-  finished?: boolean;
-  participants: Record<string, CallSession>;
-  started?: boolean;
-  answerTime?: number | null | undefined;
-  conferenceId?: string | null | undefined;
-  muted?: boolean;
-  paused?: boolean;
-}; // API adhoc conference
-
-export default class AdHocAPIConference {
-  phone: WebRTCPhone;
-
-  host: CallSession;
-
-  participants: Record<string, CallSession>;
-
-  started: boolean;
-
-  finished: boolean;
-
-  conferenceId: string;
-
-  answerTime: number | null | undefined;
-
-  muted: boolean;
-
-  paused: boolean;
-
-  constructor({
-    phone,
-    host,
-    participants,
-    started,
-    finished,
-    answerTime,
-    conferenceId,
-    muted,
-    paused,
-  }: ConferenceArguments) {
-    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: CallSession): Promise<AdHocAPIConference> {
-    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: CallSession): AdHocAPIConference {
-    delete this.participants[leaver.getId()];
-    return new AdHocAPIConference({ ...this,
-      participants: this.participants,
-    });
-  }
-
-  hasParticipants() {
-    return Object.keys(this.participants).length > 0;
-  }
-
-  mute(): AdHocAPIConference {
-    this.muted = true;
-    this.phone.mute(this.host);
-    return new AdHocAPIConference({ ...this,
-    });
-  }
-
-  unmute(): AdHocAPIConference {
-    this.muted = false;
-    this.phone.unmute(this.host);
-    return new AdHocAPIConference({ ...this,
-    });
-  }
-
-  hold(): AdHocAPIConference {
-    this.paused = true;
-    this.phone.hold(this.host);
-    return new AdHocAPIConference({ ...this,
-    });
-  }
-
-  resume(): AdHocAPIConference {
-    this.paused = false;
-    this.phone.resume(this.host);
-    return new AdHocAPIConference({ ...this,
-    });
-  }
-
-  isOnHold(): boolean {
-    return this.paused;
-  }
-
-  isMuted(): boolean {
-    return this.muted;
-  }
-
-  async hangup(): Promise<AdHocAPIConference> {
-    await getApiClient().calld.deleteAdHocConference(this.conferenceId);
-    return new AdHocAPIConference({ ...this,
-      finished: true,
-      participant: [],
-    });
-  }
-
-  async removeParticipant(participantToRemove: CallSession) {
-    const callId = participantToRemove.getTalkingToIds()[0];
-    delete this.participants[callId];
-    await getApiClient().calld.removeAdHocConferenceParticipant(this.conferenceId, callId);
-    return new AdHocAPIConference({ ...this,
-      participants: this.participants,
-    });
-  }
-
-}