@wazo/sdk 0.43.14 → 0.44.0

package/src/domain/Agent.ts

@@ -1,68 +0,0 @@
-export type AgentResponse = {
-  context: string;
-  extension: string;
-  id: number;
-  logged: boolean;
-  number: string;
-  paused: boolean;
-  paused_reason: string;
-};
-
-export type AgentArguments = {
-  context: string;
-  extension: string;
-  id: number;
-  logged: boolean;
-  number: string;
-  paused: boolean;
-  pausedReason: string;
-};
-
-class Agent {
-  context: string;
-
-  extension: string;
-
-  id: number;
-
-  logged: boolean;
-
-  number: string;
-
-  paused: boolean;
-
-  pausedReason: string;
-
-  static parse(plain: AgentResponse): Agent {
-    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,
-  }: AgentArguments) {
-    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/src/domain/BadResponse.ts

@@ -1,29 +0,0 @@
-export default class BadResponse extends Error {
-  static fromResponse(error: Record<string, any>, status: number) {
-    return new BadResponse(error.message || JSON.stringify(error), status, error.timestamp, error.error_id, error.details, error);
-  }
-
-  static fromText(response: string, status: number) {
-    return new BadResponse(response, status);
-  }
-
-  status: number;
-
-  timestamp: number | null | undefined;
-
-  errorId: string | null | undefined;
-
-  details: Record<string, any> | null | undefined;
-
-  error: Record<string, any> | Error | null | undefined;
-
-  constructor(message: string, status: number, timestamp: number | null | undefined = null, errorId: string | null | undefined = null, details: Record<string, any> | null | undefined = null, error: Record<string, any> | Error | null | undefined = null) {
-    super(message);
-    this.timestamp = timestamp;
-    this.status = status;
-    this.errorId = errorId;
-    this.details = details;
-    this.error = error;
-  }
-
-}

package/src/domain/Call.ts

@@ -1,217 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-
-const RECORD_STATE_ACTIVE = 'active';
-export type CallResponse = {
-  call_id: string;
-  sip_call_id: string;
-  caller_id_name: string;
-  caller_id_number: string;
-  peer_caller_id_name: string;
-  peer_caller_id_number: string;
-  dialed_extension: string;
-  status: string;
-  is_caller: boolean;
-  is_video?: boolean;
-  line_id: number | null | undefined;
-  creation_time: string;
-  on_hold: boolean;
-  muted: boolean;
-  talking_to: Record<string, any>;
-  record_state: string;
-};
-type CallArguments = {
-  id: string;
-  sipCallId: string;
-  isCaller: boolean;
-  isVideo?: boolean;
-  callerName: string;
-  callerNumber: string;
-  calleeName: string;
-  calleeNumber: string;
-  dialedExtension: string;
-  lineId: number | null | undefined;
-  onHold: boolean;
-  muted: boolean;
-  status: string;
-  startingTime: Date;
-  talkingToIds: string[];
-  recording: boolean;
-};
-export default class Call {
-  type: string;
-
-  id: string;
-
-  sipCallId: string;
-
-  callerName: string;
-
-  callerNumber: string;
-
-  calleeName: string;
-
-  calleeNumber: string;
-
-  dialedExtension: string;
-
-  lineId: number | null | undefined;
-
-  isCaller: boolean;
-
-  isVideo: boolean;
-
-  onHold: boolean;
-
-  muted: boolean;
-
-  status: string;
-
-  startingTime: Date;
-
-  talkingToIds: string[];
-
-  recording: boolean;
-
-  static parseMany(plain: Array<CallResponse>): Array<Call> {
-    if (!plain) {
-      return [];
-    }
-
-    return plain.map((plainCall: CallResponse) => Call.parse(plainCall));
-  }
-
-  static parse(plain: CallResponse): Call {
-    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: Call) {
-    return newFrom(call, Call);
-  }
-
-  constructor({
-    id,
-    sipCallId,
-    callerName,
-    callerNumber,
-    calleeName,
-    calleeNumber,
-    dialedExtension,
-    isCaller,
-    isVideo,
-    lineId,
-    muted,
-    onHold,
-    status,
-    startingTime,
-    talkingToIds,
-    recording,
-  }: CallArguments) {
-    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(): number {
-    const now = Date.now();
-    return (now - +this.startingTime) / 1000;
-  }
-
-  separateCalleeName(): {
-    firstName: string;
-    lastName: string;
-  } {
-    const names = this.calleeName.split(' ');
-    const firstName = names[0];
-    const lastName = names.slice(1).join(' ');
-    return {
-      firstName,
-      lastName,
-    };
-  }
-
-  is(other: Call | null | undefined): boolean {
-    return !!other && this.id === other.id;
-  }
-
-  hasACalleeName(): boolean {
-    return this.calleeName.length > 0;
-  }
-
-  hasNumber(number: string): boolean {
-    return this.calleeNumber === number;
-  }
-
-  isUp(): boolean {
-    return this.status === 'Up';
-  }
-
-  isDown(): boolean {
-    return this.status === 'Down';
-  }
-
-  isRinging(): boolean {
-    return this.isRingingIncoming() || this.isRingingOutgoing();
-  }
-
-  isRingingIncoming(): boolean {
-    return this.status === 'Ringing';
-  }
-
-  isRingingOutgoing(): boolean {
-    return this.status === 'Ring';
-  }
-
-  isFromTransfer(): boolean {
-    return this.status === 'Down' || this.status === 'Ringing';
-  }
-
-  isOnHold(): boolean {
-    return this.onHold;
-  }
-
-  putOnHold(): void {
-    this.onHold = true;
-  }
-
-  resume(): void {
-    this.onHold = false;
-  }
-
-  isRecording(): boolean {
-    return this.recording;
-  }
-
-}

package/src/domain/CallLog.ts

@@ -1,265 +0,0 @@
-import moment from 'moment';
-import newFrom from '../utils/new-from';
-import Session from './Session';
-import type { RecordingResponse } from './Recording';
-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 type CallLogResponse = {
-  answer: string | null | undefined;
-  answered: boolean;
-  call_direction: string;
-  destination_extension: string;
-  destination_name: string;
-  destination_user_uuid: string | null;
-  duration: number;
-  end: string | null | undefined;
-  id: number;
-  source_extension: string;
-  source_name: string;
-  source_user_uuid: string | null;
-  recordings: RecordingResponse[];
-  requested_extension: string;
-  requested_name: string;
-  requested_user_uuid: string | null;
-  start: string;
-};
-
-export type Response = {
-  filtered: number;
-  items: Array<CallLogResponse>;
-  total: number;
-};
-
-type LogOrigin = {
-  extension: string;
-  name: string;
-  uuid?: string | null;
-};
-
-type DestinationLogOrigin = LogOrigin & {
-  plainExtension: string;
-  plainName: string | null;
-};
-
-type CallLogArguments = {
-  answer: Date | null | undefined;
-  answered: boolean;
-  newMissedCall?: boolean;
-  callDirection: string;
-  destination: DestinationLogOrigin;
-  requested: LogOrigin;
-  source: LogOrigin;
-  id: number;
-  duration: number;
-  start: Date;
-  end: Date | null | undefined;
-  recordings: Recording[];
-};
-
-export default class CallLog {
-  type: string;
-
-  answer: Date | null | undefined;
-
-  answered: boolean;
-
-  newMissedCall: boolean;
-
-  callDirection: string;
-
-  destination: DestinationLogOrigin;
-
-  requested: LogOrigin;
-
-  recordings: Recording[];
-
-  source: LogOrigin;
-
-  id: number;
-
-  duration: number;
-
-  start: Date;
-
-  end: Date | null | undefined;
-
-  static merge(current: Array<CallLog>, toMerge: Array<CallLog>): Array<CallLog | null | undefined> {
-    const onlyUnique = (value: number, index: number, self: number[]) => self.indexOf(value) === index;
-
-    const allLogs: Array<CallLog> = current.concat(toMerge);
-    const onlyUniqueIds: Array<number> = allLogs.map(c => c.id).filter(onlyUnique);
-    return onlyUniqueIds.map(id => allLogs.find(log => log && log.id === id));
-  }
-
-  static parseMany(plain: Response): Array<CallLog> {
-    if (!plain || !plain.items) {
-      return [];
-    }
-
-    return plain.items.map(item => CallLog.parse(item));
-  }
-
-  static parse(plain: CallLogResponse): CallLog {
-    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: CallLogResponse, session: Session): CallLog {
-    const callLog: CallLog = CallLog.parse(plain);
-    callLog.newMissedCall = session && plain.destination_user_uuid === session.uuid && !plain.answered;
-    return callLog;
-  }
-
-  static newFrom(profile: CallLog) {
-    return newFrom(profile, CallLog);
-  }
-
-  constructor({
-    answer,
-    answered,
-    callDirection,
-    destination,
-    requested,
-    source,
-    id,
-    duration,
-    start,
-    end,
-    recordings,
-  }: CallLogArguments) {
-    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: CallLog, session: Session): boolean {
-    return this.theOtherParty(session).extension === other.theOtherParty(session).extension;
-  }
-
-  theOtherParty(session: Session): LogOrigin {
-    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(): boolean {
-    return this.newMissedCall;
-  }
-
-  acknowledgeCall(): CallLog {
-    this.newMissedCall = false;
-    return this;
-  }
-
-  isAcknowledged(): boolean {
-    return this.newMissedCall;
-  }
-
-  isAnswered(): boolean {
-    return this.answered;
-  }
-
-  isOutgoing(session: Session): boolean {
-    if (this.callDirection === 'internal') {
-      return session.hasExtension(this.source.extension);
-    }
-
-    return this.callDirection === 'outbound';
-  }
-
-  isIncoming(session: Session): boolean {
-    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: Session): boolean {
-    if (!session.hasEngineVersionGte(CALL_LOG_VALID_REQUESTED_VERSION) || !this.isIncoming(session)) {
-      return false;
-    }
-
-    return this.requested.extension !== this.destination.plainExtension;
-  }
-
-  isAnOutgoingCall(session: Session): boolean {
-    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: Session): boolean {
-    return session.hasExtension(this.source.extension) && !this.answered;
-  }
-
-  isAnIncomingCall(session: Session): boolean {
-    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: Session): boolean {
-    return !this.answered && session.hasExtension(this.destination.extension);
-  }
-
-  getRecordings() {
-    return this.recordings;
-  }
-
-}