@blackcode_sa/metaestetics-api 1.5.9 → 1.5.11

package/src/backoffice/services/technology.service.ts

@@ -22,8 +22,11 @@ import {
   CertificationRequirement,
 } from "../types/static/certification.types";
 import { BaseService } from "../../services/base.service";
-import { SUBCATEGORIES_COLLECTION } from "../types/subcategory.types";
-import { CATEGORIES_COLLECTION } from "../types/category.types";
+import { ProcedureFamily } from "../types/static/procedure-family.types";
+import {
+  Practitioner,
+  PractitionerCertification,
+} from "../../types/practitioner";
 
 /**
  * Default vrednosti za sertifikaciju
@@ -35,20 +38,23 @@ const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
 
 /**
  * Servis za upravljanje tehnologijama i njihovim zahtevima.
- * Tehnologije su treći nivo organizacije i pripadaju određenoj podkategoriji.
- * Svaka tehnologija može imati svoje specifične zahteve pre i posle procedure.
+ * Tehnologije su sada top-level kolekcija koja referencira svoju putanju u hijerarhiji
+ * kroz family, categoryId i subcategoryId.
  *
  * @example
  * const technologyService = new TechnologyService();
  *
  * // Kreiranje nove tehnologije
- * const technology = await technologyService.create(categoryId, subcategoryId, {
+ * const technology = await technologyService.create({
  *   name: "Botulinum Toxin",
- *   description: "Neurotoxin injections for wrinkle reduction"
+ *   description: "Neurotoxin injections for wrinkle reduction",
+ *   family: ProcedureFamily.AESTHETICS,
+ *   categoryId: "category123",
+ *   subcategoryId: "subcategory456"
  * });
  *
  * // Dodavanje zahteva
- * await technologyService.addRequirement(categoryId, subcategoryId, technology.id, {
+ * await technologyService.addRequirement(technology.id, {
  *   type: "pre",
  *   name: "Stay Hydrated",
  *   description: "Drink plenty of water"
@@ -56,69 +62,108 @@ const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
  */
 export class TechnologyService extends BaseService {
   /**
-   * Vraća referencu na Firestore kolekciju tehnologija za određenu podkategoriju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
+   * Vraća referencu na Firestore kolekciju tehnologija
    */
-  private getTechnologiesRef(categoryId: string, subcategoryId: string) {
-    return collection(
-      this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION,
-      subcategoryId,
-      TECHNOLOGIES_COLLECTION
-    );
+  private getTechnologiesRef() {
+    return collection(this.db, TECHNOLOGIES_COLLECTION);
   }
 
   /**
-   * Kreira novu tehnologiju u okviru podkategorije
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
+   * Kreira novu tehnologiju
    * @param technology - Podaci za novu tehnologiju
    * @returns Kreirana tehnologija sa generisanim ID-em
    */
-  async create(
-    categoryId: string,
-    subcategoryId: string,
-    technology: Omit<Technology, "id" | "createdAt" | "updatedAt">
-  ) {
+  async create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">) {
     const now = new Date();
     const newTechnology: Omit<Technology, "id"> = {
       ...technology,
-      subcategoryId,
       createdAt: now,
       updatedAt: now,
       isActive: true,
-      requirements: {
+      requirements: technology.requirements || {
         pre: [],
         post: [],
       },
-      blockingConditions: [],
-      contraindications: [],
-      benefits: [],
+      blockingConditions: technology.blockingConditions || [],
+      contraindications: technology.contraindications || [],
+      benefits: technology.benefits || [],
       certificationRequirement:
         technology.certificationRequirement ||
         DEFAULT_CERTIFICATION_REQUIREMENT,
     };
 
-    const docRef = await addDoc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      newTechnology
-    );
+    const docRef = await addDoc(this.getTechnologiesRef(), newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
 
   /**
-   * Vraća sve aktivne tehnologije za određenu podkategoriju
+   * Vraća sve aktivne tehnologije
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAll() {
+    const q = query(this.getTechnologiesRef(), where("isActive", "==", true));
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology)
+    );
+  }
+
+  /**
+   * Vraća sve aktivne tehnologije za određenu familiju
+   * @param family - Familija procedura
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByFamily(family: ProcedureFamily) {
+    const q = query(
+      this.getTechnologiesRef(),
+      where("isActive", "==", true),
+      where("family", "==", family)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology)
+    );
+  }
+
+  /**
+   * Vraća sve aktivne tehnologije za određenu kategoriju
    * @param categoryId - ID kategorije
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByCategoryId(categoryId: string) {
+    const q = query(
+      this.getTechnologiesRef(),
+      where("isActive", "==", true),
+      where("categoryId", "==", categoryId)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology)
+    );
+  }
+
+  /**
+   * Vraća sve aktivne tehnologije za određenu podkategoriju
    * @param subcategoryId - ID podkategorije
    * @returns Lista aktivnih tehnologija
    */
-  async getAllBySubcategoryId(categoryId: string, subcategoryId: string) {
+  async getAllBySubcategoryId(subcategoryId: string) {
     const q = query(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      where("isActive", "==", true)
+      this.getTechnologiesRef(),
+      where("isActive", "==", true),
+      where("subcategoryId", "==", subcategoryId)
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map(
@@ -132,63 +177,46 @@ export class TechnologyService extends BaseService {
 
   /**
    * Ažurira postojeću tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param technology - Novi podaci za tehnologiju
    * @returns Ažurirana tehnologija
    */
   async update(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
-    technology: Partial<Omit<Technology, "id" | "createdAt" | "subcategoryId">>
+    technology: Partial<
+      Omit<
+        Technology,
+        "id" | "createdAt" | "family" | "categoryId" | "subcategoryId"
+      >
+    >
   ) {
     const updateData = {
       ...technology,
       updatedAt: new Date(),
     };
 
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
     await updateDoc(docRef, updateData);
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Soft delete tehnologije (postavlja isActive na false)
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije koja se briše
    */
-  async delete(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
-    await this.update(categoryId, subcategoryId, technologyId, {
+  async delete(technologyId: string) {
+    await this.update(technologyId, {
       isActive: false,
     });
   }
 
   /**
    * Vraća tehnologiju po ID-u
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tražene tehnologije
    * @returns Tehnologija ili null ako ne postoji
    */
-  async getById(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ): Promise<Technology | null> {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async getById(technologyId: string): Promise<Technology | null> {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
     const docSnap = await getDoc(docRef);
     if (!docSnap.exists()) return null;
     return {
@@ -199,22 +227,12 @@ export class TechnologyService extends BaseService {
 
   /**
    * Dodaje novi zahtev tehnologiji
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param requirement - Zahtev koji se dodaje
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
-  async addRequirement(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    requirement: Requirement
-  ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addRequirement(technologyId: string, requirement: Requirement) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     const requirementType =
       requirement.type === "pre" ? "requirements.pre" : "requirements.post";
@@ -224,27 +242,17 @@ export class TechnologyService extends BaseService {
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Uklanja zahtev iz tehnologije
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param requirement - Zahtev koji se uklanja
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
-  async removeRequirement(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    requirement: Requirement
-  ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeRequirement(technologyId: string, requirement: Requirement) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     const requirementType =
       requirement.type === "pre" ? "requirements.pre" : "requirements.post";
@@ -254,28 +262,17 @@ export class TechnologyService extends BaseService {
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Vraća sve zahteve za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param type - Opcioni filter za tip zahteva (pre/post)
    * @returns Lista zahteva
    */
-  async getRequirements(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    type?: RequirementType
-  ) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getRequirements(technologyId: string, type?: RequirementType) {
+    const technology = await this.getById(technologyId);
     if (!technology || !technology.requirements) return [];
 
     if (type) {
@@ -287,300 +284,300 @@ export class TechnologyService extends BaseService {
 
   /**
    * Ažurira postojeći zahtev
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param oldRequirement - Stari zahtev koji se menja
    * @param newRequirement - Novi zahtev koji zamenjuje stari
    * @returns Ažurirana tehnologija
    */
   async updateRequirement(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     oldRequirement: Requirement,
     newRequirement: Requirement
   ) {
-    await this.removeRequirement(
-      categoryId,
-      subcategoryId,
-      technologyId,
-      oldRequirement
-    );
-    return this.addRequirement(
-      categoryId,
-      subcategoryId,
-      technologyId,
-      newRequirement
-    );
+    await this.removeRequirement(technologyId, oldRequirement);
+    return this.addRequirement(technologyId, newRequirement);
   }
 
   /**
    * Dodaje blokirajući uslov tehnologiji
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param condition - Blokirajući uslov koji se dodaje
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     condition: BlockingCondition
   ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       blockingConditions: arrayUnion(condition),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Uklanja blokirajući uslov iz tehnologije
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param condition - Blokirajući uslov koji se uklanja
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     condition: BlockingCondition
   ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       blockingConditions: arrayRemove(condition),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Dodaje kontraindikaciju tehnologiji
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param contraindication - Kontraindikacija koja se dodaje
    * @returns Ažurirana tehnologija
    */
   async addContraindication(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     contraindication: Contraindication
   ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       contraindications: arrayUnion(contraindication),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Uklanja kontraindikaciju iz tehnologije
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param contraindication - Kontraindikacija koja se uklanja
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     contraindication: Contraindication
   ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       contraindications: arrayRemove(contraindication),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Dodaje benefit tehnologiji
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param benefit - Benefit koji se dodaje
    * @returns Ažurirana tehnologija
    */
-  async addBenefit(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    benefit: TreatmentBenefit
-  ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addBenefit(technologyId: string, benefit: TreatmentBenefit) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       benefits: arrayUnion(benefit),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Uklanja benefit iz tehnologije
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param benefit - Benefit koji se uklanja
    * @returns Ažurirana tehnologija
    */
-  async removeBenefit(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    benefit: TreatmentBenefit
-  ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeBenefit(technologyId: string, benefit: TreatmentBenefit) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       benefits: arrayRemove(benefit),
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Vraća sve blokirajuće uslove za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @returns Lista blokirajućih uslova
    */
-  async getBlockingConditions(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getBlockingConditions(technologyId: string) {
+    const technology = await this.getById(technologyId);
     return technology?.blockingConditions || [];
   }
 
   /**
    * Vraća sve kontraindikacije za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @returns Lista kontraindikacija
    */
-  async getContraindications(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getContraindications(technologyId: string) {
+    const technology = await this.getById(technologyId);
     return technology?.contraindications || [];
   }
 
   /**
    * Vraća sve benefite za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @returns Lista benefita
    */
-  async getBenefits(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getBenefits(technologyId: string) {
+    const technology = await this.getById(technologyId);
     return technology?.benefits || [];
   }
 
   /**
    * Ažurira zahteve sertifikacije za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @param certificationRequirement - Novi zahtevi sertifikacije
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     certificationRequirement: CertificationRequirement
   ) {
-    const docRef = doc(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
 
     await updateDoc(docRef, {
       certificationRequirement,
       updatedAt: new Date(),
     });
 
-    return this.getById(categoryId, subcategoryId, technologyId);
+    return this.getById(technologyId);
   }
 
   /**
    * Vraća zahteve sertifikacije za tehnologiju
-   * @param categoryId - ID kategorije
-   * @param subcategoryId - ID podkategorije
    * @param technologyId - ID tehnologije
    * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
    */
   async getCertificationRequirement(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string
   ): Promise<CertificationRequirement | null> {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+    const technology = await this.getById(technologyId);
     return technology?.certificationRequirement || null;
   }
+
+  /**
+   * Proverava da li doktor ima odgovarajuću sertifikaciju za izvođenje tehnologije
+   *
+   * @param requiredCertification - Zahtevana sertifikacija za tehnologiju
+   * @param practitionerCertification - Sertifikacija zdravstvenog radnika
+   * @returns true ako zdravstveni radnik ima odgovarajuću sertifikaciju, false ako nema
+   *
+   * @example
+   * const isValid = technologyService.validateCertification(
+   *   {
+   *     minimumLevel: CertificationLevel.DOCTOR,
+   *     requiredSpecialties: [CertificationSpecialty.INJECTABLES]
+   *   },
+   *   {
+   *     level: CertificationLevel.SPECIALIST,
+   *     specialties: [CertificationSpecialty.INJECTABLES, CertificationSpecialty.LASER]
+   *   }
+   * );
+   */
+  validateCertification(
+    requiredCertification: CertificationRequirement,
+    practitionerCertification: PractitionerCertification
+  ): boolean {
+    // Provera nivoa sertifikacije
+    // Enum je definisan od najnižeg ka najvišem, pa možemo porediti brojeve
+    const doctorLevel = Object.values(CertificationLevel).indexOf(
+      practitionerCertification.level
+    );
+    const requiredLevel = Object.values(CertificationLevel).indexOf(
+      requiredCertification.minimumLevel
+    );
+
+    // Doktor mora imati nivo koji je jednak ili viši od zahtevanog
+    if (doctorLevel < requiredLevel) return false;
+
+    // Provera specijalizacija
+    const requiredSpecialties = requiredCertification.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      // Doktor mora imati sve zahtevane specijalizacije
+      const doctorSpecialties = practitionerCertification.specialties;
+      const hasAllRequiredSpecialties = requiredSpecialties.every(
+        (requiredSpecialty) => doctorSpecialties.includes(requiredSpecialty)
+      );
+
+      if (!hasAllRequiredSpecialties) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Vraća sve tehnologije koje je zdravstveni radnik sertifikovan da izvodi
+   * zajedno sa listama dozvoljenih familija, kategorija i podkategorija
+   *
+   * @param practitioner - Profil zdravstvenog radnika
+   * @returns Objekat koji sadrži:
+   * - technologies: Lista tehnologija koje zdravstveni radnik može da izvodi
+   * - families: Lista familija procedura koje zdravstveni radnik može da izvodi
+   * - categories: Lista ID-eva kategorija koje zdravstveni radnik može da izvodi
+   * - subcategories: Lista ID-eva podkategorija koje zdravstveni radnik može da izvodi
+   *
+   * @example
+   * const practitioner = {
+   *   certification: {
+   *     level: CertificationLevel.DOCTOR,
+   *     specialties: [CertificationSpecialty.INJECTABLES]
+   *   }
+   * };
+   * const allowedTechnologies = await technologyService.getAllowedTechnologies(practitioner);
+   * console.log(allowedTechnologies.families); // [ProcedureFamily.AESTHETICS]
+   * console.log(allowedTechnologies.categories); // ["category1", "category2"]
+   * console.log(allowedTechnologies.subcategories); // ["subcategory1", "subcategory2"]
+   */
+  async getAllowedTechnologies(practitioner: Practitioner): Promise<{
+    technologies: Technology[];
+    families: ProcedureFamily[];
+    categories: string[];
+    subcategories: string[];
+  }> {
+    // Get all active technologies
+    const allTechnologies = await this.getAll();
+
+    // Filter technologies based on certification requirements
+    const allowedTechnologies = allTechnologies.filter((technology) =>
+      this.validateCertification(
+        technology.certificationRequirement,
+        practitioner.certification
+      )
+    );
+
+    // Extract unique families, categories, and subcategories
+    const families = [...new Set(allowedTechnologies.map((t) => t.family))];
+    const categories = [
+      ...new Set(allowedTechnologies.map((t) => t.categoryId)),
+    ];
+    const subcategories = [
+      ...new Set(allowedTechnologies.map((t) => t.subcategoryId)),
+    ];
+
+    return {
+      technologies: allowedTechnologies,
+      families,
+      categories,
+      subcategories,
+    };
+  }
 }