@blackcode_sa/metaestetics-api 1.6.24 → 1.6.25

package/src/admin/documentation-templates/document-manager.admin.ts

@@ -5,11 +5,13 @@ import {
   FilledDocumentStatus,
   USER_FORMS_SUBCOLLECTION,
   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 InitializeAppointmentFormsResult {
   initializedFormsInfo: LinkedFormInfo[];
@@ -128,4 +130,130 @@ export class DocumentManagerAdminService {
     }
     return { initializedFormsInfo, pendingUserFormsIds, allLinkedTemplateIds };
   }
+
+  /**
+   * Adds operations to a Firestore batch to initialize all linked forms for a new appointment
+   * using the TechnologyDocumentationTemplate references.
+   *
+   * @param dbBatch - The Firestore batch to add operations to.
+   * @param appointmentId - The ID of the newly created appointment.
+   * @param procedureIdForForms - The ID of the procedure associated with this appointment.
+   * @param technologyTemplates - Array of technology documentation template references.
+   * @param patientId - ID of the patient.
+   * @param practitionerId - ID of the practitioner associated with the procedure.
+   * @param clinicId - ID of the clinic where the procedure is performed.
+   * @param nowMillis - Current timestamp in milliseconds for createdAt/updatedAt.
+   * @returns An object containing initializedFormsInfo, pendingUserFormsIds, and allLinkedTemplateIds.
+   */
+  async batchInitializeAppointmentFormsFromTechnologyTemplates(
+    dbBatch: admin.firestore.WriteBatch,
+    appointmentId: string,
+    procedureIdForForms: string,
+    technologyTemplates: TechnologyDocumentationTemplate[],
+    patientId: string,
+    practitionerId: string,
+    clinicId: string,
+    nowMillis: number
+  ): Promise<InitializeAppointmentFormsResult> {
+    const initializedFormsInfo: LinkedFormInfo[] = [];
+    const pendingUserFormsIds: string[] = [];
+    const allLinkedTemplateIds: string[] = [];
+
+    if (!technologyTemplates || technologyTemplates.length === 0) {
+      console.log(
+        `[DocManagerAdmin] No document templates to initialize for appointment ${appointmentId}.`
+      );
+      return {
+        initializedFormsInfo,
+        pendingUserFormsIds,
+        allLinkedTemplateIds,
+      };
+    }
+
+    // Fetch all template documents in one batch
+    const templateIds = technologyTemplates.map((t) => t.templateId);
+    const templatesSnapshot = await this.db
+      .collection(DOCUMENTATION_TEMPLATES_COLLECTION)
+      .where(admin.firestore.FieldPath.documentId(), "in", templateIds)
+      .get();
+
+    const templatesMap = new Map<string, DocumentTemplate>();
+    templatesSnapshot.forEach((doc) => {
+      templatesMap.set(doc.id, doc.data() as DocumentTemplate);
+    });
+
+    for (const templateRef of technologyTemplates) {
+      const template = templatesMap.get(templateRef.templateId);
+      if (!template) {
+        console.warn(
+          `[DocManagerAdmin] Template ${templateRef.templateId} not found in Firestore.`
+        );
+        continue;
+      }
+
+      const isUserForm = templateRef.isUserForm;
+      const isRequired = templateRef.isRequired;
+
+      const formSubcollectionPath = isUserForm
+        ? USER_FORMS_SUBCOLLECTION
+        : DOCTOR_FORMS_SUBCOLLECTION;
+
+      const filledDocumentId = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(appointmentId)
+        .collection(formSubcollectionPath)
+        .doc().id;
+
+      if (isUserForm && isRequired) {
+        pendingUserFormsIds.push(filledDocumentId);
+      }
+
+      allLinkedTemplateIds.push(filledDocumentId);
+      // Always initialize with PENDING status regardless of whether the form is required
+      // PENDING is the starting state, DRAFT is when a form is saved but not submitted
+      const initialStatus = FilledDocumentStatus.PENDING;
+
+      const filledDocumentData: FilledDocument = {
+        id: filledDocumentId,
+        templateId: templateRef.templateId,
+        templateVersion: template.version,
+        isUserForm: isUserForm,
+        isRequired: isRequired,
+        appointmentId: appointmentId,
+        procedureId: procedureIdForForms,
+        patientId: patientId,
+        practitionerId: practitionerId,
+        clinicId: clinicId,
+        createdAt: nowMillis,
+        updatedAt: nowMillis,
+        values: {},
+        status: initialStatus,
+      };
+
+      const docRef = this.db
+        .collection(APPOINTMENTS_COLLECTION)
+        .doc(appointmentId)
+        .collection(formSubcollectionPath)
+        .doc(filledDocumentId);
+
+      dbBatch.set(docRef, filledDocumentData);
+
+      const linkedForm: LinkedFormInfo = {
+        formId: filledDocumentData.id,
+        templateId: template.id,
+        templateVersion: template.version,
+        title: template.title,
+        isUserForm: filledDocumentData.isUserForm,
+        isRequired: filledDocumentData.isRequired,
+        status: filledDocumentData.status,
+        path: docRef.path,
+      };
+      initializedFormsInfo.push(linkedForm);
+
+      console.log(
+        `[DocManagerAdmin] Added FilledDocument ${filledDocumentId} (template: ${template.id}) and its LinkedFormInfo to batch for appointment ${appointmentId}.`
+      );
+    }
+    return { initializedFormsInfo, pendingUserFormsIds, allLinkedTemplateIds };
+  }
 }

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

@@ -6,6 +6,20 @@ import { CertificationRequirement } from "./static/certification.types";
 import { DocumentTemplate } from "../../types/documentation-templates";
 import { ProcedureFamily } from "./static/procedure-family.types";
 
+/**
+ * Reference to a documentation template with metadata
+ * @property templateId - ID of the documentation template
+ * @property isUserForm - Whether this template is filled by users
+ * @property isRequired - Whether this template is required
+ * @property sortingOrder - The display order of this template
+ */
+export interface TechnologyDocumentationTemplate {
+  templateId: string;
+  isUserForm: boolean;
+  isRequired: boolean;
+  sortingOrder: number;
+}
+
 /**
  * Zahtevi koji su povezani sa tehnologijom
  * @property pre - Lista zahteva koji se moraju ispuniti pre procedure
@@ -33,7 +47,7 @@ export interface TechnologyRequirements {
  * @property contraindications - List of conditions requiring special attention
  * @property benefits - List of expected benefits from the procedure
  * @property certificationRequirement - Required certification level and specialties
- * @property documentationTemplates - List of documentation templates required for this technology
+ * @property documentationTemplates - List of documentation template references
  * @property isActive - Whether the technology is active in the system
  * @property createdAt - Creation date
  * @property updatedAt - Last update date
@@ -54,7 +68,7 @@ export interface Technology {
   contraindications: Contraindication[];
   benefits: TreatmentBenefit[];
   certificationRequirement: CertificationRequirement;
-  documentationTemplates?: DocumentTemplate[];
+  documentationTemplates?: TechnologyDocumentationTemplate[];
   isActive: boolean;
   createdAt: Date;
   updatedAt: Date;

package/src/services/documentation-templates/documentation-template.service.ts

@@ -95,33 +95,49 @@ export class DocumentationTemplateService extends BaseService {
     templateId: string,
     version?: number
   ): Promise<DocumentTemplate | null> {
-    // If version is specified, try to get that specific version
-    if (version !== undefined) {
-      try {
-        const versionTemplate = await this.getTemplateVersion(
-          templateId,
-          version
-        );
-        // If the version exists, return it
-        if (versionTemplate) {
-          return versionTemplate;
-        }
-        // If version doesn't exist, fall back to latest version (continue with code below)
-      } catch (error) {
-        console.error(`Error getting template version ${version}:`, error);
-        // Fall back to latest version if error occurs
-      }
-    }
-
-    // Get the latest version (default behavior)
+    // First, check if the template exists at all
     const docRef = doc(this.collectionRef, templateId);
     const docSnap = await getDoc(docRef);
 
     if (!docSnap.exists()) {
-      return null;
+      return null; // Template doesn't exist
+    }
+
+    const currentTemplate = docSnap.data() as DocumentTemplate;
+
+    // If no specific version is requested, simply return the current template
+    if (version === undefined) {
+      return currentTemplate;
     }
 
-    return docSnap.data() as DocumentTemplate;
+    // If the requested version matches the current version, return it
+    if (currentTemplate.version === version) {
+      return currentTemplate;
+    }
+
+    // Otherwise, try to find the requested version in the versions subcollection
+    try {
+      const versionTemplate = await this.getTemplateVersion(
+        templateId,
+        version
+      );
+      if (versionTemplate) {
+        return versionTemplate;
+      }
+    } catch (error) {
+      console.error(`Error getting template version ${version}:`, error);
+    }
+
+    // If we get here, the requested version doesn't exist
+    // Option 1: Return null (strict approach)
+    return null;
+
+    // Option 2: Return current version but indicate it's not the requested version (uncomment to use)
+    // return {
+    //   ...currentTemplate,
+    //   _versionRequested: version,
+    //   _versionNotFound: true
+    // } as DocumentTemplate;
   }
 
   /**

package/src/types/procedure/index.ts

@@ -1,7 +1,10 @@
 import { ProcedureFamily } from "../../backoffice/types/static/procedure-family.types";
 import { Category } from "../../backoffice/types/category.types";
 import { Subcategory } from "../../backoffice/types/subcategory.types";
-import { Technology } from "../../backoffice/types/technology.types";
+import {
+  Technology,
+  type TechnologyDocumentationTemplate,
+} from "../../backoffice/types/technology.types";
 import { Product } from "../../backoffice/types/product.types";
 import {
   PricingMeasure,
@@ -62,7 +65,7 @@ export interface Procedure {
   /** Certification requirements for performing this procedure */
   certificationRequirement: CertificationRequirement;
   /** Documentation templates required for this procedure */
-  documentationTemplates: DocumentTemplate[];
+  documentationTemplates: TechnologyDocumentationTemplate[];
   /** ID of the practitioner who performs this procedure */
   practitionerId: string;
   /** ID of the clinic branch where this procedure is performed */