@blackcode_sa/metaestetics-api 1.5.9 → 1.5.11

package/dist/index.js

@@ -6432,22 +6432,14 @@ var procedureSchema = createProcedureSchema.extend({
   updatedAt: import_zod16.z.date()
 });
 
-// src/backoffice/types/category.types.ts
-var CATEGORIES_COLLECTION = "backoffice_categories";
-
-// src/backoffice/types/subcategory.types.ts
-var SUBCATEGORIES_COLLECTION = "subcategories";
-
-// src/backoffice/types/technology.types.ts
-var TECHNOLOGIES_COLLECTION = "technologies";
-
-// src/backoffice/types/product.types.ts
-var PRODUCTS_COLLECTION = "products";
-
 // src/services/procedure/procedure.service.ts
 var ProcedureService = class extends BaseService {
-  constructor(db, auth, app) {
+  constructor(db, auth, app, categoryService, subcategoryService, technologyService, productService) {
     super(db, auth, app);
+    this.categoryService = categoryService;
+    this.subcategoryService = subcategoryService;
+    this.technologyService = technologyService;
+    this.productService = productService;
   }
   /**
    * Creates a new procedure
@@ -6457,10 +6449,18 @@ var ProcedureService = class extends BaseService {
   async createProcedure(data) {
     const validatedData = createProcedureSchema.parse(data);
     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) {
       throw new Error("One or more required entities not found");
@@ -6567,40 +6567,46 @@ var ProcedureService = class extends BaseService {
     });
   }
   /**
-   * Gets a category by ID
-   * @private
-   */
-  async getCategory(id) {
-    const docRef = (0, import_firestore21.doc)(this.db, CATEGORIES_COLLECTION, id);
-    const docSnap = await (0, import_firestore21.getDoc)(docRef);
-    return docSnap.exists() ? docSnap.data() : null;
-  }
-  /**
-   * Gets a subcategory by ID
-   * @private
-   */
-  async getSubcategory(id) {
-    const docRef = (0, import_firestore21.doc)(this.db, SUBCATEGORIES_COLLECTION, id);
-    const docSnap = await (0, import_firestore21.getDoc)(docRef);
-    return docSnap.exists() ? docSnap.data() : null;
-  }
-  /**
-   * Gets a technology by ID
-   * @private
-   */
-  async getTechnology(id) {
-    const docRef = (0, import_firestore21.doc)(this.db, TECHNOLOGIES_COLLECTION, id);
-    const docSnap = await (0, import_firestore21.getDoc)(docRef);
-    return docSnap.exists() ? docSnap.data() : null;
-  }
-  /**
-   * Gets a product by ID
-   * @private
-   */
-  async getProduct(id) {
-    const docRef = (0, import_firestore21.doc)(this.db, PRODUCTS_COLLECTION, id);
-    const docSnap = await (0, import_firestore21.getDoc)(docRef);
-    return docSnap.exists() ? docSnap.data() : null;
+   * 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) {
+    const { technologies, families, categories, subcategories } = await this.technologyService.getAllowedTechnologies(practitioner);
+    const procedures = await Promise.all(
+      technologies.map(async (technology) => {
+        const q = (0, import_firestore21.query)(
+          (0, import_firestore21.collection)(this.db, PROCEDURES_COLLECTION),
+          (0, import_firestore21.where)("technologyId", "==", technology.id),
+          (0, import_firestore21.where)("isActive", "==", true)
+        );
+        const snapshot = await (0, import_firestore21.getDocs)(q);
+        return snapshot.docs.map((doc26) => doc26.data());
+      })
+    );
+    const flattenedProcedures = procedures.flat();
+    return {
+      procedures: flattenedProcedures,
+      families,
+      categories,
+      subcategories
+    };
   }
 };
 
@@ -9616,6 +9622,11 @@ var BrandService = class extends BaseService {
 
 // src/backoffice/services/category.service.ts
 var import_firestore35 = require("firebase/firestore");
+
+// src/backoffice/types/category.types.ts
+var CATEGORIES_COLLECTION = "backoffice_categories";
+
+// src/backoffice/services/category.service.ts
 var CategoryService = class extends BaseService {
   /**
    * Referenca na Firestore kolekciju kategorija
@@ -9712,6 +9723,11 @@ var CategoryService = class extends BaseService {
 
 // src/backoffice/services/subcategory.service.ts
 var import_firestore36 = require("firebase/firestore");
+
+// src/backoffice/types/subcategory.types.ts
+var SUBCATEGORIES_COLLECTION = "subcategories";
+
+// src/backoffice/services/subcategory.service.ts
 var SubcategoryService = class extends BaseService {
   /**
    * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
@@ -9807,66 +9823,108 @@ var SubcategoryService = class extends BaseService {
 
 // src/backoffice/services/technology.service.ts
 var import_firestore37 = require("firebase/firestore");
+
+// src/backoffice/types/technology.types.ts
+var TECHNOLOGIES_COLLECTION = "technologies";
+
+// src/backoffice/services/technology.service.ts
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
 };
 var TechnologyService = class 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
    */
-  getTechnologiesRef(categoryId, subcategoryId) {
-    return (0, import_firestore37.collection)(
-      this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION,
-      subcategoryId,
-      TECHNOLOGIES_COLLECTION
-    );
+  getTechnologiesRef() {
+    return (0, import_firestore37.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, subcategoryId, technology) {
+  async create(technology) {
     const now = /* @__PURE__ */ new Date();
     const newTechnology = {
       ...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 (0, import_firestore37.addDoc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      newTechnology
-    );
+    const docRef = await (0, import_firestore37.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 = (0, import_firestore37.query)(this.getTechnologiesRef(), (0, import_firestore37.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore37.getDocs)(q);
+    return snapshot.docs.map(
+      (doc26) => ({
+        id: doc26.id,
+        ...doc26.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu familiju
+   * @param family - Familija procedura
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByFamily(family) {
+    const q = (0, import_firestore37.query)(
+      this.getTechnologiesRef(),
+      (0, import_firestore37.where)("isActive", "==", true),
+      (0, import_firestore37.where)("family", "==", family)
+    );
+    const snapshot = await (0, import_firestore37.getDocs)(q);
+    return snapshot.docs.map(
+      (doc26) => ({
+        id: doc26.id,
+        ...doc26.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu kategoriju
    * @param categoryId - ID kategorije
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByCategoryId(categoryId) {
+    const q = (0, import_firestore37.query)(
+      this.getTechnologiesRef(),
+      (0, import_firestore37.where)("isActive", "==", true),
+      (0, import_firestore37.where)("categoryId", "==", categoryId)
+    );
+    const snapshot = await (0, import_firestore37.getDocs)(q);
+    return snapshot.docs.map(
+      (doc26) => ({
+        id: doc26.id,
+        ...doc26.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu podkategoriju
    * @param subcategoryId - ID podkategorije
    * @returns Lista aktivnih tehnologija
    */
-  async getAllBySubcategoryId(categoryId, subcategoryId) {
+  async getAllBySubcategoryId(subcategoryId) {
     const q = (0, import_firestore37.query)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      (0, import_firestore37.where)("isActive", "==", true)
+      this.getTechnologiesRef(),
+      (0, import_firestore37.where)("isActive", "==", true),
+      (0, import_firestore37.where)("subcategoryId", "==", subcategoryId)
     );
     const snapshot = await (0, import_firestore37.getDocs)(q);
     return snapshot.docs.map(
@@ -9878,47 +9936,35 @@ var TechnologyService = class 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, subcategoryId, technologyId, technology) {
+  async update(technologyId, technology) {
     const updateData = {
       ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.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, subcategoryId, technologyId) {
-    await this.update(categoryId, subcategoryId, technologyId, {
+  async delete(technologyId) {
+    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, subcategoryId, technologyId) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async getById(technologyId) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     const docSnap = await (0, import_firestore37.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
@@ -9928,58 +9974,42 @@ var TechnologyService = class 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, subcategoryId, technologyId, requirement) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addRequirement(technologyId, requirement) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await (0, import_firestore37.updateDoc)(docRef, {
       [requirementType]: (0, import_firestore37.arrayUnion)(requirement),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, requirement) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeRequirement(technologyId, requirement) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await (0, import_firestore37.updateDoc)(docRef, {
       [requirementType]: (0, import_firestore37.arrayRemove)(requirement),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, type) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getRequirements(technologyId, type) {
+    const technology = await this.getById(technologyId);
     if (!technology || !technology.requirements) return [];
     if (type) {
       return technology.requirements[type];
@@ -9988,224 +10018,240 @@ var TechnologyService = class 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, subcategoryId, technologyId, oldRequirement, newRequirement) {
-    await this.removeRequirement(
-      categoryId,
-      subcategoryId,
-      technologyId,
-      oldRequirement
-    );
-    return this.addRequirement(
-      categoryId,
-      subcategoryId,
-      technologyId,
-      newRequirement
-    );
+  async updateRequirement(technologyId, oldRequirement, 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, subcategoryId, technologyId, condition) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addBlockingCondition(technologyId, condition) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       blockingConditions: (0, import_firestore37.arrayUnion)(condition),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, condition) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeBlockingCondition(technologyId, condition) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       blockingConditions: (0, import_firestore37.arrayRemove)(condition),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, contraindication) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addContraindication(technologyId, contraindication) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       contraindications: (0, import_firestore37.arrayUnion)(contraindication),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, contraindication) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeContraindication(technologyId, contraindication) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       contraindications: (0, import_firestore37.arrayRemove)(contraindication),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, benefit) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addBenefit(technologyId, benefit) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       benefits: (0, import_firestore37.arrayUnion)(benefit),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId, benefit) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeBenefit(technologyId, benefit) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       benefits: (0, import_firestore37.arrayRemove)(benefit),
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getBlockingConditions(technologyId) {
+    const technology = await this.getById(technologyId);
     return (technology == null ? void 0 : 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, subcategoryId, technologyId) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getContraindications(technologyId) {
+    const technology = await this.getById(technologyId);
     return (technology == null ? void 0 : 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, subcategoryId, technologyId) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getBenefits(technologyId) {
+    const technology = await this.getById(technologyId);
     return (technology == null ? void 0 : 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, subcategoryId, technologyId, certificationRequirement) {
-    const docRef = (0, import_firestore37.doc)(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async updateCertificationRequirement(technologyId, certificationRequirement) {
+    const docRef = (0, import_firestore37.doc)(this.getTechnologiesRef(), technologyId);
     await (0, import_firestore37.updateDoc)(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ 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, subcategoryId, technologyId) {
-    const technology = await this.getById(
-      categoryId,
-      subcategoryId,
-      technologyId
-    );
+  async getCertificationRequirement(technologyId) {
+    const technology = await this.getById(technologyId);
     return (technology == null ? void 0 : 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, practitionerCertification) {
+    const doctorLevel = Object.values(CertificationLevel).indexOf(
+      practitionerCertification.level
+    );
+    const requiredLevel = Object.values(CertificationLevel).indexOf(
+      requiredCertification.minimumLevel
+    );
+    if (doctorLevel < requiredLevel) return false;
+    const requiredSpecialties = requiredCertification.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      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) {
+    const allTechnologies = await this.getAll();
+    const allowedTechnologies = allTechnologies.filter(
+      (technology) => this.validateCertification(
+        technology.certificationRequirement,
+        practitioner.certification
+      )
+    );
+    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
+    };
+  }
 };
 
 // src/backoffice/services/product.service.ts
 var import_firestore38 = require("firebase/firestore");
+
+// src/backoffice/types/product.types.ts
+var PRODUCTS_COLLECTION = "products";
+
+// src/backoffice/services/product.service.ts
 var ProductService = class extends BaseService {
   getProductsRefByTechnology(categoryId, subcategoryId, technologyId) {
     return (0, import_firestore38.collection)(