@blackcode_sa/metaestetics-api 1.5.9 → 1.5.11

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/services/procedure/procedure.service.ts

@@ -43,10 +43,37 @@ import {
   Product,
   PRODUCTS_COLLECTION,
 } from "../../backoffice/types/product.types";
+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 {
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+  private categoryService: CategoryService;
+  private subcategoryService: SubcategoryService;
+  private technologyService: TechnologyService;
+  private productService: ProductService;
+
+  constructor(
+    db: Firestore,
+    auth: Auth,
+    app: FirebaseApp,
+    categoryService: CategoryService,
+    subcategoryService: SubcategoryService,
+    technologyService: TechnologyService,
+    productService: ProductService
+  ) {
     super(db, auth, app);
+    this.categoryService = categoryService;
+    this.subcategoryService = subcategoryService;
+    this.technologyService = technologyService;
+    this.productService = productService;
   }
 
   /**
@@ -60,10 +87,18 @@ export class ProcedureService extends BaseService {
 
     // Get references to related entities
     const [category, subcategory, technology, product] = await Promise.all([
-      this.getCategory(validatedData.categoryId),
-      this.getSubcategory(validatedData.subcategoryId),
-      this.getTechnology(validatedData.technologyId),
-      this.getProduct(validatedData.productId),
+      this.categoryService.getById(validatedData.categoryId),
+      this.subcategoryService.getById(
+        validatedData.categoryId,
+        validatedData.subcategoryId
+      ),
+      this.technologyService.getById(validatedData.technologyId),
+      this.productService.getById(
+        validatedData.categoryId,
+        validatedData.subcategoryId,
+        validatedData.technologyId,
+        validatedData.productId
+      ),
     ]);
 
     if (!category || !subcategory || !technology || !product) {
@@ -197,42 +232,57 @@ export class ProcedureService extends BaseService {
   }
 
   /**
-   * Gets a category by ID
-   * @private
+   * 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"]
    */
-  private async getCategory(id: string): Promise<Category | null> {
-    const docRef = doc(this.db, CATEGORIES_COLLECTION, id);
-    const docSnap = await getDoc(docRef);
-    return docSnap.exists() ? (docSnap.data() as Category) : null;
-  }
+  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);
 
-  /**
-   * Gets a subcategory by ID
-   * @private
-   */
-  private async getSubcategory(id: string): Promise<Subcategory | null> {
-    const docRef = doc(this.db, SUBCATEGORIES_COLLECTION, id);
-    const docSnap = await getDoc(docRef);
-    return docSnap.exists() ? (docSnap.data() as Subcategory) : null;
-  }
+    // 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);
+      })
+    );
 
-  /**
-   * Gets a technology by ID
-   * @private
-   */
-  private async getTechnology(id: string): Promise<Technology | null> {
-    const docRef = doc(this.db, TECHNOLOGIES_COLLECTION, id);
-    const docSnap = await getDoc(docRef);
-    return docSnap.exists() ? (docSnap.data() as Technology) : null;
-  }
+    // Flatten the array of procedure arrays
+    const flattenedProcedures = procedures.flat();
 
-  /**
-   * Gets a product by ID
-   * @private
-   */
-  private async getProduct(id: string): Promise<Product | null> {
-    const docRef = doc(this.db, PRODUCTS_COLLECTION, id);
-    const docSnap = await getDoc(docRef);
-    return docSnap.exists() ? (docSnap.data() as Product) : null;
+    return {
+      procedures: flattenedProcedures,
+      families,
+      categories,
+      subcategories,
+    };
   }
 }