medos-sdk 1.1.10 → 1.1.12

package/dist/components/appointment-booking/hooks/useAppointmentFlow.js

@@ -5,22 +5,27 @@ import { validatePhoneNumber, validateCountryCode, } from "../../../components/v
 import { formatDateToISO, parsePatientName } from "../../../components/utils";
 export const useAppointmentFlow = (state, dispatch, onError) => {
     const goBack = useCallback(() => {
-        if (state.step === 3) {
+        if (state.step === 2) {
             dispatch({ type: "SET_OTP_SENT", payload: false });
             dispatch({ type: "SET_OTP_CODE", payload: "" });
             dispatch({ type: "SET_OTP_VERIFIED", payload: false });
             dispatch({ type: "SET_STEP", payload: 1 });
         }
+        else if (state.step === 3) {
+            dispatch({ type: "SET_STEP", payload: 2 });
+        }
         else if (state.step === 4) {
-            dispatch({ type: "SET_STEP", payload: 3 });
+            if (state.verifiedPatients && state.verifiedPatients.length > 0) {
+                dispatch({ type: "SET_STEP", payload: 3 });
+            }
+            else {
+                dispatch({ type: "SET_STEP", payload: 2 });
+            }
         }
         else {
             dispatch({ type: "SET_STEP", payload: Math.max(0, state.step - 1) });
         }
-    }, [state.step, dispatch]);
-    const goToNext = useCallback(() => {
-        dispatch({ type: "SET_STEP", payload: Math.min(5, state.step + 1) });
-    }, [state.step, dispatch]);
+    }, [state.step, state.verifiedPatients, dispatch]);
     const handleDateChange = useCallback(async (date) => {
         dispatch({ type: "SET_SELECTED_DATE", payload: date });
         if (!state.workspaceId ||
@@ -120,13 +125,74 @@ export const useAppointmentFlow = (state, dispatch, onError) => {
         }
         dispatch({ type: "SET_OTP_VERIFYING", payload: true });
         try {
-            await PatientService.verifyPhoneVerificationOtp({
+            const response = await PatientService.verifyPhoneVerificationOtp({
                 countryCode: state.countryCode,
                 phoneNumber: state.patientPhone,
                 otpCode: state.otpCode,
             });
             dispatch({ type: "SET_OTP_VERIFIED", payload: true });
             dispatch({ type: "SET_ERROR", payload: null });
+            const sessionPacksDetails = response.sessionPacksDetails;
+            if (sessionPacksDetails?.associatedPatients &&
+                sessionPacksDetails.associatedPatients.length > 0) {
+                dispatch({
+                    type: "SET_VERIFIED_PATIENTS",
+                    payload: sessionPacksDetails.associatedPatients,
+                });
+            }
+            else if (response.patients && response.patients.length > 0) {
+                dispatch({ type: "SET_VERIFIED_PATIENTS", payload: response.patients });
+            }
+            else {
+                dispatch({ type: "SET_VERIFIED_PATIENTS", payload: [] });
+            }
+            if (sessionPacksDetails?.activeSessionPackResponses &&
+                sessionPacksDetails.activeSessionPackResponses.length > 0) {
+                const userSessionPacks = sessionPacksDetails.activeSessionPackResponses.map((pack) => ({
+                    id: pack.id,
+                    name: pack.packageName || pack.name,
+                    description: pack.description,
+                    totalSessions: pack.totalSessions,
+                    remainingSessions: pack.remainingSessions,
+                    expiryDate: pack.expiryDate,
+                    purchaseDate: pack.purchaseDate,
+                    doctorId: pack.doctorId,
+                    doctorName: pack.doctorName,
+                    allowedConsultationModes: pack.allowedConsultationModes,
+                }));
+                dispatch({ type: "SET_USER_SESSION_PACKS", payload: userSessionPacks });
+            }
+            else {
+                dispatch({ type: "SET_USER_SESSION_PACKS", payload: [] });
+            }
+            if (sessionPacksDetails?.allSessionPackResponses &&
+                sessionPacksDetails.allSessionPackResponses.length > 0) {
+                const availablePackages = sessionPacksDetails.allSessionPackResponses.map((pack) => ({
+                    id: pack.id,
+                    name: pack.packageName,
+                    description: pack.description,
+                    totalSessions: pack.totalSessions,
+                    sessions: pack.totalSessions,
+                    price: pack.packagePrice,
+                    discountedPrice: pack.discountedPrice,
+                    discount: pack.discount,
+                    discountType: pack.discountType,
+                    currency: "INR",
+                    validityDays: pack.validityDays,
+                    allowedConsultationModes: pack.allowedConsultationModes,
+                    allowedDoctors: pack.allowedDoctors,
+                    doctorIds: pack.doctorIds,
+                    applicableOnline: pack.allowedConsultationModes?.includes("ONLINE"),
+                    applicableOffline: pack.allowedConsultationModes?.includes("OFFLINE"),
+                }));
+                dispatch({
+                    type: "SET_AVAILABLE_PACKAGES",
+                    payload: availablePackages,
+                });
+            }
+            else {
+                dispatch({ type: "SET_AVAILABLE_PACKAGES", payload: [] });
+            }
         }
         catch (e) {
             const msg = e.message || "Invalid OTP code";
@@ -156,11 +222,7 @@ export const useAppointmentFlow = (state, dispatch, onError) => {
             });
             return;
         }
-        if (!state.patientName ||
-            !state.patientAge ||
-            !state.patientEmail ||
-            !state.patientGender ||
-            !state.bloodGroup) {
+        if (!state.patientName || !state.patientAge || !state.patientGender) {
             dispatch({
                 type: "SET_ERROR",
                 payload: "Please fill in all patient details.",
@@ -182,7 +244,24 @@ export const useAppointmentFlow = (state, dispatch, onError) => {
         try {
             const { firstName, lastName } = parsePatientName(state.patientName);
             const appointmentDate = formatDateToISO(state.selectedDate);
-            await AppointmentService.createAppointment({
+            const patientPayload = {
+                firstName,
+                lastName,
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+                age: Number.parseInt(state.patientAge, 10),
+                gender: state.patientGender.toUpperCase(),
+            };
+            if (state.patientEmail) {
+                patientPayload.email = state.patientEmail;
+            }
+            if (state.bloodGroup) {
+                patientPayload.bloodGroup = state.bloodGroup;
+            }
+            if (state.useExistingPatient && state.selectedPatient) {
+                patientPayload.id = state.selectedPatient.id;
+            }
+            const appointmentPayload = {
                 workspaceId: state.workspaceId,
                 workspaceAddressId: state.selectedAddress,
                 doctorId: state.selectedDoctor,
@@ -193,25 +272,33 @@ export const useAppointmentFlow = (state, dispatch, onError) => {
                 consultationCharge: state.consultationCharge || "0",
                 type: "CONSULTATION",
                 source: "SDK_POWERED_WEBSITE",
-                patientPayload: {
-                    firstName,
-                    lastName,
-                    email: state.patientEmail,
-                    countryCode: state.countryCode,
-                    phoneNumber: state.patientPhone,
-                    age: parseInt(state.patientAge, 10),
-                    gender: state.patientGender.toUpperCase(),
-                },
+                bookingType: state.bookingType,
+                paymentMode: state.paymentMode,
+                patientPayload,
                 patientAddress: {
                     addressLine1: state.patientAddress,
+                    addressLine2: "",
                     city: state.patientCity,
                     state: state.patientState,
                     country: state.patientCountry,
                     zipcode: state.patientZipcode,
                     landmark: state.patientLandmark || undefined,
+                    countryCode: state.countryCode,
+                    phoneNumber: state.patientPhone,
+                    patientId: state.selectedPatient?.id || 0,
                 },
-            });
-            dispatch({ type: "SET_STEP", payload: 5 });
+            };
+            if (state.packageConfigId) {
+                appointmentPayload.packageConfigId = state.packageConfigId;
+            }
+            if (state.patientPackageId) {
+                appointmentPayload.patientPackageId = state.patientPackageId;
+            }
+            if (state.packageAmount) {
+                appointmentPayload.packageAmount = state.packageAmount;
+            }
+            await AppointmentService.createAppointment(appointmentPayload);
+            dispatch({ type: "SET_STEP", payload: 7 });
         }
         catch (e) {
             const msg = e.message || "Failed to create appointment";
@@ -224,7 +311,6 @@ export const useAppointmentFlow = (state, dispatch, onError) => {
     }, [state, dispatch, onError]);
     return {
         goBack,
-        goToNext,
         handleDateChange,
         sendOtp,
         verifyOtp,

package/dist/components/appointment-booking/hooks/useAppointmentState.js

@@ -70,6 +70,38 @@ const appointmentReducer = (state, action) => {
             return { ...state, otpSending: action.payload };
         case "SET_OTP_VERIFYING":
             return { ...state, otpVerifying: action.payload };
+        case "SET_VERIFIED_PATIENTS":
+            return { ...state, verifiedPatients: action.payload };
+        case "SET_SELECTED_PATIENT":
+            return { ...state, selectedPatient: action.payload };
+        case "SET_USE_EXISTING_PATIENT":
+            return { ...state, useExistingPatient: action.payload };
+        case "SET_USER_SESSION_PACKS":
+            return { ...state, userSessionPacks: action.payload };
+        case "SET_AVAILABLE_PACKAGES":
+            return { ...state, availablePackages: action.payload };
+        case "SET_SELECTED_SESSION_PACK":
+            return { ...state, selectedSessionPack: action.payload };
+        case "SET_SELECTED_NEW_PACKAGE":
+            return { ...state, selectedNewPackage: action.payload };
+        case "SET_BOOKING_OPTION_TYPE":
+            return { ...state, bookingOptionType: action.payload };
+        case "SET_SHOW_PACKAGE_EXPLORER":
+            return { ...state, showPackageExplorer: action.payload };
+        case "SET_PACKAGES_LOADING":
+            return { ...state, packagesLoading: action.payload };
+        case "SET_BOOKING_TYPE":
+            return { ...state, bookingType: action.payload };
+        case "SET_PAYMENT_MODE":
+            return { ...state, paymentMode: action.payload };
+        case "SET_PACKAGE_CONFIG_ID":
+            return { ...state, packageConfigId: action.payload };
+        case "SET_PATIENT_PACKAGE_ID":
+            return { ...state, patientPackageId: action.payload };
+        case "SET_PACKAGE_AMOUNT":
+            return { ...state, packageAmount: action.payload };
+        case "SET_PATIENT_DOB":
+            return { ...state, patientDob: action.payload };
         case "RESET_FORM":
             return INITIAL_STATE;
         default:

package/dist/components/appointment-booking/hooks/useInitializeAddresses.js

@@ -26,7 +26,6 @@ export const useInitializeAddresses = (dispatch, onError) => {
                                 type: "SET_SELECTED_DOCTOR",
                                 payload: address.doctors[0].id,
                             });
-                            dispatch({ type: "SET_STEP", payload: 1 });
                         }
                     }
                 }

package/dist/components/appointment-booking/index.d.ts

@@ -1,5 +1,3 @@
 export { AppointmentCalender } from "./AppointmentCalender";
-export type { AppointmentCalenderProps } from "./AppointmentCalender";
-export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
-export type { AppointmentState, AppointmentAction } from "./types";
-export { INITIAL_STATE } from "./types";
+export * from "./components";
+export * from "./types";

package/dist/components/appointment-booking/index.js

@@ -1,3 +1,3 @@
 export { AppointmentCalender } from "./AppointmentCalender";
-export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
-export { INITIAL_STATE } from "./types";
+export * from "./components";
+export * from "./types";

package/dist/components/appointment-booking/types.d.ts

@@ -1,4 +1,104 @@
 import { Doctor, Slot, AddressItem } from "../../services/AppointmentService";
+export interface Patient {
+    id: number;
+    firstName: string;
+    lastName: string;
+    email: string;
+    countryCode: string;
+    phoneNumber: string;
+    dob: string;
+    age: number;
+    gender: string;
+    bloodGroup: string;
+    mrn: string;
+    address: {
+        id: number;
+        completeAddress: string;
+        addressLine1: string;
+        addressLine2: string;
+        city: string;
+        state: string;
+        country: string;
+        zipcode: string;
+        landmark: string;
+        phoneNumber: string;
+        latitude: number;
+        longitude: number;
+    };
+}
+export interface SessionPackDoctor {
+    id: number;
+    fullName: string;
+    profilePicUrl: string | null;
+}
+export interface SessionPackResponse {
+    id: number;
+    workspaceId: number;
+    packageName: string;
+    description: string;
+    totalSessions: number;
+    packagePrice: number;
+    discount: number;
+    discountedPrice: number;
+    discountType: "PERCENTAGE" | "FLAT";
+    validityDays: number;
+    allowedConsultationModes: ("ONLINE" | "OFFLINE")[];
+    doctorIds: number[];
+    allowFamilyBooking: boolean;
+    maxFamilyMembers: number;
+    isActive: boolean;
+    allowedDoctors: SessionPackDoctor[];
+}
+export interface ActiveSessionPack {
+    id: number;
+    packageName: string;
+    totalSessions: number;
+    remainingSessions: number;
+    expiryDate: string;
+    purchaseDate?: string;
+    doctorId?: number;
+    doctorName?: string;
+    allowedConsultationModes?: ("ONLINE" | "OFFLINE")[];
+}
+export interface SessionPacksDetails {
+    associatedPatients: Patient[];
+    activeSessionPackResponses: ActiveSessionPack[];
+    allSessionPackResponses: SessionPackResponse[];
+}
+export interface SessionPack {
+    id: number;
+    name: string;
+    description?: string;
+    totalSessions: number;
+    remainingSessions: number;
+    price?: number;
+    validityDays?: number;
+    applicableOnline?: boolean;
+    applicableOffline?: boolean;
+    expiryDate: string;
+    purchaseDate?: string;
+    doctorId?: number;
+    doctorName?: string;
+}
+export interface AvailablePackage {
+    id: number;
+    name: string;
+    description?: string;
+    totalSessions: number;
+    sessions?: number;
+    price: number;
+    discountedPrice?: number;
+    discount?: number;
+    discountType?: "PERCENTAGE" | "FLAT";
+    currency?: string;
+    validityDays: number;
+    applicableOnline?: boolean;
+    applicableOffline?: boolean;
+    allowedConsultationModes?: ("ONLINE" | "OFFLINE")[];
+    allowedDoctors?: SessionPackDoctor[];
+    doctorIds?: number[];
+}
+export type BookingOptionType = "session-pack" | "new-appointment" | "explore-packages" | null;
 export interface AppointmentState {
     step: number;
     loading: boolean;
@@ -18,6 +118,7 @@ export interface AppointmentState {
     patientEmail: string;
     patientGender: string;
     bloodGroup: string;
+    patientDob: string;
     patientAddress: string;
     patientCity: string;
     patientState: string;
@@ -31,6 +132,21 @@ export interface AppointmentState {
     otpVerified: boolean;
     otpSending: boolean;
     otpVerifying: boolean;
+    verifiedPatients: Patient[];
+    selectedPatient: Patient | null;
+    useExistingPatient: boolean;
+    userSessionPacks: SessionPack[];
+    availablePackages: AvailablePackage[];
+    selectedSessionPack: SessionPack | null;
+    selectedNewPackage: AvailablePackage | null;
+    bookingOptionType: BookingOptionType;
+    showPackageExplorer: boolean;
+    packagesLoading: boolean;
+    bookingType: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+    paymentMode: "CASH" | "CARD" | string;
+    packageConfigId?: number;
+    patientPackageId?: number;
+    packageAmount?: number;
 }
 export type AppointmentAction = {
     type: "SET_STEP";
@@ -83,6 +199,9 @@ export type AppointmentAction = {
 } | {
     type: "SET_BLOOD_GROUP";
     payload: string;
+} | {
+    type: "SET_PATIENT_DOB";
+    payload: string;
 } | {
     type: "SET_PATIENT_ADDRESS";
     payload: string;
@@ -122,7 +241,55 @@ export type AppointmentAction = {
 } | {
     type: "SET_OTP_VERIFYING";
     payload: boolean;
+} | {
+    type: "SET_VERIFIED_PATIENTS";
+    payload: Patient[];
+} | {
+    type: "SET_SELECTED_PATIENT";
+    payload: Patient | null;
+} | {
+    type: "SET_USE_EXISTING_PATIENT";
+    payload: boolean;
+} | {
+    type: "SET_USER_SESSION_PACKS";
+    payload: SessionPack[];
+} | {
+    type: "SET_AVAILABLE_PACKAGES";
+    payload: AvailablePackage[];
+} | {
+    type: "SET_SELECTED_SESSION_PACK";
+    payload: SessionPack | null;
+} | {
+    type: "SET_SELECTED_NEW_PACKAGE";
+    payload: AvailablePackage | null;
+} | {
+    type: "SET_BOOKING_OPTION_TYPE";
+    payload: BookingOptionType;
+} | {
+    type: "SET_SHOW_PACKAGE_EXPLORER";
+    payload: boolean;
+} | {
+    type: "SET_PACKAGES_LOADING";
+    payload: boolean;
+} | {
+    type: "SET_BOOKING_TYPE";
+    payload: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+} | {
+    type: "SET_PAYMENT_MODE";
+    payload: "CASH" | "CARD" | string;
+} | {
+    type: "SET_PACKAGE_CONFIG_ID";
+    payload: number | undefined;
+} | {
+    type: "SET_PATIENT_PACKAGE_ID";
+    payload: number | undefined;
+} | {
+    type: "SET_PACKAGE_AMOUNT";
+    payload: number | undefined;
 } | {
     type: "RESET_FORM";
 };
+export interface AppointmentCalenderProps {
+    onError?: (err: Error) => void;
+}
 export declare const INITIAL_STATE: AppointmentState;

package/dist/components/appointment-booking/types.js

@@ -17,6 +17,7 @@ export const INITIAL_STATE = {
     patientEmail: "",
     patientGender: "",
     bloodGroup: "",
+    patientDob: "",
     patientAddress: "",
     patientCity: "",
     patientState: "",
@@ -30,4 +31,19 @@ export const INITIAL_STATE = {
     otpVerified: false,
     otpSending: false,
     otpVerifying: false,
+    verifiedPatients: [],
+    selectedPatient: null,
+    useExistingPatient: false,
+    userSessionPacks: [],
+    availablePackages: [],
+    selectedSessionPack: null,
+    selectedNewPackage: null,
+    bookingOptionType: null,
+    showPackageExplorer: false,
+    packagesLoading: false,
+    bookingType: "ONE_TIME_APPOINTMENT",
+    paymentMode: "CASH",
+    packageConfigId: undefined,
+    patientPackageId: undefined,
+    packageAmount: undefined,
 };