@blackcode_sa/metaestetics-api 1.6.4 → 1.6.5

package/src/admin/booking/booking.admin.ts

@@ -1,4 +1,5 @@
 import * as admin from "firebase-admin";
+import { Timestamp as FirebaseClientTimestamp } from "@firebase/firestore";
 import {
   BookingAvailabilityCalculator,
   BookingAvailabilityRequest,
@@ -6,9 +7,57 @@ import {
   AvailableSlot,
 } from "./";
 import { CalendarEventStatus, CalendarEventType } from "../../types/calendar";
-import { Clinic } from "../../types/clinic";
-import { Practitioner } from "../../types/practitioner";
-import { Procedure } from "../../types/procedure";
+import {
+  Clinic,
+  CLINICS_COLLECTION,
+  ClinicGroup,
+  CLINIC_GROUPS_COLLECTION,
+} from "../../types/clinic";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../types/practitioner";
+import {
+  Procedure,
+  PROCEDURES_COLLECTION,
+  ProcedureSummaryInfo,
+} from "../../types/procedure";
+import {
+  PatientProfile,
+  PATIENTS_COLLECTION,
+  PatientSensitiveInfo,
+  PATIENT_SENSITIVE_INFO_COLLECTION,
+  Gender,
+} from "../../types/patient";
+import {
+  Appointment,
+  AppointmentStatus,
+  PaymentStatus,
+  APPOINTMENTS_COLLECTION,
+  ProcedureExtendedInfo,
+} from "../../types/appointment";
+import { Currency } from "../../backoffice/types/static/pricing.types";
+import { DocumentTemplate } from "../../types/documentation-templates";
+import {
+  ClinicInfo,
+  PractitionerProfileInfo,
+  PatientProfileInfo,
+} from "../../types/profile";
+import { Category } from "../../backoffice/types/category.types";
+import { Subcategory } from "../../backoffice/types/subcategory.types";
+import { Technology } from "../../backoffice/types/technology.types";
+import { Product } from "../../backoffice/types/product.types";
+
+/**
+ * Interface for the data required by orchestrateAppointmentCreation
+ */
+export interface OrchestrateAppointmentCreationData {
+  patientId: string;
+  procedureId: string;
+  appointmentStartTime: admin.firestore.Timestamp;
+  appointmentEndTime: admin.firestore.Timestamp;
+  patientNotes?: string | null;
+}
 
 /**
  * Admin service for handling booking-related operations.
@@ -231,4 +280,328 @@ export class BookingAdmin {
       return [];
     }
   }
+
+  /**
+   * Orchestrates the creation of a new appointment, including data aggregation.
+   * This method is intended to be called from a trusted backend environment (e.g., an Express route handler in a Cloud Function).
+   *
+   * @param data - Data required to create the appointment.
+   * @param authenticatedUserId - The ID of the user making the request (for auditing, and usually is the patientId).
+   * @returns Promise resolving to an object indicating success, and appointmentId or an error message.
+   */
+  async orchestrateAppointmentCreation(
+    data: OrchestrateAppointmentCreationData,
+    authenticatedUserId: string
+  ): Promise<{
+    success: boolean;
+    appointmentId?: string;
+    appointmentData?: Appointment;
+    error?: string;
+  }> {
+    console.log(
+      `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
+    );
+
+    try {
+      // --- 1. Input Validation ---
+      if (
+        !data.patientId ||
+        !data.procedureId ||
+        !data.appointmentStartTime ||
+        !data.appointmentEndTime
+      ) {
+        return {
+          success: false,
+          error:
+            "Missing required fields: patientId, procedureId, appointmentStartTime, or appointmentEndTime.",
+        };
+      }
+      if (
+        data.appointmentEndTime.toMillis() <=
+        data.appointmentStartTime.toMillis()
+      ) {
+        return {
+          success: false,
+          error: "Appointment end time must be after start time.",
+        };
+      }
+      if (authenticatedUserId !== data.patientId) {
+        console.warn(
+          `[BookingAdmin] Authenticated user ${authenticatedUserId} is booking for a different patient ${data.patientId}. Review authorization if this is not intended.`
+        );
+      }
+
+      // --- 2. Fetch Core Procedure Data ---
+      const procedureRef = this.db
+        .collection(PROCEDURES_COLLECTION)
+        .doc(data.procedureId);
+      const procedureDoc = await procedureRef.get();
+      if (!procedureDoc.exists) {
+        return {
+          success: false,
+          error: `Procedure ${data.procedureId} not found.`,
+        };
+      }
+      const procedure = procedureDoc.data() as Procedure;
+
+      // --- 3. Fetch Clinic and then other Primary Documents ---
+      // Fetch clinic first to get its clinicGroupId
+      const clinicRef = this.db
+        .collection(CLINICS_COLLECTION)
+        .doc(procedure.clinicBranchId);
+      const clinicSnap = await clinicRef.get(); // Await here directly
+      if (!clinicSnap.exists) {
+        return {
+          success: false,
+          error: `Clinic ${procedure.clinicBranchId} not found.`,
+        };
+      }
+      const clinicData = clinicSnap.data() as Clinic; // Now clinicData is available
+
+      // Define other refs using clinicData for clinicGroupRef
+      const practitionerRef = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(procedure.practitionerId);
+      const patientProfileRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(data.patientId);
+      const patientSensitiveRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(data.patientId)
+        .collection(PATIENT_SENSITIVE_INFO_COLLECTION)
+        .doc(data.patientId);
+      const clinicGroupRef = this.db
+        .collection(CLINIC_GROUPS_COLLECTION)
+        .doc(clinicData.clinicGroupId); // Use clinicData here
+
+      const [
+        practitionerSnap,
+        patientProfileSnap,
+        patientSensitiveSnap,
+        clinicGroupSnap,
+      ] = await Promise.all([
+        // clinicRef.get() is already done via clinicSnap
+        practitionerRef.get(),
+        patientProfileRef.get(),
+        patientSensitiveRef.get(),
+        clinicGroupRef.get(), // Fetch the defined clinicGroupRef
+      ]);
+
+      if (!practitionerSnap.exists)
+        return {
+          success: false,
+          error: `Practitioner ${procedure.practitionerId} not found.`,
+        };
+      if (!patientProfileSnap.exists)
+        return {
+          success: false,
+          error: `PatientProfile ${data.patientId} not found.`,
+        };
+      if (!clinicGroupSnap.exists)
+        return {
+          success: false,
+          error: `ClinicGroup for clinic ${procedure.clinicBranchId} not found.`,
+        };
+
+      const practitionerData = practitionerSnap.data() as Practitioner;
+      const patientProfileData = patientProfileSnap.data() as PatientProfile;
+      const patientSensitiveData = patientSensitiveSnap.exists
+        ? (patientSensitiveSnap.data() as PatientSensitiveInfo)
+        : undefined;
+      const clinicGroupData = clinicGroupSnap.data() as ClinicGroup;
+
+      // --- 4. Determine initialStatus (based on clinic settings) ---
+      const autoConfirm = clinicGroupData.autoConfirmAppointments || false;
+      const initialStatus = autoConfirm
+        ? AppointmentStatus.CONFIRMED
+        : AppointmentStatus.PENDING;
+
+      // --- 5. Aggregate Information (Snapshots) ---
+      const clinicInfo: ClinicInfo = {
+        id: clinicSnap.id,
+        name: clinicData.name,
+        featuredPhoto: clinicData.coverPhoto || clinicData.logo || "",
+        description: clinicData.description,
+        location: clinicData.location,
+        contactInfo: clinicData.contactInfo,
+      };
+      const practitionerInfo: PractitionerProfileInfo = {
+        id: practitionerSnap.id,
+        practitionerPhoto: practitionerData.basicInfo.profileImageUrl || null,
+        name: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
+        email: practitionerData.basicInfo.email,
+        phone: practitionerData.basicInfo.phoneNumber || null,
+        certification: practitionerData.certification,
+      };
+      const patientInfo: PatientProfileInfo = {
+        id: patientProfileSnap.id,
+        fullName:
+          `${patientSensitiveData?.firstName || ""} ${
+            patientSensitiveData?.lastName || ""
+          }`.trim() || patientProfileData.displayName,
+        email: patientSensitiveData?.email || "",
+        phone:
+          patientSensitiveData?.phoneNumber ||
+          patientProfileData.phoneNumber ||
+          null,
+        dateOfBirth:
+          patientSensitiveData?.dateOfBirth ||
+          patientProfileData.dateOfBirth ||
+          admin.firestore.Timestamp.now(),
+        gender: patientSensitiveData?.gender || Gender.OTHER,
+      };
+      const procedureCategory = procedure.category as Category;
+      const procedureSubCategory = procedure.subcategory as Subcategory;
+      const procedureTechnology = procedure.technology as Technology;
+      const procedureProduct = procedure.product as Product;
+
+      const procedureInfo: ProcedureSummaryInfo = {
+        id: procedure.id,
+        name: procedure.name,
+        description: procedure.description,
+        family: procedure.family,
+        categoryName: procedureCategory?.name || "",
+        subcategoryName: procedureSubCategory?.name || "",
+        technologyName: procedureTechnology?.name || "",
+        price: procedure.price,
+        pricingMeasure: procedure.pricingMeasure,
+        currency: procedure.currency,
+        duration: procedure.duration,
+        clinicId: procedure.clinicBranchId,
+        clinicName: clinicData.name,
+        practitionerId: procedure.practitionerId,
+        practitionerName: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
+        photo: procedure.photos?.[0] || "",
+        brandName: procedureProduct?.brandName || "",
+        productName: procedureProduct?.name || "",
+      };
+      const procedureExtendedInfo: ProcedureExtendedInfo = {
+        id: procedure.id,
+        name: procedure.name,
+        description: procedure.description,
+        cost: procedure.price,
+        duration: procedure.duration,
+        procedureFamily: procedure.family,
+        procedureCategoryId: procedureCategory?.id || "",
+        procedureCategoryName: procedureCategory?.name || "",
+        procedureSubCategoryId: procedureSubCategory?.id || "",
+        procedureSubCategoryName: procedureSubCategory?.name || "",
+        procedureTechnologyId: procedureTechnology?.id || "",
+        procedureTechnologyName: procedureTechnology?.name || "",
+        procedureProductBrandId: procedureProduct.brandId || "",
+        procedureProductBrandName: procedureProduct.brandName || "",
+        procedureProductId: procedureProduct.id || "",
+        procedureProductName: procedureProduct.name || "",
+      };
+
+      // --- 6. Determine pendingUserFormsIds and linkedFormIds ---
+      let pendingUserFormsIds: string[] = [];
+      let linkedFormIds: string[] = [];
+      if (
+        procedure.documentationTemplates &&
+        Array.isArray(procedure.documentationTemplates)
+      ) {
+        pendingUserFormsIds = procedure.documentationTemplates
+          .filter(
+            (template: DocumentTemplate) =>
+              template.isUserForm && template.isRequired
+          )
+          .map((template: DocumentTemplate) => template.id);
+        linkedFormIds = procedure.documentationTemplates.map(
+          (template: DocumentTemplate) => template.id
+        );
+      }
+
+      // --- 7. Construct New Appointment Object ---
+      const newAppointmentId = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc().id;
+      const serverTimestampValue = admin.firestore.FieldValue.serverTimestamp();
+      const adminTsNow = admin.firestore.Timestamp.now();
+
+      const newAppointmentData: Appointment = {
+        id: newAppointmentId,
+        calendarEventId: "",
+        clinicBranchId: procedure.clinicBranchId,
+        clinicInfo,
+        practitionerId: procedure.practitionerId,
+        practitionerInfo,
+        patientId: data.patientId,
+        patientInfo,
+        procedureId: data.procedureId,
+        procedureInfo,
+        procedureExtendedInfo,
+        status: initialStatus,
+        bookingTime: serverTimestampValue as any,
+        confirmationTime:
+          initialStatus === AppointmentStatus.CONFIRMED
+            ? (serverTimestampValue as any)
+            : null,
+        appointmentStartTime: new FirebaseClientTimestamp(
+          data.appointmentStartTime.seconds,
+          data.appointmentStartTime.nanoseconds
+        ),
+        appointmentEndTime: new FirebaseClientTimestamp(
+          data.appointmentEndTime.seconds,
+          data.appointmentEndTime.nanoseconds
+        ),
+        cost: procedure.price,
+        currency: procedure.currency,
+        paymentStatus:
+          procedure.price > 0
+            ? PaymentStatus.UNPAID
+            : PaymentStatus.NOT_APPLICABLE,
+        patientNotes: data.patientNotes || null,
+        blockingConditions: procedure.blockingConditions || [],
+        contraindications: procedure.contraindications || [],
+        preProcedureRequirements: procedure.preRequirements || [],
+        postProcedureRequirements: procedure.postRequirements || [],
+        pendingUserFormsIds: pendingUserFormsIds,
+        completedPreRequirements: [],
+        completedPostRequirements: [],
+        linkedFormIds: linkedFormIds,
+        linkedForms: [],
+        media: [],
+        reviewInfo: null,
+        finalizedDetails: undefined,
+        internalNotes: null,
+        cancellationReason: null,
+        cancellationTime: null,
+        canceledBy: undefined,
+        rescheduleTime: null,
+        procedureActualStartTime: null,
+        actualDurationMinutes: undefined,
+        isRecurring: false,
+        recurringAppointmentId: null,
+        isArchived: false,
+        createdAt: serverTimestampValue as any,
+        updatedAt: serverTimestampValue as any,
+      };
+
+      // --- 8. Save New Appointment ---
+      await this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(newAppointmentId)
+        .set(newAppointmentData);
+
+      console.log(
+        `[BookingAdmin] Appointment ${newAppointmentId} created successfully with status ${initialStatus}.`
+      );
+      return {
+        success: true,
+        appointmentId: newAppointmentId,
+        appointmentData: newAppointmentData,
+      };
+    } catch (error) {
+      console.error(
+        "[BookingAdmin] Critical error in orchestrateAppointmentCreation:",
+        error
+      );
+      const errorMessage =
+        error instanceof Error
+          ? error.message
+          : "Unknown server error during appointment creation.";
+      return { success: false, error: errorMessage };
+    }
+  }
 }

package/src/backoffice/types/product.types.ts

@@ -21,7 +21,9 @@ export interface Product {
   id?: string;
   name: string;
   brandId: string;
+  brandName: string;
   technologyId: string;
+  technologyName: string;
   createdAt: Date;
   updatedAt: Date;
   isActive: boolean;