@blackcode_sa/metaestetics-api 1.6.5 → 1.6.6

package/src/admin/booking/README.md

@@ -0,0 +1,125 @@
+## BookingAdmin Service (`Api/src/admin/booking/booking.admin.ts`)
+
+This service is responsible for handling complex booking-related operations on the admin/backend side, intended primarily for use within Firebase Cloud Functions or other trusted server environments.
+
+### Class: `BookingAdmin`
+
+Manages booking availability calculations and the orchestration of appointment creation, including associated calendar events and documentation.
+
+#### Constructor
+
+```typescript
+constructor(firestore?: admin.firestore.Firestore)
+```
+
+- **`firestore`**: An optional `admin.firestore.Firestore` instance. If not provided, it initializes a default Firestore instance.
+- Initializes an instance of `DocumentManagerAdminService` for handling linked document operations.
+
+---
+
+#### Method: `getAvailableBookingSlots`
+
+```typescript
+async getAvailableBookingSlots(
+  clinicId: string,
+  practitionerId: string,
+  procedureId: string,
+  timeframe: { start: Date | admin.firestore.Timestamp; end: Date | admin.firestore.Timestamp; }
+): Promise<{ availableSlots: { start: admin.firestore.Timestamp }[] }>
+```
+
+- Calculates and returns available booking time slots for a specified clinic, practitioner, and procedure within a given timeframe.
+- **Steps Involved**:
+  1.  Fetches data for the clinic, practitioner, and procedure.
+  2.  Retrieves calendar events for both the clinic and the practitioner within the specified timeframe.
+  3.  Converts admin Firestore Timestamps to a client-compatible format for the `BookingAvailabilityCalculator`.
+  4.  Uses `BookingAvailabilityCalculator.calculateSlots()` to determine available slots based on working hours, existing events, and procedure duration.
+  5.  Converts the resulting available slot timestamps back to admin Firestore Timestamps before returning.
+- **Error Handling**: Throws an error if essential entities (clinic, practitioner, procedure) are not found or if any other issue occurs during the calculation.
+
+---
+
+#### Method: `orchestrateAppointmentCreation`
+
+```typescript
+async orchestrateAppointmentCreation(
+  data: OrchestrateAppointmentCreationData, // { patientId, procedureId, appointmentStartTime, appointmentEndTime, patientNotes? }
+  authenticatedUserId: string
+): Promise<{
+  success: boolean;
+  appointmentId?: string;
+  appointmentData?: Appointment;         // The created Appointment object
+  practitionerCalendarEventId?: string; // ID of the practitioner's calendar event
+  patientCalendarEventId?: string;      // ID of the patient's calendar event
+  clinicCalendarEventId?: string;       // ID of the clinic's calendar event
+  error?: string;
+}>
+```
+
+- Orchestrates the comprehensive creation of a new appointment. This is a critical backend process that ensures data integrity and sets up all related entities atomically.
+- **Input Data (`OrchestrateAppointmentCreationData`)**:
+  - `patientId`: ID of the patient for whom the appointment is being booked.
+  - `procedureId`: ID of the procedure.
+  - `appointmentStartTime`: Firestore Timestamp for the start of the appointment.
+  - `appointmentEndTime`: Firestore Timestamp for the end of the appointment.
+  - `patientNotes` (optional): Any notes provided by the patient during booking.
+- **`authenticatedUserId`**: The ID of the user making the request (typically the patient themselves, used for auditing and authorization checks).
+
+- **Core Operations (performed within a single Firestore batch transaction)**:
+
+  1.  **Input Validation**: Checks for required fields and valid timeframes.
+  2.  **Data Fetching**: Retrieves all necessary documents:
+      - `Procedure` (based on `data.procedureId`)
+      - `Clinic` (based on `procedure.clinicBranchId`)
+      - `Practitioner` (based on `procedure.practitionerId`)
+      - `PatientProfile` and `PatientSensitiveInfo` (based on `data.patientId`)
+      - `ClinicGroup` (based on `clinicData.clinicGroupId`)
+  3.  **Information Aggregation**: Creates summarized info objects (`ClinicInfo`, `PractitionerProfileInfo`, `PatientProfileInfo`, `CalendarProcedureInfo`) from the fetched data.
+  4.  **Status Determination**: Calculates the initial status for the appointment (`AppointmentStatus.CONFIRMED` or `PENDING`) and associated calendar events (`CalendarEventStatus.CONFIRMED` or `PENDING`) based on the `clinicGroupData.autoConfirmAppointments` setting.
+  5.  **Calendar Event Creation**: For each of the practitioner, patient, and clinic:
+      - Generates a unique ID for the calendar event.
+      - Constructs the `CalendarEvent` data, including links to the appointment, relevant profiles, procedure details, event times, and status.
+      - Adds a `set` operation to the Firestore batch for creating this calendar event in the respective entity's `calendar` subcollection (e.g., `practitioners/{id}/calendar/{eventId}`).
+  6.  **Documentation Initialization (via `DocumentManagerAdminService`)**:
+      - Calls `this.documentManagerAdmin.batchInitializeAppointmentForms()`.
+      - This service method iterates through the `procedure.documentationTemplates`.
+      - For each template, it creates a `FilledDocument` (in `DRAFT` or `PENDING` status) in the appropriate subcollection of the new appointment (`appointments/{newAppointmentId}/user-forms/{formId}` or `appointments/{newAppointmentId}/doctor-forms/{formId}`).
+      - These creation operations are added to the _same Firestore batch_.
+      - The method returns an object containing:
+        - `initializedFormsInfo: LinkedFormInfo[]`: Detailed info for each initialized form.
+        - `pendingUserFormsIds: string[]`: IDs of required user form templates.
+        - `allLinkedTemplateIds: string[]`: IDs of all templates linked to the procedure.
+  7.  **Appointment Object Construction**: Creates the main `Appointment` data object, populating all its fields, including:
+      - `id`: The newly generated appointment ID.
+      - `calendarEventId`: Linked to the `practitionerCalendarEventId`.
+      - All aggregated info objects.
+      - Timestamps (booking, confirmation, start, end), correctly using `FirebaseClientTimestamp` for client compatibility.
+      - `pendingUserFormsIds` and `linkedFormIds`: Populated from the result of `batchInitializeAppointmentForms`.
+      - `linkedForms`: Populated with the `initializedFormsInfo` array from `batchInitializeAppointmentForms`.
+  8.  **Batch Commit**: Commits all the `set` operations (appointment, 3 calendar events, all filled documents) to Firestore. This ensures atomicity – either all documents are created, or none are.
+
+- **Return Value**: On success, returns an object with `success: true`, the `appointmentId`, the full `appointmentData`, and the IDs of the three created calendar events. On failure, returns `success: false` and an error message.
+
+---
+
+### Helper Methods (Private)
+
+- **`_generateCalendarProcedureInfo(procedure: Procedure): CalendarProcedureInfo`**
+  - Creates a `CalendarProcedureInfo` object from a `Procedure` object, used when constructing `CalendarEvent` data.
+- **`_generateProcedureSummaryInfo(procedure: Procedure, clinicData: Clinic, practitionerData: Practitioner): ProcedureSummaryInfo`**
+  - Creates a `ProcedureSummaryInfo` object, used when constructing the `Appointment` data.
+- **`_generateProcedureExtendedInfo(procedure: Procedure): ProcedureExtendedInfo`**
+  - Creates a `ProcedureExtendedInfo` object, also used for the `Appointment` data.
+- **`getPractitionerCalendarEvents(...)` / `getClinicCalendarEvents(...)`** (example, actual might vary if used by `getAvailableBookingSlots`)
+  - Fetches calendar events for a specific entity within a time range.
+- **Timestamp Conversion Utilities** (example, if present for `getAvailableBookingSlots`)
+  - Handles conversions between admin and client Firestore Timestamp objects.
+
+---
+
+### Dependencies
+
+- **`DocumentManagerAdminService`**: Used to handle the creation and management of `FilledDocument` instances associated with appointments.
+- **Firebase Admin SDK**: For all Firestore interactions.
+- **Various Type Definitions**: From `../../types/` for `Appointment`, `CalendarEvent`, `Procedure`, `Clinic`, `Practitioner`, `Patient`, `DocumentTemplate`, `LinkedFormInfo`, etc.
+- **`BookingAvailabilityCalculator`**: For calculating available booking slots.

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

@@ -37,7 +37,13 @@ import {
   ProcedureExtendedInfo,
 } from "../../types/appointment";
 import { Currency } from "../../backoffice/types/static/pricing.types";
-import { DocumentTemplate } from "../../types/documentation-templates";
+import {
+  DocumentTemplate as AppDocumentTemplate,
+  FilledDocument,
+  FilledDocumentStatus,
+  USER_FORMS_SUBCOLLECTION,
+  DOCTOR_FORMS_SUBCOLLECTION,
+} from "../../types/documentation-templates";
 import {
   ClinicInfo,
   PractitionerProfileInfo,
@@ -47,6 +53,15 @@ 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";
+import {
+  CalendarEvent,
+  CalendarEventTime,
+  CalendarSyncStatus,
+  ProcedureInfo as CalendarProcedureInfo,
+  CALENDAR_COLLECTION,
+} from "../../types/calendar";
+import { DocumentManagerAdminService } from "../documentation-templates/document-manager.admin";
+import { LinkedFormInfo } from "../../types/appointment";
 
 /**
  * Interface for the data required by orchestrateAppointmentCreation
@@ -65,6 +80,7 @@ export interface OrchestrateAppointmentCreationData {
  */
 export class BookingAdmin {
   private db: admin.firestore.Firestore;
+  private documentManagerAdmin: DocumentManagerAdminService;
 
   /**
    * Creates a new BookingAdmin instance
@@ -72,6 +88,7 @@ export class BookingAdmin {
    */
   constructor(firestore?: admin.firestore.Firestore) {
     this.db = firestore || admin.firestore();
+    this.documentManagerAdmin = new DocumentManagerAdminService(this.db);
   }
 
   /**
@@ -281,6 +298,18 @@ export class BookingAdmin {
     }
   }
 
+  private _generateCalendarProcedureInfo(
+    procedure: Procedure
+  ): CalendarProcedureInfo {
+    return {
+      name: procedure.name,
+      description: procedure.description,
+      duration: procedure.duration, // in minutes
+      price: procedure.price,
+      currency: procedure.currency,
+    };
+  }
+
   /**
    * 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).
@@ -296,11 +325,17 @@ export class BookingAdmin {
     success: boolean;
     appointmentId?: string;
     appointmentData?: Appointment;
+    practitionerCalendarEventId?: string;
+    patientCalendarEventId?: string;
+    clinicCalendarEventId?: string;
     error?: string;
   }> {
     console.log(
       `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
     );
+    const batch = this.db.batch();
+    const adminTsNow = admin.firestore.Timestamp.now();
+    const serverTimestampValue = admin.firestore.FieldValue.serverTimestamp();
 
     try {
       // --- 1. Input Validation ---
@@ -412,9 +447,12 @@ export class BookingAdmin {
 
       // --- 4. Determine initialStatus (based on clinic settings) ---
       const autoConfirm = clinicGroupData.autoConfirmAppointments || false;
-      const initialStatus = autoConfirm
+      const initialAppointmentStatus = autoConfirm
         ? AppointmentStatus.CONFIRMED
         : AppointmentStatus.PENDING;
+      const initialCalendarEventStatus = autoConfirm
+        ? CalendarEventStatus.CONFIRMED
+        : CalendarEventStatus.PENDING;
 
       // --- 5. Aggregate Information (Snapshots) ---
       const clinicInfo: ClinicInfo = {
@@ -503,12 +541,12 @@ export class BookingAdmin {
       ) {
         pendingUserFormsIds = procedure.documentationTemplates
           .filter(
-            (template: DocumentTemplate) =>
+            (template: AppDocumentTemplate) =>
               template.isUserForm && template.isRequired
           )
-          .map((template: DocumentTemplate) => template.id);
+          .map((template: AppDocumentTemplate) => template.id);
         linkedFormIds = procedure.documentationTemplates.map(
-          (template: DocumentTemplate) => template.id
+          (template: AppDocumentTemplate) => template.id
         );
       }
 
@@ -516,12 +554,154 @@ export class BookingAdmin {
       const newAppointmentId = this.db
         .collection(APPOINTMENTS_COLLECTION)
         .doc().id;
-      const serverTimestampValue = admin.firestore.FieldValue.serverTimestamp();
-      const adminTsNow = admin.firestore.Timestamp.now();
 
+      const eventTimeForCalendarEvents: CalendarEventTime = {
+        start: new FirebaseClientTimestamp(
+          data.appointmentStartTime.seconds,
+          data.appointmentStartTime.nanoseconds
+        ),
+        end: new FirebaseClientTimestamp(
+          data.appointmentEndTime.seconds,
+          data.appointmentEndTime.nanoseconds
+        ),
+      };
+
+      // Practitioner Calendar Event
+      const practitionerCalendarEventId = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerData.id)
+        .collection(CALENDAR_COLLECTION)
+        .doc().id;
+      const practitionerCalendarEventData: CalendarEvent = {
+        id: practitionerCalendarEventId,
+        appointmentId: newAppointmentId,
+        clinicBranchId: clinicData.id,
+        clinicBranchInfo: clinicInfo,
+        practitionerProfileId: practitionerData.id,
+        practitionerProfileInfo: practitionerInfo,
+        patientProfileId: patientProfileData.id,
+        patientProfileInfo: patientInfo,
+        procedureId: procedure.id,
+        procedureInfo: this._generateCalendarProcedureInfo(procedure),
+        eventName: `Appointment: ${procedure.name} with ${patientInfo.fullName}`,
+        eventLocation: clinicData.location,
+        eventTime: eventTimeForCalendarEvents,
+        description: procedure.description || undefined,
+        status: initialCalendarEventStatus,
+        syncStatus: CalendarSyncStatus.INTERNAL,
+        eventType: CalendarEventType.APPOINTMENT,
+        createdAt: serverTimestampValue as any,
+        updatedAt: serverTimestampValue as any,
+      };
+      batch.set(
+        this.db
+          .collection(PRACTITIONERS_COLLECTION)
+          .doc(practitionerData.id)
+          .collection(CALENDAR_COLLECTION)
+          .doc(practitionerCalendarEventId),
+        practitionerCalendarEventData
+      );
+
+      // Patient Calendar Event
+      const patientCalendarEventId = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(patientProfileData.id)
+        .collection(CALENDAR_COLLECTION)
+        .doc().id;
+      const patientCalendarEventData: CalendarEvent = {
+        id: patientCalendarEventId,
+        appointmentId: newAppointmentId,
+        clinicBranchId: clinicData.id,
+        clinicBranchInfo: clinicInfo,
+        practitionerProfileId: practitionerData.id,
+        practitionerProfileInfo: practitionerInfo,
+        procedureId: procedure.id,
+        procedureInfo: this._generateCalendarProcedureInfo(procedure),
+        eventName: `Appointment: ${procedure.name} at ${clinicData.name}`,
+        eventLocation: clinicData.location,
+        eventTime: eventTimeForCalendarEvents,
+        description: data.patientNotes || undefined,
+        status: initialCalendarEventStatus,
+        syncStatus: CalendarSyncStatus.INTERNAL,
+        eventType: CalendarEventType.APPOINTMENT,
+        createdAt: serverTimestampValue as any,
+        updatedAt: serverTimestampValue as any,
+      };
+      batch.set(
+        this.db
+          .collection(PATIENTS_COLLECTION)
+          .doc(patientProfileData.id)
+          .collection(CALENDAR_COLLECTION)
+          .doc(patientCalendarEventId),
+        patientCalendarEventData
+      );
+
+      // Clinic Calendar Event
+      const clinicCalendarEventId = this.db
+        .collection(CLINICS_COLLECTION)
+        .doc(clinicData.id)
+        .collection(CALENDAR_COLLECTION)
+        .doc().id;
+      const clinicCalendarEventData: CalendarEvent = {
+        id: clinicCalendarEventId,
+        appointmentId: newAppointmentId,
+        clinicBranchId: clinicData.id,
+        clinicBranchInfo: clinicInfo,
+        practitionerProfileId: practitionerData.id,
+        practitionerProfileInfo: practitionerInfo,
+        patientProfileId: patientProfileData.id,
+        patientProfileInfo: patientInfo,
+        procedureId: procedure.id,
+        procedureInfo: this._generateCalendarProcedureInfo(procedure),
+        eventName: `Appointment: ${procedure.name} for ${patientInfo.fullName} with ${practitionerInfo.name}`,
+        eventLocation: clinicData.location,
+        eventTime: eventTimeForCalendarEvents,
+        description: data.patientNotes || undefined,
+        status: initialCalendarEventStatus,
+        syncStatus: CalendarSyncStatus.INTERNAL,
+        eventType: CalendarEventType.APPOINTMENT,
+        createdAt: serverTimestampValue as any,
+        updatedAt: serverTimestampValue as any,
+      };
+      batch.set(
+        this.db
+          .collection(CLINICS_COLLECTION)
+          .doc(clinicData.id)
+          .collection(CALENDAR_COLLECTION)
+          .doc(clinicCalendarEventId),
+        clinicCalendarEventData
+      );
+
+      // --- Initialize Pending/Draft Filled Documents and get form IDs ---
+      let initializedFormsInfo: LinkedFormInfo[] = [];
+      let pendingUserFormTemplateIds: string[] = [];
+      let allLinkedFormTemplateIds: string[] = [];
+
+      if (
+        procedure.documentationTemplates &&
+        Array.isArray(procedure.documentationTemplates) &&
+        procedure.documentationTemplates.length > 0
+      ) {
+        const formInitResult =
+          this.documentManagerAdmin.batchInitializeAppointmentForms(
+            batch,
+            newAppointmentId,
+            procedure.id, // Pass the actual procedureId for the forms
+            procedure.documentationTemplates as AppDocumentTemplate[],
+            data.patientId,
+            procedure.practitionerId,
+            procedure.clinicBranchId,
+            adminTsNow.toMillis()
+          );
+        initializedFormsInfo = formInitResult.initializedFormsInfo;
+        pendingUserFormTemplateIds = formInitResult.pendingUserFormsIds;
+        allLinkedFormTemplateIds = formInitResult.allLinkedTemplateIds;
+      }
+
+      // --- Construct Appointment Object ---
       const newAppointmentData: Appointment = {
         id: newAppointmentId,
-        calendarEventId: "",
+        calendarEventId: practitionerCalendarEventId,
         clinicBranchId: procedure.clinicBranchId,
         clinicInfo,
         practitionerId: procedure.practitionerId,
@@ -529,13 +709,23 @@ export class BookingAdmin {
         patientId: data.patientId,
         patientInfo,
         procedureId: data.procedureId,
-        procedureInfo,
-        procedureExtendedInfo,
-        status: initialStatus,
-        bookingTime: serverTimestampValue as any,
+        procedureInfo: this._generateProcedureSummaryInfo(
+          procedure,
+          clinicData,
+          practitionerData
+        ),
+        procedureExtendedInfo: this._generateProcedureExtendedInfo(procedure),
+        status: initialAppointmentStatus,
+        bookingTime: new FirebaseClientTimestamp(
+          adminTsNow.seconds,
+          adminTsNow.nanoseconds
+        ),
         confirmationTime:
-          initialStatus === AppointmentStatus.CONFIRMED
-            ? (serverTimestampValue as any)
+          initialAppointmentStatus === AppointmentStatus.CONFIRMED
+            ? new FirebaseClientTimestamp(
+                adminTsNow.seconds,
+                adminTsNow.nanoseconds
+              )
             : null,
         appointmentStartTime: new FirebaseClientTimestamp(
           data.appointmentStartTime.seconds,
@@ -553,14 +743,14 @@ export class BookingAdmin {
             : PaymentStatus.NOT_APPLICABLE,
         patientNotes: data.patientNotes || null,
         blockingConditions: procedure.blockingConditions || [],
-        contraindications: procedure.contraindications || [],
+        contraindications: (procedure as any).contraindications || [],
         preProcedureRequirements: procedure.preRequirements || [],
         postProcedureRequirements: procedure.postRequirements || [],
-        pendingUserFormsIds: pendingUserFormsIds,
+        pendingUserFormsIds: pendingUserFormTemplateIds,
+        linkedFormIds: allLinkedFormTemplateIds,
         completedPreRequirements: [],
         completedPostRequirements: [],
-        linkedFormIds: linkedFormIds,
-        linkedForms: [],
+        linkedForms: initializedFormsInfo,
         media: [],
         reviewInfo: null,
         finalizedDetails: undefined,
@@ -574,23 +764,34 @@ export class BookingAdmin {
         isRecurring: false,
         recurringAppointmentId: null,
         isArchived: false,
-        createdAt: serverTimestampValue as any,
-        updatedAt: serverTimestampValue as any,
+        createdAt: new FirebaseClientTimestamp(
+          adminTsNow.seconds,
+          adminTsNow.nanoseconds
+        ),
+        updatedAt: new FirebaseClientTimestamp(
+          adminTsNow.seconds,
+          adminTsNow.nanoseconds
+        ),
       };
 
-      // --- 8. Save New Appointment ---
-      await this.db
-        .collection(APPOINTMENTS_COLLECTION)
-        .doc(newAppointmentId)
-        .set(newAppointmentData);
+      batch.set(
+        this.db.collection(APPOINTMENTS_COLLECTION).doc(newAppointmentId),
+        newAppointmentData
+      );
+
+      // Commit Batch
+      await batch.commit();
 
       console.log(
-        `[BookingAdmin] Appointment ${newAppointmentId} created successfully with status ${initialStatus}.`
+        `[BookingAdmin] Appointment ${newAppointmentId} and associated calendar events created successfully.`
       );
       return {
         success: true,
         appointmentId: newAppointmentId,
         appointmentData: newAppointmentData,
+        practitionerCalendarEventId,
+        patientCalendarEventId,
+        clinicCalendarEventId,
       };
     } catch (error) {
       console.error(
@@ -604,4 +805,65 @@ export class BookingAdmin {
       return { success: false, error: errorMessage };
     }
   }
+
+  private _generateProcedureSummaryInfo(
+    procedure: Procedure,
+    clinicData: Clinic,
+    practitionerData: Practitioner
+  ): ProcedureSummaryInfo {
+    const procedureCategory = procedure.category as Category;
+    const procedureSubCategory = procedure.subcategory as Subcategory;
+    const procedureTechnology = procedure.technology as Technology;
+    const procedureProduct = procedure.product as Product;
+    return {
+      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:
+        (procedureTechnology as any)?.photos?.[0]?.url ||
+        (procedureProduct as any)?.photos?.[0]?.url ||
+        "",
+      brandName: (procedureProduct as any)?.brand?.name || "",
+      productName: procedureProduct?.name || "",
+    };
+  }
+
+  private _generateProcedureExtendedInfo(
+    procedure: Procedure
+  ): ProcedureExtendedInfo {
+    const procedureCategory = procedure.category as Category;
+    const procedureSubCategory = procedure.subcategory as Subcategory;
+    const procedureTechnology = procedure.technology as Technology;
+    const procedureProduct = procedure.product as Product;
+    return {
+      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 as any)?.brand?.id || "",
+      procedureProductBrandName: (procedureProduct as any)?.brand?.name || "",
+      procedureProductId: procedureProduct?.id || "",
+      procedureProductName: procedureProduct?.name || "",
+    };
+  }
 }