@blackcode_sa/metaestetics-api 1.5.10 → 1.5.12

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

@@ -4,6 +4,7 @@ import { Contraindication } from "./static/contraindication.types";
 import { TreatmentBenefit } from "./static/treatment-benefit.types";
 import { CertificationRequirement } from "./static/certification.types";
 import { DocumentTemplate } from "../../types/documentation-templates";
+import { ProcedureFamily } from "./static/procedure-family.types";
 
 /**
  * Zahtevi koji su povezani sa tehnologijom
@@ -17,12 +18,14 @@ export interface TechnologyRequirements {
 
 /**
  * Technology used in medical procedures
- * Technologies are the third level of hierarchy, belonging to a specific subcategory
- * and represent a specific method or approach to treatment
+ * Technologies are now a top-level collection that reference their full path in the hierarchy
+ * through family, category, and subcategory IDs
  *
  * @property id - Unique identifier of the technology
  * @property name - Name of the technology
  * @property description - Detailed description of the technology and its application
+ * @property family - The procedure family this technology belongs to (aesthetics/surgery)
+ * @property categoryId - ID of the category this technology belongs to
  * @property subcategoryId - ID of the subcategory this technology belongs to
  * @property technicalDetails - Technical specifications and details
  * @property requirements - List of pre and post procedure requirements
@@ -44,6 +47,12 @@ export interface Technology {
   /** Detaljan opis tehnologije */
   description: string;
 
+  /** Familija procedura kojoj tehnologija pripada */
+  family: ProcedureFamily;
+
+  /** ID kategorije kojoj tehnologija pripada */
+  categoryId: string;
+
   /** ID potkategorije kojoj tehnologija pripada */
   subcategoryId: string;
 

package/src/backoffice/validations/schemas.ts

@@ -81,6 +81,8 @@ export const technologySchema = z.object({
     .string()
     .max(2000, "Technical details are too long")
     .optional(),
+  family: procedureFamilySchema,
+  categoryId: z.string().min(1, "Category ID is required"),
   subcategoryId: z.string().min(1, "Subcategory ID is required"),
   requirements: technologyRequirementsSchema.default({
     pre: [],

package/src/services/procedure/procedure.service.ts

@@ -47,6 +47,12 @@ import { CategoryService } from "../../backoffice/services/category.service";
 import { SubcategoryService } from "../../backoffice/services/subcategory.service";
 import { TechnologyService } from "../../backoffice/services/technology.service";
 import { ProductService } from "../../backoffice/services/product.service";
+import { Practitioner } from "../../types/practitioner";
+import {
+  CertificationLevel,
+  CertificationSpecialty,
+  ProcedureFamily,
+} from "../../backoffice/types";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -86,11 +92,7 @@ export class ProcedureService extends BaseService {
         validatedData.categoryId,
         validatedData.subcategoryId
       ),
-      this.technologyService.getById(
-        validatedData.categoryId,
-        validatedData.subcategoryId,
-        validatedData.technologyId
-      ),
+      this.technologyService.getById(validatedData.technologyId),
       this.productService.getById(
         validatedData.categoryId,
         validatedData.subcategoryId,
@@ -228,4 +230,59 @@ export class ProcedureService extends BaseService {
       updatedAt: serverTimestamp(),
     });
   }
+
+  /**
+   * Gets all procedures that a practitioner is certified to perform
+   * @param practitioner - The practitioner's profile
+   * @returns Object containing:
+   * - procedures: List of procedures the practitioner can perform
+   * - families: List of procedure families the practitioner can perform
+   * - categories: List of category IDs the practitioner can perform
+   * - subcategories: List of subcategory IDs the practitioner can perform
+   *
+   * @example
+   * const practitioner = {
+   *   certification: {
+   *     level: CertificationLevel.DOCTOR,
+   *     specialties: [CertificationSpecialty.INJECTABLES]
+   *   }
+   * };
+   * const allowedProcedures = await procedureService.getAllowedProcedures(practitioner);
+   * console.log(allowedProcedures.families); // [ProcedureFamily.AESTHETICS]
+   * console.log(allowedProcedures.categories); // ["category1", "category2"]
+   * console.log(allowedProcedures.subcategories); // ["subcategory1", "subcategory2"]
+   */
+  async getAllowedProcedures(practitioner: Practitioner): Promise<{
+    procedures: Procedure[];
+    families: ProcedureFamily[];
+    categories: string[];
+    subcategories: string[];
+  }> {
+    // Get all allowed technologies for the practitioner
+    const { technologies, families, categories, subcategories } =
+      await this.technologyService.getAllowedTechnologies(practitioner);
+
+    // Get all procedures for these technologies
+    const procedures = await Promise.all(
+      technologies.map(async (technology) => {
+        const q = query(
+          collection(this.db, PROCEDURES_COLLECTION),
+          where("technologyId", "==", technology.id),
+          where("isActive", "==", true)
+        );
+        const snapshot = await getDocs(q);
+        return snapshot.docs.map((doc) => doc.data() as Procedure);
+      })
+    );
+
+    // Flatten the array of procedure arrays
+    const flattenedProcedures = procedures.flat();
+
+    return {
+      procedures: flattenedProcedures,
+      families,
+      categories,
+      subcategories,
+    };
+  }
 }