@blackcode_sa/metaestetics-api 1.5.12 → 1.5.14

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

@@ -1,7 +1,6 @@
 import {
   addDoc,
   collection,
-  collectionGroup,
   doc,
   getDoc,
   getDocs,
@@ -9,45 +8,40 @@ import {
   updateDoc,
   where,
 } from "firebase/firestore";
-import { Product, PRODUCTS_COLLECTION } from "../types/product.types";
+import {
+  Product,
+  PRODUCTS_COLLECTION,
+  IProductService,
+} from "../types/product.types";
 import { BaseService } from "../../services/base.service";
-import { CATEGORIES_COLLECTION } from "../types/category.types";
-import { BRANDS_COLLECTION } from "../types/brand.types";
-import { SUBCATEGORIES_COLLECTION } from "../types/subcategory.types";
 import { TECHNOLOGIES_COLLECTION } from "../types/technology.types";
 
-export class ProductService extends BaseService {
-  private getProductsRefByTechnology(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
+export class ProductService extends BaseService implements IProductService {
+  /**
+   * Gets reference to products collection under a technology
+   * @param technologyId - ID of the technology
+   * @returns Firestore collection reference
+   */
+  private getProductsRef(technologyId: string) {
     return collection(
       this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION,
-      subcategoryId,
       TECHNOLOGIES_COLLECTION,
       technologyId,
       PRODUCTS_COLLECTION
     );
   }
 
-  private getProductsRefByBrand(brandId: string) {
-    return collection(this.db, BRANDS_COLLECTION, brandId, PRODUCTS_COLLECTION);
-  }
-
+  /**
+   * Creates a new product under technology
+   */
   async create(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     brandId: string,
     product: Omit<
       Product,
       "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId"
     >
-  ) {
+  ): Promise<Product> {
     const now = new Date();
     const newProduct: Omit<Product, "id"> = {
       ...product,
@@ -58,31 +52,20 @@ export class ProductService extends BaseService {
       isActive: true,
     };
 
-    // Create in technology collection
-    const techProductRef = await addDoc(
-      this.getProductsRefByTechnology(categoryId, subcategoryId, technologyId),
+    const productRef = await addDoc(
+      this.getProductsRef(technologyId),
       newProduct
     );
 
-    // Create in brand collection (for easy access to brand's products)
-    await addDoc(this.getProductsRefByBrand(brandId), {
-      ...newProduct,
-      id: techProductRef.id, // Store the original ID for reference
-      categoryId,
-      subcategoryId,
-      technologyId,
-    });
-
-    return { id: techProductRef.id, ...newProduct };
+    return { id: productRef.id, ...newProduct };
   }
 
-  async getAllByTechnology(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string
-  ) {
+  /**
+   * Gets all products for a technology
+   */
+  async getAllByTechnology(technologyId: string): Promise<Product[]> {
     const q = query(
-      this.getProductsRefByTechnology(categoryId, subcategoryId, technologyId),
+      this.getProductsRef(technologyId),
       where("isActive", "==", true)
     );
     const snapshot = await getDocs(q);
@@ -95,76 +78,74 @@ export class ProductService extends BaseService {
     );
   }
 
-  async getAllByBrand(brandId: string) {
-    const q = query(
-      this.getProductsRefByBrand(brandId),
-      where("isActive", "==", true)
-    );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      (doc) =>
-        ({
-          id: doc.id,
-          ...doc.data(),
-        } as Product)
-    );
+  /**
+   * Gets all products for a brand by filtering through all technologies
+   */
+  async getAllByBrand(brandId: string): Promise<Product[]> {
+    const allTechnologiesRef = collection(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await getDocs(allTechnologiesRef);
+
+    const products: Product[] = [];
+
+    for (const techDoc of technologiesSnapshot.docs) {
+      const q = query(
+        this.getProductsRef(techDoc.id),
+        where("brandId", "==", brandId),
+        where("isActive", "==", true)
+      );
+      const snapshot = await getDocs(q);
+      products.push(
+        ...snapshot.docs.map(
+          (doc) =>
+            ({
+              id: doc.id,
+              ...doc.data(),
+            } as Product)
+        )
+      );
+    }
+
+    return products;
   }
 
+  /**
+   * Updates a product
+   */
   async update(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     productId: string,
     product: Partial<
       Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">
     >
-  ) {
+  ): Promise<Product | null> {
     const updateData = {
       ...product,
       updatedAt: new Date(),
     };
 
-    // Update in technology collection
-    const techDocRef = doc(
-      this.getProductsRefByTechnology(categoryId, subcategoryId, technologyId),
-      productId
-    );
-    await updateDoc(techDocRef, updateData);
-
-    // Update in brand collection
-    const brandProductsQuery = query(
-      collectionGroup(this.db, PRODUCTS_COLLECTION),
-      where("id", "==", productId)
-    );
-    const brandProductsSnapshot = await getDocs(brandProductsQuery);
-    for (const doc of brandProductsSnapshot.docs) {
-      await updateDoc(doc.ref, updateData);
-    }
+    const docRef = doc(this.getProductsRef(technologyId), productId);
+    await updateDoc(docRef, updateData);
 
-    return this.getById(categoryId, subcategoryId, technologyId, productId);
+    return this.getById(technologyId, productId);
   }
 
-  async delete(
-    categoryId: string,
-    subcategoryId: string,
-    technologyId: string,
-    productId: string
-  ) {
-    await this.update(categoryId, subcategoryId, technologyId, productId, {
+  /**
+   * Soft deletes a product
+   */
+  async delete(technologyId: string, productId: string): Promise<void> {
+    await this.update(technologyId, productId, {
       isActive: false,
     });
   }
 
+  /**
+   * Gets a product by ID
+   */
   async getById(
-    categoryId: string,
-    subcategoryId: string,
     technologyId: string,
     productId: string
-  ) {
-    const docRef = doc(
-      this.getProductsRefByTechnology(categoryId, subcategoryId, technologyId),
-      productId
-    );
+  ): Promise<Product | null> {
+    const docRef = doc(this.getProductsRef(technologyId), productId);
     const docSnap = await getDoc(docRef);
     if (!docSnap.exists()) return null;
     return {

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

@@ -1,21 +1,21 @@
 /**
- * Proizvod koji se koristi u procedurama
- * Može biti potrošni materijal, oprema ili bilo koji drugi proizvod potreban za izvođenje procedure
+ * Product used in procedures
+ * Can be consumables, equipment, or any other product needed for performing procedures
  *
- * @property id - Jedinstveni identifikator proizvoda
- * @property name - Naziv proizvoda
- * @property description - Detaljan opis proizvoda i njegove namene
- * @property brandId - ID brenda koji proizvodi ovaj proizvod
- * @property technologyId - ID tehnologije sa kojom se proizvod koristi
- * @property technicalDetails - Tehnički detalji i specifikacije proizvoda
- * @property warnings - Lista upozorenja vezanih za korišćenje proizvoda
- * @property dosage - Informacije o doziranju (ako je primenljivo)
- * @property composition - Sastav proizvoda
- * @property indications - Lista indikacija za korišćenje
- * @property contraindications - Lista kontraindikacija
- * @property isActive - Da li je proizvod aktivan u sistemu
- * @property createdAt - Datum kreiranja
- * @property updatedAt - Datum poslednjeg ažuriranja
+ * @property id - Unique identifier of the product
+ * @property name - Name of the product
+ * @property description - Detailed description of the product and its purpose
+ * @property brandId - ID of the brand that manufactures this product
+ * @property technologyId - ID of the technology this product is used with
+ * @property technicalDetails - Technical details and specifications
+ * @property warnings - List of warnings related to product use
+ * @property dosage - Dosage information (if applicable)
+ * @property composition - Product composition
+ * @property indications - List of indications for use
+ * @property contraindications - List of contraindications
+ * @property isActive - Whether the product is active in the system
+ * @property createdAt - Creation date
+ * @property updatedAt - Last update date
  */
 export interface Product {
   id?: string;
@@ -35,6 +35,66 @@ export interface Product {
 }
 
 /**
- * Kolekcija u Firestore bazi gde se čuvaju proizvodi
+ * Collection in Firestore database where products are stored
  */
 export const PRODUCTS_COLLECTION = "products";
+
+/**
+ * Interface for the ProductService class
+ */
+export interface IProductService {
+  /**
+   * Creates a new product
+   * @param technologyId - ID of the technology this product is used with
+   * @param brandId - ID of the brand that manufactures this product
+   * @param product - Product data
+   */
+  create(
+    technologyId: string,
+    brandId: string,
+    product: Omit<
+      Product,
+      "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId"
+    >
+  ): Promise<Product>;
+
+  /**
+   * Gets all products for a technology
+   * @param technologyId - ID of the technology
+   */
+  getAllByTechnology(technologyId: string): Promise<Product[]>;
+
+  /**
+   * Gets all products for a brand
+   * @param brandId - ID of the brand
+   */
+  getAllByBrand(brandId: string): Promise<Product[]>;
+
+  /**
+   * Updates a product
+   * @param technologyId - ID of the technology
+   * @param productId - ID of the product to update
+   * @param product - Updated product data
+   */
+  update(
+    technologyId: string,
+    productId: string,
+    product: Partial<
+      Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">
+    >
+  ): Promise<Product | null>;
+
+  /**
+   * Deletes a product (soft delete)
+   * @param technologyId - ID of the technology
+   * @param productId - ID of the product to delete
+   */
+  delete(technologyId: string, productId: string): Promise<void>;
+
+  /**
+   * Gets a product by ID
+   * @param technologyId - ID of the technology
+   * @param productId - ID of the product
+   */
+  getById(technologyId: string, productId: string): Promise<Product | null>;
+}

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

@@ -39,58 +39,28 @@ export interface TechnologyRequirements {
  * @property updatedAt - Last update date
  */
 export interface Technology {
-  /** Jedinstveni identifikator tehnologije (automatski generisan od strane Firestore) */
   id?: string;
-  /** Naziv tehnologije */
   name: string;
-
-  /** Detaljan opis tehnologije */
   description: string;
-
-  /** Familija procedura kojoj tehnologija pripada */
   family: ProcedureFamily;
-
-  /** ID kategorije kojoj tehnologija pripada */
   categoryId: string;
-
-  /** ID potkategorije kojoj tehnologija pripada */
   subcategoryId: string;
-
-  /** Tehnički detalji i specifikacije */
   technicalDetails?: string;
-
-  /** Zahtevi pre i posle tretmana */
   requirements: {
     pre: Requirement[];
     post: Requirement[];
   };
-
-  /** Apsolutne kontraindikacije koje sprečavaju tretman */
   blockingConditions: BlockingCondition[];
-
-  /** Relativne kontraindikacije koje zahtevaju posebnu pažnju */
   contraindications: Contraindication[];
-
-  /** Očekivane dobrobiti tretmana */
   benefits: TreatmentBenefit[];
-
-  /** Potrebna sertifikacija za korišćenje tehnologije */
   certificationRequirement: CertificationRequirement;
-
-  /** Dokumentacioni šabloni potrebni za ovu tehnologiju */
   documentationTemplates?: DocumentTemplate[];
-
-  /** Da li je tehnologija trenutno aktivna */
   isActive: boolean;
-
-  /** Datum kreiranja */
   createdAt: Date;
-
-  /** Datum poslednjeg ažuriranja */
   updatedAt: Date;
 }
 
 /**
- * Kolekcija u Firestore bazi gde se čuvaju tehnologije
+ * Collection in Firestore database where technologies are stored
  */
 export const TECHNOLOGIES_COLLECTION = "technologies";

package/src/services/practitioner/practitioner.service.ts

@@ -443,7 +443,7 @@ export class PractitionerService extends BaseService {
   }
 
   /**
-   * Dohvata sve zdravstvene radnike za određenu kliniku
+   * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */
   async getPractitionersByClinic(clinicId: string): Promise<Practitioner[]> {
     const q = query(
@@ -458,7 +458,21 @@ export class PractitionerService extends BaseService {
   }
 
   /**
-   * Dohvata sve draft zdravstvene radnike za određenu kliniku
+   * Dohvata sve zdravstvene radnike za određenu kliniku
+   */
+  async getAllPractitionersByClinic(clinicId: string): Promise<Practitioner[]> {
+    const q = query(
+      collection(this.db, PRACTITIONERS_COLLECTION),
+      where("clinics", "array-contains", clinicId),
+      where("isActive", "==", true)
+    );
+
+    const querySnapshot = await getDocs(q);
+    return querySnapshot.docs.map((doc) => doc.data() as Practitioner);
+  }
+
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
    */
   async getDraftPractitionersByClinic(
     clinicId: string

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

@@ -94,8 +94,6 @@ export class ProcedureService extends BaseService {
       ),
       this.technologyService.getById(validatedData.technologyId),
       this.productService.getById(
-        validatedData.categoryId,
-        validatedData.subcategoryId,
         validatedData.technologyId,
         validatedData.productId
       ),