@blackcode_sa/metaestetics-api 1.5.29 → 1.5.30

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

@@ -66,120 +66,27 @@ 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;
   }
 
   /**
-   * 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
+   * 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");
-      }
-
-      // 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`);
-          }
-        }
-      }
+      const validData = createPractitionerSchema.parse(data);
+      const practitionerId = this.generateId();
 
-      // Initialize default review info for new practitioners
-      const defaultReviewInfo: PractitionerReviewInfo = {
+      // Default review info
+      const reviewInfo: PractitionerReviewInfo = {
         totalReviews: 0,
         averageRating: 0,
         knowledgeAndExpertise: 0,
@@ -190,80 +97,58 @@ export class PractitionerService extends BaseService {
         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>;
+      // Create practitioner object
+      const practitioner: Omit<Practitioner, "createdAt" | "updatedAt"> & {
+        createdAt: FieldValue;
+        updatedAt: FieldValue;
       } = {
         id: practitionerId,
-        userRef: validatedData.userRef,
-        basicInfo: validatedData.basicInfo,
-        certification: validatedData.certification,
-        clinics: validatedData.clinics || [],
-        clinicWorkingHours: validatedData.clinicWorkingHours || [],
-        clinicsInfo: clinicsInfo,
+        userRef: validData.userRef,
+        basicInfo: validData.basicInfo,
+        certification: validData.certification,
+        clinics: validData.clinics || [],
+        clinicWorkingHours: validData.clinicWorkingHours || [],
+        clinicsInfo: [],
         procedures: [],
-        proceduresInfo: proceduresInfo,
-        reviewInfo: defaultReviewInfo,
-        isActive: validatedData.isActive,
-        isVerified: validatedData.isVerified,
-        status: validatedData.status || PractitionerStatus.ACTIVE,
+        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
       );
 
-      // Get the saved practitioner
-      let savedPractitioner = await this.getPractitioner(practitionerData.id);
-      if (!savedPractitioner) {
-        throw new Error("Failed to create practitioner profile");
-      }
+      await setDoc(practitionerRef, practitioner);
 
-      // 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 the created practitioner
+      const createdPractitioner = await this.getPractitioner(practitionerId);
+      if (!createdPractitioner) {
+        throw new Error(
+          `Failed to retrieve created practitioner ${practitionerId}`
+        );
       }
-
-      return savedPractitioner;
+      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;
     }
   }
@@ -321,13 +206,7 @@ export class PractitionerService extends BaseService {
       // 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 clinicsInfo = validatedData.clinicsInfo || [];
       const proceduresInfo: ProcedureSummaryInfo[] = [];
 
       const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
@@ -647,156 +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);
-
-    if (!practitionerDoc.exists()) {
-      throw new Error("Practitioner not found");
-    }
-
     try {
-      const currentPractitioner = practitionerDoc.data() as Practitioner;
+      // Validate update data
+      const validData = data; // Using the passed data directly as it's already validated by the schema type
 
-      // 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);
-          if (!clinic) {
-            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);
-        }
+      // Get current practitioner data
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await getDoc(practitionerRef);
 
-        // If clinics changed, update procedures info
-        if (!data.proceduresInfo) {
-          data.proceduresInfo = await this.aggregateProcedureInfo(
-            data.clinics,
-            practitionerId
-          );
-        }
+      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({
-        ...currentPractitioner,
-        ...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;
 
-    // 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: updatedClinics,
-      clinicsInfo: updatedClinicsInfo,
-    });
+      // Check if clinic already added
+      if (practitioner.clinics?.includes(clinicId)) {
+        console.log(
+          `Clinic ${clinicId} already added to practitioner ${practitionerId}`
+        );
+        return;
+      }
 
-    // After adding clinic, update aggregated procedure info
-    await this.updateAggregatedData(practitionerId);
+      // 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");
-    }
-
-    if (!practitioner.clinics.includes(clinicId)) {
-      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
-    );
+    try {
+      // Get practitioner
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await getDoc(practitionerRef);
 
-    // Update proceduresInfo array - remove procedures from this clinic
-    const updatedProceduresInfo = practitioner.proceduresInfo.filter(
-      (procedure) => procedure.clinicId !== clinicId
-    );
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
 
-    // Update practitioner with updated information
-    await this.updatePractitioner(practitionerId, {
-      clinics: updatedClinics,
-      clinicsInfo: updatedClinicsInfo,
-      proceduresInfo: updatedProceduresInfo,
-    });
+      // 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;
+    }
   }
 
   /**
@@ -1147,129 +996,4 @@ export class PractitionerService extends BaseService {
       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
-      );
-    }
-  }
 }