@blackcode_sa/metaestetics-api 1.12.61 → 1.12.63

package/package.json

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

package/src/backoffice/services/technology.service.ts

@@ -82,6 +82,9 @@ export class TechnologyService extends BaseService implements ITechnologyService
     if (technology.technicalDetails) {
       newTechnology.technicalDetails = technology.technicalDetails;
     }
+    if (technology.photoTemplate) {
+      newTechnology.photoTemplate = technology.photoTemplate;
+    }
 
     const docRef = await addDoc(this.technologiesRef, newTechnology as any);
     return { id: docRef.id, ...newTechnology };
@@ -240,6 +243,16 @@ export class TechnologyService extends BaseService implements ITechnologyService
       }
     });
 
+    // Handle photoTemplate: if explicitly set to null or empty string, allow it to be cleared
+    // If undefined, don't include it in the update (field won't change)
+    if ('photoTemplate' in technology) {
+      if (technology.photoTemplate === null || technology.photoTemplate === '') {
+        updateData.photoTemplate = null;
+      } else if (technology.photoTemplate !== undefined) {
+        updateData.photoTemplate = technology.photoTemplate;
+      }
+    }
+
     updateData.updatedAt = new Date();
 
     const docRef = doc(this.technologiesRef, id);

package/src/backoffice/types/technology.types.ts

@@ -69,6 +69,8 @@ export interface Technology {
   benefits: TreatmentBenefitDynamic[];
   certificationRequirement: CertificationRequirement;
   documentationTemplates?: TechnologyDocumentationTemplate[];
+  /** Media ID of the default photo template image for this technology */
+  photoTemplate?: string;
   isActive: boolean;
   createdAt: Date;
   updatedAt: Date;

package/src/backoffice/validations/schemas.ts

@@ -120,6 +120,7 @@ export const technologySchema = z.object({
   documentationTemplates: z.array(documentTemplateSchema),
   benefits: z.array(treatmentBenefitSchemaBackoffice),
   certificationRequirement: certificationRequirementSchema,
+  photoTemplate: z.string().url("Photo template must be a valid URL").optional(),
   isActive: z.boolean().default(true),
 });
 

package/src/services/appointment/appointment.service.ts

@@ -14,6 +14,8 @@ import {
   startAfter,
   getDocs,
   getCountFromServer,
+  doc,
+  getDoc,
 } from 'firebase/firestore';
 import { Auth } from 'firebase/auth';
 import { FirebaseApp } from 'firebase/app';
@@ -34,8 +36,10 @@ import {
   ExtendedProcedureInfo,
   AppointmentProductMetadata,
   RecommendedProcedure,
+  NextStepsRecommendation,
   APPOINTMENTS_COLLECTION,
 } from '../../types/appointment';
+import { PROCEDURES_COLLECTION } from '../../types/procedure';
 import {
   updateAppointmentSchema,
   searchAppointmentsSchema,
@@ -2079,4 +2083,423 @@ export class AppointmentService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Gets all next steps recommendations for a patient from their past appointments.
+   * Returns recommendations with context about which appointment, practitioner, and clinic suggested them.
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering
+   * @returns Array of next steps recommendations with context
+   */
+  async getPatientNextStepsRecommendations(
+    patientId: string,
+    options?: {
+      /** Include dismissed recommendations (default: false) */
+      includeDismissed?: boolean;
+      /** Filter by clinic branch ID */
+      clinicBranchId?: string;
+      /** Filter by practitioner ID */
+      practitionerId?: string;
+      /** Limit the number of results */
+      limit?: number;
+    },
+  ): Promise<NextStepsRecommendation[]> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting next steps recommendations for patient: ${patientId}`,
+        options,
+      );
+
+      // Get patient profile to check dismissed recommendations
+      const patientProfile = await this.patientService.getPatientProfile(patientId);
+      const dismissedIds = new Set(
+        patientProfile?.dismissedNextStepsRecommendations || [],
+      );
+
+      // Get past appointments (completed appointments)
+      const pastAppointments = await this.getPastPatientAppointments(patientId, {
+        showCanceled: false,
+        showNoShow: false,
+      });
+
+      const recommendations: NextStepsRecommendation[] = [];
+
+      // Iterate through past appointments and extract recommendations
+      for (const appointment of pastAppointments.appointments) {
+        // Filter by clinic if specified
+        if (options?.clinicBranchId && appointment.clinicBranchId !== options.clinicBranchId) {
+          continue;
+        }
+
+        // Filter by practitioner if specified
+        if (options?.practitionerId && appointment.practitionerId !== options.practitionerId) {
+          continue;
+        }
+
+        // Get recommended procedures from appointment metadata
+        const recommendedProcedures =
+          appointment.metadata?.recommendedProcedures || [];
+
+        // Create NextStepsRecommendation for each recommended procedure
+        for (let index = 0; index < recommendedProcedures.length; index++) {
+          const recommendedProcedure = recommendedProcedures[index];
+          const recommendationId = `${appointment.id}:${index}`;
+
+          // Skip if dismissed and not including dismissed
+          if (!options?.includeDismissed && dismissedIds.has(recommendationId)) {
+            continue;
+          }
+
+          const nextStepsRecommendation: NextStepsRecommendation = {
+            id: recommendationId,
+            recommendedProcedure,
+            appointmentId: appointment.id,
+            appointmentDate: appointment.appointmentStartTime,
+            practitionerId: appointment.practitionerId,
+            practitionerName: appointment.practitionerInfo?.name || 'Unknown Practitioner',
+            clinicBranchId: appointment.clinicBranchId,
+            clinicName: appointment.clinicInfo?.name || 'Unknown Clinic',
+            appointmentStatus: appointment.status,
+            isDismissed: dismissedIds.has(recommendationId),
+            dismissedAt: null, // We don't track when it was dismissed, just that it was
+          };
+
+          recommendations.push(nextStepsRecommendation);
+        }
+      }
+
+      // Sort by appointment date (most recent first)
+      recommendations.sort((a, b) => {
+        const dateA = a.appointmentDate.toMillis();
+        const dateB = b.appointmentDate.toMillis();
+        return dateB - dateA;
+      });
+
+      // Apply limit if specified
+      const limitedRecommendations = options?.limit
+        ? recommendations.slice(0, options.limit)
+        : recommendations;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${limitedRecommendations.length} next steps recommendations for patient ${patientId}`,
+      );
+
+      return limitedRecommendations;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting next steps recommendations for patient ${patientId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Dismisses a next steps recommendation for a patient.
+   * This prevents the recommendation from showing up in the default view.
+   *
+   * @param patientId ID of the patient
+   * @param recommendationId ID of the recommendation to dismiss (format: appointmentId:recommendationIndex)
+   * @returns Updated patient profile
+   */
+  async dismissNextStepsRecommendation(
+    patientId: string,
+    recommendationId: string,
+  ): Promise<void> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Dismissing recommendation ${recommendationId} for patient ${patientId}`,
+      );
+
+      // Get patient profile
+      const patientProfile = await this.patientService.getPatientProfile(patientId);
+      if (!patientProfile) {
+        throw new Error(`Patient profile not found for patient ${patientId}`);
+      }
+
+      // Get current dismissed recommendations
+      const dismissedRecommendations =
+        patientProfile.dismissedNextStepsRecommendations || [];
+
+      // Check if already dismissed
+      if (dismissedRecommendations.includes(recommendationId)) {
+        console.log(
+          `[APPOINTMENT_SERVICE] Recommendation ${recommendationId} already dismissed`,
+        );
+        return;
+      }
+
+      // Add to dismissed list
+      const updatedDismissed = [...dismissedRecommendations, recommendationId];
+
+      // Update patient profile
+      await this.patientService.updatePatientProfile(patientId, {
+        dismissedNextStepsRecommendations: updatedDismissed,
+      });
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Successfully dismissed recommendation ${recommendationId} for patient ${patientId}`,
+      );
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error dismissing recommendation for patient ${patientId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Undismisses a next steps recommendation for a patient.
+   * This makes the recommendation visible again in the default view.
+   *
+   * @param patientId ID of the patient
+   * @param recommendationId ID of the recommendation to undismiss (format: appointmentId:recommendationIndex)
+   * @returns Updated patient profile
+   */
+  async undismissNextStepsRecommendation(
+    patientId: string,
+    recommendationId: string,
+  ): Promise<void> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Undismissing recommendation ${recommendationId} for patient ${patientId}`,
+      );
+
+      // Get patient profile
+      const patientProfile = await this.patientService.getPatientProfile(patientId);
+      if (!patientProfile) {
+        throw new Error(`Patient profile not found for patient ${patientId}`);
+      }
+
+      // Get current dismissed recommendations
+      const dismissedRecommendations =
+        patientProfile.dismissedNextStepsRecommendations || [];
+
+      // Check if not dismissed
+      if (!dismissedRecommendations.includes(recommendationId)) {
+        console.log(
+          `[APPOINTMENT_SERVICE] Recommendation ${recommendationId} is not dismissed`,
+        );
+        return;
+      }
+
+      // Remove from dismissed list
+      const updatedDismissed = dismissedRecommendations.filter(
+        id => id !== recommendationId,
+      );
+
+      // Update patient profile
+      await this.patientService.updatePatientProfile(patientId, {
+        dismissedNextStepsRecommendations: updatedDismissed,
+      });
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Successfully undismissed recommendation ${recommendationId} for patient ${patientId}`,
+      );
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error undismissing recommendation for patient ${patientId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets next steps recommendations for a clinic.
+   * Returns all recommendations from appointments at the specified clinic.
+   * This is useful for clinic admins to see what treatments have been recommended to their patients.
+   *
+   * @param clinicBranchId ID of the clinic branch
+   * @param options Optional parameters for filtering
+   * @returns Array of next steps recommendations with context
+   */
+  async getClinicNextStepsRecommendations(
+    clinicBranchId: string,
+    options?: {
+      /** Filter by patient ID */
+      patientId?: string;
+      /** Filter by practitioner ID */
+      practitionerId?: string;
+      /** Limit the number of results */
+      limit?: number;
+    },
+  ): Promise<NextStepsRecommendation[]> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting next steps recommendations for clinic: ${clinicBranchId}`,
+        options,
+      );
+
+      // Get past appointments for the clinic
+      const searchParams: SearchAppointmentsParams = {
+        clinicBranchId,
+        patientId: options?.patientId,
+        practitionerId: options?.practitionerId,
+        status: AppointmentStatus.COMPLETED,
+      };
+
+      const { appointments } = await this.searchAppointments(searchParams);
+
+      const recommendations: NextStepsRecommendation[] = [];
+
+      // Iterate through appointments and extract recommendations
+      for (const appointment of appointments) {
+        // Get recommended procedures from appointment metadata
+        const recommendedProcedures =
+          appointment.metadata?.recommendedProcedures || [];
+
+        // Create NextStepsRecommendation for each recommended procedure
+        for (let index = 0; index < recommendedProcedures.length; index++) {
+          const recommendedProcedure = recommendedProcedures[index];
+          const recommendationId = `${appointment.id}:${index}`;
+
+          const nextStepsRecommendation: NextStepsRecommendation = {
+            id: recommendationId,
+            recommendedProcedure,
+            appointmentId: appointment.id,
+            appointmentDate: appointment.appointmentStartTime,
+            practitionerId: appointment.practitionerId,
+            practitionerName: appointment.practitionerInfo?.name || 'Unknown Practitioner',
+            clinicBranchId: appointment.clinicBranchId,
+            clinicName: appointment.clinicInfo?.name || 'Unknown Clinic',
+            appointmentStatus: appointment.status,
+            isDismissed: false, // Clinic view doesn't track dismissals
+            dismissedAt: null,
+          };
+
+          recommendations.push(nextStepsRecommendation);
+        }
+      }
+
+      // Sort by appointment date (most recent first)
+      recommendations.sort((a, b) => {
+        const dateA = a.appointmentDate.toMillis();
+        const dateB = b.appointmentDate.toMillis();
+        return dateB - dateA;
+      });
+
+      // Apply limit if specified
+      const limitedRecommendations = options?.limit
+        ? recommendations.slice(0, options.limit)
+        : recommendations;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${limitedRecommendations.length} next steps recommendations for clinic ${clinicBranchId}`,
+      );
+
+      return limitedRecommendations;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting next steps recommendations for clinic ${clinicBranchId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets next steps recommendations from a specific appointment.
+   * This is useful when viewing an appointment detail page in the clinic app
+   * to see what procedures were recommended during that appointment.
+   *
+   * @param appointmentId ID of the appointment
+   * @param options Optional parameters for filtering
+   * @returns Array of next steps recommendations from that appointment
+   */
+  async getAppointmentNextStepsRecommendations(
+    appointmentId: string,
+    options?: {
+      /** Filter by clinic branch ID - only show recommendations for procedures available at this clinic */
+      clinicBranchId?: string;
+    },
+  ): Promise<NextStepsRecommendation[]> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting next steps recommendations for appointment: ${appointmentId}`,
+        options,
+      );
+
+      // Get the appointment
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      // Get recommended procedures from appointment metadata
+      const recommendedProcedures =
+        appointment.metadata?.recommendedProcedures || [];
+
+      const recommendations: NextStepsRecommendation[] = [];
+
+      // If clinicBranchId is provided, we need to check which procedures are available at that clinic
+      let availableProcedureIds: Set<string> | null = null;
+      if (options?.clinicBranchId) {
+        // Query procedures collection to get all procedure IDs available at this clinic
+        const proceduresQuery = query(
+          collection(this.db, PROCEDURES_COLLECTION),
+          where('clinicBranchId', '==', options.clinicBranchId),
+          where('isActive', '==', true),
+        );
+        const proceduresSnapshot = await getDocs(proceduresQuery);
+        availableProcedureIds = new Set(
+          proceduresSnapshot.docs.map(doc => doc.id),
+        );
+        console.log(
+          `[APPOINTMENT_SERVICE] Found ${availableProcedureIds.size} procedures available at clinic ${options.clinicBranchId}`,
+        );
+      }
+
+      // Create NextStepsRecommendation for each recommended procedure
+      for (let index = 0; index < recommendedProcedures.length; index++) {
+        const recommendedProcedure = recommendedProcedures[index];
+        const procedureId = recommendedProcedure.procedure.procedureId;
+
+        // If clinicBranchId is provided, filter to only include procedures available at that clinic
+        if (options?.clinicBranchId && availableProcedureIds) {
+          if (!availableProcedureIds.has(procedureId)) {
+            console.log(
+              `[APPOINTMENT_SERVICE] Skipping recommendation for procedure ${procedureId} - not available at clinic ${options.clinicBranchId}`,
+            );
+            continue;
+          }
+        }
+
+        const recommendationId = `${appointment.id}:${index}`;
+
+        const nextStepsRecommendation: NextStepsRecommendation = {
+          id: recommendationId,
+          recommendedProcedure,
+          appointmentId: appointment.id,
+          appointmentDate: appointment.appointmentStartTime,
+          practitionerId: appointment.practitionerId,
+          practitionerName: appointment.practitionerInfo?.name || 'Unknown Practitioner',
+          clinicBranchId: appointment.clinicBranchId,
+          clinicName: appointment.clinicInfo?.name || 'Unknown Clinic',
+          appointmentStatus: appointment.status,
+          isDismissed: false, // Clinic view doesn't track dismissals
+          dismissedAt: null,
+        };
+
+        recommendations.push(nextStepsRecommendation);
+      }
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${recommendations.length} next steps recommendations for appointment ${appointmentId}`,
+        options?.clinicBranchId
+          ? `(filtered to procedures available at clinic ${options.clinicBranchId})`
+          : '',
+      );
+
+      return recommendations;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting next steps recommendations for appointment ${appointmentId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
 }

package/src/types/appointment/index.ts

@@ -451,3 +451,31 @@ export interface SearchAppointmentsParams {
 
 /** Firestore collection name */
 export const APPOINTMENTS_COLLECTION = 'appointments';
+
+/**
+ * Interface for next steps recommendation with context about when and who suggested it
+ */
+export interface NextStepsRecommendation {
+  /** Unique identifier for this recommendation (appointmentId + recommendationIndex) */
+  id: string;
+  /** The recommended procedure details */
+  recommendedProcedure: RecommendedProcedure;
+  /** ID of the appointment where this was recommended */
+  appointmentId: string;
+  /** Date of the appointment when this was recommended */
+  appointmentDate: Timestamp;
+  /** ID of the practitioner who made the recommendation */
+  practitionerId: string;
+  /** Name of the practitioner who made the recommendation */
+  practitionerName: string;
+  /** ID of the clinic where the appointment took place */
+  clinicBranchId: string;
+  /** Name of the clinic where the appointment took place */
+  clinicName: string;
+  /** Status of the appointment when recommendation was made */
+  appointmentStatus: AppointmentStatus;
+  /** Whether this recommendation has been dismissed by the patient */
+  isDismissed?: boolean;
+  /** When the recommendation was dismissed (if dismissed) */
+  dismissedAt?: Timestamp | null;
+}

package/src/types/patient/index.ts

@@ -175,6 +175,8 @@ export interface PatientProfile {
   clinics: PatientClinic[]; // Lista klinika pacijenta
   doctorIds: string[]; // Denormalized array for querying
   clinicIds: string[]; // Denormalized array for querying
+  /** IDs of dismissed next steps recommendations (format: appointmentId:recommendationIndex) */
+  dismissedNextStepsRecommendations?: string[];
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }

package/src/validations/patient.schema.ts

@@ -120,6 +120,7 @@ export const patientProfileSchema = z.object({
   clinics: z.array(patientClinicSchema),
   doctorIds: z.array(z.string()),
   clinicIds: z.array(z.string()),
+  dismissedNextStepsRecommendations: z.array(z.string()).optional(),
   createdAt: z.instanceof(Timestamp),
   updatedAt: z.instanceof(Timestamp),
 });