@blackcode_sa/metaestetics-api 1.12.66 → 1.12.68

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

@@ -23,6 +23,12 @@ import {
 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.
@@ -37,6 +43,14 @@ import { CATEGORIES_COLLECTION } from "../types/category.types";
  * });
  */
 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
@@ -90,8 +104,10 @@ export class SubcategoryService extends BaseService {
       const categoryId = categoryDoc.id;
       const subcategoriesRef = this.getSubcategoriesRef(categoryId);
       const q = query(subcategoriesRef, where("isActive", "==", active));
-      const snapshot = await getCountFromServer(q);
-      counts[categoryId] = snapshot.data().count;
+      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;
@@ -129,8 +145,9 @@ export class SubcategoryService extends BaseService {
           ...doc.data(),
         } as Subcategory)
     );
+    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
     const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
-    return { subcategories, lastVisible: newLastVisible };
+    return { subcategories: filteredSubcategories, lastVisible: newLastVisible };
   }
 
   /**
@@ -169,8 +186,9 @@ export class SubcategoryService extends BaseService {
           ...doc.data(),
         } as Subcategory)
     );
+    const filteredSubcategories = this.filterExcludedSubcategories(subcategories);
     const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
-    return { subcategories, lastVisible: newLastVisible };
+    return { subcategories: filteredSubcategories, lastVisible: newLastVisible };
   }
 
   /**
@@ -184,13 +202,14 @@ export class SubcategoryService extends BaseService {
       where("isActive", "==", true)
     );
     const querySnapshot = await getDocs(q);
-    return querySnapshot.docs.map(
+    const subcategories = querySnapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Subcategory)
     );
+    return this.filterExcludedSubcategories(subcategories);
   }
 
   /**
@@ -203,13 +222,14 @@ export class SubcategoryService extends BaseService {
       where("isActive", "==", true)
     );
     const querySnapshot = await getDocs(q);
-    return querySnapshot.docs.map(
+    const subcategories = querySnapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Subcategory)
     );
+    return this.filterExcludedSubcategories(subcategories);
   }
 
   /**
@@ -297,6 +317,26 @@ export class SubcategoryService extends BaseService {
    * @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;
@@ -306,6 +346,30 @@ export class SubcategoryService extends BaseService {
     } 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.
@@ -353,6 +417,8 @@ export class SubcategoryService extends BaseService {
       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));
       }

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

@@ -33,6 +33,12 @@ import { ProcedureFamily } from '../types/static/procedure-family.types';
 import { Practitioner, PractitionerCertification } from '../../types/practitioner';
 import { Product, PRODUCTS_COLLECTION } from '../types/product.types';
 
+/**
+ * ID of the free-consultation-tech technology that should be hidden from admin backoffice.
+ * This technology is used internally for free consultation procedures.
+ */
+const EXCLUDED_TECHNOLOGY_ID = 'free-consultation-tech';
+
 /**
  * Default vrednosti za sertifikaciju
  */
@@ -45,6 +51,14 @@ const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
  * Service for managing technologies.
  */
 export class TechnologyService extends BaseService implements ITechnologyService {
+  /**
+   * Filters out excluded technologies from a list.
+   * @param technologies - List of technologies to filter
+   * @returns Filtered list without excluded technologies
+   */
+  private filterExcludedTechnologies(technologies: Technology[]): Technology[] {
+    return technologies.filter(tech => tech.id !== EXCLUDED_TECHNOLOGY_ID);
+  }
   /**
    * Reference to the Firestore collection of technologies.
    */
@@ -100,6 +114,8 @@ export class TechnologyService extends BaseService implements ITechnologyService
     const snapshot = await getDocs(q);
     const counts: Record<string, number> = {};
     snapshot.docs.forEach(doc => {
+      // Exclude free-consultation-tech from counts
+      if (doc.id === EXCLUDED_TECHNOLOGY_ID) return;
       const tech = doc.data() as Technology;
       counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
     });
@@ -116,6 +132,8 @@ export class TechnologyService extends BaseService implements ITechnologyService
     const snapshot = await getDocs(q);
     const counts: Record<string, number> = {};
     snapshot.docs.forEach(doc => {
+      // Exclude free-consultation-tech from counts
+      if (doc.id === EXCLUDED_TECHNOLOGY_ID) return;
       const tech = doc.data() as Technology;
       counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
     });
@@ -151,8 +169,9 @@ export class TechnologyService extends BaseService implements ITechnologyService
           ...doc.data(),
         } as Technology),
     );
+    const filteredTechnologies = this.filterExcludedTechnologies(technologies);
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
+    return { technologies: filteredTechnologies, lastVisible: newLastVisible };
   }
 
   /**
@@ -187,8 +206,9 @@ export class TechnologyService extends BaseService implements ITechnologyService
           ...doc.data(),
         } as Technology),
     );
+    const filteredTechnologies = this.filterExcludedTechnologies(technologies);
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
+    return { technologies: filteredTechnologies, lastVisible: newLastVisible };
   }
 
   /**
@@ -223,8 +243,9 @@ export class TechnologyService extends BaseService implements ITechnologyService
           ...doc.data(),
         } as Technology),
     );
+    const filteredTechnologies = this.filterExcludedTechnologies(technologies);
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
-    return { technologies, lastVisible: newLastVisible };
+    return { technologies: filteredTechnologies, lastVisible: newLastVisible };
   }
 
   /**
@@ -300,6 +321,25 @@ export class TechnologyService extends BaseService implements ITechnologyService
    * @returns The technology or null if it doesn't exist.
    */
   async getById(id: string): Promise<Technology | null> {
+    // Prevent access to excluded technology
+    if (id === EXCLUDED_TECHNOLOGY_ID) return null;
+    
+    const docRef = doc(this.technologiesRef, id);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data(),
+    } as Technology;
+  }
+
+  /**
+   * Internal method to get technology by ID without filtering.
+   * Used internally for consultation procedures.
+   * @param id - The ID of the requested technology
+   * @returns The technology or null if it doesn't exist
+   */
+  async getByIdInternal(id: string): Promise<Technology | null> {
     const docRef = doc(this.technologiesRef, id);
     const docSnap = await getDoc(docRef);
     if (!docSnap.exists()) return null;
@@ -309,6 +349,29 @@ export class TechnologyService extends BaseService implements ITechnologyService
     } as Technology;
   }
 
+  /**
+   * Finds a technology by exact name match.
+   * Used for CSV import duplicate detection.
+   * @param name - Exact name of the technology to find
+   * @returns Technology if found, null otherwise
+   */
+  async findByName(name: string): Promise<Technology | null> {
+    const q = query(
+      this.technologiesRef,
+      where('name', '==', name),
+      where('isActive', '==', true),
+    );
+    const snapshot = await getDocs(q);
+    if (snapshot.empty) return null;
+    const doc = snapshot.docs[0];
+    // Exclude free-consultation-tech
+    if (doc.id === EXCLUDED_TECHNOLOGY_ID) return null;
+    return {
+      id: doc.id,
+      ...doc.data(),
+    } as Technology;
+  }
+
   /**
    * Dodaje novi zahtev tehnologiji
    * @param technologyId - ID tehnologije
@@ -759,13 +822,14 @@ export class TechnologyService extends BaseService implements ITechnologyService
       orderBy('name'),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const technologies = snapshot.docs.map(
       doc =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology),
     );
+    return this.filterExcludedTechnologies(technologies);
   }
 
   /**
@@ -785,13 +849,14 @@ export class TechnologyService extends BaseService implements ITechnologyService
       orderBy('name'),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const technologies = snapshot.docs.map(
       doc =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology),
     );
+    return this.filterExcludedTechnologies(technologies);
   }
 
   /**
@@ -804,13 +869,14 @@ export class TechnologyService extends BaseService implements ITechnologyService
       orderBy('name'),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const technologies = snapshot.docs.map(
       doc =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology),
     );
+    return this.filterExcludedTechnologies(technologies);
   }
 
   // ==========================================
@@ -1019,6 +1085,8 @@ export class TechnologyService extends BaseService implements ITechnologyService
       if (snapshot.empty) break;
 
       for (const d of snapshot.docs) {
+        // Exclude free-consultation-tech from CSV export
+        if (d.id === EXCLUDED_TECHNOLOGY_ID) continue;
         const technology = ({ id: d.id, ...d.data() } as unknown) as Technology;
         // Fetch products for this technology
         const productNames = await this.getProductNamesForTechnology(technology.id!);

package/src/backoffice/types/category.types.ts

@@ -59,4 +59,9 @@ export interface ICategoryService {
   delete(id: string): Promise<void>;
   reactivate(id: string): Promise<void>;
   getById(id: string): Promise<Category | null>;
+  findByNameAndFamily(name: string, family: ProcedureFamily): Promise<Category | null>;
+  exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string>;
 }

package/src/backoffice/types/technology.types.ts

@@ -160,4 +160,9 @@ export interface ITechnologyService {
   getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]>;
   getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
   getAllForFilter(): Promise<Technology[]>;
+  findByName(name: string): Promise<Technology | null>;
+  exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string>;
 }

package/src/services/procedure/procedure.service.ts

@@ -1497,9 +1497,9 @@ export class ProcedureService extends BaseService {
     // Get references to related entities (Category, Subcategory, Technology)
     // For consultation, we don't need a product
     const [category, subcategory, technology] = await Promise.all([
-      this.categoryService.getById(data.categoryId),
-      this.subcategoryService.getById(data.categoryId, data.subcategoryId),
-      this.technologyService.getById(data.technologyId),
+      this.categoryService.getByIdInternal(data.categoryId),
+      this.subcategoryService.getByIdInternal(data.categoryId, data.subcategoryId),
+      this.technologyService.getByIdInternal(data.technologyId),
     ]);
 
     if (!category || !subcategory || !technology) {