@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

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

@@ -1,1070 +1,1070 @@
-import {
-  addDoc,
-  collection,
-  doc,
-  DocumentData,
-  getCountFromServer,
-  getDoc,
-  getDocs,
-  limit,
-  orderBy,
-  query,
-  startAfter,
-  updateDoc,
-  where,
-  arrayUnion,
-  arrayRemove,
-  Firestore,
-  writeBatch,
-  QueryConstraint,
-} from 'firebase/firestore';
-import { Technology, TECHNOLOGIES_COLLECTION, ITechnologyService } from '../types/technology.types';
-import { Requirement, RequirementType } from '../types/requirement.types';
-import { BlockingCondition } from '../types/static/blocking-condition.types';
-import { ContraindicationDynamic } from '../types/admin-constants.types';
-import { TreatmentBenefitDynamic } from '../types/admin-constants.types';
-import {
-  CertificationLevel,
-  CertificationSpecialty,
-  CertificationRequirement,
-} from '../types/static/certification.types';
-import { BaseService } from '../../services/base.service';
-import { ProcedureFamily } from '../types/static/procedure-family.types';
-import { Practitioner, PractitionerCertification } from '../../types/practitioner';
-import { Product, PRODUCTS_COLLECTION } from '../types/product.types';
-
-/**
- * Default vrednosti za sertifikaciju
- */
-const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
-  minimumLevel: CertificationLevel.AESTHETICIAN,
-  requiredSpecialties: [],
-};
-
-/**
- * Service for managing technologies.
- */
-export class TechnologyService extends BaseService implements ITechnologyService {
-  /**
-   * Reference to the Firestore collection of technologies.
-   */
-  private get technologiesRef() {
-    return collection(this.db, TECHNOLOGIES_COLLECTION);
-  }
-
-  /**
-   * Creates a new technology.
-   * @param technology - Data for the new technology.
-   * @returns The created technology with its generated ID.
-   */
-  async create(technology: Omit<Technology, 'id' | 'createdAt' | 'updatedAt'>) {
-    const now = new Date();
-    // Explicitly construct the object to ensure no undefined values are passed.
-    const newTechnology: Omit<Technology, 'id'> = {
-      name: technology.name,
-      description: technology.description,
-      family: technology.family,
-      categoryId: technology.categoryId,
-      subcategoryId: technology.subcategoryId,
-      requirements: technology.requirements || { pre: [], post: [] },
-      blockingConditions: technology.blockingConditions || [],
-      contraindications: technology.contraindications || [],
-      benefits: technology.benefits || [],
-      certificationRequirement:
-        technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT,
-      documentationTemplates: technology.documentationTemplates || [],
-      isActive: true,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    // Add optional fields only if they are not undefined
-    if (technology.technicalDetails) {
-      newTechnology.technicalDetails = technology.technicalDetails;
-    }
-
-    const docRef = await addDoc(this.technologiesRef, newTechnology as any);
-    return { id: docRef.id, ...newTechnology };
-  }
-
-  /**
-   * Returns counts of technologies for each subcategory.
-   * @param active - Whether to count active or inactive technologies.
-   * @returns A record mapping subcategory ID to technology count.
-   */
-  async getTechnologyCounts(active = true) {
-    const q = query(this.technologiesRef, where('isActive', '==', active));
-    const snapshot = await getDocs(q);
-    const counts: Record<string, number> = {};
-    snapshot.docs.forEach(doc => {
-      const tech = doc.data() as Technology;
-      counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
-    });
-    return counts;
-  }
-
-  /**
-   * Returns counts of technologies for each category.
-   * @param active - Whether to count active or inactive technologies.
-   * @returns A record mapping category ID to technology count.
-   */
-  async getTechnologyCountsByCategory(active = true) {
-    const q = query(this.technologiesRef, where('isActive', '==', active));
-    const snapshot = await getDocs(q);
-    const counts: Record<string, number> = {};
-    snapshot.docs.forEach(doc => {
-      const tech = doc.data() as Technology;
-      counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
-    });
-    return counts;
-  }
-
-  /**
-   * Returns all technologies with pagination.
-   * @param options - Pagination and filter options.
-   * @returns A list of technologies and the last visible document.
-   */
-  async getAll(
-    options: {
-      active?: boolean;
-      limit?: number;
-      lastVisible?: DocumentData;
-    } = {},
-  ) {
-    const { active = true, limit: queryLimit = 10, lastVisible } = options;
-    const constraints = [
-      where('isActive', '==', active),
-      orderBy('name'),
-      queryLimit ? limit(queryLimit) : undefined,
-      lastVisible ? startAfter(lastVisible) : undefined,
-    ].filter((c): c is NonNullable<typeof c> => !!c);
-
-    const q = query(this.technologiesRef, ...constraints);
-    const snapshot = await getDocs(q);
-    const technologies = snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
-  }
-
-  /**
-   * Returns all technologies for a specific category with pagination.
-   * @param categoryId - The ID of the category.
-   * @param options - Pagination options.
-   * @returns A list of technologies for the specified category.
-   */
-  async getAllByCategoryId(
-    categoryId: string,
-    options: {
-      active?: boolean;
-      limit?: number;
-      lastVisible?: DocumentData;
-    } = {},
-  ) {
-    const { active = true, limit: queryLimit = 10, lastVisible } = options;
-    const constraints = [
-      where('categoryId', '==', categoryId),
-      where('isActive', '==', active),
-      orderBy('name'),
-      queryLimit ? limit(queryLimit) : undefined,
-      lastVisible ? startAfter(lastVisible) : undefined,
-    ].filter((c): c is NonNullable<typeof c> => !!c);
-
-    const q = query(this.technologiesRef, ...constraints);
-    const snapshot = await getDocs(q);
-    const technologies = snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
-  }
-
-  /**
-   * Returns all technologies for a specific subcategory with pagination.
-   * @param subcategoryId - The ID of the subcategory.
-   * @param options - Pagination options.
-   * @returns A list of technologies for the specified subcategory.
-   */
-  async getAllBySubcategoryId(
-    subcategoryId: string,
-    options: {
-      active?: boolean;
-      limit?: number;
-      lastVisible?: DocumentData;
-    } = {},
-  ) {
-    const { active = true, limit: queryLimit = 10, lastVisible } = options;
-    const constraints = [
-      where('subcategoryId', '==', subcategoryId),
-      where('isActive', '==', active),
-      orderBy('name'),
-      queryLimit ? limit(queryLimit) : undefined,
-      lastVisible ? startAfter(lastVisible) : undefined,
-    ].filter((c): c is NonNullable<typeof c> => !!c);
-
-    const q = query(this.technologiesRef, ...constraints);
-    const snapshot = await getDocs(q);
-    const technologies = snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
-  }
-
-  /**
-   * Updates an existing technology.
-   * @param id - The ID of the technology to update.
-   * @param technology - New data for the technology.
-   * @returns The updated technology.
-   */
-  async update(id: string, technology: Partial<Omit<Technology, 'id' | 'createdAt'>>) {
-    const updateData: { [key: string]: any } = { ...technology };
-
-    // Remove undefined fields to prevent Firestore errors
-    Object.keys(updateData).forEach(key => {
-      if (updateData[key] === undefined) {
-        delete updateData[key];
-      }
-    });
-
-    updateData.updatedAt = new Date();
-
-    const docRef = doc(this.technologiesRef, id);
-    
-    // Get the technology before update to check what changed
-    const beforeTech = await this.getById(id);
-    
-    await updateDoc(docRef, updateData);
-    
-    // If categoryId, subcategoryId, or name changed, update all products in subcollection
-    const categoryChanged = beforeTech && updateData.categoryId && beforeTech.categoryId !== updateData.categoryId;
-    const subcategoryChanged = beforeTech && updateData.subcategoryId && beforeTech.subcategoryId !== updateData.subcategoryId;
-    const nameChanged = beforeTech && updateData.name && beforeTech.name !== updateData.name;
-    
-    if (categoryChanged || subcategoryChanged || nameChanged) {
-      await this.updateProductsInSubcollection(id, {
-        categoryId: updateData.categoryId,
-        subcategoryId: updateData.subcategoryId,
-        technologyName: updateData.name,
-      });
-    }
-    
-    return this.getById(id);
-  }
-
-  /**
-   * Soft deletes a technology.
-   * @param id - The ID of the technology to delete.
-   */
-  async delete(id: string) {
-    await this.update(id, { isActive: false });
-  }
-
-  /**
-   * Reactivates a technology.
-   * @param id - The ID of the technology to reactivate.
-   */
-  async reactivate(id: string) {
-    await this.update(id, { isActive: true });
-  }
-
-  /**
-   * Returns a technology by its ID.
-   * @param id - The ID of the requested technology.
-   * @returns The technology or null if it doesn't exist.
-   */
-  async getById(id: string): Promise<Technology | null> {
-    const docRef = doc(this.technologiesRef, id);
-    const docSnap = await getDoc(docRef);
-    if (!docSnap.exists()) return null;
-    return {
-      id: docSnap.id,
-      ...docSnap.data(),
-    } as Technology;
-  }
-
-  /**
-   * Dodaje novi zahtev tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param requirement - Zahtev koji se dodaje
-   * @returns Ažurirana tehnologija sa novim zahtevom
-   */
-  async addRequirement(technologyId: string, requirement: Requirement) {
-    const docRef = doc(this.technologiesRef, technologyId);
-
-    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
-
-    await updateDoc(docRef, {
-      [requirementType]: arrayUnion(requirement),
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Uklanja zahtev iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param requirement - Zahtev koji se uklanja
-   * @returns Ažurirana tehnologija bez uklonjenog zahteva
-   */
-  async removeRequirement(technologyId: string, requirement: Requirement) {
-    const docRef = doc(this.technologiesRef, technologyId);
-
-    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
-
-    await updateDoc(docRef, {
-      [requirementType]: arrayRemove(requirement),
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Vraća sve zahteve za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param type - Opcioni filter za tip zahteva (pre/post)
-   * @returns Lista zahteva
-   */
-  async getRequirements(technologyId: string, type?: RequirementType) {
-    const technology = await this.getById(technologyId);
-    if (!technology || !technology.requirements) return [];
-
-    if (type) {
-      return technology.requirements[type];
-    }
-
-    return [...technology.requirements.pre, ...technology.requirements.post];
-  }
-
-  /**
-   * Ažurira postojeći zahtev
-   * @param technologyId - ID tehnologije
-   * @param oldRequirement - Stari zahtev koji se menja
-   * @param newRequirement - Novi zahtev koji zamenjuje stari
-   * @returns Ažurirana tehnologija
-   */
-  async updateRequirement(
-    technologyId: string,
-    oldRequirement: Requirement,
-    newRequirement: Requirement,
-  ) {
-    await this.removeRequirement(technologyId, oldRequirement);
-    return this.addRequirement(technologyId, newRequirement);
-  }
-
-  /**
-   * Dodaje blokirajući uslov tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param condition - Blokirajući uslov koji se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addBlockingCondition(technologyId: string, condition: BlockingCondition) {
-    const docRef = doc(this.technologiesRef, technologyId);
-
-    await updateDoc(docRef, {
-      blockingConditions: arrayUnion(condition),
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Uklanja blokirajući uslov iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param condition - Blokirajući uslov koji se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeBlockingCondition(technologyId: string, condition: BlockingCondition) {
-    const docRef = doc(this.technologiesRef, technologyId);
-
-    await updateDoc(docRef, {
-      blockingConditions: arrayRemove(condition),
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Dodaje kontraindikaciju tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param contraindication - Kontraindikacija koja se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const existingContraindications = technology.contraindications || [];
-    if (existingContraindications.some(c => c.id === contraindication.id)) {
-      return technology; // Already exists, do nothing
-    }
-
-    await updateDoc(docRef, {
-      contraindications: [...existingContraindications, contraindication],
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Uklanja kontraindikaciju iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param contraindication - Kontraindikacija koja se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const updatedContraindications = (technology.contraindications || []).filter(
-      c => c.id !== contraindication.id,
-    );
-
-    await updateDoc(docRef, {
-      contraindications: updatedContraindications,
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Updates an existing contraindication in a technology's list.
-   * If the contraindication does not exist, it will not be added.
-   * @param technologyId - ID of the technology
-   * @param contraindication - The updated contraindication object
-   * @returns The updated technology
-   */
-  async updateContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const contraindications = technology.contraindications || [];
-    const index = contraindications.findIndex(c => c.id === contraindication.id);
-
-    if (index === -1) {
-      // If contraindication doesn't exist, do not update
-      // Consider throwing an error if this is an unexpected state
-      console.warn(
-        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`,
-      );
-      return technology;
-    }
-
-    const updatedContraindications = [...contraindications];
-    updatedContraindications[index] = contraindication;
-
-    await updateDoc(docRef, {
-      contraindications: updatedContraindications,
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Dodaje benefit tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param benefit - Benefit koji se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const existingBenefits = technology.benefits || [];
-    if (existingBenefits.some(b => b.id === benefit.id)) {
-      return technology; // Already exists, do nothing
-    }
-
-    await updateDoc(docRef, {
-      benefits: [...existingBenefits, benefit],
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Uklanja benefit iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param benefit - Benefit koji se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const updatedBenefits = (technology.benefits || []).filter(b => b.id !== benefit.id);
-
-    await updateDoc(docRef, {
-      benefits: updatedBenefits,
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Updates an existing benefit in a technology's list.
-   * If the benefit does not exist, it will not be added.
-   * @param technologyId - ID of the technology
-   * @param benefit - The updated benefit object
-   * @returns The updated technology
-   */
-  async updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
-    const docRef = doc(this.technologiesRef, technologyId);
-    const technology = await this.getById(technologyId);
-    if (!technology) {
-      throw new Error(`Technology with id ${technologyId} not found`);
-    }
-
-    const benefits = technology.benefits || [];
-    const index = benefits.findIndex(b => b.id === benefit.id);
-
-    if (index === -1) {
-      // If benefit doesn't exist, do not update
-      console.warn(
-        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`,
-      );
-      return technology;
-    }
-
-    const updatedBenefits = [...benefits];
-    updatedBenefits[index] = benefit;
-
-    await updateDoc(docRef, {
-      benefits: updatedBenefits,
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Vraća sve blokirajuće uslove za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista blokirajućih uslova
-   */
-  async getBlockingConditions(technologyId: string) {
-    const technology = await this.getById(technologyId);
-    return technology?.blockingConditions || [];
-  }
-
-  /**
-   * Vraća sve kontraindikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista kontraindikacija
-   */
-  async getContraindications(technologyId: string) {
-    const technology = await this.getById(technologyId);
-    return technology?.contraindications || [];
-  }
-
-  /**
-   * Vraća sve benefite za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista benefita
-   */
-  async getBenefits(technologyId: string) {
-    const technology = await this.getById(technologyId);
-    return technology?.benefits || [];
-  }
-
-  /**
-   * Ažurira zahteve sertifikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param certificationRequirement - Novi zahtevi sertifikacije
-   * @returns Ažurirana tehnologija
-   */
-  async updateCertificationRequirement(
-    technologyId: string,
-    certificationRequirement: CertificationRequirement,
-  ) {
-    const docRef = doc(this.technologiesRef, technologyId);
-
-    await updateDoc(docRef, {
-      certificationRequirement,
-      updatedAt: new Date(),
-    });
-
-    return this.getById(technologyId);
-  }
-
-  /**
-   * Vraća zahteve sertifikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
-   */
-  async getCertificationRequirement(
-    technologyId: string,
-  ): Promise<CertificationRequirement | null> {
-    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.getAllForFilter();
-
-    // 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,
-    };
-  }
-
-  /**
-   * Gets all active technologies for a subcategory for filter dropdowns (by subcategory only).
-   * @param subcategoryId - The ID of the subcategory.
-   */
-  async getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]> {
-    const q = query(
-      collection(this.db, TECHNOLOGIES_COLLECTION),
-      where('isActive', '==', true),
-      where('subcategoryId', '==', subcategoryId),
-      orderBy('name'),
-    );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-  }
-
-  /**
-   * Gets all active technologies for a subcategory for filter dropdowns.
-   * @param categoryId - The ID of the parent category.
-   * @param subcategoryId - The ID of the subcategory.
-   */
-  async getAllForFilterBySubcategoryId(
-    categoryId: string,
-    subcategoryId: string,
-  ): Promise<Technology[]> {
-    const q = query(
-      collection(this.db, TECHNOLOGIES_COLLECTION),
-      where('isActive', '==', true),
-      where('categoryId', '==', categoryId),
-      where('subcategoryId', '==', subcategoryId),
-      orderBy('name'),
-    );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-  }
-
-  /**
-   * Gets all active technologies for filter dropdowns.
-   */
-  async getAllForFilter(): Promise<Technology[]> {
-    const q = query(
-      collection(this.db, TECHNOLOGIES_COLLECTION),
-      where('isActive', '==', true),
-      orderBy('name'),
-    );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology),
-    );
-  }
-
-  // ==========================================
-  // NEW METHODS: Product assignment management
-  // ==========================================
-
-  /**
-   * Assigns multiple products to a technology
-   * Updates each product's assignedTechnologyIds array
-   */
-  async assignProducts(technologyId: string, productIds: string[]): Promise<void> {
-    const batch = writeBatch(this.db);
-    
-    for (const productId of productIds) {
-      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
-      batch.update(productRef, {
-        assignedTechnologyIds: arrayUnion(technologyId),
-        updatedAt: new Date(),
-      });
-    }
-    
-    await batch.commit();
-    // Cloud Function will handle syncing to subcollections
-  }
-
-  /**
-   * Unassigns multiple products from a technology
-   * Updates each product's assignedTechnologyIds array
-   */
-  async unassignProducts(technologyId: string, productIds: string[]): Promise<void> {
-    const batch = writeBatch(this.db);
-    
-    for (const productId of productIds) {
-      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
-      batch.update(productRef, {
-        assignedTechnologyIds: arrayRemove(technologyId),
-        updatedAt: new Date(),
-      });
-    }
-    
-    await batch.commit();
-    // Cloud Function will handle removing from subcollections
-  }
-
-  /**
-   * Gets products assigned to a specific technology
-   * Reads from top-level collection for immediate consistency (Cloud Functions may lag)
-   */
-  async getAssignedProducts(technologyId: string): Promise<Product[]> {
-    const q = query(
-      collection(this.db, PRODUCTS_COLLECTION),
-      where('assignedTechnologyIds', 'array-contains', technologyId),
-      where('isActive', '==', true),
-      orderBy('name'),
-    );
-    const snapshot = await getDocs(q);
-    
-    return snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Product),
-    );
-  }
-
-  /**
-   * Gets products NOT assigned to a specific technology
-   */
-  async getUnassignedProducts(technologyId: string): Promise<Product[]> {
-    const q = query(
-      collection(this.db, PRODUCTS_COLLECTION),
-      where('isActive', '==', true),
-      orderBy('name'),
-    );
-    const snapshot = await getDocs(q);
-    
-    const allProducts = snapshot.docs.map(
-      doc =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Product),
-    );
-    
-    // Filter out products already assigned to this technology
-    return allProducts.filter(product => 
-      !product.assignedTechnologyIds?.includes(technologyId)
-    );
-  }
-
-  /**
-   * Gets product assignment statistics for a technology
-   */
-  async getProductStats(technologyId: string): Promise<{
-    totalAssigned: number;
-    byBrand: Record<string, number>;
-  }> {
-    const products = await this.getAssignedProducts(technologyId);
-    
-    const byBrand: Record<string, number> = {};
-    products.forEach(product => {
-      byBrand[product.brandName] = (byBrand[product.brandName] || 0) + 1;
-    });
-    
-    return {
-      totalAssigned: products.length,
-      byBrand,
-    };
-  }
-
-  /**
-   * Updates products in technology subcollection when technology metadata changes
-   * @param technologyId - ID of the technology
-   * @param updates - Fields to update (categoryId, subcategoryId, technologyName)
-   */
-  private async updateProductsInSubcollection(
-    technologyId: string,
-    updates: { categoryId?: string; subcategoryId?: string; technologyName?: string }
-  ): Promise<void> {
-    const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
-    const productsSnapshot = await getDocs(productsRef);
-    
-    if (productsSnapshot.empty) {
-      return;
-    }
-    
-    const batch = writeBatch(this.db);
-    
-    for (const productDoc of productsSnapshot.docs) {
-      const productRef = productDoc.ref;
-      const updateFields: any = {};
-      
-      if (updates.categoryId !== undefined) {
-        updateFields.categoryId = updates.categoryId;
-      }
-      if (updates.subcategoryId !== undefined) {
-        updateFields.subcategoryId = updates.subcategoryId;
-      }
-      if (updates.technologyName !== undefined) {
-        updateFields.technologyName = updates.technologyName;
-      }
-      
-      if (Object.keys(updateFields).length > 0) {
-        batch.update(productRef, updateFields);
-      }
-    }
-    
-    await batch.commit();
-  }
-
-  /**
-   * Exports technologies to CSV string, suitable for Excel/Sheets.
-   * Includes headers and optional UTF-8 BOM.
-   * By default exports only active technologies (set includeInactive to true to export all).
-   * Includes product names from subcollections.
-   */
-  async exportToCsv(options?: {
-    includeInactive?: boolean;
-    includeBom?: boolean;
-  }): Promise<string> {
-    const includeInactive = options?.includeInactive ?? false;
-    const includeBom = options?.includeBom ?? true;
-
-    const headers = [
-      "id",
-      "name",
-      "description",
-      "family",
-      "categoryId",
-      "subcategoryId",
-      "technicalDetails",
-      "requirements_pre",
-      "requirements_post",
-      "blockingConditions",
-      "contraindications",
-      "benefits",
-      "certificationMinimumLevel",
-      "certificationRequiredSpecialties",
-      "documentationTemplateIds",
-      "productNames",
-      "isActive",
-    ];
-
-    const rows: string[] = [];
-    rows.push(headers.map((h) => this.formatCsvValue(h)).join(","));
-
-    const PAGE_SIZE = 1000;
-    let cursor: any | undefined;
-
-    // Build base constraints
-    const constraints: QueryConstraint[] = [];
-    if (!includeInactive) {
-      constraints.push(where("isActive", "==", true));
-    }
-    constraints.push(orderBy("name"));
-
-    // Page through all results
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const queryConstraints: QueryConstraint[] = [...constraints, limit(PAGE_SIZE)];
-      if (cursor) queryConstraints.push(startAfter(cursor));
-
-      const q = query(this.technologiesRef, ...queryConstraints);
-      const snapshot = await getDocs(q);
-      if (snapshot.empty) break;
-
-      for (const d of snapshot.docs) {
-        const technology = ({ id: d.id, ...d.data() } as unknown) as Technology;
-        // Fetch products for this technology
-        const productNames = await this.getProductNamesForTechnology(technology.id!);
-        rows.push(this.technologyToCsvRow(technology, productNames));
-      }
-
-      cursor = snapshot.docs[snapshot.docs.length - 1];
-      if (snapshot.size < PAGE_SIZE) break;
-    }
-
-    const csvBody = rows.join("\r\n");
-    return includeBom ? "\uFEFF" + csvBody : csvBody;
-  }
-
-  /**
-   * Gets product names from the technology's product subcollection
-   */
-  private async getProductNamesForTechnology(technologyId: string): Promise<string[]> {
-    try {
-      const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
-      const q = query(productsRef, where("isActive", "==", true));
-      const snapshot = await getDocs(q);
-      return snapshot.docs.map(doc => {
-        const product = doc.data() as Product;
-        return product.name || "";
-      }).filter(name => name); // Filter out empty names
-    } catch (error) {
-      console.error(`Error fetching products for technology ${technologyId}:`, error);
-      return [];
-    }
-  }
-
-  private technologyToCsvRow(technology: Technology, productNames: string[] = []): string {
-    const values = [
-      technology.id ?? "",
-      technology.name ?? "",
-      technology.description ?? "",
-      technology.family ?? "",
-      technology.categoryId ?? "",
-      technology.subcategoryId ?? "",
-      technology.technicalDetails ?? "",
-      technology.requirements?.pre?.map(r => r.name).join(";") ?? "",
-      technology.requirements?.post?.map(r => r.name).join(";") ?? "",
-      technology.blockingConditions?.join(";") ?? "",
-      technology.contraindications?.map(c => c.name).join(";") ?? "",
-      technology.benefits?.map(b => b.name).join(";") ?? "",
-      technology.certificationRequirement?.minimumLevel ?? "",
-      technology.certificationRequirement?.requiredSpecialties?.join(";") ?? "",
-      technology.documentationTemplates?.map(t => t.templateId).join(";") ?? "",
-      productNames.join(";"),
-      String(technology.isActive ?? ""),
-    ];
-    return values.map((v) => this.formatCsvValue(v)).join(",");
-  }
-
-  private formatCsvValue(value: any): string {
-    const str = value === null || value === undefined ? "" : String(value);
-    // Escape double quotes by doubling them and wrap in quotes
-    const escaped = str.replace(/"/g, '""');
-    return `"${escaped}"`;
-  }
-}
+import {
+  addDoc,
+  collection,
+  doc,
+  DocumentData,
+  getCountFromServer,
+  getDoc,
+  getDocs,
+  limit,
+  orderBy,
+  query,
+  startAfter,
+  updateDoc,
+  where,
+  arrayUnion,
+  arrayRemove,
+  Firestore,
+  writeBatch,
+  QueryConstraint,
+} from 'firebase/firestore';
+import { Technology, TECHNOLOGIES_COLLECTION, ITechnologyService } from '../types/technology.types';
+import { Requirement, RequirementType } from '../types/requirement.types';
+import { BlockingCondition } from '../types/static/blocking-condition.types';
+import { ContraindicationDynamic } from '../types/admin-constants.types';
+import { TreatmentBenefitDynamic } from '../types/admin-constants.types';
+import {
+  CertificationLevel,
+  CertificationSpecialty,
+  CertificationRequirement,
+} from '../types/static/certification.types';
+import { BaseService } from '../../services/base.service';
+import { ProcedureFamily } from '../types/static/procedure-family.types';
+import { Practitioner, PractitionerCertification } from '../../types/practitioner';
+import { Product, PRODUCTS_COLLECTION } from '../types/product.types';
+
+/**
+ * Default vrednosti za sertifikaciju
+ */
+const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
+  minimumLevel: CertificationLevel.AESTHETICIAN,
+  requiredSpecialties: [],
+};
+
+/**
+ * Service for managing technologies.
+ */
+export class TechnologyService extends BaseService implements ITechnologyService {
+  /**
+   * Reference to the Firestore collection of technologies.
+   */
+  private get technologiesRef() {
+    return collection(this.db, TECHNOLOGIES_COLLECTION);
+  }
+
+  /**
+   * Creates a new technology.
+   * @param technology - Data for the new technology.
+   * @returns The created technology with its generated ID.
+   */
+  async create(technology: Omit<Technology, 'id' | 'createdAt' | 'updatedAt'>) {
+    const now = new Date();
+    // Explicitly construct the object to ensure no undefined values are passed.
+    const newTechnology: Omit<Technology, 'id'> = {
+      name: technology.name,
+      description: technology.description,
+      family: technology.family,
+      categoryId: technology.categoryId,
+      subcategoryId: technology.subcategoryId,
+      requirements: technology.requirements || { pre: [], post: [] },
+      blockingConditions: technology.blockingConditions || [],
+      contraindications: technology.contraindications || [],
+      benefits: technology.benefits || [],
+      certificationRequirement:
+        technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    // Add optional fields only if they are not undefined
+    if (technology.technicalDetails) {
+      newTechnology.technicalDetails = technology.technicalDetails;
+    }
+
+    const docRef = await addDoc(this.technologiesRef, newTechnology as any);
+    return { id: docRef.id, ...newTechnology };
+  }
+
+  /**
+   * Returns counts of technologies for each subcategory.
+   * @param active - Whether to count active or inactive technologies.
+   * @returns A record mapping subcategory ID to technology count.
+   */
+  async getTechnologyCounts(active = true) {
+    const q = query(this.technologiesRef, where('isActive', '==', active));
+    const snapshot = await getDocs(q);
+    const counts: Record<string, number> = {};
+    snapshot.docs.forEach(doc => {
+      const tech = doc.data() as Technology;
+      counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
+    });
+    return counts;
+  }
+
+  /**
+   * Returns counts of technologies for each category.
+   * @param active - Whether to count active or inactive technologies.
+   * @returns A record mapping category ID to technology count.
+   */
+  async getTechnologyCountsByCategory(active = true) {
+    const q = query(this.technologiesRef, where('isActive', '==', active));
+    const snapshot = await getDocs(q);
+    const counts: Record<string, number> = {};
+    snapshot.docs.forEach(doc => {
+      const tech = doc.data() as Technology;
+      counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
+    });
+    return counts;
+  }
+
+  /**
+   * Returns all technologies with pagination.
+   * @param options - Pagination and filter options.
+   * @returns A list of technologies and the last visible document.
+   */
+  async getAll(
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {},
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where('isActive', '==', active),
+      orderBy('name'),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
+    const snapshot = await getDocs(q);
+    const technologies = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Returns all technologies for a specific category with pagination.
+   * @param categoryId - The ID of the category.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified category.
+   */
+  async getAllByCategoryId(
+    categoryId: string,
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {},
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where('categoryId', '==', categoryId),
+      where('isActive', '==', active),
+      orderBy('name'),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
+    const snapshot = await getDocs(q);
+    const technologies = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Returns all technologies for a specific subcategory with pagination.
+   * @param subcategoryId - The ID of the subcategory.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified subcategory.
+   */
+  async getAllBySubcategoryId(
+    subcategoryId: string,
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {},
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where('subcategoryId', '==', subcategoryId),
+      where('isActive', '==', active),
+      orderBy('name'),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
+    const snapshot = await getDocs(q);
+    const technologies = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Updates an existing technology.
+   * @param id - The ID of the technology to update.
+   * @param technology - New data for the technology.
+   * @returns The updated technology.
+   */
+  async update(id: string, technology: Partial<Omit<Technology, 'id' | 'createdAt'>>) {
+    const updateData: { [key: string]: any } = { ...technology };
+
+    // Remove undefined fields to prevent Firestore errors
+    Object.keys(updateData).forEach(key => {
+      if (updateData[key] === undefined) {
+        delete updateData[key];
+      }
+    });
+
+    updateData.updatedAt = new Date();
+
+    const docRef = doc(this.technologiesRef, id);
+    
+    // Get the technology before update to check what changed
+    const beforeTech = await this.getById(id);
+    
+    await updateDoc(docRef, updateData);
+    
+    // If categoryId, subcategoryId, or name changed, update all products in subcollection
+    const categoryChanged = beforeTech && updateData.categoryId && beforeTech.categoryId !== updateData.categoryId;
+    const subcategoryChanged = beforeTech && updateData.subcategoryId && beforeTech.subcategoryId !== updateData.subcategoryId;
+    const nameChanged = beforeTech && updateData.name && beforeTech.name !== updateData.name;
+    
+    if (categoryChanged || subcategoryChanged || nameChanged) {
+      await this.updateProductsInSubcollection(id, {
+        categoryId: updateData.categoryId,
+        subcategoryId: updateData.subcategoryId,
+        technologyName: updateData.name,
+      });
+    }
+    
+    return this.getById(id);
+  }
+
+  /**
+   * Soft deletes a technology.
+   * @param id - The ID of the technology to delete.
+   */
+  async delete(id: string) {
+    await this.update(id, { isActive: false });
+  }
+
+  /**
+   * Reactivates a technology.
+   * @param id - The ID of the technology to reactivate.
+   */
+  async reactivate(id: string) {
+    await this.update(id, { isActive: true });
+  }
+
+  /**
+   * Returns a technology by its ID.
+   * @param id - The ID of the requested technology.
+   * @returns The technology or null if it doesn't exist.
+   */
+  async getById(id: string): Promise<Technology | null> {
+    const docRef = doc(this.technologiesRef, id);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data(),
+    } as Technology;
+  }
+
+  /**
+   * Dodaje novi zahtev tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param requirement - Zahtev koji se dodaje
+   * @returns Ažurirana tehnologija sa novim zahtevom
+   */
+  async addRequirement(technologyId: string, requirement: Requirement) {
+    const docRef = doc(this.technologiesRef, technologyId);
+
+    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
+
+    await updateDoc(docRef, {
+      [requirementType]: arrayUnion(requirement),
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Uklanja zahtev iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param requirement - Zahtev koji se uklanja
+   * @returns Ažurirana tehnologija bez uklonjenog zahteva
+   */
+  async removeRequirement(technologyId: string, requirement: Requirement) {
+    const docRef = doc(this.technologiesRef, technologyId);
+
+    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
+
+    await updateDoc(docRef, {
+      [requirementType]: arrayRemove(requirement),
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Vraća sve zahteve za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @param type - Opcioni filter za tip zahteva (pre/post)
+   * @returns Lista zahteva
+   */
+  async getRequirements(technologyId: string, type?: RequirementType) {
+    const technology = await this.getById(technologyId);
+    if (!technology || !technology.requirements) return [];
+
+    if (type) {
+      return technology.requirements[type];
+    }
+
+    return [...technology.requirements.pre, ...technology.requirements.post];
+  }
+
+  /**
+   * Ažurira postojeći zahtev
+   * @param technologyId - ID tehnologije
+   * @param oldRequirement - Stari zahtev koji se menja
+   * @param newRequirement - Novi zahtev koji zamenjuje stari
+   * @returns Ažurirana tehnologija
+   */
+  async updateRequirement(
+    technologyId: string,
+    oldRequirement: Requirement,
+    newRequirement: Requirement,
+  ) {
+    await this.removeRequirement(technologyId, oldRequirement);
+    return this.addRequirement(technologyId, newRequirement);
+  }
+
+  /**
+   * Dodaje blokirajući uslov tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param condition - Blokirajući uslov koji se dodaje
+   * @returns Ažurirana tehnologija
+   */
+  async addBlockingCondition(technologyId: string, condition: BlockingCondition) {
+    const docRef = doc(this.technologiesRef, technologyId);
+
+    await updateDoc(docRef, {
+      blockingConditions: arrayUnion(condition),
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Uklanja blokirajući uslov iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param condition - Blokirajući uslov koji se uklanja
+   * @returns Ažurirana tehnologija
+   */
+  async removeBlockingCondition(technologyId: string, condition: BlockingCondition) {
+    const docRef = doc(this.technologiesRef, technologyId);
+
+    await updateDoc(docRef, {
+      blockingConditions: arrayRemove(condition),
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Dodaje kontraindikaciju tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param contraindication - Kontraindikacija koja se dodaje
+   * @returns Ažurirana tehnologija
+   */
+  async addContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingContraindications = technology.contraindications || [];
+    if (existingContraindications.some(c => c.id === contraindication.id)) {
+      return technology; // Already exists, do nothing
+    }
+
+    await updateDoc(docRef, {
+      contraindications: [...existingContraindications, contraindication],
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Uklanja kontraindikaciju iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param contraindication - Kontraindikacija koja se uklanja
+   * @returns Ažurirana tehnologija
+   */
+  async removeContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedContraindications = (technology.contraindications || []).filter(
+      c => c.id !== contraindication.id,
+    );
+
+    await updateDoc(docRef, {
+      contraindications: updatedContraindications,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing contraindication in a technology's list.
+   * If the contraindication does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param contraindication - The updated contraindication object
+   * @returns The updated technology
+   */
+  async updateContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const contraindications = technology.contraindications || [];
+    const index = contraindications.findIndex(c => c.id === contraindication.id);
+
+    if (index === -1) {
+      // If contraindication doesn't exist, do not update
+      // Consider throwing an error if this is an unexpected state
+      console.warn(
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`,
+      );
+      return technology;
+    }
+
+    const updatedContraindications = [...contraindications];
+    updatedContraindications[index] = contraindication;
+
+    await updateDoc(docRef, {
+      contraindications: updatedContraindications,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Dodaje benefit tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param benefit - Benefit koji se dodaje
+   * @returns Ažurirana tehnologija
+   */
+  async addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingBenefits = technology.benefits || [];
+    if (existingBenefits.some(b => b.id === benefit.id)) {
+      return technology; // Already exists, do nothing
+    }
+
+    await updateDoc(docRef, {
+      benefits: [...existingBenefits, benefit],
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Uklanja benefit iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param benefit - Benefit koji se uklanja
+   * @returns Ažurirana tehnologija
+   */
+  async removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedBenefits = (technology.benefits || []).filter(b => b.id !== benefit.id);
+
+    await updateDoc(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing benefit in a technology's list.
+   * If the benefit does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param benefit - The updated benefit object
+   * @returns The updated technology
+   */
+  async updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const benefits = technology.benefits || [];
+    const index = benefits.findIndex(b => b.id === benefit.id);
+
+    if (index === -1) {
+      // If benefit doesn't exist, do not update
+      console.warn(
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`,
+      );
+      return technology;
+    }
+
+    const updatedBenefits = [...benefits];
+    updatedBenefits[index] = benefit;
+
+    await updateDoc(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Vraća sve blokirajuće uslove za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista blokirajućih uslova
+   */
+  async getBlockingConditions(technologyId: string) {
+    const technology = await this.getById(technologyId);
+    return technology?.blockingConditions || [];
+  }
+
+  /**
+   * Vraća sve kontraindikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista kontraindikacija
+   */
+  async getContraindications(technologyId: string) {
+    const technology = await this.getById(technologyId);
+    return technology?.contraindications || [];
+  }
+
+  /**
+   * Vraća sve benefite za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista benefita
+   */
+  async getBenefits(technologyId: string) {
+    const technology = await this.getById(technologyId);
+    return technology?.benefits || [];
+  }
+
+  /**
+   * Ažurira zahteve sertifikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @param certificationRequirement - Novi zahtevi sertifikacije
+   * @returns Ažurirana tehnologija
+   */
+  async updateCertificationRequirement(
+    technologyId: string,
+    certificationRequirement: CertificationRequirement,
+  ) {
+    const docRef = doc(this.technologiesRef, technologyId);
+
+    await updateDoc(docRef, {
+      certificationRequirement,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Vraća zahteve sertifikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
+   */
+  async getCertificationRequirement(
+    technologyId: string,
+  ): Promise<CertificationRequirement | null> {
+    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.getAllForFilter();
+
+    // 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,
+    };
+  }
+
+  /**
+   * Gets all active technologies for a subcategory for filter dropdowns (by subcategory only).
+   * @param subcategoryId - The ID of the subcategory.
+   */
+  async getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where('isActive', '==', true),
+      where('subcategoryId', '==', subcategoryId),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+  }
+
+  /**
+   * Gets all active technologies for a subcategory for filter dropdowns.
+   * @param categoryId - The ID of the parent category.
+   * @param subcategoryId - The ID of the subcategory.
+   */
+  async getAllForFilterBySubcategoryId(
+    categoryId: string,
+    subcategoryId: string,
+  ): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where('isActive', '==', true),
+      where('categoryId', '==', categoryId),
+      where('subcategoryId', '==', subcategoryId),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+  }
+
+  /**
+   * Gets all active technologies for filter dropdowns.
+   */
+  async getAllForFilter(): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+  }
+
+  // ==========================================
+  // NEW METHODS: Product assignment management
+  // ==========================================
+
+  /**
+   * Assigns multiple products to a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async assignProducts(technologyId: string, productIds: string[]): Promise<void> {
+    const batch = writeBatch(this.db);
+    
+    for (const productId of productIds) {
+      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayUnion(technologyId),
+        updatedAt: new Date(),
+      });
+    }
+    
+    await batch.commit();
+    // Cloud Function will handle syncing to subcollections
+  }
+
+  /**
+   * Unassigns multiple products from a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async unassignProducts(technologyId: string, productIds: string[]): Promise<void> {
+    const batch = writeBatch(this.db);
+    
+    for (const productId of productIds) {
+      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayRemove(technologyId),
+        updatedAt: new Date(),
+      });
+    }
+    
+    await batch.commit();
+    // Cloud Function will handle removing from subcollections
+  }
+
+  /**
+   * Gets products assigned to a specific technology
+   * Reads from top-level collection for immediate consistency (Cloud Functions may lag)
+   */
+  async getAssignedProducts(technologyId: string): Promise<Product[]> {
+    const q = query(
+      collection(this.db, PRODUCTS_COLLECTION),
+      where('assignedTechnologyIds', 'array-contains', technologyId),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+  }
+
+  /**
+   * Gets products NOT assigned to a specific technology
+   */
+  async getUnassignedProducts(technologyId: string): Promise<Product[]> {
+    const q = query(
+      collection(this.db, PRODUCTS_COLLECTION),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    
+    const allProducts = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+    
+    // Filter out products already assigned to this technology
+    return allProducts.filter(product => 
+      !product.assignedTechnologyIds?.includes(technologyId)
+    );
+  }
+
+  /**
+   * Gets product assignment statistics for a technology
+   */
+  async getProductStats(technologyId: string): Promise<{
+    totalAssigned: number;
+    byBrand: Record<string, number>;
+  }> {
+    const products = await this.getAssignedProducts(technologyId);
+    
+    const byBrand: Record<string, number> = {};
+    products.forEach(product => {
+      byBrand[product.brandName] = (byBrand[product.brandName] || 0) + 1;
+    });
+    
+    return {
+      totalAssigned: products.length,
+      byBrand,
+    };
+  }
+
+  /**
+   * Updates products in technology subcollection when technology metadata changes
+   * @param technologyId - ID of the technology
+   * @param updates - Fields to update (categoryId, subcategoryId, technologyName)
+   */
+  private async updateProductsInSubcollection(
+    technologyId: string,
+    updates: { categoryId?: string; subcategoryId?: string; technologyName?: string }
+  ): Promise<void> {
+    const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
+    const productsSnapshot = await getDocs(productsRef);
+    
+    if (productsSnapshot.empty) {
+      return;
+    }
+    
+    const batch = writeBatch(this.db);
+    
+    for (const productDoc of productsSnapshot.docs) {
+      const productRef = productDoc.ref;
+      const updateFields: any = {};
+      
+      if (updates.categoryId !== undefined) {
+        updateFields.categoryId = updates.categoryId;
+      }
+      if (updates.subcategoryId !== undefined) {
+        updateFields.subcategoryId = updates.subcategoryId;
+      }
+      if (updates.technologyName !== undefined) {
+        updateFields.technologyName = updates.technologyName;
+      }
+      
+      if (Object.keys(updateFields).length > 0) {
+        batch.update(productRef, updateFields);
+      }
+    }
+    
+    await batch.commit();
+  }
+
+  /**
+   * Exports technologies to CSV string, suitable for Excel/Sheets.
+   * Includes headers and optional UTF-8 BOM.
+   * By default exports only active technologies (set includeInactive to true to export all).
+   * Includes product names from subcollections.
+   */
+  async exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string> {
+    const includeInactive = options?.includeInactive ?? false;
+    const includeBom = options?.includeBom ?? true;
+
+    const headers = [
+      "id",
+      "name",
+      "description",
+      "family",
+      "categoryId",
+      "subcategoryId",
+      "technicalDetails",
+      "requirements_pre",
+      "requirements_post",
+      "blockingConditions",
+      "contraindications",
+      "benefits",
+      "certificationMinimumLevel",
+      "certificationRequiredSpecialties",
+      "documentationTemplateIds",
+      "productNames",
+      "isActive",
+    ];
+
+    const rows: string[] = [];
+    rows.push(headers.map((h) => this.formatCsvValue(h)).join(","));
+
+    const PAGE_SIZE = 1000;
+    let cursor: any | undefined;
+
+    // Build base constraints
+    const constraints: QueryConstraint[] = [];
+    if (!includeInactive) {
+      constraints.push(where("isActive", "==", true));
+    }
+    constraints.push(orderBy("name"));
+
+    // Page through all results
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const queryConstraints: QueryConstraint[] = [...constraints, limit(PAGE_SIZE)];
+      if (cursor) queryConstraints.push(startAfter(cursor));
+
+      const q = query(this.technologiesRef, ...queryConstraints);
+      const snapshot = await getDocs(q);
+      if (snapshot.empty) break;
+
+      for (const d of snapshot.docs) {
+        const technology = ({ id: d.id, ...d.data() } as unknown) as Technology;
+        // Fetch products for this technology
+        const productNames = await this.getProductNamesForTechnology(technology.id!);
+        rows.push(this.technologyToCsvRow(technology, productNames));
+      }
+
+      cursor = snapshot.docs[snapshot.docs.length - 1];
+      if (snapshot.size < PAGE_SIZE) break;
+    }
+
+    const csvBody = rows.join("\r\n");
+    return includeBom ? "\uFEFF" + csvBody : csvBody;
+  }
+
+  /**
+   * Gets product names from the technology's product subcollection
+   */
+  private async getProductNamesForTechnology(technologyId: string): Promise<string[]> {
+    try {
+      const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
+      const q = query(productsRef, where("isActive", "==", true));
+      const snapshot = await getDocs(q);
+      return snapshot.docs.map(doc => {
+        const product = doc.data() as Product;
+        return product.name || "";
+      }).filter(name => name); // Filter out empty names
+    } catch (error) {
+      console.error(`Error fetching products for technology ${technologyId}:`, error);
+      return [];
+    }
+  }
+
+  private technologyToCsvRow(technology: Technology, productNames: string[] = []): string {
+    const values = [
+      technology.id ?? "",
+      technology.name ?? "",
+      technology.description ?? "",
+      technology.family ?? "",
+      technology.categoryId ?? "",
+      technology.subcategoryId ?? "",
+      technology.technicalDetails ?? "",
+      technology.requirements?.pre?.map(r => r.name).join(";") ?? "",
+      technology.requirements?.post?.map(r => r.name).join(";") ?? "",
+      technology.blockingConditions?.join(";") ?? "",
+      technology.contraindications?.map(c => c.name).join(";") ?? "",
+      technology.benefits?.map(b => b.name).join(";") ?? "",
+      technology.certificationRequirement?.minimumLevel ?? "",
+      technology.certificationRequirement?.requiredSpecialties?.join(";") ?? "",
+      technology.documentationTemplates?.map(t => t.templateId).join(";") ?? "",
+      productNames.join(";"),
+      String(technology.isActive ?? ""),
+    ];
+    return values.map((v) => this.formatCsvValue(v)).join(",");
+  }
+
+  private formatCsvValue(value: any): string {
+    const str = value === null || value === undefined ? "" : String(value);
+    // Escape double quotes by doubling them and wrap in quotes
+    const escaped = str.replace(/"/g, '""');
+    return `"${escaped}"`;
+  }
+}