@blackcode_sa/metaestetics-api 1.5.25 → 1.5.28

package/src/services/clinic/utils/clinic.utils.ts

@@ -768,3 +768,233 @@ export async function getActiveClinicsByAdmin(
     clinicGroupService
   );
 }
+
+/**
+ * Retrieves a clinic by its ID
+ *
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to retrieve
+ * @returns The clinic if found, null otherwise
+ */
+export async function getClinicById(
+  db: Firestore,
+  clinicId: string
+): Promise<Clinic | null> {
+  try {
+    const clinicRef = doc(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await getDoc(clinicRef);
+
+    if (!clinicSnapshot.exists()) {
+      return null;
+    }
+
+    const clinicData = clinicSnapshot.data() as Clinic;
+    return {
+      ...clinicData,
+      id: clinicSnapshot.id,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @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
+ */
+export async function getAllClinics(
+  db: Firestore,
+  pagination?: number,
+  lastDoc?: any
+): Promise<{ clinics: Clinic[]; lastDoc: any }> {
+  try {
+    const clinicsCollection = collection(db, CLINICS_COLLECTION);
+    let clinicsQuery = query(clinicsCollection);
+
+    // If pagination is specified and greater than 0, limit the query
+    if (pagination && pagination > 0) {
+      const { limit, startAfter } = require("firebase/firestore");
+
+      if (lastDoc) {
+        clinicsQuery = query(
+          clinicsCollection,
+          startAfter(lastDoc),
+          limit(pagination)
+        );
+      } else {
+        clinicsQuery = query(clinicsCollection, limit(pagination));
+      }
+    }
+
+    const clinicsSnapshot = await getDocs(clinicsQuery);
+    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
+
+    const clinics = clinicsSnapshot.docs.map((doc) => {
+      const data = doc.data() as Clinic;
+      return {
+        ...data,
+        id: doc.id,
+      };
+    });
+
+    return {
+      clinics,
+      lastDoc: lastVisible,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics within a specified range from a location with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @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 within range and the last document for pagination
+ */
+export async function getAllClinicsInRange(
+  db: Firestore,
+  center: { latitude: number; longitude: number },
+  rangeInKm: number,
+  pagination?: number,
+  lastDoc?: any,
+  filters?: {
+    isActive?: boolean;
+    tags?: ClinicTag[];
+  }
+): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
+  try {
+    const { distanceBetween } = require("geofire-common");
+    const centerLat = center.latitude;
+    const centerLng = center.longitude;
+
+    // We'll need to get all clinics and filter them by distance
+    const clinicsCollection = collection(db, CLINICS_COLLECTION);
+    let clinicsQuery = query(clinicsCollection);
+
+    // Add active filter if specified
+    if (filters?.isActive !== undefined) {
+      clinicsQuery = query(
+        clinicsCollection,
+        where("isActive", "==", filters.isActive)
+      );
+    }
+
+    const querySnapshot = await getDocs(clinicsQuery);
+    console.log(
+      `[CLINIC_UTILS] Found ${querySnapshot.docs.length} total clinics to filter by distance`
+    );
+
+    // Filter the results by distance
+    const filteredDocs = [];
+    for (const doc of querySnapshot.docs) {
+      const clinic = doc.data() as Clinic;
+
+      // Skip clinics without proper location data
+      if (
+        !clinic.location ||
+        !clinic.location.latitude ||
+        !clinic.location.longitude
+      ) {
+        continue;
+      }
+
+      // Calculate distance
+      const distanceInM = distanceBetween(
+        [centerLat, centerLng],
+        [clinic.location.latitude, clinic.location.longitude]
+      );
+
+      // Convert to km and check if within range
+      const distanceInKm = distanceInM / 1000;
+      if (distanceInKm <= rangeInKm) {
+        // If tags filter exists, apply it
+        if (filters?.tags && filters.tags.length > 0) {
+          const hasAllTags = filters.tags.every((filterTag) =>
+            clinic.tags.some(
+              (clinicTag) =>
+                (filterTag as any).id === (clinicTag as any).id ||
+                (filterTag as any).name === (clinicTag as any).name
+            )
+          );
+
+          if (hasAllTags) {
+            // Add distance to clinic object for reference
+            filteredDocs.push({
+              doc,
+              distance: distanceInKm,
+            });
+          }
+        } else {
+          // Add distance to clinic object for reference
+          filteredDocs.push({
+            doc,
+            distance: distanceInKm,
+          });
+        }
+      }
+    }
+
+    console.log(
+      `[CLINIC_UTILS] Filtered to ${filteredDocs.length} clinics within ${rangeInKm}km`
+    );
+
+    // Sort results by distance
+    filteredDocs.sort((a, b) => a.distance - b.distance);
+
+    // Apply pagination if needed
+    let paginatedDocs = filteredDocs;
+    let lastVisible = null;
+
+    if (pagination && pagination > 0) {
+      // If we have a lastDoc, find its index in our sorted results
+      let startIndex = 0;
+      if (lastDoc) {
+        const lastDocIndex = filteredDocs.findIndex(
+          (item) => item.doc.id === lastDoc.id
+        );
+        if (lastDocIndex !== -1) {
+          startIndex = lastDocIndex + 1;
+        }
+      }
+
+      // Get the paginated subset
+      paginatedDocs = filteredDocs.slice(startIndex, startIndex + pagination);
+
+      // Set the last document for the next pagination
+      lastVisible =
+        paginatedDocs.length > 0
+          ? paginatedDocs[paginatedDocs.length - 1].doc
+          : null;
+    }
+
+    // Map to Clinic objects with distance information
+    const clinics = paginatedDocs.map((item) => {
+      const data = item.doc.data() as Clinic;
+      return {
+        ...data,
+        id: item.doc.id,
+        distance: item.distance, // Include distance in response
+      } as Clinic & { distance: number };
+    });
+
+    return {
+      clinics,
+      lastDoc: lastVisible,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinics in range:", error);
+    throw error;
+  }
+}

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

@@ -11,6 +11,7 @@ import {
   Timestamp,
   serverTimestamp,
   DocumentData,
+  writeBatch,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -47,12 +48,16 @@ import { CategoryService } from "../../backoffice/services/category.service";
 import { SubcategoryService } from "../../backoffice/services/subcategory.service";
 import { TechnologyService } from "../../backoffice/services/technology.service";
 import { ProductService } from "../../backoffice/services/product.service";
-import { Practitioner } from "../../types/practitioner";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../types/practitioner";
 import {
   CertificationLevel,
   CertificationSpecialty,
   ProcedureFamily,
 } from "../../backoffice/types";
+import { CLINICS_COLLECTION } from "../../types/clinic";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -103,6 +108,68 @@ export class ProcedureService extends BaseService {
       throw new Error("One or more required entities not found");
     }
 
+    // Get clinic and practitioner information
+    const clinicRef = doc(
+      this.db,
+      CLINICS_COLLECTION,
+      validatedData.clinicBranchId
+    );
+    const clinicSnapshot = await getDoc(clinicRef);
+
+    if (!clinicSnapshot.exists()) {
+      throw new Error(
+        `Clinic with ID ${validatedData.clinicBranchId} not found`
+      );
+    }
+
+    const clinic = clinicSnapshot.data();
+
+    // Create clinic info
+    const clinicInfo = {
+      id: clinicSnapshot.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,
+    };
+
+    // Get practitioner information
+    const practitionerRef = doc(
+      this.db,
+      PRACTITIONERS_COLLECTION,
+      validatedData.practitionerId
+    );
+    const practitionerSnapshot = await getDoc(practitionerRef);
+
+    if (!practitionerSnapshot.exists()) {
+      throw new Error(
+        `Practitioner with ID ${validatedData.practitionerId} not found`
+      );
+    }
+
+    const practitioner = practitionerSnapshot.data();
+
+    // Find doctor info in clinic's doctorsInfo array
+    let doctorInfo = clinic.doctorsInfo?.find(
+      (doctor: any) => doctor.id === validatedData.practitionerId
+    );
+
+    // If not found, create basic doctor info
+    if (!doctorInfo) {
+      doctorInfo = {
+        id: practitionerSnapshot.id,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        description: practitioner.basicInfo.bio || "",
+        photo: practitioner.basicInfo.profileImageUrl || "",
+        rating: 0,
+        services: [],
+      };
+    }
+
     // Create the procedure object
     const procedure: Omit<Procedure, "id"> = {
       ...validatedData,
@@ -116,6 +183,8 @@ export class ProcedureService extends BaseService {
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
       documentationTemplates: technology.documentationTemplates || [],
+      clinicInfo,
+      doctorInfo,
       isActive: true,
       createdAt: new Date(),
       updatedAt: new Date(),
@@ -210,6 +279,9 @@ export class ProcedureService extends BaseService {
       updatedAt: serverTimestamp(),
     });
 
+    // Return the updated procedure with combined data
+    // Note: Since we're not changing the clinicInfo or doctorInfo in this update,
+    // we just keep the existing values from the procedure
     return {
       ...existingProcedure,
       ...validatedData,
@@ -267,4 +339,311 @@ export class ProcedureService extends BaseService {
       subcategories,
     };
   }
+
+  /**
+   * Gets all procedures with optional pagination
+   *
+   * @param pagination - Optional number of procedures per page (0 or undefined returns all)
+   * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @returns Object containing procedures array and the last document for pagination
+   */
+  async getAllProcedures(
+    pagination?: number,
+    lastDoc?: any
+  ): Promise<{ procedures: Procedure[]; lastDoc: any }> {
+    try {
+      const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
+      let proceduresQuery = query(proceduresCollection);
+
+      // If pagination is specified and greater than 0, limit the query
+      if (pagination && pagination > 0) {
+        const { limit, startAfter } = require("firebase/firestore");
+
+        if (lastDoc) {
+          proceduresQuery = query(
+            proceduresCollection,
+            startAfter(lastDoc),
+            limit(pagination)
+          );
+        } else {
+          proceduresQuery = query(proceduresCollection, limit(pagination));
+        }
+      }
+
+      const proceduresSnapshot = await getDocs(proceduresQuery);
+      const lastVisible =
+        proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
+
+      const procedures = proceduresSnapshot.docs.map((doc) => {
+        const data = doc.data() as Procedure;
+
+        // Ensure clinicInfo and doctorInfo are present
+        if (!data.clinicInfo || !data.doctorInfo) {
+          console.warn(
+            `Procedure ${data.id} is missing clinicInfo or doctorInfo fields. These should be updated.`
+          );
+        }
+
+        return {
+          ...data,
+          id: doc.id,
+        };
+      });
+
+      return {
+        procedures,
+        lastDoc: lastVisible,
+      };
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Error getting all procedures:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates the clinicInfo and doctorInfo fields in procedures when the source data changes
+   *
+   * @param entityType - The type of entity that changed ("clinic" or "doctor")
+   * @param entityId - The ID of the entity that changed
+   * @param updatedData - The updated data for the entity
+   * @returns Number of procedures updated
+   */
+  async updateProcedureAggregateData(
+    entityType: "clinic" | "doctor",
+    entityId: string,
+    updatedData: any
+  ): Promise<number> {
+    let proceduresQuery;
+    const updatedField = entityType === "clinic" ? "clinicInfo" : "doctorInfo";
+
+    // Find all procedures related to this entity
+    if (entityType === "clinic") {
+      proceduresQuery = query(
+        collection(this.db, PROCEDURES_COLLECTION),
+        where("clinicBranchId", "==", entityId)
+      );
+    } else {
+      proceduresQuery = query(
+        collection(this.db, PROCEDURES_COLLECTION),
+        where("practitionerId", "==", entityId)
+      );
+    }
+
+    const snapshot = await getDocs(proceduresQuery);
+
+    if (snapshot.empty) {
+      return 0;
+    }
+
+    // Create the updated data object
+    let updatedFieldData;
+
+    if (entityType === "clinic") {
+      // Clinic info format
+      updatedFieldData = {
+        id: entityId,
+        name: updatedData.name,
+        description: updatedData.description || "",
+        featuredPhoto:
+          updatedData.featuredPhotos && updatedData.featuredPhotos.length > 0
+            ? updatedData.featuredPhotos[0]
+            : updatedData.coverPhoto || "",
+        location: updatedData.location,
+        contactInfo: updatedData.contactInfo,
+      };
+    } else {
+      // Doctor info format
+      if (updatedData.basicInfo) {
+        // If it's a practitioner object
+        updatedFieldData = {
+          id: entityId,
+          name: `${updatedData.basicInfo.firstName} ${updatedData.basicInfo.lastName}`,
+          description: updatedData.basicInfo.bio || "",
+          photo: updatedData.basicInfo.profileImageUrl || "",
+          rating: 0, // This would need to be calculated or passed in
+          services: [], // This would need to be determined or passed in
+        };
+      } else {
+        // If it's already a doctorInfo object
+        updatedFieldData = {
+          id: entityId,
+          name: updatedData.name,
+          description: updatedData.description || "",
+          photo: updatedData.photo || "",
+          rating: updatedData.rating || 0,
+          services: updatedData.services || [],
+        };
+      }
+    }
+
+    // Update all found procedures
+    const batch = writeBatch(this.db);
+
+    snapshot.docs.forEach((doc) => {
+      batch.update(doc.ref, {
+        [updatedField]: updatedFieldData,
+        updatedAt: serverTimestamp(),
+      });
+    });
+
+    await batch.commit();
+
+    return snapshot.size;
+  }
+
+  /**
+   * Updates the clinicInfo for all procedures associated with a specific clinic
+   *
+   * @param clinicId - The ID of the clinic that was updated
+   * @param clinicData - The updated clinic data
+   * @returns Number of procedures updated
+   */
+  async updateClinicInfoInProcedures(
+    clinicId: string,
+    clinicData: any
+  ): Promise<number> {
+    return this.updateProcedureAggregateData("clinic", clinicId, clinicData);
+  }
+
+  /**
+   * Updates the doctorInfo for all procedures associated with a specific practitioner
+   *
+   * @param practitionerId - The ID of the practitioner that was updated
+   * @param practitionerData - The updated practitioner data
+   * @returns Number of procedures updated
+   */
+  async updateDoctorInfoInProcedures(
+    practitionerId: string,
+    practitionerData: any
+  ): Promise<number> {
+    return this.updateProcedureAggregateData(
+      "doctor",
+      practitionerId,
+      practitionerData
+    );
+  }
+
+  /**
+   * Updates all existing procedures to include clinicInfo and doctorInfo
+   * This is a migration helper method that can be used to update existing procedures
+   *
+   * @returns Number of procedures updated
+   */
+  async migrateAllProceduresWithAggregateData(): Promise<number> {
+    // Get all procedures
+    const proceduresQuery = query(collection(this.db, PROCEDURES_COLLECTION));
+    const proceduresSnapshot = await getDocs(proceduresQuery);
+
+    if (proceduresSnapshot.empty) {
+      return 0;
+    }
+
+    let updatedCount = 0;
+    const batch = writeBatch(this.db);
+    const batchLimit = 500; // Firestore batch limit
+    let batchCount = 0;
+
+    // Process each procedure
+    for (const procedureDoc of proceduresSnapshot.docs) {
+      const procedure = procedureDoc.data() as Procedure;
+
+      // Skip if already has both required fields
+      if (procedure.clinicInfo && procedure.doctorInfo) {
+        continue;
+      }
+
+      try {
+        // Get clinic data
+        const clinicRef = doc(
+          this.db,
+          CLINICS_COLLECTION,
+          procedure.clinicBranchId
+        );
+        const clinicSnapshot = await getDoc(clinicRef);
+
+        if (!clinicSnapshot.exists()) {
+          console.warn(
+            `Clinic ${procedure.clinicBranchId} not found for procedure ${procedure.id}`
+          );
+          continue;
+        }
+
+        const clinic = clinicSnapshot.data();
+
+        // Create clinic info
+        const clinicInfo = {
+          id: clinicSnapshot.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,
+        };
+
+        // Get practitioner data
+        const practitionerRef = doc(
+          this.db,
+          PRACTITIONERS_COLLECTION,
+          procedure.practitionerId
+        );
+        const practitionerSnapshot = await getDoc(practitionerRef);
+
+        if (!practitionerSnapshot.exists()) {
+          console.warn(
+            `Practitioner ${procedure.practitionerId} not found for procedure ${procedure.id}`
+          );
+          continue;
+        }
+
+        const practitioner = practitionerSnapshot.data();
+
+        // Find doctor info in clinic's doctorsInfo array
+        let doctorInfo = clinic.doctorsInfo?.find(
+          (doctor: any) => doctor.id === procedure.practitionerId
+        );
+
+        // If not found, create basic doctor info
+        if (!doctorInfo) {
+          doctorInfo = {
+            id: practitionerSnapshot.id,
+            name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+            description: practitioner.basicInfo.bio || "",
+            photo: practitioner.basicInfo.profileImageUrl || "",
+            rating: 0,
+            services: [],
+          };
+        }
+
+        // Add to batch
+        batch.update(procedureDoc.ref, {
+          clinicInfo,
+          doctorInfo,
+          updatedAt: serverTimestamp(),
+        });
+
+        batchCount++;
+        updatedCount++;
+
+        // Commit batch if we've reached the limit
+        if (batchCount >= batchLimit) {
+          await batch.commit();
+          console.log(`Committed batch of ${batchCount} procedure updates`);
+          batchCount = 0;
+        }
+      } catch (error) {
+        console.error(`Error updating procedure ${procedure.id}:`, error);
+      }
+    }
+
+    // Commit any remaining updates
+    if (batchCount > 0) {
+      await batch.commit();
+      console.log(`Committed final batch of ${batchCount} procedure updates`);
+    }
+
+    return updatedCount;
+  }
 }

package/src/types/procedure/index.ts

@@ -12,6 +12,9 @@ import { BlockingCondition } from "../../backoffice/types/static/blocking-condit
 import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
 import { CertificationRequirement } from "../../backoffice/types/static/certification.types";
 import { DocumentTemplate } from "../documentation-templates";
+import { ClinicInfo } from "../profile";
+import { DoctorInfo } from "../clinic";
+import { PRACTITIONERS_COLLECTION } from "../practitioner";
 
 /**
  * Procedure represents a specific medical procedure that can be performed by a practitioner in a clinic
@@ -58,6 +61,10 @@ export interface Procedure {
   practitionerId: string;
   /** ID of the clinic branch where this procedure is performed */
   clinicBranchId: string;
+  /** Aggregated clinic information */
+  clinicInfo: ClinicInfo;
+  /** Aggregated doctor information */
+  doctorInfo: DoctorInfo;
   /** Whether this procedure is active */
   isActive: boolean;
   /** When this procedure was created */

package/src/validations/procedure.schema.ts

@@ -4,6 +4,7 @@ import {
   Currency,
   PricingMeasure,
 } from "../backoffice/types/static/pricing.types";
+import { clinicInfoSchema, doctorInfoSchema } from "./clinic.schema";
 
 /**
  * Schema for creating a new procedure
@@ -52,6 +53,8 @@ export const procedureSchema = createProcedureSchema.extend({
   postRequirements: z.array(z.any()), // We'll validate requirements separately
   certificationRequirement: z.any(), // We'll validate certification requirement separately
   documentationTemplates: z.array(z.any()), // We'll validate documentation templates separately
+  clinicInfo: clinicInfoSchema, // Clinic info validation
+  doctorInfo: doctorInfoSchema, // Doctor info validation
   isActive: z.boolean(),
   createdAt: z.date(),
   updatedAt: z.date(),