@blackcode_sa/metaestetics-api 1.7.27 → 1.7.28

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/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;
+    }
+  }
 }

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

@@ -1001,4 +1001,145 @@ export class ProcedureService extends BaseService {
 
     return filteredProcedures;
   }
+
+  /**
+   * Creates a consultation procedure without requiring a product
+   * This is a special method for consultation procedures that don't use products
+   * @param data - The data for creating a consultation procedure (without productId)
+   * @returns The created procedure
+   */
+  async createConsultationProcedure(
+    data: Omit<CreateProcedureData, "productId">
+  ): Promise<Procedure> {
+    // Generate procedure ID first so we can use it for media uploads
+    const procedureId = this.generateId();
+
+    // Get references to related entities (Category, Subcategory, Technology)
+    // For consultation, we don't need a product
+    const [category, subcategory, technology] = await Promise.all([
+      this.categoryService.getById(data.categoryId),
+      this.subcategoryService.getById(data.categoryId, data.subcategoryId),
+      this.technologyService.getById(data.technologyId),
+    ]);
+
+    if (!category || !subcategory || !technology) {
+      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, data.clinicBranchId);
+    const clinicSnapshot = await getDoc(clinicRef);
+    if (!clinicSnapshot.exists()) {
+      throw new Error(`Clinic with ID ${data.clinicBranchId} not found`);
+    }
+    const clinic = clinicSnapshot.data() as Clinic;
+
+    const practitionerRef = doc(
+      this.db,
+      PRACTITIONERS_COLLECTION,
+      data.practitionerId
+    );
+    const practitionerSnapshot = await getDoc(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(`Practitioner with ID ${data.practitionerId} not found`);
+    }
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+
+    // Process photos if provided
+    let processedPhotos: string[] = [];
+    if (data.photos && data.photos.length > 0) {
+      processedPhotos = await this.processMediaArray(
+        data.photos,
+        procedureId,
+        "procedure-photos"
+      );
+    }
+
+    // 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
+          ? typeof clinic.featuredPhotos[0] === "string"
+            ? clinic.featuredPhotos[0]
+            : ""
+          : typeof clinic.coverPhoto === "string"
+          ? clinic.coverPhoto
+          : "",
+      location: clinic.location,
+      contactInfo: clinic.contactInfo,
+    };
+
+    // Create aggregated doctor info for the procedure document
+    const doctorInfo = {
+      id: practitionerSnapshot.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 || [],
+    };
+
+    // Create a placeholder product for consultation procedures
+    const consultationProduct: Product = {
+      id: "consultation-no-product",
+      name: "No Product Required",
+      description: "Consultation procedures do not require specific products",
+      brandId: "consultation-brand",
+      brandName: "Consultation",
+      technologyId: data.technologyId,
+      technologyName: technology.name,
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    // Create the procedure object
+    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+      id: procedureId,
+      ...data,
+      photos: processedPhotos,
+      category,
+      subcategory,
+      technology,
+      product: consultationProduct, // Use placeholder product
+      blockingConditions: technology.blockingConditions,
+      contraindications: technology.contraindications || [],
+      treatmentBenefits: technology.benefits,
+      preRequirements: technology.requirements.pre,
+      postRequirements: technology.requirements.post,
+      certificationRequirement: technology.certificationRequirement,
+      documentationTemplates: technology?.documentationTemplates || [],
+      clinicInfo,
+      doctorInfo,
+      reviewInfo: {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      },
+      isActive: true,
+    };
+
+    // Create the procedure document
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
+    await setDoc(procedureRef, {
+      ...newProcedure,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+
+    // Return the created procedure (fetch again to get server timestamps)
+    const savedDoc = await getDoc(procedureRef);
+    return savedDoc.data() as Procedure;
+  }
 }

package/src/types/practitioner/index.ts

@@ -94,6 +94,7 @@ export interface Practitioner {
   clinicWorkingHours: PractitionerClinicWorkingHours[]; // Radno vreme za svaku kliniku
   clinicsInfo: ClinicInfo[]; // Aggregated clinic information
   procedures: string[]; // Reference na procedure koje izvodi
+  freeConsultations?: Record<string, string> | null; // Map of clinic IDs to procedure ID for free consultations (one per clinic)
   proceduresInfo: ProcedureSummaryInfo[]; // Aggregated procedure information
   reviewInfo: PractitionerReviewInfo; // Aggregated review information
   isActive: boolean;
@@ -113,6 +114,7 @@ export interface CreatePractitionerData {
   clinics?: string[];
   clinicWorkingHours?: PractitionerClinicWorkingHours[];
   clinicsInfo?: ClinicInfo[];
+  freeConsultations?: Record<string, string> | null;
   isActive: boolean;
   isVerified: boolean;
   status?: PractitionerStatus;
@@ -127,6 +129,7 @@ export interface CreateDraftPractitionerData {
   clinics?: string[];
   clinicWorkingHours?: PractitionerClinicWorkingHours[];
   clinicsInfo?: ClinicInfo[];
+  freeConsultations?: Record<string, string> | null;
   isActive?: boolean;
   isVerified?: boolean;
 }

package/src/validations/practitioner.schema.ts

@@ -125,6 +125,7 @@ export const practitionerSchema = z.object({
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema),
   clinicsInfo: z.array(clinicInfoSchema),
   procedures: z.array(z.string()),
+  freeConsultations: z.record(z.string(), z.string()).optional().nullable(),
   proceduresInfo: z.array(procedureSummaryInfoSchema),
   reviewInfo: practitionerReviewInfoSchema,
   isActive: z.boolean(),
@@ -144,6 +145,7 @@ export const createPractitionerSchema = z.object({
   clinics: z.array(z.string()).optional(),
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
   clinicsInfo: z.array(clinicInfoSchema).optional(),
+  freeConsultations: z.record(z.string(), z.string()).optional().nullable(),
   proceduresInfo: z.array(procedureSummaryInfoSchema).optional(),
   isActive: z.boolean(),
   isVerified: z.boolean(),
@@ -159,6 +161,7 @@ export const createDraftPractitionerSchema = z.object({
   clinics: z.array(z.string()).optional(),
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
   clinicsInfo: z.array(clinicInfoSchema).optional(),
+  freeConsultations: z.record(z.string(), z.string()).optional().nullable(),
   proceduresInfo: z.array(procedureSummaryInfoSchema).optional(),
   isActive: z.boolean().optional().default(false),
   isVerified: z.boolean().optional().default(false),