@blackcode_sa/metaestetics-api 1.11.2 → 1.12.0

package/dist/backoffice/index.mjs

@@ -7,7 +7,11 @@ import {
   getDocs,
   query,
   updateDoc,
-  where
+  where,
+  limit,
+  orderBy,
+  startAfter,
+  getCountFromServer
 } from "firebase/firestore";
 
 // src/backoffice/types/brand.types.ts
@@ -16,11 +20,13 @@ var BRANDS_COLLECTION = "brands";
 // src/services/base.service.ts
 import { getStorage } from "firebase/storage";
 var BaseService = class {
-  constructor(db, auth, app) {
+  constructor(db, auth, app, storage) {
     this.db = db;
     this.auth = auth;
     this.app = app;
-    this.storage = getStorage(app);
+    if (app) {
+      this.storage = storage || getStorage(app);
+    }
   }
   /**
    * Generiše jedinstveni ID za dokumente
@@ -53,6 +59,7 @@ var BrandService = class extends BaseService {
     const now = /* @__PURE__ */ new Date();
     const newBrand = {
       ...brand,
+      name_lowercase: brand.name.toLowerCase(),
       createdAt: now,
       updatedAt: now,
       isActive: true
@@ -61,15 +68,69 @@ var BrandService = class extends BaseService {
     return { id: docRef.id, ...newBrand };
   }
   /**
-   * Gets all active brands
+   * Gets a paginated list of active brands, optionally filtered by name.
+   * @param rowsPerPage - The number of brands to fetch.
+   * @param searchTerm - An optional string to filter brand names by (starts-with search).
+   * @param lastVisible - An optional document snapshot to use as a cursor for pagination.
    */
-  async getAll() {
-    const q = query(this.getBrandsRef(), where("isActive", "==", true));
+  async getAll(rowsPerPage, searchTerm, lastVisible) {
+    const constraints = [
+      where("isActive", "==", true),
+      orderBy("name_lowercase")
+    ];
+    if (searchTerm) {
+      const lowercasedSearchTerm = searchTerm.toLowerCase();
+      constraints.push(where("name_lowercase", ">=", lowercasedSearchTerm));
+      constraints.push(
+        where("name_lowercase", "<=", lowercasedSearchTerm + "\uF8FF")
+      );
+    }
+    if (lastVisible) {
+      constraints.push(startAfter(lastVisible));
+    }
+    constraints.push(limit(rowsPerPage));
+    const q = query(this.getBrandsRef(), ...constraints);
+    const snapshot = await getDocs(q);
+    const brands = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { brands, lastVisible: newLastVisible };
+  }
+  /**
+   * Gets the total count of active brands, optionally filtered by name.
+   * @param searchTerm - An optional string to filter brand names by (starts-with search).
+   */
+  async getBrandsCount(searchTerm) {
+    const constraints = [where("isActive", "==", true)];
+    if (searchTerm) {
+      const lowercasedSearchTerm = searchTerm.toLowerCase();
+      constraints.push(where("name_lowercase", ">=", lowercasedSearchTerm));
+      constraints.push(
+        where("name_lowercase", "<=", lowercasedSearchTerm + "\uF8FF")
+      );
+    }
+    const q = query(this.getBrandsRef(), ...constraints);
+    const snapshot = await getCountFromServer(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Gets all active brands for filter dropdowns (not paginated).
+   */
+  async getAllForFilter() {
+    const q = query(
+      this.getBrandsRef(),
+      where("isActive", "==", true),
+      orderBy("name")
+    );
     const snapshot = await getDocs(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -81,6 +142,9 @@ var BrandService = class extends BaseService {
       ...brand,
       updatedAt: /* @__PURE__ */ new Date()
     };
+    if (brand.name) {
+      updateData.name_lowercase = brand.name.toLowerCase();
+    }
     const docRef = doc(this.getBrandsRef(), brandId);
     await updateDoc(docRef, updateData);
     return this.getById(brandId);
@@ -112,9 +176,13 @@ import {
   addDoc as addDoc2,
   collection as collection2,
   doc as doc2,
+  getCountFromServer as getCountFromServer2,
   getDoc as getDoc2,
   getDocs as getDocs2,
+  limit as limit2,
+  orderBy as orderBy2,
   query as query2,
+  startAfter as startAfter2,
   updateDoc as updateDoc2,
   where as where2
 } from "firebase/firestore";
@@ -122,6 +190,13 @@ import {
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
 
+// src/backoffice/types/static/procedure-family.types.ts
+var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
+  ProcedureFamily2["AESTHETICS"] = "aesthetics";
+  ProcedureFamily2["SURGERY"] = "surgery";
+  return ProcedureFamily2;
+})(ProcedureFamily || {});
+
 // src/backoffice/services/category.service.ts
 var CategoryService = class extends BaseService {
   /**
@@ -147,37 +222,87 @@ var CategoryService = class extends BaseService {
     return { id: docRef.id, ...newCategory };
   }
   /**
-   * Vraća sve aktivne kategorije
-   * @returns Lista aktivnih kategorija
+   * Returns counts of categories for each family.
+   * @param active - Whether to count active or inactive categories.
+   * @returns A record mapping family to category count.
    */
-  async getAll() {
+  async getCategoryCounts(active = true) {
+    const counts = {};
+    const families = Object.values(ProcedureFamily);
+    for (const family of families) {
+      const q = query2(
+        this.categoriesRef,
+        where2("family", "==", family),
+        where2("isActive", "==", active)
+      );
+      const snapshot = await getCountFromServer2(q);
+      counts[family] = snapshot.data().count;
+    }
+    return counts;
+  }
+  /**
+   * Vraća sve kategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih kategorija
+   */
+  async getAllForFilter() {
     const q = query2(this.categoriesRef, where2("isActive", "==", true));
     const snapshot = await getDocs2(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
   /**
-   * Vraća sve aktivne kategorije za određenu familiju procedura
+   * Vraća sve kategorije sa paginacijom
+   * @param options - Pagination and filter options
+   * @returns Lista kategorija i poslednji vidljiv dokument
+   */
+  async getAll(options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where2("isActive", "==", active),
+      orderBy2("name"),
+      queryLimit ? limit2(queryLimit) : void 0,
+      lastVisible ? startAfter2(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query2(this.categoriesRef, ...constraints);
+    const snapshot = await getDocs2(q);
+    const categories = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { categories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve aktivne kategorije za određenu familiju procedura sa paginacijom
    * @param family - Familija procedura (aesthetics/surgery)
+   * @param options - Pagination options
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
-  async getAllByFamily(family) {
-    const q = query2(
-      this.categoriesRef,
+  async getAllByFamily(family, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
       where2("family", "==", family),
-      where2("isActive", "==", true)
-    );
+      where2("isActive", "==", active),
+      orderBy2("name"),
+      queryLimit ? limit2(queryLimit) : void 0,
+      lastVisible ? startAfter2(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query2(this.categoriesRef, ...constraints);
     const snapshot = await getDocs2(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const categories = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { categories, lastVisible: newLastVisible };
   }
   /**
    * Ažurira postojeću kategoriju
@@ -201,6 +326,13 @@ var CategoryService = class extends BaseService {
   async delete(id) {
     await this.update(id, { isActive: false });
   }
+  /**
+   * Reactivates a category by setting its isActive flag to true.
+   * @param id - The ID of the category to reactivate.
+   */
+  async reactivate(id) {
+    await this.update(id, { isActive: true });
+  }
   /**
    * Vraća kategoriju po ID-u
    * @param id - ID tražene kategorije
@@ -228,9 +360,9 @@ import {
   deleteDoc,
   query as query3,
   where as where3,
-  orderBy,
-  limit,
-  startAfter
+  orderBy as orderBy3,
+  limit as limit3,
+  startAfter as startAfter3
 } from "firebase/firestore";
 
 // src/types/documentation-templates/index.ts
@@ -465,9 +597,10 @@ var updateFilledDocumentDataSchema = z.object({
 });
 
 // src/services/documentation-templates/documentation-template.service.ts
+import { getCountFromServer as getCountFromServer3 } from "firebase/firestore";
 var DocumentationTemplateService = class extends BaseService {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     this.collectionRef = collection3(
       this.db,
       DOCUMENTATION_TEMPLATES_COLLECTION
@@ -616,11 +749,11 @@ var DocumentationTemplateService = class extends BaseService {
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const q = query3(versionsCollectionRef, orderBy("version", "desc"));
+    const q = query3(versionsCollectionRef, orderBy3("version", "desc"));
     const querySnapshot = await getDocs3(q);
     const versions = [];
-    querySnapshot.forEach((doc10) => {
-      versions.push(doc10.data());
+    querySnapshot.forEach((doc11) => {
+      versions.push(doc11.data());
     });
     return versions;
   }
@@ -642,24 +775,106 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query3(
       this.collectionRef,
       where3("isActive", "==", true),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
+      orderBy3("updatedAt", "desc"),
+      limit3(pageSize)
     );
     if (lastDoc) {
-      q = query3(q, startAfter(lastDoc));
+      q = query3(q, startAfter3(lastDoc));
+    }
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    let lastVisible = null;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
+    });
+    return {
+      templates,
+      lastDoc: lastVisible
+    };
+  }
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options) {
+    const {
+      pageSize = 20,
+      lastDoc,
+      isUserForm,
+      isRequired,
+      sortingOrder
+    } = options;
+    const constraints = [
+      where3("isActive", "==", true),
+      orderBy3("sortingOrder", "asc"),
+      orderBy3("title", "asc"),
+      limit3(pageSize)
+    ];
+    if (isUserForm !== void 0) {
+      constraints.push(where3("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== void 0) {
+      constraints.push(where3("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== void 0) {
+      constraints.push(where3("sortingOrder", "==", sortingOrder));
+    }
+    if (lastDoc) {
+      constraints.push(startAfter3(lastDoc));
     }
+    const q = query3(this.collectionRef, ...constraints.filter((c) => c));
     const querySnapshot = await getDocs3(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
       lastDoc: lastVisible
     };
   }
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options) {
+    const { isUserForm, isRequired, sortingOrder } = options;
+    const constraints = [where3("isActive", "==", true)];
+    if (isUserForm !== void 0) {
+      constraints.push(where3("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== void 0) {
+      constraints.push(where3("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== void 0) {
+      constraints.push(where3("sortingOrder", "==", sortingOrder));
+    }
+    const q = query3(this.collectionRef, ...constraints.filter((c) => c));
+    const snapshot = await getCountFromServer3(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates() {
+    const q = query3(
+      this.collectionRef,
+      where3("isActive", "==", true),
+      orderBy3("title", "asc")
+    );
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+    });
+    return templates;
+  }
   /**
    * Get templates by tags
    * @param tags - Tags to filter by
@@ -672,18 +887,18 @@ var DocumentationTemplateService = class extends BaseService {
       this.collectionRef,
       where3("isActive", "==", true),
       where3("tags", "array-contains-any", tags),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
+      orderBy3("updatedAt", "desc"),
+      limit3(pageSize)
     );
     if (lastDoc) {
-      q = query3(q, startAfter(lastDoc));
+      q = query3(q, startAfter3(lastDoc));
     }
     const querySnapshot = await getDocs3(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
@@ -701,18 +916,18 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query3(
       this.collectionRef,
       where3("createdBy", "==", userId),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
+      orderBy3("updatedAt", "desc"),
+      limit3(pageSize)
     );
     if (lastDoc) {
-      q = query3(q, startAfter(lastDoc));
+      q = query3(q, startAfter3(lastDoc));
     }
     const querySnapshot = await getDocs3(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
@@ -728,7 +943,7 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query3(
       this.collectionRef,
       where3("isActive", "==", true),
-      orderBy("updatedAt", "desc")
+      orderBy3("updatedAt", "desc")
     );
     if ((options == null ? void 0 : options.isUserForm) !== void 0) {
       q = query3(q, where3("isUserForm", "==", options.isUserForm));
@@ -738,8 +953,8 @@ var DocumentationTemplateService = class extends BaseService {
     }
     const querySnapshot = await getDocs3(q);
     const templates = [];
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
     });
     return templates;
   }
@@ -754,9 +969,9 @@ import {
   setDoc as setDoc3,
   updateDoc as updateDoc5,
   query as query5,
-  orderBy as orderBy3,
-  limit as limit3,
-  startAfter as startAfter2
+  orderBy as orderBy5,
+  limit as limit5,
+  startAfter as startAfter4
 } from "firebase/firestore";
 
 // src/services/media/media.service.ts
@@ -776,10 +991,10 @@ import {
   collection as collection4,
   query as query4,
   where as where4,
-  limit as limit2,
+  limit as limit4,
   getDocs as getDocs4,
   deleteDoc as deleteDoc2,
-  orderBy as orderBy2
+  orderBy as orderBy4
 } from "firebase/firestore";
 
 // src/backoffice/services/documentation-template.service.ts
@@ -790,8 +1005,8 @@ var DocumentationTemplateServiceBackoffice = class {
    * @param auth - Firebase Auth instance
    * @param app - Firebase App instance
    */
-  constructor(db, auth, app) {
-    this.apiService = new DocumentationTemplateService(db, auth, app);
+  constructor(...args) {
+    this.apiService = new DocumentationTemplateService(...args);
   }
   /**
    * Create a new document template
@@ -836,6 +1051,40 @@ var DocumentationTemplateServiceBackoffice = class {
   async getActiveTemplates(pageSize = 20, lastDoc) {
     return this.apiService.getActiveTemplates(pageSize, lastDoc);
   }
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options) {
+    return this.apiService.getTemplates(options);
+  }
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options) {
+    return this.apiService.getTemplatesCount(options);
+  }
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates() {
+    return this.apiService.getAllActiveTemplates();
+  }
+  /**
+   * Searches for active templates by title.
+   * @param title - The title to search for.
+   * @returns A list of templates that match the search criteria.
+   */
+  async search(title) {
+    const { templates } = await this.apiService.getActiveTemplates(1e3);
+    return templates.filter(
+      (t) => t.title.toLowerCase().includes(title.toLowerCase())
+    );
+  }
   /**
    * Get templates by tags
    * @param tags - Tags to filter by
@@ -879,12 +1128,17 @@ var DocumentationTemplateServiceBackoffice = class {
 import {
   addDoc as addDoc3,
   collection as collection6,
+  collectionGroup,
   doc as doc6,
   getDoc as getDoc6,
   getDocs as getDocs6,
   query as query6,
   updateDoc as updateDoc6,
-  where as where6
+  where as where6,
+  limit as limit6,
+  orderBy as orderBy6,
+  startAfter as startAfter5,
+  getCountFromServer as getCountFromServer4
 } from "firebase/firestore";
 
 // src/backoffice/types/product.types.ts
@@ -928,20 +1182,102 @@ var ProductService = class extends BaseService {
     return { id: productRef.id, ...newProduct };
   }
   /**
-   * Gets all products for a technology
+   * Gets a paginated list of all products, with optional filters.
+   * This uses a collectionGroup query to search across all technologies.
    */
-  async getAllByTechnology(technologyId) {
+  async getAll(options) {
+    const {
+      rowsPerPage,
+      lastVisible,
+      categoryId,
+      subcategoryId,
+      technologyId
+    } = options;
+    const constraints = [
+      where6("isActive", "==", true),
+      orderBy6("name")
+    ];
+    if (categoryId) {
+      constraints.push(where6("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push(where6("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push(where6("technologyId", "==", technologyId));
+    }
+    if (lastVisible) {
+      constraints.push(startAfter5(lastVisible));
+    }
+    constraints.push(limit6(rowsPerPage));
     const q = query6(
-      this.getProductsRef(technologyId),
-      where6("isActive", "==", true)
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      ...constraints
     );
     const snapshot = await getDocs6(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const products = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { products, lastVisible: newLastVisible };
+  }
+  /**
+   * Gets the total count of active products, with optional filters.
+   */
+  async getProductsCount(options) {
+    const { categoryId, subcategoryId, technologyId } = options;
+    const constraints = [where6("isActive", "==", true)];
+    if (categoryId) {
+      constraints.push(where6("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push(where6("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push(where6("technologyId", "==", technologyId));
+    }
+    const q = query6(
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      ...constraints
+    );
+    const snapshot = await getCountFromServer4(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Gets counts of active products grouped by category, subcategory, and technology.
+   * This uses a single collectionGroup query for efficiency.
+   */
+  async getProductCounts() {
+    const q = query6(
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      where6("isActive", "==", true)
+    );
+    const snapshot = await getDocs6(q);
+    const counts = {
+      byCategory: {},
+      bySubcategory: {},
+      byTechnology: {}
+    };
+    if (snapshot.empty) {
+      return counts;
+    }
+    snapshot.docs.forEach((doc11) => {
+      const product = doc11.data();
+      const { categoryId, subcategoryId, technologyId } = product;
+      if (categoryId) {
+        counts.byCategory[categoryId] = (counts.byCategory[categoryId] || 0) + 1;
+      }
+      if (subcategoryId) {
+        counts.bySubcategory[subcategoryId] = (counts.bySubcategory[subcategoryId] || 0) + 1;
+      }
+      if (technologyId) {
+        counts.byTechnology[technologyId] = (counts.byTechnology[technologyId] || 0) + 1;
+      }
+    });
+    return counts;
   }
   /**
    * Gets all products for a brand by filtering through all technologies
@@ -959,9 +1295,9 @@ var ProductService = class extends BaseService {
       const snapshot = await getDocs6(q);
       products.push(
         ...snapshot.docs.map(
-          (doc10) => ({
-            id: doc10.id,
-            ...doc10.data()
+          (doc11) => ({
+            id: doc11.id,
+            ...doc11.data()
           })
         )
       );
@@ -1059,9 +1395,9 @@ var RequirementService = class extends BaseService {
     const q = query7(this.requirementsRef, where7("isActive", "==", true));
     const snapshot = await getDocs7(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -1078,12 +1414,24 @@ var RequirementService = class extends BaseService {
     );
     const snapshot = await getDocs7(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
+  /**
+   * Searches for requirements by name.
+   * @param name - The name to search for.
+   * @param type - The type of requirement (pre/post).
+   * @returns A list of requirements that match the search criteria.
+   */
+  async search(name, type) {
+    const requirements = await this.getAllByType(type);
+    return requirements.filter(
+      (r) => r.name.toLowerCase().includes(name.toLowerCase())
+    );
+  }
   /**
    * Ažurira postojeći zahtev
    * @param id - ID zahteva koji se ažurira
@@ -1126,10 +1474,17 @@ var RequirementService = class extends BaseService {
 import {
   addDoc as addDoc5,
   collection as collection8,
+  collectionGroup as collectionGroup2,
+  deleteDoc as deleteDoc3,
   doc as doc8,
+  getCountFromServer as getCountFromServer5,
   getDoc as getDoc8,
   getDocs as getDocs8,
+  limit as limit7,
+  orderBy as orderBy7,
   query as query8,
+  setDoc as setDoc4,
+  startAfter as startAfter6,
   updateDoc as updateDoc8,
   where as where8
 } from "firebase/firestore";
@@ -1173,20 +1528,110 @@ var SubcategoryService = class extends BaseService {
     return { id: docRef.id, ...newSubcategory };
   }
   /**
-   * Vraća sve aktivne podkategorije za određenu kategoriju
+   * Returns counts of subcategories for all categories.
+   * @param active - Whether to count active or inactive subcategories.
+   * @returns A record mapping category ID to subcategory count.
+   */
+  async getSubcategoryCounts(active = true) {
+    const categoriesRef = collection8(this.db, CATEGORIES_COLLECTION);
+    const categoriesSnapshot = await getDocs8(categoriesRef);
+    const counts = {};
+    for (const categoryDoc of categoriesSnapshot.docs) {
+      const categoryId = categoryDoc.id;
+      const subcategoriesRef = this.getSubcategoriesRef(categoryId);
+      const q = query8(subcategoriesRef, where8("isActive", "==", active));
+      const snapshot = await getCountFromServer5(q);
+      counts[categoryId] = snapshot.data().count;
+    }
+    return counts;
+  }
+  /**
+   * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
    * @param categoryId - ID kategorije čije podkategorije tražimo
-   * @returns Lista aktivnih podkategorija
+   * @param options - Pagination options
+   * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
+   */
+  async getAllByCategoryId(categoryId, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where8("isActive", "==", active),
+      orderBy7("name"),
+      queryLimit ? limit7(queryLimit) : void 0,
+      lastVisible ? startAfter6(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query8(this.getSubcategoriesRef(categoryId), ...constraints);
+    const querySnapshot = await getDocs8(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve podkategorije sa paginacijom koristeći collection group query.
+   * NOTE: This query requires a composite index in Firestore on the 'subcategories' collection group.
+   * The index should be on 'isActive' (ascending) and 'name' (ascending).
+   * Firestore will provide a link to create this index in the console error if it's missing.
+   * @param options - Pagination options
+   * @returns Lista podkategorija i poslednji vidljiv dokument
+   */
+  async getAll(options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where8("isActive", "==", active),
+      orderBy7("name"),
+      queryLimit ? limit7(queryLimit) : void 0,
+      lastVisible ? startAfter6(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query8(
+      collectionGroup2(this.db, SUBCATEGORIES_COLLECTION),
+      ...constraints
+    );
+    const querySnapshot = await getDocs8(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve subkategorije za određenu kategoriju za potrebe filtera (bez paginacije)
+   * @param categoryId - ID kategorije čije subkategorije tražimo
+   * @returns Lista svih aktivnih subkategorija
    */
-  async getAllByCategoryId(categoryId) {
+  async getAllForFilterByCategoryId(categoryId) {
     const q = query8(
       this.getSubcategoriesRef(categoryId),
       where8("isActive", "==", true)
     );
-    const snapshot = await getDocs8(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const querySnapshot = await getDocs8(q);
+    return querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve subkategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih subkategorija
+   */
+  async getAllForFilter() {
+    const q = query8(
+      collectionGroup2(this.db, SUBCATEGORIES_COLLECTION),
+      where8("isActive", "==", true)
+    );
+    const querySnapshot = await getDocs8(q);
+    return querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -1198,13 +1643,42 @@ var SubcategoryService = class extends BaseService {
    * @returns Ažurirana podkategorija
    */
   async update(categoryId, subcategoryId, subcategory) {
-    const updateData = {
-      ...subcategory,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = doc8(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await updateDoc8(docRef, updateData);
-    return this.getById(categoryId, subcategoryId);
+    const newCategoryId = subcategory.categoryId;
+    if (newCategoryId && newCategoryId !== categoryId) {
+      const oldDocRef = doc8(
+        this.getSubcategoriesRef(categoryId),
+        subcategoryId
+      );
+      const docSnap = await getDoc8(oldDocRef);
+      if (!docSnap.exists()) {
+        throw new Error("Subcategory to update does not exist.");
+      }
+      const existingData = docSnap.data();
+      const newData = {
+        ...existingData,
+        ...subcategory,
+        categoryId: newCategoryId,
+        // Ensure categoryId is updated
+        createdAt: existingData.createdAt,
+        // Preserve original creation date
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const newDocRef = doc8(
+        this.getSubcategoriesRef(newCategoryId),
+        subcategoryId
+      );
+      await setDoc4(newDocRef, newData);
+      await deleteDoc3(oldDocRef);
+      return { id: subcategoryId, ...newData };
+    } else {
+      const updateData = {
+        ...subcategory,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const docRef = doc8(this.getSubcategoriesRef(categoryId), subcategoryId);
+      await updateDoc8(docRef, updateData);
+      return this.getById(categoryId, subcategoryId);
+    }
   }
   /**
    * Soft delete podkategorije (postavlja isActive na false)
@@ -1214,6 +1688,14 @@ var SubcategoryService = class extends BaseService {
   async delete(categoryId, subcategoryId) {
     await this.update(categoryId, subcategoryId, { isActive: false });
   }
+  /**
+   * Reactivates a subcategory by setting its isActive flag to true.
+   * @param categoryId - The ID of the category to which the subcategory belongs.
+   * @param subcategoryId - The ID of the subcategory to reactivate.
+   */
+  async reactivate(categoryId, subcategoryId) {
+    await this.update(categoryId, subcategoryId, { isActive: true });
+  }
   /**
    * Vraća podkategoriju po ID-u
    * @param categoryId - ID kategorije kojoj pripada podkategorija
@@ -1238,7 +1720,10 @@ import {
   doc as doc9,
   getDoc as getDoc9,
   getDocs as getDocs9,
+  limit as limit8,
+  orderBy as orderBy8,
   query as query9,
+  startAfter as startAfter7,
   updateDoc as updateDoc9,
   where as where9,
   arrayUnion,
@@ -1276,137 +1761,185 @@ var DEFAULT_CERTIFICATION_REQUIREMENT = {
 };
 var TechnologyService = class extends BaseService {
   /**
-   * Vraća referencu na Firestore kolekciju tehnologija
+   * Reference to the Firestore collection of technologies.
    */
-  getTechnologiesRef() {
+  get technologiesRef() {
     return collection9(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
-   * Kreira novu tehnologiju
-   * @param technology - Podaci za novu tehnologiju
-   * @returns Kreirana tehnologija sa generisanim ID-em
+   * Creates a new technology.
+   * @param technology - Data for the new technology.
+   * @returns The created technology with its generated ID.
    */
   async create(technology) {
     const now = /* @__PURE__ */ new Date();
     const newTechnology = {
-      ...technology,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true,
-      requirements: technology.requirements || {
-        pre: [],
-        post: []
-      },
+      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
+      certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: now,
+      updatedAt: now
     };
-    const docRef = await addDoc6(this.getTechnologiesRef(), newTechnology);
+    if (technology.technicalDetails) {
+      newTechnology.technicalDetails = technology.technicalDetails;
+    }
+    const docRef = await addDoc6(this.technologiesRef, newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
   /**
-   * Vraća sve aktivne tehnologije
-   * @returns Lista aktivnih tehnologija
+   * 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 getAll() {
-    const q = query9(this.getTechnologiesRef(), where9("isActive", "==", true));
+  async getTechnologyCounts(active = true) {
+    const q = query9(this.technologiesRef, where9("isActive", "==", active));
     const snapshot = await getDocs9(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+    const counts = {};
+    snapshot.docs.forEach((doc11) => {
+      const tech = doc11.data();
+      counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
+    });
+    return counts;
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu familiju
-   * @param family - Familija procedura
-   * @returns Lista aktivnih tehnologija
+   * 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 getAllByFamily(family) {
-    const q = query9(
-      this.getTechnologiesRef(),
-      where9("isActive", "==", true),
-      where9("family", "==", family)
-    );
+  async getTechnologyCountsByCategory(active = true) {
+    const q = query9(this.technologiesRef, where9("isActive", "==", active));
     const snapshot = await getDocs9(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const counts = {};
+    snapshot.docs.forEach((doc11) => {
+      const tech = doc11.data();
+      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 = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where9("isActive", "==", active),
+      orderBy8("name"),
+      queryLimit ? limit8(queryLimit) : void 0,
+      lastVisible ? startAfter7(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query9(this.technologiesRef, ...constraints);
+    const snapshot = await getDocs9(q);
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
-  }
-  /**
-   * Vraća sve aktivne tehnologije za određenu kategoriju
-   * @param categoryId - ID kategorije
-   * @returns Lista aktivnih tehnologija
-   */
-  async getAllByCategoryId(categoryId) {
-    const q = query9(
-      this.getTechnologiesRef(),
-      where9("isActive", "==", true),
-      where9("categoryId", "==", categoryId)
-    );
+    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, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where9("categoryId", "==", categoryId),
+      where9("isActive", "==", active),
+      orderBy8("name"),
+      queryLimit ? limit8(queryLimit) : void 0,
+      lastVisible ? startAfter7(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query9(this.technologiesRef, ...constraints);
     const snapshot = await getDocs9(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
-  }
-  /**
-   * Vraća sve aktivne tehnologije za određenu podkategoriju
-   * @param subcategoryId - ID podkategorije
-   * @returns Lista aktivnih tehnologija
-   */
-  async getAllBySubcategoryId(subcategoryId) {
-    const q = query9(
-      this.getTechnologiesRef(),
-      where9("isActive", "==", true),
-      where9("subcategoryId", "==", subcategoryId)
-    );
+    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, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where9("subcategoryId", "==", subcategoryId),
+      where9("isActive", "==", active),
+      orderBy8("name"),
+      queryLimit ? limit8(queryLimit) : void 0,
+      lastVisible ? startAfter7(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = query9(this.technologiesRef, ...constraints);
     const snapshot = await getDocs9(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
   }
   /**
-   * Ažurira postojeću tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param technology - Novi podaci za tehnologiju
-   * @returns Ažurirana tehnologija
+   * 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(technologyId, technology) {
-    const updateData = {
-      ...technology,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+  async update(id, technology) {
+    const updateData = { ...technology };
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key] === void 0) {
+        delete updateData[key];
+      }
+    });
+    updateData.updatedAt = /* @__PURE__ */ new Date();
+    const docRef = doc9(this.technologiesRef, id);
     await updateDoc9(docRef, updateData);
-    return this.getById(technologyId);
+    return this.getById(id);
   }
   /**
-   * Soft delete tehnologije (postavlja isActive na false)
-   * @param technologyId - ID tehnologije koja se briše
+   * Soft deletes a technology.
+   * @param id - The ID of the technology to delete.
    */
-  async delete(technologyId) {
-    await this.update(technologyId, {
-      isActive: false
-    });
+  async delete(id) {
+    await this.update(id, { isActive: false });
   }
   /**
-   * Vraća tehnologiju po ID-u
-   * @param technologyId - ID tražene tehnologije
-   * @returns Tehnologija ili null ako ne postoji
+   * Reactivates a technology.
+   * @param id - The ID of the technology to reactivate.
    */
-  async getById(technologyId) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+  async reactivate(id) {
+    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) {
+    const docRef = doc9(this.technologiesRef, id);
     const docSnap = await getDoc9(docRef);
     if (!docSnap.exists()) return null;
     return {
@@ -1421,7 +1954,7 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(this.technologiesRef, technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await updateDoc9(docRef, {
       [requirementType]: arrayUnion(requirement),
@@ -1436,7 +1969,7 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(this.technologiesRef, technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
     await updateDoc9(docRef, {
       [requirementType]: arrayRemove(requirement),
@@ -1476,7 +2009,7 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(this.technologiesRef, technologyId);
     await updateDoc9(docRef, {
       blockingConditions: arrayUnion(condition),
       updatedAt: /* @__PURE__ */ new Date()
@@ -1490,7 +2023,7 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(this.technologiesRef, technologyId);
     await updateDoc9(docRef, {
       blockingConditions: arrayRemove(condition),
       updatedAt: /* @__PURE__ */ new Date()
@@ -1504,9 +2037,17 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(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;
+    }
     await updateDoc9(docRef, {
-      contraindications: arrayUnion(contraindication),
+      contraindications: [...existingContraindications, contraindication],
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1518,9 +2059,45 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(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 updateDoc9(docRef, {
+      contraindications: updatedContraindications,
+      updatedAt: /* @__PURE__ */ 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, contraindication) {
+    const docRef = doc9(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) {
+      console.warn(
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+    const updatedContraindications = [...contraindications];
+    updatedContraindications[index] = contraindication;
     await updateDoc9(docRef, {
-      contraindications: arrayRemove(contraindication),
+      contraindications: updatedContraindications,
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1532,9 +2109,17 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(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;
+    }
     await updateDoc9(docRef, {
-      benefits: arrayUnion(benefit),
+      benefits: [...existingBenefits, benefit],
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1546,9 +2131,45 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(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 updateDoc9(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: /* @__PURE__ */ 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, benefit) {
+    const docRef = doc9(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) {
+      console.warn(
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+    const updatedBenefits = [...benefits];
+    updatedBenefits[index] = benefit;
     await updateDoc9(docRef, {
-      benefits: arrayRemove(benefit),
+      benefits: updatedBenefits,
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1587,7 +2208,7 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docRef = doc9(this.technologiesRef, technologyId);
     await updateDoc9(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
@@ -1665,7 +2286,7 @@ var TechnologyService = class extends BaseService {
    */
   async getAllowedTechnologies(practitioner) {
     const allTechnologies = await this.getAll();
-    const allowedTechnologies = allTechnologies.filter(
+    const allowedTechnologies = allTechnologies.technologies.filter(
       (technology) => this.validateCertification(
         technology.certificationRequirement,
         practitioner.certification
@@ -1685,6 +2306,283 @@ var TechnologyService = class extends BaseService {
       subcategories
     };
   }
+  /**
+   * 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, subcategoryId) {
+    const q = query9(
+      collection9(this.db, TECHNOLOGIES_COLLECTION),
+      where9("isActive", "==", true),
+      where9("categoryId", "==", categoryId),
+      where9("subcategoryId", "==", subcategoryId),
+      orderBy8("name")
+    );
+    const snapshot = await getDocs9(q);
+    return snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+  /**
+   * Gets all active technologies for filter dropdowns.
+   */
+  async getAllForFilter() {
+    const q = query9(
+      collection9(this.db, TECHNOLOGIES_COLLECTION),
+      where9("isActive", "==", true),
+      orderBy8("name")
+    );
+    const snapshot = await getDocs9(q);
+    return snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+};
+
+// src/backoffice/services/constants.service.ts
+import {
+  arrayRemove as arrayRemove2,
+  arrayUnion as arrayUnion2,
+  doc as doc10,
+  getDoc as getDoc10,
+  setDoc as setDoc5,
+  updateDoc as updateDoc10
+} from "firebase/firestore";
+var ADMIN_CONSTANTS_COLLECTION = "admin-constants";
+var TREATMENT_BENEFITS_DOC = "treatment-benefits";
+var CONTRAINDICATIONS_DOC = "contraindications";
+var ConstantsService = class extends BaseService {
+  /**
+   * @description Gets the reference to the document holding treatment benefits.
+   * @private
+   * @type {DocumentReference}
+   */
+  get treatmentBenefitsDocRef() {
+    return doc10(this.db, ADMIN_CONSTANTS_COLLECTION, TREATMENT_BENEFITS_DOC);
+  }
+  /**
+   * @description Gets the reference to the document holding contraindications.
+   * @private
+   * @type {DocumentReference}
+   */
+  get contraindicationsDocRef() {
+    return doc10(this.db, ADMIN_CONSTANTS_COLLECTION, CONTRAINDICATIONS_DOC);
+  }
+  // =================================================================
+  // Treatment Benefits
+  // =================================================================
+  /**
+   * @description Retrieves all treatment benefits without pagination.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of all treatment benefits.
+   */
+  async getAllBenefitsForFilter() {
+    const docSnap = await getDoc10(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return docSnap.data().benefits;
+  }
+  /**
+   * @description Retrieves a paginated list of treatment benefits.
+   * @param {{ page: number; limit: number }} options - Pagination options.
+   * @returns {Promise<{ benefits: TreatmentBenefitDynamic[]; total: number }>} A paginated list of benefits and the total count.
+   */
+  async getAllBenefits(options) {
+    const allBenefits = await this.getAllBenefitsForFilter();
+    const { page, limit: limit9 } = options;
+    const startIndex = page * limit9;
+    const endIndex = startIndex + limit9;
+    const paginatedBenefits = allBenefits.slice(startIndex, endIndex);
+    return { benefits: paginatedBenefits, total: allBenefits.length };
+  }
+  /**
+   * @description Adds a new treatment benefit.
+   * @param {Omit<TreatmentBenefitDynamic, "id">} benefit - The treatment benefit to add, without an ID.
+   * @returns {Promise<TreatmentBenefitDynamic>} The newly created treatment benefit with its generated ID.
+   */
+  async addTreatmentBenefit(benefit) {
+    const newBenefit = {
+      id: this.generateId(),
+      ...benefit
+    };
+    const docSnap = await getDoc10(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      await setDoc5(this.treatmentBenefitsDocRef, { benefits: [newBenefit] });
+    } else {
+      await updateDoc10(this.treatmentBenefitsDocRef, {
+        benefits: arrayUnion2(newBenefit)
+      });
+    }
+    return newBenefit;
+  }
+  /**
+   * @description Retrieves a single treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to retrieve.
+   * @returns {Promise<TreatmentBenefitDynamic | undefined>} The found treatment benefit or undefined.
+   */
+  async getBenefitById(benefitId) {
+    const benefits = await this.getAllBenefitsForFilter();
+    return benefits.find((b) => b.id === benefitId);
+  }
+  /**
+   * @description Searches for treatment benefits by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the benefit names.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of matching treatment benefits.
+   */
+  async searchBenefitsByName(searchTerm) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return benefits.filter(
+      (b) => b.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+  /**
+   * @description Updates an existing treatment benefit.
+   * @param {TreatmentBenefitDynamic} benefit - The treatment benefit with updated data. Its ID must match an existing benefit.
+   * @returns {Promise<TreatmentBenefitDynamic>} The updated treatment benefit.
+   * @throws {Error} If the treatment benefit is not found.
+   */
+  async updateTreatmentBenefit(benefit) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const benefitIndex = benefits.findIndex((b) => b.id === benefit.id);
+    if (benefitIndex === -1) {
+      throw new Error("Treatment benefit not found.");
+    }
+    benefits[benefitIndex] = benefit;
+    await updateDoc10(this.treatmentBenefitsDocRef, { benefits });
+    return benefit;
+  }
+  /**
+   * @description Deletes a treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteTreatmentBenefit(benefitId) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const benefitToRemove = benefits.find((b) => b.id === benefitId);
+    if (!benefitToRemove) {
+      return;
+    }
+    await updateDoc10(this.treatmentBenefitsDocRef, {
+      benefits: arrayRemove2(benefitToRemove)
+    });
+  }
+  // =================================================================
+  // Contraindications
+  // =================================================================
+  /**
+   * @description Retrieves all contraindications without pagination.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of all contraindications.
+   */
+  async getAllContraindicationsForFilter() {
+    const docSnap = await getDoc10(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return docSnap.data().contraindications;
+  }
+  /**
+   * @description Retrieves a paginated list of contraindications.
+   * @param {{ page: number; limit: number }} options - Pagination options.
+   * @returns {Promise<{ contraindications: ContraindicationDynamic[]; total: number }>} A paginated list and the total count.
+   */
+  async getAllContraindications(options) {
+    const allContraindications = await this.getAllContraindicationsForFilter();
+    const { page, limit: limit9 } = options;
+    const startIndex = page * limit9;
+    const endIndex = startIndex + limit9;
+    const paginatedContraindications = allContraindications.slice(
+      startIndex,
+      endIndex
+    );
+    return {
+      contraindications: paginatedContraindications,
+      total: allContraindications.length
+    };
+  }
+  /**
+   * @description Adds a new contraindication.
+   * @param {Omit<ContraindicationDynamic, "id">} contraindication - The contraindication to add, without an ID.
+   * @returns {Promise<ContraindicationDynamic>} The newly created contraindication with its generated ID.
+   */
+  async addContraindication(contraindication) {
+    const newContraindication = {
+      id: this.generateId(),
+      ...contraindication
+    };
+    const docSnap = await getDoc10(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      await setDoc5(this.contraindicationsDocRef, {
+        contraindications: [newContraindication]
+      });
+    } else {
+      await updateDoc10(this.contraindicationsDocRef, {
+        contraindications: arrayUnion2(newContraindication)
+      });
+    }
+    return newContraindication;
+  }
+  /**
+   * @description Retrieves a single contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to retrieve.
+   * @returns {Promise<ContraindicationDynamic | undefined>} The found contraindication or undefined.
+   */
+  async getContraindicationById(contraindicationId) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    return contraindications.find((c) => c.id === contraindicationId);
+  }
+  /**
+   * @description Searches for contraindications by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the contraindication names.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of matching contraindications.
+   */
+  async searchContraindicationsByName(searchTerm) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return contraindications.filter(
+      (c) => c.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+  /**
+   * @description Updates an existing contraindication.
+   * @param {ContraindicationDynamic} contraindication - The contraindication with updated data. Its ID must match an existing one.
+   * @returns {Promise<ContraindicationDynamic>} The updated contraindication.
+   * @throws {Error} If the contraindication is not found.
+   */
+  async updateContraindication(contraindication) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+    if (index === -1) {
+      throw new Error("Contraindication not found.");
+    }
+    contraindications[index] = contraindication;
+    await updateDoc10(this.contraindicationsDocRef, { contraindications });
+    return contraindication;
+  }
+  /**
+   * @description Deletes a contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteContraindication(contraindicationId) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const toRemove = contraindications.find((c) => c.id === contraindicationId);
+    if (!toRemove) {
+      return;
+    }
+    await updateDoc10(this.contraindicationsDocRef, {
+      contraindications: arrayRemove2(toRemove)
+    });
+  }
 };
 
 // src/backoffice/types/static/blocking-condition.types.ts
@@ -1743,13 +2641,6 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
   return Currency2;
 })(Currency || {});
 
-// src/backoffice/types/static/procedure-family.types.ts
-var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
-  ProcedureFamily2["AESTHETICS"] = "aesthetics";
-  ProcedureFamily2["SURGERY"] = "surgery";
-  return ProcedureFamily2;
-})(ProcedureFamily || {});
-
 // src/backoffice/types/static/treatment-benefit.types.ts
 var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
   TreatmentBenefit2["WRINKLE_REDUCTION"] = "wrinkle_reduction";
@@ -1772,9 +2663,25 @@ var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
 
 // src/backoffice/validations/schemas.ts
 import { z as z2 } from "zod";
+var contraindicationDynamicSchema = z2.object({
+  id: z2.string().min(1, "Contraindication ID is required").regex(
+    /^[a-z0-9_]+$/,
+    "ID must be in snake_case (lowercase, numbers, and underscores only)"
+  ),
+  name: z2.string().min(1, "Contraindication name is required"),
+  description: z2.string().optional()
+});
+var treatmentBenefitDynamicSchema = z2.object({
+  id: z2.string().min(1, "Benefit ID is required").regex(
+    /^[a-z0-9_]+$/,
+    "ID must be in snake_case (lowercase, numbers, and underscores only)"
+  ),
+  name: z2.string().min(1, "Benefit name is required"),
+  description: z2.string().optional()
+});
 var blockingConditionSchemaBackoffice = z2.nativeEnum(BlockingCondition);
-var contraindicationSchemaBackoffice = z2.nativeEnum(Contraindication);
-var treatmentBenefitSchemaBackoffice = z2.nativeEnum(TreatmentBenefit);
+var contraindicationSchemaBackoffice = contraindicationDynamicSchema;
+var treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
 var procedureFamilySchemaBackoffice = z2.nativeEnum(ProcedureFamily);
 var timeUnitSchemaBackoffice = z2.nativeEnum(TimeUnit);
 var requirementTypeSchema = z2.nativeEnum(RequirementType);
@@ -1996,6 +2903,7 @@ export {
   CertificationLevel,
   CertificationSpecialty,
   CircularReferenceError,
+  ConstantsService,
   Contraindication,
   ContraindicationError,
   Currency,
@@ -2043,6 +2951,7 @@ export {
   certificationLevelSchema,
   certificationRequirementSchema,
   certificationSpecialtySchema,
+  contraindicationDynamicSchema,
   contraindicationSchemaBackoffice,
   createDocumentTemplateSchema,
   documentElementSchema,
@@ -2059,6 +2968,7 @@ export {
   technologyUpdateSchema,
   timeUnitSchemaBackoffice,
   timeframeSchema,
+  treatmentBenefitDynamicSchema,
   treatmentBenefitSchemaBackoffice,
   updateDocumentTemplateSchema
 };