@blackcode_sa/metaestetics-api 1.12.0 → 1.12.2

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

@@ -20,57 +20,41 @@ import {
   startAfter,
   QueryConstraint,
   documentId,
-} from "firebase/firestore";
-import { BaseService } from "../base.service";
+} from 'firebase/firestore';
+import { BaseService } from '../base.service';
 import {
   Procedure,
   CreateProcedureData,
   UpdateProcedureData,
   PROCEDURES_COLLECTION,
   ProcedureSummaryInfo,
-} from "../../types/procedure";
-import {
-  createProcedureSchema,
-  updateProcedureSchema,
-} from "../../validations/procedure.schema";
-import { z } from "zod";
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import {
-  Category,
-  CATEGORIES_COLLECTION,
-} from "../../backoffice/types/category.types";
-import {
-  Subcategory,
-  SUBCATEGORIES_COLLECTION,
-} from "../../backoffice/types/subcategory.types";
-import {
-  Technology,
-  TECHNOLOGIES_COLLECTION,
-} from "../../backoffice/types/technology.types";
-import {
-  Product,
-  PRODUCTS_COLLECTION,
-} from "../../backoffice/types/product.types";
-import { CategoryService } from "../../backoffice/services/category.service";
-import { SubcategoryService } from "../../backoffice/services/subcategory.service";
-import { TechnologyService } from "../../backoffice/services/technology.service";
-import { ProductService } from "../../backoffice/services/product.service";
-import {
-  Practitioner,
-  PRACTITIONERS_COLLECTION,
-} from "../../types/practitioner";
+} from '../../types/procedure';
+import { createProcedureSchema, updateProcedureSchema } from '../../validations/procedure.schema';
+import { z } from 'zod';
+import { Auth } from 'firebase/auth';
+import { Firestore } from 'firebase/firestore';
+import { FirebaseApp } from 'firebase/app';
+import { Category, CATEGORIES_COLLECTION } from '../../backoffice/types/category.types';
+import { Subcategory, SUBCATEGORIES_COLLECTION } from '../../backoffice/types/subcategory.types';
+import { Technology, TECHNOLOGIES_COLLECTION } from '../../backoffice/types/technology.types';
+import { Product, PRODUCTS_COLLECTION } from '../../backoffice/types/product.types';
+import { CategoryService } from '../../backoffice/services/category.service';
+import { SubcategoryService } from '../../backoffice/services/subcategory.service';
+import { TechnologyService } from '../../backoffice/services/technology.service';
+import { ProductService } from '../../backoffice/services/product.service';
+import { Practitioner, PRACTITIONERS_COLLECTION } from '../../types/practitioner';
 import {
   CertificationLevel,
   CertificationSpecialty,
   ProcedureFamily,
   type TreatmentBenefitDynamic,
-} from "../../backoffice/types";
-import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
-import { ProcedureReviewInfo } from "../../types/reviews";
-import { distanceBetween, geohashQueryBounds } from "geofire-common";
-import { MediaService, MediaAccessLevel } from "../media/media.service";
+} from '../../backoffice/types';
+import { Currency, PricingMeasure } from '../../backoffice/types/static/pricing.types';
+import { Clinic, CLINICS_COLLECTION } from '../../types/clinic';
+import { ProcedureReviewInfo } from '../../types/reviews';
+import { distanceBetween, geohashQueryBounds } from 'geofire-common';
+import { MediaService, MediaAccessLevel } from '../media/media.service';
+import type { ProcedureProduct } from '../../backoffice/types/procedure-product.types';
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -87,7 +71,7 @@ export class ProcedureService extends BaseService {
     subcategoryService: SubcategoryService,
     technologyService: TechnologyService,
     productService: ProductService,
-    mediaService: MediaService
+    mediaService: MediaService,
   ) {
     super(db, auth, app);
     this.categoryService = categoryService;
@@ -107,25 +91,23 @@ export class ProcedureService extends BaseService {
   private async processMedia(
     media: string | File | Blob | null | undefined,
     ownerId: string,
-    collectionName: string
+    collectionName: string,
   ): Promise<string | null> {
     if (!media) return null;
 
     // If already a string URL, return it directly
-    if (typeof media === "string") {
+    if (typeof media === 'string') {
       return media;
     }
 
     // If it's a File, upload it using MediaService
     if (media instanceof File || media instanceof Blob) {
-      console.log(
-        `[ProcedureService] Uploading ${collectionName} media for ${ownerId}`
-      );
+      console.log(`[ProcedureService] Uploading ${collectionName} media for ${ownerId}`);
       const metadata = await this.mediaService.uploadMedia(
         media,
         ownerId,
         MediaAccessLevel.PUBLIC,
-        collectionName
+        collectionName,
       );
       return metadata.url;
     }
@@ -143,18 +125,14 @@ export class ProcedureService extends BaseService {
   private async processMediaArray(
     mediaArray: (string | File | Blob)[] | undefined,
     ownerId: string,
-    collectionName: string
+    collectionName: string,
   ): Promise<string[]> {
     if (!mediaArray || mediaArray.length === 0) return [];
 
     const result: string[] = [];
 
     for (const media of mediaArray) {
-      const processedUrl = await this.processMedia(
-        media,
-        ownerId,
-        collectionName
-      );
+      const processedUrl = await this.processMedia(media, ownerId, collectionName);
       if (processedUrl) {
         result.push(processedUrl);
       }
@@ -163,6 +141,46 @@ export class ProcedureService extends BaseService {
     return result;
   }
 
+  /**
+   * Transforms validated procedure product data (with productId) to ProcedureProduct objects (with full product)
+   * @param productsMetadata Array of validated procedure product data
+   * @param technologyId Technology ID to fetch products from
+   * @returns Array of ProcedureProduct objects with full product information
+   */
+  private async transformProductsMetadata(
+    productsMetadata: {
+      productId: string;
+      price: number;
+      currency: Currency;
+      pricingMeasure: PricingMeasure;
+      isDefault?: boolean;
+    }[],
+    technologyId: string,
+  ): Promise<ProcedureProduct[]> {
+    const transformedProducts: ProcedureProduct[] = [];
+
+    for (const productData of productsMetadata) {
+      // Fetch the full product object
+      const product = await this.productService.getById(technologyId, productData.productId);
+      if (!product) {
+        throw new Error(
+          `Product with ID ${productData.productId} not found for technology ${technologyId}`,
+        );
+      }
+
+      // Transform to ProcedureProduct
+      transformedProducts.push({
+        product,
+        price: productData.price,
+        currency: productData.currency,
+        pricingMeasure: productData.pricingMeasure,
+        isDefault: productData.isDefault,
+      });
+    }
+
+    return transformedProducts;
+  }
+
   /**
    * Creates a new procedure
    * @param data - The data for creating a new procedure
@@ -177,45 +195,27 @@ export class ProcedureService extends BaseService {
     // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
-      this.subcategoryService.getById(
-        validatedData.categoryId,
-        validatedData.subcategoryId
-      ),
+      this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
       this.technologyService.getById(validatedData.technologyId),
-      this.productService.getById(
-        validatedData.technologyId,
-        validatedData.productId
-      ),
+      this.productService.getById(validatedData.technologyId, validatedData.productId),
     ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
 
     // Get clinic and practitioner information for aggregation
-    const clinicRef = doc(
-      this.db,
-      CLINICS_COLLECTION,
-      validatedData.clinicBranchId
-    );
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
     const clinicSnapshot = await getDoc(clinicRef);
     if (!clinicSnapshot.exists()) {
-      throw new Error(
-        `Clinic with ID ${validatedData.clinicBranchId} not found`
-      );
+      throw new Error(`Clinic with ID ${validatedData.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data() as Clinic; // Assert type
 
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      validatedData.practitionerId
-    );
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, validatedData.practitionerId);
     const practitionerSnapshot = await getDoc(practitionerRef);
     if (!practitionerSnapshot.exists()) {
-      throw new Error(
-        `Practitioner with ID ${validatedData.practitionerId} not found`
-      );
+      throw new Error(`Practitioner with ID ${validatedData.practitionerId} not found`);
     }
     const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
@@ -225,23 +225,29 @@ export class ProcedureService extends BaseService {
       processedPhotos = await this.processMediaArray(
         validatedData.photos,
         procedureId,
-        "procedure-photos"
+        'procedure-photos',
       );
     }
 
+    // Transform productsMetadata from validation format to ProcedureProduct format
+    const transformedProductsMetadata = await this.transformProductsMetadata(
+      validatedData.productsMetadata,
+      validatedData.technologyId,
+    );
+
     // Create aggregated clinic info for the procedure document
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -250,32 +256,33 @@ export class ProcedureService extends BaseService {
     const doctorInfo = {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-      description: practitioner.basicInfo.bio || "",
+      description: practitioner.basicInfo.bio || '',
       photo:
-        typeof practitioner.basicInfo.profileImageUrl === "string"
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
           ? practitioner.basicInfo.profileImageUrl
-          : "", // Default to empty string if not a processed URL
+          : '', // Default to empty string if not a processed URL
       rating: practitioner.reviewInfo?.averageRating || 0,
       services: practitioner.procedures || [],
     };
 
     // Create the procedure object
-    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+    const { productsMetadata: _, ...validatedDataWithoutProductsMetadata } = validatedData;
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
       id: procedureId,
-      ...validatedData,
+      ...validatedDataWithoutProductsMetadata,
       // Ensure nameLower is always set even if omitted by client
-      nameLower:
-        (validatedData as any).nameLower || validatedData.name.toLowerCase(),
+      nameLower: (validatedData as any).nameLower || validatedData.name.toLowerCase(),
       photos: processedPhotos,
       category, // Embed full objects
       subcategory,
       technology,
       product,
+      productsMetadata: transformedProductsMetadata, // Use transformed data, not original
       blockingConditions: technology.blockingConditions,
       contraindications: technology.contraindications || [],
-      contraindicationIds: technology.contraindications?.map((c) => c.id) || [],
+      contraindicationIds: technology.contraindications?.map(c => c.id) || [],
       treatmentBenefits: technology.benefits,
-      treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
+      treatmentBenefitIds: technology.benefits?.map(b => b.id) || [],
       preRequirements: technology.requirements.pre,
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
@@ -318,12 +325,12 @@ export class ProcedureService extends BaseService {
    * @returns A promise that resolves to an array of the newly created procedures.
    */
   async bulkCreateProcedures(
-    baseData: Omit<CreateProcedureData, "practitionerId">,
-    practitionerIds: string[]
+    baseData: Omit<CreateProcedureData, 'practitionerId'>,
+    practitionerIds: string[],
   ): Promise<Procedure[]> {
     // 1. Validation
     if (!practitionerIds || practitionerIds.length === 0) {
-      throw new Error("Practitioner IDs array cannot be empty.");
+      throw new Error('Practitioner IDs array cannot be empty.');
     }
 
     // Add a dummy practitionerId for the validation schema to pass
@@ -331,28 +338,19 @@ export class ProcedureService extends BaseService {
     const validatedData = createProcedureSchema.parse(validationData);
 
     // 2. Fetch common data once to avoid redundant reads
-    const [category, subcategory, technology, product, clinicSnapshot] =
-      await Promise.all([
-        this.categoryService.getById(validatedData.categoryId),
-        this.subcategoryService.getById(
-          validatedData.categoryId,
-          validatedData.subcategoryId
-        ),
-        this.technologyService.getById(validatedData.technologyId),
-        this.productService.getById(
-          validatedData.technologyId,
-          validatedData.productId
-        ),
-        getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
-      ]);
+    const [category, subcategory, technology, product, clinicSnapshot] = await Promise.all([
+      this.categoryService.getById(validatedData.categoryId),
+      this.subcategoryService.getById(validatedData.categoryId, validatedData.subcategoryId),
+      this.technologyService.getById(validatedData.technologyId),
+      this.productService.getById(validatedData.technologyId, validatedData.productId),
+      getDoc(doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId)),
+    ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
     if (!clinicSnapshot.exists()) {
-      throw new Error(
-        `Clinic with ID ${validatedData.clinicBranchId} not found`
-      );
+      throw new Error(`Clinic with ID ${validatedData.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data() as Clinic;
 
@@ -363,10 +361,16 @@ export class ProcedureService extends BaseService {
       processedPhotos = await this.processMediaArray(
         validatedData.photos,
         batchId,
-        "procedure-photos-batch"
+        'procedure-photos-batch',
       );
     }
 
+    // Transform productsMetadata from validation format to ProcedureProduct format
+    const transformedProductsMetadata = await this.transformProductsMetadata(
+      validatedData.productsMetadata,
+      validatedData.technologyId,
+    );
+
     // 4. Fetch all practitioner data efficiently
     const practitionersMap = new Map<string, Practitioner>();
     // Use 'in' query in chunks of 30, as this is the Firestore limit
@@ -374,10 +378,10 @@ export class ProcedureService extends BaseService {
       const chunk = practitionerIds.slice(i, i + 30);
       const practitionersQuery = query(
         collection(this.db, PRACTITIONERS_COLLECTION),
-        where(documentId(), "in", chunk)
+        where(documentId(), 'in', chunk),
       );
       const practitionersSnapshot = await getDocs(practitionersQuery);
-      practitionersSnapshot.docs.forEach((doc) => {
+      practitionersSnapshot.docs.forEach(doc => {
         practitionersMap.set(doc.id, doc.data() as Practitioner);
       });
     }
@@ -385,12 +389,8 @@ export class ProcedureService extends BaseService {
     // Verify all practitioners were found
     if (practitionersMap.size !== practitionerIds.length) {
       const foundIds = Array.from(practitionersMap.keys());
-      const notFoundIds = practitionerIds.filter(
-        (id) => !foundIds.includes(id)
-      );
-      throw new Error(
-        `The following practitioners were not found: ${notFoundIds.join(", ")}`
-      );
+      const notFoundIds = practitionerIds.filter(id => !foundIds.includes(id));
+      throw new Error(`The following practitioners were not found: ${notFoundIds.join(', ')}`);
     }
 
     // 5. Use a Firestore batch for atomic creation
@@ -399,15 +399,15 @@ export class ProcedureService extends BaseService {
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -418,11 +418,11 @@ export class ProcedureService extends BaseService {
       const doctorInfo = {
         id: practitioner.id,
         name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-        description: practitioner.basicInfo.bio || "",
+        description: practitioner.basicInfo.bio || '',
         photo:
-          typeof practitioner.basicInfo.profileImageUrl === "string"
+          typeof practitioner.basicInfo.profileImageUrl === 'string'
             ? practitioner.basicInfo.profileImageUrl
-            : "",
+            : '',
         rating: practitioner.reviewInfo?.averageRating || 0,
         services: practitioner.procedures || [],
       };
@@ -432,23 +432,23 @@ export class ProcedureService extends BaseService {
       const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
 
       // Construct the new procedure, reusing common data
-      const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+      const { productsMetadata: _, ...validatedDataWithoutProductsMetadata } = validatedData;
+      const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
         id: procedureId,
-        ...validatedData,
-        nameLower:
-          (validatedData as any).nameLower || validatedData.name.toLowerCase(),
+        ...validatedDataWithoutProductsMetadata,
+        nameLower: (validatedData as any).nameLower || validatedData.name.toLowerCase(),
         practitionerId: practitionerId, // Override practitionerId with the correct one
         photos: processedPhotos,
         category,
         subcategory,
         technology,
         product,
+        productsMetadata: transformedProductsMetadata, // Use transformed data, not original
         blockingConditions: technology.blockingConditions,
         contraindications: technology.contraindications || [],
-        contraindicationIds:
-          technology.contraindications?.map((c) => c.id) || [],
+        contraindicationIds: technology.contraindications?.map(c => c.id) || [],
         treatmentBenefits: technology.benefits,
-        treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
+        treatmentBenefitIds: technology.benefits?.map(b => b.id) || [],
         preRequirements: technology.requirements.pre,
         postRequirements: technology.requirements.post,
         certificationRequirement: technology.certificationRequirement,
@@ -482,12 +482,9 @@ export class ProcedureService extends BaseService {
     const fetchedProcedures: Procedure[] = [];
     for (let i = 0; i < createdProcedureIds.length; i += 30) {
       const chunk = createdProcedureIds.slice(i, i + 30);
-      const q = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where(documentId(), "in", chunk)
-      );
+      const q = query(collection(this.db, PROCEDURES_COLLECTION), where(documentId(), 'in', chunk));
       const snapshot = await getDocs(q);
-      snapshot.forEach((doc) => {
+      snapshot.forEach(doc => {
         fetchedProcedures.push(doc.data() as Procedure);
       });
     }
@@ -516,16 +513,14 @@ export class ProcedureService extends BaseService {
    * @param clinicBranchId - The ID of the clinic branch
    * @returns List of procedures
    */
-  async getProceduresByClinicBranch(
-    clinicBranchId: string
-  ): Promise<Procedure[]> {
+  async getProceduresByClinicBranch(clinicBranchId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("clinicBranchId", "==", clinicBranchId),
-      where("isActive", "==", true)
+      where('clinicBranchId', '==', clinicBranchId),
+      where('isActive', '==', true),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map((doc) => doc.data() as Procedure);
+    return snapshot.docs.map(doc => doc.data() as Procedure);
   }
 
   /**
@@ -533,16 +528,14 @@ export class ProcedureService extends BaseService {
    * @param practitionerId - The ID of the practitioner
    * @returns List of procedures
    */
-  async getProceduresByPractitioner(
-    practitionerId: string
-  ): Promise<Procedure[]> {
+  async getProceduresByPractitioner(practitionerId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("practitionerId", "==", practitionerId),
-      where("isActive", "==", true)
+      where('practitionerId', '==', practitionerId),
+      where('isActive', '==', true),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map((doc) => doc.data() as Procedure);
+    return snapshot.docs.map(doc => doc.data() as Procedure);
   }
 
   /**
@@ -550,16 +543,14 @@ export class ProcedureService extends BaseService {
    * @param practitionerId - The ID of the practitioner
    * @returns List of inactive procedures
    */
-  async getInactiveProceduresByPractitioner(
-    practitionerId: string
-  ): Promise<Procedure[]> {
+  async getInactiveProceduresByPractitioner(practitionerId: string): Promise<Procedure[]> {
     const q = query(
       collection(this.db, PROCEDURES_COLLECTION),
-      where("practitionerId", "==", practitionerId),
-      where("isActive", "==", false)
+      where('practitionerId', '==', practitionerId),
+      where('isActive', '==', false),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map((doc) => doc.data() as Procedure);
+    return snapshot.docs.map(doc => doc.data() as Procedure);
   }
 
   /**
@@ -568,10 +559,7 @@ export class ProcedureService extends BaseService {
    * @param data - The data to update the procedure with
    * @returns The updated procedure
    */
-  async updateProcedure(
-    id: string,
-    data: UpdateProcedureData
-  ): Promise<Procedure> {
+  async updateProcedure(id: string, data: UpdateProcedureData): Promise<Procedure> {
     const validatedData = updateProcedureSchema.parse(data);
     const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
     const procedureSnapshot = await getDoc(procedureRef);
@@ -581,7 +569,21 @@ export class ProcedureService extends BaseService {
     }
 
     const existingProcedure = procedureSnapshot.data() as Procedure;
-    let updatedProcedureData: Partial<Procedure> = { ...validatedData };
+    let updatedProcedureData: Partial<Procedure> = {};
+
+    // Copy validated simple fields
+    if (validatedData.name !== undefined) updatedProcedureData.name = validatedData.name;
+    if (validatedData.description !== undefined)
+      updatedProcedureData.description = validatedData.description;
+    if (validatedData.price !== undefined) updatedProcedureData.price = validatedData.price;
+    if (validatedData.currency !== undefined)
+      updatedProcedureData.currency = validatedData.currency;
+    if (validatedData.pricingMeasure !== undefined)
+      updatedProcedureData.pricingMeasure = validatedData.pricingMeasure;
+    if (validatedData.duration !== undefined)
+      updatedProcedureData.duration = validatedData.duration;
+    if (validatedData.isActive !== undefined)
+      updatedProcedureData.isActive = validatedData.isActive;
 
     let practitionerChanged = false;
     let clinicChanged = false;
@@ -595,54 +597,54 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.photos = await this.processMediaArray(
         validatedData.photos,
         id,
-        "procedure-photos"
+        'procedure-photos',
+      );
+    }
+
+    // Transform productsMetadata if provided
+    if (validatedData.productsMetadata !== undefined) {
+      const technologyId = validatedData.technologyId ?? existingProcedure.technology.id;
+      if (!technologyId) {
+        throw new Error('Technology ID is required for updating products metadata');
+      }
+      updatedProcedureData.productsMetadata = await this.transformProductsMetadata(
+        validatedData.productsMetadata,
+        technologyId,
       );
     }
 
     // --- Prepare updates and fetch new related data if IDs change ---
 
     // Handle Practitioner Change
-    if (
-      validatedData.practitionerId &&
-      validatedData.practitionerId !== oldPractitionerId
-    ) {
+    if (validatedData.practitionerId && validatedData.practitionerId !== oldPractitionerId) {
       practitionerChanged = true;
       const newPractitionerRef = doc(
         this.db,
         PRACTITIONERS_COLLECTION,
-        validatedData.practitionerId
+        validatedData.practitionerId,
       );
       const newPractitionerSnap = await getDoc(newPractitionerRef);
       if (!newPractitionerSnap.exists())
-        throw new Error(
-          `New Practitioner ${validatedData.practitionerId} not found`
-        );
+        throw new Error(`New Practitioner ${validatedData.practitionerId} not found`);
       newPractitioner = newPractitionerSnap.data() as Practitioner;
       // Update doctorInfo within the procedure document
       updatedProcedureData.doctorInfo = {
         id: newPractitioner.id,
         name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
-        description: newPractitioner.basicInfo.bio || "",
+        description: newPractitioner.basicInfo.bio || '',
         photo:
-          typeof newPractitioner.basicInfo.profileImageUrl === "string"
+          typeof newPractitioner.basicInfo.profileImageUrl === 'string'
             ? newPractitioner.basicInfo.profileImageUrl
-            : "", // Default to empty string if not a processed URL
+            : '', // Default to empty string if not a processed URL
         rating: newPractitioner.reviewInfo?.averageRating || 0,
         services: newPractitioner.procedures || [],
       };
     }
 
     // Handle Clinic Change
-    if (
-      validatedData.clinicBranchId &&
-      validatedData.clinicBranchId !== oldClinicId
-    ) {
+    if (validatedData.clinicBranchId && validatedData.clinicBranchId !== oldClinicId) {
       clinicChanged = true;
-      const newClinicRef = doc(
-        this.db,
-        CLINICS_COLLECTION,
-        validatedData.clinicBranchId
-      );
+      const newClinicRef = doc(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId);
       const newClinicSnap = await getDoc(newClinicRef);
       if (!newClinicSnap.exists())
         throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
@@ -651,15 +653,15 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.clinicInfo = {
         id: newClinic.id,
         name: newClinic.name,
-        description: newClinic.description || "",
+        description: newClinic.description || '',
         featuredPhoto:
           newClinic.featuredPhotos && newClinic.featuredPhotos.length > 0
-            ? typeof newClinic.featuredPhotos[0] === "string"
+            ? typeof newClinic.featuredPhotos[0] === 'string'
               ? newClinic.featuredPhotos[0]
-              : ""
-            : typeof newClinic.coverPhoto === "string"
+              : ''
+            : typeof newClinic.coverPhoto === 'string'
             ? newClinic.coverPhoto
-            : "",
+            : '',
         location: newClinic.location,
         contactInfo: newClinic.contactInfo,
       };
@@ -671,11 +673,8 @@ export class ProcedureService extends BaseService {
       updatedProcedureData.nameLower = validatedData.name.toLowerCase();
     }
     if (validatedData.categoryId) {
-      const category = await this.categoryService.getById(
-        validatedData.categoryId
-      );
-      if (!category)
-        throw new Error(`Category ${validatedData.categoryId} not found`);
+      const category = await this.categoryService.getById(validatedData.categoryId);
+      if (!category) throw new Error(`Category ${validatedData.categoryId} not found`);
       updatedProcedureData.category = category;
       finalCategoryId = category.id; // Update finalCategoryId if category changed
     }
@@ -684,58 +683,45 @@ export class ProcedureService extends BaseService {
     if (validatedData.subcategoryId && finalCategoryId) {
       const subcategory = await this.subcategoryService.getById(
         finalCategoryId,
-        validatedData.subcategoryId
+        validatedData.subcategoryId,
       );
       if (!subcategory)
         throw new Error(
-          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`
+          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`,
         );
       updatedProcedureData.subcategory = subcategory;
     } else if (validatedData.subcategoryId) {
-      console.warn(
-        "Attempted to update subcategory without a valid categoryId"
-      );
+      console.warn('Attempted to update subcategory without a valid categoryId');
     }
 
     let finalTechnologyId = existingProcedure.technology.id;
     if (validatedData.technologyId) {
-      const technology = await this.technologyService.getById(
-        validatedData.technologyId
-      );
-      if (!technology)
-        throw new Error(`Technology ${validatedData.technologyId} not found`);
+      const technology = await this.technologyService.getById(validatedData.technologyId);
+      if (!technology) throw new Error(`Technology ${validatedData.technologyId} not found`);
       updatedProcedureData.technology = technology;
       finalTechnologyId = technology.id; // Update finalTechnologyId if technology changed
       // Update related fields derived from technology
       updatedProcedureData.blockingConditions = technology.blockingConditions;
-      updatedProcedureData.contraindications =
-        technology.contraindications || [];
-      updatedProcedureData.contraindicationIds =
-        technology.contraindications?.map((c) => c.id) || [];
+      updatedProcedureData.contraindications = technology.contraindications || [];
+      updatedProcedureData.contraindicationIds = technology.contraindications?.map(c => c.id) || [];
       updatedProcedureData.treatmentBenefits = technology.benefits;
-      updatedProcedureData.treatmentBenefitIds =
-        technology.benefits?.map((b) => b.id) || [];
+      updatedProcedureData.treatmentBenefitIds = technology.benefits?.map(b => b.id) || [];
       updatedProcedureData.preRequirements = technology.requirements.pre;
       updatedProcedureData.postRequirements = technology.requirements.post;
-      updatedProcedureData.certificationRequirement =
-        technology.certificationRequirement;
-      updatedProcedureData.documentationTemplates =
-        technology.documentationTemplates || [];
+      updatedProcedureData.certificationRequirement = technology.certificationRequirement;
+      updatedProcedureData.documentationTemplates = technology.documentationTemplates || [];
     }
 
     // Only fetch product if its ID is provided AND we have a valid finalTechnologyId
     if (validatedData.productId && finalTechnologyId) {
-      const product = await this.productService.getById(
-        finalTechnologyId,
-        validatedData.productId
-      );
+      const product = await this.productService.getById(finalTechnologyId, validatedData.productId);
       if (!product)
         throw new Error(
-          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`
+          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`,
         );
       updatedProcedureData.product = product;
     } else if (validatedData.productId) {
-      console.warn("Attempted to update product without a valid technologyId");
+      console.warn('Attempted to update product without a valid technologyId');
     }
 
     // Update the procedure document
@@ -819,7 +805,7 @@ export class ProcedureService extends BaseService {
    */
   async getAllProcedures(
     pagination?: number,
-    lastDoc?: any
+    lastDoc?: any,
   ): Promise<{ procedures: Procedure[]; lastDoc: any }> {
     try {
       const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
@@ -827,31 +813,26 @@ export class ProcedureService extends BaseService {
 
       // Apply pagination if specified
       if (pagination && pagination > 0) {
-        const { limit, startAfter } = await import("firebase/firestore"); // Use dynamic import if needed top-level
+        const { limit, startAfter } = await import('firebase/firestore'); // Use dynamic import if needed top-level
 
         if (lastDoc) {
           proceduresQuery = query(
             proceduresCollection,
-            orderBy("name"), // Use imported orderBy
+            orderBy('name'), // Use imported orderBy
             startAfter(lastDoc),
-            limit(pagination)
+            limit(pagination),
           );
         } else {
-          proceduresQuery = query(
-            proceduresCollection,
-            orderBy("name"),
-            limit(pagination)
-          ); // Use imported orderBy
+          proceduresQuery = query(proceduresCollection, orderBy('name'), limit(pagination)); // Use imported orderBy
         }
       } else {
-        proceduresQuery = query(proceduresCollection, orderBy("name")); // Use imported orderBy
+        proceduresQuery = query(proceduresCollection, orderBy('name')); // Use imported orderBy
       }
 
       const proceduresSnapshot = await getDocs(proceduresQuery);
-      const lastVisible =
-        proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
+      const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
 
-      const procedures = proceduresSnapshot.docs.map((doc) => {
+      const procedures = proceduresSnapshot.docs.map(doc => {
         const data = doc.data() as Procedure;
         return {
           ...data,
@@ -864,7 +845,7 @@ export class ProcedureService extends BaseService {
         lastDoc: lastVisible,
       };
     } catch (error) {
-      console.error("[PROCEDURE_SERVICE] Error getting all procedures:", error);
+      console.error('[PROCEDURE_SERVICE] Error getting all procedures:', error);
       throw error;
     }
   }
@@ -913,32 +894,26 @@ export class ProcedureService extends BaseService {
     lastDoc: any;
   }> {
     try {
-      console.log(
-        "[PROCEDURE_SERVICE] Starting procedure filtering with multiple strategies"
-      );
+      console.log('[PROCEDURE_SERVICE] Starting procedure filtering with multiple strategies');
 
       // Geo query debug i validacija
       if (filters.location && filters.radiusInKm) {
-        console.log("[PROCEDURE_SERVICE] Executing geo query:", {
+        console.log('[PROCEDURE_SERVICE] Executing geo query:', {
           location: filters.location,
           radius: filters.radiusInKm,
-          serviceName: "ProcedureService",
+          serviceName: 'ProcedureService',
         });
 
         // Validacija location podataka
         if (!filters.location.latitude || !filters.location.longitude) {
-          console.warn(
-            "[PROCEDURE_SERVICE] Invalid location data:",
-            filters.location
-          );
+          console.warn('[PROCEDURE_SERVICE] Invalid location data:', filters.location);
           filters.location = undefined;
           filters.radiusInKm = undefined;
         }
       }
 
       // Handle geo queries separately (they work differently)
-      const isGeoQuery =
-        filters.location && filters.radiusInKm && filters.radiusInKm > 0;
+      const isGeoQuery = filters.location && filters.radiusInKm && filters.radiusInKm > 0;
       if (isGeoQuery) {
         return this.handleGeoQuery(filters);
       }
@@ -949,55 +924,39 @@ export class ProcedureService extends BaseService {
 
         // Active status filter
         if (filters.isActive !== undefined) {
-          constraints.push(where("isActive", "==", filters.isActive));
+          constraints.push(where('isActive', '==', filters.isActive));
         } else {
-          constraints.push(where("isActive", "==", true));
+          constraints.push(where('isActive', '==', true));
         }
 
         // Filter constraints
         if (filters.procedureFamily) {
-          constraints.push(where("family", "==", filters.procedureFamily));
+          constraints.push(where('family', '==', filters.procedureFamily));
         }
         if (filters.procedureCategory) {
-          constraints.push(
-            where("category.id", "==", filters.procedureCategory)
-          );
+          constraints.push(where('category.id', '==', filters.procedureCategory));
         }
         if (filters.procedureSubcategory) {
-          constraints.push(
-            where("subcategory.id", "==", filters.procedureSubcategory)
-          );
+          constraints.push(where('subcategory.id', '==', filters.procedureSubcategory));
         }
         if (filters.procedureTechnology) {
-          constraints.push(
-            where("technology.id", "==", filters.procedureTechnology)
-          );
+          constraints.push(where('technology.id', '==', filters.procedureTechnology));
         }
         if (filters.minPrice !== undefined) {
-          constraints.push(where("price", ">=", filters.minPrice));
+          constraints.push(where('price', '>=', filters.minPrice));
         }
         if (filters.maxPrice !== undefined) {
-          constraints.push(where("price", "<=", filters.maxPrice));
+          constraints.push(where('price', '<=', filters.maxPrice));
         }
         if (filters.minRating !== undefined) {
-          constraints.push(
-            where("reviewInfo.averageRating", ">=", filters.minRating)
-          );
+          constraints.push(where('reviewInfo.averageRating', '>=', filters.minRating));
         }
         if (filters.maxRating !== undefined) {
-          constraints.push(
-            where("reviewInfo.averageRating", "<=", filters.maxRating)
-          );
+          constraints.push(where('reviewInfo.averageRating', '<=', filters.maxRating));
         }
         if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
           const benefitIdsToMatch = filters.treatmentBenefits;
-          constraints.push(
-            where(
-              "treatmentBenefitIds",
-              "array-contains-any",
-              benefitIdsToMatch
-            )
-          );
+          constraints.push(where('treatmentBenefitIds', 'array-contains-any', benefitIdsToMatch));
         }
 
         return constraints;
@@ -1006,17 +965,15 @@ export class ProcedureService extends BaseService {
       // Strategy 1: Try nameLower search if nameSearch exists
       if (filters.nameSearch && filters.nameSearch.trim()) {
         try {
-          console.log(
-            "[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search"
-          );
+          console.log('[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
-          constraints.push(where("nameLower", ">=", searchTerm));
-          constraints.push(where("nameLower", "<=", searchTerm + "\uf8ff"));
-          constraints.push(orderBy("nameLower"));
+          constraints.push(where('nameLower', '>=', searchTerm));
+          constraints.push(where('nameLower', '<=', searchTerm + '\uf8ff'));
+          constraints.push(orderBy('nameLower'));
 
           if (filters.lastDoc) {
-            if (typeof filters.lastDoc.data === "function") {
+            if (typeof filters.lastDoc.data === 'function') {
               constraints.push(startAfter(filters.lastDoc));
             } else if (Array.isArray(filters.lastDoc)) {
               constraints.push(startAfter(...filters.lastDoc));
@@ -1026,22 +983,17 @@ export class ProcedureService extends BaseService {
           }
           constraints.push(limit(filters.pagination || 10));
 
-          const q = query(
-            collection(this.db, PROCEDURES_COLLECTION),
-            ...constraints
-          );
+          const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
           const procedures = querySnapshot.docs.map(
-            (doc) => ({ ...doc.data(), id: doc.id } as Procedure)
+            doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
               : null;
 
-          console.log(
-            `[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`
-          );
+          console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
 
           // Fix Load More - ako je broj rezultata manji od pagination, nema više
           if (procedures.length < (filters.pagination || 10)) {
@@ -1049,24 +1001,22 @@ export class ProcedureService extends BaseService {
           }
           return { procedures, lastDoc };
         } catch (error) {
-          console.log("[PROCEDURE_SERVICE] Strategy 1 failed:", error);
+          console.log('[PROCEDURE_SERVICE] Strategy 1 failed:', error);
         }
       }
 
       // Strategy 2: Try name field search as fallback
       if (filters.nameSearch && filters.nameSearch.trim()) {
         try {
-          console.log(
-            "[PROCEDURE_SERVICE] Strategy 2: Trying name field search"
-          );
+          console.log('[PROCEDURE_SERVICE] Strategy 2: Trying name field search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
-          constraints.push(where("name", ">=", searchTerm));
-          constraints.push(where("name", "<=", searchTerm + "\uf8ff"));
-          constraints.push(orderBy("name"));
+          constraints.push(where('name', '>=', searchTerm));
+          constraints.push(where('name', '<=', searchTerm + '\uf8ff'));
+          constraints.push(orderBy('name'));
 
           if (filters.lastDoc) {
-            if (typeof filters.lastDoc.data === "function") {
+            if (typeof filters.lastDoc.data === 'function') {
               constraints.push(startAfter(filters.lastDoc));
             } else if (Array.isArray(filters.lastDoc)) {
               constraints.push(startAfter(...filters.lastDoc));
@@ -1076,22 +1026,17 @@ export class ProcedureService extends BaseService {
           }
           constraints.push(limit(filters.pagination || 10));
 
-          const q = query(
-            collection(this.db, PROCEDURES_COLLECTION),
-            ...constraints
-          );
+          const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
           const procedures = querySnapshot.docs.map(
-            (doc) => ({ ...doc.data(), id: doc.id } as Procedure)
+            doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
               : null;
 
-          console.log(
-            `[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`
-          );
+          console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
 
           // Fix Load More - ako je broj rezultata manji od pagination, nema više
           if (procedures.length < (filters.pagination || 10)) {
@@ -1099,20 +1044,20 @@ export class ProcedureService extends BaseService {
           }
           return { procedures, lastDoc };
         } catch (error) {
-          console.log("[PROCEDURE_SERVICE] Strategy 2 failed:", error);
+          console.log('[PROCEDURE_SERVICE] Strategy 2 failed:', error);
         }
       }
 
       // Strategy 3: orderBy createdAt with client-side filtering
       try {
         console.log(
-          "[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering"
+          '[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering',
         );
         const constraints = getBaseConstraints();
-        constraints.push(orderBy("createdAt", "desc"));
+        constraints.push(orderBy('createdAt', 'desc'));
 
         if (filters.lastDoc) {
-          if (typeof filters.lastDoc.data === "function") {
+          if (typeof filters.lastDoc.data === 'function') {
             constraints.push(startAfter(filters.lastDoc));
           } else if (Array.isArray(filters.lastDoc)) {
             constraints.push(startAfter(...filters.lastDoc));
@@ -1122,25 +1067,18 @@ export class ProcedureService extends BaseService {
         }
         constraints.push(limit(filters.pagination || 10));
 
-        const q = query(
-          collection(this.db, PROCEDURES_COLLECTION),
-          ...constraints
-        );
+        const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
         let procedures = querySnapshot.docs.map(
-          (doc) => ({ ...doc.data(), id: doc.id } as Procedure)
+          doc => ({ ...doc.data(), id: doc.id } as Procedure),
         );
 
         // Apply all client-side filters using centralized function
         procedures = this.applyInMemoryFilters(procedures, filters);
 
         const lastDoc =
-          querySnapshot.docs.length > 0
-            ? querySnapshot.docs[querySnapshot.docs.length - 1]
-            : null;
-        console.log(
-          `[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`
-        );
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`);
 
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         if (procedures.length < (filters.pagination || 10)) {
@@ -1148,37 +1086,30 @@ export class ProcedureService extends BaseService {
         }
         return { procedures, lastDoc };
       } catch (error) {
-        console.log("[PROCEDURE_SERVICE] Strategy 3 failed:", error);
+        console.log('[PROCEDURE_SERVICE] Strategy 3 failed:', error);
       }
 
       // Strategy 4: Minimal query fallback
       try {
-        console.log("[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback");
+        console.log('[PROCEDURE_SERVICE] Strategy 4: Minimal query fallback');
         const constraints: QueryConstraint[] = [
-          where("isActive", "==", true),
-          orderBy("createdAt", "desc"),
+          where('isActive', '==', true),
+          orderBy('createdAt', 'desc'),
           limit(filters.pagination || 10),
         ];
 
-        const q = query(
-          collection(this.db, PROCEDURES_COLLECTION),
-          ...constraints
-        );
+        const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
         let procedures = querySnapshot.docs.map(
-          (doc) => ({ ...doc.data(), id: doc.id } as Procedure)
+          doc => ({ ...doc.data(), id: doc.id } as Procedure),
         );
 
         // Apply all client-side filters using centralized function
         procedures = this.applyInMemoryFilters(procedures, filters);
 
         const lastDoc =
-          querySnapshot.docs.length > 0
-            ? querySnapshot.docs[querySnapshot.docs.length - 1]
-            : null;
-        console.log(
-          `[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`
-        );
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
 
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         if (procedures.length < (filters.pagination || 10)) {
@@ -1186,16 +1117,14 @@ export class ProcedureService extends BaseService {
         }
         return { procedures, lastDoc };
       } catch (error) {
-        console.log("[PROCEDURE_SERVICE] Strategy 4 failed:", error);
+        console.log('[PROCEDURE_SERVICE] Strategy 4 failed:', error);
       }
 
       // All strategies failed
-      console.log(
-        "[PROCEDURE_SERVICE] All strategies failed, returning empty result"
-      );
+      console.log('[PROCEDURE_SERVICE] All strategies failed, returning empty result');
       return { procedures: [], lastDoc: null };
     } catch (error) {
-      console.error("[PROCEDURE_SERVICE] Error filtering procedures:", error);
+      console.error('[PROCEDURE_SERVICE] Error filtering procedures:', error);
       return { procedures: [], lastDoc: null };
     }
   }
@@ -1206,105 +1135,98 @@ export class ProcedureService extends BaseService {
    */
   private applyInMemoryFilters(
     procedures: Procedure[],
-    filters: any
+    filters: any,
   ): (Procedure & { distance?: number })[] {
     let filteredProcedures = [...procedures]; // Create copy to avoid mutating original
 
     // Name search filter
     if (filters.nameSearch && filters.nameSearch.trim()) {
       const searchTerm = filters.nameSearch.trim().toLowerCase();
-      filteredProcedures = filteredProcedures.filter((procedure) => {
-        const name = (procedure.name || "").toLowerCase();
-        const nameLower = procedure.nameLower || "";
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const name = (procedure.name || '').toLowerCase();
+        const nameLower = procedure.nameLower || '';
         return name.includes(searchTerm) || nameLower.includes(searchTerm);
       });
-      console.log(
-        `[PROCEDURE_SERVICE] Applied name filter, results: ${filteredProcedures.length}`
-      );
+      console.log(`[PROCEDURE_SERVICE] Applied name filter, results: ${filteredProcedures.length}`);
     }
 
     // Price filtering
     if (filters.minPrice !== undefined || filters.maxPrice !== undefined) {
-      filteredProcedures = filteredProcedures.filter((procedure) => {
+      filteredProcedures = filteredProcedures.filter(procedure => {
         const price = procedure.price || 0;
-        if (filters.minPrice !== undefined && price < filters.minPrice)
-          return false;
-        if (filters.maxPrice !== undefined && price > filters.maxPrice)
-          return false;
+        if (filters.minPrice !== undefined && price < filters.minPrice) return false;
+        if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
         return true;
       });
       console.log(
-        `[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`,
       );
     }
 
     // Rating filtering
     if (filters.minRating !== undefined || filters.maxRating !== undefined) {
-      filteredProcedures = filteredProcedures.filter((procedure) => {
+      filteredProcedures = filteredProcedures.filter(procedure => {
         const rating = procedure.reviewInfo?.averageRating || 0;
-        if (filters.minRating !== undefined && rating < filters.minRating)
-          return false;
-        if (filters.maxRating !== undefined && rating > filters.maxRating)
-          return false;
+        if (filters.minRating !== undefined && rating < filters.minRating) return false;
+        if (filters.maxRating !== undefined && rating > filters.maxRating) return false;
         return true;
       });
       console.log(
-        `[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`,
       );
     }
 
     // Treatment benefits filtering
     if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
       const benefitIdsToMatch = filters.treatmentBenefits;
-      filteredProcedures = filteredProcedures.filter((procedure) => {
+      filteredProcedures = filteredProcedures.filter(procedure => {
         const procedureBenefitIds = procedure.treatmentBenefitIds || [];
         return benefitIdsToMatch.some((benefitId: string) =>
-          procedureBenefitIds.includes(benefitId)
+          procedureBenefitIds.includes(benefitId),
         );
       });
       console.log(
-        `[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`,
       );
     }
 
     // Procedure family filtering
     if (filters.procedureFamily) {
       filteredProcedures = filteredProcedures.filter(
-        (procedure) => procedure.family === filters.procedureFamily
+        procedure => procedure.family === filters.procedureFamily,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`,
       );
     }
 
     // Category filtering
     if (filters.procedureCategory) {
       filteredProcedures = filteredProcedures.filter(
-        (procedure) => procedure.category?.id === filters.procedureCategory
+        procedure => procedure.category?.id === filters.procedureCategory,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`,
       );
     }
 
     // Subcategory filtering
     if (filters.procedureSubcategory) {
       filteredProcedures = filteredProcedures.filter(
-        (procedure) =>
-          procedure.subcategory?.id === filters.procedureSubcategory
+        procedure => procedure.subcategory?.id === filters.procedureSubcategory,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`,
       );
     }
 
     // Technology filtering
     if (filters.procedureTechnology) {
       filteredProcedures = filteredProcedures.filter(
-        (procedure) => procedure.technology?.id === filters.procedureTechnology
+        procedure => procedure.technology?.id === filters.procedureTechnology,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`,
       );
     }
 
@@ -1312,7 +1234,7 @@ export class ProcedureService extends BaseService {
     if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
       const location = filters.location;
       const radiusInKm = filters.radiusInKm;
-      filteredProcedures = filteredProcedures.filter((procedure) => {
+      filteredProcedures = filteredProcedures.filter(procedure => {
         const clinicLocation = procedure.clinicInfo?.location;
         if (!clinicLocation?.latitude || !clinicLocation?.longitude) {
           return false;
@@ -1321,7 +1243,7 @@ export class ProcedureService extends BaseService {
         const distance =
           distanceBetween(
             [location.latitude, location.longitude],
-            [clinicLocation.latitude, clinicLocation.longitude]
+            [clinicLocation.latitude, clinicLocation.longitude],
           ) / 1000; // Convert to km
 
         // Attach distance for frontend sorting/display
@@ -1329,14 +1251,10 @@ export class ProcedureService extends BaseService {
 
         return distance <= radiusInKm;
       });
-      console.log(
-        `[PROCEDURE_SERVICE] Applied geo filter, results: ${filteredProcedures.length}`
-      );
+      console.log(`[PROCEDURE_SERVICE] Applied geo filter, results: ${filteredProcedures.length}`);
 
       // Sort by distance when geo filtering is applied
-      filteredProcedures.sort(
-        (a, b) => ((a as any).distance || 0) - ((b as any).distance || 0)
-      );
+      filteredProcedures.sort((a, b) => ((a as any).distance || 0) - ((b as any).distance || 0));
     }
 
     return filteredProcedures as (Procedure & { distance?: number })[];
@@ -1346,7 +1264,7 @@ export class ProcedureService extends BaseService {
     procedures: (Procedure & { distance?: number })[];
     lastDoc: any;
   }> {
-    console.log("[PROCEDURE_SERVICE] Executing geo query with geohash bounds");
+    console.log('[PROCEDURE_SERVICE] Executing geo query with geohash bounds');
     try {
       const location = filters.location;
       const radiusInKm = filters.radiusInKm;
@@ -1355,33 +1273,22 @@ export class ProcedureService extends BaseService {
         return Promise.resolve({ procedures: [], lastDoc: null });
       }
 
-      const bounds = geohashQueryBounds(
-        [location.latitude, location.longitude],
-        radiusInKm * 1000
-      );
+      const bounds = geohashQueryBounds([location.latitude, location.longitude], radiusInKm * 1000);
 
-      const fetches = bounds.map((b) => {
+      const fetches = bounds.map(b => {
         const constraints: QueryConstraint[] = [
-          where("clinicInfo.location.geohash", ">=", b[0]),
-          where("clinicInfo.location.geohash", "<=", b[1]),
-          where(
-            "isActive",
-            "==",
-            filters.isActive !== undefined ? filters.isActive : true
-          ),
+          where('clinicInfo.location.geohash', '>=', b[0]),
+          where('clinicInfo.location.geohash', '<=', b[1]),
+          where('isActive', '==', filters.isActive !== undefined ? filters.isActive : true),
         ];
-        return getDocs(
-          query(collection(this.db, PROCEDURES_COLLECTION), ...constraints)
-        );
+        return getDocs(query(collection(this.db, PROCEDURES_COLLECTION), ...constraints));
       });
 
       return Promise.all(fetches)
-        .then((snaps) => {
+        .then(snaps => {
           const collected: Procedure[] = [];
-          snaps.forEach((snap) => {
-            snap.docs.forEach((d) =>
-              collected.push({ ...(d.data() as Procedure), id: d.id })
-            );
+          snaps.forEach(snap => {
+            snap.docs.forEach(d => collected.push({ ...(d.data() as Procedure), id: d.id }));
           });
 
           // Deduplicate by id
@@ -1399,29 +1306,26 @@ export class ProcedureService extends BaseService {
           let startIndex = 0;
           if (
             filters.lastDoc &&
-            typeof filters.lastDoc === "object" &&
+            typeof filters.lastDoc === 'object' &&
             (filters.lastDoc as any).id
           ) {
-            const idx = procedures.findIndex(
-              (p) => p.id === (filters.lastDoc as any).id
-            );
+            const idx = procedures.findIndex(p => p.id === (filters.lastDoc as any).id);
             if (idx >= 0) startIndex = idx + 1;
           }
           const page = procedures.slice(startIndex, startIndex + pageSize);
-          const newLastDoc =
-            page.length === pageSize ? page[page.length - 1] : null;
+          const newLastDoc = page.length === pageSize ? page[page.length - 1] : null;
 
           console.log(
-            `[PROCEDURE_SERVICE] Geo query success: ${page.length} (of ${procedures.length}) within ${radiusInKm}km`
+            `[PROCEDURE_SERVICE] Geo query success: ${page.length} (of ${procedures.length}) within ${radiusInKm}km`,
           );
           return { procedures: page, lastDoc: newLastDoc };
         })
-        .catch((err) => {
-          console.error("[PROCEDURE_SERVICE] Geo bounds fetch failed:", err);
+        .catch(err => {
+          console.error('[PROCEDURE_SERVICE] Geo bounds fetch failed:', err);
           return { procedures: [], lastDoc: null };
         });
     } catch (error) {
-      console.error("[PROCEDURE_SERVICE] Geo query failed:", error);
+      console.error('[PROCEDURE_SERVICE] Geo query failed:', error);
       return Promise.resolve({ procedures: [], lastDoc: null });
     }
   }
@@ -1433,7 +1337,7 @@ export class ProcedureService extends BaseService {
    * @returns The created procedure
    */
   async createConsultationProcedure(
-    data: Omit<CreateProcedureData, "productId">
+    data: Omit<CreateProcedureData, 'productId'>,
   ): Promise<Procedure> {
     // Generate procedure ID first so we can use it for media uploads
     const procedureId = this.generateId();
@@ -1447,7 +1351,7 @@ export class ProcedureService extends BaseService {
     ]);
 
     if (!category || !subcategory || !technology) {
-      throw new Error("One or more required base entities not found");
+      throw new Error('One or more required base entities not found');
     }
 
     // Get clinic and practitioner information for aggregation
@@ -1458,11 +1362,7 @@ export class ProcedureService extends BaseService {
     }
     const clinic = clinicSnapshot.data() as Clinic;
 
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      data.practitionerId
-    );
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, data.practitionerId);
     const practitionerSnapshot = await getDoc(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(`Practitioner with ID ${data.practitionerId} not found`);
@@ -1472,26 +1372,28 @@ export class ProcedureService extends BaseService {
     // Process photos if provided
     let processedPhotos: string[] = [];
     if (data.photos && data.photos.length > 0) {
-      processedPhotos = await this.processMediaArray(
-        data.photos,
-        procedureId,
-        "procedure-photos"
-      );
+      processedPhotos = await this.processMediaArray(data.photos, procedureId, 'procedure-photos');
     }
 
+    // Transform productsMetadata from validation format to ProcedureProduct format
+    const transformedProductsMetadata = await this.transformProductsMetadata(
+      data.productsMetadata,
+      data.technologyId,
+    );
+
     // Create aggregated clinic info for the procedure document
     const clinicInfo = {
       id: clinicSnapshot.id,
       name: clinic.name,
-      description: clinic.description || "",
+      description: clinic.description || '',
       featuredPhoto:
         clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? typeof clinic.featuredPhotos[0] === "string"
+          ? typeof clinic.featuredPhotos[0] === 'string'
             ? clinic.featuredPhotos[0]
-            : ""
-          : typeof clinic.coverPhoto === "string"
+            : ''
+          : typeof clinic.coverPhoto === 'string'
           ? clinic.coverPhoto
-          : "",
+          : '',
       location: clinic.location,
       contactInfo: clinic.contactInfo,
     };
@@ -1500,22 +1402,22 @@ export class ProcedureService extends BaseService {
     const doctorInfo = {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-      description: practitioner.basicInfo.bio || "",
+      description: practitioner.basicInfo.bio || '',
       photo:
-        typeof practitioner.basicInfo.profileImageUrl === "string"
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
           ? practitioner.basicInfo.profileImageUrl
-          : "",
+          : '',
       rating: practitioner.reviewInfo?.averageRating || 0,
       services: practitioner.procedures || [],
     };
 
     // Create a placeholder product for consultation procedures
     const consultationProduct: Product = {
-      id: "consultation-no-product",
-      name: "No Product Required",
-      description: "Consultation procedures do not require specific products",
-      brandId: "consultation-brand",
-      brandName: "Consultation",
+      id: 'consultation-no-product',
+      name: 'No Product Required',
+      description: 'Consultation procedures do not require specific products',
+      brandId: 'consultation-brand',
+      brandName: 'Consultation',
       technologyId: data.technologyId,
       technologyName: technology.name,
       categoryId: technology.categoryId,
@@ -1526,20 +1428,22 @@ export class ProcedureService extends BaseService {
     };
 
     // Create the procedure object
-    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+    const { productsMetadata: _, ...dataWithoutProductsMetadata } = data;
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
       id: procedureId,
-      ...data,
+      ...dataWithoutProductsMetadata,
       nameLower: (data as any).nameLower || data.name.toLowerCase(),
       photos: processedPhotos,
       category,
       subcategory,
       technology,
       product: consultationProduct, // Use placeholder product
+      productsMetadata: transformedProductsMetadata, // Use transformed data, not original
       blockingConditions: technology.blockingConditions,
       contraindications: technology.contraindications || [],
-      contraindicationIds: technology.contraindications?.map((c) => c.id) || [],
+      contraindicationIds: technology.contraindications?.map(c => c.id) || [],
       treatmentBenefits: technology.benefits,
-      treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
+      treatmentBenefitIds: technology.benefits?.map(b => b.id) || [],
       preRequirements: technology.requirements.pre,
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
@@ -1590,14 +1494,14 @@ export class ProcedureService extends BaseService {
   > {
     const proceduresRef = collection(this.db, PROCEDURES_COLLECTION);
     const snapshot = await getDocs(proceduresRef);
-    const proceduresForMap = snapshot.docs.map((doc) => {
+    const proceduresForMap = snapshot.docs.map(doc => {
       const data = doc.data();
       return {
         id: doc.id,
         name: data.name,
         clinicId: data.clinicInfo?.id,
         clinicName: data.clinicInfo?.name,
-        address: data.clinicInfo?.location?.address || "",
+        address: data.clinicInfo?.location?.address || '',
         latitude: data.clinicInfo?.location?.latitude,
         longitude: data.clinicInfo?.location?.longitude,
       };