@blackcode_sa/metaestetics-api 1.11.3 → 1.12.0

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

@@ -2,9 +2,14 @@ import {
   addDoc,
   collection,
   doc,
+  DocumentData,
+  getCountFromServer,
   getDoc,
   getDocs,
+  limit,
+  orderBy,
   query,
+  startAfter,
   updateDoc,
   where,
   arrayUnion,
@@ -14,8 +19,8 @@ import {
 import { Technology, TECHNOLOGIES_COLLECTION } from "../types/technology.types";
 import { Requirement, RequirementType } from "../types/requirement.types";
 import { BlockingCondition } from "../types/static/blocking-condition.types";
-import { Contraindication } from "../types/static/contraindication.types";
-import { TreatmentBenefit } from "../types/static/treatment-benefit.types";
+import { ContraindicationDynamic } from "../types/admin-constants.types";
+import { TreatmentBenefitDynamic } from "../types/admin-constants.types";
 import {
   CertificationLevel,
   CertificationSpecialty,
@@ -37,186 +42,238 @@ const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement = {
 };
 
 /**
- * Servis za upravljanje tehnologijama i njihovim zahtevima.
- * Tehnologije su sada top-level kolekcija koja referencira svoju putanju u hijerarhiji
- * kroz family, categoryId i subcategoryId.
- *
- * @example
- * const technologyService = new TechnologyService();
- *
- * // Kreiranje nove tehnologije
- * const technology = await technologyService.create({
- *   name: "Botulinum Toxin",
- *   description: "Neurotoxin injections for wrinkle reduction",
- *   family: ProcedureFamily.AESTHETICS,
- *   categoryId: "category123",
- *   subcategoryId: "subcategory456"
- * });
- *
- * // Dodavanje zahteva
- * await technologyService.addRequirement(technology.id, {
- *   type: "pre",
- *   name: "Stay Hydrated",
- *   description: "Drink plenty of water"
- * });
+ * Service for managing technologies.
  */
 export class TechnologyService extends BaseService {
   /**
-   * Vraća referencu na Firestore kolekciju tehnologija
+   * Reference to the Firestore collection of technologies.
    */
-  private getTechnologiesRef() {
+  private get technologiesRef() {
     return collection(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: 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"> = {
-      ...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,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: now,
+      updatedAt: now,
     };
 
-    const docRef = await addDoc(this.getTechnologiesRef(), newTechnology);
+    // Add optional fields only if they are not undefined
+    if (technology.technicalDetails) {
+      newTechnology.technicalDetails = technology.technicalDetails;
+    }
+
+    const docRef = await addDoc(this.technologiesRef, newTechnology as any);
     return { id: docRef.id, ...newTechnology };
   }
 
   /**
-   * 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 = query(this.getTechnologiesRef(), where("isActive", "==", true));
+  async getTechnologyCounts(active = true) {
+    const q = query(this.technologiesRef, where("isActive", "==", active));
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Technology)
-    );
+    const counts: Record<string, number> = {};
+    snapshot.docs.forEach((doc) => {
+      const tech = doc.data() as Technology;
+      counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
+    });
+    return counts;
   }
 
   /**
-   * 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: ProcedureFamily) {
-    const q = query(
-      this.getTechnologiesRef(),
-      where("isActive", "==", true),
-      where("family", "==", family)
-    );
+  async getTechnologyCountsByCategory(active = true) {
+    const q = query(this.technologiesRef, where("isActive", "==", active));
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const counts: Record<string, number> = {};
+    snapshot.docs.forEach((doc) => {
+      const tech = doc.data() as Technology;
+      counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
+    });
+    return counts;
+  }
+
+  /**
+   * Returns all technologies with pagination.
+   * @param options - Pagination and filter options.
+   * @returns A list of technologies and the last visible document.
+   */
+  async getAll(
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {}
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where("isActive", "==", active),
+      orderBy("name"),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
+    const snapshot = await getDocs(q);
+    const technologies = snapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology)
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
   }
 
   /**
-   * Vraća sve aktivne tehnologije za određenu kategoriju
-   * @param categoryId - ID kategorije
-   * @returns Lista aktivnih tehnologija
+   * Returns all technologies for a specific category with pagination.
+   * @param categoryId - The ID of the category.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified category.
    */
-  async getAllByCategoryId(categoryId: string) {
-    const q = query(
-      this.getTechnologiesRef(),
-      where("isActive", "==", true),
-      where("categoryId", "==", categoryId)
-    );
+  async getAllByCategoryId(
+    categoryId: string,
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {}
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where("categoryId", "==", categoryId),
+      where("isActive", "==", active),
+      orderBy("name"),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const technologies = snapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology)
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
   }
 
   /**
-   * Vraća sve aktivne tehnologije za određenu podkategoriju
-   * @param subcategoryId - ID podkategorije
-   * @returns Lista aktivnih tehnologija
+   * Returns all technologies for a specific subcategory with pagination.
+   * @param subcategoryId - The ID of the subcategory.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified subcategory.
    */
-  async getAllBySubcategoryId(subcategoryId: string) {
-    const q = query(
-      this.getTechnologiesRef(),
-      where("isActive", "==", true),
-      where("subcategoryId", "==", subcategoryId)
-    );
+  async getAllBySubcategoryId(
+    subcategoryId: string,
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {}
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where("subcategoryId", "==", subcategoryId),
+      where("isActive", "==", active),
+      orderBy("name"),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.technologiesRef, ...constraints);
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const technologies = snapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Technology)
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
   }
 
   /**
-   * 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: string,
-    technology: Partial<
-      Omit<
-        Technology,
-        "id" | "createdAt" | "family" | "categoryId" | "subcategoryId"
-      >
-    >
+    id: string,
+    technology: Partial<Omit<Technology, "id" | "createdAt">>
   ) {
-    const updateData = {
-      ...technology,
-      updatedAt: new Date(),
-    };
+    const updateData: { [key: string]: any } = { ...technology };
 
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    // Remove undefined fields to prevent Firestore errors
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key] === undefined) {
+        delete updateData[key];
+      }
+    });
+
+    updateData.updatedAt = new Date();
+
+    const docRef = doc(this.technologiesRef, id);
     await updateDoc(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: string) {
-    await this.update(technologyId, {
-      isActive: false,
-    });
+  async delete(id: string) {
+    await this.update(id, { isActive: false });
+  }
+
+  /**
+   * Reactivates a technology.
+   * @param id - The ID of the technology to reactivate.
+   */
+  async reactivate(id: string) {
+    await this.update(id, { isActive: true });
   }
 
   /**
-   * Vraća tehnologiju po ID-u
-   * @param technologyId - ID tražene tehnologije
-   * @returns Tehnologija ili null ako ne postoji
+   * 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(technologyId: string): Promise<Technology | null> {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+  async getById(id: string): Promise<Technology | null> {
+    const docRef = doc(this.technologiesRef, id);
     const docSnap = await getDoc(docRef);
     if (!docSnap.exists()) return null;
     return {
@@ -232,7 +289,7 @@ export class TechnologyService extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId: string, requirement: Requirement) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
 
     const requirementType =
       requirement.type === "pre" ? "requirements.pre" : "requirements.post";
@@ -252,7 +309,7 @@ export class TechnologyService extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId: string, requirement: Requirement) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
 
     const requirementType =
       requirement.type === "pre" ? "requirements.pre" : "requirements.post";
@@ -308,7 +365,7 @@ export class TechnologyService extends BaseService {
     technologyId: string,
     condition: BlockingCondition
   ) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
 
     await updateDoc(docRef, {
       blockingConditions: arrayUnion(condition),
@@ -328,7 +385,7 @@ export class TechnologyService extends BaseService {
     technologyId: string,
     condition: BlockingCondition
   ) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
 
     await updateDoc(docRef, {
       blockingConditions: arrayRemove(condition),
@@ -346,12 +403,21 @@ export class TechnologyService extends BaseService {
    */
   async addContraindication(
     technologyId: string,
-    contraindication: Contraindication
+    contraindication: ContraindicationDynamic
   ) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingContraindications = technology.contraindications || [];
+    if (existingContraindications.some((c) => c.id === contraindication.id)) {
+      return technology; // Already exists, do nothing
+    }
 
     await updateDoc(docRef, {
-      contraindications: arrayUnion(contraindication),
+      contraindications: [...existingContraindications, contraindication],
       updatedAt: new Date(),
     });
 
@@ -366,12 +432,62 @@ export class TechnologyService extends BaseService {
    */
   async removeContraindication(
     technologyId: string,
-    contraindication: Contraindication
+    contraindication: ContraindicationDynamic
   ) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedContraindications = (
+      technology.contraindications || []
+    ).filter((c) => c.id !== contraindication.id);
 
     await updateDoc(docRef, {
-      contraindications: arrayRemove(contraindication),
+      contraindications: updatedContraindications,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing contraindication in a technology's list.
+   * If the contraindication does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param contraindication - The updated contraindication object
+   * @returns The updated technology
+   */
+  async updateContraindication(
+    technologyId: string,
+    contraindication: ContraindicationDynamic
+  ) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const contraindications = technology.contraindications || [];
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+
+    if (index === -1) {
+      // If contraindication doesn't exist, do not update
+      // Consider throwing an error if this is an unexpected state
+      console.warn(
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+
+    const updatedContraindications = [...contraindications];
+    updatedContraindications[index] = contraindication;
+
+    await updateDoc(docRef, {
+      contraindications: updatedContraindications,
       updatedAt: new Date(),
     });
 
@@ -384,11 +500,20 @@ export class TechnologyService extends BaseService {
    * @param benefit - Benefit koji se dodaje
    * @returns Ažurirana tehnologija
    */
-  async addBenefit(technologyId: string, benefit: TreatmentBenefit) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+  async addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingBenefits = technology.benefits || [];
+    if (existingBenefits.some((b) => b.id === benefit.id)) {
+      return technology; // Already exists, do nothing
+    }
 
     await updateDoc(docRef, {
-      benefits: arrayUnion(benefit),
+      benefits: [...existingBenefits, benefit],
       updatedAt: new Date(),
     });
 
@@ -401,11 +526,55 @@ export class TechnologyService extends BaseService {
    * @param benefit - Benefit koji se uklanja
    * @returns Ažurirana tehnologija
    */
-  async removeBenefit(technologyId: string, benefit: TreatmentBenefit) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+  async removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedBenefits = (technology.benefits || []).filter(
+      (b) => b.id !== benefit.id
+    );
+
+    await updateDoc(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing benefit in a technology's list.
+   * If the benefit does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param benefit - The updated benefit object
+   * @returns The updated technology
+   */
+  async updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const benefits = technology.benefits || [];
+    const index = benefits.findIndex((b) => b.id === benefit.id);
+
+    if (index === -1) {
+      // If benefit doesn't exist, do not update
+      console.warn(
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+
+    const updatedBenefits = [...benefits];
+    updatedBenefits[index] = benefit;
 
     await updateDoc(docRef, {
-      benefits: arrayRemove(benefit),
+      benefits: updatedBenefits,
       updatedAt: new Date(),
     });
 
@@ -452,7 +621,7 @@ export class TechnologyService extends BaseService {
     technologyId: string,
     certificationRequirement: CertificationRequirement
   ) {
-    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const docRef = doc(this.technologiesRef, technologyId);
 
     await updateDoc(docRef, {
       certificationRequirement,
@@ -557,11 +726,12 @@ export class TechnologyService extends BaseService {
     const allTechnologies = await this.getAll();
 
     // Filter technologies based on certification requirements
-    const allowedTechnologies = allTechnologies.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
@@ -580,4 +750,49 @@ export class TechnologyService 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: string,
+    subcategoryId: string
+  ): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where("isActive", "==", true),
+      where("categoryId", "==", categoryId),
+      where("subcategoryId", "==", subcategoryId),
+      orderBy("name")
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology)
+    );
+  }
+
+  /**
+   * Gets all active technologies for filter dropdowns.
+   */
+  async getAllForFilter(): Promise<Technology[]> {
+    const q = query(
+      collection(this.db, TECHNOLOGIES_COLLECTION),
+      where("isActive", "==", true),
+      orderBy("name")
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Technology)
+    );
+  }
 }