@blackcode_sa/metaestetics-api 1.13.0 → 1.13.2

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

@@ -370,6 +370,308 @@ export class ProcedureService extends BaseService {
     return savedDoc.data() as Procedure;
   }
 
+  /**
+   * Validates if a practitioner can perform a procedure based on certification requirements.
+   * 
+   * @param procedure - The procedure to check
+   * @param practitioner - The practitioner to validate
+   * @returns true if practitioner can perform the procedure, false otherwise
+   */
+  canPractitionerPerformProcedure(procedure: Procedure, practitioner: Practitioner): boolean {
+    if (!practitioner.certification) {
+      return false;
+    }
+
+    const requiredCert = procedure.certificationRequirement;
+    const practitionerCert = practitioner.certification;
+
+    // Check certification level
+    const levelOrder = [
+      'aesthetician',
+      'nurse_assistant',
+      'nurse',
+      'nurse_practitioner',
+      'physician_assistant',
+      'doctor',
+      'specialist',
+      'plastic_surgeon',
+    ];
+
+    const practitionerLevelIndex = levelOrder.indexOf(practitionerCert.level);
+    const requiredLevelIndex = levelOrder.indexOf(requiredCert.minimumLevel);
+
+    if (practitionerLevelIndex < requiredLevelIndex) {
+      return false;
+    }
+
+    // Check required specialties
+    const requiredSpecialties = requiredCert.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      const practitionerSpecialties = practitionerCert.specialties || [];
+      const hasAllRequired = requiredSpecialties.every(specialty =>
+        practitionerSpecialties.includes(specialty)
+      );
+      if (!hasAllRequired) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Clones an existing procedure for a target practitioner.
+   * This creates a new procedure document with the same data as the source procedure,
+   * but linked to the target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerId - The ID of the practitioner to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedure (e.g. price, duration, isActive)
+   * @returns The newly created procedure
+   */
+  async cloneProcedureForPractitioner(
+    sourceProcedureId: string,
+    targetPractitionerId: string,
+    overrides?: Partial<CreateProcedureData> & { isActive?: boolean }
+  ): Promise<Procedure> {
+    // 1. Fetch source procedure
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+
+    // 2. Fetch target practitioner
+    const practitionerRef = doc(this.db, PRACTITIONERS_COLLECTION, targetPractitionerId);
+    const practitionerSnapshot = await getDoc(practitionerRef);
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(`Target practitioner with ID ${targetPractitionerId} not found`);
+    }
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+
+    // 3. Validate certification
+    if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+      );
+    }
+
+    // 4. Check if practitioner already has a procedure with the same technology ID in this clinic branch
+    const existingProceduresQuery = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where('practitionerId', '==', targetPractitionerId),
+      where('clinicBranchId', '==', sourceProcedure.clinicBranchId),
+      where('isActive', '==', true)
+    );
+    const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+    const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+    
+    const hasSameTechnology = existingProcedures.some(
+      proc => proc.technology?.id === sourceProcedure.technology?.id
+    );
+    if (hasSameTechnology) {
+      throw new Error(
+        `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${sourceProcedure.technology?.name || sourceProcedure.technology?.id}" in this clinic branch`
+      );
+    }
+
+    // 5. Prepare data for new procedure
+    const newProcedureId = this.generateId();
+
+    // Create aggregated doctor info for the new procedure
+    const doctorInfo = {
+      id: practitioner.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || '',
+      photo:
+        typeof practitioner.basicInfo.profileImageUrl === 'string'
+          ? practitioner.basicInfo.profileImageUrl
+          : '',
+      rating: practitioner.reviewInfo?.averageRating || 0,
+      services: practitioner.procedures || [],
+    };
+
+    // Construct the new procedure object
+    // We copy everything from source, but override specific fields
+    const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
+      ...sourceProcedure,
+      id: newProcedureId,
+      practitionerId: targetPractitionerId,
+      doctorInfo, // Link to new doctor
+      
+      // Reset review info for the new procedure
+      reviewInfo: {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      },
+
+      // Apply any overrides if provided
+      ...(overrides?.price !== undefined && { price: overrides.price }),
+      ...(overrides?.duration !== undefined && { duration: overrides.duration }),
+      ...(overrides?.description !== undefined && { description: overrides.description }),
+      
+      // Ensure it's active by default unless specified otherwise
+      isActive: overrides?.isActive !== undefined ? overrides.isActive : true,
+    };
+
+    // 6. Save to Firestore
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, newProcedureId);
+    await setDoc(procedureRef, {
+      ...newProcedure,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+
+    // 7. Return the new procedure
+    const savedDoc = await getDoc(procedureRef);
+    return savedDoc.data() as Procedure;
+  }
+
+  /**
+   * Clones an existing procedure for multiple target practitioners.
+   * This creates new procedure documents with the same data as the source procedure,
+   * but linked to each target practitioner.
+   *
+   * @param sourceProcedureId - The ID of the procedure to clone
+   * @param targetPractitionerIds - Array of practitioner IDs to assign the cloned procedure to
+   * @param overrides - Optional overrides for the new procedures (e.g. price, duration, isActive)
+   * @returns Array of newly created procedures
+   */
+  async bulkCloneProcedureForPractitioners(
+    sourceProcedureId: string,
+    targetPractitionerIds: string[],
+    overrides?: Partial<CreateProcedureData> & { isActive?: boolean }
+  ): Promise<Procedure[]> {
+    if (!targetPractitionerIds || targetPractitionerIds.length === 0) {
+      throw new Error('At least one target practitioner ID is required');
+    }
+
+    // 1. Fetch source procedure
+    const sourceProcedure = await this.getProcedure(sourceProcedureId);
+    if (!sourceProcedure) {
+      throw new Error(`Source procedure with ID ${sourceProcedureId} not found`);
+    }
+
+    // 2. Fetch all target practitioners
+    const practitionerPromises = targetPractitionerIds.map(id =>
+      getDoc(doc(this.db, PRACTITIONERS_COLLECTION, id))
+    );
+    const practitionerSnapshots = await Promise.all(practitionerPromises);
+
+    // 3. Validate all practitioners exist, can perform the procedure, and don't already have the same technology
+    const practitioners: Practitioner[] = [];
+    const sourceTechnologyId = sourceProcedure.technology?.id;
+    
+    for (let i = 0; i < practitionerSnapshots.length; i++) {
+      const snapshot = practitionerSnapshots[i];
+      if (!snapshot.exists()) {
+        throw new Error(`Target practitioner with ID ${targetPractitionerIds[i]} not found`);
+      }
+      const practitioner = snapshot.data() as Practitioner;
+      
+      if (!this.canPractitionerPerformProcedure(sourceProcedure, practitioner)) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} does not meet the certification requirements for this procedure`
+        );
+      }
+
+      // Check if practitioner already has a procedure with the same technology ID in this clinic branch
+      const existingProceduresQuery = query(
+        collection(this.db, PROCEDURES_COLLECTION),
+        where('practitionerId', '==', practitioner.id),
+        where('clinicBranchId', '==', sourceProcedure.clinicBranchId),
+        where('isActive', '==', true)
+      );
+      const existingProceduresSnapshot = await getDocs(existingProceduresQuery);
+      const existingProcedures = existingProceduresSnapshot.docs.map(doc => doc.data() as Procedure);
+      
+      const hasSameTechnology = existingProcedures.some(
+        proc => proc.technology?.id === sourceTechnologyId
+      );
+      if (hasSameTechnology) {
+        throw new Error(
+          `Practitioner ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName} already has a procedure with technology "${sourceProcedure.technology?.name || sourceTechnologyId}" in this clinic branch`
+        );
+      }
+      
+      practitioners.push(practitioner);
+    }
+
+    // 4. Create procedures in batch
+    const batch = writeBatch(this.db);
+    const newProcedures: Omit<Procedure, 'createdAt' | 'updatedAt'>[] = [];
+
+    for (const practitioner of practitioners) {
+      const newProcedureId = this.generateId();
+
+      // Create aggregated doctor info for the new procedure
+      const doctorInfo = {
+        id: practitioner.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || '',
+        photo:
+          typeof practitioner.basicInfo.profileImageUrl === 'string'
+            ? practitioner.basicInfo.profileImageUrl
+            : '',
+        rating: practitioner.reviewInfo?.averageRating || 0,
+        services: practitioner.procedures || [],
+      };
+
+      // Construct the new procedure object
+      const newProcedure: Omit<Procedure, 'createdAt' | 'updatedAt'> = {
+        ...sourceProcedure,
+        id: newProcedureId,
+        practitionerId: practitioner.id,
+        doctorInfo,
+        
+        // Reset review info for the new procedure
+        reviewInfo: {
+          totalReviews: 0,
+          averageRating: 0,
+          effectivenessOfTreatment: 0,
+          outcomeExplanation: 0,
+          painManagement: 0,
+          followUpCare: 0,
+          valueForMoney: 0,
+          recommendationPercentage: 0,
+        },
+
+        // Apply any overrides if provided
+        ...(overrides?.price !== undefined && { price: overrides.price }),
+        ...(overrides?.duration !== undefined && { duration: overrides.duration }),
+        ...(overrides?.description !== undefined && { description: overrides.description }),
+        
+        // Ensure it's active by default unless specified otherwise
+        isActive: overrides?.isActive !== undefined ? overrides.isActive : true,
+      };
+
+      newProcedures.push(newProcedure);
+
+      // Add to batch
+      const procedureRef = doc(this.db, PROCEDURES_COLLECTION, newProcedureId);
+      batch.set(procedureRef, {
+        ...newProcedure,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      });
+    }
+
+    // 5. Commit batch
+    await batch.commit();
+
+    // 6. Fetch and return the created procedures
+    const createdProcedures = await Promise.all(
+      newProcedures.map(p => this.getProcedure(p.id))
+    );
+
+    return createdProcedures.filter((p): p is Procedure => p !== null);
+  }
+
   /**
    * Creates multiple procedures for a list of practitioners based on common data.
    * This method is optimized for bulk creation to reduce database reads and writes.
@@ -1088,6 +1390,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 +1415,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 +1447,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 +1472,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 +1499,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 +1579,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 +1663,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 +1754,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

package/src/services/reviews/reviews.service.ts

@@ -29,6 +29,57 @@ export class ReviewService extends BaseService {
     super(db, auth, app);
   }
 
+  /**
+   * Helper function to convert Firestore Timestamps to Date objects
+   * @param timestamp The timestamp to convert
+   * @returns A JavaScript Date object or null
+   */
+  private convertTimestamp(timestamp: any): Date {
+    if (!timestamp) {
+      return new Date();
+    }
+
+    // Firebase Timestamp object with __isTimestamp
+    if (timestamp && timestamp.__isTimestamp === true && typeof timestamp.seconds === 'number') {
+      return new Date(timestamp.seconds * 1000 + (timestamp.nanoseconds || 0) / 1000000);
+    }
+
+    // Firebase Firestore Timestamp with toDate method
+    if (timestamp && timestamp.toDate && typeof timestamp.toDate === 'function') {
+      return timestamp.toDate();
+    }
+
+    // Already a Date object
+    if (timestamp instanceof Date) {
+      return timestamp;
+    }
+
+    // String or number
+    if (typeof timestamp === 'string' || typeof timestamp === 'number') {
+      const date = new Date(timestamp);
+      if (!isNaN(date.getTime())) {
+        return date;
+      }
+    }
+
+    return new Date();
+  }
+
+  /**
+   * Converts a Firestore document to a Review object with proper date handling
+   * @param docData The raw Firestore document data
+   * @returns A Review object with properly converted dates
+   */
+  private convertDocToReview(docData: any): Review {
+    const review = docData as Review;
+    
+    // Convert main review timestamps (all sub-reviews share the same creation date)
+    review.createdAt = this.convertTimestamp(docData.createdAt);
+    review.updatedAt = this.convertTimestamp(docData.updatedAt);
+
+    return review;
+  }
+
   /**
    * Creates a new review
    * @param data - The review data to create
@@ -206,7 +257,7 @@ export class ReviewService extends BaseService {
       return null;
     }
 
-    const review = { ...docSnap.data(), id: reviewId } as Review;
+    const review = { ...this.convertDocToReview(docSnap.data()), id: reviewId };
 
     try {
       // Fetch the associated appointment to enhance with entity names
@@ -293,7 +344,7 @@ export class ReviewService extends BaseService {
   async getReviewsByPatient(patientId: string): Promise<Review[]> {
     const q = query(collection(this.db, REVIEWS_COLLECTION), where('patientId', '==', patientId));
     const snapshot = await getDocs(q);
-    const reviews = snapshot.docs.map(doc => doc.data() as Review);
+    const reviews = snapshot.docs.map(doc => this.convertDocToReview(doc.data()));
 
     // Enhance reviews with entity names from appointments
     const enhancedReviews = await Promise.all(
@@ -364,8 +415,8 @@ export class ReviewService extends BaseService {
     );
     const snapshot = await getDocs(q);
     const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
+      const review = this.convertDocToReview(doc.data());
+      return { ...review, id: doc.id };
     });
 
     console.log('🔍 ReviewService.getReviewsByClinic - Found reviews before enhancement:', {
@@ -459,8 +510,8 @@ export class ReviewService extends BaseService {
     );
     const snapshot = await getDocs(q);
     const reviews = snapshot.docs.map(doc => {
-      const data = doc.data() as Review;
-      return { ...data, id: doc.id };
+      const review = this.convertDocToReview(doc.data());
+      return { ...review, id: doc.id };
     });
 
     console.log('🔍 ReviewService.getReviewsByPractitioner - Found reviews before enhancement:', {
@@ -644,7 +695,7 @@ export class ReviewService extends BaseService {
       return null;
     }
 
-    return snapshot.docs[0].data() as Review;
+    return this.convertDocToReview(snapshot.docs[0].data());
   }
 
   /**