@blackcode_sa/metaestetics-api 1.12.50 → 1.12.51

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

@@ -15,6 +15,8 @@ import {
   arrayUnion,
   arrayRemove,
   Firestore,
+  writeBatch,
+  QueryConstraint,
 } from 'firebase/firestore';
 import { Technology, TECHNOLOGIES_COLLECTION, ITechnologyService } from '../types/technology.types';
 import { Requirement, RequirementType } from '../types/requirement.types';
@@ -29,6 +31,7 @@ import {
 import { BaseService } from '../../services/base.service';
 import { ProcedureFamily } from '../types/static/procedure-family.types';
 import { Practitioner, PractitionerCertification } from '../../types/practitioner';
+import { Product, PRODUCTS_COLLECTION } from '../types/product.types';
 
 /**
  * Default vrednosti za sertifikaciju
@@ -240,7 +243,25 @@ export class TechnologyService extends BaseService implements ITechnologyService
     updateData.updatedAt = new Date();
 
     const docRef = doc(this.technologiesRef, id);
+    
+    // Get the technology before update to check what changed
+    const beforeTech = await this.getById(id);
+    
     await updateDoc(docRef, updateData);
+    
+    // If categoryId, subcategoryId, or name changed, update all products in subcollection
+    const categoryChanged = beforeTech && updateData.categoryId && beforeTech.categoryId !== updateData.categoryId;
+    const subcategoryChanged = beforeTech && updateData.subcategoryId && beforeTech.subcategoryId !== updateData.subcategoryId;
+    const nameChanged = beforeTech && updateData.name && beforeTech.name !== updateData.name;
+    
+    if (categoryChanged || subcategoryChanged || nameChanged) {
+      await this.updateProductsInSubcollection(id, {
+        categoryId: updateData.categoryId,
+        subcategoryId: updateData.subcategoryId,
+        technologyName: updateData.name,
+      });
+    }
+    
     return this.getById(id);
   }
 
@@ -778,4 +799,272 @@ export class TechnologyService extends BaseService implements ITechnologyService
         } as Technology),
     );
   }
+
+  // ==========================================
+  // NEW METHODS: Product assignment management
+  // ==========================================
+
+  /**
+   * Assigns multiple products to a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async assignProducts(technologyId: string, productIds: string[]): Promise<void> {
+    const batch = writeBatch(this.db);
+    
+    for (const productId of productIds) {
+      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayUnion(technologyId),
+        updatedAt: new Date(),
+      });
+    }
+    
+    await batch.commit();
+    // Cloud Function will handle syncing to subcollections
+  }
+
+  /**
+   * Unassigns multiple products from a technology
+   * Updates each product's assignedTechnologyIds array
+   */
+  async unassignProducts(technologyId: string, productIds: string[]): Promise<void> {
+    const batch = writeBatch(this.db);
+    
+    for (const productId of productIds) {
+      const productRef = doc(this.db, PRODUCTS_COLLECTION, productId);
+      batch.update(productRef, {
+        assignedTechnologyIds: arrayRemove(technologyId),
+        updatedAt: new Date(),
+      });
+    }
+    
+    await batch.commit();
+    // Cloud Function will handle removing from subcollections
+  }
+
+  /**
+   * Gets products assigned to a specific technology
+   * Reads from top-level collection for immediate consistency (Cloud Functions may lag)
+   */
+  async getAssignedProducts(technologyId: string): Promise<Product[]> {
+    const q = query(
+      collection(this.db, PRODUCTS_COLLECTION),
+      where('assignedTechnologyIds', 'array-contains', technologyId),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+  }
+
+  /**
+   * Gets products NOT assigned to a specific technology
+   */
+  async getUnassignedProducts(technologyId: string): Promise<Product[]> {
+    const q = query(
+      collection(this.db, PRODUCTS_COLLECTION),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    
+    const allProducts = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+    
+    // Filter out products already assigned to this technology
+    return allProducts.filter(product => 
+      !product.assignedTechnologyIds?.includes(technologyId)
+    );
+  }
+
+  /**
+   * Gets product assignment statistics for a technology
+   */
+  async getProductStats(technologyId: string): Promise<{
+    totalAssigned: number;
+    byBrand: Record<string, number>;
+  }> {
+    const products = await this.getAssignedProducts(technologyId);
+    
+    const byBrand: Record<string, number> = {};
+    products.forEach(product => {
+      byBrand[product.brandName] = (byBrand[product.brandName] || 0) + 1;
+    });
+    
+    return {
+      totalAssigned: products.length,
+      byBrand,
+    };
+  }
+
+  /**
+   * Updates products in technology subcollection when technology metadata changes
+   * @param technologyId - ID of the technology
+   * @param updates - Fields to update (categoryId, subcategoryId, technologyName)
+   */
+  private async updateProductsInSubcollection(
+    technologyId: string,
+    updates: { categoryId?: string; subcategoryId?: string; technologyName?: string }
+  ): Promise<void> {
+    const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
+    const productsSnapshot = await getDocs(productsRef);
+    
+    if (productsSnapshot.empty) {
+      return;
+    }
+    
+    const batch = writeBatch(this.db);
+    
+    for (const productDoc of productsSnapshot.docs) {
+      const productRef = productDoc.ref;
+      const updateFields: any = {};
+      
+      if (updates.categoryId !== undefined) {
+        updateFields.categoryId = updates.categoryId;
+      }
+      if (updates.subcategoryId !== undefined) {
+        updateFields.subcategoryId = updates.subcategoryId;
+      }
+      if (updates.technologyName !== undefined) {
+        updateFields.technologyName = updates.technologyName;
+      }
+      
+      if (Object.keys(updateFields).length > 0) {
+        batch.update(productRef, updateFields);
+      }
+    }
+    
+    await batch.commit();
+  }
+
+  /**
+   * Exports technologies to CSV string, suitable for Excel/Sheets.
+   * Includes headers and optional UTF-8 BOM.
+   * By default exports only active technologies (set includeInactive to true to export all).
+   * Includes product names from subcollections.
+   */
+  async exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string> {
+    const includeInactive = options?.includeInactive ?? false;
+    const includeBom = options?.includeBom ?? true;
+
+    const headers = [
+      "id",
+      "name",
+      "description",
+      "family",
+      "categoryId",
+      "subcategoryId",
+      "technicalDetails",
+      "requirements_pre",
+      "requirements_post",
+      "blockingConditions",
+      "contraindications",
+      "benefits",
+      "certificationMinimumLevel",
+      "certificationRequiredSpecialties",
+      "documentationTemplateIds",
+      "productNames",
+      "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: QueryConstraint[] = [];
+    if (!includeInactive) {
+      constraints.push(where("isActive", "==", true));
+    }
+    constraints.push(orderBy("name"));
+
+    // Page through all results
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const queryConstraints: QueryConstraint[] = [...constraints, limit(PAGE_SIZE)];
+      if (cursor) queryConstraints.push(startAfter(cursor));
+
+      const q = query(this.technologiesRef, ...queryConstraints);
+      const snapshot = await getDocs(q);
+      if (snapshot.empty) break;
+
+      for (const d of snapshot.docs) {
+        const technology = ({ id: d.id, ...d.data() } as unknown) as Technology;
+        // Fetch products for this technology
+        const productNames = await this.getProductNamesForTechnology(technology.id!);
+        rows.push(this.technologyToCsvRow(technology, productNames));
+      }
+
+      cursor = snapshot.docs[snapshot.docs.length - 1];
+      if (snapshot.size < PAGE_SIZE) break;
+    }
+
+    const csvBody = rows.join("\r\n");
+    return includeBom ? "\uFEFF" + csvBody : csvBody;
+  }
+
+  /**
+   * Gets product names from the technology's product subcollection
+   */
+  private async getProductNamesForTechnology(technologyId: string): Promise<string[]> {
+    try {
+      const productsRef = collection(this.db, TECHNOLOGIES_COLLECTION, technologyId, PRODUCTS_COLLECTION);
+      const q = query(productsRef, where("isActive", "==", true));
+      const snapshot = await getDocs(q);
+      return snapshot.docs.map(doc => {
+        const product = doc.data() as Product;
+        return product.name || "";
+      }).filter(name => name); // Filter out empty names
+    } catch (error) {
+      console.error(`Error fetching products for technology ${technologyId}:`, error);
+      return [];
+    }
+  }
+
+  private technologyToCsvRow(technology: Technology, productNames: string[] = []): string {
+    const values = [
+      technology.id ?? "",
+      technology.name ?? "",
+      technology.description ?? "",
+      technology.family ?? "",
+      technology.categoryId ?? "",
+      technology.subcategoryId ?? "",
+      technology.technicalDetails ?? "",
+      technology.requirements?.pre?.map(r => r.name).join(";") ?? "",
+      technology.requirements?.post?.map(r => r.name).join(";") ?? "",
+      technology.blockingConditions?.join(";") ?? "",
+      technology.contraindications?.map(c => c.name).join(";") ?? "",
+      technology.benefits?.map(b => b.name).join(";") ?? "",
+      technology.certificationRequirement?.minimumLevel ?? "",
+      technology.certificationRequirement?.requiredSpecialties?.join(";") ?? "",
+      technology.documentationTemplates?.map(t => t.templateId).join(";") ?? "",
+      productNames.join(";"),
+      String(technology.isActive ?? ""),
+    ];
+    return values.map((v) => this.formatCsvValue(v)).join(",");
+  }
+
+  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}"`;
+  }
 }

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

@@ -6,9 +6,10 @@ import type { ContraindicationDynamic } from './admin-constants.types';
  *
  * @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 brandName - Name of the brand (denormalized for display)
+ * @property assignedTechnologyIds - Array of technology IDs this product is assigned to
+ * @property description - Detailed description of the product and its purpose
  * @property technicalDetails - Technical details and specifications
  * @property warnings - List of warnings related to product use
  * @property dosage - Dosage information (if applicable)
@@ -24,10 +25,11 @@ export interface Product {
   name: string;
   brandId: string;
   brandName: string;
-  technologyId: string;
-  technologyName: string;
-  categoryId: string;
-  subcategoryId: string;
+  
+  // NEW: Technology assignment tracking
+  assignedTechnologyIds?: string[];
+  
+  // Product details
   createdAt: Date;
   updatedAt: Date;
   isActive: boolean;
@@ -38,6 +40,18 @@ export interface Product {
   composition?: string;
   indications?: string[];
   contraindications?: ContraindicationDynamic[];
+  
+  // LEGACY FIELDS: Only present in technology subcollections (/technologies/{id}/products/)
+  // These fields are synced by Cloud Functions for backward compatibility
+  // NOT stored in top-level /products collection
+  /** Present only in subcollections - synced from technology metadata */
+  technologyId?: string;
+  /** Present only in subcollections - synced from technology name */
+  technologyName?: string;
+  /** Present only in subcollections - synced from technology categoryId */
+  categoryId?: string;
+  /** Present only in subcollections - synced from technology subcategoryId */
+  subcategoryId?: string;
 }
 
 /**
@@ -47,9 +61,97 @@ export const PRODUCTS_COLLECTION = 'products';
 
 /**
  * Interface for the ProductService class
+ * 
+ * NOTE: This interface maintains backward compatibility while adding new top-level collection methods.
+ * Old methods using technologyId are kept for existing code, new methods work with top-level collection.
  */
 export interface IProductService {
+  // ==========================================
+  // NEW METHODS: Top-level collection (preferred)
+  // ==========================================
+  
+  /**
+   * Creates a new product in the top-level collection
+   * @param brandId - ID of the brand that manufactures this product
+   * @param product - Product data
+   * @param technologyIds - Optional array of technology IDs to assign this product to
+   */
+  createTopLevel(
+    brandId: string,
+    product: Omit<Product, 'id' | 'createdAt' | 'updatedAt' | 'brandId' | 'assignedTechnologyIds'>,
+    technologyIds?: string[],
+  ): Promise<Product>;
+
+  /**
+   * Gets all products from the top-level collection
+   * @param options - Query options
+   */
+  getAllTopLevel(options: {
+    rowsPerPage: number;
+    lastVisible?: any;
+    brandId?: string;
+  }): Promise<{ products: Product[]; lastVisible: any }>;
+
+  /**
+   * Gets a product by ID from the top-level collection
+   * @param productId - ID of the product
+   */
+  getByIdTopLevel(productId: string): Promise<Product | null>;
+
+  /**
+   * Updates a product in the top-level collection
+   * @param productId - ID of the product to update
+   * @param product - Updated product data
+   */
+  updateTopLevel(
+    productId: string,
+    product: Partial<Omit<Product, 'id' | 'createdAt' | 'brandId'>>,
+  ): Promise<Product | null>;
+
+  /**
+   * Deletes a product from the top-level collection (soft delete)
+   * @param productId - ID of the product to delete
+   */
+  deleteTopLevel(productId: string): Promise<void>;
+
+  /**
+   * Assigns a product to a technology
+   * @param productId - ID of the product
+   * @param technologyId - ID of the technology
+   */
+  assignToTechnology(productId: string, technologyId: string): Promise<void>;
+
+  /**
+   * Unassigns a product from a technology
+   * @param productId - ID of the product
+   * @param technologyId - ID of the technology
+   */
+  unassignFromTechnology(productId: string, technologyId: string): Promise<void>;
+
+  /**
+   * Gets products assigned to a specific technology
+   * @param technologyId - ID of the technology
+   */
+  getAssignedProducts(technologyId: string): Promise<Product[]>;
+
+  /**
+   * Gets products NOT assigned to a specific technology
+   * @param technologyId - ID of the technology
+   */
+  getUnassignedProducts(technologyId: string): Promise<Product[]>;
+
+  /**
+   * Gets all products for a brand
+   * @param brandId - ID of the brand
+   */
+  getByBrand(brandId: string): Promise<Product[]>;
+
+  // ==========================================
+  // DEPRECATED METHODS: Kept for backward compatibility
+  // ==========================================
+  
   /**
+   * @deprecated Use createTopLevel instead
    * 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
@@ -62,6 +164,7 @@ export interface IProductService {
   ): Promise<Product>;
 
   /**
+   * @deprecated Use getAllTopLevel instead
    * Gets a paginated list of all products, with optional filters.
    */
   getAll(options: {
@@ -73,6 +176,7 @@ export interface IProductService {
   }): Promise<{ products: Product[]; lastVisible: any }>;
 
   /**
+   * @deprecated Use alternative counting methods
    * Gets the total count of active products, with optional filters.
    */
   getProductsCount(options: {
@@ -82,6 +186,7 @@ export interface IProductService {
   }): Promise<number>;
 
   /**
+   * @deprecated Use alternative counting methods
    * Gets counts of active products grouped by category, subcategory, and technology.
    */
   getProductCounts(): Promise<{
@@ -91,18 +196,21 @@ export interface IProductService {
   }>;
 
   /**
+   * @deprecated Use getAssignedProducts instead
    * Gets all products for a specific technology (non-paginated, for filters/dropdowns)
    * @param technologyId - ID of the technology
    */
   getAllByTechnology(technologyId: string): Promise<Product[]>;
 
   /**
+   * @deprecated Use getByBrand instead
    * Gets all products for a brand
    * @param brandId - ID of the brand
    */
   getAllByBrand(brandId: string): Promise<Product[]>;
 
   /**
+   * @deprecated Use updateTopLevel instead
    * Updates a product
    * @param technologyId - ID of the technology
    * @param productId - ID of the product to update
@@ -115,6 +223,7 @@ export interface IProductService {
   ): Promise<Product | null>;
 
   /**
+   * @deprecated Use deleteTopLevel instead
    * Deletes a product (soft delete)
    * @param technologyId - ID of the technology
    * @param productId - ID of the product to delete
@@ -122,6 +231,7 @@ export interface IProductService {
   delete(technologyId: string, productId: string): Promise<void>;
 
   /**
+   * @deprecated Use getByIdTopLevel instead
    * Gets a product by ID
    * @param technologyId - ID of the technology
    * @param productId - ID of the product

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

@@ -201,7 +201,7 @@ export class ProcedureService extends BaseService {
     const procedureId = this.generateId();
 
     // Get references to related entities (Category, Subcategory, Technology, and optionally Product)
-    const baseEntitiesPromises = [
+    const baseEntitiesPromises: Promise<Category | Subcategory | Technology | Product | null>[] = [
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
@@ -366,7 +366,7 @@ export class ProcedureService extends BaseService {
     const validatedData = createProcedureSchema.parse(validationData);
 
     // 2. Fetch common data once to avoid redundant reads
-    const baseEntitiesPromises = [
+    const baseEntitiesPromises: Promise<Category | Subcategory | Technology | Product | null>[] = [
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),