@blackcode_sa/metaestetics-api 1.7.26 → 1.7.28

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/calendar/index.ts

@@ -227,3 +227,32 @@ export interface SearchCalendarEventsParams {
   /** Optional filter for event type. */
   eventType?: CalendarEventType;
 }
+
+/**
+ * Interface for creating blocking events
+ */
+export interface CreateBlockingEventParams {
+  entityType: "practitioner" | "clinic";
+  entityId: string;
+  eventName: string;
+  eventTime: CalendarEventTime;
+  eventType:
+    | CalendarEventType.BLOCKING
+    | CalendarEventType.BREAK
+    | CalendarEventType.FREE_DAY
+    | CalendarEventType.OTHER;
+  description?: string;
+}
+
+/**
+ * Interface for updating blocking events
+ */
+export interface UpdateBlockingEventParams {
+  entityType: "practitioner" | "clinic";
+  entityId: string;
+  eventId: string;
+  eventName?: string;
+  eventTime?: CalendarEventTime;
+  description?: string;
+  status?: CalendarEventStatus;
+}

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/calendar.schema.ts

@@ -4,6 +4,8 @@ import {
   CalendarEventStatus,
   CalendarEventType,
   CalendarSyncStatus,
+  CreateBlockingEventParams,
+  UpdateBlockingEventParams,
 } from "../types/calendar";
 import { SyncedCalendarProvider } from "../types/calendar/synced-calendar.types";
 import {
@@ -221,3 +223,42 @@ export const calendarEventSchema = z.object({
   createdAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
   updatedAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
 });
+
+/**
+ * Validation schema for creating blocking events
+ * Based on CreateBlockingEventParams interface
+ */
+export const createBlockingEventSchema = z.object({
+  entityType: z.enum(["practitioner", "clinic"]),
+  entityId: z.string().min(1, "Entity ID is required"),
+  eventName: z
+    .string()
+    .min(1, "Event name is required")
+    .max(200, "Event name too long"),
+  eventTime: calendarEventTimeSchema,
+  eventType: z.enum([
+    CalendarEventType.BLOCKING,
+    CalendarEventType.BREAK,
+    CalendarEventType.FREE_DAY,
+    CalendarEventType.OTHER,
+  ]),
+  description: z.string().max(1000, "Description too long").optional(),
+});
+
+/**
+ * Validation schema for updating blocking events
+ * Based on UpdateBlockingEventParams interface
+ */
+export const updateBlockingEventSchema = z.object({
+  entityType: z.enum(["practitioner", "clinic"]),
+  entityId: z.string().min(1, "Entity ID is required"),
+  eventId: z.string().min(1, "Event ID is required"),
+  eventName: z
+    .string()
+    .min(1, "Event name is required")
+    .max(200, "Event name too long")
+    .optional(),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z.string().max(1000, "Description too long").optional(),
+  status: z.nativeEnum(CalendarEventStatus).optional(),
+});

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),