@blackcode_sa/metaestetics-api 1.5.28 → 1.5.29

package/src/services/clinic/clinic.service.ts

@@ -13,19 +13,29 @@ import {
   GeoPoint,
   QueryConstraint,
   FieldValue,
+  writeBatch,
+  arrayUnion,
+  arrayRemove,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
   Clinic,
   CreateClinicData,
   CLINICS_COLLECTION,
-  ClinicReview,
   ClinicTag,
   ClinicTags,
   ClinicGroup,
+  CLINIC_GROUPS_COLLECTION,
   ClinicBranchSetupData,
   CLINIC_ADMINS_COLLECTION,
+  DoctorInfo,
+  // Remove incorrect imports below
+  // ProcedureSummaryInfo,
+  // ClinicInfo
 } from "../../types/clinic";
+// Correct imports
+import { ProcedureSummaryInfo } from "../../types/procedure";
+import { ClinicInfo } from "../../types/profile";
 import { ClinicGroupService } from "./clinic-group.service";
 import { ClinicAdminService } from "./clinic-admin.service";
 import {
@@ -36,17 +46,18 @@ import {
 import {
   clinicSchema,
   createClinicSchema,
-  clinicReviewSchema,
 } from "../../validations/clinic.schema";
 import { z } from "zod";
 import { Auth } from "firebase/auth";
 import { Firestore } from "firebase/firestore";
 import { FirebaseApp } from "firebase/app";
 import * as ClinicUtils from "./utils/clinic.utils";
-import * as ReviewUtils from "./utils/review.utils";
 import * as TagUtils from "./utils/tag.utils";
 import * as SearchUtils from "./utils/search.utils";
 import * as AdminUtils from "./utils/admin.utils";
+import * as FilterUtils from "./utils/filter.utils";
+import { ClinicReviewInfo } from "../../types/reviews";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
 
 export class ClinicService extends BaseService {
   private clinicGroupService: ClinicGroupService;
@@ -64,23 +75,290 @@ export class ClinicService extends BaseService {
     this.clinicGroupService = clinicGroupService;
   }
 
+  // --- Helper Functions ---
+
+  /**
+   * Creates an aggregated ClinicInfo object from Clinic data.
+   * @param clinic The clinic object
+   * @returns ClinicInfo object
+   */
+  private _createClinicInfoForAggregation(clinic: Clinic): ClinicInfo {
+    return {
+      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,
+    };
+  }
+
+  /**
+   * Updates the ClinicInfo within the clinicsInfo array for multiple practitioners.
+   * @param practitionerIds IDs of practitioners to update
+   * @param clinicInfo The updated ClinicInfo object
+   */
+  private async _updateClinicInfoInPractitioners(
+    practitionerIds: string[],
+    clinicInfo: ClinicInfo
+  ): Promise<void> {
+    const batch = writeBatch(this.db);
+    const clinicId = clinicInfo.id;
+
+    for (const practitionerId of practitionerIds) {
+      const practitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      // Remove old clinic info based on ID
+      batch.update(practitionerRef, {
+        clinicsInfo: arrayRemove(...[{ id: clinicId }]),
+        updatedAt: serverTimestamp(),
+      });
+      // Add updated clinic info
+      batch.update(practitionerRef, {
+        clinicsInfo: arrayUnion(clinicInfo),
+        updatedAt: serverTimestamp(),
+      });
+    }
+    try {
+      await batch.commit();
+    } catch (error) {
+      console.error(
+        `Error updating clinic info in practitioners for clinic ${clinicId}:`,
+        error
+      );
+      // Decide on error handling
+    }
+  }
+
+  // --- Core Service Methods (Updated) ---
+
   /**
-   * Kreira novu kliniku
+   * Creates a new clinic.
+   * Initializes empty doctorsInfo and proceduresInfo.
+   * Aggregation into Clinic happens via PractitionerService and ProcedureService.
    */
   async createClinic(
     data: CreateClinicData,
     creatorAdminId: string
   ): Promise<Clinic> {
-    return ClinicUtils.createClinic(
-      this.db,
-      data,
-      creatorAdminId,
-      this.clinicGroupService,
-      this.clinicAdminService,
-      this.app
-    );
+    try {
+      const validatedData = createClinicSchema.parse(data);
+      const group = await this.clinicGroupService.getClinicGroup(
+        validatedData.clinicGroupId
+      );
+      if (!group)
+        throw new Error(
+          `Clinic group ${validatedData.clinicGroupId} not found`
+        );
+      const location = validatedData.location;
+      const hash = geohashForLocation([location.latitude, location.longitude]);
+      const defaultReviewInfo: ClinicReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        cleanliness: 0,
+        facilities: 0,
+        staffFriendliness: 0,
+        waitingTime: 0,
+        accessibility: 0,
+        recommendationPercentage: 0,
+      };
+      const clinicId = this.generateId();
+
+      const clinicData: Omit<Clinic, "createdAt" | "updatedAt"> & {
+        createdAt: FieldValue;
+        updatedAt: FieldValue;
+      } = {
+        id: clinicId,
+        clinicGroupId: validatedData.clinicGroupId,
+        name: validatedData.name,
+        description: validatedData.description,
+        location: { ...location, geohash: hash },
+        contactInfo: validatedData.contactInfo,
+        workingHours: validatedData.workingHours,
+        tags: validatedData.tags,
+        featuredPhotos: validatedData.featuredPhotos || [],
+        coverPhoto: validatedData.coverPhoto,
+        photosWithTags: validatedData.photosWithTags,
+        doctors: [],
+        procedures: [],
+        doctorsInfo: [],
+        proceduresInfo: [],
+        reviewInfo: defaultReviewInfo,
+        admins: [creatorAdminId],
+        isActive: validatedData.isActive,
+        isVerified: validatedData.isVerified,
+        logo: validatedData.logo,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      };
+
+      // Re-validate before saving (ensure schema matches the final object)
+      clinicSchema.parse({
+        ...clinicData,
+        createdAt: Timestamp.now(),
+        updatedAt: Timestamp.now(),
+      });
+
+      const batch = writeBatch(this.db);
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      batch.set(clinicRef, clinicData);
+
+      const groupRef = doc(
+        this.db,
+        CLINIC_GROUPS_COLLECTION,
+        validatedData.clinicGroupId
+      );
+      const newClinicInfoForGroup = this._createClinicInfoForAggregation({
+        ...clinicData,
+        id: clinicId,
+      } as Clinic);
+      batch.update(groupRef, {
+        clinics: arrayUnion(clinicId),
+        clinicsInfo: arrayUnion(newClinicInfoForGroup),
+        updatedAt: serverTimestamp(),
+      });
+
+      const adminRef = doc(this.db, CLINIC_ADMINS_COLLECTION, creatorAdminId);
+      batch.update(adminRef, {
+        clinicsManaged: arrayUnion(clinicId),
+        updatedAt: serverTimestamp(),
+      });
+
+      await batch.commit();
+      const savedClinic = await this.getClinic(clinicId);
+      if (!savedClinic) throw new Error("Failed to retrieve created clinic");
+      return savedClinic;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error("Invalid clinic data: " + error.message);
+      }
+      console.error("Error creating clinic:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates a clinic and propagates changes (ClinicInfo) to associated practitioners.
+   */
+  async updateClinic(
+    clinicId: string,
+    data: Partial<Omit<Clinic, "id" | "createdAt" | "clinicGroupId">>,
+    adminId: string
+  ): Promise<Clinic> {
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+    const clinicDoc = await getDoc(clinicRef);
+    if (!clinicDoc.exists()) {
+      throw new Error(`Clinic ${clinicId} not found`);
+    }
+
+    try {
+      const currentClinic = clinicDoc.data() as Clinic;
+      // Explicitly Omit fields managed by other services or internally
+      const { doctorsInfo, proceduresInfo, ...updatePayload } =
+        data as Partial<Clinic>;
+
+      if (updatePayload.location) {
+        const loc = updatePayload.location;
+        updatePayload.location = {
+          ...loc,
+          geohash: geohashForLocation([loc.latitude, loc.longitude]),
+        };
+      }
+
+      // Merge with current data for validation and aggregation, preserving arrays managed elsewhere
+      const finalStateForValidation = {
+        ...currentClinic,
+        ...updatePayload, // Apply safe updates
+        // Explicitly keep arrays managed by other services from current state
+        doctorsInfo: currentClinic.doctorsInfo,
+        proceduresInfo: currentClinic.proceduresInfo,
+      };
+
+      // Ensure required fields for validation are present
+      clinicSchema.parse({
+        ...finalStateForValidation,
+        updatedAt: Timestamp.now(), // Use current time for validation
+      });
+
+      // Prepare final update data for Firestore, including timestamp
+      const updateDataForFirestore = {
+        ...updatePayload,
+        updatedAt: serverTimestamp(),
+      };
+
+      const batch = writeBatch(this.db);
+      batch.update(clinicRef, updateDataForFirestore);
+
+      const groupRef = doc(
+        this.db,
+        CLINIC_GROUPS_COLLECTION,
+        currentClinic.clinicGroupId
+      );
+      // Use the validated final state for aggregation
+      const updatedClinicInfoForGroup = this._createClinicInfoForAggregation(
+        finalStateForValidation as Clinic
+      );
+      batch.update(groupRef, {
+        clinicsInfo: arrayRemove(...[{ id: clinicId }]),
+        updatedAt: serverTimestamp(),
+      });
+      batch.update(groupRef, {
+        clinicsInfo: arrayUnion(updatedClinicInfoForGroup),
+        updatedAt: serverTimestamp(),
+      });
+
+      const practitionerIds = currentClinic.doctors || [];
+      if (practitionerIds.length > 0) {
+        // Pass the aggregated info based on the final validated state
+        await this._updateClinicInfoInPractitioners(
+          practitionerIds,
+          updatedClinicInfoForGroup
+        );
+      }
+
+      await batch.commit();
+      const updatedClinic = await this.getClinic(clinicId);
+      if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
+      return updatedClinic;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(
+          "Invalid clinic update data: " +
+            error.errors
+              .map((e) => `${e.path.join(".")} - ${e.message}`)
+              .join(", ")
+        );
+      }
+      console.error(`Error updating clinic ${clinicId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Deactivates a clinic.
+   * Note: Does not currently remove ClinicInfo from practitioners (might be desired).
+   */
+  async deactivateClinic(clinicId: string, adminId: string): Promise<void> {
+    // Permission check omitted
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+    await updateDoc(clinicRef, {
+      isActive: false,
+      updatedAt: serverTimestamp(),
+    });
+    // Consider whether to also update ClinicInfo in practitioners to reflect inactive status
   }
 
+  // --- Other Methods ---
+  // (getClinic, getClinicsByGroup, findClinicsInRadius, addTags, removeTags, getClinicsByAdmin, etc.)
+  // Review these methods to ensure they don't rely on outdated aggregation logic (e.g., filtering ServiceInfo)
+  // and update them to use proceduresInfo if necessary for filtering.
+
   /**
    * Dohvata kliniku po ID-u
    */
@@ -97,15 +375,21 @@ export class ClinicService extends BaseService {
 
   /**
    * Pretražuje klinike u određenom radijusu
+   * REVIEW: SearchUtils.findClinicsInRadius might need updating for filters.
    */
   async findClinicsInRadius(
     center: { latitude: number; longitude: number },
     radiusInKm: number,
     filters?: {
-      services?: string[];
+      procedures?: string[];
       tags?: ClinicTag[];
+      // Add other relevant filters based on Clinic/ProcedureSummaryInfo fields
     }
   ): Promise<Clinic[]> {
+    console.warn(
+      "SearchUtils.findClinicsInRadius filter logic might need updating for proceduresInfo."
+    );
+    // Pass filters directly, assuming SearchUtils handles it.
     return SearchUtils.findClinicsInRadius(
       this.db,
       center,
@@ -114,52 +398,6 @@ export class ClinicService extends BaseService {
     );
   }
 
-  /**
-   * Ažurira kliniku
-   */
-  async updateClinic(
-    clinicId: string,
-    data: Partial<Clinic>,
-    adminId: string
-  ): Promise<Clinic> {
-    return ClinicUtils.updateClinic(
-      this.db,
-      clinicId,
-      data,
-      adminId,
-      this.clinicAdminService,
-      this.app
-    );
-  }
-
-  /**
-   * Dodaje recenziju klinici
-   */
-  async addReview(
-    clinicId: string,
-    review: Omit<
-      ClinicReview,
-      "id" | "clinicId" | "createdAt" | "updatedAt" | "isVerified"
-    >
-  ): Promise<ClinicReview> {
-    return ReviewUtils.addReview(this.db, clinicId, review, this.app);
-  }
-
-  /**
-   * Deaktivira kliniku
-   */
-  async deactivateClinic(clinicId: string, adminId: string): Promise<void> {
-    return ClinicUtils.deactivateClinic(
-      this.db,
-      clinicId,
-      adminId,
-      this.clinicAdminService
-    );
-  }
-
-  /**
-   * Dodaje tagove klinici
-   */
   async addTags(
     clinicId: string,
     adminId: string,
@@ -177,9 +415,6 @@ export class ClinicService extends BaseService {
     );
   }
 
-  /**
-   * Uklanja tagove iz klinike
-   */
   async removeTags(
     clinicId: string,
     adminId: string,
@@ -197,9 +432,6 @@ export class ClinicService extends BaseService {
     );
   }
 
-  /**
-   * Dohvata sve klinike gde je korisnik admin
-   */
   async getClinicsByAdmin(
     adminId: string,
     options?: {
@@ -216,9 +448,6 @@ export class ClinicService extends BaseService {
     );
   }
 
-  /**
-   * Dohvata sve aktivne klinike gde je korisnik admin
-   */
   async getActiveClinicsByAdmin(adminId: string): Promise<Clinic[]> {
     return ClinicUtils.getActiveClinicsByAdmin(
       this.db,
@@ -228,14 +457,6 @@ export class ClinicService extends BaseService {
     );
   }
 
-  /**
-   * Creates a new clinic branch for a clinic group
-   *
-   * @param clinicGroupId - The ID of the clinic group
-   * @param setupData - The setup data for the clinic branch
-   * @param adminId - The ID of the admin creating the branch
-   * @returns The created clinic
-   */
   async createClinicBranch(
     clinicGroupId: string,
     setupData: ClinicBranchSetupData,
@@ -276,7 +497,7 @@ export class ClinicService extends BaseService {
       coverPhoto: setupData.coverPhoto || null,
       photosWithTags: setupData.photosWithTags || [],
       doctors: [],
-      services: [],
+      procedures: [],
       admins: [adminId],
       isActive: true,
       isVerified: false,
@@ -302,23 +523,10 @@ export class ClinicService extends BaseService {
     return clinic;
   }
 
-  /**
-   * Retrieves a clinic by its ID
-   *
-   * @param clinicId - ID of the clinic to retrieve
-   * @returns The clinic if found, null otherwise
-   */
   async getClinicById(clinicId: string): Promise<Clinic | null> {
     return ClinicUtils.getClinicById(this.db, clinicId);
   }
 
-  /**
-   * Retrieves all clinics with optional pagination
-   *
-   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
-   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
-   * @returns Array of clinics and the last document for pagination
-   */
   async getAllClinics(
     pagination?: number,
     lastDoc?: any
@@ -326,33 +534,38 @@ export class ClinicService extends BaseService {
     return ClinicUtils.getAllClinics(this.db, pagination, lastDoc);
   }
 
-  /**
-   * Retrieves all clinics within a specified range from a location with optional pagination
-   *
-   * @param center - The center location coordinates {latitude, longitude}
-   * @param rangeInKm - The range in kilometers to search within
-   * @param pagination - Optional number of clinics per page (0 or undefined returns all)
-   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
-   * @param filters - Optional filters to apply to the search (isActive, tags, etc.)
-   * @returns Array of clinics with distance information and the last document for pagination
-   */
   async getAllClinicsInRange(
     center: { latitude: number; longitude: number },
     rangeInKm: number,
     pagination?: number,
-    lastDoc?: any,
-    filters?: {
-      isActive?: boolean;
-      tags?: ClinicTag[];
-    }
+    lastDoc?: any
   ): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
     return ClinicUtils.getAllClinicsInRange(
       this.db,
       center,
       rangeInKm,
       pagination,
-      lastDoc,
-      filters
+      lastDoc
     );
   }
+
+  async getClinicsByFilters(filters: {
+    center?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    tags?: ClinicTag[];
+    procedureFamily?: string;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }): Promise<{
+    clinics: (Clinic & { distance?: number })[];
+    lastDoc: any;
+  }> {
+    return FilterUtils.getClinicsByFilters(this.db, filters);
+  }
 }