@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

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;
@@ -52,86 +66,89 @@ export class PractitionerService extends BaseService {
 
   private getClinicService(): ClinicService {
     if (!this.clinicService) {
-      throw new Error("ClinicService nije inicijalizovan");
+      throw new Error("Clinic service not initialized!");
     }
     return this.clinicService;
   }
 
-  /**
-   * Postavlja referencu na ClinicService nakon inicijalizacije
-   */
   setClinicService(clinicService: ClinicService): void {
     this.clinicService = clinicService;
   }
 
   /**
-   * Kreira novog zdravstvenog radnika
+   * Creates a new practitioner
    */
   async createPractitioner(
     data: CreatePractitionerData
   ): Promise<Practitioner> {
     try {
-      // Validacija ulaznih podataka
-      const validatedData = createPractitionerSchema.parse(data);
-
-      // Provera da li već postoji profil za ovog korisnika
-      const existingPractitioner = await this.getPractitionerByUserRef(
-        validatedData.userRef
-      );
-      if (existingPractitioner) {
-        throw new Error("User already has a practitioner profile");
-      }
+      const validData = createPractitionerSchema.parse(data);
+      const practitionerId = this.generateId();
 
-      // Provera da li sve klinike postoje
-      if (validatedData.clinics) {
-        for (const clinicId of validatedData.clinics) {
-          const clinic = await this.getClinicService().getClinic(clinicId);
-          if (!clinic) {
-            throw new Error(`Clinic ${clinicId} not found`);
-          }
-        }
-      }
+      // Default review info
+      const reviewInfo: PractitionerReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0,
+      };
 
-      const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
-        createdAt: ReturnType<typeof serverTimestamp>;
-        updatedAt: ReturnType<typeof serverTimestamp>;
+      // Create practitioner object
+      const practitioner: Omit<Practitioner, "createdAt" | "updatedAt"> & {
+        createdAt: FieldValue;
+        updatedAt: FieldValue;
       } = {
-        id: this.generateId(),
-        userRef: validatedData.userRef,
-        basicInfo: validatedData.basicInfo,
-        certification: validatedData.certification,
-        clinics: validatedData.clinics || [],
-        clinicWorkingHours: validatedData.clinicWorkingHours || [],
-        isActive: validatedData.isActive,
-        isVerified: validatedData.isVerified,
-        status: validatedData.status || PractitionerStatus.ACTIVE,
+        id: practitionerId,
+        userRef: validData.userRef,
+        basicInfo: validData.basicInfo,
+        certification: validData.certification,
+        clinics: validData.clinics || [],
+        clinicWorkingHours: validData.clinicWorkingHours || [],
+        clinicsInfo: [],
+        procedures: [],
+        proceduresInfo: [],
+        reviewInfo,
+        isActive: validData.isActive !== undefined ? validData.isActive : true,
+        isVerified:
+          validData.isVerified !== undefined ? validData.isVerified : false,
+        status: validData.status || PractitionerStatus.ACTIVE,
         createdAt: serverTimestamp(),
         updatedAt: serverTimestamp(),
       };
 
-      // Validacija kompletnog objekta
+      // Validate the entire object
       practitionerSchema.parse({
-        ...practitionerData,
+        ...practitioner,
         createdAt: Timestamp.now(),
         updatedAt: Timestamp.now(),
       });
 
-      // Čuvamo u Firestore
-      await setDoc(
-        doc(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
-        practitionerData
+      // Create practitioner document
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
       );
 
-      const savedPractitioner = await this.getPractitioner(practitionerData.id);
-      if (!savedPractitioner) {
-        throw new Error("Failed to create practitioner profile");
-      }
+      await setDoc(practitionerRef, practitioner);
 
-      return savedPractitioner;
+      // Return the created practitioner
+      const createdPractitioner = await this.getPractitioner(practitionerId);
+      if (!createdPractitioner) {
+        throw new Error(
+          `Failed to retrieve created practitioner ${practitionerId}`
+        );
+      }
+      return createdPractitioner;
     } catch (error) {
       if (error instanceof z.ZodError) {
-        throw new Error("Invalid practitioner data: " + error.message);
+        throw new Error(`Invalid practitioner data: ${error.message}`);
       }
+      console.error("Error creating practitioner:", error);
       throw error;
     }
   }
@@ -174,7 +191,24 @@ 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();
+
+      const clinicsInfo = validatedData.clinicsInfo || [];
+      const proceduresInfo: ProcedureSummaryInfo[] = [];
+
       const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
         createdAt: ReturnType<typeof serverTimestamp>;
         updatedAt: ReturnType<typeof serverTimestamp>;
@@ -185,6 +219,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:
@@ -488,101 +526,126 @@ export class PractitionerService extends BaseService {
   }
 
   /**
-   * Ažurira profil zdravstvenog radnika
+   * Updates a practitioner
    */
   async updatePractitioner(
     practitionerId: string,
     data: UpdatePractitionerData
   ): Promise<Practitioner> {
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      practitionerId
-    );
-    const practitionerDoc = await getDoc(practitionerRef);
+    try {
+      // Validate update data
+      const validData = data; // Using the passed data directly as it's already validated by the schema type
 
-    if (!practitionerDoc.exists()) {
-      throw new Error("Practitioner not found");
-    }
+      // Get current practitioner data
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await getDoc(practitionerRef);
 
-    try {
-      // Ako se ažurira lista klinika, proveravamo da li sve postoje
-      if (data.clinics) {
-        for (const clinicId of data.clinics) {
-          const clinic = await this.getClinicService().getClinic(clinicId);
-          if (!clinic) {
-            throw new Error(`Clinic ${clinicId} not found`);
-          }
-        }
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
       }
 
+      const currentPractitioner = practitionerDoc.data() as Practitioner;
+
+      // Prepare update data
       const updateData = {
-        ...data,
+        ...validData,
         updatedAt: serverTimestamp(),
       };
 
-      // Validiramo kompletan objekat
-      practitionerSchema.parse({
-        ...practitionerDoc.data(),
-        ...data,
-        updatedAt: Timestamp.now(),
-      });
-
+      // Update practitioner
       await updateDoc(practitionerRef, updateData);
 
+      // Return updated practitioner
       const updatedPractitioner = await this.getPractitioner(practitionerId);
       if (!updatedPractitioner) {
-        throw new Error("Failed to retrieve updated practitioner profile");
+        throw new Error(
+          `Failed to retrieve updated practitioner ${practitionerId}`
+        );
       }
-
       return updatedPractitioner;
     } catch (error) {
       if (error instanceof z.ZodError) {
-        throw new Error("Invalid practitioner data: " + error.message);
+        throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
+      console.error(`Error updating practitioner ${practitionerId}:`, error);
       throw error;
     }
   }
 
   /**
-   * Dodaje kliniku zdravstvenom radniku
+   * Adds a clinic to a practitioner
    */
   async addClinic(practitionerId: string, clinicId: string): Promise<void> {
-    const practitioner = await this.getPractitioner(practitionerId);
-    if (!practitioner) {
-      throw new Error("Practitioner not found");
-    }
+    try {
+      // Get practitioner
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await getDoc(practitionerRef);
 
-    const clinic = await this.getClinicService().getClinic(clinicId);
-    if (!clinic) {
-      throw new Error("Clinic not found");
-    }
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
 
-    if (practitioner.clinics.includes(clinicId)) {
-      throw new Error("Practitioner is already associated with this clinic");
-    }
+      const practitioner = practitionerDoc.data() as Practitioner;
 
-    await this.updatePractitioner(practitionerId, {
-      clinics: [...practitioner.clinics, clinicId],
-    });
+      // Check if clinic already added
+      if (practitioner.clinics?.includes(clinicId)) {
+        console.log(
+          `Clinic ${clinicId} already added to practitioner ${practitionerId}`
+        );
+        return;
+      }
+
+      // Add clinic to clinics array
+      await updateDoc(practitionerRef, {
+        clinics: arrayUnion(clinicId),
+        updatedAt: serverTimestamp(),
+      });
+    } catch (error) {
+      console.error(
+        `Error adding clinic ${clinicId} to practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
   }
 
   /**
-   * Uklanja kliniku iz liste klinika zdravstvenog radnika
+   * Removes a clinic from a practitioner
    */
   async removeClinic(practitionerId: string, clinicId: string): Promise<void> {
-    const practitioner = await this.getPractitioner(practitionerId);
-    if (!practitioner) {
-      throw new Error("Practitioner not found");
-    }
+    try {
+      // Get practitioner
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await getDoc(practitionerRef);
 
-    if (!practitioner.clinics.includes(clinicId)) {
-      throw new Error("Practitioner is not associated with this clinic");
-    }
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
 
-    await this.updatePractitioner(practitionerId, {
-      clinics: practitioner.clinics.filter((id) => id !== clinicId),
-    });
+      // Remove clinic from clinics array
+      await updateDoc(practitionerRef, {
+        clinics: arrayRemove(clinicId),
+        updatedAt: serverTimestamp(),
+      });
+    } catch (error) {
+      console.error(
+        `Error removing clinic ${clinicId} from practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
   }
 
   /**
@@ -661,4 +724,276 @@ 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;
+    }
+  }
 }