@blackcode_sa/metaestetics-api 1.5.9 → 1.5.11

package/dist/index.d.ts

@@ -1684,12 +1684,14 @@ interface Subcategory {
 
 /**
  * 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
@@ -1709,6 +1711,10 @@ interface Technology {
     name: string;
     /** 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;
     /** Tehnički detalji i specifikacije */
@@ -3567,20 +3573,23 @@ declare class SubcategoryService extends BaseService {
 
 /**
  * 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"
@@ -3588,19 +3597,15 @@ declare class SubcategoryService extends BaseService {
  */
 declare 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;
     /**
-     * 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
      */
-    create(categoryId: string, subcategoryId: string, technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
+    create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
         isActive: boolean;
         updatedAt: Date;
         blockingConditions: BlockingCondition[];
@@ -3617,171 +3622,202 @@ declare class TechnologyService extends BaseService {
         documentationTemplates?: DocumentTemplate[] | undefined;
         benefits: TreatmentBenefit[];
         certificationRequirement: CertificationRequirement;
+        family: ProcedureFamily;
+        categoryId: string;
         id: string;
     }>;
     /**
-     * Vraća sve aktivne tehnologije za određenu podkategoriju
+     * Vraća sve aktivne tehnologije
+     * @returns Lista aktivnih tehnologija
+     */
+    getAll(): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu familiju
+     * @param family - Familija procedura
+     * @returns Lista aktivnih tehnologija
+     */
+    getAllByFamily(family: ProcedureFamily): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu kategoriju
      * @param categoryId - ID kategorije
+     * @returns Lista aktivnih tehnologija
+     */
+    getAllByCategoryId(categoryId: string): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu podkategoriju
      * @param subcategoryId - ID podkategorije
      * @returns Lista aktivnih tehnologija
      */
-    getAllBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
+    getAllBySubcategoryId(subcategoryId: string): Promise<Technology[]>;
     /**
      * 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
      */
-    update(categoryId: string, subcategoryId: string, technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "subcategoryId">>): Promise<Technology | null>;
+    update(technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "family" | "categoryId" | "subcategoryId">>): Promise<Technology | null>;
     /**
      * Soft delete tehnologije (postavlja isActive na false)
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije koja se briše
      */
-    delete(categoryId: string, subcategoryId: string, technologyId: string): Promise<void>;
+    delete(technologyId: string): Promise<void>;
     /**
      * 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
      */
-    getById(categoryId: string, subcategoryId: string, technologyId: string): Promise<Technology | null>;
+    getById(technologyId: string): Promise<Technology | null>;
     /**
      * 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
      */
-    addRequirement(categoryId: string, subcategoryId: string, technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
     /**
      * 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
      */
-    removeRequirement(categoryId: string, subcategoryId: string, technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
     /**
      * 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
      */
-    getRequirements(categoryId: string, subcategoryId: string, technologyId: string, type?: RequirementType): Promise<Requirement[]>;
+    getRequirements(technologyId: string, type?: RequirementType): Promise<Requirement[]>;
     /**
      * 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
      */
-    updateRequirement(categoryId: string, subcategoryId: string, technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
+    updateRequirement(technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
     /**
      * 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
      */
-    addBlockingCondition(categoryId: string, subcategoryId: string, technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    addBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
     /**
      * 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
      */
-    removeBlockingCondition(categoryId: string, subcategoryId: string, technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    removeBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
     /**
      * 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
      */
-    addContraindication(categoryId: string, subcategoryId: string, technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    addContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
     /**
      * 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
      */
-    removeContraindication(categoryId: string, subcategoryId: string, technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    removeContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
     /**
      * 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
      */
-    addBenefit(categoryId: string, subcategoryId: string, technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    addBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
     /**
      * 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
      */
-    removeBenefit(categoryId: string, subcategoryId: string, technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    removeBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
     /**
      * 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
      */
-    getBlockingConditions(categoryId: string, subcategoryId: string, technologyId: string): Promise<BlockingCondition[]>;
+    getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
     /**
      * Vraća sve kontraindikacije za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Lista kontraindikacija
      */
-    getContraindications(categoryId: string, subcategoryId: string, technologyId: string): Promise<Contraindication[]>;
+    getContraindications(technologyId: string): Promise<Contraindication[]>;
     /**
      * Vraća sve benefite za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Lista benefita
      */
-    getBenefits(categoryId: string, subcategoryId: string, technologyId: string): Promise<TreatmentBenefit[]>;
+    getBenefits(technologyId: string): Promise<TreatmentBenefit[]>;
     /**
      * 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
      */
-    updateCertificationRequirement(categoryId: string, subcategoryId: string, technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
+    updateCertificationRequirement(technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
     /**
      * 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
      */
-    getCertificationRequirement(categoryId: string, subcategoryId: string, technologyId: string): Promise<CertificationRequirement | null>;
+    getCertificationRequirement(technologyId: string): Promise<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;
+    /**
+     * 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"]
+     */
+    getAllowedTechnologies(practitioner: Practitioner): Promise<{
+        technologies: Technology[];
+        families: ProcedureFamily[];
+        categories: string[];
+        subcategories: string[];
+    }>;
 }
 
 declare class BrandService extends BaseService {
@@ -4818,7 +4854,11 @@ interface UpdateProcedureData {
 declare const PROCEDURES_COLLECTION = "procedures";
 
 declare class ProcedureService extends BaseService {
-    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
+    private categoryService;
+    private subcategoryService;
+    private technologyService;
+    private productService;
+    constructor(db: Firestore, auth: Auth, app: FirebaseApp, categoryService: CategoryService, subcategoryService: SubcategoryService, technologyService: TechnologyService, productService: ProductService);
     /**
      * Creates a new procedure
      * @param data - The data for creating a new procedure
@@ -4856,25 +4896,32 @@ declare class ProcedureService extends BaseService {
      */
     deactivateProcedure(id: string): Promise<void>;
     /**
-     * Gets a category by ID
-     * @private
-     */
-    private getCategory;
-    /**
-     * Gets a subcategory by ID
-     * @private
-     */
-    private getSubcategory;
-    /**
-     * Gets a technology by ID
-     * @private
-     */
-    private getTechnology;
-    /**
-     * Gets a product by ID
-     * @private
-     */
-    private getProduct;
+     * 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"]
+     */
+    getAllowedProcedures(practitioner: Practitioner): Promise<{
+        procedures: Procedure[];
+        families: ProcedureFamily[];
+        categories: string[];
+        subcategories: string[];
+    }>;
 }
 
 /**