@blackcode_sa/metaestetics-api 1.6.23 → 1.6.25

package/dist/index.js

@@ -8426,15 +8426,34 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * Get a document template by ID
    * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
    * @returns The template or null if not found
    */
-  async getTemplateById(templateId) {
+  async getTemplateById(templateId, version) {
     const docRef = (0, import_firestore25.doc)(this.collectionRef, templateId);
     const docSnap = await (0, import_firestore25.getDoc)(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
@@ -8450,6 +8469,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = (0, import_firestore25.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = (0, import_firestore25.doc)(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await (0, import_firestore25.setDoc)(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -8478,6 +8506,41 @@ var DocumentationTemplateService = class extends BaseService {
     await (0, import_firestore25.updateDoc)(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(templateId, versionNumber) {
+    const versionDocRef = (0, import_firestore25.doc)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await (0, import_firestore25.getDoc)(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = (0, import_firestore25.collection)(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = (0, import_firestore25.query)(versionsCollectionRef, (0, import_firestore25.orderBy)("version", "desc"));
+    const querySnapshot = await (0, import_firestore25.getDocs)(q);
+    const versions = [];
+    querySnapshot.forEach((doc33) => {
+      versions.push(doc33.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete

package/dist/index.mjs

@@ -8414,15 +8414,34 @@ var DocumentationTemplateService = class extends BaseService {
   /**
    * Get a document template by ID
    * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
    * @returns The template or null if not found
    */
-  async getTemplateById(templateId) {
+  async getTemplateById(templateId, version) {
     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
@@ -8438,6 +8457,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
+    const versionsCollectionRef = collection16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc16(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc14(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -8466,6 +8494,41 @@ var DocumentationTemplateService = class extends BaseService {
     await updateDoc16(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(templateId, versionNumber) {
+    const versionDocRef = doc16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc19(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = collection16(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query16(versionsCollectionRef, orderBy5("version", "desc"));
+    const querySnapshot = await getDocs16(q);
+    const versions = [];
+    querySnapshot.forEach((doc33) => {
+      versions.push(doc33.data());
+    });
+    return versions;
+  }
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.6.23",
+  "version": "1.6.25",
   "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,
@@ -539,12 +540,14 @@ export class BookingAdmin {
       ) {
         pendingUserFormsIds = procedure.documentationTemplates
           .filter(
-            (template: AppDocumentTemplate) =>
+            (template: TechnologyDocumentationTemplate) =>
               template.isUserForm && template.isRequired
           )
-          .map((template: AppDocumentTemplate) => template.id);
+          .map(
+            (template: TechnologyDocumentationTemplate) => template.templateId
+          );
         linkedFormIds = procedure.documentationTemplates.map(
-          (template: AppDocumentTemplate) => template.id
+          (template: TechnologyDocumentationTemplate) => template.templateId
         );
       }
 
@@ -675,11 +678,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/services/documentation-template.service.ts

@@ -41,10 +41,14 @@ export class DocumentationTemplateService {
   /**
    * Get a document template by ID
    * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
    * @returns The template or null if not found
    */
-  async getTemplateById(templateId: string): Promise<DocumentTemplate | null> {
-    return this.apiService.getTemplateById(templateId);
+  async getTemplateById(
+    templateId: string,
+    version?: number
+  ): Promise<DocumentTemplate | null> {
+    return this.apiService.getTemplateById(templateId, version);
   }
 
   /**
@@ -119,4 +123,26 @@ export class DocumentationTemplateService {
   }> {
     return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
   }
+
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(
+    templateId: string,
+    versionNumber: number
+  ): Promise<DocumentTemplate | null> {
+    return this.apiService.getTemplateVersion(templateId, versionNumber);
+  }
+
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateVersions(templateId: string): Promise<DocumentTemplate[]> {
+    return this.apiService.getTemplateOldVersions(templateId);
+  }
 }

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

@@ -88,17 +88,56 @@ export class DocumentationTemplateService extends BaseService {
   /**
    * Get a document template by ID
    * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
    * @returns The template or null if not found
    */
-  async getTemplateById(templateId: string): Promise<DocumentTemplate | null> {
+  async getTemplateById(
+    templateId: string,
+    version?: number
+  ): Promise<DocumentTemplate | null> {
+    // 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;
+    }
+
+    // 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);
     }
 
-    return docSnap.data() as DocumentTemplate;
+    // 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;
   }
 
   /**
@@ -121,6 +160,17 @@ export class DocumentationTemplateService extends BaseService {
       throw new Error(`Template with ID ${templateId} not found`);
     }
 
+    // Store the current version in the versions subcollection
+    const versionsCollectionRef = collection(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc(versionDocRef, template);
+
     // Process elements if provided
     let updatedElements = template.elements;
     if (validatedData.elements) {
@@ -158,6 +208,53 @@ export class DocumentationTemplateService extends BaseService {
     return { ...template, ...updatePayload } as DocumentTemplate;
   }
 
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(
+    templateId: string,
+    versionNumber: number
+  ): Promise<DocumentTemplate | null> {
+    const versionDocRef = doc(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc(versionDocRef);
+
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+
+    return versionDocSnap.data() as DocumentTemplate;
+  }
+
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(
+    templateId: string
+  ): Promise<DocumentTemplate[]> {
+    const versionsCollectionRef = collection(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query(versionsCollectionRef, orderBy("version", "desc"));
+
+    const querySnapshot = await getDocs(q);
+    const versions: DocumentTemplate[] = [];
+
+    querySnapshot.forEach((doc) => {
+      versions.push(doc.data() as DocumentTemplate);
+    });
+
+    return versions;
+  }
+
   /**
    * Delete a document template
    * @param templateId - ID of the template to delete

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