@blackcode_sa/metaestetics-api 1.11.3 → 1.12.1

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

@@ -20,39 +20,62 @@ 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,
-} from '../../backoffice/types';
-import { Clinic, CLINICS_COLLECTION } from '../../types/clinic';
-import { ProcedureReviewInfo } from '../../types/reviews';
-import { distanceBetween, geohashQueryBounds } from 'geofire-common';
-import { TreatmentBenefit } from '../../backoffice/types/static/treatment-benefit.types';
-import { MediaService, MediaAccessLevel } from '../media/media.service';
+  type TreatmentBenefitDynamic,
+} 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;
@@ -69,7 +92,7 @@ export class ProcedureService extends BaseService {
     subcategoryService: SubcategoryService,
     technologyService: TechnologyService,
     productService: ProductService,
-    mediaService: MediaService,
+    mediaService: MediaService
   ) {
     super(db, auth, app);
     this.categoryService = categoryService;
@@ -89,23 +112,25 @@ 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;
     }
@@ -123,14 +148,18 @@ 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);
       }
@@ -139,6 +168,49 @@ 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
@@ -153,27 +225,45 @@ 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
 
@@ -183,23 +273,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,
     };
@@ -208,29 +304,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 newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...validatedData,
       // 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,
       blockingConditions: technology.blockingConditions,
       contraindications: technology.contraindications || [],
+      contraindicationIds: technology.contraindications?.map((c) => c.id) || [],
       treatmentBenefits: technology.benefits,
+      treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
       preRequirements: technology.requirements.pre,
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
@@ -273,12 +373,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
@@ -286,19 +386,28 @@ 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;
 
@@ -309,10 +418,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
@@ -320,7 +435,7 @@ 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) => {
@@ -331,8 +446,12 @@ 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
@@ -341,15 +460,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,
     };
@@ -360,11 +479,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 || [],
       };
@@ -374,19 +493,24 @@ 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 newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
         id: procedureId,
         ...validatedData,
-        nameLower: (validatedData as any).nameLower || validatedData.name.toLowerCase(),
+        nameLower:
+          (validatedData as any).nameLower || validatedData.name.toLowerCase(),
         practitionerId: practitionerId, // Override practitionerId with the correct one
         photos: processedPhotos,
         category,
         subcategory,
         technology,
         product,
+        productsMetadata: transformedProductsMetadata,
         blockingConditions: technology.blockingConditions,
         contraindications: technology.contraindications || [],
+        contraindicationIds:
+          technology.contraindications?.map((c) => c.id) || [],
         treatmentBenefits: technology.benefits,
+        treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
         preRequirements: technology.requirements.pre,
         postRequirements: technology.requirements.post,
         certificationRequirement: technology.certificationRequirement,
@@ -420,7 +544,10 @@ 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) => {
         fetchedProcedures.push(doc.data() as Procedure);
@@ -451,11 +578,13 @@ 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);
@@ -466,11 +595,13 @@ 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);
@@ -481,11 +612,13 @@ 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);
@@ -497,7 +630,10 @@ 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);
@@ -507,7 +643,23 @@ 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;
@@ -521,42 +673,70 @@ 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`);
@@ -565,15 +745,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,
       };
@@ -585,8 +765,11 @@ 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
     }
@@ -595,42 +778,58 @@ 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.treatmentBenefits = technology.benefits;
+      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
@@ -714,7 +913,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);
@@ -722,24 +921,29 @@ 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 data = doc.data() as Procedure;
@@ -754,7 +958,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;
     }
   }
@@ -766,7 +970,7 @@ export class ProcedureService extends BaseService {
    *
    * @param filters - Various filters to apply
    * @param filters.nameSearch - Optional search text for procedure name
-   * @param filters.treatmentBenefits - Optional array of treatment benefits to filter by
+   * @param filters.treatmentBenefitIds - Optional array of treatment benefits to filter by
    * @param filters.procedureFamily - Optional procedure family to filter by
    * @param filters.procedureCategory - Optional procedure category to filter by
    * @param filters.procedureSubcategory - Optional procedure subcategory to filter by
@@ -784,7 +988,7 @@ export class ProcedureService extends BaseService {
    */
   async getProceduresByFilters(filters: {
     nameSearch?: string;
-    treatmentBenefits?: TreatmentBenefit[];
+    treatmentBenefits?: string[];
     procedureFamily?: ProcedureFamily;
     procedureCategory?: string;
     procedureSubcategory?: string;
@@ -803,26 +1007,32 @@ 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);
       }
@@ -833,39 +1043,55 @@ 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 benefitsToMatch = filters.treatmentBenefits;
-          constraints.push(where('treatmentBenefits', 'array-contains-any', benefitsToMatch));
+          const benefitIdsToMatch = filters.treatmentBenefits;
+          constraints.push(
+            where(
+              "treatmentBenefitIds",
+              "array-contains-any",
+              benefitIdsToMatch
+            )
+          );
         }
 
         return constraints;
@@ -874,15 +1100,17 @@ 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));
@@ -892,17 +1120,22 @@ 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)) {
@@ -910,22 +1143,24 @@ 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));
@@ -935,17 +1170,22 @@ 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)) {
@@ -953,20 +1193,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));
@@ -976,18 +1216,25 @@ 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)) {
@@ -995,30 +1242,37 @@ 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)) {
@@ -1026,14 +1280,16 @@ 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 };
     }
   }
@@ -1044,7 +1300,7 @@ 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
 
@@ -1052,23 +1308,27 @@ export class ProcedureService extends BaseService {
     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 || '';
+        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) => {
         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}`
       );
     }
 
@@ -1076,64 +1336,69 @@ export class ProcedureService extends BaseService {
     if (filters.minRating !== undefined || filters.maxRating !== undefined) {
       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 benefitsToMatch = filters.treatmentBenefits;
+      const benefitIdsToMatch = filters.treatmentBenefits;
       filteredProcedures = filteredProcedures.filter((procedure) => {
-        const procedureBenefits = procedure.treatmentBenefits || [];
-        return benefitsToMatch.some((benefit: any) => procedureBenefits.includes(benefit));
+        const procedureBenefitIds = procedure.treatmentBenefitIds || [];
+        return benefitIdsToMatch.some((benefitId: string) =>
+          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}`
       );
     }
 
@@ -1150,7 +1415,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
@@ -1158,19 +1423,24 @@ 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 })[];
   }
 
-  private handleGeoQuery(
-    filters: any,
-  ): Promise<{ procedures: (Procedure & { distance?: number })[]; lastDoc: any }> {
-    console.log('[PROCEDURE_SERVICE] Executing geo query with geohash bounds');
+  private handleGeoQuery(filters: any): Promise<{
+    procedures: (Procedure & { distance?: number })[];
+    lastDoc: any;
+  }> {
+    console.log("[PROCEDURE_SERVICE] Executing geo query with geohash bounds");
     try {
       const location = filters.location;
       const radiusInKm = filters.radiusInKm;
@@ -1179,22 +1449,33 @@ 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 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) => {
           const collected: Procedure[] = [];
           snaps.forEach((snap) => {
-            snap.docs.forEach((d) => collected.push({ ...(d.data() as Procedure), id: d.id }));
+            snap.docs.forEach((d) =>
+              collected.push({ ...(d.data() as Procedure), id: d.id })
+            );
           });
 
           // Deduplicate by id
@@ -1212,26 +1493,29 @@ 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);
+          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 });
     }
   }
@@ -1243,7 +1527,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();
@@ -1257,7 +1541,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
@@ -1268,7 +1552,11 @@ 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`);
@@ -1278,22 +1566,32 @@ 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,
     };
@@ -1302,31 +1600,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
-          : '',
+          : "",
       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,
+      subcategoryId: technology.subcategoryId,
       isActive: true,
       createdAt: new Date(),
       updatedAt: new Date(),
     };
 
     // Create the procedure object
-    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
+    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...data,
       nameLower: (data as any).nameLower || data.name.toLowerCase(),
@@ -1335,9 +1635,12 @@ export class ProcedureService extends BaseService {
       subcategory,
       technology,
       product: consultationProduct, // Use placeholder product
+      productsMetadata: transformedProductsMetadata,
       blockingConditions: technology.blockingConditions,
       contraindications: technology.contraindications || [],
+      contraindicationIds: technology.contraindications?.map((c) => c.id) || [],
       treatmentBenefits: technology.benefits,
+      treatmentBenefitIds: technology.benefits?.map((b) => b.id) || [],
       preRequirements: technology.requirements.pre,
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
@@ -1395,7 +1698,7 @@ export class ProcedureService extends BaseService {
         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,
       };