react-native-altibbi 0.2.0 → 0.4.0

package/src/connection.ts

@@ -1,9 +1,17 @@
 import { TBIConstants } from './service';
 import type {
+  Article,
   ConsultationType,
   MediaType,
+  PredictSpecialty,
+  PredictSummary,
   ResponseType,
+  Soap,
+  Transcription,
   UserType,
+  ChatType,
+  ChatResponse,
+  ChatMessage,
 } from './types';
 
 interface MethodsObject {
@@ -18,7 +26,8 @@ interface ConsultationObject {
   medium: string;
   user_id: number;
   mediaIds?: string[];
-  parent_consultation_id?: number;
+  parent_consultation_id?: number | null;
+  forceWhiteLabelingPartnerName?: string | null;
 }
 
 interface RequestParamsInterface {
@@ -29,6 +38,7 @@ interface RequestParamsInterface {
   type?: string;
   fileName?: string;
   download?: boolean;
+  isSinaAPI?: boolean;
 }
 
 interface RequestInterface {
@@ -68,8 +78,12 @@ export const request = async ({
   type,
   fileName,
   download,
+  isSinaAPI,
 }: RequestParamsInterface) => {
-  if (!TBIConstants.baseURL) {
+  if (
+    !TBIConstants.baseURL ||
+    (isSinaAPI && !(TBIConstants.sinaModelEndPoint?.length > 0))
+  ) {
     return {
       message: 'Add your baseURL to Init',
     };
@@ -77,12 +91,23 @@ export const request = async ({
 
   const headers = {
     'Content-Type': 'application/json',
-    'Authorization': `Bearer ${TBIConstants.token}`,
+    'Authorization': `Bearer ${isSinaAPI ? '' : TBIConstants.token}`,
     'accept-language': TBIConstants.language,
   };
 
-  let url = `${TBIConstants.baseURL}/v1/${endPoint}`;
+  let url = endPoint.includes('rest-api')
+    ? endPoint
+    : isSinaAPI
+    ? `${TBIConstants.sinaModelEndPoint}/${endPoint}`
+    : `${TBIConstants.baseURL}/v1/${endPoint}`;
   let body;
+  if (isSinaAPI) {
+    if (!data) {
+      data = {};
+    }
+    data.partner = TBIConstants.baseURL;
+    data.partnerUser = TBIConstants.token;
+  }
   if (method === Methods.get) {
     url = url + '?' + new URLSearchParams(data).toString();
   } else if (path) {
@@ -197,13 +222,13 @@ export const createConsultation = async ({
   medium,
   user_id,
   mediaIds,
-  parent_consultation_id,
+  parent_consultation_id = null,
+  forceWhiteLabelingPartnerName = null,
 }: ConsultationObject): Promise<ResponseType<ConsultationType>> => {
   if (!question || !medium || !user_id) {
     throw Error('missing field');
   }
-
-  const data = {
+  let data = {
     question,
     medium,
     user_id,
@@ -213,6 +238,12 @@ export const createConsultation = async ({
       'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
     parent_consultation_id,
   };
+  if (
+    forceWhiteLabelingPartnerName &&
+    forceWhiteLabelingPartnerName?.length > 3
+  ) {
+    data.question = `${data.question} ~${forceWhiteLabelingPartnerName}~`;
+  }
   const response: ResponseType<ConsultationType> = await request({
     method: Methods.post,
     data,
@@ -379,8 +410,163 @@ export const rateConsultation = async (
     data: { score },
     endPoint: `consultations/${consultation_id}/rate`,
   });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+export const getPredictSummary = async (
+  consultation_id: number
+): Promise<ResponseType<PredictSummary>> => {
+  const response: ResponseType<PredictSummary> = await request({
+    method: Methods.get,
+    data: {},
+    endPoint: `consultations/${consultation_id}/predict-summary`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const getSoapSummary = async (
+  consultation_id: number
+): Promise<ResponseType<Soap>> => {
+  const response: ResponseType<Soap> = await request({
+    method: Methods.get,
+    data: {},
+    endPoint: `consultations/${consultation_id}/soap-summary`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+export const getTranscription = async (
+  consultation_id: number
+): Promise<ResponseType<Transcription>> => {
+  const response: ResponseType<Transcription> = await request({
+    method: Methods.get,
+    data: {},
+    endPoint: `consultations/${consultation_id}/transcription`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+export const getPredictSpecialty = async (
+  consultation_id: number
+): Promise<ResponseType<PredictSpecialty[]>> => {
+  const response: ResponseType<PredictSpecialty[]> = await request({
+    method: Methods.get,
+    data: {},
+    endPoint: `consultations/${consultation_id}/predict-specialty`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const getMediaList = async (
+  page: number = 1,
+  perPage = 20
+): Promise<ResponseType<ConsultationType[]>> => {
+  const response = await request({
+    method: Methods.get,
+    data: {
+      page,
+      'sort': '-id',
+      'per-page': perPage,
+    },
+    endPoint: `media`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const deleteMedia = async (
+  mediaId: string
+): Promise<ResponseType<string>> => {
+  const response: ResponseType<string> = await request({
+    method: Methods.delete,
+    data: {},
+    endPoint: `media/${mediaId}`,
+  });
   if (response.status === 204) {
     return response;
   }
   throw Error(JSON.stringify(response));
 };
+
+export const getArticlesList = async (
+  subcategoryIds: string[]
+): Promise<ResponseType<Article[]>> => {
+  const response: ResponseType<Article[]> = await request({
+    method: Methods.get,
+    data: {
+      'filter[sub_category_id][in]': subcategoryIds.join(','),
+      'sort': '-article_id',
+    },
+    endPoint: `https://rest-api.altibbi.com/active/v1/articles`,
+  });
+  if (response.status === 204) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const createChat = async (): Promise<ResponseType<ChatType>> => {
+  const response: ResponseType<ChatType> = await request({
+    method: Methods.post,
+    endPoint: `chats`,
+    isSinaAPI: true,
+  });
+  if (response.status === 201) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const sendSinaMessage = async (
+  text: String,
+  sessionId: String
+): Promise<ResponseType<ChatResponse>> => {
+  const response: ResponseType<ChatResponse> = await request({
+    method: Methods.post,
+    endPoint: `chats/${sessionId}/messages`,
+    isSinaAPI: true,
+    data: {
+      text,
+    },
+  });
+  if (response.status === 201) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const getSinaChatMessages = async (
+  sessionId: string,
+  page: number = 1,
+  perPage = 20
+): Promise<ResponseType<ChatMessage[]>> => {
+  const response = await request({
+    isSinaAPI: true,
+    method: Methods.get,
+    data: {
+      sessionId,
+      page,
+      'sort': '-id',
+      'per-page': perPage,
+    },
+    endPoint: `chats/${sessionId}/messages`,
+  });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};

package/src/index.tsx

@@ -54,6 +54,11 @@ export {
   cancelConsultation,
   getPrescription,
   rateConsultation,
+  getMediaList,
+  deleteMedia,
+  createChat,
+  sendSinaMessage,
+  getSinaChatMessages,
 } from './connection';
 
 export { TBIConstants, init } from './service';
@@ -92,6 +97,9 @@ export type {
   RecommendationDoctorReferral,
   RecommendationPostCallAnswer,
   ConsultationType,
+  ChatType,
+  ChatResponse,
+  ChatMessage,
 } from './types';
 export {
   materialStatusArray,

package/src/service.ts

@@ -2,18 +2,21 @@ interface ConstantObject {
   token: string;
   baseURL: string;
   language: string;
+  sinaModelEndPoint: string;
 }
 
 export let TBIConstants: ConstantObject = {
   token: '',
   baseURL: '',
   language: 'ar',
+  sinaModelEndPoint: '',
 };
 
-export const init = (token: string, baseURL: string, language: string) => {
+export const init = (token: string, baseURL: string, language: string, sinaModelEndPoint: string = "") => {
   TBIConstants = {
     token,
     baseURL,
     language,
+    sinaModelEndPoint,
   };
 };

package/src/types.ts

@@ -80,8 +80,8 @@ interface VoipConfig {
   api_key?: string;
   call_id?: string;
   token?: string;
-  created_at?: string
-  updated_at?: string
+  created_at?: string;
+  updated_at?: string;
 }
 interface Recommendation {
   id?: number;
@@ -175,6 +175,61 @@ interface ConsultationType {
   socketParams?: SocketParams;
   doctor_average_rating?: number;
 }
+interface Transcription {
+  transcript: string;
+}
+interface SubCategory {
+  sub_category_id: number;
+  name_en: string;
+  name_ar: string;
+}
+
+interface PredictSpecialty {
+  specialty_id: number;
+  subCategories: SubCategory[];
+}
+interface PredictSummary {
+  summary: string;
+}
+interface Soap {
+  summary: {
+    subjective: {
+      symptoms?: string;
+      concerns?: string;
+    };
+    objective: {
+      laboratory_results?: string;
+      physical_examination_findings?: string;
+    };
+    assessment: {
+      diagnosis?: string;
+      differential_diagnosis?: string;
+    };
+    plan: {
+      non_pharmacological_intervention?: string;
+      medications?: string;
+      referrals?: string;
+      follow_up_instructions?: string;
+    };
+  };
+}
+interface Article {
+  article_id: number;
+  slug: string;
+  sub_category_id: number;
+  title: string;
+  body: string;
+  article_references: string;
+  activation_date: string;
+  publish_status: string;
+  adult_content: boolean;
+  featured: boolean;
+  date_added: string;
+  date_modified: string;
+  body_clean: string;
+  image_url: string;
+  url: string;
+}
 export type {
   ResponseType,
   MediumType,
@@ -202,4 +257,90 @@ export type {
   RecommendationDoctorReferral,
   RecommendationPostCallAnswer,
   ConsultationType,
+  Transcription,
+  PredictSpecialty,
+  PredictSummary,
+  Soap,
+  Article,
 };
+
+export interface ChatType {
+  id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface MessageData {
+  contentType: string;
+  foundInRag: boolean;
+  links: any[];
+}
+
+export interface ChatMessage {
+  id: number;
+  sender: string;
+  text: string;
+  chatId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  media: any;
+  data?: MessageData;
+}
+
+export interface ChatResponse {
+  userMessage: ChatMessage;
+  sinaMessage: ChatMessage;
+}
+
+export function parseChatMessage(json: any): ChatMessage {
+  return {
+    id: json.id,
+    sender: json.sender,
+    text: json.text,
+    chatId: json.chat_id,
+    createdAt: new Date(json.created_at),
+    updatedAt: new Date(json.updated_at),
+    media: json.media,
+    data: json.data
+      ? {
+          contentType: json.data.content_type,
+          foundInRag: json.data.found_in_rag,
+          links: json.data.links,
+        }
+      : undefined,
+  };
+}
+
+export function parseChatResponse(json: any): ChatResponse {
+  return {
+    userMessage: parseChatMessage(json.user_message),
+    sinaMessage: parseChatMessage(json.sina_message),
+  };
+}
+
+export function serializeChatMessage(msg: ChatMessage): any {
+  const base: any = {
+    id: msg.id,
+    sender: msg.sender,
+    text: msg.text,
+    chat_id: msg.chatId,
+    created_at: msg.createdAt.toISOString(),
+    updated_at: msg.updatedAt.toISOString(),
+    media: msg.media,
+  };
+  if (msg.data) {
+    base.data = {
+      content_type: msg.data.contentType,
+      found_in_rag: msg.data.foundInRag,
+      links: msg.data.links,
+    };
+  }
+  return base;
+}
+
+export function serializeChatResponse(resp: ChatResponse): any {
+  return {
+    user_message: serializeChatMessage(resp.userMessage),
+    sina_message: serializeChatMessage(resp.sinaMessage),
+  };
+}

package/src/video/OT.d.ts

@@ -1,15 +1,6 @@
-declare const OT: any;
-declare const nativeEvents: NativeEventEmitter;
-declare function checkAndroidPermissions(): Promise<any>;
-declare function setNativeEvents(events: any): void;
-declare function removeNativeEvents(events: any): void;
+export let OT: any;
+export let nativeEvents: NativeEventEmitter;
+export function checkAndroidPermissions(audioTrack: any, videoTrack: any, isScreenSharing: any): Promise<any>;
+export function setNativeEvents(events: any): void;
+export function removeNativeEvents(events: any): void;
 import { NativeEventEmitter } from 'react-native';
-
-// Export the declared types
-export {
-  OT,
-  nativeEvents,
-  checkAndroidPermissions,
-  setNativeEvents,
-  removeNativeEvents,
-};

package/src/video/OT.js

@@ -4,10 +4,12 @@ import { each } from 'underscore';
 const OT = NativeModules.OTSessionManager;
 const nativeEvents = new NativeEventEmitter(OT);
 
-const checkAndroidPermissions = () => new Promise((resolve, reject) => {
-  PermissionsAndroid.requestMultiple([
-    PermissionsAndroid.PERMISSIONS.CAMERA,
-    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO])
+const checkAndroidPermissions = (audioTrack, videoTrack, isScreenSharing) => new Promise((resolve, reject) => {
+  const permissionsToCheck = [
+    ... audioTrack ? [PermissionsAndroid.PERMISSIONS.RECORD_AUDIO] : [],
+    ... (videoTrack && !isScreenSharing) ? [PermissionsAndroid.PERMISSIONS.CAMERA] : [],
+  ];
+  PermissionsAndroid.requestMultiple(permissionsToCheck)
     .then((result) => {
       const permissionsError = {};
       permissionsError.permissionsDenied = [];

package/src/video/OTPublisher.d.ts

@@ -1,27 +1,33 @@
 export default OTPublisher;
-declare class OTPublisher extends Component<any, any, any> {
+declare class OTPublisher extends React.Component<any, any, any> {
     constructor(props: any, context: any);
     state: {
-        initError: any;
-        publisher: any;
+        initError: null;
+        publisher: null;
         publisherId: any;
     };
     initComponent: () => void;
     componentEvents: {
+        publisherStreamCreated: string;
+        publisherStreamDestroyed: string;
         sessionConnected: string;
-    };
-    componentEventsArray: string[];
-    otrnEventHandler: (event: any) => void;
-    publisherEvents: {};
-    sessionConnected: import("react-native").EmitterSubscription;
+    } | undefined;
+    componentEventsArray: string[] | undefined;
+    otrnEventHandler: ((event: any) => void) | undefined;
+    publisherEvents: {} | undefined;
+    publisherStreamCreated: import("react-native").EmitterSubscription | undefined;
+    publisherStreamDestroyed: import("react-native").EmitterSubscription | undefined;
+    sessionConnected: import("react-native").EmitterSubscription | undefined;
     componentDidMount(): void;
     componentDidUpdate(previousProps: any): void;
     componentWillUnmount(): void;
     sessionConnectedHandler: () => void;
     createPublisher(): void;
-    initPublisher(): void;
+    initPublisher(publisherProperties: any): void;
     publish(): void;
     getRtcStatsReport(): void;
+    publisherStreamCreatedHandler: (stream: any) => void;
+    publisherStreamDestroyedHandler: (stream: any) => void;
     setVideoTransformers(videoTransformers: any): void;
     render(): JSX.Element;
 }
@@ -34,5 +40,5 @@ declare namespace OTPublisher {
     }
     export { OTContext as contextType };
 }
-import { Component } from 'react';
+import React from 'react';
 import OTContext from './contexts/OTContext';

package/src/video/OTPublisher.js

@@ -31,6 +31,8 @@ class OTPublisher extends Component {
   }
   initComponent = () => {
     this.componentEvents = {
+      publisherStreamCreated: 'publisherStreamCreated',
+      publisherStreamDestroyed: 'publisherStreamDestroyed:',
       sessionConnected:
         Platform.OS === 'android'
           ? 'session:onConnected'
@@ -44,6 +46,14 @@ class OTPublisher extends Component {
     );
     setNativeEvents(this.publisherEvents);
     OT.setJSComponentEvents(this.componentEventsArray);
+    this.publisherStreamCreated = nativeEvents.addListener(
+      'publisherStreamCreated',
+      stream => this.publisherStreamCreatedHandler(stream)
+    );
+    this.publisherStreamDestroyed = nativeEvents.addListener(
+      'publisherStreamDestroyed',
+      stream => this.publisherStreamDestroyedHandler(stream)
+    );
     if (this.context.sessionId) {
       this.sessionConnected = nativeEvents.addListener(
         `${this.context.sessionId}:${this.componentEvents.sessionConnected}`,
@@ -99,20 +109,22 @@ class OTPublisher extends Component {
     }
   };
   createPublisher() {
+    const publisherProperties = sanitizeProperties(this.props.properties);
     if (Platform.OS === 'android') {
-      checkAndroidPermissions()
+      const { audioTrack, videoTrack, videoSource } = publisherProperties;
+      const isScreenSharing = (videoSource === 'screen');
+      checkAndroidPermissions(audioTrack, videoTrack, isScreenSharing)
         .then(() => {
-          this.initPublisher();
+          this.initPublisher(publisherProperties);
         })
         .catch((error) => {
           this.otrnEventHandler(error);
         });
     } else {
-      this.initPublisher();
+      this.initPublisher(publisherProperties);
     }
   }
-  initPublisher() {
-    const publisherProperties = sanitizeProperties(this.props.properties);
+  initPublisher(publisherProperties) {
     OT.initPublisher(
       this.state.publisherId,
       publisherProperties,
@@ -157,6 +169,26 @@ class OTPublisher extends Component {
     OT.getRtcStatsReport(this.state.publisherId);
   }
 
+  publisherStreamCreatedHandler = (stream) => {
+    if (
+      this.props.eventHandlers
+      && this.props.eventHandlers.streamCreated
+      && stream.publisherId === this.state.publisherId
+    ) {
+      this.props.eventHandlers.streamCreated(stream);
+    }
+  }
+
+  publisherStreamDestroyedHandler = (stream) => {
+    if (
+      this.props.eventHandlers
+      && this.props.eventHandlers.streamCreated
+      && stream.publisherId === this.state.publisherId
+    ) {
+      this.props.eventHandlers.streamDestroyed(stream);
+    }
+  }
+
   setVideoTransformers(videoTransformers) {
     OT.setVideoTransformers(this.state.publisherId, videoTransformers);
   }