@wazo/sdk 0.38.22 → 0.39.0-beta.10

package/src/api/chatd.ts

@@ -0,0 +1,101 @@
+import ApiRequester from '../utils/api-requester';
+import type { UUID } from '../domain/types';
+import Profile from '../domain/Profile';
+import ChatRoom from '../domain/ChatRoom';
+import type { ChatUser, ChatMessageListResponse } from '../domain/ChatMessage';
+import ChatMessage from '../domain/ChatMessage';
+
+export type PresenceResponse = {
+  lines: Array<{
+    id: number;
+    state: string;
+  }>;
+  sessions: Array<{
+    mobile: boolean;
+    uuid: string;
+  }>;
+  state: string;
+  status: string;
+  user_uuid: string;
+};
+type PresenceListResponse = {
+  filtered: number;
+  total: number;
+  items: Array<PresenceResponse>;
+};
+type GetMessagesOptions = {
+  direction: string | null | undefined;
+  limit: number | null | undefined;
+  order: string | null | undefined;
+  offset: string | null | undefined;
+  search: string | null | undefined;
+  distinct: string | null | undefined;
+};
+
+export interface ChatD {
+  updateState: (contactUuid: UUID, state: string) => Promise<boolean>;
+  updateStatus: (contactUuid: UUID, state: string, status: string) => Promise<boolean>;
+  getState: (contactUuid: UUID) => Promise<string>;
+  getContactStatusInfo: (contactUuid: UUID) => Promise<PresenceResponse>;
+  getLineState: (contactUuid: UUID) => Promise<string>;
+  getMultipleLineState: (contactUuids: Array<UUID> | null | undefined) => Promise<Array<PresenceResponse>>;
+  getUserRooms: () => Promise<Array<ChatRoom>>;
+  createRoom: (name: string, users: Array<ChatUser>) => Promise<ChatRoom>;
+  getRoomMessages: (roomUuid: string, params?: GetMessagesOptions) => Promise<Array<ChatMessage>>;
+  sendRoomMessage: (roomUuid: string, message: ChatMessage) => Promise<ChatMessage>;
+  getMessages: (options: GetMessagesOptions) => Promise<ChatMessage>;
+}
+
+// split contact status retrieval to avoid `414 Request-URI Too Large`.
+const MAX_PRESENCE_FETCHED = 30;
+
+export default ((client: ApiRequester, baseUrl: string): ChatD => ({
+  updateState: (contactUuid: UUID, state: string): Promise<boolean> => client.put(`${baseUrl}/users/${contactUuid}/presences`, {
+    state,
+  }, null, ApiRequester.successResponseParser),
+  updateStatus: (contactUuid: UUID, state: string, status: string): Promise<boolean> => {
+    const body = {
+      state,
+      status,
+    };
+    return client.put(`${baseUrl}/users/${contactUuid}/presences`, body, null, ApiRequester.successResponseParser);
+  },
+  getState: async (contactUuid: UUID): Promise<string> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => response.state),
+  getContactStatusInfo: async (contactUuid: UUID): Promise<PresenceResponse> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => response),
+  getLineState: async (contactUuid: UUID): Promise<string> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => Profile.getLinesState(response.lines)),
+  async getMultipleLineState(contactUuids: Array<UUID> | null | undefined): Promise<Array<PresenceResponse>> {
+    const body: any = {};
+    const uuids: Array<UUID> = contactUuids || [];
+
+    if (uuids.length > MAX_PRESENCE_FETCHED) {
+      const requests = uuids.reduce((acc, _, i) => {
+        if (i % MAX_PRESENCE_FETCHED === 0) {
+          // @ts-ignore
+          acc.push(this.getMultipleLineState(uuids.slice(i, i + MAX_PRESENCE_FETCHED)));
+        }
+        return acc;
+      }, []);
+
+      const splittedStatuses = await Promise.all(requests);
+
+      return splittedStatuses.flat();
+    }
+
+    if (uuids.length) {
+      body.user_uuid = uuids.join(',');
+    }
+
+    return client.get(`${baseUrl}/users/presences`, body).then((response: PresenceListResponse) => response.items);
+  },
+  getUserRooms: async (): Promise<Array<ChatRoom>> => client.get(`${baseUrl}/users/me/rooms`).then(ChatRoom.parseMany),
+  createRoom: async (name: string, users: Array<ChatUser>): Promise<ChatRoom> => client.post(`${baseUrl}/users/me/rooms`, {
+    name,
+    users,
+  }).then(ChatRoom.parse),
+  getRoomMessages: async (roomUuid: string, params?: GetMessagesOptions): Promise<Array<ChatMessage>> => {
+    const qs = ApiRequester.getQueryString(params || {});
+    return client.get(`${baseUrl}/users/me/rooms/${roomUuid}/messages${qs.length ? `?${qs}` : ''}`).then((response: ChatMessageListResponse) => ChatMessage.parseMany(response));
+  },
+  sendRoomMessage: async (roomUuid: string, message: ChatMessage): Promise<ChatMessage> => client.post(`${baseUrl}/users/me/rooms/${roomUuid}/messages`, message).then(ChatMessage.parse),
+  getMessages: async (options: GetMessagesOptions): Promise<ChatMessage> => client.get(`${baseUrl}/users/me/rooms/messages`, options),
+}));

package/src/api/confd.ts

@@ -0,0 +1,110 @@
+import ApiRequester from '../utils/api-requester';
+import type { UUID, ListConfdUsersResponse, ListApplicationsResponse } from '../domain/types';
+import type { MeetingCreateArguments, MeetingUpdateArguments } from '../domain/Meeting';
+import Profile from '../domain/Profile';
+import SipLine from '../domain/SipLine';
+import ExternalApp from '../domain/ExternalApp';
+import Meeting from '../domain/Meeting';
+import MeetingAuthorization from '../domain/MeetingAuthorization';
+import { convertKeysFromCamelToUnderscore } from '../utils/object';
+
+export interface ConfD {
+  listUsers: () => Promise<ListConfdUsersResponse>;
+  getUser: (userUuid: string) => Promise<Profile>;
+  updateUser: (userUuid: string, profile: Profile) => Promise<boolean>;
+  updateForwardOption: (userUuid: string, key: string, destination: string, enabled: boolean) => Promise<boolean>;
+  updateDoNotDisturb: (userUuid: UUID, enabled: boolean) => Promise<boolean>;
+  getUserLineSip: (userUuid: string, lineId: string) => Promise<SipLine>;
+  getUserLinesSip: (userUuid: string, lineIds: string[]) => Promise<(SipLine | null)[]>;
+  getUserLineSipFromToken: (userUuid: string) => Promise<any>; // @TODO
+  listApplications: () => Promise<ListApplicationsResponse>;
+  getInfos: () => Promise<{
+    uuid: string;
+    wazo_version: string;
+  }>;
+  getExternalApps: (userUuid: string) => Promise<ExternalApp[]>;
+  getExternalApp: (userUuid: string, name: string) => Promise<ExternalApp | null | undefined>;
+  getMyMeetings: () => Promise<Meeting>;
+  createMyMeeting: (args: MeetingCreateArguments) => Promise<Meeting>;
+  updateMyMeeting: (meetingUuid: string, data: MeetingUpdateArguments) => Promise<boolean>;
+  deleteMyMeeting: (meetingUuid: string) => Promise<Meeting>;
+  getMeeting: (meetingUuid: string) => Promise<Meeting>;
+  meetingAuthorizations: (meetingUuid: string) => Promise<Array<MeetingAuthorization>>;
+  meetingAuthorizationReject: (meetingUuid: string, authorizationUuid: string) => Promise<boolean>;
+  meetingAuthorizationAccept: (meetingUuid: string, authorizationUuid: string) => Promise<boolean>;
+  guestGetMeeting: (meetingUuid: string) => Promise<Meeting>;
+  guestAuthorizationRequest: (userUuid: string, meetingUuid: string, username: string) => Promise<any>;
+  guestAuthorizationCheck: (userUuid: string, meetingUuid: string, authorizationUuid: string) => Promise<any>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): ConfD => ({
+  listUsers: (): Promise<ListConfdUsersResponse> => client.get(`${baseUrl}/users`, null),
+  getUser: (userUuid: string): Promise<Profile> => client.get(`${baseUrl}/users/${userUuid}`, null).then(Profile.parse),
+  updateUser: (userUuid: string, profile: Profile): Promise<boolean> => {
+    const body = {
+      firstname: profile.firstName,
+      lastname: profile.lastName,
+      email: profile.email,
+      mobile_phone_number: profile.mobileNumber,
+    };
+    return client.put(`${baseUrl}/users/${userUuid}`, body, null, ApiRequester.successResponseParser);
+  },
+  updateForwardOption: (userUuid: string, key: string, destination: string, enabled: boolean): Promise<boolean> => {
+    const url = `${baseUrl}/users/${userUuid}/forwards/${key}`;
+    return client.put(url, {
+      destination,
+      enabled,
+    }, null, ApiRequester.successResponseParser);
+  },
+  updateDoNotDisturb: (userUuid: UUID, enabled: boolean): Promise<boolean> => client.put(`${baseUrl}/users/${userUuid}/services/dnd`, {
+    enabled,
+  }, null, ApiRequester.successResponseParser),
+  getUserLineSip: (userUuid: string, lineId: string): Promise<SipLine> => client.get(`${baseUrl}/users/${userUuid}/lines/${lineId}/associated/endpoints/sip?view=merged`).then(SipLine.parse),
+
+  getUserLinesSip(userUuid: string, lineIds: string[]): Promise<(SipLine | null)[]> {
+    // We have to catch all exception, unless Promise.all will returns an empty array for 2 lines with a custom one:
+    // The custom line will throw a 404 and break the Promise.all.
+    return Promise.all(lineIds.map(lineId => this.getUserLineSip(userUuid, lineId).catch(() => null)));
+  },
+
+  getUserLineSipFromToken(userUuid: string) {
+    return this.getUser(userUuid).then(user => {
+      if (!user.lines.length) {
+        console.warn(`No sip line for user: ${userUuid}`);
+        return null;
+      }
+
+      const line:any = user.lines[0];
+      return this.getUserLineSip(userUuid, line.uuid || line.id);
+    });
+  },
+
+  listApplications: (): Promise<ListApplicationsResponse> => client.get(`${baseUrl}/applications`, null),
+  getInfos: (): Promise<{
+    uuid: string;
+    wazo_version: string;
+  }> => client.get(`${baseUrl}/infos`, null),
+  getExternalApps: (userUuid: string): Promise<ExternalApp[]> => client.get(`${baseUrl}/users/${userUuid}/external/apps`).then(ExternalApp.parseMany),
+  getExternalApp: async (userUuid: string, name: string): Promise<ExternalApp | null | undefined> => {
+    const url = `${baseUrl}/users/${userUuid}/external/apps/${name}?view=fallback`;
+
+    try {
+      return await client.get(url).then(ExternalApp.parse);
+    } catch (e: any) {
+      return null;
+    }
+  },
+  getMyMeetings: (): Promise<Meeting> => client.get(`${baseUrl}/users/me/meetings`).then((response: any) => Meeting.parseMany(response.items)),
+  createMyMeeting: (args: MeetingCreateArguments): Promise<Meeting> => client.post(`${baseUrl}/users/me/meetings`, convertKeysFromCamelToUnderscore(args)).then(Meeting.parse),
+  updateMyMeeting: (meetingUuid: string, data: MeetingUpdateArguments): Promise<boolean> => client.put(`${baseUrl}/users/me/meetings/${meetingUuid}`, convertKeysFromCamelToUnderscore(data), null, ApiRequester.successResponseParser),
+  deleteMyMeeting: (meetingUuid: string): Promise<Meeting> => client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),
+  getMeeting: (meetingUuid: string): Promise<Meeting> => client.get(`${baseUrl}/meetings/${meetingUuid}`, null).then(Meeting.parse),
+  meetingAuthorizations: (meetingUuid: string): Promise<Array<MeetingAuthorization>> => client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/authorizations`, null).then((response: any) => MeetingAuthorization.parseMany(response.items)),
+  meetingAuthorizationReject: (meetingUuid: string, authorizationUuid: string): Promise<boolean> => client.put(`${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/reject`, {}, null, ApiRequester.successResponseParser),
+  meetingAuthorizationAccept: (meetingUuid: string, authorizationUuid: string): Promise<boolean> => client.put(`${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/accept`, {}, null, ApiRequester.successResponseParser),
+  guestGetMeeting: (meetingUuid: string): Promise<Meeting> => client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}`, null).then(Meeting.parse),
+  guestAuthorizationRequest: (userUuid: string, meetingUuid: string, username: string): Promise<any> => client.post(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations`, {
+    guest_name: username,
+  }).then(MeetingAuthorization.parse),
+  guestAuthorizationCheck: (userUuid: string, meetingUuid: string, authorizationUuid: string): Promise<any> => client.get(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations/${authorizationUuid}`, null),
+}));

package/src/api/ctid-ng.ts

@@ -0,0 +1,152 @@
+/* eslint-disable camelcase */
+
+/* DEPRECATED: USE CALLD INSTEAD CTID-NG */
+import ApiRequester from '../utils/api-requester';
+import type { UUID, RequestError, CTITransfer } from '../domain/types';
+import Relocation from '../domain/Relocation';
+import ChatMessage from '../domain/ChatMessage';
+import Voicemail, { Response } from '../domain/Voicemail';
+import Call, { CallResponse } from '../domain/Call';
+import { TRANSFER_FLOW_BLIND } from '../domain/Phone/CTIPhone';
+
+type CallQuery = {
+  from_mobile: boolean;
+  extension: string;
+  line_id?: number;
+  all_lines?: boolean;
+};
+
+type GetPresenceResponse = {
+  presence: string;
+  user_uuid: string;
+  xivo_uuid: string;
+};
+
+export interface CtidNg {
+  updatePresence: (presence: string) => Promise<boolean>;
+  listMessages: (participantUuid: UUID | null | undefined, limit?: number) => Promise<Array<ChatMessage>>;
+  sendMessage: (alias: string, msg: string, toUserId: string) => Promise<boolean>;
+  makeCall: (extension: string, fromMobile: boolean, lineId: number | null | undefined, allLines: boolean | null | undefined) => Promise<CallResponse>;
+  cancelCall: (callId: number) => Promise<boolean>;
+  listCalls: () => Promise<Array<Call>>;
+  relocateCall: (callId: number, destination: string, lineId: number | null | undefined, contact?: string | null | undefined) => Promise<Relocation>;
+  transferCall: (callId: number, number: string, flow: string) => Promise<RequestError | CTITransfer>;
+  cancelCallTransfer: (transferId: string) => Promise<RequestError | void>;
+  confirmCallTransfer: (transferId: string) => Promise<RequestError | void>;
+  listVoicemails: () => Promise<RequestError | Array<Voicemail>>;
+  deleteVoicemail: (voicemailId: number) => Promise<boolean>;
+  getPresence: (contactUuid: UUID) => Promise<GetPresenceResponse>;
+  getStatus: (lineUuid: UUID) => Promise<string>;
+  fetchSwitchboardHeldCalls: (switchboardUuid: UUID) => Promise<any>;
+  holdSwitchboardCall: (switchboardUuid: UUID, callId: string) => Promise<boolean>;
+  answerSwitchboardHeldCall: (switchboardUuid: UUID, callId: string) => Promise<boolean>;
+  fetchSwitchboardQueuedCalls: (switchboardUuid: UUID) => Promise<boolean>;
+  answerSwitchboardQueuedCall: (switchboardUuid: UUID, callId: string) => Promise<boolean>;
+  sendFax: (extension: string, fax: string, callerId: string | null | undefined) => Promise<any>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): CtidNg => ({
+  updatePresence: (presence: string): Promise<boolean> => client.put(`${baseUrl}/users/me/presences`, {
+    presence,
+  }, null, ApiRequester.successResponseParser),
+  listMessages: (participantUuid: UUID | null | undefined, limit?: number): Promise<Array<ChatMessage>> => {
+    const query: Record<string, any> = {};
+
+    if (participantUuid) {
+      query.participant_user_uuid = participantUuid;
+    }
+
+    if (limit) {
+      query.limit = limit;
+    }
+
+    return client.get(`${baseUrl}/users/me/chats`, query).then(ChatMessage.parseMany);
+  },
+  sendMessage: (alias: string, msg: string, toUserId: string) => {
+    const body = {
+      alias,
+      msg,
+      to: toUserId,
+    };
+    return client.post(`${baseUrl}/users/me/chats`, body, null, ApiRequester.successResponseParser);
+  },
+  makeCall: (extension: string, fromMobile: boolean, lineId: number | null | undefined, allLines: boolean | null | undefined = false) => {
+    const query: CallQuery = {
+      from_mobile: fromMobile,
+      extension,
+    };
+
+    if (lineId) {
+      query.line_id = lineId;
+    }
+
+    if (allLines) {
+      query.all_lines = true;
+    }
+
+    return client.post(`${baseUrl}/users/me/calls`, query);
+  },
+  cancelCall: (callId: number): Promise<boolean> => client.delete(`${baseUrl}/users/me/calls/${callId}`),
+  listCalls: (): Promise<Array<Call>> => client.get(`${baseUrl}/users/me/calls`).then((response: any) => Call.parseMany(response.items)),
+
+  relocateCall(callId: number, destination: string, lineId: number | null | undefined, contact?: string | null | undefined): Promise<Relocation> {
+    const body: Record<string, any> = {
+      completions: ['answer'],
+      destination,
+      initiator_call: callId,
+      auto_answer: true,
+    };
+
+    if (lineId || contact) {
+      body.location = {};
+    }
+
+    if (lineId) {
+      body.location.line_id = lineId;
+    }
+
+    if (contact) {
+      body.location.contact = contact;
+    }
+
+    return client.post(`${baseUrl}/users/me/relocates`, body).then(Relocation.parse);
+  },
+
+  transferCall(callId: number, number: string, flow: string = TRANSFER_FLOW_BLIND): Promise<RequestError | CTITransfer> {
+    const body: Record<string, any> = {
+      exten: number,
+      flow,
+      initiator_call: callId,
+    };
+    return client.post(`${baseUrl}/users/me/transfers`, body);
+  },
+
+  // @TODO: fix response type
+  cancelCallTransfer: (transferId: string): Promise<RequestError | void> => client.delete(`${baseUrl}/users/me/transfers/${transferId}`),
+  // @TODO: fix response type
+  confirmCallTransfer: (transferId: string): Promise<RequestError | void> => client.put(`${baseUrl}/users/me/transfers/${transferId}/complete`),
+  listVoicemails: (): Promise<RequestError | Array<Voicemail>> => client.get(`${baseUrl}/users/me/voicemails`, null).then((response: Response) => Voicemail.parseMany(response)),
+  deleteVoicemail: (voicemailId: number): Promise<boolean> => client.delete(`${baseUrl}/users/me/voicemails/messages/${voicemailId}`, null),
+  getPresence: (contactUuid: UUID): Promise<{
+    presence: string;
+    user_uuid: string;
+    xivo_uuid: string;
+  }> => client.get(`${baseUrl}/users/${contactUuid}/presences`, null),
+  getStatus: (lineUuid: UUID) => client.get(`${baseUrl}/lines/${lineUuid}/presences`, null),
+  fetchSwitchboardHeldCalls: (switchboardUuid: UUID) => client.get(`${baseUrl}/switchboards/${switchboardUuid}/calls/held`, null),
+  holdSwitchboardCall: (switchboardUuid: UUID, callId: string) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/held/${callId}`, null, null, ApiRequester.successResponseParser),
+  answerSwitchboardHeldCall: (switchboardUuid: UUID, callId: string) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/held/${callId}/answer`, null),
+  fetchSwitchboardQueuedCalls: (switchboardUuid: UUID) => client.get(`${baseUrl}/switchboards/${switchboardUuid}/calls/queued`, null),
+  answerSwitchboardQueuedCall: (switchboardUuid: UUID, callId: string) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/queued/${callId}/answer`, null),
+  sendFax: (extension: string, fax: string, callerId: string | null | undefined = null) => {
+    const headers = {
+      'Content-type': 'application/pdf',
+      'X-Auth-Token': client.token,
+    };
+    const params = ApiRequester.getQueryString({
+      extension,
+      caller_id: callerId,
+    });
+    return client.post(`${baseUrl}/users/me/faxes?${params}`, fax, headers);
+  },
+}));

package/src/api/dird.ts

@@ -0,0 +1,146 @@
+import { jsonToGraphQLQuery } from 'json-to-graphql-query/lib/jsonToGraphQLQuery';
+import ApiRequester from '../utils/api-requester';
+import type { UUID } from '../domain/types';
+import Contact from '../domain/Contact';
+import type { NewContact } from '../domain/Contact';
+import type { DirectorySource, DirectorySources } from '../domain/DirectorySource';
+import type { Sources } from '../index';
+
+const getContactPayload = (contact: NewContact | Contact) => ({
+  email: contact.email,
+  // @ts-ignore
+  firstname: contact.firstName ? contact.firstName : '',
+  // @ts-ignore
+  lastname: contact.lastName ? contact.lastName : '',
+  // @ts-ignore
+  number: contact.phoneNumber ? contact.phoneNumber : '',
+  entreprise: contact.entreprise ? contact.entreprise : '',
+  birthday: contact.birthday ? contact.birthday : '',
+  address: contact.address ? contact.address : '',
+  note: contact.note ? contact.note : '',
+});
+
+export interface DirD {
+  search: (context: string, term: string) => Promise<Array<Contact>>;
+  listPersonalContacts: (queryParams?: ContactSearchQueryParams) => Promise<Array<Contact>>;
+  fetchPersonalContact: (contactUuid: string) => Promise<Contact>;
+  addContact: (contact: NewContact) => Promise<Contact>;
+  editContact: (contact: Contact) => Promise<Contact>;
+  importContacts: (csv: string) => Promise<Contact[]>;
+  deleteContact: (contactUuid: UUID) => void,
+  listFavorites: (context: string) => Promise<Array<Contact>>;
+  markAsFavorite: (source: string, sourceId: string) => Promise<boolean>;
+  removeFavorite: (source: string, sourceId: string) => Promise<void>;
+  fetchOffice365Source: (context: string) => Promise<DirectorySources>;
+  fetchOffice365Contacts: (source: DirectorySource, queryParams: ContactSearchQueryParams) => Promise<Contact[]> | null | undefined;
+  fetchWazoSource: (context: string) => Promise<Sources>;
+  fetchWazoContacts: (source: DirectorySource, queryParams: ContactSearchQueryParams) => Promise<Contact[]> | null | undefined;
+  fetchGoogleSource: (context: string) => Promise<Sources>;
+  fetchGoogleContacts: (source: DirectorySource, queryParams: ContactSearchQueryParams) => Promise<Contact[]> | null | undefined;
+  fetchConferenceSource: (context: string) => Promise<Sources>;
+  fetchConferenceContacts: (source: DirectorySource) => Promise<Contact[]> | null | undefined;
+  findMultipleContactsByNumber: (numbers: string[], fields?: Record<string, any>) => Promise<Contact[]>;
+}
+
+type ContactSearchQueryParams = {
+  order?: string;
+  direction?: 'asc' | 'desc';
+  limit?: number;
+  offset?: number;
+  search?: string;
+  uuid?: string;
+} | null;
+export default ((client: ApiRequester, baseUrl: string): DirD => ({
+  search: (context: string, term: string): Promise<Array<Contact>> => client.get(`${baseUrl}/directories/lookup/${context}`, {
+    term,
+  }).then(Contact.parseMany),
+  listPersonalContacts: (queryParams: ContactSearchQueryParams = null): Promise<Array<Contact>> => client.get(`${baseUrl}/personal`, queryParams).then((response: any) => Contact.parseManyPersonal(response.items)),
+  fetchPersonalContact: (contactUuid: string): Promise<Contact> => client.get(`${baseUrl}/personal/${contactUuid}`).then(Contact.parsePersonal),
+  addContact: (contact: NewContact): Promise<Contact> => client.post(`${baseUrl}/personal`, getContactPayload(contact)).then(Contact.parsePersonal),
+  editContact: (contact: Contact): Promise<Contact> => client.put(`${baseUrl}/personal/${contact.sourceId || contact.id || ''}`, getContactPayload(contact)).then(Contact.parsePersonal),
+  importContacts: (csv: string): Promise<Contact[]> => {
+    const headers = {
+      'Content-Type': 'text/csv; charset=utf-8',
+      'X-Auth-Token': client.token,
+    };
+    return client.post(`${baseUrl}/personal/import`, csv, headers).then((result: any) => Contact.parseManyPersonal(result.created));
+  },
+  deleteContact: (contactUuid: UUID) => client.delete(`${baseUrl}/personal/${contactUuid}`),
+  listFavorites: (context: string): Promise<Array<Contact>> => client.get(`${baseUrl}/directories/favorites/${context}`).then(Contact.parseMany),
+  markAsFavorite: (source: string, sourceId: string): Promise<boolean> => {
+    const url = `${baseUrl}/directories/favorites/${source}/${sourceId}`;
+    return client.put(url, null, null, ApiRequester.successResponseParser);
+  },
+  removeFavorite: (source: string, sourceId: string) => client.delete(`${baseUrl}/directories/favorites/${source}/${sourceId}`),
+  fetchOffice365Source: (context: string): Promise<DirectorySources> => client.get(`${baseUrl}/directories/${context}/sources`, {
+    backend: 'office365',
+  }),
+  fetchOffice365Contacts: (source: DirectorySource, queryParams: ContactSearchQueryParams = null): Promise<Contact[]> | null | undefined => {
+    if (!source) {
+      return null;
+    }
+
+    return client.get(`${baseUrl}/backends/office365/sources/${source.uuid}/contacts`, queryParams).then((response: any) => Contact.parseManyOffice365(response.items, source));
+  },
+  fetchWazoSource: (context: string): Promise<Sources> => client.get(`${baseUrl}/directories/${context}/sources`, {
+    backend: 'wazo',
+  }),
+  // Can be used with `queryParams = { uuid: uuid1, uuid2 }` to fetch multiple contacts
+  fetchWazoContacts: (source: DirectorySource, queryParams: ContactSearchQueryParams = null): Promise<Contact[]> | null | undefined => {
+    if (!source) {
+      return null;
+    }
+
+    return client.get(`${baseUrl}/backends/wazo/sources/${source.uuid}/contacts`, queryParams).then((response: any) => Contact.parseManyWazo(response.items, source));
+  },
+  fetchGoogleSource: (context: string): Promise<Sources> => client.get(`${baseUrl}/directories/${context}/sources`, {
+    backend: 'google',
+  }),
+  fetchGoogleContacts: (source: DirectorySource, queryParams: ContactSearchQueryParams = null): Promise<Contact[]> | null | undefined => {
+    if (!source) {
+      return null;
+    }
+
+    return client.get(`${baseUrl}/backends/google/sources/${source.uuid}/contacts`, queryParams).then((response: any) => Contact.parseManyGoogle(response.items, source));
+  },
+  fetchConferenceSource: (context: string): Promise<Sources> => client.get(`${baseUrl}/directories/${context}/sources`, {
+    backend: 'conference',
+  }),
+  fetchConferenceContacts: (source: DirectorySource): Promise<Contact[]> | null | undefined => {
+    if (!source) {
+      return null;
+    }
+
+    return client.get(`${baseUrl}/backends/conference/sources/${source.uuid}/contacts`).then((response: any) => Contact.parseManyConference(response.items, source));
+  },
+  // Graphql
+  findMultipleContactsByNumber: (numbers: string[], fields?: Record<string, any>): Promise<Contact[]> => {
+    const query = jsonToGraphQLQuery({
+      me: {
+        contacts: {
+          __args: {
+            profile: 'default',
+            extens: numbers,
+          },
+          edges: {
+            node: fields || {
+              firstname: true,
+              lastname: true,
+              wazoReverse: true,
+              wazoBackend: true,
+              email: true,
+              wazoSourceEntryId: true,
+              wazoSourceName: true,
+              '... on WazoContact': {
+                userUuid: true,
+              },
+            },
+          },
+        },
+      },
+    });
+    return client.post(`${baseUrl}/graphql`, {
+      query: `{${query}}`,
+    }).then(Contact.manyGraphQlWithNumbersParser(numbers));
+  },
+}));

package/src/api/webhookd.ts

@@ -0,0 +1,30 @@
+import ApiRequester from '../utils/api-requester';
+import Subscription from '../domain/Subscription';
+
+type CreatePayload = {
+  config: {
+    body: string;
+    content_type: string;
+    method: string;
+    url: string;
+    verify_certificate: string;
+  };
+  events: string[];
+  name: string;
+  service: string;
+  tags: Record<string, any>;
+};
+
+export interface WebhookD {
+  getSubscriptions: () => Promise<Subscription[]>;
+  getSubscription: (uuid: string) => Promise<Subscription>;
+  createSubscription: (payload: CreatePayload) => Promise<Subscription>;
+  removeSubscription: (uuid: string) => Promise<Subscription>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): WebhookD => ({
+  getSubscriptions: (): Promise<Subscription[]> => client.get(`${baseUrl}/users/me/subscriptions`).then(Subscription.parseMany),
+  getSubscription: (uuid: string): Promise<Subscription> => client.get(`${baseUrl}/users/me/subscriptions/${uuid}`).then(Subscription.parse),
+  createSubscription: (payload: CreatePayload): Promise<Subscription> => client.post(`${baseUrl}/users/me/subscriptions`, payload),
+  removeSubscription: (uuid: string): Promise<Subscription> => client.delete(`${baseUrl}/users/me/subscriptions/${uuid}`),
+}));