@blackcode_sa/metaestetics-api 1.12.40 → 1.12.41

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

@@ -13,6 +13,8 @@ import {
   startAfter,
   getCountFromServer,
   QueryConstraint,
+  arrayUnion,
+  arrayRemove,
 } from 'firebase/firestore';
 import { Product, PRODUCTS_COLLECTION, IProductService } from '../types/product.types';
 import { BaseService } from '../../services/base.service';
@@ -20,7 +22,15 @@ import { TECHNOLOGIES_COLLECTION } from '../types/technology.types';
 
 export class ProductService extends BaseService implements IProductService {
   /**
-   * Gets reference to products collection under a technology
+   * Gets reference to top-level products collection (source of truth)
+   * @returns Firestore collection reference
+   */
+  private getTopLevelProductsRef() {
+    return collection(this.db, PRODUCTS_COLLECTION);
+  }
+
+  /**
+   * Gets reference to products collection under a technology (backward compatibility)
    * @param technologyId - ID of the technology
    * @returns Firestore collection reference
    */
@@ -37,11 +47,11 @@ export class ProductService extends BaseService implements IProductService {
     product: Omit<Product, 'id' | 'createdAt' | 'updatedAt' | 'brandId' | 'technologyId'>,
   ): Promise<Product> {
     const now = new Date();
-    // categoryId and subcategoryId are now expected to be part of the product object
+    // Create product with legacy structure for subcollection compatibility
     const newProduct: Omit<Product, 'id'> = {
       ...product,
       brandId,
-      technologyId,
+      technologyId, // Required for old subcollection structure
       createdAt: now,
       updatedAt: now,
       isActive: true,
@@ -124,39 +134,33 @@ export class ProductService extends BaseService implements IProductService {
   }
 
   /**
-   * Gets counts of active products grouped by category, subcategory, and technology.
-   * This uses a single collectionGroup query for efficiency.
+   * Gets counts of active products grouped by technology.
+   * NOTE: Only counts top-level collection to avoid duplication during migration.
+   * Categories/subcategories not available in top-level structure.
    */
   async getProductCounts(): Promise<{
     byCategory: Record<string, number>;
     bySubcategory: Record<string, number>;
     byTechnology: Record<string, number>;
   }> {
-    const q = query(collectionGroup(this.db, PRODUCTS_COLLECTION), where('isActive', '==', true));
-    const snapshot = await getDocs(q);
-
     const counts = {
       byCategory: {} as Record<string, number>,
       bySubcategory: {} as Record<string, number>,
       byTechnology: {} as Record<string, number>,
     };
 
-    if (snapshot.empty) {
-      return counts;
-    }
+    // Query top-level collection only (to avoid duplication during migration)
+    const q = query(this.getTopLevelProductsRef(), where('isActive', '==', true));
+    const snapshot = await getDocs(q);
 
     snapshot.docs.forEach(doc => {
       const product = doc.data() as Product;
-      const { categoryId, subcategoryId, technologyId } = product;
-
-      if (categoryId) {
-        counts.byCategory[categoryId] = (counts.byCategory[categoryId] || 0) + 1;
-      }
-      if (subcategoryId) {
-        counts.bySubcategory[subcategoryId] = (counts.bySubcategory[subcategoryId] || 0) + 1;
-      }
-      if (technologyId) {
-        counts.byTechnology[technologyId] = (counts.byTechnology[technologyId] || 0) + 1;
+      
+      // Count by technology using assignedTechnologyIds
+      if (product.assignedTechnologyIds && Array.isArray(product.assignedTechnologyIds)) {
+        product.assignedTechnologyIds.forEach(techId => {
+          counts.byTechnology[techId] = (counts.byTechnology[techId] || 0) + 1;
+        });
       }
     });
 
@@ -252,4 +256,195 @@ export class ProductService extends BaseService implements IProductService {
       ...docSnap.data(),
     } as Product;
   }
+
+  // ==========================================
+  // NEW METHODS: Top-level collection (preferred)
+  // ==========================================
+
+  /**
+   * Creates a new product in the top-level collection
+   */
+  async createTopLevel(
+    brandId: string,
+    product: Omit<Product, 'id' | 'createdAt' | 'updatedAt' | 'brandId' | 'assignedTechnologyIds'>,
+    technologyIds: string[] = [],
+  ): Promise<Product> {
+    const now = new Date();
+    const newProduct: Omit<Product, 'id'> = {
+      ...product,
+      brandId,
+      assignedTechnologyIds: technologyIds,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true,
+    };
+
+    const productRef = await addDoc(this.getTopLevelProductsRef(), newProduct);
+    return { id: productRef.id, ...newProduct };
+  }
+
+  /**
+   * Gets all products from the top-level collection
+   */
+  async getAllTopLevel(options: {
+    rowsPerPage: number;
+    lastVisible?: any;
+    brandId?: string;
+  }): Promise<{ products: Product[]; lastVisible: any }> {
+    const { rowsPerPage, lastVisible, brandId } = options;
+
+    const constraints: QueryConstraint[] = [where('isActive', '==', true), orderBy('name')];
+
+    if (brandId) {
+      constraints.push(where('brandId', '==', brandId));
+    }
+
+    if (lastVisible) {
+      constraints.push(startAfter(lastVisible));
+    }
+    constraints.push(limit(rowsPerPage));
+
+    const q = query(this.getTopLevelProductsRef(), ...constraints);
+    const snapshot = await getDocs(q);
+
+    const products = snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+
+    return { products, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Gets a product by ID from the top-level collection
+   */
+  async getByIdTopLevel(productId: string): Promise<Product | null> {
+    const docRef = doc(this.getTopLevelProductsRef(), productId);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data(),
+    } as Product;
+  }
+
+  /**
+   * Updates a product in the top-level collection
+   */
+  async updateTopLevel(
+    productId: string,
+    product: Partial<Omit<Product, 'id' | 'createdAt' | 'brandId'>>,
+  ): Promise<Product | null> {
+    const updateData = {
+      ...product,
+      updatedAt: new Date(),
+    };
+
+    const docRef = doc(this.getTopLevelProductsRef(), productId);
+    await updateDoc(docRef, updateData);
+
+    return this.getByIdTopLevel(productId);
+  }
+
+  /**
+   * Deletes a product from the top-level collection (soft delete)
+   */
+  async deleteTopLevel(productId: string): Promise<void> {
+    await this.updateTopLevel(productId, {
+      isActive: false,
+    });
+  }
+
+  /**
+   * Assigns a product to a technology
+   */
+  async assignToTechnology(productId: string, technologyId: string): Promise<void> {
+    const docRef = doc(this.getTopLevelProductsRef(), productId);
+    await updateDoc(docRef, {
+      assignedTechnologyIds: arrayUnion(technologyId),
+      updatedAt: new Date(),
+    });
+    // Cloud Function will handle syncing to subcollection
+  }
+
+  /**
+   * Unassigns a product from a technology
+   */
+  async unassignFromTechnology(productId: string, technologyId: string): Promise<void> {
+    const docRef = doc(this.getTopLevelProductsRef(), productId);
+    await updateDoc(docRef, {
+      assignedTechnologyIds: arrayRemove(technologyId),
+      updatedAt: new Date(),
+    });
+    // Cloud Function will handle removing from subcollection
+  }
+
+  /**
+   * Gets products assigned to a specific technology
+   */
+  async getAssignedProducts(technologyId: string): Promise<Product[]> {
+    const q = query(
+      this.getTopLevelProductsRef(),
+      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(
+      this.getTopLevelProductsRef(),
+      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 all products for a brand (from top-level collection)
+   */
+  async getByBrand(brandId: string): Promise<Product[]> {
+    const q = query(
+      this.getTopLevelProductsRef(),
+      where('brandId', '==', brandId),
+      where('isActive', '==', true),
+      orderBy('name'),
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      doc =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Product),
+    );
+  }
 }

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

@@ -15,6 +15,7 @@ import {
   arrayUnion,
   arrayRemove,
   Firestore,
+  writeBatch,
 } from 'firebase/firestore';
 import { Technology, TECHNOLOGIES_COLLECTION, ITechnologyService } from '../types/technology.types';
 import { Requirement, RequirementType } from '../types/requirement.types';
@@ -29,6 +30,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
@@ -778,4 +780,113 @@ 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,
+    };
+  }
 }

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,17 @@ export interface Product {
   composition?: string;
   indications?: string[];
   contraindications?: ContraindicationDynamic[];
+  
+  // DEPRECATED: Kept for backward compatibility with subcollection structure
+  // These fields exist in old products in /technologies/{id}/products/
+  /** @deprecated Use assignedTechnologyIds instead */
+  technologyId?: string;
+  /** @deprecated Will be removed in future version */
+  technologyName?: string;
+  /** @deprecated Not needed in top-level collection */
+  categoryId?: string;
+  /** @deprecated Not needed in top-level collection */
+  subcategoryId?: string;
 }
 
 /**
@@ -47,9 +60,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 +163,7 @@ export interface IProductService {
   ): Promise<Product>;
 
   /**
+   * @deprecated Use getAllTopLevel instead
    * Gets a paginated list of all products, with optional filters.
    */
   getAll(options: {
@@ -73,6 +175,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 +185,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 +195,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 +222,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 +230,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/appointment/appointment.service.ts

@@ -412,20 +412,44 @@ export class AppointmentService extends BaseService {
       }
 
       // AUTO-CLEANUP: Remove invalid recommendedProcedures with empty notes BEFORE validation
-      if (data.metadata?.recommendedProcedures && Array.isArray(data.metadata.recommendedProcedures)) {
-        const validRecommendations = data.metadata.recommendedProcedures.filter(
-          (rec: any) => rec.note && typeof rec.note === 'string' && rec.note.trim().length > 0
-        );
+      console.log(
+        '[APPOINTMENT_SERVICE] 🔍 BEFORE CLEANUP - recommendedProcedures:',
+        JSON.stringify(data.metadata?.recommendedProcedures, null, 2),
+      );
+
+      if (
+        data.metadata?.recommendedProcedures &&
+        Array.isArray(data.metadata.recommendedProcedures)
+      ) {
+        const validRecommendations = data.metadata.recommendedProcedures.filter((rec: any) => {
+          const isValid = rec.note && typeof rec.note === 'string' && rec.note.trim().length > 0;
+          if (!isValid) {
+            console.log('[APPOINTMENT_SERVICE] ❌ INVALID recommendation found:', rec);
+          }
+          return isValid;
+        });
+
         if (validRecommendations.length !== data.metadata.recommendedProcedures.length) {
           console.log(
-            `[APPOINTMENT_SERVICE] Removing ${data.metadata.recommendedProcedures.length - validRecommendations.length} invalid recommended procedures with empty notes`
+            `[APPOINTMENT_SERVICE] 🧹 Removing ${
+              data.metadata.recommendedProcedures.length - validRecommendations.length
+            } invalid recommended procedures with empty notes`,
           );
           data.metadata.recommendedProcedures = validRecommendations;
+        } else {
+          console.log('[APPOINTMENT_SERVICE] ✅ All recommendedProcedures are valid');
         }
       }
 
+      console.log(
+        '[APPOINTMENT_SERVICE] 🔍 AFTER CLEANUP - recommendedProcedures:',
+        JSON.stringify(data.metadata?.recommendedProcedures, null, 2),
+      );
+
       // Validate input data
+      console.log('[APPOINTMENT_SERVICE] 🔍 Starting Zod validation...');
       const validatedData = await updateAppointmentSchema.parseAsync(data);
+      console.log('[APPOINTMENT_SERVICE] ✅ Zod validation passed!');
 
       // Update the appointment using the utility function
       const updatedAppointment = await updateAppointmentUtil(this.db, appointmentId, validatedData);