@wazo/sdk 0.43.15 → 0.44.0

package/src/domain/Country.ts

@@ -1,19 +0,0 @@
-export default {
-  AUSTRALIA: 'AU',
-  BELGIUM: 'BE',
-  CANADA: 'CA',
-  FRANCE: 'FR',
-  GERMANY: 'DE',
-  ISRAEL: 'IL',
-  ITALY: 'IT',
-  LUXEMBOURG: 'LU',
-  MALAYSIA: 'MY',
-  MONACO: 'MC',
-  NETHERLANDS: 'NL',
-  POLAND: 'PL',
-  PORTUGAL: 'PT',
-  UNITED_KINGDOM: 'GB',
-  UNITED_STATES: 'US',
-  SPAIN: 'ES',
-  SWITZERLAND: 'CH',
-};

package/src/domain/Device/DebugDevice.ts

@@ -1,44 +0,0 @@
-/* eslint-disable */
-import type { Device } from "./Device";
-export default class DebugDevice implements Device {
-  connectToCall() {
-    console.info('DebugDevice - Connected to call');
-  }
-
-  disconnectFromCall() {
-    console.info('DebugDevice - Disconnected from call');
-  }
-
-  ringback() {
-    console.info('DebugDevice - Ringback');
-  }
-
-  stopRingback() {
-    console.info('DebugDevice - Stop ringback');
-  }
-
-  playRingtone() {
-    console.info('DebugDevice - Play ringtone');
-  }
-
-  stopRingtone() {
-    console.info('DebugDevice - Stop ringtone');
-  }
-
-  mute() {
-    console.info('DebugDevice - Mute');
-  }
-
-  unmute() {
-    console.info('DebugDevice - Unmute');
-  }
-
-  putOnSpeaker() {
-    console.info('DebugDevice - Put on speaker');
-  }
-
-  putOffSpeaker() {
-    console.info('DebugDevice - Put off speaker');
-  }
-
-}

package/src/domain/Device/Device.ts

@@ -1,12 +0,0 @@
-export interface Device {
-  connectToCall(): void;
-  disconnectFromCall(): void;
-  ringback(): void;
-  stopRingback(): void;
-  playRingtone(): void;
-  stopRingtone(): void;
-  mute(): void;
-  unmute(): void;
-  putOnSpeaker(): void;
-  putOffSpeaker(): void;
-}

package/src/domain/DirectorySource.ts

@@ -1,13 +0,0 @@
-import type { UUID } from './types';
-
-export type DirectorySource = {
-  backend: string;
-  name: string;
-  tenant_uuid: UUID;
-  uuid: UUID;
-};
-export type DirectorySources = {
-  filtered: number;
-  total: number;
-  items: DirectorySource[];
-};

package/src/domain/ExternalApp.ts

@@ -1,46 +0,0 @@
-import newFrom from '../utils/new-from';
-
-type Response = {
-  name: string;
-  configuration: Record<string, any>;
-};
-type ListResponse = {
-  items: Response[];
-};
-type Arguments = {
-  name?: string;
-  configuration?: Record<string, any>;
-};
-export default class ExternalApp {
-  name: string | undefined;
-
-  type: string;
-
-  configuration?: Record<string, any>;
-
-  static parse(plain: Response): ExternalApp {
-    return new ExternalApp({
-      name: plain.name,
-      configuration: plain.configuration,
-    });
-  }
-
-  static parseMany(plain: ListResponse): ExternalApp[] {
-    return plain.items.map(item => ExternalApp.parse(item));
-  }
-
-  static newFrom(profile: ExternalApp) {
-    return newFrom(profile, ExternalApp);
-  }
-
-  constructor({
-    name,
-    configuration,
-  }: Arguments = {}) {
-    this.name = name;
-    this.configuration = configuration;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'ExternalApp';
-  }
-
-}

package/src/domain/Features.ts

@@ -1,105 +0,0 @@
-import getApiClient from '../service/getApiClient';
-
-export const FEATURES = ['chat', 'video', 'call_recording', 'fax', 'mobile_double_call', 'mobile_gsm', 'meeting', 'caller_id'];
-export const getScopeName = (featureName: string) => `enterprise.app.${featureName}`;
-const scopesToCheck = FEATURES.map(getScopeName); // Handle available features on the engine.
-
-class Features {
-  _hasChat: boolean;
-
-  _hasVideo: boolean;
-
-  _hasCallRecording: boolean;
-
-  _hasFax: boolean;
-
-  _hasMobileDoubleCall: boolean;
-
-  _hasMobileGsm: boolean;
-
-  _hasMeeting: boolean;
-
-  _hasCallerID: boolean;
-
-  constructor() {
-    this._hasChat = true;
-    this._hasVideo = true;
-    this._hasCallRecording = true;
-    this._hasFax = true;
-    this._hasMobileDoubleCall = true;
-    this._hasMobileGsm = true;
-    this._hasMeeting = true;
-    this._hasCallerID = false;
-  }
-
-  async fetchAccess() {
-    let response;
-
-    try {
-      response = await getApiClient().auth.getRestrictionPolicies(scopesToCheck);
-    } catch (_) { // Noting to do because everything should be available even if the API is not available
-    }
-
-    if (!response) {
-      return;
-    }
-
-    const {
-      scopes,
-    } = response;
-    this._hasChat = this._hasFeatures(scopes, 'chat');
-    this._hasVideo = this._hasFeatures(scopes, 'video');
-    this._hasCallRecording = this._hasFeatures(scopes, 'call_recording');
-    this._hasFax = this._hasFeatures(scopes, 'fax');
-    this._hasMobileDoubleCall = this._hasFeatures(scopes, 'mobile_double_call');
-    this._hasMobileGsm = this._hasFeatures(scopes, 'mobile_gsm');
-    this._hasMeeting = this._hasFeatures(scopes, 'meeting');
-    this._hasCallerID = this._hasFeatures(scopes, 'caller_id');
-  }
-
-  hasChat() {
-    return this._hasChat;
-  }
-
-  hasVideo() {
-    return this._hasVideo;
-  }
-
-  hasCallRecording() {
-    return this._hasCallRecording;
-  }
-
-  hasFax() {
-    return this._hasFax;
-  }
-
-  hasMobileDoubleCall() {
-    return this._hasMobileDoubleCall;
-  }
-
-  hasMobileGsm() {
-    return this._hasMobileGsm;
-  }
-
-  hasMeeting() {
-    return this._hasMeeting;
-  }
-
-  hasCallerID() {
-    return this._hasCallerID;
-  }
-
-  _hasFeatures(scopes: Record<string, any>, featureName: string) {
-    const scopeName = getScopeName(featureName);
-
-    if (!scopes || !(scopeName in scopes)) {
-      // Assume that the feature is available if not present (available by default)
-      return true;
-    }
-
-    return scopes[scopeName] === true;
-  }
-
-}
-
-export default new Features();

package/src/domain/ForwardOption.ts

@@ -1,65 +0,0 @@
-import newFrom from '../utils/new-from';
-
-type Response = {
-  destination: string;
-  enabled: boolean;
-};
-export type ForwardName = 'busy' | 'noanswer' | 'unconditional';
-export const FORWARD_KEYS: {
-  BUSY: 'busy';
-  NO_ANSWER: 'noanswer';
-  UNCONDITIONAL: 'unconditional';
-} = {
-  BUSY: 'busy',
-  NO_ANSWER: 'noanswer',
-  UNCONDITIONAL: 'unconditional',
-};
-type ForwardOptionArguments = {
-  destination?: string;
-  enabled?: boolean;
-  key?: ForwardName;
-};
-export default class ForwardOption {
-  destination: string | undefined;
-
-  enabled: boolean | undefined;
-
-  key: ForwardName | undefined;
-
-  static parse(plain: Response, key: ForwardName): ForwardOption {
-    return new ForwardOption({
-      destination: plain.destination || '',
-      enabled: plain.enabled,
-      key,
-    });
-  }
-
-  static newFrom(profile: ForwardOption) {
-    return newFrom(profile, ForwardOption);
-  }
-
-  constructor({
-    destination,
-    enabled,
-    key,
-  }: ForwardOptionArguments = {}) {
-    this.destination = destination;
-    this.enabled = enabled;
-    this.key = key;
-  }
-
-  setDestination(number: string): ForwardOption {
-    this.destination = number;
-    return this;
-  }
-
-  setEnabled(enabled: boolean): ForwardOption {
-    this.enabled = enabled;
-    return this;
-  }
-
-  is(other: ForwardOption) {
-    return this.key === other.key;
-  }
-
-}

package/src/domain/Incall.ts

@@ -1,50 +0,0 @@
-import newFrom from '../utils/new-from';
-import { ExtensionRelation } from './types';
-
-// Generic based on incall and user's incall payload
-export type GenericIncall = {
-  id: number;
-  extensions: ExtensionRelation[];
-  [key: string]: any;
-};
-
-export type IncallArguments = {
-  id?: number;
-  extensions?: ExtensionRelation[];
-};
-
-export default class Incall {
-  id: number | undefined;
-
-  extensions: ExtensionRelation[] | undefined;
-
-  extension: string | undefined;
-
-  // Useful to compare instead of instanceof with minified code
-  readonly type: string = 'Incall';
-
-  constructor({ id, extensions }: IncallArguments = {}) {
-    this.id = id;
-    this.extensions = extensions;
-    this.extension = extensions?.[0]?.exten;
-  }
-
-  static parse(plain: GenericIncall): Incall {
-    return new Incall({
-      id: plain.id,
-      extensions: plain.extensions,
-    });
-  }
-
-  static newFrom(profile: Incall) {
-    return newFrom(profile, Incall);
-  }
-
-  hasExtension(extension: string) {
-    if (!this.extensions) {
-      return false;
-    }
-
-    return this.extensions.some(ext => ext.exten === extension);
-  }
-}

package/src/domain/IndirectTransfer.ts

@@ -1,73 +0,0 @@
-import CallSession from './CallSession';
-import newFrom from '../utils/new-from';
-import updateFrom from '../utils/update-from';
-
-export type IndirectTransferArguments = {
-  status?: string;
-  id?: string;
-  destinationId: string;
-  sourceId: string;
-};
-type Reponse = {
-  id: string;
-  initiator_uuid: string;
-  transferred_call: string;
-  initiator_call: string;
-  recipient_call: string;
-  status: string;
-  flow: string;
-};
-export default class IndirectTransfer {
-  status: string | null | undefined;
-
-  id: string | null | undefined;
-
-  sourceId: string;
-
-  destinationId: string;
-
-  constructor({
-    sourceId,
-    destinationId,
-    status,
-    id,
-  }: IndirectTransferArguments) {
-    this.sourceId = sourceId;
-    this.destinationId = destinationId;
-    this.status = status;
-    this.id = id;
-  }
-
-  static parseFromCallSession(source: CallSession, destination: CallSession) {
-    return new IndirectTransfer({
-      sourceId: source.getId(),
-      destinationId: destination.getId(),
-    });
-  }
-
-  static parseFromApi(plain: Reponse) {
-    return new IndirectTransfer({
-      id: plain.id,
-      status: plain.status,
-      sourceId: plain.initiator_call,
-      destinationId: plain.recipient_call,
-    });
-  }
-
-  destinationIs(callSession: CallSession): boolean {
-    return callSession.isId(this.destinationId);
-  }
-
-  sourceIs(callSession: CallSession): boolean {
-    return callSession.isId(this.sourceId);
-  }
-
-  updateFrom(indirectTransfer: IndirectTransfer) {
-    updateFrom(this, indirectTransfer);
-  }
-
-  static newFrom(indirectTransfer: IndirectTransfer) {
-    return newFrom(indirectTransfer, IndirectTransfer);
-  }
-
-}

package/src/domain/Line.ts

@@ -1,79 +0,0 @@
-import newFrom from '../utils/new-from';
-import type { ExtensionRelation, Link } from './types';
-
-export type Endpoint = {
-  id: number;
-  links: Link[];
-  username?: string;
-};
-
-export type LineResponse = {
-  endpoint_custom: Endpoint | null | undefined;
-  endpoint_sccp: Endpoint | null | undefined;
-  endpoint_sip: Endpoint | null | undefined;
-  extensions: ExtensionRelation[];
-  id: number;
-};
-
-type LineArguments = {
-  id?: number;
-  extensions?: ExtensionRelation[];
-  endpointCustom?: Endpoint | null;
-  endpointSccp?: Endpoint | null;
-  endpointSip?: Endpoint | null;
-};
-export default class Line {
-  type: string;
-
-  id: number | undefined;
-
-  extensions: ExtensionRelation[] | undefined;
-
-  endpointCustom: Endpoint | null;
-
-  endpointSccp: Endpoint | null;
-
-  endpointSip: Endpoint | null;
-
-  static parse(plain: LineResponse): Line {
-    return new Line({
-      id: plain.id,
-      extensions: plain.extensions,
-      endpointCustom: plain.endpoint_custom || null,
-      endpointSccp: plain.endpoint_sccp || null,
-      endpointSip: plain.endpoint_sip || null,
-    });
-  }
-
-  static newFrom(profile: Line) {
-    return newFrom(profile, Line);
-  }
-
-  is(line: Line | null | undefined) {
-    return line ? this.id === line.id : false;
-  }
-
-  hasExtension(extension: string) {
-    if (!this.extensions) {
-      return false;
-    }
-
-    return this.extensions.some(ext => ext.exten === extension);
-  }
-
-  constructor({
-    id,
-    extensions,
-    endpointCustom,
-    endpointSccp,
-    endpointSip,
-  }: LineArguments = {}) {
-    this.id = id;
-    this.extensions = extensions;
-    this.endpointCustom = endpointCustom || null;
-    this.endpointSccp = endpointSccp || null;
-    this.endpointSip = endpointSip || null;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'Line';
-  }
-}

package/src/domain/Meeting.ts

@@ -1,113 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-import MeetingAuthorization from './MeetingAuthorization';
-
-export type MeetingCreateArguments = {
-  name: string;
-  requireAuthorization: boolean;
-  persistent: boolean;
-};
-export type MeetingUpdateArguments = {
-  name?: string;
-  requireAuthorization?: boolean;
-};
-export type MeetingCreationResponse = {
-  guest_sip_authorization: string;
-  ingress_http_uri: string;
-  name: string;
-  owner_uuids: Array<string>;
-  port: string;
-  uuid: string;
-  exten: string;
-  persistent: boolean;
-  creation_time: string;
-  require_authorization: boolean;
-};
-export default class Meeting {
-  type: string;
-
-  guestSipAuthorization: string;
-
-  uri: string;
-
-  uuid: string;
-
-  name: string;
-
-  port: string;
-
-  extension: string;
-
-  persistent: boolean;
-
-  ownerUuids: Array<string>;
-
-  creationTime: Date;
-
-  pendingAuthorizations: Array<MeetingAuthorization>;
-
-  requireAuthorization: boolean;
-
-  static parse(plain: MeetingCreationResponse): Meeting {
-    return new Meeting({
-      guestSipAuthorization: plain.guest_sip_authorization,
-      uri: plain.ingress_http_uri,
-      name: plain.name,
-      ownerUuids: plain.owner_uuids,
-      port: plain.port,
-      uuid: plain.uuid,
-      extension: plain.exten,
-      persistent: plain.persistent,
-      creationTime: moment(plain.creation_time).toDate(),
-      requireAuthorization: plain.require_authorization,
-    });
-  }
-
-  static parseMany(items: MeetingCreationResponse[]): Array<Meeting> {
-    if (!items) {
-      return [];
-    }
-
-    return items.map(plain => Meeting.parse(plain));
-  }
-
-  static newFrom(meeting: Meeting) {
-    return newFrom(meeting, Meeting);
-  }
-
-  constructor({
-    uuid,
-    name,
-    guestSipAuthorization,
-    ownerUuids,
-    port,
-    uri,
-    extension,
-    persistent,
-    creationTime,
-    requireAuthorization,
-  }: Record<string, any> = {}) {
-    this.guestSipAuthorization = guestSipAuthorization;
-    this.uri = uri;
-    this.name = name;
-    this.ownerUuids = ownerUuids;
-    this.port = port;
-    this.uuid = uuid;
-    this.extension = extension;
-    this.persistent = persistent;
-    this.creationTime = creationTime;
-    this.requireAuthorization = requireAuthorization;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'Meeting';
-  }
-
-  getGuestSipCredentials() {
-    // eslint-disable-next-line no-undef
-    const [username, secret] = Buffer.from(this.guestSipAuthorization, 'base64').toString('ascii').split(':');
-    return {
-      username,
-      secret,
-    };
-  }
-
-}

package/src/domain/MeetingAuthorization.ts

@@ -1,81 +0,0 @@
-export type RawMeetingAuthorization = {
-  created_at: string;
-  meeting_uuid: string;
-  uuid: string;
-  guest_uuid: string;
-  guest_name: string;
-};
-export const PENDING = 'pending';
-export const ACCEPTED = 'accepted';
-export const REJECTED = 'rejected';
-export const POST_PROCESSING = 'post_processing';
-export const POST_PROCESSED_SUCCESS = 'post_processed_success';
-export const POST_PROCESSED_ERROR = 'post_processed_error';
-
-export default class MeetingAuthorization {
-  static PENDING = PENDING;
-
-  static ACCEPTED = ACCEPTED;
-
-  static REJECTED = REJECTED;
-
-  static POST_PROCESSING = POST_PROCESSING;
-
-  static POST_PROCESSED_SUCCESS = POST_PROCESSED_SUCCESS;
-
-  static POST_PROCESSED_ERROR = POST_PROCESSED_ERROR;
-
-  meetingUuid: string;
-
-  uuid: string;
-
-  userUuid: string;
-
-  userName: string;
-
-  status: string;
-
-  constructor({
-    meetingUuid,
-    uuid,
-    userUuid,
-    userName,
-  }: Record<string, any> = {}) {
-    this.meetingUuid = meetingUuid;
-    this.uuid = uuid;
-    this.userUuid = userUuid;
-    this.userName = userName;
-  }
-
-  setStatus(status: string) {
-    this.status = status;
-  }
-
-  getStatus() {
-    return this.status;
-  }
-
-  static parse(plain: RawMeetingAuthorization) {
-    const {
-      meeting_uuid: meetingUuid,
-      uuid,
-      guest_uuid: userUuid,
-      guest_name: userName,
-    } = plain;
-    return new MeetingAuthorization({
-      meetingUuid,
-      uuid,
-      userUuid,
-      userName,
-    });
-  }
-
-  static parseMany(items: RawMeetingAuthorization[]): Array<MeetingAuthorization> {
-    if (!items) {
-      return [];
-    }
-
-    return items.map(MeetingAuthorization.parse);
-  }
-
-}