@blackcode_sa/metaestetics-api 1.7.12 → 1.7.14

package/src/admin/aggregation/forms/filled-forms.aggregation.service.ts

@@ -0,0 +1,316 @@
+import * as admin from "firebase-admin";
+import {
+  FilledDocument,
+  FilledDocumentStatus,
+  USER_FORMS_SUBCOLLECTION,
+  DOCTOR_FORMS_SUBCOLLECTION,
+} from "../../../types/documentation-templates";
+import {
+  Appointment,
+  LinkedFormInfo,
+  APPOINTMENTS_COLLECTION,
+} from "../../../types/appointment";
+import { Logger } from "../../logger";
+import { Timestamp } from "firebase/firestore";
+
+/**
+ * @class FilledFormsAggregationService
+ * @description Handles aggregation tasks related to filled forms data updates.
+ * Updates appointment documents with LinkedFormInfo when forms are created, updated, or deleted.
+ */
+export class FilledFormsAggregationService {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Constructor for FilledFormsAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+    Logger.info("[FilledFormsAggregationService] Initialized");
+  }
+
+  /**
+   * Handles side effects when a filled form is created or updated.
+   * This function would typically be called by a Firestore onCreate or onUpdate trigger.
+   * @param filledDocument The filled document that was created or updated.
+   * @returns {Promise<void>}
+   */
+  async handleFilledFormCreateOrUpdate(
+    filledDocument: FilledDocument
+  ): Promise<void> {
+    Logger.info(
+      `[FilledFormsAggregationService] Handling CREATE/UPDATE for filled form: ${filledDocument.id}, appointment: ${filledDocument.appointmentId}`
+    );
+
+    try {
+      // 1. Get the appointment document
+      const appointmentRef = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(filledDocument.appointmentId);
+
+      const appointmentDoc = await appointmentRef.get();
+      if (!appointmentDoc.exists) {
+        Logger.error(
+          `[FilledFormsAggregationService] Appointment ${filledDocument.appointmentId} not found.`
+        );
+        return;
+      }
+
+      const appointment = appointmentDoc.data() as Appointment;
+
+      // 2. Prepare the LinkedFormInfo object
+      const formSubcollection = filledDocument.isUserForm
+        ? USER_FORMS_SUBCOLLECTION
+        : DOCTOR_FORMS_SUBCOLLECTION;
+
+      const linkedFormInfo: LinkedFormInfo = {
+        formId: filledDocument.id,
+        templateId: filledDocument.templateId,
+        templateVersion: filledDocument.templateVersion,
+        title: filledDocument.isUserForm
+          ? "User Form" // Default title if not available
+          : "Doctor Form", // Default title if not available
+        isUserForm: filledDocument.isUserForm,
+        isRequired: filledDocument.isRequired,
+        status: filledDocument.status,
+        path: `${APPOINTMENTS_COLLECTION}/${filledDocument.appointmentId}/${formSubcollection}/${filledDocument.id}`,
+      };
+
+      // Add timestamps if available
+      if (filledDocument.updatedAt) {
+        // Convert to admin.firestore.Timestamp to ensure compatibility
+        linkedFormInfo.submittedAt = admin.firestore.Timestamp.fromMillis(
+          filledDocument.updatedAt
+        ) as unknown as Timestamp;
+      }
+
+      if (
+        filledDocument.status === FilledDocumentStatus.COMPLETED ||
+        filledDocument.status === FilledDocumentStatus.SIGNED
+      ) {
+        linkedFormInfo.completedAt = admin.firestore.Timestamp.fromMillis(
+          filledDocument.updatedAt
+        ) as unknown as Timestamp;
+      }
+
+      // 3. Check if the appointment already has linkedForms array and this form is in it
+      let updateData: any = {};
+      let existingFormIndex = -1;
+
+      if (appointment.linkedForms && appointment.linkedForms.length > 0) {
+        existingFormIndex = appointment.linkedForms.findIndex(
+          (form) => form.formId === filledDocument.id
+        );
+      }
+
+      // 4. Update the appointment with the new/updated LinkedFormInfo
+      if (existingFormIndex >= 0 && appointment.linkedForms) {
+        // Form exists, update it using arrayRemove + arrayUnion
+        updateData = {
+          linkedForms: admin.firestore.FieldValue.arrayRemove(
+            appointment.linkedForms[existingFormIndex]
+          ),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+
+        // First remove the old form info
+        await appointmentRef.update(updateData);
+
+        // Then add the updated form info
+        updateData = {
+          linkedForms: admin.firestore.FieldValue.arrayUnion(linkedFormInfo),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+      } else {
+        // Form doesn't exist, add it to the array or create the array
+        updateData = {
+          linkedForms: appointment.linkedForms
+            ? admin.firestore.FieldValue.arrayUnion(linkedFormInfo)
+            : [linkedFormInfo], // If linkedForms doesn't exist, create a new array
+          linkedFormIds: appointment.linkedFormIds
+            ? admin.firestore.FieldValue.arrayUnion(filledDocument.id)
+            : [filledDocument.id], // If linkedFormIds doesn't exist, create a new array
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+      }
+
+      // 5. Handle pendingUserFormsIds for required user forms
+      if (
+        filledDocument.isUserForm &&
+        filledDocument.isRequired &&
+        (filledDocument.status === FilledDocumentStatus.COMPLETED ||
+          filledDocument.status === FilledDocumentStatus.SIGNED)
+      ) {
+        // Check if the form ID is in pendingUserFormsIds
+        if (
+          appointment.pendingUserFormsIds &&
+          appointment.pendingUserFormsIds.includes(filledDocument.id)
+        ) {
+          // Remove the form ID from pendingUserFormsIds
+          updateData.pendingUserFormsIds =
+            admin.firestore.FieldValue.arrayRemove(filledDocument.id);
+          Logger.info(
+            `[FilledFormsAggregationService] Removing form ${filledDocument.id} from pendingUserFormsIds`
+          );
+        }
+      }
+
+      // 6. Update the appointment
+      await appointmentRef.update(updateData);
+      Logger.info(
+        `[FilledFormsAggregationService] Successfully updated appointment ${filledDocument.appointmentId} with form info for ${filledDocument.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error updating appointment for filled form ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Handles side effects when a filled form is deleted.
+   * This function would typically be called by a Firestore onDelete trigger.
+   * @param filledDocument The filled document that was deleted.
+   * @returns {Promise<void>}
+   */
+  async handleFilledFormDelete(filledDocument: FilledDocument): Promise<void> {
+    Logger.info(
+      `[FilledFormsAggregationService] Handling DELETE for filled form: ${filledDocument.id}, appointment: ${filledDocument.appointmentId}`
+    );
+
+    try {
+      // 1. Get the appointment document
+      const appointmentRef = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(filledDocument.appointmentId);
+
+      const appointmentDoc = await appointmentRef.get();
+      if (!appointmentDoc.exists) {
+        Logger.error(
+          `[FilledFormsAggregationService] Appointment ${filledDocument.appointmentId} not found.`
+        );
+        return;
+      }
+
+      const appointment = appointmentDoc.data() as Appointment;
+
+      // 2. Prepare the update data
+      let updateData: any = {};
+
+      // 3. Remove the form from linkedForms if it exists
+      if (appointment.linkedForms && appointment.linkedForms.length > 0) {
+        const formToRemove = appointment.linkedForms.find(
+          (form) => form.formId === filledDocument.id
+        );
+
+        if (formToRemove) {
+          updateData.linkedForms =
+            admin.firestore.FieldValue.arrayRemove(formToRemove);
+        }
+      }
+
+      // 4. Remove the form ID from linkedFormIds
+      if (
+        appointment.linkedFormIds &&
+        appointment.linkedFormIds.includes(filledDocument.id)
+      ) {
+        updateData.linkedFormIds = admin.firestore.FieldValue.arrayRemove(
+          filledDocument.id
+        );
+      }
+
+      // 5. For required user forms, handle pendingUserFormsIds
+      if (filledDocument.isUserForm && filledDocument.isRequired) {
+        if (
+          filledDocument.status !== FilledDocumentStatus.COMPLETED &&
+          filledDocument.status !== FilledDocumentStatus.SIGNED
+        ) {
+          // If the form was not completed or signed, ensure it's added back to pending
+          if (
+            !appointment.pendingUserFormsIds ||
+            !appointment.pendingUserFormsIds.includes(filledDocument.id)
+          ) {
+            updateData.pendingUserFormsIds = appointment.pendingUserFormsIds
+              ? admin.firestore.FieldValue.arrayUnion(filledDocument.id)
+              : [filledDocument.id];
+          }
+        }
+      }
+
+      // 6. Only update if there's something to update
+      if (Object.keys(updateData).length > 0) {
+        updateData.updatedAt = admin.firestore.FieldValue.serverTimestamp();
+        await appointmentRef.update(updateData);
+        Logger.info(
+          `[FilledFormsAggregationService] Successfully updated appointment ${filledDocument.appointmentId} after form deletion`
+        );
+      } else {
+        Logger.info(
+          `[FilledFormsAggregationService] No updates needed for appointment ${filledDocument.appointmentId}`
+        );
+      }
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error updating appointment after form deletion for ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates the appointment's pendingUserFormsIds for a new required user form.
+   * This should be called when a required user form is first created.
+   * @param filledDocument The newly created filled document.
+   * @returns {Promise<void>}
+   */
+  async handleRequiredUserFormCreate(
+    filledDocument: FilledDocument
+  ): Promise<void> {
+    if (!filledDocument.isUserForm || !filledDocument.isRequired) {
+      return; // Only process required user forms
+    }
+
+    Logger.info(
+      `[FilledFormsAggregationService] Handling new required user form creation: ${filledDocument.id}`
+    );
+
+    try {
+      const appointmentRef = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(filledDocument.appointmentId);
+
+      // Skip adding to pendingUserFormsIds if already completed/signed
+      if (
+        filledDocument.status === FilledDocumentStatus.COMPLETED ||
+        filledDocument.status === FilledDocumentStatus.SIGNED
+      ) {
+        Logger.info(
+          `[FilledFormsAggregationService] Form ${filledDocument.id} is already completed/signed, not adding to pendingUserFormsIds`
+        );
+        return;
+      }
+
+      // Add to pendingUserFormsIds
+      await appointmentRef.update({
+        pendingUserFormsIds: admin.firestore.FieldValue.arrayUnion(
+          filledDocument.id
+        ),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      Logger.info(
+        `[FilledFormsAggregationService] Successfully added form ${filledDocument.id} to pendingUserFormsIds for appointment ${filledDocument.appointmentId}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error handling required user form creation for ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/admin/index.ts

@@ -22,6 +22,8 @@ import { PractitionerAggregationService } from "./aggregation/practitioner/pract
 import { ProcedureAggregationService } from "./aggregation/procedure/procedure.aggregation.service";
 import { PatientAggregationService } from "./aggregation/patient/patient.aggregation.service";
 import { AppointmentAggregationService } from "./aggregation/appointment/appointment.aggregation.service";
+import { FilledFormsAggregationService } from "./aggregation/forms/filled-forms.aggregation.service";
+import { ReviewsAggregationService } from "./aggregation/reviews/reviews.aggregation.service";
 
 // Import mailing services
 import { BaseMailingService } from "./mailing/base.mailing.service";
@@ -50,6 +52,8 @@ export type { DoctorInfo } from "../types/clinic";
 export type { Procedure, ProcedureSummaryInfo } from "../types/procedure";
 export type { PatientProfile as Patient } from "../types/patient";
 export type { Appointment } from "../types/appointment";
+export type { FilledDocument } from "../types/documentation-templates";
+export type { Review } from "../types/reviews";
 
 // Re-export enums/consts
 export {
@@ -70,6 +74,8 @@ export {
   PatientAggregationService,
   AppointmentAggregationService,
   PatientRequirementsAdminService,
+  FilledFormsAggregationService,
+  ReviewsAggregationService,
 };
 
 // Export mailing services
@@ -128,7 +134,8 @@ export * from "./mailing/appointment/appointment.mailing.service";
 export * from "./notifications/notifications.admin";
 export * from "./requirements/patient-requirements.admin.service";
 export * from "./aggregation/appointment/appointment.aggregation.service";
-
+export * from "./aggregation/forms/filled-forms.aggregation.service";
+export * from "./aggregation/reviews/reviews.aggregation.service";
 // Re-export types that Cloud Functions might need direct access to
 export * from "../types/appointment";
 // Add other types as needed

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

@@ -70,12 +70,14 @@ import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
 import { ProcedureReviewInfo } from "../../types/reviews";
 import { distanceBetween, geohashQueryBounds } from "geofire-common";
 import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
+import { MediaService, MediaAccessLevel } from "../media/media.service";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
   private subcategoryService: SubcategoryService;
   private technologyService: TechnologyService;
   private productService: ProductService;
+  private mediaService: MediaService;
 
   constructor(
     db: Firestore,
@@ -84,13 +86,81 @@ export class ProcedureService extends BaseService {
     categoryService: CategoryService,
     subcategoryService: SubcategoryService,
     technologyService: TechnologyService,
-    productService: ProductService
+    productService: ProductService,
+    mediaService: MediaService
   ) {
     super(db, auth, app);
     this.categoryService = categoryService;
     this.subcategoryService = subcategoryService;
     this.technologyService = technologyService;
     this.productService = productService;
+    this.mediaService = mediaService;
+  }
+
+  /**
+   * Process media resource (string URL or File object)
+   * @param media String URL or File object
+   * @param ownerId Owner ID for the media (usually procedureId)
+   * @param collectionName Collection name for organizing files
+   * @returns URL string after processing
+   */
+  private async processMedia(
+    media: string | File | Blob | null | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string | null> {
+    if (!media) return null;
+
+    // If already a string URL, return it directly
+    if (typeof media === "string") {
+      return media;
+    }
+
+    // If it's a File, upload it using MediaService
+    if (media instanceof File || media instanceof Blob) {
+      console.log(
+        `[ProcedureService] Uploading ${collectionName} media for ${ownerId}`
+      );
+      const metadata = await this.mediaService.uploadMedia(
+        media,
+        ownerId,
+        MediaAccessLevel.PUBLIC,
+        collectionName
+      );
+      return metadata.url;
+    }
+
+    return null;
+  }
+
+  /**
+   * Process array of media resources (strings or Files)
+   * @param mediaArray Array of string URLs or File objects
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Array of URL strings after processing
+   */
+  private async processMediaArray(
+    mediaArray: (string | File | Blob)[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string[]> {
+    if (!mediaArray || mediaArray.length === 0) return [];
+
+    const result: string[] = [];
+
+    for (const media of mediaArray) {
+      const processedUrl = await this.processMedia(
+        media,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push(processedUrl);
+      }
+    }
+
+    return result;
   }
 
   /**
@@ -101,6 +171,9 @@ export class ProcedureService extends BaseService {
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
     const validatedData = createProcedureSchema.parse(data);
 
+    // Generate procedure ID first so we can use it for media uploads
+    const procedureId = this.generateId();
+
     // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
@@ -146,6 +219,16 @@ export class ProcedureService extends BaseService {
     }
     const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
+    // Process photos if provided
+    let processedPhotos: string[] = [];
+    if (validatedData.photos && validatedData.photos.length > 0) {
+      processedPhotos = await this.processMediaArray(
+        validatedData.photos,
+        procedureId,
+        "procedure-photos"
+      );
+    }
+
     // Create aggregated clinic info for the procedure document
     const clinicInfo = {
       id: clinicSnapshot.id,
@@ -174,10 +257,10 @@ export class ProcedureService extends BaseService {
     };
 
     // Create the procedure object
-    const procedureId = this.generateId();
     const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...validatedData,
+      photos: processedPhotos,
       category, // Embed full objects
       subcategory,
       technology,
@@ -296,6 +379,15 @@ export class ProcedureService extends BaseService {
     let newPractitioner: Practitioner | null = null;
     let newClinic: Clinic | null = null;
 
+    // Process photos if provided
+    if (validatedData.photos !== undefined) {
+      updatedProcedureData.photos = await this.processMediaArray(
+        validatedData.photos,
+        id,
+        "procedure-photos"
+      );
+    }
+
     // --- Prepare updates and fetch new related data if IDs change ---
 
     // Handle Practitioner Change

package/src/types/procedure/index.ts

@@ -20,6 +20,7 @@ import { DoctorInfo } from "../clinic";
 import { PRACTITIONERS_COLLECTION } from "../practitioner";
 import { ProcedureReviewInfo } from "../reviews";
 import type { Contraindication } from "../../backoffice/types/static/contraindication.types";
+import { MediaResource } from "../../services/media/media.service";
 
 /**
  * Procedure represents a specific medical procedure that can be performed by a practitioner in a clinic
@@ -31,7 +32,7 @@ export interface Procedure {
   /** Name of the procedure */
   name: string;
   /** Photos of the procedure */
-  photos?: string[];
+  photos?: MediaResource[];
   /** Detailed description of the procedure */
   description: string;
   /** Family of procedures this belongs to (aesthetics/surgery) */
@@ -101,7 +102,7 @@ export interface CreateProcedureData {
   duration: number;
   practitionerId: string;
   clinicBranchId: string;
-  photos?: string[];
+  photos?: MediaResource[];
 }
 
 /**
@@ -121,7 +122,7 @@ export interface UpdateProcedureData {
   technologyId?: string;
   productId?: string;
   clinicBranchId?: string;
-  photos?: string[];
+  photos?: MediaResource[];
 }
 
 /**

package/src/validations/procedure.schema.ts

@@ -6,7 +6,7 @@ import {
 } from "../backoffice/types/static/pricing.types";
 import { clinicInfoSchema, doctorInfoSchema } from "./shared.schema";
 import { procedureReviewInfoSchema } from "./reviews.schema";
-
+import { mediaResourceSchema } from "./media.schema";
 /**
  * Schema for creating a new procedure
  */
@@ -24,7 +24,7 @@ export const createProcedureSchema = z.object({
   duration: z.number().min(1).max(480), // Max 8 hours
   practitionerId: z.string().min(1),
   clinicBranchId: z.string().min(1),
-  photos: z.array(z.string()).optional(),
+  photos: z.array(mediaResourceSchema).optional(),
 });
 
 /**
@@ -44,7 +44,7 @@ export const updateProcedureSchema = z.object({
   technologyId: z.string().optional(),
   productId: z.string().optional(),
   clinicBranchId: z.string().optional(),
-  photos: z.array(z.string()).optional(),
+  photos: z.array(mediaResourceSchema).optional(),
 });
 
 /**