@blackcode_sa/metaestetics-api 1.5.10 → 1.5.12

package/dist/backoffice/index.mjs

@@ -468,6 +468,8 @@ var technologySchema = z2.object({
   name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
   description: z2.string().max(1e3, "Description is too long").optional(),
   technicalDetails: z2.string().max(2e3, "Technical details are too long").optional(),
+  family: procedureFamilySchema,
+  categoryId: z2.string().min(1, "Category ID is required"),
   subcategoryId: z2.string().min(1, "Subcategory ID is required"),
   requirements: technologyRequirementsSchema.default({
     pre: [],
@@ -752,60 +754,97 @@ var DEFAULT_CERTIFICATION_REQUIREMENT2 = {
 };
 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 collection3(
-      this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION,
-      subcategoryId,
-      TECHNOLOGIES_COLLECTION
-    );
+  getTechnologiesRef() {
+    return collection3(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_REQUIREMENT2
     };
-    const docRef = await addDoc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      newTechnology
-    );
+    const docRef = await addDoc3(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 = query3(this.getTechnologiesRef(), where3("isActive", "==", true));
+    const snapshot = await getDocs3(q);
+    return snapshot.docs.map(
+      (doc9) => ({
+        id: doc9.id,
+        ...doc9.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu familiju
+   * @param family - Familija procedura
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByFamily(family) {
+    const q = query3(
+      this.getTechnologiesRef(),
+      where3("isActive", "==", true),
+      where3("family", "==", family)
+    );
+    const snapshot = await getDocs3(q);
+    return snapshot.docs.map(
+      (doc9) => ({
+        id: doc9.id,
+        ...doc9.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu kategoriju
    * @param categoryId - ID kategorije
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByCategoryId(categoryId) {
+    const q = query3(
+      this.getTechnologiesRef(),
+      where3("isActive", "==", true),
+      where3("categoryId", "==", categoryId)
+    );
+    const snapshot = await getDocs3(q);
+    return snapshot.docs.map(
+      (doc9) => ({
+        id: doc9.id,
+        ...doc9.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 = query3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      where3("isActive", "==", true)
+      this.getTechnologiesRef(),
+      where3("isActive", "==", true),
+      where3("subcategoryId", "==", subcategoryId)
     );
     const snapshot = await getDocs3(q);
     return snapshot.docs.map(
@@ -817,47 +856,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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async getById(technologyId) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     const docSnap = await getDoc3(docRef);
     if (!docSnap.exists()) return null;
     return {
@@ -867,58 +894,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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addRequirement(technologyId, requirement) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await updateDoc3(docRef, {
       [requirementType]: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeRequirement(technologyId, requirement) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await updateDoc3(docRef, {
       [requirementType]: 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];
@@ -927,220 +938,231 @@ 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addBlockingCondition(technologyId, condition) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       blockingConditions: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeBlockingCondition(technologyId, condition) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       blockingConditions: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addContraindication(technologyId, contraindication) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       contraindications: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeContraindication(technologyId, contraindication) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       contraindications: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async addBenefit(technologyId, benefit) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       benefits: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async removeBenefit(technologyId, benefit) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(docRef, {
       benefits: 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 = doc3(
-      this.getTechnologiesRef(categoryId, subcategoryId),
-      technologyId
-    );
+  async updateCertificationRequirement(technologyId, certificationRequirement) {
+    const docRef = doc3(this.getTechnologiesRef(), technologyId);
     await updateDoc3(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/requirement.service.ts