@blackcode_sa/metaestetics-api 1.12.33 → 1.12.34

package/package.json

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

package/src/services/appointment/utils/extended-procedure.utils.ts

@@ -7,6 +7,7 @@ import {
 } from '../../../types/appointment';
 import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
 import { PROCEDURES_COLLECTION } from '../../../types/procedure';
+import { initializeFormsForExtendedProcedure, removeFormsForExtendedProcedure } from './form-initialization.utils';
 
 /**
  * Aggregates products from a procedure into appointmentProducts
@@ -134,6 +135,16 @@ export async function addExtendedProcedureUtil(
   // Create extended procedure info
   const extendedProcedureInfo = await createExtendedProcedureInfo(db, procedureId);
 
+  // Get procedure data for forms and products
+  const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
+  const procedureSnap = await getDoc(procedureRef);
+  
+  if (!procedureSnap.exists()) {
+    throw new Error(`Procedure with ID ${procedureId} not found`);
+  }
+  
+  const procedureData = procedureSnap.data();
+
   // Aggregate products
   const updatedProducts = await aggregateProductsFromProcedure(
     db,
@@ -141,6 +152,28 @@ export async function addExtendedProcedureUtil(
     metadata.appointmentProducts || []
   );
 
+  // Initialize forms for extended procedure
+  let updatedLinkedFormIds = appointment.linkedFormIds || [];
+  let updatedLinkedForms = appointment.linkedForms || [];
+  let updatedPendingUserFormsIds = appointment.pendingUserFormsIds || [];
+
+  if (procedureData.documentationTemplates && procedureData.documentationTemplates.length > 0) {
+    const formInitResult = await initializeFormsForExtendedProcedure(
+      db,
+      appointmentId,
+      procedureId,
+      procedureData.documentationTemplates,
+      appointment.patientId,
+      appointment.practitionerId,
+      appointment.clinicBranchId
+    );
+
+    // Merge form IDs and info
+    updatedLinkedFormIds = [...updatedLinkedFormIds, ...formInitResult.allLinkedFormIds];
+    updatedLinkedForms = [...updatedLinkedForms, ...formInitResult.initializedFormsInfo];
+    updatedPendingUserFormsIds = [...updatedPendingUserFormsIds, ...formInitResult.pendingUserFormsIds];
+  }
+
   // Add extended procedure
   const extendedProcedures = [...(metadata.extendedProcedures || []), extendedProcedureInfo];
 
@@ -149,6 +182,9 @@ export async function addExtendedProcedureUtil(
   await updateDoc(appointmentRef, {
     'metadata.extendedProcedures': extendedProcedures,
     'metadata.appointmentProducts': updatedProducts,
+    linkedFormIds: updatedLinkedFormIds,
+    linkedForms: updatedLinkedForms,
+    pendingUserFormsIds: updatedPendingUserFormsIds,
     updatedAt: serverTimestamp(),
   });
 
@@ -191,11 +227,28 @@ export async function removeExtendedProcedureUtil(
     p => p.procedureId !== procedureId
   );
 
+  // Remove forms associated with this procedure
+  const removedFormIds = await removeFormsForExtendedProcedure(db, appointmentId, procedureId);
+  
+  // Update appointment form arrays
+  const updatedLinkedFormIds = (appointment.linkedFormIds || []).filter(
+    formId => !removedFormIds.includes(formId)
+  );
+  const updatedLinkedForms = (appointment.linkedForms || []).filter(
+    form => !removedFormIds.includes(form.formId)
+  );
+  const updatedPendingUserFormsIds = (appointment.pendingUserFormsIds || []).filter(
+    formId => !removedFormIds.includes(formId)
+  );
+
   // Update appointment
   const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
   await updateDoc(appointmentRef, {
     'metadata.extendedProcedures': metadata.extendedProcedures,
     'metadata.appointmentProducts': updatedProducts,
+    linkedFormIds: updatedLinkedFormIds,
+    linkedForms: updatedLinkedForms,
+    pendingUserFormsIds: updatedPendingUserFormsIds,
     updatedAt: serverTimestamp(),
   });
 

package/src/services/appointment/utils/form-initialization.utils.ts

@@ -0,0 +1,225 @@
+import { Firestore, collection, doc, addDoc, deleteDoc, getDocs, query, where, serverTimestamp, getDoc } from 'firebase/firestore';
+import {
+  DocumentTemplate,
+  FilledDocumentStatus,
+  DOCTOR_FORMS_SUBCOLLECTION,
+  DOCUMENTATION_TEMPLATES_COLLECTION,
+} from '../../../types/documentation-templates';
+import {
+  APPOINTMENTS_COLLECTION,
+  LinkedFormInfo,
+} from '../../../types/appointment';
+import { TechnologyDocumentationTemplate } from '../../../backoffice/types/technology.types';
+
+export interface InitializeExtendedProcedureFormsResult {
+  initializedFormsInfo: LinkedFormInfo[];
+  pendingUserFormsIds: string[];
+  allLinkedFormIds: string[];
+}
+
+/**
+ * Initializes forms for an extended procedure using client-side Firestore
+ * Similar to DocumentManagerAdminService but for client-side usage
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID for forms
+ * @param technologyTemplates Technology documentation templates
+ * @param patientId Patient ID
+ * @param practitionerId Practitioner ID
+ * @param clinicId Clinic ID
+ * @returns Form initialization result
+ */
+export async function initializeFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string,
+  technologyTemplates: TechnologyDocumentationTemplate[],
+  patientId: string,
+  practitionerId: string,
+  clinicId: string
+): Promise<InitializeExtendedProcedureFormsResult> {
+  const initializedFormsInfo: LinkedFormInfo[] = [];
+  const pendingUserFormsIds: string[] = [];
+  const allLinkedFormIds: string[] = [];
+
+  if (!technologyTemplates || technologyTemplates.length === 0) {
+    console.log(
+      `[FormInit] No document templates to initialize for extended procedure ${procedureId} in appointment ${appointmentId}.`
+    );
+    return {
+      initializedFormsInfo,
+      pendingUserFormsIds,
+      allLinkedFormIds,
+    };
+  }
+
+  // Fetch all template documents
+  const templateIds = technologyTemplates.map((t) => t.templateId);
+  
+  // Note: Client-side Firestore doesn't support 'in' queries with more than 10 items
+  // We'll fetch templates one by one for now (can be optimized later)
+  const templatesMap = new Map<string, DocumentTemplate>();
+  
+  for (const templateId of templateIds) {
+    try {
+      const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, templateId);
+      const templateSnap = await getDoc(templateDoc);
+      
+      if (templateSnap.exists()) {
+        templatesMap.set(templateId, templateSnap.data() as DocumentTemplate);
+      } else {
+        console.warn(
+          `[FormInit] Template ${templateId} not found in Firestore.`
+        );
+      }
+    } catch (error) {
+      console.error(`[FormInit] Error fetching template ${templateId}:`, error);
+    }
+  }
+
+  // Initialize forms for each template (only doctor forms for extended procedures)
+  for (const templateRef of technologyTemplates) {
+    const template = templatesMap.get(templateRef.templateId);
+    if (!template) {
+      console.warn(
+        `[FormInit] Template ${templateRef.templateId} not found in Firestore.`
+      );
+      continue;
+    }
+
+    // Skip user forms - only create doctor forms for extended procedures
+    if (templateRef.isUserForm) {
+      console.log(
+        `[FormInit] Skipping user form ${templateRef.templateId} for extended procedure ${procedureId}.`
+      );
+      continue;
+    }
+
+    const isRequired = templateRef.isRequired;
+    const formSubcollectionPath = DOCTOR_FORMS_SUBCOLLECTION;
+
+    // Create form document in subcollection
+    const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+    const formsCollectionRef = collection(appointmentRef, formSubcollectionPath);
+    
+    const filledDocumentData = {
+      templateId: templateRef.templateId,
+      templateVersion: template.version,
+      isUserForm: false, // Always false for extended procedures
+      isRequired: isRequired,
+      appointmentId: appointmentId,
+      procedureId: procedureId,
+      patientId: patientId,
+      practitionerId: practitionerId,
+      clinicId: clinicId,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+      values: {},
+      status: FilledDocumentStatus.PENDING,
+    };
+
+    try {
+      const docRef = await addDoc(formsCollectionRef, filledDocumentData);
+      const filledDocumentId = docRef.id;
+
+      // No user forms for extended procedures, so no pending user forms
+
+      allLinkedFormIds.push(filledDocumentId);
+
+      const linkedForm: LinkedFormInfo = {
+        formId: filledDocumentId,
+        templateId: template.id,
+        templateVersion: template.version,
+        title: template.title,
+        isUserForm: false, // Always false for extended procedures
+        isRequired: isRequired,
+        sortingOrder: templateRef.sortingOrder,
+        status: FilledDocumentStatus.PENDING,
+        path: docRef.path,
+      };
+      initializedFormsInfo.push(linkedForm);
+
+      console.log(
+        `[FormInit] Created FilledDocument ${filledDocumentId} (template: ${template.id}) for extended procedure ${procedureId} in appointment ${appointmentId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[FormInit] Error creating form for template ${templateRef.templateId}:`,
+        error
+      );
+    }
+  }
+
+  return { initializedFormsInfo, pendingUserFormsIds, allLinkedFormIds };
+}
+
+/**
+ * Removes all forms associated with a specific procedure from an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to remove forms for
+ * @returns Array of removed form IDs
+ */
+export async function removeFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<string[]> {
+  const removedFormIds: string[] = [];
+
+  // Only remove from doctor forms subcollection (no user forms for extended procedures)
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
+
+  // Query doctor forms for this procedure
+  const doctorFormsQuery = query(
+    doctorFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const doctorFormsSnap = await getDocs(doctorFormsQuery);
+
+  for (const formDoc of doctorFormsSnap.docs) {
+    try {
+      await deleteDoc(formDoc.ref);
+      removedFormIds.push(formDoc.id);
+      console.log(
+        `[FormInit] Removed doctor form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[FormInit] Error removing doctor form ${formDoc.id}:`,
+        error
+      );
+    }
+  }
+
+  return removedFormIds;
+}
+
+/**
+ * Gets all forms associated with a specific procedure in an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID
+ * @returns Array of form IDs
+ */
+export async function getFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<string[]> {
+  const formIds: string[] = [];
+
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
+
+  // Query doctor forms for this procedure
+  const doctorFormsQuery = query(
+    doctorFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const doctorFormsSnap = await getDocs(doctorFormsQuery);
+  doctorFormsSnap.docs.forEach(doc => formIds.push(doc.id));
+
+  return formIds;
+}