@blackcode_sa/metaestetics-api 1.13.5 → 1.13.8

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

@@ -1,461 +1,461 @@
-import {
-  addDoc,
-  collection,
-  collectionGroup,
-  deleteDoc,
-  doc,
-  DocumentData,
-  getCountFromServer,
-  getDoc,
-  getDocs,
-  limit,
-  orderBy,
-  query,
-  setDoc,
-  startAfter,
-  updateDoc,
-  where,
-} from "firebase/firestore";
-import {
-  Subcategory,
-  SUBCATEGORIES_COLLECTION,
-} from "../types/subcategory.types";
-import { BaseService } from "../../services/base.service";
-import { CATEGORIES_COLLECTION } from "../types/category.types";
-
-/**
- * ID of the free-consultation subcategory that should be hidden from admin backoffice.
- * This subcategory is used internally for free consultation procedures.
- */
-const EXCLUDED_SUBCATEGORY_ID = 'free-consultation';
-
-/**
- * Servis za upravljanje podkategorijama procedura.
- * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
- *
- * @example
- * const subcategoryService = new SubcategoryService();
- *
- * // Kreiranje nove podkategorije
- * const subcategory = await subcategoryService.create(categoryId, {
- *   name: "Anti-Wrinkle",
- *   description: "Treatments targeting facial wrinkles"
- * });
- */
-export class SubcategoryService extends BaseService {
-  /**
-   * Filters out excluded subcategories from a list.
-   * @param subcategories - List of subcategories to filter
-   * @returns Filtered list without excluded subcategories
-   */
-  private filterExcludedSubcategories(subcategories: Subcategory[]): Subcategory[] {
-    return subcategories.filter(sub => sub.id !== EXCLUDED_SUBCATEGORY_ID);
-  }
-  /**
-   * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
-   * @param categoryId - ID roditeljske kategorije
-   */
-  private getSubcategoriesRef(categoryId: string) {
-    return collection(
-      this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION
-    );
-  }
-
-  /**
-   * Kreira novu podkategoriju u okviru kategorije
-   * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
-   * @param subcategory - Podaci za novu podkategoriju
-   * @returns Kreirana podkategorija sa generisanim ID-em
-   */
-  async create(
-    categoryId: string,
-    subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">
-  ) {
-    const now = new Date();
-    const newSubcategory: Omit<Subcategory, "id"> = {
-      ...subcategory,
-      categoryId,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true,
-    };
-
-    const docRef = await addDoc(
-      this.getSubcategoriesRef(categoryId),
-      newSubcategory
-    );
-    return { id: docRef.id, ...newSubcategory };
-  }
-
-  /**
-   * 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 = collection(this.db, CATEGORIES_COLLECTION);
-    const categoriesSnapshot = await getDocs(categoriesRef);
-    const counts: Record<string, number> = {};
-
-    for (const categoryDoc of categoriesSnapshot.docs) {
-      const categoryId = categoryDoc.id;
-      const subcategoriesRef = this.getSubcategoriesRef(categoryId);
-      const q = query(subcategoriesRef, where("isActive", "==", active));
-      const snapshot = await getDocs(q);
-      // Filter out excluded subcategory and count
-      const filteredDocs = snapshot.docs.filter(doc => doc.id !== EXCLUDED_SUBCATEGORY_ID);
-      counts[categoryId] = filteredDocs.length;
-    }
-
-    return counts;
-  }
-
-  /**
-   * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
-   * @param categoryId - ID kategorije čije podkategorije tražimo
-   * @param options - Pagination options
-   * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
-   */
-  async getAllByCategoryId(
-    categoryId: string,
-    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.getSubcategoriesRef(categoryId), ...constraints);
-
-    const querySnapshot = await getDocs(q);
-    const subcategories = querySnapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Subcategory)
-    );
-    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
-    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
-    return { subcategories: filteredSubcategories, 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: {
-      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(
-      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
-      ...constraints
-    );
-
-    const querySnapshot = await getDocs(q);
-    const subcategories = querySnapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Subcategory)
-    );
-    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
-    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
-    return { subcategories: filteredSubcategories, 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 getAllForFilterByCategoryId(categoryId: string) {
-    const q = query(
-      this.getSubcategoriesRef(categoryId),
-      where("isActive", "==", true)
-    );
-    const querySnapshot = await getDocs(q);
-    const subcategories = querySnapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Subcategory)
-    );
-    return this.filterExcludedSubcategories(subcategories);
-  }
-
-  /**
-   * Vraća sve subkategorije za potrebe filtera (bez paginacije)
-   * @returns Lista svih aktivnih subkategorija
-   */
-  async getAllForFilter() {
-    const q = query(
-      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
-      where("isActive", "==", true)
-    );
-    const querySnapshot = await getDocs(q);
-    const subcategories = querySnapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Subcategory)
-    );
-    return this.filterExcludedSubcategories(subcategories);
-  }
-
-  /**
-   * Ažurira postojeću podkategoriju
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID podkategorije koja se ažurira
-   * @param subcategory - Novi podaci za podkategoriju
-   * @returns Ažurirana podkategorija
-   */
-  async update(
-    categoryId: string,
-    subcategoryId: string,
-    subcategory: Partial<Omit<Subcategory, "id" | "createdAt">>
-  ) {
-    const newCategoryId = subcategory.categoryId;
-
-    if (newCategoryId && newCategoryId !== categoryId) {
-      // Category has changed, move the document
-      const oldDocRef = doc(
-        this.getSubcategoriesRef(categoryId),
-        subcategoryId
-      );
-      const docSnap = await getDoc(oldDocRef);
-
-      if (!docSnap.exists()) {
-        throw new Error("Subcategory to update does not exist.");
-      }
-
-      const existingData = docSnap.data();
-      const newData: Omit<Subcategory, "id"> = {
-        ...(existingData as Omit<
-          Subcategory,
-          "id" | "createdAt" | "updatedAt"
-        >),
-        ...subcategory,
-        categoryId: newCategoryId, // Ensure categoryId is updated
-        createdAt: existingData.createdAt, // Preserve original creation date
-        updatedAt: new Date(),
-      };
-
-      const newDocRef = doc(
-        this.getSubcategoriesRef(newCategoryId),
-        subcategoryId
-      );
-
-      await setDoc(newDocRef, newData);
-      await deleteDoc(oldDocRef);
-
-      return { id: subcategoryId, ...newData };
-    } else {
-      // Category has not changed, just update the document
-      const updateData = {
-        ...subcategory,
-        updatedAt: new Date(),
-      };
-
-      const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
-      await updateDoc(docRef, updateData);
-      return this.getById(categoryId, subcategoryId);
-    }
-  }
-
-  /**
-   * Soft delete podkategorije (postavlja isActive na false)
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID podkategorije koja se briše
-   */
-  async delete(categoryId: string, subcategoryId: string) {
-    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: string, subcategoryId: string) {
-    await this.update(categoryId, subcategoryId, { isActive: true });
-  }
-
-  /**
-   * Vraća podkategoriju po ID-u
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID tražene podkategorije
-   * @returns Podkategorija ili null ako ne postoji
-   */
-  async getById(categoryId: string, subcategoryId: string) {
-    // Prevent access to excluded subcategory
-    if (subcategoryId === EXCLUDED_SUBCATEGORY_ID) return null;
-    
-    const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await getDoc(docRef);
-    if (!docSnap.exists()) return null;
-    return {
-      id: docSnap.id,
-      ...docSnap.data(),
-    } as Subcategory;
-  }
-
-  /**
-   * Internal method to get subcategory by ID without filtering.
-   * Used internally for consultation procedures.
-   * @param categoryId - ID of the category
-   * @param subcategoryId - ID of the subcategory to get
-   * @returns Subcategory or null if not found
-   */
-  async getByIdInternal(categoryId: string, subcategoryId: string): Promise<Subcategory | null> {
-    const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await getDoc(docRef);
-    if (!docSnap.exists()) return null;
-    return {
-      id: docSnap.id,
-      ...docSnap.data(),
-    } as Subcategory;
-  }
-
-  /**
-   * Finds a subcategory by exact name match within a specific category.
-   * Used for CSV import matching.
-   * @param name - Exact name of the subcategory to find
-   * @param categoryId - ID of the category to search within
-   * @returns Subcategory if found, null otherwise
-   */
-  async findByNameAndCategory(name: string, categoryId: string): Promise<Subcategory | null> {
-    const q = query(
-      this.getSubcategoriesRef(categoryId),
-      where('name', '==', name),
-      where('isActive', '==', true),
-    );
-    const querySnapshot = await getDocs(q);
-    if (querySnapshot.empty) return null;
-    const doc = querySnapshot.docs[0];
-    // Exclude free-consultation subcategory
-    if (doc.id === EXCLUDED_SUBCATEGORY_ID) return null;
-    return {
-      id: doc.id,
-      ...doc.data(),
-    } as Subcategory;
-  }
-
-  /**
-   * Exports subcategories to CSV string, suitable for Excel/Sheets.
-   * Includes headers and optional UTF-8 BOM.
-   * By default exports only active subcategories (set includeInactive to true to export all).
-   */
-  async exportToCsv(options?: {
-    includeInactive?: boolean;
-    includeBom?: boolean;
-  }): Promise<string> {
-    const includeInactive = options?.includeInactive ?? false;
-    const includeBom = options?.includeBom ?? true;
-
-    const headers = [
-      "id",
-      "name",
-      "categoryId",
-      "description",
-      "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: any[] = [];
-    if (!includeInactive) {
-      constraints.push(where("isActive", "==", true));
-    }
-    constraints.push(orderBy("name"));
-
-    // Page through all results using collectionGroup
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const queryConstraints: any[] = [...constraints, limit(PAGE_SIZE)];
-      if (cursor) queryConstraints.push(startAfter(cursor));
-
-      const q = query(
-        collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
-        ...queryConstraints
-      );
-      const snapshot = await getDocs(q);
-      if (snapshot.empty) break;
-
-      for (const d of snapshot.docs) {
-        // Exclude free-consultation subcategory from CSV export
-        if (d.id === EXCLUDED_SUBCATEGORY_ID) continue;
-        const subcategory = ({ id: d.id, ...d.data() } as unknown) as Subcategory;
-        rows.push(this.subcategoryToCsvRow(subcategory));
-      }
-
-      cursor = snapshot.docs[snapshot.docs.length - 1];
-      if (snapshot.size < PAGE_SIZE) break;
-    }
-
-    const csvBody = rows.join("\r\n");
-    return includeBom ? "\uFEFF" + csvBody : csvBody;
-  }
-
-  private subcategoryToCsvRow(subcategory: Subcategory): string {
-    const values = [
-      subcategory.id ?? "",
-      subcategory.name ?? "",
-      subcategory.categoryId ?? "",
-      subcategory.description ?? "",
-      String(subcategory.isActive ?? ""),
-    ];
-    return values.map((v) => this.formatCsvValue(v)).join(",");
-  }
-
-  private formatDateIso(value: any): string {
-    // Firestore timestamps may come back as Date or Timestamp; handle both
-    if (value instanceof Date) return value.toISOString();
-    if (value && typeof value.toDate === "function") {
-      const d = value.toDate();
-      return d instanceof Date ? d.toISOString() : String(value);
-    }
-    return String(value ?? "");
-  }
-
-  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,
+  collectionGroup,
+  deleteDoc,
+  doc,
+  DocumentData,
+  getCountFromServer,
+  getDoc,
+  getDocs,
+  limit,
+  orderBy,
+  query,
+  setDoc,
+  startAfter,
+  updateDoc,
+  where,
+} from "firebase/firestore";
+import {
+  Subcategory,
+  SUBCATEGORIES_COLLECTION,
+} from "../types/subcategory.types";
+import { BaseService } from "../../services/base.service";
+import { CATEGORIES_COLLECTION } from "../types/category.types";
+
+/**
+ * ID of the free-consultation subcategory that should be hidden from admin backoffice.
+ * This subcategory is used internally for free consultation procedures.
+ */
+const EXCLUDED_SUBCATEGORY_ID = 'free-consultation';
+
+/**
+ * Servis za upravljanje podkategorijama procedura.
+ * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
+ *
+ * @example
+ * const subcategoryService = new SubcategoryService();
+ *
+ * // Kreiranje nove podkategorije
+ * const subcategory = await subcategoryService.create(categoryId, {
+ *   name: "Anti-Wrinkle",
+ *   description: "Treatments targeting facial wrinkles"
+ * });
+ */
+export class SubcategoryService extends BaseService {
+  /**
+   * Filters out excluded subcategories from a list.
+   * @param subcategories - List of subcategories to filter
+   * @returns Filtered list without excluded subcategories
+   */
+  private filterExcludedSubcategories(subcategories: Subcategory[]): Subcategory[] {
+    return subcategories.filter(sub => sub.id !== EXCLUDED_SUBCATEGORY_ID);
+  }
+  /**
+   * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
+   * @param categoryId - ID roditeljske kategorije
+   */
+  private getSubcategoriesRef(categoryId: string) {
+    return collection(
+      this.db,
+      CATEGORIES_COLLECTION,
+      categoryId,
+      SUBCATEGORIES_COLLECTION
+    );
+  }
+
+  /**
+   * Kreira novu podkategoriju u okviru kategorije
+   * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
+   * @param subcategory - Podaci za novu podkategoriju
+   * @returns Kreirana podkategorija sa generisanim ID-em
+   */
+  async create(
+    categoryId: string,
+    subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">
+  ) {
+    const now = new Date();
+    const newSubcategory: Omit<Subcategory, "id"> = {
+      ...subcategory,
+      categoryId,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true,
+    };
+
+    const docRef = await addDoc(
+      this.getSubcategoriesRef(categoryId),
+      newSubcategory
+    );
+    return { id: docRef.id, ...newSubcategory };
+  }
+
+  /**
+   * 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 = collection(this.db, CATEGORIES_COLLECTION);
+    const categoriesSnapshot = await getDocs(categoriesRef);
+    const counts: Record<string, number> = {};
+
+    for (const categoryDoc of categoriesSnapshot.docs) {
+      const categoryId = categoryDoc.id;
+      const subcategoriesRef = this.getSubcategoriesRef(categoryId);
+      const q = query(subcategoriesRef, where("isActive", "==", active));
+      const snapshot = await getDocs(q);
+      // Filter out excluded subcategory and count
+      const filteredDocs = snapshot.docs.filter(doc => doc.id !== EXCLUDED_SUBCATEGORY_ID);
+      counts[categoryId] = filteredDocs.length;
+    }
+
+    return counts;
+  }
+
+  /**
+   * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
+   * @param categoryId - ID kategorije čije podkategorije tražimo
+   * @param options - Pagination options
+   * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
+   */
+  async getAllByCategoryId(
+    categoryId: string,
+    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.getSubcategoriesRef(categoryId), ...constraints);
+
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories: filteredSubcategories, 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: {
+      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(
+      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
+      ...constraints
+    );
+
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories: filteredSubcategories, 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 getAllForFilterByCategoryId(categoryId: string) {
+    const q = query(
+      this.getSubcategoriesRef(categoryId),
+      where("isActive", "==", true)
+    );
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    return this.filterExcludedSubcategories(subcategories);
+  }
+
+  /**
+   * Vraća sve subkategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih subkategorija
+   */
+  async getAllForFilter() {
+    const q = query(
+      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
+      where("isActive", "==", true)
+    );
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    return this.filterExcludedSubcategories(subcategories);
+  }
+
+  /**
+   * Ažurira postojeću podkategoriju
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID podkategorije koja se ažurira
+   * @param subcategory - Novi podaci za podkategoriju
+   * @returns Ažurirana podkategorija
+   */
+  async update(
+    categoryId: string,
+    subcategoryId: string,
+    subcategory: Partial<Omit<Subcategory, "id" | "createdAt">>
+  ) {
+    const newCategoryId = subcategory.categoryId;
+
+    if (newCategoryId && newCategoryId !== categoryId) {
+      // Category has changed, move the document
+      const oldDocRef = doc(
+        this.getSubcategoriesRef(categoryId),
+        subcategoryId
+      );
+      const docSnap = await getDoc(oldDocRef);
+
+      if (!docSnap.exists()) {
+        throw new Error("Subcategory to update does not exist.");
+      }
+
+      const existingData = docSnap.data();
+      const newData: Omit<Subcategory, "id"> = {
+        ...(existingData as Omit<
+          Subcategory,
+          "id" | "createdAt" | "updatedAt"
+        >),
+        ...subcategory,
+        categoryId: newCategoryId, // Ensure categoryId is updated
+        createdAt: existingData.createdAt, // Preserve original creation date
+        updatedAt: new Date(),
+      };
+
+      const newDocRef = doc(
+        this.getSubcategoriesRef(newCategoryId),
+        subcategoryId
+      );
+
+      await setDoc(newDocRef, newData);
+      await deleteDoc(oldDocRef);
+
+      return { id: subcategoryId, ...newData };
+    } else {
+      // Category has not changed, just update the document
+      const updateData = {
+        ...subcategory,
+        updatedAt: new Date(),
+      };
+
+      const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
+      await updateDoc(docRef, updateData);
+      return this.getById(categoryId, subcategoryId);
+    }
+  }
+
+  /**
+   * Soft delete podkategorije (postavlja isActive na false)
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID podkategorije koja se briše
+   */
+  async delete(categoryId: string, subcategoryId: string) {
+    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: string, subcategoryId: string) {
+    await this.update(categoryId, subcategoryId, { isActive: true });
+  }
+
+  /**
+   * Vraća podkategoriju po ID-u
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID tražene podkategorije
+   * @returns Podkategorija ili null ako ne postoji
+   */
+  async getById(categoryId: string, subcategoryId: string) {
+    // Prevent access to excluded subcategory
+    if (subcategoryId === EXCLUDED_SUBCATEGORY_ID) return null;
+    
+    const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data(),
+    } as Subcategory;
+  }
+
+  /**
+   * Internal method to get subcategory by ID without filtering.
+   * Used internally for consultation procedures.
+   * @param categoryId - ID of the category
+   * @param subcategoryId - ID of the subcategory to get
+   * @returns Subcategory or null if not found
+   */
+  async getByIdInternal(categoryId: string, subcategoryId: string): Promise<Subcategory | null> {
+    const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data(),
+    } as Subcategory;
+  }
+
+  /**
+   * Finds a subcategory by exact name match within a specific category.
+   * Used for CSV import matching.
+   * @param name - Exact name of the subcategory to find
+   * @param categoryId - ID of the category to search within
+   * @returns Subcategory if found, null otherwise
+   */
+  async findByNameAndCategory(name: string, categoryId: string): Promise<Subcategory | null> {
+    const q = query(
+      this.getSubcategoriesRef(categoryId),
+      where('name', '==', name),
+      where('isActive', '==', true),
+    );
+    const querySnapshot = await getDocs(q);
+    if (querySnapshot.empty) return null;
+    const doc = querySnapshot.docs[0];
+    // Exclude free-consultation subcategory
+    if (doc.id === EXCLUDED_SUBCATEGORY_ID) return null;
+    return {
+      id: doc.id,
+      ...doc.data(),
+    } as Subcategory;
+  }
+
+  /**
+   * Exports subcategories to CSV string, suitable for Excel/Sheets.
+   * Includes headers and optional UTF-8 BOM.
+   * By default exports only active subcategories (set includeInactive to true to export all).
+   */
+  async exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string> {
+    const includeInactive = options?.includeInactive ?? false;
+    const includeBom = options?.includeBom ?? true;
+
+    const headers = [
+      "id",
+      "name",
+      "categoryId",
+      "description",
+      "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: any[] = [];
+    if (!includeInactive) {
+      constraints.push(where("isActive", "==", true));
+    }
+    constraints.push(orderBy("name"));
+
+    // Page through all results using collectionGroup
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const queryConstraints: any[] = [...constraints, limit(PAGE_SIZE)];
+      if (cursor) queryConstraints.push(startAfter(cursor));
+
+      const q = query(
+        collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
+        ...queryConstraints
+      );
+      const snapshot = await getDocs(q);
+      if (snapshot.empty) break;
+
+      for (const d of snapshot.docs) {
+        // Exclude free-consultation subcategory from CSV export
+        if (d.id === EXCLUDED_SUBCATEGORY_ID) continue;
+        const subcategory = ({ id: d.id, ...d.data() } as unknown) as Subcategory;
+        rows.push(this.subcategoryToCsvRow(subcategory));
+      }
+
+      cursor = snapshot.docs[snapshot.docs.length - 1];
+      if (snapshot.size < PAGE_SIZE) break;
+    }
+
+    const csvBody = rows.join("\r\n");
+    return includeBom ? "\uFEFF" + csvBody : csvBody;
+  }
+
+  private subcategoryToCsvRow(subcategory: Subcategory): string {
+    const values = [
+      subcategory.id ?? "",
+      subcategory.name ?? "",
+      subcategory.categoryId ?? "",
+      subcategory.description ?? "",
+      String(subcategory.isActive ?? ""),
+    ];
+    return values.map((v) => this.formatCsvValue(v)).join(",");
+  }
+
+  private formatDateIso(value: any): string {
+    // Firestore timestamps may come back as Date or Timestamp; handle both
+    if (value instanceof Date) return value.toISOString();
+    if (value && typeof value.toDate === "function") {
+      const d = value.toDate();
+      return d instanceof Date ? d.toISOString() : String(value);
+    }
+    return String(value ?? "");
+  }
+
+  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}"`;
+  }
+}