@wazo/sdk 0.38.22 → 0.39.0-beta.1

package/src/domain/{CallLog.js → CallLog.ts}

@@ -1,89 +1,89 @@
-// @flow
 import moment from 'moment';
-
 import newFrom from '../utils/new-from';
-
 import Session from './Session';
 import type { RecordingResponse } from './Recording';
 import Recording from './Recording';
 
 type CallLogResponse = {
-  answer: ?string,
-  answered: boolean,
-  call_direction: string,
-  destination_extension: string,
-  destination_name: ?string,
-  destination_user_uuid: ?string,
-  duration: number,
-  end: ?string,
-  id: number,
-  source_extension: string,
-  source_name: string,
-  source_user_uuid: ?string,
-  recordings: RecordingResponse[],
-  requested_extension: string,
-  requested_name: string,
-  start: string,
+  answer: string | null | undefined;
+  answered: boolean;
+  call_direction: string;
+  destination_extension: string;
+  destination_name: string | null | undefined;
+  destination_user_uuid: string | null | undefined;
+  duration: number;
+  end: string | null | undefined;
+  id: number;
+  source_extension: string;
+  source_name: string;
+  source_user_uuid: string | null | undefined;
+  recordings: RecordingResponse[];
+  requested_extension: string;
+  requested_name: string;
+  start: string;
 };
-
 type Response = {
-  filtered: number,
-  items: Array<CallLogResponse>,
-  total: number,
+  filtered: number;
+  items: Array<CallLogResponse>;
+  total: number;
 };
-
 type CallLogArguments = {
-  answer: ?Date,
-  answered: boolean,
-  newMissedCall?: boolean,
-  callDirection: string,
+  answer: Date | null | undefined;
+  answered: boolean;
+  newMissedCall?: boolean;
+  callDirection: string;
   destination: {
-    extension: string,
-    name: string,
-    uuid: ?string,
-  },
+    extension: string;
+    name: string;
+    uuid: string | null | undefined;
+  };
   source: {
-    extension: string,
-    name: string,
-    uuid: ?string,
-  },
-  id: number,
-  duration: number,
-  start: Date,
-  end: ?Date,
-  recordings: Recording[],
+    extension: string;
+    name: string;
+    uuid: string | null | undefined;
+  };
+  id: number;
+  duration: number;
+  start: Date;
+  end: Date | null | undefined;
+  recordings: Recording[];
 };
-
 export default class CallLog {
   type: string;
 
-  answer: ?Date;
+  answer: Date | null | undefined;
+
   answered: boolean;
+
   newMissedCall: boolean;
+
   callDirection: string;
+
   destination: {
-    extension: string,
-    name: string,
+    extension: string;
+    name: string;
   };
 
   recordings: Recording[];
 
   source: {
-    extension: string,
-    name: string,
+    extension: string;
+    name: string;
   };
 
   id: number;
+
   duration: number;
+
   start: Date;
-  end: ?Date;
 
-  static merge(current: Array<CallLog>, toMerge: Array<CallLog>): Array<?CallLog> {
-    const onlyUnique = (value, index, self) => self.indexOf(value) === index;
+  end: Date | null | undefined;
+
+  static merge(current: Array<CallLog>, toMerge: Array<CallLog>): Array<CallLog | null | undefined> {
+    const onlyUnique = (value: any, index: any, self: any) => 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));
   }
 
@@ -103,9 +103,7 @@ export default class CallLog {
       destination: {
         // @TEMP: Temporarily assuming empty numbers are meetings
         // which is admittedly a very dangerous assumption. Did i mention it was temporary?
-        extension: plain.requested_extension
-          || plain.destination_extension
-          || `meeting-${plain.requested_name || plain.destination_name || ''}`,
+        extension: plain.requested_extension || plain.destination_extension || `meeting-${plain.requested_name || plain.destination_name || ''}`,
         name: plain.requested_name || plain.destination_name || '',
         uuid: plain.destination_user_uuid,
       },
@@ -115,7 +113,8 @@ export default class CallLog {
         uuid: plain.source_user_uuid,
       },
       id: plain.id,
-      duration: (plain.duration || 0) * 1000, // duration is in seconds
+      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 || []),
@@ -125,8 +124,7 @@ export default class CallLog {
   static parseNew(plain: CallLogResponse, session: Session): CallLog {
     const callLog: CallLog = CallLog.parse(plain);
     // @TODO: FIXME add verification declined vs missed call
-    callLog.newMissedCall = session
-      && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered;
+    callLog.newMissedCall = session && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered;
     return callLog;
   }
 
@@ -145,7 +143,7 @@ export default class CallLog {
     start,
     end,
     recordings,
-  }: CallLogArguments = {}) {
+  }: CallLogArguments) {
     this.answer = answer;
     this.answered = answered;
     this.callDirection = callDirection;
@@ -156,7 +154,6 @@ export default class CallLog {
     this.start = start;
     this.end = end;
     this.recordings = recordings || [];
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'CallLog';
   }
@@ -165,7 +162,10 @@ export default class CallLog {
     return this.theOtherParty(session).extension === other.theOtherParty(session).extension;
   }
 
-  theOtherParty(session: Session): { extension: string, name: string } {
+  theOtherParty(session: Session): {
+    extension: string;
+    name: string;
+  } {
     if (this.callDirection === 'inbound') {
       return this.source;
     }
@@ -183,7 +183,6 @@ export default class CallLog {
 
   acknowledgeCall(): CallLog {
     this.newMissedCall = false;
-
     return this;
   }
 
@@ -216,7 +215,6 @@ export default class CallLog {
       CallLog.isAnOutgoingcall(session) method is obsolete.
       Please use CallLog.isOutgoing(session).
     `);
-
     return session.hasExtension(this.source.extension) && this.answered;
   }
 
@@ -229,7 +227,6 @@ export default class CallLog {
       CallLog.isAnIncomingCall(session) method is obsolete.
       Please use CallLog.isIncoming(session).
     `);
-
     return session.hasExtension(this.destination.extension) && this.answered;
   }
 
@@ -240,4 +237,5 @@ export default class CallLog {
   getRecordings() {
     return this.recordings;
   }
+
 }

package/src/domain/{CallSession.js → CallSession.ts}

@@ -1,45 +1,43 @@
-// @flow
 import { SessionState } from 'sip.js/lib/api/session-state';
-import type { Session } from 'sip.js/lib/api/session';
-
+import type { Invitation } from 'sip.js/lib/api';
+import { Inviter } from 'sip.js/lib/api';
 import Call from './Call';
 import newFrom from '../utils/new-from';
 import updateFrom from '../utils/update-from';
 
 type CallSessionArguments = {
-  answered: boolean,
-  answerTime?: ?Date,
-  answeredBySystem: boolean,
-  call: ?Call,
-  callId: string,
-  callerNumber: string,
-  cameraEnabled: boolean,
-  creationTime?: ?Date,
-  dialedExtension?: string | null,
-  displayName: string,
-  endTime?: ?Date,
-  isCaller: boolean,
-  muted: boolean,
-  videoMuted: boolean,
-  videoRemotelyDowngraded?: boolean,
-  number: string,
-  paused: boolean,
-  ringing: boolean,
-  sipCallId: string,
-  sipId?: string,
-  sipStatus?: number,
-  startTime: number,
-  autoAnswer?: boolean,
-  ignored?: boolean,
-  screensharing: boolean,
-  recording: boolean,
-  recordingPaused: boolean,
-  sipSession?: Session,
-  conference: boolean,
+  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?: Inviter | Invitation;
+  conference: boolean;
 };
-
 export default class CallSession {
-  call: ?Call;
+  call: Call | null | undefined;
 
   // Wazo's callId, like `1594062407.xxxx`
   callId: string;
@@ -55,13 +53,13 @@ export default class CallSession {
 
   callerNumber: string;
 
-  creationTime: ?Date;
+  creationTime: Date | null | undefined;
 
   startTime: number; // = creationTime
 
-  answerTime: ?Date;
+  answerTime: Date | null | undefined;
 
-  endTime: ?Date;
+  endTime: Date | null | undefined;
 
   isCaller: boolean;
 
@@ -77,13 +75,13 @@ export default class CallSession {
   // Asterisk callId, like `7aed6793-4405-466d-873e-92d21c2fef9f`
   sipCallId: string;
 
-  sipStatus: ?number;
+  sipStatus: string | number | null | undefined;
 
   muted: boolean;
 
   videoMuted: boolean;
 
-  videoRemotelyDowngraded: ?boolean;
+  videoRemotelyDowngraded: boolean | null | undefined;
 
   cameraEnabled: boolean;
 
@@ -99,7 +97,7 @@ export default class CallSession {
 
   recordingPaused: boolean;
 
-  sipSession: Session;
+  sipSession: Inviter | Invitation | undefined;
 
   conference: boolean;
 
@@ -161,7 +159,6 @@ export default class CallSession {
     this.sipSession = sipSession;
     this.answerTime = answerTime || this.answerTime;
     this.conference = conference;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'CallSession';
   }
@@ -306,6 +303,7 @@ export default class CallSession {
     if (!this.startTime) {
       return 0;
     }
+
     return (Date.now() - this.startTime) / 1000;
   }
 
@@ -313,7 +311,7 @@ export default class CallSession {
     return this.sipCallId || this.callId;
   }
 
-  is(callSession: ?CallSession) {
+  is(callSession: CallSession | null | undefined) {
     if (!callSession) {
       return false;
     }
@@ -322,21 +320,24 @@ export default class CallSession {
   }
 
   isId(id: string): boolean {
-    return (
-      this.getId() === id || (this.sipCallId && this.sipCallId === id) || (Boolean(this.callId) && this.callId === id)
-    );
+    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 } {
+  separateDisplayName(): {
+    firstName: string;
+    lastName: string;
+  } {
     const names = this.displayName.split(' ');
     const firstName = names[0];
     const lastName = names.slice(1).join(' ');
-
-    return { firstName, lastName };
+    return {
+      firstName,
+      lastName,
+    };
   }
 
   getTalkingToIds() {
@@ -365,10 +366,9 @@ export default class CallSession {
   }
 
   toJSON() {
-    const jsonObj = { ...this };
-    // $FlowFixMe
+    const jsonObj = { ...this,
+    };
     jsonObj.answered = this.answered;
-
     return jsonObj;
   }
 
@@ -386,7 +386,8 @@ export default class CallSession {
       videoMuted: false,
       screensharing: false,
       recording: call.isRecording(),
-      recordingPaused: false, // @TODO
+      recordingPaused: false,
+      // @TODO
       ringing: call.isRinging(),
       answered: call.isUp(),
       answeredBySystem: call.isUp() && call.talkingToIds.length === 0,
@@ -394,6 +395,8 @@ export default class CallSession {
       dialedExtension: call.dialedExtension,
       call,
       conference: false, // @FIXME?
+
     });
   }
+
 }

package/src/domain/{ChatMessage.js → ChatMessage.ts}

@@ -1,44 +1,48 @@
-// @flow
 import moment from 'moment';
-
 import newFrom from '../utils/new-from';
 
 export type ChatUser = {
-  tenant_uuid: string,
-  uuid: string,
-  wazo_uuid: string,
+  tenant_uuid: string;
+  uuid: string;
+  wazo_uuid: string;
 };
 
 export type ChatMessageResponseRoom = {
-  uuid: ?string,
+  uuid: string | null | undefined;
 };
 
 export type ChatMessageResponse = {
-  alias: string,
-  content: string,
-  created_at: string,
-  tenant_uuid: string,
-  user_uuid: string,
-  uuid: string,
-  wazo_uuid: string,
-  room: ?ChatMessageResponseRoom,
+  alias: string;
+  content: string;
+  created_at: string;
+  tenant_uuid: string;
+  user_uuid: string;
+  uuid: string;
+  wazo_uuid: string;
+  room: ChatMessageResponseRoom | null | undefined;
 };
 
 export type ChatMessageListResponse = {
-  filtered: number,
-  total: number,
-  items: Array<ChatMessageResponse>,
+  filtered: number;
+  total: number;
+  items: Array<ChatMessageResponse>;
 };
 
 export default class ChatMessage {
   type: string;
 
   uuid: string;
+
   content: string;
+
   date: Date;
+
   alias: string;
+
   userUuid: string;
-  roomUuid: ?string;
+
+  roomUuid: string | null | undefined;
+
   read: boolean;
 
   static parseMany(plain: ChatMessageListResponse): Array<ChatMessage> {
@@ -65,17 +69,23 @@ export default class ChatMessage {
     return newFrom(message, ChatMessage);
   }
 
-  constructor({ uuid, date, content, userUuid, alias, roomUuid, read }: Object = {}) {
+  constructor({
+    uuid,
+    date,
+    content,
+    userUuid,
+    alias,
+    roomUuid,
+    read,
+  }: Record<string, any> = {}) {
     this.uuid = uuid;
     this.date = date;
     this.content = content;
     this.userUuid = userUuid;
     this.alias = alias;
     this.roomUuid = roomUuid;
-
     // @TODO: change after message read status available
     this.read = read;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'ChatMessage';
   }
@@ -93,4 +103,5 @@ export default class ChatMessage {
     this.read = true;
     return this;
   }
+
 }

package/src/domain/{ChatRoom.js → ChatRoom.ts}

@@ -1,30 +1,30 @@
-// @flow
 import type { ChatUser } from './ChatMessage';
 import newFrom from '../utils/new-from';
 
 export type RoomResponse = {
-  name: string,
-  uuid: string,
-  users: Array<ChatUser>,
+  name: string;
+  uuid: string;
+  users: Array<ChatUser>;
 };
-
 export type RootListResponse = {
-  filtered: number,
-  total: number,
-  items: Array<RoomResponse>,
+  filtered: number;
+  total: number;
+  items: Array<RoomResponse>;
 };
-
 export default class ChatRoom {
   type: string;
 
   uuid: string;
+
   name: string;
+
   users: Array<ChatUser>;
 
   static parseMany(plain: RootListResponse): Array<ChatRoom> {
     if (!plain || !plain.items) {
       return [];
     }
+
     return plain.items.map(item => ChatRoom.parse(item));
   }
 
@@ -40,12 +40,16 @@ export default class ChatRoom {
     return newFrom(room, ChatRoom);
   }
 
-  constructor({ uuid, name, users }: Object = {}) {
+  constructor({
+    uuid,
+    name,
+    users,
+  }: Record<string, any> = {}) {
     this.uuid = uuid;
     this.name = name;
     this.users = users;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'ChatRoom';
   }
+
 }