@blackcode_sa/metaestetics-api 1.7.12 → 1.7.13

package/package.json

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

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