@blackcode_sa/metaestetics-api 1.13.1 → 1.13.3

package/dist/index.d.mts

@@ -6736,6 +6736,40 @@ declare class ProcedureService extends BaseService {
      * @returns The created procedure
      */
     createProcedure(data: CreateProcedureData): Promise<Procedure>;
+    /**
+     * Validates if a practitioner can perform a procedure based on certification requirements.
+     *
+     * @param procedure - The procedure to check
+     * @param practitioner - The practitioner to validate
+     * @returns true if practitioner can perform the procedure, false otherwise
+     */
+    canPractitionerPerformProcedure(procedure: Procedure, practitioner: Practitioner): boolean;
+    /**
+     * Clones an existing procedure for a target practitioner.
+     * This creates a new procedure document with the same data as the source procedure,
+     * but linked to the target practitioner.
+     *
+     * @param sourceProcedureId - The ID of the procedure to clone
+     * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+     * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+     * @returns The newly created procedure
+     */
+    cloneProcedureForPractitioner(sourceProcedureId: string, targetPractitionerId: string, overrides?: Partial<CreateProcedureData> & {
+        isActive?: boolean;
+    }): Promise<Procedure>;
+    /**
+     * Clones an existing procedure for multiple target practitioners.
+     * This creates new procedure documents with the same data as the source procedure,
+     * but linked to each target practitioner.
+     *
+     * @param sourceProcedureId - The ID of the procedure to clone
+     * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+     * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+     * @returns Array of newly created procedures
+     */
+    bulkCloneProcedureForPractitioners(sourceProcedureId: string, targetPractitionerIds: string[], overrides?: Partial<CreateProcedureData> & {
+        isActive?: boolean;
+    }): Promise<Procedure[]>;
     /**
      * Creates multiple procedures for a list of practitioners based on common data.
      * This method is optimized for bulk creation to reduce database reads and writes.

package/dist/index.d.ts

@@ -6736,6 +6736,40 @@ declare class ProcedureService extends BaseService {
      * @returns The created procedure
      */
     createProcedure(data: CreateProcedureData): Promise<Procedure>;
+    /**
+     * Validates if a practitioner can perform a procedure based on certification requirements.
+     *
+     * @param procedure - The procedure to check
+     * @param practitioner - The practitioner to validate
+     * @returns true if practitioner can perform the procedure, false otherwise
+     */
+    canPractitionerPerformProcedure(procedure: Procedure, practitioner: Practitioner): boolean;
+    /**
+     * Clones an existing procedure for a target practitioner.
+     * This creates a new procedure document with the same data as the source procedure,
+     * but linked to the target practitioner.
+     *
+     * @param sourceProcedureId - The ID of the procedure to clone
+     * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+     * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+     * @returns The newly created procedure
+     */
+    cloneProcedureForPractitioner(sourceProcedureId: string, targetPractitionerId: string, overrides?: Partial<CreateProcedureData> & {
+        isActive?: boolean;
+    }): Promise<Procedure>;
+    /**
+     * Clones an existing procedure for multiple target practitioners.
+     * This creates new procedure documents with the same data as the source procedure,
+     * but linked to each target practitioner.
+     *
+     * @param sourceProcedureId - The ID of the procedure to clone
+     * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+     * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+     * @returns Array of newly created procedures
+     */
+    bulkCloneProcedureForPractitioners(sourceProcedureId: string, targetPractitionerIds: string[], overrides?: Partial<CreateProcedureData> & {
+        isActive?: boolean;
+    }): Promise<Procedure[]>;
     /**
      * Creates multiple procedures for a list of practitioners based on common data.
      * This method is optimized for bulk creation to reduce database reads and writes.

package/dist/index.js

@@ -20035,6 +20035,25 @@ var ProcedureService = class extends BaseService {
       throw new Error(`Practitioner with ID ${validatedData.practitionerId} not found`);
     }
     const practitioner = practitionerSnapshot.data();
+    const existingProceduresQuery = (0, import_firestore58.query)(
+      (0, import_firestore58.collection)(this.db, PROCEDURES_COLLECTION),
+      (0, import_firestore58.where)("practitionerId", "==", validatedData.practitionerId),
+      (0, import_firestore58.where)("clinicBranchId", "==", validatedData.clinicBranchId),
+      (0, import_firestore58.where)("isActive", "==", true)
+    );
+    const existingProceduresSnapshot = await (0, import_firestore58.getDocs)(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+    const hasSameTechnology = existingProcedures.some(
+      (proc) => {
+        var _a2;
+        return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === validatedData.technologyId;
+      }
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${(technology == null ? void 0 : technology.name) || validatedData.technologyId}" in this clinic branch`
+      );
+    }
     let processedPhotos = [];
     if (validatedData.photos && validatedData.photos.length > 0) {
       processedPhotos = await this.processMediaArray(
@@ -20137,6 +20156,240 @@ var ProcedureService = class extends BaseService {
     const savedDoc = await (0, import_firestore58.getDoc)(procedureRef);
     return savedDoc.data();
   }
+  /**
+   * Validates if a practitioner can perform a procedure based on certification requirements.
+   * 
+   * @param procedure - The procedure to check
+   * @param practitioner - The practitioner to validate
+   * @returns true if practitioner can perform the procedure, false otherwise
+   */
+  canPractitionerPerformProcedure(procedure, practitioner) {
+    if (!practitioner.certification) {
+      return false;
+    }
+    const requiredCert = procedure.certificationRequirement;
+    const practitionerCert = practitioner.certification;
+    const levelOrder = [
+      "aesthetician",
+      "nurse_assistant",
+      "nurse",
+      "nurse_practitioner",
+      "physician_assistant",
+      "doctor",
+      "specialist",
+      "plastic_surgeon"
+    ];
+    const practitionerLevelIndex = levelOrder.indexOf(practitionerCert.level);
+    const requiredLevelIndex = levelOrder.indexOf(requiredCert.minimumLevel);
+    if (practitionerLevelIndex < requiredLevelIndex) {
+      return false;
+    }
+    const requiredSpecialties = requiredCert.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      const practitionerSpecialties = practitionerCert.specialties || [];
+      const hasAllRequired = requiredSpecialties.every(
+        (specialty) => practitionerSpecialties.includes(specialty)
+      );
+      if (!hasAllRequired) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Clones an existing procedure for a target practitioner.
+   * This creates a new procedure document with the same data as the source procedure,
+   * but linked to the target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+   * @returns The newly created procedure
+   */
+  async cloneProcedureForPractitioner(sourceProcedureId, targetPractitionerId, overrides) {
+    var _a, _b, _c;
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+    const practitionerRef = (0, import_firestore58.doc)(this.db, PRACTITIONERS_COLLECTION, targetPractitionerId);
+    const practitionerSnapshot = await (0, import_firestore58.getDoc)(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(`Target practitioner with ID ${targetPractitionerId} not found`);
+    }
+    const practitioner = practitionerSnapshot.data();
+    if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+      );
+    }
+    const existingProceduresQuery = (0, import_firestore58.query)(
+      (0, import_firestore58.collection)(this.db, PROCEDURES_COLLECTION),
+      (0, import_firestore58.where)("practitionerId", "==", targetPractitionerId),
+      (0, import_firestore58.where)("clinicBranchId", "==", sourceProcedure.clinicBranchId),
+      (0, import_firestore58.where)("isActive", "==", true)
+    );
+    const existingProceduresSnapshot = await (0, import_firestore58.getDocs)(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+    const hasSameTechnology = existingProcedures.some(
+      (proc) => {
+        var _a2, _b2;
+        return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === ((_b2 = sourceProcedure.technology) == null ? void 0 : _b2.id);
+      }
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${((_a = sourceProcedure.technology) == null ? void 0 : _a.name) || ((_b = sourceProcedure.technology) == null ? void 0 : _b.id)}" in this clinic branch`
+      );
+    }
+    const newProcedureId = this.generateId();
+    const doctorInfo = {
+      id: practitioner.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || "",
+      photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+      rating: ((_c = practitioner.reviewInfo) == null ? void 0 : _c.averageRating) || 0,
+      services: practitioner.procedures || []
+    };
+    const newProcedure = {
+      ...sourceProcedure,
+      id: newProcedureId,
+      practitionerId: targetPractitionerId,
+      doctorInfo,
+      // Link to new doctor
+      // Reset review info for the new procedure
+      reviewInfo: {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0
+      },
+      // Apply any overrides if provided
+      ...(overrides == null ? void 0 : overrides.price) !== void 0 && { price: overrides.price },
+      ...(overrides == null ? void 0 : overrides.duration) !== void 0 && { duration: overrides.duration },
+      ...(overrides == null ? void 0 : overrides.description) !== void 0 && { description: overrides.description },
+      // Ensure it's active by default unless specified otherwise
+      isActive: (overrides == null ? void 0 : overrides.isActive) !== void 0 ? overrides.isActive : true
+    };
+    const procedureRef = (0, import_firestore58.doc)(this.db, PROCEDURES_COLLECTION, newProcedureId);
+    await (0, import_firestore58.setDoc)(procedureRef, {
+      ...newProcedure,
+      createdAt: (0, import_firestore58.serverTimestamp)(),
+      updatedAt: (0, import_firestore58.serverTimestamp)()
+    });
+    const savedDoc = await (0, import_firestore58.getDoc)(procedureRef);
+    return savedDoc.data();
+  }
+  /**
+   * Clones an existing procedure for multiple target practitioners.
+   * This creates new procedure documents with the same data as the source procedure,
+   * but linked to each target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+   * @returns Array of newly created procedures
+   */
+  async bulkCloneProcedureForPractitioners(sourceProcedureId, targetPractitionerIds, overrides) {
+    var _a, _b, _c;
+    if (!targetPractitionerIds || targetPractitionerIds.length === 0) {
+      throw new Error("At least one target practitioner ID is required");
+    }
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+    const practitionerPromises = targetPractitionerIds.map(
+      (id) => (0, import_firestore58.getDoc)((0, import_firestore58.doc)(this.db, PRACTITIONERS_COLLECTION, id))
+    );
+    const practitionerSnapshots = await Promise.all(practitionerPromises);
+    const practitioners = [];
+    const sourceTechnologyId = (_a = sourceProcedure.technology) == null ? void 0 : _a.id;
+    for (let i = 0; i < practitionerSnapshots.length; i++) {
+      const snapshot = practitionerSnapshots[i];
+      if (!snapshot.exists()) {
+        throw new Error(`Target practitioner with ID ${targetPractitionerIds[i]} not found`);
+      }
+      const practitioner = snapshot.data();
+      if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+        );
+      }
+      const existingProceduresQuery = (0, import_firestore58.query)(
+        (0, import_firestore58.collection)(this.db, PROCEDURES_COLLECTION),
+        (0, import_firestore58.where)("practitionerId", "==", practitioner.id),
+        (0, import_firestore58.where)("clinicBranchId", "==", sourceProcedure.clinicBranchId),
+        (0, import_firestore58.where)("isActive", "==", true)
+      );
+      const existingProceduresSnapshot = await (0, import_firestore58.getDocs)(existingProceduresQuery);
+      const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+      const hasSameTechnology = existingProcedures.some(
+        (proc) => {
+          var _a2;
+          return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === sourceTechnologyId;
+        }
+      );
+      if (hasSameTechnology) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${((_b = sourceProcedure.technology) == null ? void 0 : _b.name) || sourceTechnologyId}" in this clinic branch`
+        );
+      }
+      practitioners.push(practitioner);
+    }
+    const batch = (0, import_firestore58.writeBatch)(this.db);
+    const newProcedures = [];
+    for (const practitioner of practitioners) {
+      const newProcedureId = this.generateId();
+      const doctorInfo = {
+        id: practitioner.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || "",
+        photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+        rating: ((_c = practitioner.reviewInfo) == null ? void 0 : _c.averageRating) || 0,
+        services: practitioner.procedures || []
+      };
+      const newProcedure = {
+        ...sourceProcedure,
+        id: newProcedureId,
+        practitionerId: practitioner.id,
+        doctorInfo,
+        // Reset review info for the new procedure
+        reviewInfo: {
+          totalReviews: 0,
+          averageRating: 0,
+          effectivenessOfTreatment: 0,
+          outcomeExplanation: 0,
+          painManagement: 0,
+          followUpCare: 0,
+          valueForMoney: 0,
+          recommendationPercentage: 0
+        },
+        // Apply any overrides if provided
+        ...(overrides == null ? void 0 : overrides.price) !== void 0 && { price: overrides.price },
+        ...(overrides == null ? void 0 : overrides.duration) !== void 0 && { duration: overrides.duration },
+        ...(overrides == null ? void 0 : overrides.description) !== void 0 && { description: overrides.description },
+        // Ensure it's active by default unless specified otherwise
+        isActive: (overrides == null ? void 0 : overrides.isActive) !== void 0 ? overrides.isActive : true
+      };
+      newProcedures.push(newProcedure);
+      const procedureRef = (0, import_firestore58.doc)(this.db, PROCEDURES_COLLECTION, newProcedureId);
+      batch.set(procedureRef, {
+        ...newProcedure,
+        createdAt: (0, import_firestore58.serverTimestamp)(),
+        updatedAt: (0, import_firestore58.serverTimestamp)()
+      });
+    }
+    await batch.commit();
+    const createdProcedures = await Promise.all(
+      newProcedures.map((p) => this.getProcedure(p.id))
+    );
+    return createdProcedures.filter((p) => p !== null);
+  }
   /**
    * Creates multiple procedures for a list of practitioners based on common data.
    * This method is optimized for bulk creation to reduce database reads and writes.
@@ -20221,6 +20474,40 @@ var ProcedureService = class extends BaseService {
       const notFoundIds = practitionerIds.filter((id) => !foundIds.includes(id));
       throw new Error(`The following practitioners were not found: ${notFoundIds.join(", ")}`);
     }
+    const duplicatePractitioners = [];
+    const duplicateChecks = await Promise.all(
+      practitionerIds.map(async (practitionerId) => {
+        const existingProceduresQuery = (0, import_firestore58.query)(
+          (0, import_firestore58.collection)(this.db, PROCEDURES_COLLECTION),
+          (0, import_firestore58.where)("practitionerId", "==", practitionerId),
+          (0, import_firestore58.where)("clinicBranchId", "==", validatedData.clinicBranchId),
+          (0, import_firestore58.where)("isActive", "==", true)
+        );
+        const existingProceduresSnapshot = await (0, import_firestore58.getDocs)(existingProceduresQuery);
+        const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+        const hasSameTechnology = existingProcedures.some(
+          (proc) => {
+            var _a2;
+            return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === validatedData.technologyId;
+          }
+        );
+        return { practitionerId, hasSameTechnology };
+      })
+    );
+    duplicateChecks.forEach(({ practitionerId, hasSameTechnology }) => {
+      if (hasSameTechnology) {
+        duplicatePractitioners.push(practitionerId);
+      }
+    });
+    if (duplicatePractitioners.length > 0) {
+      const duplicateNames = duplicatePractitioners.map((id) => {
+        const practitioner = practitionersMap.get(id);
+        return `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`;
+      }).join(", ");
+      throw new Error(
+        `The following practitioner(s) already have a procedure with technology "${(technology == null ? void 0 : technology.name) || validatedData.technologyId}" in this clinic branch: ${duplicateNames}. Please remove them from the selection and try again.`
+      );
+    }
     const batch = (0, import_firestore58.writeBatch)(this.db);
     const createdProcedureIds = [];
     const clinicInfo = {

package/dist/index.mjs

@@ -20271,6 +20271,25 @@ var ProcedureService = class extends BaseService {
       throw new Error(`Practitioner with ID ${validatedData.practitionerId} not found`);
     }
     const practitioner = practitionerSnapshot.data();
+    const existingProceduresQuery = query33(
+      collection33(this.db, PROCEDURES_COLLECTION),
+      where33("practitionerId", "==", validatedData.practitionerId),
+      where33("clinicBranchId", "==", validatedData.clinicBranchId),
+      where33("isActive", "==", true)
+    );
+    const existingProceduresSnapshot = await getDocs33(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+    const hasSameTechnology = existingProcedures.some(
+      (proc) => {
+        var _a2;
+        return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === validatedData.technologyId;
+      }
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${(technology == null ? void 0 : technology.name) || validatedData.technologyId}" in this clinic branch`
+      );
+    }
     let processedPhotos = [];
     if (validatedData.photos && validatedData.photos.length > 0) {
       processedPhotos = await this.processMediaArray(
@@ -20373,6 +20392,240 @@ var ProcedureService = class extends BaseService {
     const savedDoc = await getDoc40(procedureRef);
     return savedDoc.data();
   }
+  /**
+   * Validates if a practitioner can perform a procedure based on certification requirements.
+   * 
+   * @param procedure - The procedure to check
+   * @param practitioner - The practitioner to validate
+   * @returns true if practitioner can perform the procedure, false otherwise
+   */
+  canPractitionerPerformProcedure(procedure, practitioner) {
+    if (!practitioner.certification) {
+      return false;
+    }
+    const requiredCert = procedure.certificationRequirement;
+    const practitionerCert = practitioner.certification;
+    const levelOrder = [
+      "aesthetician",
+      "nurse_assistant",
+      "nurse",
+      "nurse_practitioner",
+      "physician_assistant",
+      "doctor",
+      "specialist",
+      "plastic_surgeon"
+    ];
+    const practitionerLevelIndex = levelOrder.indexOf(practitionerCert.level);
+    const requiredLevelIndex = levelOrder.indexOf(requiredCert.minimumLevel);
+    if (practitionerLevelIndex < requiredLevelIndex) {
+      return false;
+    }
+    const requiredSpecialties = requiredCert.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      const practitionerSpecialties = practitionerCert.specialties || [];
+      const hasAllRequired = requiredSpecialties.every(
+        (specialty) => practitionerSpecialties.includes(specialty)
+      );
+      if (!hasAllRequired) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Clones an existing procedure for a target practitioner.
+   * This creates a new procedure document with the same data as the source procedure,
+   * but linked to the target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+   * @returns The newly created procedure
+   */
+  async cloneProcedureForPractitioner(sourceProcedureId, targetPractitionerId, overrides) {
+    var _a, _b, _c;
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+    const practitionerRef = doc39(this.db, PRACTITIONERS_COLLECTION, targetPractitionerId);
+    const practitionerSnapshot = await getDoc40(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(`Target practitioner with ID ${targetPractitionerId} not found`);
+    }
+    const practitioner = practitionerSnapshot.data();
+    if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+      );
+    }
+    const existingProceduresQuery = query33(
+      collection33(this.db, PROCEDURES_COLLECTION),
+      where33("practitionerId", "==", targetPractitionerId),
+      where33("clinicBranchId", "==", sourceProcedure.clinicBranchId),
+      where33("isActive", "==", true)
+    );
+    const existingProceduresSnapshot = await getDocs33(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+    const hasSameTechnology = existingProcedures.some(
+      (proc) => {
+        var _a2, _b2;
+        return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === ((_b2 = sourceProcedure.technology) == null ? void 0 : _b2.id);
+      }
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${((_a = sourceProcedure.technology) == null ? void 0 : _a.name) || ((_b = sourceProcedure.technology) == null ? void 0 : _b.id)}" in this clinic branch`
+      );
+    }
+    const newProcedureId = this.generateId();
+    const doctorInfo = {
+      id: practitioner.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || "",
+      photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+      rating: ((_c = practitioner.reviewInfo) == null ? void 0 : _c.averageRating) || 0,
+      services: practitioner.procedures || []
+    };
+    const newProcedure = {
+      ...sourceProcedure,
+      id: newProcedureId,
+      practitionerId: targetPractitionerId,
+      doctorInfo,
+      // Link to new doctor
+      // Reset review info for the new procedure
+      reviewInfo: {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0
+      },
+      // Apply any overrides if provided
+      ...(overrides == null ? void 0 : overrides.price) !== void 0 && { price: overrides.price },
+      ...(overrides == null ? void 0 : overrides.duration) !== void 0 && { duration: overrides.duration },
+      ...(overrides == null ? void 0 : overrides.description) !== void 0 && { description: overrides.description },
+      // Ensure it's active by default unless specified otherwise
+      isActive: (overrides == null ? void 0 : overrides.isActive) !== void 0 ? overrides.isActive : true
+    };
+    const procedureRef = doc39(this.db, PROCEDURES_COLLECTION, newProcedureId);
+    await setDoc27(procedureRef, {
+      ...newProcedure,
+      createdAt: serverTimestamp31(),
+      updatedAt: serverTimestamp31()
+    });
+    const savedDoc = await getDoc40(procedureRef);
+    return savedDoc.data();
+  }
+  /**
+   * Clones an existing procedure for multiple target practitioners.
+   * This creates new procedure documents with the same data as the source procedure,
+   * but linked to each target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+   * @returns Array of newly created procedures
+   */
+  async bulkCloneProcedureForPractitioners(sourceProcedureId, targetPractitionerIds, overrides) {
+    var _a, _b, _c;
+    if (!targetPractitionerIds || targetPractitionerIds.length === 0) {
+      throw new Error("At least one target practitioner ID is required");
+    }
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+    const practitionerPromises = targetPractitionerIds.map(
+      (id) => getDoc40(doc39(this.db, PRACTITIONERS_COLLECTION, id))
+    );
+    const practitionerSnapshots = await Promise.all(practitionerPromises);
+    const practitioners = [];
+    const sourceTechnologyId = (_a = sourceProcedure.technology) == null ? void 0 : _a.id;
+    for (let i = 0; i < practitionerSnapshots.length; i++) {
+      const snapshot = practitionerSnapshots[i];
+      if (!snapshot.exists()) {
+        throw new Error(`Target practitioner with ID ${targetPractitionerIds[i]} not found`);
+      }
+      const practitioner = snapshot.data();
+      if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+        );
+      }
+      const existingProceduresQuery = query33(
+        collection33(this.db, PROCEDURES_COLLECTION),
+        where33("practitionerId", "==", practitioner.id),
+        where33("clinicBranchId", "==", sourceProcedure.clinicBranchId),
+        where33("isActive", "==", true)
+      );
+      const existingProceduresSnapshot = await getDocs33(existingProceduresQuery);
+      const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+      const hasSameTechnology = existingProcedures.some(
+        (proc) => {
+          var _a2;
+          return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === sourceTechnologyId;
+        }
+      );
+      if (hasSameTechnology) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${((_b = sourceProcedure.technology) == null ? void 0 : _b.name) || sourceTechnologyId}" in this clinic branch`
+        );
+      }
+      practitioners.push(practitioner);
+    }
+    const batch = writeBatch6(this.db);
+    const newProcedures = [];
+    for (const practitioner of practitioners) {
+      const newProcedureId = this.generateId();
+      const doctorInfo = {
+        id: practitioner.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || "",
+        photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+        rating: ((_c = practitioner.reviewInfo) == null ? void 0 : _c.averageRating) || 0,
+        services: practitioner.procedures || []
+      };
+      const newProcedure = {
+        ...sourceProcedure,
+        id: newProcedureId,
+        practitionerId: practitioner.id,
+        doctorInfo,
+        // Reset review info for the new procedure
+        reviewInfo: {
+          totalReviews: 0,
+          averageRating: 0,
+          effectivenessOfTreatment: 0,
+          outcomeExplanation: 0,
+          painManagement: 0,
+          followUpCare: 0,
+          valueForMoney: 0,
+          recommendationPercentage: 0
+        },
+        // Apply any overrides if provided
+        ...(overrides == null ? void 0 : overrides.price) !== void 0 && { price: overrides.price },
+        ...(overrides == null ? void 0 : overrides.duration) !== void 0 && { duration: overrides.duration },
+        ...(overrides == null ? void 0 : overrides.description) !== void 0 && { description: overrides.description },
+        // Ensure it's active by default unless specified otherwise
+        isActive: (overrides == null ? void 0 : overrides.isActive) !== void 0 ? overrides.isActive : true
+      };
+      newProcedures.push(newProcedure);
+      const procedureRef = doc39(this.db, PROCEDURES_COLLECTION, newProcedureId);
+      batch.set(procedureRef, {
+        ...newProcedure,
+        createdAt: serverTimestamp31(),
+        updatedAt: serverTimestamp31()
+      });
+    }
+    await batch.commit();
+    const createdProcedures = await Promise.all(
+      newProcedures.map((p) => this.getProcedure(p.id))
+    );
+    return createdProcedures.filter((p) => p !== null);
+  }
   /**
    * Creates multiple procedures for a list of practitioners based on common data.
    * This method is optimized for bulk creation to reduce database reads and writes.
@@ -20457,6 +20710,40 @@ var ProcedureService = class extends BaseService {
       const notFoundIds = practitionerIds.filter((id) => !foundIds.includes(id));
       throw new Error(`The following practitioners were not found: ${notFoundIds.join(", ")}`);
     }
+    const duplicatePractitioners = [];
+    const duplicateChecks = await Promise.all(
+      practitionerIds.map(async (practitionerId) => {
+        const existingProceduresQuery = query33(
+          collection33(this.db, PROCEDURES_COLLECTION),
+          where33("practitionerId", "==", practitionerId),
+          where33("clinicBranchId", "==", validatedData.clinicBranchId),
+          where33("isActive", "==", true)
+        );
+        const existingProceduresSnapshot = await getDocs33(existingProceduresQuery);
+        const existingProcedures = existingProceduresSnapshot.docs.map((doc47) => doc47.data());
+        const hasSameTechnology = existingProcedures.some(
+          (proc) => {
+            var _a2;
+            return ((_a2 = proc.technology) == null ? void 0 : _a2.id) === validatedData.technologyId;
+          }
+        );
+        return { practitionerId, hasSameTechnology };
+      })
+    );
+    duplicateChecks.forEach(({ practitionerId, hasSameTechnology }) => {
+      if (hasSameTechnology) {
+        duplicatePractitioners.push(practitionerId);
+      }
+    });
+    if (duplicatePractitioners.length > 0) {
+      const duplicateNames = duplicatePractitioners.map((id) => {
+        const practitioner = practitionersMap.get(id);
+        return `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`;
+      }).join(", ");
+      throw new Error(
+        `The following practitioner(s) already have a procedure with technology "${(technology == null ? void 0 : technology.name) || validatedData.technologyId}" in this clinic branch: ${duplicateNames}. Please remove them from the selection and try again.`
+      );
+    }
     const batch = writeBatch6(this.db);
     const createdProcedureIds = [];
     const clinicInfo = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.13.1",
+  "version": "1.13.3",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

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

@@ -244,6 +244,25 @@ export class ProcedureService extends BaseService {
     }
     const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
+    // Check if practitioner already has a procedure with the same technology ID in this clinic branch
+    const existingProceduresQuery = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where('practitionerId', '==', validatedData.practitionerId),
+      where('clinicBranchId', '==', validatedData.clinicBranchId),
+      where('isActive', '==', true)
+    );
+    const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+    
+    const hasSameTechnology = existingProcedures.some(
+      proc => proc.technology?.id === validatedData.technologyId
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${technology?.name || validatedData.technologyId}" in this clinic branch`
+      );
+    }
+
     // Process photos if provided
     let processedPhotos: string[] = [];
     if (validatedData.photos && validatedData.photos.length > 0) {
@@ -370,6 +389,308 @@ export class ProcedureService extends BaseService {
     return savedDoc.data() as Procedure;
   }
 
+  /**
+   * Validates if a practitioner can perform a procedure based on certification requirements.
+   * 
+   * @param procedure - The procedure to check
+   * @param practitioner - The practitioner to validate
+   * @returns true if practitioner can perform the procedure, false otherwise
+   */
+  canPractitionerPerformProcedure(procedure: Procedure, practitioner: Practitioner): boolean {
+    if (!practitioner.certification) {
+      return false;
+    }
+
+    const requiredCert = procedure.certificationRequirement;
+    const practitionerCert = practitioner.certification;
+
+    // Check certification level
+    const levelOrder = [
+      'aesthetician',
+      'nurse_assistant',
+      'nurse',
+      'nurse_practitioner',
+      'physician_assistant',
+      'doctor',
+      'specialist',
+      'plastic_surgeon',
+    ];
+
+    const practitionerLevelIndex = levelOrder.indexOf(practitionerCert.level);
+    const requiredLevelIndex = levelOrder.indexOf(requiredCert.minimumLevel);
+
+    if (practitionerLevelIndex < requiredLevelIndex) {
+      return false;
+    }
+
+    // Check required specialties
+    const requiredSpecialties = requiredCert.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      const practitionerSpecialties = practitionerCert.specialties || [];
+      const hasAllRequired = requiredSpecialties.every(specialty =>
+        practitionerSpecialties.includes(specialty)
+      );
+      if (!hasAllRequired) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Clones an existing procedure for a target practitioner.
+   * This creates a new procedure document with the same data as the source procedure,
+   * but linked to the target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+   * @returns The newly created procedure
+   */
+  async cloneProcedureForPractitioner(
+    sourceProcedureId: string,
+    targetPractitionerId: string,
+    overrides?: Partial<CreateProcedureData> & { isActive?: boolean }
+  ): Promise<Procedure> {
+    // 1. Fetch source procedure
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+
+    // 2. Fetch target practitioner
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, targetPractitionerId);
+    const practitionerSnapshot = await getDoc(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(`Target practitioner with ID ${targetPractitionerId} not found`);
+    }
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+
+    // 3. Validate certification
+    if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+      );
+    }
+
+    // 4. Check if practitioner already has a procedure with the same technology ID in this clinic branch
+    const existingProceduresQuery = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where('practitionerId', '==', targetPractitionerId),
+      where('clinicBranchId', '==', sourceProcedure.clinicBranchId),
+      where('isActive', '==', true)
+    );
+    const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+    
+    const hasSameTechnology = existingProcedures.some(
+      proc => proc.technology?.id === sourceProcedure.technology?.id
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${sourceProcedure.technology?.name || sourceProcedure.technology?.id}" in this clinic branch`
+      );
+    }
+
+    // 5. Prepare data for new procedure
+    const newProcedureId = this.generateId();
+
+    // Create aggregated doctor info for the new procedure
+    const doctorInfo = {
+      id: practitioner.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || '',
+      photo:
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
+          ? practitioner.basicInfo.profileImageUrl
+          : '',
+      rating: practitioner.reviewInfo?.averageRating || 0,
+      services: practitioner.procedures || [],
+    };
+
+    // Construct the new procedure object
+    // We copy everything from source, but override specific fields
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
+      ...sourceProcedure,
+      id: newProcedureId,
+      practitionerId: targetPractitionerId,
+      doctorInfo, // Link to new doctor
+      
+      // Reset review info for the new procedure
+      reviewInfo: {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      },
+
+      // Apply any overrides if provided
+      ...(overrides?.price !== undefined && { price: overrides.price }),
+      ...(overrides?.duration !== undefined && { duration: overrides.duration }),
+      ...(overrides?.description !== undefined && { description: overrides.description }),
+      
+      // Ensure it's active by default unless specified otherwise
+      isActive: overrides?.isActive !== undefined ? overrides.isActive : true,
+    };
+
+    // 6. Save to Firestore
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, newProcedureId);
+    await setDoc(procedureRef, {
+      ...newProcedure,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+
+    // 7. Return the new procedure
+    const savedDoc = await getDoc(procedureRef);
+    return savedDoc.data() as Procedure;
+  }
+
+  /**
+   * Clones an existing procedure for multiple target practitioners.
+   * This creates new procedure documents with the same data as the source procedure,
+   * but linked to each target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+   * @returns Array of newly created procedures
+   */
+  async bulkCloneProcedureForPractitioners(
+    sourceProcedureId: string,
+    targetPractitionerIds: string[],
+    overrides?: Partial<CreateProcedureData> & { isActive?: boolean }
+  ): Promise<Procedure[]> {
+    if (!targetPractitionerIds || targetPractitionerIds.length === 0) {
+      throw new Error('At least one target practitioner ID is required');
+    }
+
+    // 1. Fetch source procedure
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+
+    // 2. Fetch all target practitioners
+    const practitionerPromises = targetPractitionerIds.map(id =>
+      getDoc(doc(this.db, PRACTITIONERS_COLLECTION, id))
+    );
+    const practitionerSnapshots = await Promise.all(practitionerPromises);
+
+    // 3. Validate all practitioners exist, can perform the procedure, and don't already have the same technology
+    const practitioners: Practitioner[] = [];
+    const sourceTechnologyId = sourceProcedure.technology?.id;
+    
+    for (let i = 0; i < practitionerSnapshots.length; i++) {
+      const snapshot = practitionerSnapshots[i];
+      if (!snapshot.exists()) {
+        throw new Error(`Target practitioner with ID ${targetPractitionerIds[i]} not found`);
+      }
+      const practitioner = snapshot.data() as Practitioner;
+      
+      if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+        );
+      }
+
+      // Check if practitioner already has a procedure with the same technology ID in this clinic branch
+      const existingProceduresQuery = query(
+        collection(this.db, PROCEDURES_COLLECTION),
+        where('practitionerId', '==', practitioner.id),
+        where('clinicBranchId', '==', sourceProcedure.clinicBranchId),
+        where('isActive', '==', true)
+      );
+      const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+      const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+      
+      const hasSameTechnology = existingProcedures.some(
+        proc => proc.technology?.id === sourceTechnologyId
+      );
+      if (hasSameTechnology) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${sourceProcedure.technology?.name || sourceTechnologyId}" in this clinic branch`
+        );
+      }
+      
+      practitioners.push(practitioner);
+    }
+
+    // 4. Create procedures in batch
+    const batch = writeBatch(this.db);
+    const newProcedures: Omit<Procedure, 'createdAt' | 'updatedAt'>[] = [];
+
+    for (const practitioner of practitioners) {
+      const newProcedureId = this.generateId();
+
+      // Create aggregated doctor info for the new procedure
+      const doctorInfo = {
+        id: practitioner.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || '',
+        photo:
+          typeof practitioner.basicInfo.profileImageUrl === 'string'
+            ? practitioner.basicInfo.profileImageUrl
+            : '',
+        rating: practitioner.reviewInfo?.averageRating || 0,
+        services: practitioner.procedures || [],
+      };
+
+      // Construct the new procedure object
+      const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
+        ...sourceProcedure,
+        id: newProcedureId,
+        practitionerId: practitioner.id,
+        doctorInfo,
+        
+        // Reset review info for the new procedure
+        reviewInfo: {
+          totalReviews: 0,
+          averageRating: 0,
+          effectivenessOfTreatment: 0,
+          outcomeExplanation: 0,
+          painManagement: 0,
+          followUpCare: 0,
+          valueForMoney: 0,
+          recommendationPercentage: 0,
+        },
+
+        // Apply any overrides if provided
+        ...(overrides?.price !== undefined && { price: overrides.price }),
+        ...(overrides?.duration !== undefined && { duration: overrides.duration }),
+        ...(overrides?.description !== undefined && { description: overrides.description }),
+        
+        // Ensure it's active by default unless specified otherwise
+        isActive: overrides?.isActive !== undefined ? overrides.isActive : true,
+      };
+
+      newProcedures.push(newProcedure);
+
+      // Add to batch
+      const procedureRef = doc(this.db, PROCEDURES_COLLECTION, newProcedureId);
+      batch.set(procedureRef, {
+        ...newProcedure,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      });
+    }
+
+    // 5. Commit batch
+    await batch.commit();
+
+    // 6. Fetch and return the created procedures
+    const createdProcedures = await Promise.all(
+      newProcedures.map(p => this.getProcedure(p.id))
+    );
+
+    return createdProcedures.filter((p): p is Procedure => p !== null);
+  }
+
   /**
    * Creates multiple procedures for a list of practitioners based on common data.
    * This method is optimized for bulk creation to reduce database reads and writes.
@@ -485,7 +806,49 @@ export class ProcedureService extends BaseService {
       throw new Error(`The following practitioners were not found: ${notFoundIds.join(', ')}`);
     }
 
-    // 5. Use a Firestore batch for atomic creation
+    // 5. Check for duplicates across all practitioners before creating any procedures
+    const duplicatePractitioners: string[] = [];
+    const duplicateChecks = await Promise.all(
+      practitionerIds.map(async (practitionerId) => {
+        const existingProceduresQuery = query(
+          collection(this.db, PROCEDURES_COLLECTION),
+          where('practitionerId', '==', practitionerId),
+          where('clinicBranchId', '==', validatedData.clinicBranchId),
+          where('isActive', '==', true)
+        );
+        const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+        const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+        
+        const hasSameTechnology = existingProcedures.some(
+          proc => proc.technology?.id === validatedData.technologyId
+        );
+        
+        return { practitionerId, hasSameTechnology };
+      })
+    );
+
+    // Collect all practitioners with duplicates
+    duplicateChecks.forEach(({ practitionerId, hasSameTechnology }) => {
+      if (hasSameTechnology) {
+        duplicatePractitioners.push(practitionerId);
+      }
+    });
+
+    // If any duplicates found, throw error listing all of them
+    if (duplicatePractitioners.length > 0) {
+      const duplicateNames = duplicatePractitioners
+        .map(id => {
+          const practitioner = practitionersMap.get(id)!;
+          return `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`;
+        })
+        .join(', ');
+      
+      throw new Error(
+        `The following practitioner(s) already have a procedure with technology "${technology?.name || validatedData.technologyId}" in this clinic branch: ${duplicateNames}. Please remove them from the selection and try again.`
+      );
+    }
+
+    // 6. Use a Firestore batch for atomic creation
     const batch = writeBatch(this.db);
     const createdProcedureIds: string[] = [];
     const clinicInfo = {
@@ -585,10 +948,10 @@ export class ProcedureService extends BaseService {
       });
     }
 
-    // 6. Commit the atomic batch write
+    // 7. Commit the atomic batch write
     await batch.commit();
 
-    // 7. Fetch and return the newly created procedures
+    // 8. Fetch and return the newly created procedures
     const fetchedProcedures: Procedure[] = [];
     for (let i = 0; i < createdProcedureIds.length; i += 30) {
       const chunk = createdProcedureIds.slice(i, i + 30);