@blackcode_sa/metaestetics-api 1.5.28 → 1.5.29

package/src/services/practitioner/practitioner.service.ts

@@ -10,6 +10,13 @@ import {
   deleteDoc,
   Timestamp,
   serverTimestamp,
+  limit,
+  startAfter,
+  orderBy,
+  writeBatch,
+  arrayUnion,
+  arrayRemove,
+  FieldValue,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -23,7 +30,9 @@ import {
   PractitionerToken,
   CreatePractitionerTokenData,
   PractitionerTokenStatus,
+  PractitionerBasicInfo,
 } from "../../types/practitioner";
+import { ProcedureSummaryInfo } from "../../types/procedure";
 import { ClinicService } from "../clinic/clinic.service";
 import {
   practitionerSchema,
@@ -36,6 +45,11 @@ import { z } from "zod";
 import { Auth } from "firebase/auth";
 import { Firestore } from "firebase/firestore";
 import { FirebaseApp } from "firebase/app";
+import { PractitionerReviewInfo } from "../../types/reviews";
+import { distanceBetween } from "geofire-common";
+import { CertificationSpecialty } from "../../backoffice/types/static/certification.types";
+import { Clinic, DoctorInfo, CLINICS_COLLECTION } from "../../types/clinic";
+import { ClinicInfo } from "../../types/profile";
 
 export class PractitionerService extends BaseService {
   private clinicService?: ClinicService;
@@ -64,6 +78,78 @@ export class PractitionerService extends BaseService {
     this.clinicService = clinicService;
   }
 
+  /**
+   * Aggregates clinic information for a practitioner
+   * @param clinicIds Array of clinic IDs the practitioner works at
+   * @returns Array of ClinicInfo objects
+   */
+  private async aggregateClinicInfo(
+    clinicIds: string[]
+  ): Promise<ClinicInfo[]> {
+    const clinicsInfo: ClinicInfo[] = [];
+
+    for (const clinicId of clinicIds) {
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) continue;
+
+      clinicsInfo.push({
+        id: clinic.id,
+        featuredPhoto:
+          clinic.featuredPhotos && clinic.featuredPhotos.length > 0
+            ? clinic.featuredPhotos[0]
+            : clinic.coverPhoto || "",
+        name: clinic.name,
+        description: clinic.description || "",
+        location: clinic.location,
+        contactInfo: clinic.contactInfo,
+      });
+    }
+
+    return clinicsInfo;
+  }
+
+  /**
+   * @deprecated Aggregation of procedure info is now handled by ProcedureService.
+   */
+  private async aggregateProcedureInfo(
+    clinicIds: string[],
+    practitionerId: string
+  ): Promise<ProcedureSummaryInfo[]> {
+    console.warn("PractitionerService.aggregateProcedureInfo is deprecated.");
+    return [];
+  }
+
+  /**
+   * Updates aggregated data (clinics and procedures) for a practitioner
+   * @param practitionerId ID of the practitioner to update
+   * @returns Updated practitioner
+   */
+  async updateAggregatedData(
+    practitionerId: string
+  ): Promise<Practitioner | null> {
+    const practitioner = await this.getPractitioner(practitionerId);
+    if (!practitioner) {
+      return null;
+    }
+
+    // Aggregate clinic info
+    const clinicsInfo = await this.aggregateClinicInfo(practitioner.clinics);
+
+    // Aggregate procedure info
+    const proceduresInfo = await this.aggregateProcedureInfo(
+      practitioner.clinics,
+      practitionerId
+    );
+
+    // Update the practitioner with aggregated data
+    const updatedPractitioner = await this.updatePractitioner(practitionerId, {
+      clinicsInfo: clinicsInfo,
+      proceduresInfo: proceduresInfo,
+    });
+
+    return updatedPractitioner;
+  }
+
   /**
    * Kreira novog zdravstvenog radnika
    */
@@ -92,16 +178,49 @@ export class PractitionerService extends BaseService {
         }
       }
 
+      // Initialize default review info for new practitioners
+      const defaultReviewInfo: PractitionerReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0,
+      };
+
+      // Generate ID for the new practitioner
+      const practitionerId = this.generateId();
+
+      // Aggregate clinic info if not provided
+      let clinicsInfo = validatedData.clinicsInfo || [];
+      if (
+        clinicsInfo.length === 0 &&
+        validatedData.clinics &&
+        validatedData.clinics.length > 0
+      ) {
+        clinicsInfo = await this.aggregateClinicInfo(validatedData.clinics);
+      }
+
+      // Can't aggregate procedures at creation time since the practitioner ID doesn't exist yet
+      // We'll initialize with an empty array and update after creation if needed
+      const proceduresInfo: ProcedureSummaryInfo[] = [];
+
       const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
         createdAt: ReturnType<typeof serverTimestamp>;
         updatedAt: ReturnType<typeof serverTimestamp>;
       } = {
-        id: this.generateId(),
+        id: practitionerId,
         userRef: validatedData.userRef,
         basicInfo: validatedData.basicInfo,
         certification: validatedData.certification,
         clinics: validatedData.clinics || [],
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        clinicsInfo: clinicsInfo,
+        procedures: [],
+        proceduresInfo: proceduresInfo,
+        reviewInfo: defaultReviewInfo,
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
         status: validatedData.status || PractitionerStatus.ACTIVE,
@@ -122,11 +241,24 @@ export class PractitionerService extends BaseService {
         practitionerData
       );
 
-      const savedPractitioner = await this.getPractitioner(practitionerData.id);
+      // Get the saved practitioner
+      let savedPractitioner = await this.getPractitioner(practitionerData.id);
       if (!savedPractitioner) {
         throw new Error("Failed to create practitioner profile");
       }
 
+      // If procedures weren't provided and the practitioner is associated with clinics,
+      // update the aggregated procedure info
+      if (
+        proceduresInfo.length === 0 &&
+        validatedData.clinics &&
+        validatedData.clinics.length > 0
+      ) {
+        savedPractitioner =
+          (await this.updateAggregatedData(savedPractitioner.id)) ||
+          savedPractitioner;
+      }
+
       return savedPractitioner;
     } catch (error) {
       if (error instanceof z.ZodError) {
@@ -174,7 +306,30 @@ export class PractitionerService extends BaseService {
         }
       }
 
+      // Initialize default review info for new practitioners
+      const defaultReviewInfo: PractitionerReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0,
+      };
+
+      // Generate ID for the new practitioner
       const practitionerId = this.generateId();
+
+      // Aggregate clinic info if not provided
+      let clinicsInfo = validatedData.clinicsInfo || [];
+      if (clinicsInfo.length === 0 && clinics.length > 0) {
+        clinicsInfo = await this.aggregateClinicInfo(clinics);
+      }
+
+      // Can't aggregate procedures for draft practitioners yet
+      const proceduresInfo: ProcedureSummaryInfo[] = [];
+
       const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
         createdAt: ReturnType<typeof serverTimestamp>;
         updatedAt: ReturnType<typeof serverTimestamp>;
@@ -185,6 +340,10 @@ export class PractitionerService extends BaseService {
         certification: validatedData.certification,
         clinics: clinics,
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        clinicsInfo: clinicsInfo,
+        procedures: [],
+        proceduresInfo: proceduresInfo,
+        reviewInfo: defaultReviewInfo,
         isActive:
           validatedData.isActive !== undefined ? validatedData.isActive : false,
         isVerified:
@@ -506,7 +665,10 @@ export class PractitionerService extends BaseService {
     }
 
     try {
+      const currentPractitioner = practitionerDoc.data() as Practitioner;
+
       // Ako se ažurira lista klinika, proveravamo da li sve postoje
+      // i agregiramo informacije o klinikama
       if (data.clinics) {
         for (const clinicId of data.clinics) {
           const clinic = await this.getClinicService().getClinic(clinicId);
@@ -514,6 +676,19 @@ export class PractitionerService extends BaseService {
             throw new Error(`Clinic ${clinicId} not found`);
           }
         }
+
+        // If clinics changed and clinicsInfo wasn't explicitly provided, update clinicsInfo
+        if (!data.clinicsInfo) {
+          data.clinicsInfo = await this.aggregateClinicInfo(data.clinics);
+        }
+
+        // If clinics changed, update procedures info
+        if (!data.proceduresInfo) {
+          data.proceduresInfo = await this.aggregateProcedureInfo(
+            data.clinics,
+            practitionerId
+          );
+        }
       }
 
       const updateData = {
@@ -523,7 +698,7 @@ export class PractitionerService extends BaseService {
 
       // Validiramo kompletan objekat
       practitionerSchema.parse({
-        ...practitionerDoc.data(),
+        ...currentPractitioner,
         ...data,
         updatedAt: Timestamp.now(),
       });
@@ -562,9 +737,32 @@ export class PractitionerService extends BaseService {
       throw new Error("Practitioner is already associated with this clinic");
     }
 
+    // Add clinic to the list
+    const updatedClinics = [...practitioner.clinics, clinicId];
+
+    // Update clinicsInfo array
+    const clinicInfo: ClinicInfo = {
+      id: clinic.id,
+      name: clinic.name,
+      description: clinic.description || "",
+      featuredPhoto:
+        clinic.featuredPhotos && clinic.featuredPhotos.length > 0
+          ? clinic.featuredPhotos[0]
+          : clinic.coverPhoto || "",
+      location: clinic.location,
+      contactInfo: clinic.contactInfo,
+    };
+
+    const updatedClinicsInfo = [...practitioner.clinicsInfo, clinicInfo];
+
+    // Update practitioner with new clinic information
     await this.updatePractitioner(practitionerId, {
-      clinics: [...practitioner.clinics, clinicId],
+      clinics: updatedClinics,
+      clinicsInfo: updatedClinicsInfo,
     });
+
+    // After adding clinic, update aggregated procedure info
+    await this.updateAggregatedData(practitionerId);
   }
 
   /**
@@ -580,8 +778,24 @@ export class PractitionerService extends BaseService {
       throw new Error("Practitioner is not associated with this clinic");
     }
 
+    // Remove clinic from the list
+    const updatedClinics = practitioner.clinics.filter((id) => id !== clinicId);
+
+    // Update clinicsInfo array
+    const updatedClinicsInfo = practitioner.clinicsInfo.filter(
+      (clinic) => clinic.id !== clinicId
+    );
+
+    // Update proceduresInfo array - remove procedures from this clinic
+    const updatedProceduresInfo = practitioner.proceduresInfo.filter(
+      (procedure) => procedure.clinicId !== clinicId
+    );
+
+    // Update practitioner with updated information
     await this.updatePractitioner(practitionerId, {
-      clinics: practitioner.clinics.filter((id) => id !== clinicId),
+      clinics: updatedClinics,
+      clinicsInfo: updatedClinicsInfo,
+      proceduresInfo: updatedProceduresInfo,
     });
   }
 
@@ -661,4 +875,401 @@ export class PractitionerService extends BaseService {
 
     return updatedPractitioner;
   }
+
+  /**
+   * Retrieves all practitioners with optional pagination and draft inclusion
+   *
+   * @param options - Search options
+   * @param options.pagination - Optional limit for number of results per page
+   * @param options.lastDoc - Optional last document for pagination
+   * @param options.includeDraftPractitioners - Whether to include draft practitioners
+   * @returns Array of practitioners and the last document for pagination
+   */
+  async getAllPractitioners(options?: {
+    pagination?: number;
+    lastDoc?: any;
+    includeDraftPractitioners?: boolean;
+  }): Promise<{ practitioners: Practitioner[]; lastDoc: any }> {
+    try {
+      const constraints = [];
+
+      // Filter by status if not including drafts
+      if (!options?.includeDraftPractitioners) {
+        constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
+      }
+
+      // Add ordering for consistent pagination
+      constraints.push(orderBy("basicInfo.lastName", "asc"));
+      constraints.push(orderBy("basicInfo.firstName", "asc"));
+
+      // Add pagination if specified
+      if (options?.pagination && options.pagination > 0) {
+        if (options.lastDoc) {
+          constraints.push(startAfter(options.lastDoc));
+        }
+        constraints.push(limit(options.pagination));
+      }
+
+      const q = query(
+        collection(this.db, PRACTITIONERS_COLLECTION),
+        ...constraints
+      );
+
+      const querySnapshot = await getDocs(q);
+
+      const practitioners = querySnapshot.docs.map(
+        (doc) => doc.data() as Practitioner
+      );
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      return {
+        practitioners,
+        lastDoc,
+      };
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER_SERVICE] Error getting all practitioners:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Searches and filters practitioners based on multiple criteria
+   *
+   * @param filters - Various filters to apply
+   * @param filters.nameSearch - Optional search text for first/last name
+   * @param filters.certifications - Optional array of certifications to filter by
+   * @param filters.specialties - Optional array of specialties to filter by
+   * @param filters.procedureFamily - Optional procedure family practitioners provide
+   * @param filters.procedureCategory - Optional procedure category practitioners provide
+   * @param filters.procedureSubcategory - Optional procedure subcategory practitioners provide
+   * @param filters.procedureTechnology - Optional procedure technology practitioners provide
+   * @param filters.location - Optional location for distance-based search
+   * @param filters.radiusInKm - Optional radius in kilometers (required if location is provided)
+   * @param filters.minRating - Optional minimum rating (0-5)
+   * @param filters.maxRating - Optional maximum rating (0-5)
+   * @param filters.pagination - Optional number of results per page
+   * @param filters.lastDoc - Optional last document for pagination
+   * @param filters.includeDraftPractitioners - Whether to include draft practitioners
+   * @returns Filtered practitioners and the last document for pagination
+   */
+  async getPractitionersByFilters(filters: {
+    nameSearch?: string;
+    certifications?: string[];
+    specialties?: CertificationSpecialty[];
+    procedureFamily?: string;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    location?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    includeDraftPractitioners?: boolean;
+  }): Promise<{ practitioners: Practitioner[]; lastDoc: any }> {
+    try {
+      console.log(
+        "[PRACTITIONER_SERVICE] Starting practitioner filtering with criteria:",
+        filters
+      );
+
+      const constraints = [];
+
+      // Filter by status if not including drafts
+      if (!filters.includeDraftPractitioners) {
+        constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
+      }
+
+      // Filter by active status
+      constraints.push(where("isActive", "==", true));
+
+      // Add certifications filter if specified
+      if (filters.certifications && filters.certifications.length > 0) {
+        constraints.push(
+          where(
+            "certification.certifications",
+            "array-contains-any",
+            filters.certifications
+          )
+        );
+      }
+
+      // Add ordering for consistent pagination
+      constraints.push(orderBy("basicInfo.lastName", "asc"));
+      constraints.push(orderBy("basicInfo.firstName", "asc"));
+
+      // Add pagination if specified
+      if (filters.pagination && filters.pagination > 0) {
+        if (filters.lastDoc) {
+          constraints.push(startAfter(filters.lastDoc));
+        }
+        constraints.push(limit(filters.pagination));
+      }
+
+      // Execute the query
+      const q = query(
+        collection(this.db, PRACTITIONERS_COLLECTION),
+        ...constraints
+      );
+      const querySnapshot = await getDocs(q);
+
+      console.log(
+        `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
+      );
+
+      // Convert docs to practitioners
+      let practitioners = querySnapshot.docs.map((doc) => {
+        return { ...doc.data(), id: doc.id } as Practitioner;
+      });
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      // Further filter results in memory
+
+      // Filter by name search if specified
+      if (filters.nameSearch && filters.nameSearch.trim() !== "") {
+        const searchTerm = filters.nameSearch.toLowerCase().trim();
+        practitioners = practitioners.filter((practitioner) => {
+          const fullName =
+            `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`.toLowerCase();
+          return fullName.includes(searchTerm);
+        });
+      }
+
+      // Filter by specialties
+      if (filters.specialties && filters.specialties.length > 0) {
+        practitioners = practitioners.filter((practitioner) => {
+          return filters.specialties!.every((specialty) =>
+            practitioner.certification.specialties.includes(specialty)
+          );
+        });
+      }
+
+      // Filter by procedure attributes using the aggregated proceduresInfo
+      if (
+        filters.procedureTechnology ||
+        filters.procedureSubcategory ||
+        filters.procedureCategory ||
+        filters.procedureFamily
+      ) {
+        practitioners = practitioners.filter((practitioner) => {
+          const procedures = practitioner.proceduresInfo || [];
+          return procedures.some((procedure: ProcedureSummaryInfo) => {
+            // Apply hierarchical filter - most specific first
+            if (filters.procedureTechnology) {
+              return procedure.technologyName === filters.procedureTechnology;
+            }
+            if (filters.procedureSubcategory) {
+              return procedure.subcategoryName === filters.procedureSubcategory;
+            }
+            if (filters.procedureCategory) {
+              return procedure.categoryName === filters.procedureCategory;
+            }
+            if (filters.procedureFamily) {
+              return procedure.family === filters.procedureFamily;
+            }
+            return false;
+          });
+        });
+      }
+
+      // Filter by location/distance if specified
+      if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+        const location = filters.location;
+        const radiusInKm = filters.radiusInKm;
+
+        practitioners = practitioners.filter((practitioner) => {
+          // Use the aggregated clinicsInfo to check if any clinic is within range
+          const clinics = practitioner.clinicsInfo || [];
+
+          // Check if any clinic is within the specified radius
+          return clinics.some((clinic) => {
+            // Calculate distance
+            const distance = distanceBetween(
+              [location.latitude, location.longitude],
+              [clinic.location.latitude, clinic.location.longitude]
+            );
+
+            // Convert to kilometers
+            const distanceInKm = distance / 1000;
+
+            // Check if within radius
+            return distanceInKm <= radiusInKm;
+          });
+        });
+      }
+
+      // Filter by rating
+      if (filters.minRating !== undefined) {
+        practitioners = practitioners.filter(
+          (p) => p.reviewInfo.averageRating >= filters.minRating!
+        );
+      }
+
+      if (filters.maxRating !== undefined) {
+        practitioners = practitioners.filter(
+          (p) => p.reviewInfo.averageRating <= filters.maxRating!
+        );
+      }
+
+      console.log(
+        `[PRACTITIONER_SERVICE] Filtered to ${practitioners.length} practitioners`
+      );
+
+      // Apply pagination after all filters have been applied
+      // This is a secondary pagination for in-memory filtered results
+      if (filters.pagination && filters.pagination > 0) {
+        practitioners = practitioners.slice(0, filters.pagination);
+      }
+
+      return {
+        practitioners,
+        lastDoc,
+      };
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER_SERVICE] Error filtering practitioners:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  // --- Helper Functions ---
+
+  /**
+   * Aggregates essential clinic information for embedding in Practitioner.
+   * @param clinicIds Array of clinic IDs the practitioner works at
+   * @returns Array of ClinicInfo objects
+   */
+  private async _aggregateClinicInfoForPractitioner(
+    clinicIds: string[]
+  ): Promise<ClinicInfo[]> {
+    const clinicsInfo: ClinicInfo[] = [];
+    const clinicService = this.getClinicService(); // Get service instance
+
+    for (const clinicId of clinicIds) {
+      try {
+        const clinic = await clinicService.getClinic(clinicId);
+        if (!clinic) {
+          console.warn(
+            `Clinic ${clinicId} not found during practitioner aggregation.`
+          );
+          continue;
+        }
+
+        clinicsInfo.push({
+          id: clinic.id,
+          featuredPhoto:
+            clinic.featuredPhotos && clinic.featuredPhotos.length > 0
+              ? clinic.featuredPhotos[0]
+              : clinic.coverPhoto || "",
+          name: clinic.name,
+          description: clinic.description || "",
+          location: clinic.location,
+          contactInfo: clinic.contactInfo,
+        });
+      } catch (error) {
+        console.error(
+          `Error fetching clinic ${clinicId} for practitioner aggregation:`,
+          error
+        );
+      }
+    }
+    return clinicsInfo;
+  }
+
+  /**
+   * Creates an aggregated DoctorInfo object from Practitioner data.
+   * @param practitioner The practitioner object
+   * @returns DoctorInfo object
+   */
+  private _createDoctorInfoForClinic(practitioner: Practitioner): DoctorInfo {
+    return {
+      id: practitioner.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || "",
+      photo: practitioner.basicInfo.profileImageUrl || "",
+      rating: practitioner.reviewInfo?.averageRating || 0,
+      services: practitioner.procedures || [], // List of procedure IDs
+    };
+  }
+
+  /**
+   * Updates the DoctorInfo within the doctorsInfo array for multiple clinics.
+   * @param clinicIds IDs of clinics to update
+   * @param doctorInfo The updated DoctorInfo object
+   */
+  private async _updateDoctorInfoInClinics(
+    clinicIds: string[],
+    doctorInfo: DoctorInfo
+  ): Promise<void> {
+    const batch = writeBatch(this.db);
+    const practitionerId = doctorInfo.id;
+
+    for (const clinicId of clinicIds) {
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      // First, remove the old doctor info based on ID
+      batch.update(clinicRef, {
+        doctorsInfo: arrayRemove(...[{ id: practitionerId }]),
+        updatedAt: serverTimestamp(),
+      });
+      // Then, add the updated doctor info
+      batch.update(clinicRef, {
+        doctorsInfo: arrayUnion(doctorInfo),
+        updatedAt: serverTimestamp(),
+      });
+    }
+    try {
+      await batch.commit();
+    } catch (error) {
+      console.error(
+        `Error updating doctor info in clinics for practitioner ${practitionerId}:`,
+        error
+      );
+      // Decide on error handling: throw, retry, log?
+    }
+  }
+
+  /**
+   * Removes DoctorInfo from the doctorsInfo array for multiple clinics.
+   * @param clinicIds IDs of clinics to update
+   * @param practitionerId ID of the practitioner whose info should be removed
+   */
+  private async _removeDoctorInfoFromClinics(
+    clinicIds: string[],
+    practitionerId: string
+  ): Promise<void> {
+    const batch = writeBatch(this.db);
+
+    for (const clinicId of clinicIds) {
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      batch.update(clinicRef, {
+        doctors: arrayRemove(practitionerId), // Also remove from simple ID list
+        doctorsInfo: arrayRemove(...[{ id: practitionerId }]), // Remove by ID matcher
+        updatedAt: serverTimestamp(),
+      });
+    }
+    try {
+      await batch.commit();
+    } catch (error) {
+      console.error(
+        `Error removing doctor info from clinics for practitioner ${practitionerId}:`,
+        error
+      );
+    }
+  }
 }