@blackcode_sa/metaestetics-api 1.12.2 → 1.12.3

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

@@ -15,23 +15,20 @@ import {
   arrayUnion,
   arrayRemove,
   Firestore,
-} from "firebase/firestore";
-import { Technology, TECHNOLOGIES_COLLECTION } from "../types/technology.types";
-import { Requirement, RequirementType } from "../types/requirement.types";
-import { BlockingCondition } from "../types/static/blocking-condition.types";
-import { ContraindicationDynamic } from "../types/admin-constants.types";
-import { TreatmentBenefitDynamic } from "../types/admin-constants.types";
+} from 'firebase/firestore';
+import { Technology, TECHNOLOGIES_COLLECTION, ITechnologyService } from '../types/technology.types';
+import { Requirement, RequirementType } from '../types/requirement.types';
+import { BlockingCondition } from '../types/static/blocking-condition.types';
+import { ContraindicationDynamic } from '../types/admin-constants.types';
+import { TreatmentBenefitDynamic } from '../types/admin-constants.types';
 import {
   CertificationLevel,
   CertificationSpecialty,
   CertificationRequirement,
-} from "../types/static/certification.types";
-import { BaseService } from "../../services/base.service";
-import { ProcedureFamily } from "../types/static/procedure-family.types";
-import {
-  Practitioner,
-  PractitionerCertification,
-} from "../../types/practitioner";
+} from '../types/static/certification.types';
+import { BaseService } from '../../services/base.service';
+import { ProcedureFamily } from '../types/static/procedure-family.types';
+import { Practitioner, PractitionerCertification } from '../../types/practitioner';
 
 /**
  * Default vrednosti za sertifikaciju
@@ -44,7 +41,7 @@ const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
 /**
  * Service for managing technologies.
  */
-export class TechnologyService extends BaseService {
+export class TechnologyService extends BaseService implements ITechnologyService {
   /**
    * Reference to the Firestore collection of technologies.
    */
@@ -57,10 +54,10 @@ export class TechnologyService extends BaseService {
    * @param technology - Data for the new technology.
    * @returns The created technology with its generated ID.
    */
-  async create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">) {
+  async create(technology: Omit<Technology, 'id' | 'createdAt' | 'updatedAt'>) {
     const now = new Date();
     // Explicitly construct the object to ensure no undefined values are passed.
-    const newTechnology: Omit<Technology, "id"> = {
+    const newTechnology: Omit<Technology, 'id'> = {
       name: technology.name,
       description: technology.description,
       family: technology.family,
@@ -71,8 +68,7 @@ export class TechnologyService extends BaseService {
       contraindications: technology.contraindications || [],
       benefits: technology.benefits || [],
       certificationRequirement:
-        technology.certificationRequirement ||
-        DEFAULT_CERTIFICATION_REQUIREMENT,
+        technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT,
       documentationTemplates: technology.documentationTemplates || [],
       isActive: true,
       createdAt: now,
@@ -94,10 +90,10 @@ export class TechnologyService extends BaseService {
    * @returns A record mapping subcategory ID to technology count.
    */
   async getTechnologyCounts(active = true) {
-    const q = query(this.technologiesRef, where("isActive", "==", active));
+    const q = query(this.technologiesRef, where('isActive', '==', active));
     const snapshot = await getDocs(q);
     const counts: Record<string, number> = {};
-    snapshot.docs.forEach((doc) => {
+    snapshot.docs.forEach(doc => {
       const tech = doc.data() as Technology;
       counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
     });
@@ -110,10 +106,10 @@ export class TechnologyService extends BaseService {
    * @returns A record mapping category ID to technology count.
    */
   async getTechnologyCountsByCategory(active = true) {
-    const q = query(this.technologiesRef, where("isActive", "==", active));
+    const q = query(this.technologiesRef, where('isActive', '==', active));
     const snapshot = await getDocs(q);
     const counts: Record<string, number> = {};
-    snapshot.docs.forEach((doc) => {
+    snapshot.docs.forEach(doc => {
       const tech = doc.data() as Technology;
       counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
     });
@@ -130,12 +126,12 @@ export class TechnologyService extends BaseService {
       active?: boolean;
       limit?: number;
       lastVisible?: DocumentData;
-    } = {}
+    } = {},
   ) {
     const { active = true, limit: queryLimit = 10, lastVisible } = options;
     const constraints = [
-      where("isActive", "==", active),
-      orderBy("name"),
+      where('isActive', '==', active),
+      orderBy('name'),
       queryLimit ? limit(queryLimit) : undefined,
       lastVisible ? startAfter(lastVisible) : undefined,
     ].filter((c): c is NonNullable<typeof c> => !!c);
@@ -143,11 +139,11 @@ export class TechnologyService extends BaseService {
     const q = query(this.technologiesRef, ...constraints);
     const snapshot = await getDocs(q);
     const technologies = snapshot.docs.map(
-      (doc) =>
+      doc =>
         ({
           id: doc.id,
           ...doc.data(),
-        } as Technology)
+        } as Technology),
     );
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
     return { technologies, lastVisible: newLastVisible };
@@ -165,13 +161,13 @@ export class TechnologyService extends BaseService {
       active?: boolean;
       limit?: number;
       lastVisible?: DocumentData;
-    } = {}
+    } = {},
   ) {
     const { active = true, limit: queryLimit = 10, lastVisible } = options;
     const constraints = [
-      where("categoryId", "==", categoryId),
-      where("isActive", "==", active),
-      orderBy("name"),
+      where('categoryId', '==', categoryId),
+      where('isActive', '==', active),
+      orderBy('name'),
       queryLimit ? limit(queryLimit) : undefined,
       lastVisible ? startAfter(lastVisible) : undefined,
     ].filter((c): c is NonNullable<typeof c> => !!c);
@@ -179,11 +175,11 @@ export class TechnologyService extends BaseService {
     const q = query(this.technologiesRef, ...constraints);
     const snapshot = await getDocs(q);
     const technologies = snapshot.docs.map(
-      (doc) =>
+      doc =>
         ({
           id: doc.id,
           ...doc.data(),
-        } as Technology)
+        } as Technology),
     );
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
     return { technologies, lastVisible: newLastVisible };
@@ -201,13 +197,13 @@ export class TechnologyService extends BaseService {
       active?: boolean;
       limit?: number;
       lastVisible?: DocumentData;
-    } = {}
+    } = {},
   ) {
     const { active = true, limit: queryLimit = 10, lastVisible } = options;
     const constraints = [
-      where("subcategoryId", "==", subcategoryId),
-      where("isActive", "==", active),
-      orderBy("name"),
+      where('subcategoryId', '==', subcategoryId),
+      where('isActive', '==', active),
+      orderBy('name'),
       queryLimit ? limit(queryLimit) : undefined,
       lastVisible ? startAfter(lastVisible) : undefined,
     ].filter((c): c is NonNullable<typeof c> => !!c);
@@ -215,11 +211,11 @@ export class TechnologyService extends BaseService {
     const q = query(this.technologiesRef, ...constraints);
     const snapshot = await getDocs(q);
     const technologies = snapshot.docs.map(
-      (doc) =>
+      doc =>
         ({
           id: doc.id,
           ...doc.data(),
-        } as Technology)
+        } as Technology),
     );
     const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
     return { technologies, lastVisible: newLastVisible };
@@ -231,14 +227,11 @@ export class TechnologyService extends BaseService {
    * @param technology - New data for the technology.
    * @returns The updated technology.
    */
-  async update(
-    id: string,
-    technology: Partial<Omit<Technology, "id" | "createdAt">>
-  ) {
+  async update(id: string, technology: Partial<Omit<Technology, 'id' | 'createdAt'>>) {
     const updateData: { [key: string]: any } = { ...technology };
 
     // Remove undefined fields to prevent Firestore errors
-    Object.keys(updateData).forEach((key) => {
+    Object.keys(updateData).forEach(key => {
       if (updateData[key] === undefined) {
         delete updateData[key];
       }
@@ -291,8 +284,7 @@ export class TechnologyService extends BaseService {
   async addRequirement(technologyId: string, requirement: Requirement) {
     const docRef = doc(this.technologiesRef, technologyId);
 
-    const requirementType =
-      requirement.type === "pre" ? "requirements.pre" : "requirements.post";
+    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
 
     await updateDoc(docRef, {
       [requirementType]: arrayUnion(requirement),
@@ -311,8 +303,7 @@ export class TechnologyService extends BaseService {
   async removeRequirement(technologyId: string, requirement: Requirement) {
     const docRef = doc(this.technologiesRef, technologyId);
 
-    const requirementType =
-      requirement.type === "pre" ? "requirements.pre" : "requirements.post";
+    const requirementType = requirement.type === 'pre' ? 'requirements.pre' : 'requirements.post';
 
     await updateDoc(docRef, {
       [requirementType]: arrayRemove(requirement),
@@ -349,7 +340,7 @@ export class TechnologyService extends BaseService {
   async updateRequirement(
     technologyId: string,
     oldRequirement: Requirement,
-    newRequirement: Requirement
+    newRequirement: Requirement,
   ) {
     await this.removeRequirement(technologyId, oldRequirement);
     return this.addRequirement(technologyId, newRequirement);
@@ -361,10 +352,7 @@ export class TechnologyService extends BaseService {
    * @param condition - Blokirajući uslov koji se dodaje
    * @returns Ažurirana tehnologija
    */
-  async addBlockingCondition(
-    technologyId: string,
-    condition: BlockingCondition
-  ) {
+  async addBlockingCondition(technologyId: string, condition: BlockingCondition) {
     const docRef = doc(this.technologiesRef, technologyId);
 
     await updateDoc(docRef, {
@@ -381,10 +369,7 @@ export class TechnologyService extends BaseService {
    * @param condition - Blokirajući uslov koji se uklanja
    * @returns Ažurirana tehnologija
    */
-  async removeBlockingCondition(
-    technologyId: string,
-    condition: BlockingCondition
-  ) {
+  async removeBlockingCondition(technologyId: string, condition: BlockingCondition) {
     const docRef = doc(this.technologiesRef, technologyId);
 
     await updateDoc(docRef, {
@@ -401,10 +386,7 @@ export class TechnologyService extends BaseService {
    * @param contraindication - Kontraindikacija koja se dodaje
    * @returns Ažurirana tehnologija
    */
-  async addContraindication(
-    technologyId: string,
-    contraindication: ContraindicationDynamic
-  ) {
+  async addContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
     const docRef = doc(this.technologiesRef, technologyId);
     const technology = await this.getById(technologyId);
     if (!technology) {
@@ -412,7 +394,7 @@ export class TechnologyService extends BaseService {
     }
 
     const existingContraindications = technology.contraindications || [];
-    if (existingContraindications.some((c) => c.id === contraindication.id)) {
+    if (existingContraindications.some(c => c.id === contraindication.id)) {
       return technology; // Already exists, do nothing
     }
 
@@ -430,19 +412,16 @@ export class TechnologyService extends BaseService {
    * @param contraindication - Kontraindikacija koja se uklanja
    * @returns Ažurirana tehnologija
    */
-  async removeContraindication(
-    technologyId: string,
-    contraindication: ContraindicationDynamic
-  ) {
+  async removeContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
     const docRef = doc(this.technologiesRef, technologyId);
     const technology = await this.getById(technologyId);
     if (!technology) {
       throw new Error(`Technology with id ${technologyId} not found`);
     }
 
-    const updatedContraindications = (
-      technology.contraindications || []
-    ).filter((c) => c.id !== contraindication.id);
+    const updatedContraindications = (technology.contraindications || []).filter(
+      c => c.id !== contraindication.id,
+    );
 
     await updateDoc(docRef, {
       contraindications: updatedContraindications,
@@ -459,10 +438,7 @@ export class TechnologyService extends BaseService {
    * @param contraindication - The updated contraindication object
    * @returns The updated technology
    */
-  async updateContraindication(
-    technologyId: string,
-    contraindication: ContraindicationDynamic
-  ) {
+  async updateContraindication(technologyId: string, contraindication: ContraindicationDynamic) {
     const docRef = doc(this.technologiesRef, technologyId);
     const technology = await this.getById(technologyId);
     if (!technology) {
@@ -470,15 +446,13 @@ export class TechnologyService extends BaseService {
     }
 
     const contraindications = technology.contraindications || [];
-    const index = contraindications.findIndex(
-      (c) => c.id === contraindication.id
-    );
+    const index = contraindications.findIndex(c => c.id === contraindication.id);
 
     if (index === -1) {
       // If contraindication doesn't exist, do not update
       // Consider throwing an error if this is an unexpected state
       console.warn(
-        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`,
       );
       return technology;
     }
@@ -508,7 +482,7 @@ export class TechnologyService extends BaseService {
     }
 
     const existingBenefits = technology.benefits || [];
-    if (existingBenefits.some((b) => b.id === benefit.id)) {
+    if (existingBenefits.some(b => b.id === benefit.id)) {
       return technology; // Already exists, do nothing
     }
 
@@ -533,9 +507,7 @@ export class TechnologyService extends BaseService {
       throw new Error(`Technology with id ${technologyId} not found`);
     }
 
-    const updatedBenefits = (technology.benefits || []).filter(
-      (b) => b.id !== benefit.id
-    );
+    const updatedBenefits = (technology.benefits || []).filter(b => b.id !== benefit.id);
 
     await updateDoc(docRef, {
       benefits: updatedBenefits,
@@ -560,12 +532,12 @@ export class TechnologyService extends BaseService {
     }
 
     const benefits = technology.benefits || [];
-    const index = benefits.findIndex((b) => b.id === benefit.id);
+    const index = benefits.findIndex(b => b.id === benefit.id);
 
     if (index === -1) {
       // If benefit doesn't exist, do not update
       console.warn(
-        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`,
       );
       return technology;
     }
@@ -619,7 +591,7 @@ export class TechnologyService extends BaseService {
    */
   async updateCertificationRequirement(
     technologyId: string,
-    certificationRequirement: CertificationRequirement
+    certificationRequirement: CertificationRequirement,
   ) {
     const docRef = doc(this.technologiesRef, technologyId);
 
@@ -637,7 +609,7 @@ export class TechnologyService extends BaseService {
    * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
    */
   async getCertificationRequirement(
-    technologyId: string
+    technologyId: string,
   ): Promise<CertificationRequirement | null> {
     const technology = await this.getById(technologyId);
     return technology?.certificationRequirement || null;
@@ -664,15 +636,13 @@ export class TechnologyService extends BaseService {
    */
   validateCertification(
     requiredCertification: CertificationRequirement,
-    practitionerCertification: PractitionerCertification
+    practitionerCertification: PractitionerCertification,
   ): boolean {
     // Provera nivoa sertifikacije
     // Enum je definisan od najnižeg ka najvišem, pa možemo porediti brojeve
-    const doctorLevel = Object.values(CertificationLevel).indexOf(
-      practitionerCertification.level
-    );
+    const doctorLevel = Object.values(CertificationLevel).indexOf(practitionerCertification.level);
     const requiredLevel = Object.values(CertificationLevel).indexOf(
-      requiredCertification.minimumLevel
+      requiredCertification.minimumLevel,
     );
 
     // Doktor mora imati nivo koji je jednak ili viši od zahtevanog
@@ -683,8 +653,8 @@ export class TechnologyService extends BaseService {
     if (requiredSpecialties.length > 0) {
       // Doktor mora imati sve zahtevane specijalizacije
       const doctorSpecialties = practitionerCertification.specialties;
-      const hasAllRequiredSpecialties = requiredSpecialties.every(
-        (requiredSpecialty) => doctorSpecialties.includes(requiredSpecialty)
+      const hasAllRequiredSpecialties = requiredSpecialties.every(requiredSpecialty =>
+        doctorSpecialties.includes(requiredSpecialty),
       );
 
       if (!hasAllRequiredSpecialties) return false;
@@ -726,22 +696,14 @@ export class TechnologyService extends BaseService {
     const allTechnologies = await this.getAll();
 
     // Filter technologies based on certification requirements
-    const allowedTechnologies = allTechnologies.technologies.filter(
-      (technology) =>
-        this.validateCertification(
-          technology.certificationRequirement,
-          practitioner.certification
-        )
+    const allowedTechnologies = allTechnologies.technologies.filter(technology =>
+      this.validateCertification(technology.certificationRequirement, practitioner.certification),
     );
 
     // Extract unique families, categories, and subcategories
-    const families = [...new Set(allowedTechnologies.map((t) => t.family))];
-    const categories = [
-      ...new Set(allowedTechnologies.map((t) => t.categoryId)),
-    ];
-    const subcategories = [
-      ...new Set(allowedTechnologies.map((t) => t.subcategoryId)),
-    ];
+    const families = [...new Set(allowedTechnologies.map(t => t.family))];
+    const categories = [...new Set(allowedTechnologies.map(t => t.categoryId))];
+    const subcategories = [...new Set(allowedTechnologies.map(t => t.subcategoryId))];
 
     return {
       technologies: allowedTechnologies,
@@ -751,6 +713,27 @@ export class TechnologyService extends BaseService {
     };
   }
 
+  /**
+   * Gets all active technologies for a subcategory for filter dropdowns (by subcategory only).
+   * @param subcategoryId - The ID of the subcategory.
+   */
+  async getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where('isActive', '==', true),
+      where('subcategoryId', '==', subcategoryId),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology),
+    );
+  }
+
   /**
    * Gets all active technologies for a subcategory for filter dropdowns.
    * @param categoryId - The ID of the parent category.
@@ -758,22 +741,22 @@ export class TechnologyService extends BaseService {
    */
   async getAllForFilterBySubcategoryId(
     categoryId: string,
-    subcategoryId: string
+    subcategoryId: string,
   ): Promise<Technology[]> {
     const q = query(
       collection(this.db, TECHNOLOGIES_COLLECTION),
-      where("isActive", "==", true),
-      where("categoryId", "==", categoryId),
-      where("subcategoryId", "==", subcategoryId),
-      orderBy("name")
+      where('isActive', '==', true),
+      where('categoryId', '==', categoryId),
+      where('subcategoryId', '==', subcategoryId),
+      orderBy('name'),
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map(
-      (doc) =>
+      doc =>
         ({
           id: doc.id,
           ...doc.data(),
-        } as Technology)
+        } as Technology),
     );
   }
 
@@ -783,16 +766,16 @@ export class TechnologyService extends BaseService {
   async getAllForFilter(): Promise<Technology[]> {
     const q = query(
       collection(this.db, TECHNOLOGIES_COLLECTION),
-      where("isActive", "==", true),
-      orderBy("name")
+      where('isActive', '==', true),
+      orderBy('name'),
     );
     const snapshot = await getDocs(q);
     return snapshot.docs.map(
-      (doc) =>
+      doc =>
         ({
           id: doc.id,
           ...doc.data(),
-        } as Technology)
+        } as Technology),
     );
   }
 }

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

@@ -1,4 +1,4 @@
-import { ProcedureFamily } from "./static/procedure-family.types";
+import { ProcedureFamily } from './static/procedure-family.types';
 
 /**
  * Kategorija procedura
@@ -33,4 +33,30 @@ export interface Category {
 /**
  * Kolekcija u Firestore bazi gde se čuvaju kategorije
  */
-export const CATEGORIES_COLLECTION = "backoffice_categories";
+export const CATEGORIES_COLLECTION = 'backoffice_categories';
+
+/**
+ * Interface for the CategoryService class
+ */
+export interface ICategoryService {
+  create(category: Omit<Category, 'id' | 'createdAt' | 'updatedAt'>): Promise<Category>;
+  getCategoryCounts(active?: boolean): Promise<Record<string, number>>;
+  getAllForFilter(): Promise<Category[]>;
+  getAllForFilterByFamily(family: ProcedureFamily): Promise<Category[]>;
+  getAll(options?: {
+    active?: boolean;
+    limit?: number;
+    lastVisible?: any;
+  }): Promise<{ categories: Category[]; lastVisible: any }>;
+  getAllByFamily(
+    family: ProcedureFamily,
+    options?: { active?: boolean; limit?: number; lastVisible?: any },
+  ): Promise<{ categories: Category[]; lastVisible: any }>;
+  update(
+    id: string,
+    category: Partial<Omit<Category, 'id' | 'createdAt'>>,
+  ): Promise<Category | null>;
+  delete(id: string): Promise<void>;
+  reactivate(id: string): Promise<void>;
+  getById(id: string): Promise<Category | null>;
+}

package/src/backoffice/types/product.types.ts

@@ -1,4 +1,4 @@
-import type { ContraindicationDynamic } from "./admin-constants.types";
+import type { ContraindicationDynamic } from './admin-constants.types';
 
 /**
  * Product used in procedures
@@ -43,7 +43,7 @@ export interface Product {
 /**
  * Collection in Firestore database where products are stored
  */
-export const PRODUCTS_COLLECTION = "products";
+export const PRODUCTS_COLLECTION = 'products';
 
 /**
  * Interface for the ProductService class
@@ -58,10 +58,7 @@ export interface IProductService {
   create(
     technologyId: string,
     brandId: string,
-    product: Omit<
-      Product,
-      "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId"
-    >
+    product: Omit<Product, 'id' | 'createdAt' | 'updatedAt' | 'brandId' | 'technologyId'>,
   ): Promise<Product>;
 
   /**
@@ -93,6 +90,12 @@ export interface IProductService {
     byTechnology: Record<string, number>;
   }>;
 
+  /**
+   * Gets all products for a specific technology (non-paginated, for filters/dropdowns)
+   * @param technologyId - ID of the technology
+   */
+  getAllByTechnology(technologyId: string): Promise<Product[]>;
+
   /**
    * Gets all products for a brand
    * @param brandId - ID of the brand
@@ -108,9 +111,7 @@ export interface IProductService {
   update(
     technologyId: string,
     productId: string,
-    product: Partial<
-      Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">
-    >
+    product: Partial<Omit<Product, 'id' | 'createdAt' | 'brandId' | 'technologyId'>>,
   ): Promise<Product | null>;
 
   /**