@wazo/sdk 0.43.15 → 0.44.0

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;
-  }
-
-}

package/src/domain/CallSession.ts

@@ -1,401 +0,0 @@
-import { SessionState } from 'sip.js/lib/api/session-state';
-import Call from './Call';
-import newFrom from '../utils/new-from';
-import updateFrom from '../utils/update-from';
-import { WazoSession } from './types';
-
-type CallSessionArguments = {
-  answered: boolean;
-  answerTime?: Date | null | undefined;
-  answeredBySystem: boolean;
-  call: Call | null | undefined;
-  callId: string;
-  callerNumber: string;
-  cameraEnabled: boolean;
-  creationTime?: Date | null | undefined;
-  dialedExtension?: string | null;
-  displayName: string;
-  endTime?: Date | null | undefined;
-  isCaller: boolean;
-  muted: boolean;
-  videoMuted: boolean;
-  videoRemotelyDowngraded?: boolean;
-  number: string;
-  paused: boolean;
-  ringing: boolean;
-  sipCallId: string;
-  sipId?: string;
-  sipStatus?: string;
-  startTime: number;
-  autoAnswer?: boolean;
-  ignored?: boolean;
-  screensharing: boolean;
-  recording: boolean;
-  recordingPaused: boolean;
-  sipSession?: WazoSession;
-  conference: boolean;
-};
-export default class CallSession {
-  call: Call | null | undefined;
-
-  // Wazo's callId, like `1594062407.xxxx`
-  callId: string;
-
-  displayName: string;
-
-  // Used to retrieve the real callee when doing indirect transfer
-  realDisplayName: string;
-
-  updatedNumber: string;
-
-  number: string;
-
-  callerNumber: string;
-
-  creationTime: Date | null | undefined;
-
-  startTime: number; // = creationTime
-
-  answerTime: Date | null | undefined;
-
-  endTime: Date | null | undefined;
-
-  isCaller: boolean;
-
-  answeredBySystem: boolean;
-
-  dialedExtension: string;
-
-  ringing: boolean;
-
-  // Should be computed ?
-  paused: boolean;
-
-  // Asterisk callId, like `7aed6793-4405-466d-873e-92d21c2fef9f`
-  sipCallId: string;
-
-  sipStatus: string | number | null | undefined;
-
-  muted: boolean;
-
-  videoMuted: boolean;
-
-  videoRemotelyDowngraded: boolean | null | undefined;
-
-  cameraEnabled: boolean;
-
-  autoAnswer: boolean;
-
-  ignored: boolean;
-
-  screensharing: boolean;
-
-  type: string;
-
-  recording: boolean;
-
-  recordingPaused: boolean;
-
-  sipSession: WazoSession | undefined;
-
-  conference: boolean;
-
-  constructor({
-    answered,
-    answeredBySystem,
-    isCaller,
-    displayName,
-    callId,
-    muted,
-    videoMuted,
-    number,
-    paused,
-    ringing,
-    startTime,
-    creationTime,
-    endTime,
-    cameraEnabled,
-    dialedExtension,
-    sipCallId,
-    sipStatus,
-    callerNumber,
-    call,
-    autoAnswer,
-    ignored,
-    screensharing,
-    recording,
-    recordingPaused,
-    videoRemotelyDowngraded,
-    sipSession,
-    answerTime,
-    conference,
-  }: CallSessionArguments) {
-    this.callId = callId;
-    this.sipCallId = sipCallId;
-    this.displayName = displayName;
-    this.number = number;
-    this.creationTime = creationTime;
-    this.startTime = startTime;
-    this.endTime = endTime;
-    this.isCaller = isCaller;
-    this.answered = answered;
-    this.answeredBySystem = answeredBySystem;
-    this.ringing = ringing;
-    this.paused = paused;
-    this.muted = muted;
-    this.videoMuted = videoMuted;
-    this.callerNumber = callerNumber;
-    this.cameraEnabled = cameraEnabled;
-    this.dialedExtension = dialedExtension || '';
-    this.call = call;
-    this.sipStatus = sipStatus;
-    this.autoAnswer = autoAnswer || false;
-    this.ignored = ignored || false;
-    this.screensharing = screensharing || false;
-    this.recording = recording || false;
-    this.recordingPaused = recordingPaused || false;
-    this.videoRemotelyDowngraded = videoRemotelyDowngraded;
-    this.sipSession = sipSession;
-    this.answerTime = answerTime || this.answerTime;
-    this.conference = conference;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'CallSession';
-  }
-
-  resume() {
-    this.paused = false;
-  }
-
-  hold() {
-    this.paused = true;
-  }
-
-  mute() {
-    this.muted = true;
-  }
-
-  unmute() {
-    this.muted = false;
-  }
-
-  muteVideo() {
-    this.videoMuted = true;
-  }
-
-  unmuteVideo() {
-    this.videoMuted = false;
-  }
-
-  answer() {
-    this.answerTime = new Date();
-  }
-
-  systemAnswer() {
-    this.answeredBySystem = true;
-  }
-
-  enableCamera() {
-    this.cameraEnabled = true;
-  }
-
-  disableCamera() {
-    this.cameraEnabled = false;
-  }
-
-  ignore() {
-    this.ignored = true;
-  }
-
-  startScreenSharing() {
-    this.screensharing = true;
-  }
-
-  stopScreenSharing() {
-    this.screensharing = false;
-  }
-
-  setIsConference(conference: boolean) {
-    this.conference = conference;
-  }
-
-  isIncoming(): boolean {
-    return !this.isCaller && !this.answered;
-  }
-
-  isOutgoing(): boolean {
-    return this.isCaller && !this.answered;
-  }
-
-  isActive(): boolean {
-    return this.answered || this.isOutgoing();
-  }
-
-  isAnswered(): boolean {
-    return this.answered;
-  }
-
-  isAnsweredBySystem(): boolean {
-    return this.answeredBySystem;
-  }
-
-  isRinging(): boolean {
-    return this.ringing;
-  }
-
-  isOnHold(): boolean {
-    return this.paused;
-  }
-
-  isMuted(): boolean {
-    return this.muted;
-  }
-
-  isVideoMuted(): boolean {
-    return this.videoMuted;
-  }
-
-  isCameraEnabled(): boolean {
-    return this.cameraEnabled;
-  }
-
-  isIgnored(): boolean {
-    return this.ignored;
-  }
-
-  isScreenSharing(): boolean {
-    return this.screensharing;
-  }
-
-  isRecording(): boolean {
-    return this.recording;
-  }
-
-  recordingIsPaused(): boolean {
-    return this.recordingPaused;
-  }
-
-  hasAnInitialInterceptionNumber(): boolean {
-    return this.number.startsWith('*8');
-  }
-
-  isAnInterception(): boolean {
-    return this.dialedExtension.startsWith('*8');
-  }
-
-  isEstablished(): boolean {
-    return this.sipStatus === SessionState.Established;
-  }
-
-  isTerminating(): boolean {
-    return this.sipStatus === SessionState.Terminating;
-  }
-
-  isTerminated(): boolean {
-    return this.sipStatus === SessionState.Terminated;
-  }
-
-  isConference(): boolean {
-    return this.conference;
-  }
-
-  getElapsedTimeInSeconds() {
-    if (!this.startTime) {
-      return 0;
-    }
-
-    return (Date.now() - this.startTime) / 1000;
-  }
-
-  getId() {
-    return this.sipCallId || this.callId;
-  }
-
-  is(callSession: CallSession | null | undefined) {
-    if (!callSession) {
-      return false;
-    }
-
-    return this.isId(callSession.sipCallId) || this.isId(callSession.callId);
-  }
-
-  isId(id: string): boolean {
-    return this.getId() === id || (!!this.sipCallId && this.sipCallId === id) || (!!this.callId && this.callId === id);
-  }
-
-  updateFrom(session: CallSession) {
-    updateFrom(this, session);
-  }
-
-  separateDisplayName(): {
-    firstName: string;
-    lastName: string;
-  } {
-    const names = this.displayName.split(' ');
-    const firstName = names[0];
-    const lastName = names.slice(1).join(' ');
-    return {
-      firstName,
-      lastName,
-    };
-  }
-
-  getTalkingToIds() {
-    return this.call ? this.call.talkingToIds : [];
-  }
-
-  setVideoRemotelyDowngraded(value: boolean) {
-    this.videoRemotelyDowngraded = value;
-  }
-
-  isVideoRemotelyDowngraded() {
-    return this.videoRemotelyDowngraded;
-  }
-
-  static newFrom(callSession: CallSession) {
-    return newFrom(callSession, CallSession);
-  }
-
-  // Retro-compatibility: `answered` was a boolean before. We can reproduce the behaviour with a getter/setter
-  set answered(value: boolean) {
-    this.answerTime = value ? this.answerTime || new Date() : null;
-  }
-
-  get answered(): boolean {
-    return !!this.answerTime;
-  }
-
-  toJSON() {
-    const jsonObj = { ...this,
-    };
-    jsonObj.answered = this.answered;
-    return jsonObj;
-  }
-
-  static parseCall(call: Call): CallSession {
-    return new CallSession({
-      callId: call.id,
-      sipCallId: call.sipCallId,
-      displayName: call.calleeName || call.calleeNumber,
-      number: call.calleeNumber,
-      callerNumber: call.callerNumber,
-      startTime: +call.startingTime,
-      paused: call.isOnHold(),
-      isCaller: call.isCaller,
-      muted: call.muted,
-      videoMuted: false,
-      screensharing: false,
-      recording: call.isRecording(),
-      recordingPaused: false,
-      // @TODO
-      ringing: call.isRinging(),
-      answered: call.isUp(),
-      answeredBySystem: call.isUp() && call.talkingToIds.length === 0,
-      cameraEnabled: call.isVideo,
-      dialedExtension: call.dialedExtension,
-      call,
-      conference: false, // @FIXME?
-
-    });
-  }
-
-}

package/src/domain/CallerID.ts

@@ -1,49 +0,0 @@
-import newFrom from '../utils/new-from';
-
-type Response = {
-  number?: string;
-  type: 'main' | 'associated' | 'anonymous';
-};
-
-type ListResponse = {
-  items: Response[];
-};
-
-type Arguments = {
-  number?: string;
-  type: 'main' | 'associated' | 'anonymous';
-};
-
-export default class CallerID {
-  number?: string;
-
-  idType: 'main' | 'associated' | 'anonymous';
-
-  type: string;
-
-  static parse(plain: Response): CallerID {
-    return new CallerID({
-      number: plain.number,
-      type: plain.type,
-    });
-  }
-
-  static parseMany(plain: ListResponse): CallerID[] {
-    return plain.items.map(item => CallerID.parse(item));
-  }
-
-  static newFrom(profile: CallerID) {
-    return newFrom(profile, CallerID);
-  }
-
-  constructor({
-    type,
-    number,
-  }: Arguments) {
-    this.idType = type;
-    this.number = number;
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'CallerID';
-  }
-
-}