@blackcode_sa/metaestetics-api 1.5.28 → 1.5.29

package/src/services/procedure/procedure.service.ts

@@ -12,6 +12,10 @@ import {
   serverTimestamp,
   DocumentData,
   writeBatch,
+  arrayUnion,
+  arrayRemove,
+  FieldValue,
+  orderBy,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -19,6 +23,7 @@ import {
   CreateProcedureData,
   UpdateProcedureData,
   PROCEDURES_COLLECTION,
+  ProcedureSummaryInfo,
 } from "../../types/procedure";
 import {
   createProcedureSchema,
@@ -57,7 +62,8 @@ import {
   CertificationSpecialty,
   ProcedureFamily,
 } from "../../backoffice/types";
-import { CLINICS_COLLECTION } from "../../types/clinic";
+import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
+import { ProcedureReviewInfo } from "../../types/reviews";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -81,16 +87,150 @@ export class ProcedureService extends BaseService {
     this.productService = productService;
   }
 
+  // Helper function to create ProcedureSummaryInfo
+  private _createProcedureSummaryInfo(
+    procedure: Procedure
+  ): ProcedureSummaryInfo {
+    // Ensure nested objects and names exist before accessing them
+    const categoryName = procedure.category?.name || "N/A";
+    const subcategoryName = procedure.subcategory?.name || "N/A";
+    const technologyName = procedure.technology?.name || "N/A";
+    const clinicName = procedure.clinicInfo?.name || "N/A";
+    const practitionerName = procedure.doctorInfo?.name || "N/A";
+
+    return {
+      id: procedure.id,
+      name: procedure.name,
+      description: procedure.description || "",
+      photo: "", // No photo source identified yet
+      family: procedure.family,
+      categoryName: categoryName,
+      subcategoryName: subcategoryName,
+      technologyName: technologyName,
+      price: procedure.price,
+      pricingMeasure: procedure.pricingMeasure,
+      currency: procedure.currency,
+      duration: procedure.duration,
+      clinicId: procedure.clinicBranchId,
+      clinicName: clinicName,
+      practitionerId: procedure.practitionerId,
+      practitionerName: practitionerName,
+    };
+  }
+
+  // Helper to update practitioner's procedures
+  private async _updatePractitionerProcedures(
+    practitionerId: string,
+    procedureSummary: ProcedureSummaryInfo | null, // Null means remove
+    procedureIdToRemove?: string
+  ) {
+    const practitionerRef = doc(
+      this.db,
+      PRACTITIONERS_COLLECTION,
+      practitionerId
+    );
+    const updateData: { [key: string]: FieldValue } = {};
+
+    if (procedureSummary) {
+      // Add/Update
+      updateData["procedures"] = arrayUnion(procedureSummary.id);
+      // Remove old summary first (by ID) then add new one to ensure update
+      updateData["proceduresInfo"] = arrayRemove(
+        ...[
+          // Need to spread the arrayRemove arguments
+          // Create a 'matcher' object with only the ID for removal
+          { id: procedureSummary.id },
+        ]
+      );
+      // We'll add the new summary in a separate update to avoid conflicts if needed, or rely on a subsequent transaction/batch commit
+    } else if (procedureIdToRemove) {
+      // Remove
+      updateData["procedures"] = arrayRemove(procedureIdToRemove);
+      updateData["proceduresInfo"] = arrayRemove(
+        ...[{ id: procedureIdToRemove }] // Use matcher for removal
+      );
+    } else {
+      return; // No operation needed
+    }
+
+    updateData["updatedAt"] = serverTimestamp();
+
+    // Perform the update
+    const batch = writeBatch(this.db);
+    batch.update(practitionerRef, updateData);
+
+    // If adding/updating, add the new summary info after removing the old one
+    if (procedureSummary) {
+      batch.update(practitionerRef, {
+        proceduresInfo: arrayUnion(procedureSummary),
+      });
+    }
+
+    await batch.commit();
+  }
+
+  // Helper to update clinic's procedures
+  private async _updateClinicProcedures(
+    clinicId: string,
+    procedureSummary: ProcedureSummaryInfo | null, // Null means remove
+    procedureIdToRemove?: string
+  ) {
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+
+    // Check if clinic exists before attempting update
+    const clinicSnap = await getDoc(clinicRef);
+    if (!clinicSnap.exists()) {
+      console.warn(
+        `Clinic ${clinicId} not found, skipping procedure aggregation update.`
+      );
+      return;
+    }
+
+    const updateData: { [key: string]: FieldValue } = {};
+
+    if (procedureSummary) {
+      // Add/Update - Using arrayUnion for simplicity, assuming procedure IDs are unique in services array too
+      // Note: 'services' array might be deprecated or used differently now
+      updateData["services"] = arrayUnion(procedureSummary.id);
+      // Remove old summary first (by ID) then add new one to ensure update
+      updateData["proceduresInfo"] = arrayRemove(
+        ...[{ id: procedureSummary.id }] // Use matcher for removal
+      );
+    } else if (procedureIdToRemove) {
+      // Remove
+      updateData["services"] = arrayRemove(procedureIdToRemove);
+      updateData["proceduresInfo"] = arrayRemove(
+        ...[{ id: procedureIdToRemove }] // Use matcher for removal
+      );
+    } else {
+      return; // No operation needed
+    }
+
+    updateData["updatedAt"] = serverTimestamp();
+
+    // Perform the update
+    const batch = writeBatch(this.db);
+    batch.update(clinicRef, updateData);
+
+    // If adding/updating, add the new summary info after removing the old one
+    if (procedureSummary) {
+      batch.update(clinicRef, {
+        proceduresInfo: arrayUnion(procedureSummary),
+      });
+    }
+
+    await batch.commit();
+  }
+
   /**
-   * Creates a new procedure
+   * Creates a new procedure and updates related practitioner/clinic aggregates
    * @param data - The data for creating a new procedure
    * @returns The created procedure
    */
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
-    // Validate input data
     const validatedData = createProcedureSchema.parse(data);
 
-    // Get references to related entities
+    // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(
@@ -105,75 +245,66 @@ export class ProcedureService extends BaseService {
     ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required entities not found");
+      throw new Error("One or more required base entities not found");
     }
 
-    // Get clinic and practitioner information
+    // Get clinic and practitioner information for aggregation
     const clinicRef = doc(
       this.db,
       CLINICS_COLLECTION,
       validatedData.clinicBranchId
     );
     const clinicSnapshot = await getDoc(clinicRef);
-
     if (!clinicSnapshot.exists()) {
       throw new Error(
         `Clinic with ID ${validatedData.clinicBranchId} not found`
       );
     }
+    const clinic = clinicSnapshot.data() as Clinic; // Assert type
 
-    const clinic = clinicSnapshot.data();
-
-    // Create clinic info
-    const clinicInfo = {
-      id: clinicSnapshot.id,
-      name: clinic.name,
-      description: clinic.description || "",
-      featuredPhoto:
-        clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? clinic.featuredPhotos[0]
-          : clinic.coverPhoto || "",
-      location: clinic.location,
-      contactInfo: clinic.contactInfo,
-    };
-
-    // Get practitioner information
     const practitionerRef = doc(
       this.db,
       PRACTITIONERS_COLLECTION,
       validatedData.practitionerId
     );
     const practitionerSnapshot = await getDoc(practitionerRef);
-
     if (!practitionerSnapshot.exists()) {
       throw new Error(
         `Practitioner with ID ${validatedData.practitionerId} not found`
       );
     }
+    const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
-    const practitioner = practitionerSnapshot.data();
-
-    // Find doctor info in clinic's doctorsInfo array
-    let doctorInfo = clinic.doctorsInfo?.find(
-      (doctor: any) => doctor.id === validatedData.practitionerId
-    );
+    // Create aggregated clinic info for the procedure document
+    const clinicInfo = {
+      id: clinicSnapshot.id,
+      name: clinic.name,
+      description: clinic.description || "",
+      featuredPhoto:
+        clinic.featuredPhotos && clinic.featuredPhotos.length > 0
+          ? clinic.featuredPhotos[0]
+          : clinic.coverPhoto || "",
+      location: clinic.location,
+      contactInfo: clinic.contactInfo,
+    };
 
-    // If not found, create basic doctor info
-    if (!doctorInfo) {
-      doctorInfo = {
-        id: practitionerSnapshot.id,
-        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-        description: practitioner.basicInfo.bio || "",
-        photo: practitioner.basicInfo.profileImageUrl || "",
-        rating: 0,
-        services: [],
-      };
-    }
+    // Create aggregated doctor info for the procedure document
+    // Re-use logic from previous implementation or simplify
+    const doctorInfo = {
+      id: practitionerSnapshot.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || "",
+      photo: practitioner.basicInfo.profileImageUrl || "",
+      rating: practitioner.reviewInfo?.averageRating || 0, // Example rating source
+      services: practitioner.procedures || [], // Link services to practitioner's procedures
+    };
 
     // Create the procedure object
-    const procedure: Omit<Procedure, "id"> = {
+    const procedureId = this.generateId();
+    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+      id: procedureId,
       ...validatedData,
-      category,
+      category, // Embed full objects
       subcategory,
       technology,
       product,
@@ -183,24 +314,67 @@ export class ProcedureService extends BaseService {
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
       documentationTemplates: technology.documentationTemplates || [],
-      clinicInfo,
-      doctorInfo,
-      isActive: true,
-      createdAt: new Date(),
-      updatedAt: new Date(),
+      clinicInfo, // Embed aggregated info
+      doctorInfo, // Embed aggregated info
+      reviewInfo: {
+        // Default empty reviews
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      },
+      isActive: true, // Default to active
     };
 
-    // Generate ID and create document
-    const id = this.generateId();
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await setDoc(docRef, {
-      ...procedure,
-      id,
+    // --- Transaction/Batch Start ---
+    const batch = writeBatch(this.db);
+
+    // 1. Create the procedure document
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
+    batch.set(procedureRef, {
+      ...newProcedure,
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp(),
     });
 
-    return { ...procedure, id } as Procedure;
+    // 2. Create the summary object AFTER the main object is defined
+    const procedureSummary = this._createProcedureSummaryInfo({
+      ...newProcedure,
+      createdAt: new Date(), // Use placeholder date for summary creation
+      updatedAt: new Date(),
+    });
+
+    // 3. Update Practitioner
+    const practitionerUpdateData: { [key: string]: FieldValue } = {
+      procedures: arrayUnion(procedureId),
+      proceduresInfo: arrayUnion(procedureSummary),
+      updatedAt: serverTimestamp(),
+    };
+    batch.update(practitionerRef, practitionerUpdateData);
+
+    // 4. Update Clinic
+    const clinicUpdateData: { [key: string]: FieldValue } = {
+      // services: arrayUnion(procedureId), // Decide if 'services' array is still needed
+      proceduresInfo: arrayUnion(procedureSummary),
+      // Potentially update clinic.doctors array if not already present
+      doctors: arrayUnion(validatedData.practitionerId),
+      // Potentially update clinic.doctorsInfo array
+      // This requires fetching existing doctorsInfo and adding/updating
+      // For simplicity now, we'll just add the procedure summary
+      updatedAt: serverTimestamp(),
+    };
+    batch.update(clinicRef, clinicUpdateData);
+
+    // --- Transaction/Batch Commit ---
+    await batch.commit();
+
+    // Return the created procedure (fetch again to get server timestamps)
+    const savedDoc = await getDoc(procedureRef);
+    return savedDoc.data() as Procedure;
   }
 
   /**
@@ -254,73 +428,394 @@ export class ProcedureService extends BaseService {
   }
 
   /**
-   * Updates a procedure
+   * Updates a procedure and its related aggregates in Practitioner and Clinic docs
    * @param id - The ID of the procedure to update
-   * @param data - The data to update
+   * @param data - The data to update the procedure with
    * @returns The updated procedure
    */
   async updateProcedure(
     id: string,
     data: UpdateProcedureData
   ): Promise<Procedure> {
-    // Validate input data
     const validatedData = updateProcedureSchema.parse(data);
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc(procedureRef);
 
-    // Get the existing procedure
-    const existingProcedure = await this.getProcedure(id);
-    if (!existingProcedure) {
+    if (!procedureSnapshot.exists()) {
       throw new Error(`Procedure with ID ${id} not found`);
     }
 
-    // Update the procedure
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await updateDoc(docRef, {
-      ...validatedData,
+    const existingProcedure = procedureSnapshot.data() as Procedure;
+    let updatedProcedureData: Partial<Procedure> = { ...validatedData };
+
+    let practitionerChanged = false;
+    let clinicChanged = false;
+    const oldPractitionerId = existingProcedure.practitionerId;
+    const oldClinicId = existingProcedure.clinicBranchId;
+    let newPractitioner: Practitioner | null = null;
+    let newClinic: Clinic | null = null;
+
+    // --- Prepare updates and fetch new related data if IDs change ---
+
+    // Handle Practitioner Change
+    if (
+      validatedData.practitionerId &&
+      validatedData.practitionerId !== oldPractitionerId
+    ) {
+      practitionerChanged = true;
+      const newPractitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        validatedData.practitionerId
+      );
+      const newPractitionerSnap = await getDoc(newPractitionerRef);
+      if (!newPractitionerSnap.exists())
+        throw new Error(
+          `New Practitioner ${validatedData.practitionerId} not found`
+        );
+      newPractitioner = newPractitionerSnap.data() as Practitioner;
+      // Update doctorInfo within the procedure document
+      updatedProcedureData.doctorInfo = {
+        id: newPractitioner.id,
+        name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
+        description: newPractitioner.basicInfo.bio || "",
+        photo: newPractitioner.basicInfo.profileImageUrl || "",
+        rating: newPractitioner.reviewInfo?.averageRating || 0,
+        services: newPractitioner.procedures || [],
+      };
+    }
+
+    // Handle Clinic Change
+    if (
+      validatedData.clinicBranchId &&
+      validatedData.clinicBranchId !== oldClinicId
+    ) {
+      clinicChanged = true;
+      const newClinicRef = doc(
+        this.db,
+        CLINICS_COLLECTION,
+        validatedData.clinicBranchId
+      );
+      const newClinicSnap = await getDoc(newClinicRef);
+      if (!newClinicSnap.exists())
+        throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
+      newClinic = newClinicSnap.data() as Clinic;
+      // Update clinicInfo within the procedure document
+      updatedProcedureData.clinicInfo = {
+        id: newClinic.id,
+        name: newClinic.name,
+        description: newClinic.description || "",
+        featuredPhoto:
+          newClinic.featuredPhotos && newClinic.featuredPhotos.length > 0
+            ? newClinic.featuredPhotos[0]
+            : newClinic.coverPhoto || "",
+        location: newClinic.location,
+        contactInfo: newClinic.contactInfo,
+      };
+    }
+
+    // Handle Category/Subcategory/Technology/Product Changes
+    let finalCategoryId = existingProcedure.category.id;
+    if (validatedData.categoryId) {
+      const category = await this.categoryService.getById(
+        validatedData.categoryId
+      );
+      if (!category)
+        throw new Error(`Category ${validatedData.categoryId} not found`);
+      updatedProcedureData.category = category;
+      finalCategoryId = category.id; // Update finalCategoryId if category changed
+    }
+
+    // Only fetch subcategory if its ID is provided AND we have a valid finalCategoryId
+    if (validatedData.subcategoryId && finalCategoryId) {
+      const subcategory = await this.subcategoryService.getById(
+        finalCategoryId,
+        validatedData.subcategoryId
+      );
+      if (!subcategory)
+        throw new Error(
+          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`
+        );
+      updatedProcedureData.subcategory = subcategory;
+    } else if (validatedData.subcategoryId) {
+      console.warn(
+        "Attempted to update subcategory without a valid categoryId"
+      );
+    }
+
+    let finalTechnologyId = existingProcedure.technology.id;
+    if (validatedData.technologyId) {
+      const technology = await this.technologyService.getById(
+        validatedData.technologyId
+      );
+      if (!technology)
+        throw new Error(`Technology ${validatedData.technologyId} not found`);
+      updatedProcedureData.technology = technology;
+      finalTechnologyId = technology.id; // Update finalTechnologyId if technology changed
+      // Update related fields derived from technology
+      updatedProcedureData.blockingConditions = technology.blockingConditions;
+      updatedProcedureData.treatmentBenefits = technology.benefits;
+      updatedProcedureData.preRequirements = technology.requirements.pre;
+      updatedProcedureData.postRequirements = technology.requirements.post;
+      updatedProcedureData.certificationRequirement =
+        technology.certificationRequirement;
+      updatedProcedureData.documentationTemplates =
+        technology.documentationTemplates || [];
+    }
+
+    // Only fetch product if its ID is provided AND we have a valid finalTechnologyId
+    if (validatedData.productId && finalTechnologyId) {
+      const product = await this.productService.getById(
+        finalTechnologyId,
+        validatedData.productId
+      );
+      if (!product)
+        throw new Error(
+          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`
+        );
+      updatedProcedureData.product = product;
+    } else if (validatedData.productId) {
+      console.warn("Attempted to update product without a valid technologyId");
+    }
+
+    // --- Perform updates using a batch ---
+    const batch = writeBatch(this.db);
+
+    // 1. Update the main procedure document
+    batch.update(procedureRef, {
+      ...updatedProcedureData,
       updatedAt: serverTimestamp(),
     });
 
-    // Return the updated procedure with combined data
-    // Note: Since we're not changing the clinicInfo or doctorInfo in this update,
-    // we just keep the existing values from the procedure
-    return {
+    // 2. Create the updated summary info object
+    // We need the final state of the procedure for the summary
+    const finalProcedureStateForSummary = {
       ...existingProcedure,
-      ...validatedData,
-      updatedAt: new Date(),
-    };
+      ...updatedProcedureData, // Apply updates
+      // Ensure nested objects needed for summary are present
+      category: updatedProcedureData.category || existingProcedure.category,
+      subcategory:
+        updatedProcedureData.subcategory || existingProcedure.subcategory,
+      technology:
+        updatedProcedureData.technology || existingProcedure.technology,
+      product: updatedProcedureData.product || existingProcedure.product,
+      clinicInfo:
+        updatedProcedureData.clinicInfo || existingProcedure.clinicInfo,
+      doctorInfo:
+        updatedProcedureData.doctorInfo || existingProcedure.doctorInfo,
+      practitionerId:
+        validatedData.practitionerId || existingProcedure.practitionerId, // Use potentially updated IDs
+      clinicBranchId:
+        validatedData.clinicBranchId || existingProcedure.clinicBranchId,
+    } as Procedure; // Cast because we're merging potentially partial data
+
+    const updatedProcedureSummary = this._createProcedureSummaryInfo(
+      finalProcedureStateForSummary
+    );
+
+    // 3. Update Practitioner(s)
+    if (practitionerChanged) {
+      // Remove from old practitioner
+      const oldPractitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        oldPractitionerId
+      );
+      batch.update(oldPractitionerRef, {
+        procedures: arrayRemove(id),
+        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+        updatedAt: serverTimestamp(),
+      });
+      // Add to new practitioner
+      const newPractitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        updatedProcedureSummary.practitionerId
+      );
+      batch.update(newPractitionerRef, {
+        procedures: arrayUnion(id),
+        proceduresInfo: arrayUnion(updatedProcedureSummary),
+        updatedAt: serverTimestamp(),
+      });
+    } else {
+      // Update in place for the current practitioner
+      const currentPractitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        oldPractitionerId
+      );
+      // Remove old first
+      batch.update(currentPractitionerRef, {
+        proceduresInfo: arrayRemove(...[{ id: id }]),
+        updatedAt: serverTimestamp(),
+      });
+      // Add updated
+      batch.update(currentPractitionerRef, {
+        proceduresInfo: arrayUnion(updatedProcedureSummary),
+        updatedAt: serverTimestamp(),
+      });
+    }
+
+    // 4. Update Clinic(s)
+    if (clinicChanged) {
+      // Remove from old clinic
+      const oldClinicRef = doc(this.db, CLINICS_COLLECTION, oldClinicId);
+      batch.update(oldClinicRef, {
+        // services: arrayRemove(id),
+        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+        updatedAt: serverTimestamp(),
+        // Potentially remove from clinic.doctors and clinic.doctorsInfo if practitioner also changed or was last one for this clinic
+      });
+      // Add to new clinic
+      const newClinicRef = doc(
+        this.db,
+        CLINICS_COLLECTION,
+        updatedProcedureSummary.clinicId
+      );
+      batch.update(newClinicRef, {
+        // services: arrayUnion(id),
+        proceduresInfo: arrayUnion(updatedProcedureSummary),
+        doctors: arrayUnion(updatedProcedureSummary.practitionerId), // Ensure practitioner is listed
+        updatedAt: serverTimestamp(),
+      });
+    } else {
+      // Update in place for the current clinic
+      const currentClinicRef = doc(this.db, CLINICS_COLLECTION, oldClinicId);
+      // Remove old first
+      batch.update(currentClinicRef, {
+        proceduresInfo: arrayRemove(...[{ id: id }]),
+        updatedAt: serverTimestamp(),
+      });
+      // Add updated
+      batch.update(currentClinicRef, {
+        proceduresInfo: arrayUnion(updatedProcedureSummary),
+        updatedAt: serverTimestamp(),
+      });
+    }
+
+    // --- Commit Batch ---
+    await batch.commit();
+
+    // Return the updated procedure
+    const updatedSnapshot = await getDoc(procedureRef);
+    return updatedSnapshot.data() as Procedure;
   }
 
   /**
-   * Deactivates a procedure
+   * Deactivates a procedure (soft delete) and updates aggregates
    * @param id - The ID of the procedure to deactivate
    */
   async deactivateProcedure(id: string): Promise<void> {
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await updateDoc(docRef, {
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnap = await getDoc(procedureRef);
+    if (!procedureSnap.exists()) {
+      console.warn(`Procedure ${id} not found for deactivation.`);
+      return;
+    }
+    const procedure = procedureSnap.data() as Procedure;
+
+    // We treat deactivation like a deletion for the aggregated lists
+    // Alternatively, keep inactive procedures but filter them client-side
+
+    // --- Perform updates using a batch ---
+    const batch = writeBatch(this.db);
+
+    // 1. Mark procedure as inactive
+    batch.update(procedureRef, {
       isActive: false,
       updatedAt: serverTimestamp(),
     });
+
+    // 2. Remove from Practitioner aggregates
+    const practitionerRef = doc(
+      this.db,
+      PRACTITIONERS_COLLECTION,
+      procedure.practitionerId
+    );
+    batch.update(practitionerRef, {
+      procedures: arrayRemove(id),
+      proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+      updatedAt: serverTimestamp(),
+    });
+
+    // 3. Remove from Clinic aggregates
+    const clinicRef = doc(
+      this.db,
+      CLINICS_COLLECTION,
+      procedure.clinicBranchId
+    );
+    batch.update(clinicRef, {
+      // services: arrayRemove(id),
+      proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+      updatedAt: serverTimestamp(),
+      // Potentially update clinic.doctors/doctorsInfo if this was the last active procedure for this doctor at this clinic
+    });
+
+    // --- Commit Batch ---
+    await batch.commit();
+  }
+
+  /**
+   * Deletes a procedure permanently and updates related aggregates
+   * @param id - The ID of the procedure to delete
+   * @returns A boolean indicating if the deletion was successful
+   */
+  async deleteProcedure(id: string): Promise<boolean> {
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc(procedureRef);
+
+    if (!procedureSnapshot.exists()) {
+      // Already deleted or never existed
+      return false;
+    }
+
+    const procedure = procedureSnapshot.data() as Procedure;
+
+    // --- Perform updates using a batch ---
+    const batch = writeBatch(this.db);
+
+    // 1. Remove from Practitioner aggregates
+    if (procedure.practitionerId) {
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        procedure.practitionerId
+      );
+      batch.update(practitionerRef, {
+        procedures: arrayRemove(id),
+        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+        updatedAt: serverTimestamp(),
+      });
+    }
+
+    // 2. Remove from Clinic aggregates
+    if (procedure.clinicBranchId) {
+      const clinicRef = doc(
+        this.db,
+        CLINICS_COLLECTION,
+        procedure.clinicBranchId
+      );
+      batch.update(clinicRef, {
+        // services: arrayRemove(id),
+        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
+        updatedAt: serverTimestamp(),
+        // Potentially update clinic.doctors/doctorsInfo
+      });
+    }
+
+    // 3. Delete the procedure document itself
+    batch.delete(procedureRef);
+
+    // --- Commit Batch ---
+    await batch.commit();
+
+    return true;
   }
 
   /**
    * Gets all procedures that a practitioner is certified to perform
    * @param practitioner - The practitioner's profile
-   * @returns Object containing:
-   * - procedures: List of procedures the practitioner can perform
-   * - families: List of procedure families the practitioner can perform
-   * - categories: List of category IDs the practitioner can perform
-   * - subcategories: List of subcategory IDs the practitioner can perform
-   *
-   * @example
-   * const practitioner = {
-   *   certification: {
-   *     level: CertificationLevel.DOCTOR,
-   *     specialties: [CertificationSpecialty.INJECTABLES]
-   *   }
-   * };
-   * const allowedProcedures = await procedureService.getAllowedProcedures(practitioner);
-   * console.log(allowedProcedures.families); // [ProcedureFamily.AESTHETICS]
-   * console.log(allowedProcedures.categories); // ["category1", "category2"]
-   * console.log(allowedProcedures.subcategories); // ["subcategory1", "subcategory2"]
+   * @returns Object containing allowed technologies, families, categories, subcategories
    */
   async getAllowedTechnologies(practitioner: Practitioner): Promise<{
     technologies: Technology[];
@@ -328,7 +823,7 @@ export class ProcedureService extends BaseService {
     categories: string[];
     subcategories: string[];
   }> {
-    // Get all allowed technologies for the practitioner
+    // This logic depends on TechnologyService and remains valid
     const { technologies, families, categories, subcategories } =
       await this.technologyService.getAllowedTechnologies(practitioner);
 
@@ -355,19 +850,26 @@ export class ProcedureService extends BaseService {
       const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = query(proceduresCollection);
 
-      // If pagination is specified and greater than 0, limit the query
+      // Apply pagination if specified
       if (pagination && pagination > 0) {
-        const { limit, startAfter } = require("firebase/firestore");
+        const { limit, startAfter } = await import("firebase/firestore"); // Use dynamic import if needed top-level
 
         if (lastDoc) {
           proceduresQuery = query(
             proceduresCollection,
+            orderBy("name"), // Use imported orderBy
             startAfter(lastDoc),
             limit(pagination)
           );
         } else {
-          proceduresQuery = query(proceduresCollection, limit(pagination));
+          proceduresQuery = query(
+            proceduresCollection,
+            orderBy("name"),
+            limit(pagination)
+          ); // Use imported orderBy
         }
+      } else {
+        proceduresQuery = query(proceduresCollection, orderBy("name")); // Use imported orderBy
       }
 
       const proceduresSnapshot = await getDocs(proceduresQuery);
@@ -376,17 +878,9 @@ export class ProcedureService extends BaseService {
 
       const procedures = proceduresSnapshot.docs.map((doc) => {
         const data = doc.data() as Procedure;
-
-        // Ensure clinicInfo and doctorInfo are present
-        if (!data.clinicInfo || !data.doctorInfo) {
-          console.warn(
-            `Procedure ${data.id} is missing clinicInfo or doctorInfo fields. These should be updated.`
-          );
-        }
-
         return {
           ...data,
-          id: doc.id,
+          id: doc.id, // Ensure ID is present
         };
       });
 
@@ -399,251 +893,4 @@ export class ProcedureService extends BaseService {
       throw error;
     }
   }
-
-  /**
-   * Updates the clinicInfo and doctorInfo fields in procedures when the source data changes
-   *
-   * @param entityType - The type of entity that changed ("clinic" or "doctor")
-   * @param entityId - The ID of the entity that changed
-   * @param updatedData - The updated data for the entity
-   * @returns Number of procedures updated
-   */
-  async updateProcedureAggregateData(
-    entityType: "clinic" | "doctor",
-    entityId: string,
-    updatedData: any
-  ): Promise<number> {
-    let proceduresQuery;
-    const updatedField = entityType === "clinic" ? "clinicInfo" : "doctorInfo";
-
-    // Find all procedures related to this entity
-    if (entityType === "clinic") {
-      proceduresQuery = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where("clinicBranchId", "==", entityId)
-      );
-    } else {
-      proceduresQuery = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where("practitionerId", "==", entityId)
-      );
-    }
-
-    const snapshot = await getDocs(proceduresQuery);
-
-    if (snapshot.empty) {
-      return 0;
-    }
-
-    // Create the updated data object
-    let updatedFieldData;
-
-    if (entityType === "clinic") {
-      // Clinic info format
-      updatedFieldData = {
-        id: entityId,
-        name: updatedData.name,
-        description: updatedData.description || "",
-        featuredPhoto:
-          updatedData.featuredPhotos && updatedData.featuredPhotos.length > 0
-            ? updatedData.featuredPhotos[0]
-            : updatedData.coverPhoto || "",
-        location: updatedData.location,
-        contactInfo: updatedData.contactInfo,
-      };
-    } else {
-      // Doctor info format
-      if (updatedData.basicInfo) {
-        // If it's a practitioner object
-        updatedFieldData = {
-          id: entityId,
-          name: `${updatedData.basicInfo.firstName} ${updatedData.basicInfo.lastName}`,
-          description: updatedData.basicInfo.bio || "",
-          photo: updatedData.basicInfo.profileImageUrl || "",
-          rating: 0, // This would need to be calculated or passed in
-          services: [], // This would need to be determined or passed in
-        };
-      } else {
-        // If it's already a doctorInfo object
-        updatedFieldData = {
-          id: entityId,
-          name: updatedData.name,
-          description: updatedData.description || "",
-          photo: updatedData.photo || "",
-          rating: updatedData.rating || 0,
-          services: updatedData.services || [],
-        };
-      }
-    }
-
-    // Update all found procedures
-    const batch = writeBatch(this.db);
-
-    snapshot.docs.forEach((doc) => {
-      batch.update(doc.ref, {
-        [updatedField]: updatedFieldData,
-        updatedAt: serverTimestamp(),
-      });
-    });
-
-    await batch.commit();
-
-    return snapshot.size;
-  }
-
-  /**
-   * Updates the clinicInfo for all procedures associated with a specific clinic
-   *
-   * @param clinicId - The ID of the clinic that was updated
-   * @param clinicData - The updated clinic data
-   * @returns Number of procedures updated
-   */
-  async updateClinicInfoInProcedures(
-    clinicId: string,
-    clinicData: any
-  ): Promise<number> {
-    return this.updateProcedureAggregateData("clinic", clinicId, clinicData);
-  }
-
-  /**
-   * Updates the doctorInfo for all procedures associated with a specific practitioner
-   *
-   * @param practitionerId - The ID of the practitioner that was updated
-   * @param practitionerData - The updated practitioner data
-   * @returns Number of procedures updated
-   */
-  async updateDoctorInfoInProcedures(
-    practitionerId: string,
-    practitionerData: any
-  ): Promise<number> {
-    return this.updateProcedureAggregateData(
-      "doctor",
-      practitionerId,
-      practitionerData
-    );
-  }
-
-  /**
-   * Updates all existing procedures to include clinicInfo and doctorInfo
-   * This is a migration helper method that can be used to update existing procedures
-   *
-   * @returns Number of procedures updated
-   */
-  async migrateAllProceduresWithAggregateData(): Promise<number> {
-    // Get all procedures
-    const proceduresQuery = query(collection(this.db, PROCEDURES_COLLECTION));
-    const proceduresSnapshot = await getDocs(proceduresQuery);
-
-    if (proceduresSnapshot.empty) {
-      return 0;
-    }
-
-    let updatedCount = 0;
-    const batch = writeBatch(this.db);
-    const batchLimit = 500; // Firestore batch limit
-    let batchCount = 0;
-
-    // Process each procedure
-    for (const procedureDoc of proceduresSnapshot.docs) {
-      const procedure = procedureDoc.data() as Procedure;
-
-      // Skip if already has both required fields
-      if (procedure.clinicInfo && procedure.doctorInfo) {
-        continue;
-      }
-
-      try {
-        // Get clinic data
-        const clinicRef = doc(
-          this.db,
-          CLINICS_COLLECTION,
-          procedure.clinicBranchId
-        );
-        const clinicSnapshot = await getDoc(clinicRef);
-
-        if (!clinicSnapshot.exists()) {
-          console.warn(
-            `Clinic ${procedure.clinicBranchId} not found for procedure ${procedure.id}`
-          );
-          continue;
-        }
-
-        const clinic = clinicSnapshot.data();
-
-        // Create clinic info
-        const clinicInfo = {
-          id: clinicSnapshot.id,
-          name: clinic.name,
-          description: clinic.description || "",
-          featuredPhoto:
-            clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-              ? clinic.featuredPhotos[0]
-              : clinic.coverPhoto || "",
-          location: clinic.location,
-          contactInfo: clinic.contactInfo,
-        };
-
-        // Get practitioner data
-        const practitionerRef = doc(
-          this.db,
-          PRACTITIONERS_COLLECTION,
-          procedure.practitionerId
-        );
-        const practitionerSnapshot = await getDoc(practitionerRef);
-
-        if (!practitionerSnapshot.exists()) {
-          console.warn(
-            `Practitioner ${procedure.practitionerId} not found for procedure ${procedure.id}`
-          );
-          continue;
-        }
-
-        const practitioner = practitionerSnapshot.data();
-
-        // Find doctor info in clinic's doctorsInfo array
-        let doctorInfo = clinic.doctorsInfo?.find(
-          (doctor: any) => doctor.id === procedure.practitionerId
-        );
-
-        // If not found, create basic doctor info
-        if (!doctorInfo) {
-          doctorInfo = {
-            id: practitionerSnapshot.id,
-            name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-            description: practitioner.basicInfo.bio || "",
-            photo: practitioner.basicInfo.profileImageUrl || "",
-            rating: 0,
-            services: [],
-          };
-        }
-
-        // Add to batch
-        batch.update(procedureDoc.ref, {
-          clinicInfo,
-          doctorInfo,
-          updatedAt: serverTimestamp(),
-        });
-
-        batchCount++;
-        updatedCount++;
-
-        // Commit batch if we've reached the limit
-        if (batchCount >= batchLimit) {
-          await batch.commit();
-          console.log(`Committed batch of ${batchCount} procedure updates`);
-          batchCount = 0;
-        }
-      } catch (error) {
-        console.error(`Error updating procedure ${procedure.id}:`, error);
-      }
-    }
-
-    // Commit any remaining updates
-    if (batchCount > 0) {
-      await batch.commit();
-      console.log(`Committed final batch of ${batchCount} procedure updates`);
-    }
-
-    return updatedCount;
-  }
 }