@blackcode_sa/metaestetics-api 1.12.67 → 1.12.69

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

@@ -1088,6 +1088,14 @@ export class ProcedureService extends BaseService {
           console.log('[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          
+          // Check if we have nested field filters that might conflict with orderBy
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          
+          if (hasNestedFilters) {
+            console.log('[PROCEDURE_SERVICE] Strategy 1: Has nested filters, will apply client-side after query');
+          }
+          
           constraints.push(where('nameLower', '>=', searchTerm));
           constraints.push(where('nameLower', '<=', searchTerm + '\uf8ff'));
           constraints.push(orderBy('nameLower'));
@@ -1105,9 +1113,15 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
+          
+          // Apply client-side filters for nested fields if needed
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1131,6 +1145,14 @@ export class ProcedureService extends BaseService {
           console.log('[PROCEDURE_SERVICE] Strategy 2: Trying name field search');
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          
+          // Check if we have nested field filters that might conflict with orderBy
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          
+          if (hasNestedFilters) {
+            console.log('[PROCEDURE_SERVICE] Strategy 2: Has nested filters, will apply client-side after query');
+          }
+          
           constraints.push(where('name', '>=', searchTerm));
           constraints.push(where('name', '<=', searchTerm + '\uf8ff'));
           constraints.push(orderBy('name'));
@@ -1148,9 +1170,15 @@ export class ProcedureService extends BaseService {
 
           const q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             doc => ({ ...doc.data(), id: doc.id } as Procedure),
           );
+          
+          // Apply client-side filters for nested fields if needed
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1169,11 +1197,66 @@ export class ProcedureService extends BaseService {
       }
 
       // Strategy 3: orderBy createdAt with client-side filtering
+      // NOTE: This strategy excludes nested field filters (technology.id, category.id, subcategory.id)
+      // from Firestore query because Firestore doesn't support orderBy on different field
+      // when using where on nested fields without a composite index.
+      // These filters are applied client-side instead.
       try {
         console.log(
           '[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering',
+          {
+            procedureTechnology: filters.procedureTechnology,
+            hasTechnologyFilter: !!filters.procedureTechnology,
+          },
+        );
+        
+        // Build constraints WITHOUT nested field filters (these will be applied client-side)
+        const constraints: QueryConstraint[] = [];
+        
+        // Active status filter
+        if (filters.isActive !== undefined) {
+          constraints.push(where('isActive', '==', filters.isActive));
+        } else {
+          constraints.push(where('isActive', '==', true));
+        }
+        
+        // Only include non-nested field filters in Firestore query
+        if (filters.procedureFamily) {
+          constraints.push(where('family', '==', filters.procedureFamily));
+        }
+        if (filters.practitionerId) {
+          constraints.push(where('practitionerId', '==', filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where('clinicBranchId', '==', filters.clinicId));
+        }
+        if (filters.minPrice !== undefined) {
+          constraints.push(where('price', '>=', filters.minPrice));
+        }
+        if (filters.maxPrice !== undefined) {
+          constraints.push(where('price', '<=', filters.maxPrice));
+        }
+        if (filters.minRating !== undefined) {
+          constraints.push(where('reviewInfo.averageRating', '>=', filters.minRating));
+        }
+        if (filters.maxRating !== undefined) {
+          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));
+        }
+        
+        // NOTE: We intentionally EXCLUDE these nested field filters from Firestore query:
+        // - filters.procedureTechnology (technology.id)
+        // - filters.procedureCategory (category.id)
+        // - filters.procedureSubcategory (subcategory.id)
+        // These will be applied client-side in applyInMemoryFilters
+        
+        console.log(
+          '[PROCEDURE_SERVICE] Strategy 3 Firestore constraints (nested filters excluded):',
+          constraints.map(c => (c as any).fieldPath || 'unknown'),
         );
-        const constraints = getBaseConstraints();
         constraints.push(orderBy('createdAt', 'desc'));
 
         if (filters.lastDoc) {
@@ -1194,7 +1277,20 @@ export class ProcedureService extends BaseService {
         );
 
         // Apply all client-side filters using centralized function
+        console.log('[PROCEDURE_SERVICE] Before applyInMemoryFilters (Strategy 3):', {
+          procedureCount: procedures.length,
+          procedureTechnology: filters.procedureTechnology,
+          filtersObject: {
+            procedureTechnology: filters.procedureTechnology,
+            procedureFamily: filters.procedureFamily,
+            procedureCategory: filters.procedureCategory,
+            procedureSubcategory: filters.procedureSubcategory,
+          },
+        });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        console.log('[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):', {
+          procedureCount: procedures.length,
+        });
 
         const lastDoc =
           querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
@@ -1265,6 +1361,14 @@ export class ProcedureService extends BaseService {
   ): (Procedure & { distance?: number })[] {
     let filteredProcedures = [...procedures]; // Create copy to avoid mutating original
 
+    // Debug: Log what filters we received
+    console.log('[PROCEDURE_SERVICE] applyInMemoryFilters called:', {
+      procedureCount: procedures.length,
+      procedureTechnology: filters.procedureTechnology,
+      hasTechnologyFilter: !!filters.procedureTechnology,
+      allFilterKeys: Object.keys(filters).filter(k => filters[k] !== undefined && filters[k] !== null),
+    });
+
     // Name search filter
     if (filters.nameSearch && filters.nameSearch.trim()) {
       const searchTerm = filters.nameSearch.trim().toLowerCase();
@@ -1348,12 +1452,21 @@ export class ProcedureService extends BaseService {
 
     // Technology filtering
     if (filters.procedureTechnology) {
+      const beforeCount = filteredProcedures.length;
       filteredProcedures = filteredProcedures.filter(
         procedure => procedure.technology?.id === filters.procedureTechnology,
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`,
+        `[PROCEDURE_SERVICE] Applied technology filter (${filters.procedureTechnology}), before: ${beforeCount}, after: ${filteredProcedures.length}`,
       );
+      // Log sample technology IDs for debugging
+      if (beforeCount > filteredProcedures.length) {
+        const filteredOut = procedures
+          .filter(p => p.technology?.id !== filters.procedureTechnology)
+          .slice(0, 3)
+          .map(p => ({ id: p.id, techId: p.technology?.id, name: p.name }));
+        console.log('[PROCEDURE_SERVICE] Filtered out sample procedures:', filteredOut);
+      }
     }
 
     // Practitioner filtering
@@ -1497,9 +1610,9 @@ export class ProcedureService extends BaseService {
     // Get references to related entities (Category, Subcategory, Technology)
     // For consultation, we don't need a product
     const [category, subcategory, technology] = await Promise.all([
-      this.categoryService.getById(data.categoryId),
-      this.subcategoryService.getById(data.categoryId, data.subcategoryId),
-      this.technologyService.getById(data.technologyId),
+      this.categoryService.getByIdInternal(data.categoryId),
+      this.subcategoryService.getByIdInternal(data.categoryId, data.subcategoryId),
+      this.technologyService.getByIdInternal(data.technologyId),
     ]);
 
     if (!category || !subcategory || !technology) {

package/src/types/notifications/index.ts

@@ -21,6 +21,7 @@ export enum NotificationType {
 
   // --- Patient Engagement ---
   REVIEW_REQUEST = "reviewRequest", // Request for patient review post-appointment
+  PROCEDURE_RECOMMENDATION = "procedureRecommendation", // Doctor recommended a procedure for follow-up
 
   // --- Payment Related (Examples) ---
   PAYMENT_DUE = "paymentDue",
@@ -231,6 +232,25 @@ export interface ReviewRequestNotification extends BaseNotification {
   procedureName?: string;
 }
 
+/**
+ * Notification for when a doctor recommends a procedure for follow-up.
+ * Example: "Dr. Smith recommended [Procedure Name] for you. Suggested timeframe: in 2 weeks"
+ */
+export interface ProcedureRecommendationNotification extends BaseNotification {
+  notificationType: NotificationType.PROCEDURE_RECOMMENDATION;
+  appointmentId: string; // The appointment where recommendation was made
+  recommendationId: string; // Format: `${appointmentId}:${index}`
+  procedureId: string;
+  procedureName: string;
+  practitionerName: string;
+  clinicName: string;
+  note?: string; // Doctor's note about the recommendation
+  timeframe: {
+    value: number;
+    unit: 'day' | 'week' | 'month' | 'year';
+  };
+}
+
 /**
  * Generic notification for direct messages or announcements.
  */
@@ -261,5 +281,6 @@ export type Notification =
   | FormReminderNotification
   | FormSubmissionConfirmationNotification
   | ReviewRequestNotification
+  | ProcedureRecommendationNotification
   | GeneralMessageNotification
   | PaymentConfirmationNotification;