@blackcode_sa/metaestetics-api 1.6.24 → 1.6.26

package/dist/index.mjs

@@ -8418,25 +8418,30 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template or null if not found
    */
   async getTemplateById(templateId, version) {
-    if (version !== void 0) {
-      try {
-        const versionTemplate = await this.getTemplateVersion(
-          templateId,
-          version
-        );
-        if (versionTemplate) {
-          return versionTemplate;
-        }
-      } catch (error) {
-        console.error(`Error getting template version ${version}:`, error);
-      }
-    }
     const docRef = doc16(this.collectionRef, templateId);
     const docSnap = await getDoc19(docRef);
     if (!docSnap.exists()) {
       return null;
     }
-    return docSnap.data();
+    const currentTemplate = docSnap.data();
+    if (version === void 0) {
+      return currentTemplate;
+    }
+    if (currentTemplate.version === version) {
+      return currentTemplate;
+    }
+    try {
+      const versionTemplate = await this.getTemplateVersion(
+        templateId,
+        version
+      );
+      if (versionTemplate) {
+        return versionTemplate;
+      }
+    } catch (error) {
+      console.error(`Error getting template version ${version}:`, error);
+    }
+    return null;
   }
   /**
    * Update an existing document template
@@ -8669,6 +8674,7 @@ var FilledDocumentService = class extends BaseService {
   /**
    * Create a new filled document within an appointment's subcollection.
    * @param templateId - ID of the template to use.
+   * @param templateVersion - Version of the template to use.
    * @param appointmentId - ID of the appointment this form belongs to.
    * @param procedureId - ID of the procedure associated with this form.
    * @param patientId - ID of the patient.
@@ -8678,8 +8684,11 @@ var FilledDocumentService = class extends BaseService {
    * @param initialStatus - Optional initial status for the form.
    * @returns The created filled document.
    */
-  async createFilledDocumentForAppointment(templateId, appointmentId, procedureId, patientId, practitionerId, clinicId, initialValues = {}, initialStatus = "draft" /* DRAFT */) {
-    const template = await this.templateService.getTemplateById(templateId);
+  async createFilledDocumentForAppointment(templateId, templateVersion, appointmentId, procedureId, patientId, practitionerId, clinicId, initialValues = {}, initialStatus = "draft" /* DRAFT */) {
+    const template = await this.templateService.getTemplateById(
+      templateId,
+      templateVersion
+    );
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }

package/package.json

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

package/src/admin/booking/booking.admin.ts

@@ -44,6 +44,7 @@ import {
   USER_FORMS_SUBCOLLECTION,
   DOCTOR_FORMS_SUBCOLLECTION,
 } from "../../types/documentation-templates";
+import { TechnologyDocumentationTemplate } from "../../backoffice/types/technology.types";
 import {
   ClinicInfo,
   PractitionerProfileInfo,
@@ -486,67 +487,49 @@ export class BookingAdmin {
           admin.firestore.Timestamp.now(),
         gender: patientSensitiveData?.gender || Gender.OTHER,
       };
-      const procedureCategory = procedure.category as Category;
-      const procedureSubCategory = procedure.subcategory as Subcategory;
-      const procedureTechnology = procedure.technology as Technology;
-      const procedureProduct = procedure.product as Product;
-
-      const procedureInfo: ProcedureSummaryInfo = {
-        id: procedure.id,
-        name: procedure.name,
-        description: procedure.description,
-        family: procedure.family,
-        categoryName: procedureCategory?.name || "",
-        subcategoryName: procedureSubCategory?.name || "",
-        technologyName: procedureTechnology?.name || "",
-        price: procedure.price,
-        pricingMeasure: procedure.pricingMeasure,
-        currency: procedure.currency,
-        duration: procedure.duration,
-        clinicId: procedure.clinicBranchId,
-        clinicName: clinicData.name,
-        practitionerId: procedure.practitionerId,
-        practitionerName: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
-        photo: procedure.photos?.[0] || "",
-        brandName: procedureProduct?.brandName || "",
-        productName: procedureProduct?.name || "",
-      };
-      const procedureExtendedInfo: ProcedureExtendedInfo = {
-        id: procedure.id,
-        name: procedure.name,
-        description: procedure.description,
-        cost: procedure.price,
-        duration: procedure.duration,
-        procedureFamily: procedure.family,
-        procedureCategoryId: procedureCategory?.id || "",
-        procedureCategoryName: procedureCategory?.name || "",
-        procedureSubCategoryId: procedureSubCategory?.id || "",
-        procedureSubCategoryName: procedureSubCategory?.name || "",
-        procedureTechnologyId: procedureTechnology?.id || "",
-        procedureTechnologyName: procedureTechnology?.name || "",
-        procedureProductBrandId: procedureProduct.brandId || "",
-        procedureProductBrandName: procedureProduct.brandName || "",
-        procedureProductId: procedureProduct.id || "",
-        procedureProductName: procedureProduct.name || "",
-      };
-
-      // --- 6. Determine pendingUserFormsIds and linkedFormIds ---
-      let pendingUserFormsIds: string[] = [];
-      let linkedFormIds: string[] = [];
-      if (
-        procedure.documentationTemplates &&
-        Array.isArray(procedure.documentationTemplates)
-      ) {
-        pendingUserFormsIds = procedure.documentationTemplates
-          .filter(
-            (template: AppDocumentTemplate) =>
-              template.isUserForm && template.isRequired
-          )
-          .map((template: AppDocumentTemplate) => template.id);
-        linkedFormIds = procedure.documentationTemplates.map(
-          (template: AppDocumentTemplate) => template.id
-        );
-      }
+      // const procedureCategory = procedure.category as Category;
+      // const procedureSubCategory = procedure.subcategory as Subcategory;
+      // const procedureTechnology = procedure.technology as Technology;
+      // const procedureProduct = procedure.product as Product;
+
+      // const procedureExtendedInfo: ProcedureExtendedInfo = {
+      //   id: procedure.id,
+      //   name: procedure.name,
+      //   description: procedure.description,
+      //   cost: procedure.price,
+      //   duration: procedure.duration,
+      //   procedureFamily: procedure.family,
+      //   procedureCategoryId: procedureCategory?.id || "",
+      //   procedureCategoryName: procedureCategory?.name || "",
+      //   procedureSubCategoryId: procedureSubCategory?.id || "",
+      //   procedureSubCategoryName: procedureSubCategory?.name || "",
+      //   procedureTechnologyId: procedureTechnology?.id || "",
+      //   procedureTechnologyName: procedureTechnology?.name || "",
+      //   procedureProductBrandId: procedureProduct.brandId || "",
+      //   procedureProductBrandName: procedureProduct.brandName || "",
+      //   procedureProductId: procedureProduct.id || "",
+      //   procedureProductName: procedureProduct.name || "",
+      // };
+
+      // // --- 6. Determine pendingUserFormsIds and linkedFormIds ---
+      // let pendingUserFormsIds: string[] = [];
+      // let linkedFormIds: string[] = [];
+      // if (
+      //   procedure.documentationTemplates &&
+      //   Array.isArray(procedure.documentationTemplates)
+      // ) {
+      //   pendingUserFormsIds = procedure.documentationTemplates
+      //     .filter(
+      //       (template: TechnologyDocumentationTemplate) =>
+      //         template.isUserForm && template.isRequired
+      //     )
+      //     .map(
+      //       (template: TechnologyDocumentationTemplate) => template.templateId
+      //     );
+      //   linkedFormIds = procedure.documentationTemplates.map(
+      //     (template: TechnologyDocumentationTemplate) => template.templateId
+      //   );
+      // }
 
       // --- 7. Construct New Appointment Object ---
       const newAppointmentId = this.db
@@ -675,11 +658,11 @@ export class BookingAdmin {
         procedure.documentationTemplates.length > 0
       ) {
         const formInitResult =
-          this.documentManagerAdmin.batchInitializeAppointmentForms(
+          await this.documentManagerAdmin.batchInitializeAppointmentFormsFromTechnologyTemplates(
             batch,
             newAppointmentId,
             procedure.id, // Pass the actual procedureId for the forms
-            procedure.documentationTemplates as AppDocumentTemplate[],
+            procedure.documentationTemplates,
             data.patientId,
             procedure.practitionerId,
             procedure.clinicBranchId,

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/services/documentation-templates/filled-document.service.ts

@@ -48,6 +48,7 @@ export class FilledDocumentService extends BaseService {
   /**
    * Create a new filled document within an appointment's subcollection.
    * @param templateId - ID of the template to use.
+   * @param templateVersion - Version of the template to use.
    * @param appointmentId - ID of the appointment this form belongs to.
    * @param procedureId - ID of the procedure associated with this form.
    * @param patientId - ID of the patient.
@@ -59,6 +60,7 @@ export class FilledDocumentService extends BaseService {
    */
   async createFilledDocumentForAppointment(
     templateId: string,
+    templateVersion: number,
     appointmentId: string,
     procedureId: string,
     patientId: string,
@@ -67,7 +69,10 @@ export class FilledDocumentService extends BaseService {
     initialValues: { [elementId: string]: any } = {},
     initialStatus: FilledDocumentStatus = FilledDocumentStatus.DRAFT
   ): Promise<FilledDocument> {
-    const template = await this.templateService.getTemplateById(templateId);
+    const template = await this.templateService.getTemplateById(
+      templateId,
+      templateVersion
+    );
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }

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 */