react-native-altibbi 0.1.0 → 0.1.2

package/src/connection.ts

@@ -1,5 +1,5 @@
 import { TBIConstants } from './service';
-import { UserType } from './types';
+import { ConsultationType, MediaType, ResponseType, UserType } from './types';
 
 interface MethodsObject {
   get: string;
@@ -11,10 +11,27 @@ interface MethodsObject {
 interface ConsultationObject {
   question: string;
   medium: string;
-  userId: number;
+  user_id: number;
   mediaIds?: string[];
   followUpId?: string;
 }
+
+interface RequestParamsInterface {
+  method: string;
+  data?: Record<any, any>;
+  endPoint: string;
+  path?: string;
+  type?: string;
+  fileName?: string;
+  download?: boolean;
+}
+
+interface RequestInterface {
+  method: string;
+  headers: Record<string, string>;
+  body: string | FormData | undefined;
+}
+
 export const Methods: MethodsObject = {
   get: 'GET',
   post: 'POST',
@@ -38,22 +55,6 @@ const fetchData = (
     throw Error(`Fetch Error : ${e}`);
   });
 
-interface RequestParamsInterface {
-  method: string;
-  data?: Record<any, any>;
-  endPoint: string;
-  path?: string;
-  type?: string;
-  fileName?: string;
-  download?: boolean;
-}
-
-interface RequestInterface {
-  method: string;
-  headers: Record<string, string>;
-  body: string | FormData | undefined;
-}
-
 export const request = async ({
   method,
   data,
@@ -63,9 +64,9 @@ export const request = async ({
   fileName,
   download,
 }: RequestParamsInterface) => {
-  if (!TBIConstants.domain) {
+  if (!TBIConstants.baseURL) {
     return {
-      message: 'Add your domain to Init',
+      message: 'Add your baseURL to Init',
     };
   }
 
@@ -75,7 +76,7 @@ export const request = async ({
     'accept-language': TBIConstants.language,
   };
 
-  let url = `${TBIConstants.domain}/v1/${endPoint}`;
+  let url = `${TBIConstants.baseURL}/v1/${endPoint}`;
   let body;
   if (method === Methods.get) {
     url = url + '?' + new URLSearchParams(data).toString();
@@ -114,81 +115,138 @@ export const request = async ({
   };
 };
 
-export const getUser = (userId: string) =>
-  request({
+export const getUser = async (
+  user_id: string
+): Promise<ResponseType<UserType>> => {
+  const response: ResponseType<UserType> = await request({
     method: Methods.get,
     data: {},
-    endPoint: `users/${userId}`,
+    endPoint: `users/${user_id}`,
   });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const getUsers = (page: number = 1, perPage: number = 20) =>
-  request({
+export const getUsers = async (
+  page: number = 1,
+  perPage: number = 20
+): Promise<ResponseType<UserType[]>> => {
+  const response: ResponseType<UserType[]> = await request({
     method: Methods.get,
     data: { page, 'per-page': perPage },
     endPoint: `users`,
   });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const createUser = (user: UserType) =>
-  request({
+export const createUser = async (
+  user: UserType
+): Promise<ResponseType<UserType>> => {
+  const response: ResponseType<UserType> = await request({
     method: Methods.post,
     data: user,
     endPoint: `users`,
   });
-export const updateUser = (user: UserType, userId: string) =>
-  request({
+  if (response.status === 201) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
+
+export const updateUser = async (
+  user: UserType,
+  user_id: string
+): Promise<ResponseType<UserType>> => {
+  const response: ResponseType<UserType> = await request({
     method: Methods.put,
     data: user,
-    endPoint: `users/${userId}`,
+    endPoint: `users/${user_id}`,
   });
+  if (response.status === 201) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const deleteUser = (userId: string) =>
-  request({
+export const deleteUser = async (
+  user_id: string
+): Promise<ResponseType<string>> => {
+  const response: ResponseType<string> = await request({
     method: Methods.delete,
     data: {},
-    endPoint: `users/${userId}`,
+    endPoint: `users/${user_id}`,
   });
+  if (response.status === 204) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
 export const createConsultation = async ({
   question,
   medium,
-  userId,
+  user_id,
   mediaIds,
   followUpId,
-}: ConsultationObject) => {
-  if (!question || !medium || !userId) {
-    return { message: 'missing field' };
+}: ConsultationObject): Promise<ResponseType<ConsultationType>> => {
+  if (!question || !medium || !user_id) {
+    throw Error('missing field');
   }
 
   const data = {
     question,
     medium,
-    user_id: userId,
+    user_id,
     media_ids: mediaIds,
     expand:
       'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
       'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
     followUpId,
   };
-  return await request({
+  const response: ResponseType<ConsultationType> = await request({
     method: Methods.post,
     data,
     endPoint: `consultations`,
   });
+
+  if (response.status === 201) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
 };
 
-export const getConsultationInfo = (consultationId: number) =>
-  request({
+export const getConsultationInfo = async (
+  consultation_id: number
+): Promise<ResponseType<ConsultationType>> => {
+  const response: ResponseType<ConsultationType> = await request({
     method: Methods.get,
     data: {
       expand:
         'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
         'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
     },
-    endPoint: `consultations/${consultationId}`,
+    endPoint: `consultations/${consultation_id}`,
   });
+  if (response.status === 200) {
+    response.data.socketParams = {
+      apiKey: response?.data?.[0]?.pusherAppKey,
+      cluster: 'eu',
+      authEndpoint: `${TBIConstants.baseURL}/v1/auth/pusher?access-token=${TBIConstants.token}`,
+    };
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const getLastConsultation = () =>
-  request({
+export const getLastConsultation = async (): Promise<
+  ResponseType<ConsultationType[]>
+> => {
+  const response: ResponseType<ConsultationType[]> = await request({
     method: Methods.get,
     data: {
       'per-page': 1,
@@ -199,46 +257,79 @@ export const getLastConsultation = () =>
     },
     endPoint: `consultations`,
   });
+  if (response.status === 200) {
+    response.data[0].socketParams = {
+      apiKey: response.data[0].pusherAppKey,
+      cluster: 'eu',
+      authEndpoint: `${TBIConstants.baseURL}/v1/auth/pusher?access-token=${TBIConstants.token}`,
+    };
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
 export const getConsultationList = async (
-  userId: number,
+  user_id: number,
   page: number = 1,
   perPage = 20
-) => {
-  if (!userId) {
-    return { message: 'missing user id' };
+): Promise<ResponseType<ConsultationType[]>> => {
+  if (!user_id) {
+    throw Error('missing user id');
   }
 
-  return await request({
+  const response = await request({
     method: Methods.get,
     data: {
       page,
       'per-page': perPage,
-      'filter[user_id]': userId,
+      'filter[user_id]': user_id,
       'expand':
         'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
         'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
     },
     endPoint: `consultations`,
   });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
 };
 
-export const deleteConsultation = (consultationId: number) =>
-  request({
+export const deleteConsultation = async (
+  consultation_id: number
+): Promise<ResponseType<string>> => {
+  const response: ResponseType<string> = await request({
     method: Methods.delete,
     data: {},
-    endPoint: `consultations/${consultationId}`,
+    endPoint: `consultations/${consultation_id}`,
   });
+  if (response.status === 204) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const cancelConsultation = (consultationId: number) =>
-  request({
-    method: Methods.post,
-    data: {},
-    endPoint: `consultations/${consultationId}/cancel`,
-  });
+export const cancelConsultation = async (
+  consultation_id: number
+): Promise<ResponseType<{ consultation_id: number; status: string }>> => {
+  const response: ResponseType<{ consultation_id: number; status: string }> =
+    await request({
+      method: Methods.post,
+      data: {},
+      endPoint: `consultations/${consultation_id}/cancel`,
+    });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const uploadMedia = (path: string, type: string, fileName: string) =>
-  request({
+export const uploadMedia = async (
+  path: string,
+  type: string,
+  fileName: string
+): Promise<ResponseType<MediaType>> => {
+  const response: ResponseType<MediaType> = await request({
     method: Methods.post,
     endPoint: `media`,
     data: {},
@@ -246,10 +337,15 @@ export const uploadMedia = (path: string, type: string, fileName: string) =>
     type,
     fileName,
   });
+  if (response.status === 200) {
+    return response;
+  }
+  throw Error(JSON.stringify(response));
+};
 
-export const getPrescription = (consultationId: number) =>
+export const getPrescription = (consultation_id: number) =>
   request({
     method: Methods.get,
-    endPoint: `consultations/${consultationId}/download-prescription`,
+    endPoint: `consultations/${consultation_id}/download-prescription`,
     download: true,
   });

package/src/data.ts

@@ -1,4 +1,10 @@
-import { BloodType, BoolString, GenderType, MaritalStatus, MediumType } from './types';
+import {
+  BloodType,
+  BoolString,
+  GenderType,
+  MaritalStatus,
+  MediumType,
+} from './types';
 
 export const materialStatusArray: MaritalStatus[] = [
   'single',

package/src/index.tsx

@@ -63,13 +63,32 @@ export {
   type TBISocketAuthorizerResult,
 } from './scoket';
 
-export {
+export type {
+  ResponseType,
+  MediumType,
+  BloodType,
+  MaritalStatus,
+  BoolString,
+  GenderType,
   UserType,
-  type BloodType,
-  type MaritalStatus,
-  type BoolString,
-  type GenderType,
-  type MediumType,
+  MediaType,
+  ChatData,
+  ChatHistory,
+  ChatConfig,
+  VoipConfig,
+  Recommendation,
+  RecommendationData,
+  RecommendationLab,
+  RecommendationLabItem,
+  RecommendationDrug,
+  RecommendationFdaDrug,
+  RecommendationICD10,
+  RecommendationSymptom,
+  RecommendationDiagnosis,
+  RecommendationFollowUp,
+  RecommendationDoctorReferral,
+  RecommendationPostCallAnswer,
+  ConsultationType,
 } from './types';
 export {
   materialStatusArray,
@@ -78,3 +97,5 @@ export {
   genderTypeArray,
   MediumArray,
 } from './data';
+
+

package/src/service.ts

@@ -1,20 +1,19 @@
 interface ConstantObject {
-  domain: string;
-  language: string;
   token: string;
+  baseURL: string;
+  language: string;
 }
 
 export let TBIConstants: ConstantObject = {
-  domain: '',
-  language: 'ar',
   token: '',
+  baseURL: '',
+  language: 'ar',
 };
 
-export const init = (domain: string, language: string, token: string) => {
-  console.log("init", domain, language, token);
+export const init = (token: string, baseURL: string, language: string) => {
   TBIConstants = {
-    domain,
-    language,
     token,
+    baseURL,
+    language,
   };
 };

package/src/types.ts

@@ -1,22 +1,185 @@
-export type MediumType = 'chat' | 'gsm' | 'voip' | 'video';
-export type BloodType = 'A+' | 'B+' | 'AB+' | 'O+' | 'A-' | 'B-' | 'AB-' | 'O-';
-export type MaritalStatus = 'single' | 'married' | 'divorced' | 'widow';
-export type BoolString = 'yes' | 'no';
-export type GenderType = 'male' | 'female';
-export interface UserType {
-  name?: string;
-  phoneNumber?: string;
+type MediumType = 'chat' | 'gsm' | 'voip' | 'video';
+type BloodType = 'A+' | 'B+' | 'AB+' | 'O+' | 'A-' | 'B-' | 'AB-' | 'O-';
+type MaritalStatus = 'single' | 'married' | 'divorced' | 'widow';
+type BoolString = 'yes' | 'no';
+type GenderType = 'male' | 'female';
+interface UserType {
+  id?: number;
+  name?: string;
+  phone_number?: string;
   email?: string;
-  dateOfBirth?: string;
+  date_of_birth?: string;
   gender?: GenderType;
-  insuranceId?: string;
-  policyNumber?: string;
-  nationalityNumber?: string;
+  insurance_id?: string;
+  policy_number?: string;
+  nationality_number?: string;
   height?: string;
   weight?: string;
-  bloodType?: BloodType;
+  blood_type?: BloodType;
   smoker?: BoolString;
   alcoholic?: BoolString;
-  maritalStatus?: MaritalStatus;
+  marital_status?: MaritalStatus;
+  created_at?: string;
+  updated_at?: string;
+}
+interface MediaType {
+  id?: string;
+  type?: string;
+  name?: string;
+  path?: string;
+  extension?: string;
+  url?: string;
+  size?: number;
+}
+interface SocketParams {
+  apiKey?: string;
+  cluster?: string;
+  authEndpoint?: string;
+}
+interface ResponseType<T> {
+  status: number;
+  data: T;
+}
+interface ChatData {
+  id?: string;
+  message?: string;
+  sent_at?: string;
+  chat_user_id?: string;
+}
+interface ChatHistory {
+  id?: number;
+  consultation_id?: number;
+  data?: ChatData[];
+  created_at?: string;
+  updated_at?: string;
+}
+interface ChatConfig {
+  id?: number;
+  consultation_id?: number;
+  group_id?: String;
+  chat_user_id?: String;
+  app_id?: String;
+  chat_user_token?: String;
+}
+interface VoipConfig {
+  id?: number;
+  consultation_id?: number;
+  apiKey?: string;
+  callId?: string;
+  token?: string;
+}
+interface Recommendation {
+  id?: number;
+  consultation_id?: number;
+  data?: RecommendationData;
+  created_at?: string;
+  updated_at?: string;
+}
+interface RecommendationData {
+  lab?: RecommendationLab;
+  drug?: RecommendationDrug;
+  icd10?: RecommendationICD10;
+  followUp?: RecommendationFollowUp[] | null;
+  doctorReferral?: RecommendationDoctorReferral;
+  postCallAnswer?: RecommendationPostCallAnswer[] | null;
+}
+interface RecommendationLab {
+  lab?: RecommendationLabItem[] | null;
+  panel?: RecommendationLabItem[] | null;
+}
+interface RecommendationLabItem {
+  name?: string;
+}
+interface RecommendationDrug {
+  fdaDrug?: RecommendationFdaDrug[] | null;
+}
+interface RecommendationFdaDrug {
+  name?: string;
+  dosage?: string;
+  duration?: number;
+  howToUse?: string;
+  frequency?: string;
+  tradeName?: string;
+  dosageForm?: string;
+  dosageUnit?: string;
+  packageSize?: string;
+  packageType?: string;
+  strengthValue?: string;
+  relationWithFood?: string;
+  specialInstructions?: string;
+  routeOfAdministration?: string;
+}
+interface RecommendationICD10 {
+  symptom?: RecommendationSymptom[] | null;
+  diagnosis?: RecommendationDiagnosis[] | null;
+}
+interface RecommendationSymptom {
+  code?: string;
+  name?: string;
+}
+interface RecommendationDiagnosis {
+  code?: string;
+  name?: string;
+}
+interface RecommendationFollowUp {
+  name?: string;
+}
+interface RecommendationDoctorReferral {
+  name?: string;
+}
+interface RecommendationPostCallAnswer {
+  answer?: string;
+  question?: string;
+}
+interface ConsultationType {
+  id?: number;
+  userId?: number;
+  question?: string;
+  doctorName?: string;
+  doctorAvatar?: string;
+  medium?: string;
+  status?: string;
+  isFulfilled?: number;
+  parentConsultationId?: number;
+  createdAt?: string;
+  updatedAt?: string;
+  user?: UserType;
+  parentConsultation?: ConsultationType;
+  media?: MediaType[];
+  consultations?: ConsultationType[];
+  pusherChannel?: string;
+  pusherAppKey?: string;
+  chatConfig?: ChatConfig;
+  voipConfig?: VoipConfig;
+  videoConfig?: VoipConfig;
+  chatHistory: ChatHistory;
+  recommendation?: Recommendation;
+  socketParams?: SocketParams;
 }
-
+export type {
+  ResponseType,
+  MediumType,
+  BloodType,
+  MaritalStatus,
+  BoolString,
+  GenderType,
+  UserType,
+  MediaType,
+  ChatData,
+  ChatHistory,
+  ChatConfig,
+  VoipConfig,
+  Recommendation,
+  RecommendationData,
+  RecommendationLab,
+  RecommendationLabItem,
+  RecommendationDrug,
+  RecommendationFdaDrug,
+  RecommendationICD10,
+  RecommendationSymptom,
+  RecommendationDiagnosis,
+  RecommendationFollowUp,
+  RecommendationDoctorReferral,
+  RecommendationPostCallAnswer,
+  ConsultationType,
+};