@blackcode_sa/metaestetics-api 1.5.27 → 1.5.29

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

@@ -11,6 +11,11 @@ import {
   Timestamp,
   serverTimestamp,
   DocumentData,
+  writeBatch,
+  arrayUnion,
+  arrayRemove,
+  FieldValue,
+  orderBy,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -18,6 +23,7 @@ import {
   CreateProcedureData,
   UpdateProcedureData,
   PROCEDURES_COLLECTION,
+  ProcedureSummaryInfo,
 } from "../../types/procedure";
 import {
   createProcedureSchema,
@@ -47,12 +53,17 @@ import { CategoryService } from "../../backoffice/services/category.service";
 import { SubcategoryService } from "../../backoffice/services/subcategory.service";
 import { TechnologyService } from "../../backoffice/services/technology.service";
 import { ProductService } from "../../backoffice/services/product.service";
-import { Practitioner } from "../../types/practitioner";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../types/practitioner";
 import {
   CertificationLevel,
   CertificationSpecialty,
   ProcedureFamily,
 } from "../../backoffice/types";
+import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
+import { ProcedureReviewInfo } from "../../types/reviews";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -76,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(
@@ -100,13 +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 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 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
+
+    // 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,
+    };
+
+    // 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,
@@ -116,22 +314,67 @@ export class ProcedureService extends BaseService {
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
       documentationTemplates: technology.documentationTemplates || [],
-      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;
   }
 
   /**
@@ -185,70 +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 {
+    // 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[];
@@ -256,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);
 
@@ -267,4 +834,63 @@ export class ProcedureService extends BaseService {
       subcategories,
     };
   }
+
+  /**
+   * Gets all procedures with optional pagination
+   *
+   * @param pagination - Optional number of procedures per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @returns Object containing procedures array and the last document for pagination
+   */
+  async getAllProcedures(
+    pagination?: number,
+    lastDoc?: any
+  ): Promise<{ procedures: Procedure[]; lastDoc: any }> {
+    try {
+      const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
+      let proceduresQuery = query(proceduresCollection);
+
+      // Apply pagination if specified
+      if (pagination && pagination > 0) {
+        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,
+            orderBy("name"),
+            limit(pagination)
+          ); // Use imported orderBy
+        }
+      } else {
+        proceduresQuery = query(proceduresCollection, orderBy("name")); // Use imported orderBy
+      }
+
+      const proceduresSnapshot = await getDocs(proceduresQuery);
+      const lastVisible =
+        proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
+
+      const procedures = proceduresSnapshot.docs.map((doc) => {
+        const data = doc.data() as Procedure;
+        return {
+          ...data,
+          id: doc.id, // Ensure ID is present
+        };
+      });
+
+      return {
+        procedures,
+        lastDoc: lastVisible,
+      };
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Error getting all procedures:", error);
+      throw error;
+    }
+  }
 }