@blackcode_sa/metaestetics-api 1.7.27 → 1.7.29

package/src/admin/aggregation/procedure/procedure.aggregation.service.ts

@@ -35,8 +35,14 @@ export class ProcedureAggregationService {
     }
 
     const procedureId = procedureSummary.id;
+    const clinicId = procedureSummary.clinicId;
+    const isFreeConsultation =
+      procedureSummary.technologyName === "free-consultation-tech";
+
     console.log(
-      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}.`
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}. ${
+        isFreeConsultation ? "(Free Consultation)" : ""
+      }`
     );
 
     const practitionerRef = this.db
@@ -44,11 +50,54 @@ export class ProcedureAggregationService {
       .doc(practitionerId);
 
     try {
-      await practitionerRef.update({
+      // Prepare the basic update data
+      const updateData: any = {
         procedureIds: admin.firestore.FieldValue.arrayUnion(procedureId),
         proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
         updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-      });
+      };
+
+      // If this is a free consultation, we need to update the freeConsultations map
+      if (isFreeConsultation) {
+        await this.db.runTransaction(async (transaction) => {
+          const practitionerDoc = await transaction.get(practitionerRef);
+          if (!practitionerDoc.exists) {
+            throw new Error(
+              `Practitioner ${practitionerId} does not exist for adding free consultation`
+            );
+          }
+
+          const practitionerData = practitionerDoc.data();
+          const currentFreeConsultations =
+            practitionerData?.freeConsultations || {};
+
+          // Check if there's already a free consultation for this clinic
+          if (currentFreeConsultations[clinicId]) {
+            console.log(
+              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a free consultation ${currentFreeConsultations[clinicId]}. Replacing with new one ${procedureId}.`
+            );
+          }
+
+          // Set the single procedure ID for this clinic (replaces any existing one)
+          const updatedFreeConsultations = {
+            ...currentFreeConsultations,
+            [clinicId]: procedureId,
+          };
+
+          // Apply all updates including freeConsultations
+          transaction.update(practitionerRef, {
+            ...updateData,
+            freeConsultations: updatedFreeConsultations,
+          });
+
+          console.log(
+            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId}`
+          );
+        });
+      } else {
+        // For regular procedures, just do the standard update
+        await practitionerRef.update(updateData);
+      }
 
       console.log(
         `[ProcedureAggregationService] Successfully added procedure ${procedureId} to practitioner ${practitionerId}.`
@@ -374,11 +423,13 @@ export class ProcedureAggregationService {
    * Removes procedure from a practitioner when a procedure is deleted or inactivated
    * @param practitionerId - ID of the practitioner who performs the procedure
    * @param procedureId - ID of the procedure
+   * @param clinicId - Optional clinic ID for free consultation removal
    * @returns {Promise<void>}
    */
   async removeProcedureFromPractitioner(
     practitionerId: string,
-    procedureId: string
+    procedureId: string,
+    clinicId?: string
   ): Promise<void> {
     if (!practitionerId || !procedureId) {
       console.log(
@@ -414,17 +465,52 @@ export class ProcedureAggregationService {
         // Get current procedures info array
         const proceduresInfo = practitionerData.proceduresInfo || [];
 
+        // Find the procedure being removed to check if it's a free consultation
+        const procedureBeingRemoved = proceduresInfo.find(
+          (p: any) => p.id === procedureId
+        );
+
+        const isFreeConsultation =
+          procedureBeingRemoved?.technologyName === "free-consultation-tech";
+        const procedureClinicId = clinicId || procedureBeingRemoved?.clinicId;
+
         // Remove the procedure summary
         const updatedProceduresInfo = proceduresInfo.filter(
-          (p: ProcedureSummaryInfo) => p.id !== procedureId
+          (p: any) => p.id !== procedureId
         );
 
-        // Update the practitioner document
-        transaction.update(practitionerRef, {
+        // Prepare update data
+        const updateData: any = {
           procedureIds: admin.firestore.FieldValue.arrayRemove(procedureId),
           proceduresInfo: updatedProceduresInfo,
           updatedAt: admin.firestore.FieldValue.serverTimestamp(),
-        });
+        };
+
+        // If this is a free consultation, also remove it from the freeConsultations map
+        if (isFreeConsultation && procedureClinicId) {
+          const currentFreeConsultations =
+            practitionerData.freeConsultations || {};
+
+          // Check if this clinic's free consultation matches the procedure being removed
+          if (currentFreeConsultations[procedureClinicId] === procedureId) {
+            // Remove the clinic entry from the freeConsultations map
+            const updatedFreeConsultations = { ...currentFreeConsultations };
+            delete updatedFreeConsultations[procedureClinicId];
+
+            updateData.freeConsultations = updatedFreeConsultations;
+
+            console.log(
+              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${procedureClinicId}`
+            );
+          } else {
+            console.log(
+              `[ProcedureAggregationService] Free consultation mismatch for clinic ${procedureClinicId}: expected ${procedureId}, found ${currentFreeConsultations[procedureClinicId]}`
+            );
+          }
+        }
+
+        // Update the practitioner document
+        transaction.update(practitionerRef, updateData);
       });
 
       console.log(
@@ -505,4 +591,112 @@ export class ProcedureAggregationService {
       throw error;
     }
   }
+
+  /**
+   * Handles procedure status changes (activation/deactivation) specifically for free consultations
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureId - ID of the procedure
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param isActive - New active status of the procedure
+   * @param technologyName - Technology name of the procedure (to check if it's a free consultation)
+   * @returns {Promise<void>}
+   */
+  async handleFreeConsultationStatusChange(
+    practitionerId: string,
+    procedureId: string,
+    clinicId: string,
+    isActive: boolean,
+    technologyName: string
+  ): Promise<void> {
+    if (!practitionerId || !procedureId || !clinicId) {
+      console.log(
+        "[ProcedureAggregationService] Missing required parameters for handling free consultation status change. Skipping."
+      );
+      return;
+    }
+
+    // Only handle free consultations
+    if (technologyName !== "free-consultation-tech") {
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Handling free consultation status change: procedure ${procedureId} for practitioner ${practitionerId} in clinic ${clinicId}. New status: ${
+        isActive ? "active" : "inactive"
+      }`
+    );
+
+    const practitionerRef = this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId);
+
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const practitionerDoc = await transaction.get(practitionerRef);
+        if (!practitionerDoc.exists) {
+          throw new Error(
+            `Practitioner ${practitionerId} does not exist for free consultation status change`
+          );
+        }
+
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for free consultation status change`
+          );
+        }
+
+        const currentFreeConsultations =
+          practitionerData.freeConsultations || {};
+        let updatedFreeConsultations = { ...currentFreeConsultations };
+
+        if (isActive) {
+          // If procedure is being activated, set it as the free consultation for this clinic
+          if (
+            currentFreeConsultations[clinicId] &&
+            currentFreeConsultations[clinicId] !== procedureId
+          ) {
+            console.log(
+              `[ProcedureAggregationService] Warning: Clinic ${clinicId} already has a different free consultation ${currentFreeConsultations[clinicId]}. Replacing with ${procedureId}.`
+            );
+          }
+
+          updatedFreeConsultations[clinicId] = procedureId;
+
+          console.log(
+            `[ProcedureAggregationService] Set free consultation ${procedureId} for practitioner ${practitionerId} at clinic ${clinicId} (activated)`
+          );
+        } else {
+          // If procedure is being deactivated, remove it from the free consultations map
+          if (currentFreeConsultations[clinicId] === procedureId) {
+            delete updatedFreeConsultations[clinicId];
+
+            console.log(
+              `[ProcedureAggregationService] Removed free consultation ${procedureId} from practitioner ${practitionerId} for clinic ${clinicId} (deactivated)`
+            );
+          } else {
+            console.log(
+              `[ProcedureAggregationService] Free consultation mismatch for clinic ${clinicId}: expected ${procedureId}, found ${currentFreeConsultations[clinicId]}`
+            );
+          }
+        }
+
+        // Update the practitioner document with the new freeConsultations map
+        transaction.update(practitionerRef, {
+          freeConsultations: updatedFreeConsultations,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully handled free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error handling free consultation status change for procedure ${procedureId} of practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
 }

package/src/admin/free-consultation/free-consultation-utils.admin.ts

@@ -0,0 +1,147 @@
+import * as admin from "firebase-admin";
+import { ProcedureFamily } from "../../backoffice/types/static/procedure-family.types";
+import {
+  CertificationLevel,
+  CertificationSpecialty,
+} from "../../backoffice/types/static/certification.types";
+import { CATEGORIES_COLLECTION } from "../../backoffice/types/category.types";
+import { SUBCATEGORIES_COLLECTION } from "../../backoffice/types/subcategory.types";
+import { TECHNOLOGIES_COLLECTION } from "../../backoffice/types/technology.types";
+
+/**
+ * Ensures that the free consultation infrastructure exists in the database
+ * Creates category, subcategory, and technology if they don't exist
+ * @param db - Firestore database instance (optional, defaults to admin.firestore())
+ * @returns Promise<boolean> - Always returns true after ensuring infrastructure exists
+ */
+export async function freeConsultationInfrastructure(
+  db?: admin.firestore.Firestore
+): Promise<boolean> {
+  const firestore = db || admin.firestore();
+
+  try {
+    console.log(
+      "[freeConsultationInfrastructure] Checking free consultation infrastructure..."
+    );
+
+    // Check if the technology already exists
+    const technologyRef = firestore
+      .collection(TECHNOLOGIES_COLLECTION)
+      .doc("free-consultation-tech");
+
+    const technologyDoc = await technologyRef.get();
+
+    if (technologyDoc.exists) {
+      console.log(
+        "[freeConsultationInfrastructure] Free consultation infrastructure already exists"
+      );
+      return true;
+    }
+
+    console.log(
+      "[freeConsultationInfrastructure] Creating free consultation infrastructure..."
+    );
+
+    // Create the infrastructure in the correct order: Category → Subcategory → Technology
+    await createFreeConsultationInfrastructure(firestore);
+
+    console.log(
+      "[freeConsultationInfrastructure] Successfully created free consultation infrastructure"
+    );
+    return true;
+  } catch (error) {
+    console.error(
+      "[freeConsultationInfrastructure] Error ensuring infrastructure:",
+      error
+    );
+    throw error;
+  }
+}
+
+/**
+ * Creates the complete free consultation infrastructure
+ * @param db - Firestore database instance
+ */
+async function createFreeConsultationInfrastructure(
+  db: admin.firestore.Firestore
+): Promise<void> {
+  const batch = db.batch();
+  const now = new Date();
+
+  // 1. Create Category: "consultation"
+  const categoryRef = db.collection(CATEGORIES_COLLECTION).doc("consultation");
+  const categoryData = {
+    id: "consultation",
+    name: "Consultation",
+    description:
+      "Professional consultation services for treatment planning and assessment",
+    family: ProcedureFamily.AESTHETICS,
+    isActive: true,
+    createdAt: now,
+    updatedAt: now,
+  };
+  batch.set(categoryRef, categoryData);
+
+  // 2. Create Subcategory: "free-consultation"
+  const subcategoryRef = db
+    .collection(CATEGORIES_COLLECTION)
+    .doc("consultation")
+    .collection(SUBCATEGORIES_COLLECTION)
+    .doc("free-consultation");
+
+  const subcategoryData = {
+    id: "free-consultation",
+    name: "Free Consultation",
+    description:
+      "Complimentary initial consultation to discuss treatment options and assess patient needs",
+    categoryId: "consultation",
+    isActive: true,
+    createdAt: now,
+    updatedAt: now,
+  };
+  batch.set(subcategoryRef, subcategoryData);
+
+  // 3. Create Technology: "free-consultation-tech"
+  const technologyRef = db
+    .collection(TECHNOLOGIES_COLLECTION)
+    .doc("free-consultation-tech");
+  const technologyData = {
+    id: "free-consultation-tech",
+    name: "Free Consultation Technology",
+    description:
+      "Technology framework for providing free initial consultations to patients",
+    family: ProcedureFamily.AESTHETICS,
+    categoryId: "consultation",
+    subcategoryId: "free-consultation",
+    technicalDetails:
+      "Standard consultation protocol for initial patient assessment",
+    requirements: {
+      pre: [], // No pre-requirements for consultation
+      post: [], // No post-requirements for consultation
+    },
+    blockingConditions: [], // No blocking conditions for consultation
+    contraindications: [], // No contraindications for consultation
+    benefits: [
+      "IMPROVED_PATIENT_UNDERSTANDING",
+      "BETTER_TREATMENT_PLANNING",
+      "ENHANCED_PATIENT_CONFIDENCE",
+    ],
+    certificationRequirement: {
+      minimumLevel: CertificationLevel.AESTHETICIAN,
+      requiredSpecialties: [], // No required specialties for consultation
+    },
+    documentationTemplates: [],
+    isActive: true,
+    createdAt: now,
+    updatedAt: now,
+  };
+  batch.set(technologyRef, technologyData);
+
+  // Commit all changes atomically
+  await batch.commit();
+
+  console.log("[freeConsultationInfrastructure] Successfully created:");
+  console.log("  ✓ Category: consultation");
+  console.log("  ✓ Subcategory: free-consultation");
+  console.log("  ✓ Technology: free-consultation-tech");
+}

package/src/services/practitioner/practitioner.service.ts

@@ -55,19 +55,29 @@ import { distanceBetween } from "geofire-common";
 import { CertificationSpecialty } from "../../backoffice/types/static/certification.types";
 import { Clinic, DoctorInfo, CLINICS_COLLECTION } from "../../types/clinic";
 import { ClinicInfo } from "../../types/profile";
+import { ProcedureService } from "../procedure/procedure.service";
+import { ProcedureFamily } from "../../backoffice/types/static/procedure-family.types";
+import {
+  Currency,
+  PricingMeasure,
+} from "../../backoffice/types/static/pricing.types";
+import { CreateProcedureData } from "../../types/procedure";
 
 export class PractitionerService extends BaseService {
   private clinicService?: ClinicService;
   private mediaService: MediaService;
+  private procedureService?: ProcedureService;
 
   constructor(
     db: Firestore,
     auth: Auth,
     app: FirebaseApp,
-    clinicService?: ClinicService
+    clinicService?: ClinicService,
+    procedureService?: ProcedureService
   ) {
     super(db, auth, app);
     this.clinicService = clinicService;
+    this.procedureService = procedureService;
     this.mediaService = new MediaService(db, auth, app);
   }
 
@@ -78,10 +88,21 @@ export class PractitionerService extends BaseService {
     return this.clinicService;
   }
 
+  private getProcedureService(): ProcedureService {
+    if (!this.procedureService) {
+      throw new Error("Procedure service not initialized!");
+    }
+    return this.procedureService;
+  }
+
   setClinicService(clinicService: ClinicService): void {
     this.clinicService = clinicService;
   }
 
+  setProcedureService(procedureService: ProcedureService): void {
+    this.procedureService = procedureService;
+  }
+
   /**
    * Handles profile photo upload for practitioners
    * @param profilePhoto - MediaResource (File, Blob, or URL string)
@@ -1183,4 +1204,160 @@ export class PractitionerService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Enables free consultation for a practitioner in a specific clinic
+   * Creates a free consultation procedure with hardcoded parameters
+   * @param practitionerId - ID of the practitioner
+   * @param clinicId - ID of the clinic
+   * @returns The created consultation procedure
+   */
+  async EnableFreeConsultation(
+    practitionerId: string,
+    clinicId: string
+  ): Promise<void> {
+    try {
+      // Validate that practitioner exists and is active
+      const practitioner = await this.getPractitioner(practitionerId);
+      if (!practitioner) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+
+      if (
+        !practitioner.isActive ||
+        practitioner.status !== PractitionerStatus.ACTIVE
+      ) {
+        throw new Error(`Practitioner ${practitionerId} is not active`);
+      }
+
+      // Validate that clinic exists
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+
+      // Check if practitioner is associated with this clinic
+      if (!practitioner.clinics.includes(clinicId)) {
+        throw new Error(
+          `Practitioner ${practitionerId} is not associated with clinic ${clinicId}`
+        );
+      }
+
+      // Check if free consultation already exists for this practitioner in this clinic
+      const existingProcedures =
+        await this.getProcedureService().getProceduresByPractitioner(
+          practitionerId
+        );
+      const existingConsultation = existingProcedures.find(
+        (procedure) =>
+          procedure.name === "Free Consultation" &&
+          procedure.clinicBranchId === clinicId &&
+          procedure.isActive
+      );
+
+      if (existingConsultation) {
+        console.log(
+          `Free consultation already exists for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        return;
+      }
+
+      // Create procedure data for free consultation (without productId)
+      const consultationData: Omit<CreateProcedureData, "productId"> = {
+        name: "Free Consultation",
+        description:
+          "Free initial consultation to discuss treatment options and assess patient needs.",
+        family: ProcedureFamily.AESTHETICS,
+        categoryId: "consultation",
+        subcategoryId: "free-consultation",
+        technologyId: "free-consultation-tech",
+        price: 0,
+        currency: Currency.EUR,
+        pricingMeasure: PricingMeasure.PER_SESSION,
+        duration: 30, // 30 minutes consultation
+        practitionerId: practitionerId,
+        clinicBranchId: clinicId,
+        photos: [], // No photos for consultation
+      };
+
+      // Create the consultation procedure using the special method
+      await this.getProcedureService().createConsultationProcedure(
+        consultationData
+      );
+
+      console.log(
+        `Free consultation enabled for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
+    } catch (error) {
+      console.error(
+        `Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Disables free consultation for a practitioner in a specific clinic
+   * Finds and deactivates the existing free consultation procedure
+   * @param practitionerId - ID of the practitioner
+   * @param clinicId - ID of the clinic
+   */
+  async DisableFreeConsultation(
+    practitionerId: string,
+    clinicId: string
+  ): Promise<void> {
+    try {
+      // Validate that practitioner exists
+      const practitioner = await this.getPractitioner(practitionerId);
+      if (!practitioner) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+
+      // Validate that clinic exists
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+
+      // Check if practitioner is associated with this clinic
+      if (!practitioner.clinics.includes(clinicId)) {
+        throw new Error(
+          `Practitioner ${practitionerId} is not associated with clinic ${clinicId}`
+        );
+      }
+
+      // Find the free consultation procedure for this practitioner in this clinic
+      const existingProcedures =
+        await this.getProcedureService().getProceduresByPractitioner(
+          practitionerId
+        );
+      const freeConsultation = existingProcedures.find(
+        (procedure) =>
+          procedure.name === "Free Consultation" &&
+          procedure.clinicBranchId === clinicId &&
+          procedure.isActive
+      );
+
+      if (!freeConsultation) {
+        console.log(
+          `No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        return;
+      }
+
+      // Deactivate the consultation procedure
+      await this.getProcedureService().deactivateProcedure(freeConsultation.id);
+
+      console.log(
+        `Free consultation disabled for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
+    } catch (error) {
+      console.error(
+        `Error disabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
 }