@blackcode_sa/metaestetics-api 1.5.27 → 1.5.29

package/src/admin/aggregation/procedure/procedure.aggregation.service.ts

@@ -0,0 +1,508 @@
+import * as admin from "firebase-admin";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PROCEDURES_COLLECTION } from "../../../types/procedure";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+import { ProcedureSummaryInfo } from "../../../types/procedure";
+
+const CALENDAR_SUBCOLLECTION_ID = "calendar";
+
+/**
+ * @class ProcedureAggregationService
+ * @description Handles aggregation tasks related to procedure data updates/deletions.
+ */
+export class ProcedureAggregationService {
+  private db: admin.firestore.Firestore;
+
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  /**
+   * Adds procedure information to a practitioner when a new procedure is created
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureSummary - Summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async addProcedureToPractitioner(
+    practitionerId: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    if (!practitionerId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for adding procedure to practitioner. Skipping."
+      );
+      return;
+    }
+
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to practitioner ${practitionerId}.`
+    );
+
+    const practitionerRef = this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId);
+
+    try {
+      await practitionerRef.update({
+        procedureIds: admin.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully added procedure ${procedureId} to practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error adding procedure ${procedureId} to practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Adds procedure information to a clinic when a new procedure is created
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureSummary - Summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async addProcedureToClinic(
+    clinicId: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    if (!clinicId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureSummary for adding procedure to clinic. Skipping."
+      );
+      return;
+    }
+
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Adding procedure ${procedureId} to clinic ${clinicId}.`
+    );
+
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+    try {
+      await clinicRef.update({
+        procedures: admin.firestore.FieldValue.arrayUnion(procedureId),
+        proceduresInfo: admin.firestore.FieldValue.arrayUnion(procedureSummary),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully added procedure ${procedureId} to clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error adding procedure ${procedureId} to clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates procedure information in a practitioner document
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureSummary - Updated summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInPractitioner(
+    practitionerId: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    if (!practitionerId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureSummary for updating procedure in practitioner. Skipping."
+      );
+      return;
+    }
+
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Updating procedure ${procedureId} info in practitioner ${practitionerId}.`
+    );
+
+    const practitionerRef = this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId);
+
+    // This requires a transaction to avoid race conditions
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const practitionerDoc = await transaction.get(practitionerRef);
+        if (!practitionerDoc.exists) {
+          throw new Error(
+            `Practitioner ${practitionerId} does not exist for procedure update`
+          );
+        }
+
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for procedure update`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+
+        // Remove the old procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Add the updated procedure summary
+        updatedProceduresInfo.push(procedureSummary);
+
+        // Update the practitioner document
+        transaction.update(practitionerRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure ${procedureId} info in practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure ${procedureId} info in practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates procedure information in a clinic document
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureSummary - Updated summary information about the procedure
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInClinic(
+    clinicId: string,
+    procedureSummary: ProcedureSummaryInfo
+  ): Promise<void> {
+    if (!clinicId || !procedureSummary) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureSummary for updating procedure in clinic. Skipping."
+      );
+      return;
+    }
+
+    const procedureId = procedureSummary.id;
+    console.log(
+      `[ProcedureAggregationService] Updating procedure ${procedureId} info in clinic ${clinicId}.`
+    );
+
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+    // This requires a transaction to avoid race conditions
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const clinicDoc = await transaction.get(clinicRef);
+        if (!clinicDoc.exists) {
+          throw new Error(
+            `Clinic ${clinicId} does not exist for procedure update`
+          );
+        }
+
+        const clinicData = clinicDoc.data();
+        if (!clinicData) {
+          throw new Error(
+            `Clinic ${clinicId} data is empty for procedure update`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = clinicData.proceduresInfo || [];
+
+        // Remove the old procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Add the updated procedure summary
+        updatedProceduresInfo.push(procedureSummary);
+
+        // Update the clinic document
+        transaction.update(clinicRef, {
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure ${procedureId} info in clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure ${procedureId} info in clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Updates procedure information in calendar events
+   * @param procedureId - ID of the procedure
+   * @param procedureInfo - Updated procedure information
+   * @returns {Promise<void>}
+   */
+  async updateProcedureInfoInCalendarEvents(
+    procedureId: string,
+    procedureInfo: any
+  ): Promise<void> {
+    if (!procedureId || !procedureInfo) {
+      console.log(
+        "[ProcedureAggregationService] Missing procedureId or procedureInfo for calendar update. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Querying upcoming calendar events for procedure ${procedureId} to update procedure info.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("procedureId", "==", procedureId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ProcedureAggregationService] No upcoming calendar events found for procedure ${procedureId}. No procedure info updates needed.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          procedureInfo: procedureInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[ProcedureAggregationService] Successfully updated procedure info in ${snapshot.size} upcoming calendar events for procedure ${procedureId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error updating procedure info in calendar events for procedure ${procedureId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Cancels all upcoming calendar events for a procedure
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async cancelUpcomingCalendarEventsForProcedure(
+    procedureId: string
+  ): Promise<void> {
+    if (!procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing procedureId for canceling calendar events. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Querying upcoming calendar events for procedure ${procedureId} to cancel.`
+    );
+
+    const now = admin.firestore.Timestamp.now();
+    // Use a Collection Group query
+    const calendarEventsQuery = this.db
+      .collectionGroup(CALENDAR_SUBCOLLECTION_ID)
+      .where("procedureId", "==", procedureId)
+      .where("eventTime.start", ">", now);
+
+    try {
+      const snapshot = await calendarEventsQuery.get();
+      if (snapshot.empty) {
+        console.log(
+          `[ProcedureAggregationService] No upcoming calendar events found for procedure ${procedureId}. No events to cancel.`
+        );
+        return;
+      }
+
+      const batch = this.db.batch();
+      snapshot.docs.forEach((doc) => {
+        console.log(
+          `[ProcedureAggregationService] Canceling calendar event ${doc.ref.path}`
+        );
+        batch.update(doc.ref, {
+          status: "CANCELED",
+          cancelReason: "Procedure deleted or inactivated",
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      await batch.commit();
+      console.log(
+        `[ProcedureAggregationService] Successfully canceled ${snapshot.size} upcoming calendar events for procedure ${procedureId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error canceling calendar events for procedure ${procedureId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Removes procedure from a practitioner when a procedure is deleted or inactivated
+   * @param practitionerId - ID of the practitioner who performs the procedure
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async removeProcedureFromPractitioner(
+    practitionerId: string,
+    procedureId: string
+  ): Promise<void> {
+    if (!practitionerId || !procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing practitionerId or procedureId for removing procedure from practitioner. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Removing procedure ${procedureId} from practitioner ${practitionerId}.`
+    );
+
+    const practitionerRef = this.db
+      .collection(PRACTITIONERS_COLLECTION)
+      .doc(practitionerId);
+
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const practitionerDoc = await transaction.get(practitionerRef);
+        if (!practitionerDoc.exists) {
+          throw new Error(
+            `Practitioner ${practitionerId} does not exist for procedure removal`
+          );
+        }
+
+        const practitionerData = practitionerDoc.data();
+        if (!practitionerData) {
+          throw new Error(
+            `Practitioner ${practitionerId} data is empty for procedure removal`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = practitionerData.proceduresInfo || [];
+
+        // Remove the procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Update the practitioner document
+        transaction.update(practitionerRef, {
+          procedureIds: admin.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully removed procedure ${procedureId} from practitioner ${practitionerId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error removing procedure ${procedureId} from practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Removes procedure from a clinic when a procedure is deleted or inactivated
+   * @param clinicId - ID of the clinic where the procedure is performed
+   * @param procedureId - ID of the procedure
+   * @returns {Promise<void>}
+   */
+  async removeProcedureFromClinic(
+    clinicId: string,
+    procedureId: string
+  ): Promise<void> {
+    if (!clinicId || !procedureId) {
+      console.log(
+        "[ProcedureAggregationService] Missing clinicId or procedureId for removing procedure from clinic. Skipping."
+      );
+      return;
+    }
+
+    console.log(
+      `[ProcedureAggregationService] Removing procedure ${procedureId} from clinic ${clinicId}.`
+    );
+
+    const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(clinicId);
+
+    try {
+      await this.db.runTransaction(async (transaction) => {
+        const clinicDoc = await transaction.get(clinicRef);
+        if (!clinicDoc.exists) {
+          throw new Error(
+            `Clinic ${clinicId} does not exist for procedure removal`
+          );
+        }
+
+        const clinicData = clinicDoc.data();
+        if (!clinicData) {
+          throw new Error(
+            `Clinic ${clinicId} data is empty for procedure removal`
+          );
+        }
+
+        // Get current procedures info array
+        const proceduresInfo = clinicData.proceduresInfo || [];
+
+        // Remove the procedure summary
+        const updatedProceduresInfo = proceduresInfo.filter(
+          (p: ProcedureSummaryInfo) => p.id !== procedureId
+        );
+
+        // Update the clinic document
+        transaction.update(clinicRef, {
+          procedures: admin.firestore.FieldValue.arrayRemove(procedureId),
+          proceduresInfo: updatedProceduresInfo,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      });
+
+      console.log(
+        `[ProcedureAggregationService] Successfully removed procedure ${procedureId} from clinic ${clinicId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[ProcedureAggregationService] Error removing procedure ${procedureId} from clinic ${clinicId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/admin/index.ts

@@ -5,8 +5,21 @@ import {
   NotificationType,
 } from "../types/notifications";
 import { UserRole } from "../types";
+// Import types needed by admin consumers (like Cloud Functions)
+import { Clinic, ClinicLocation } from "../types/clinic";
+import { ClinicInfo } from "../types/profile";
+import { Practitioner } from "../types/practitioner";
+import { DoctorInfo } from "../types/clinic";
+import { Procedure, ProcedureSummaryInfo } from "../types/procedure";
+import { PatientProfile } from "../types/patient";
 
-// Re-export tipova koji su potrebni za admin modul
+// Explicitly import the services to re-export them by name
+import { ClinicAggregationService } from "./aggregation/clinic/clinic.aggregation.service";
+import { PractitionerAggregationService } from "./aggregation/practitioner/practitioner.aggregation.service";
+import { ProcedureAggregationService } from "./aggregation/procedure/procedure.aggregation.service";
+import { PatientAggregationService } from "./aggregation/patient/patient.aggregation.service";
+
+// Re-export types
 export type {
   Notification,
   BaseNotification,
@@ -16,13 +29,49 @@ export type {
   AppointmentNotification,
 } from "../types/notifications";
 
+// Re-export types needed by cloud functions
+export type { Clinic, ClinicLocation } from "../types/clinic";
+export type { ClinicInfo } from "../types/profile";
+export type { Practitioner } from "../types/practitioner";
+export type { DoctorInfo } from "../types/clinic";
+export type { Procedure, ProcedureSummaryInfo } from "../types/procedure";
+export type { PatientProfile as Patient } from "../types/patient";
+
+// Re-export enums/consts
 export {
   NotificationType,
   NotificationStatus,
   NOTIFICATIONS_COLLECTION,
 } from "../types/notifications";
-
 export { UserRole } from "../types";
 
-// Export admin klasa
-export { NotificationsAdmin };
+// Export admin classes/services explicitly by name
+export {
+  NotificationsAdmin,
+  ClinicAggregationService,
+  PractitionerAggregationService,
+  ProcedureAggregationService,
+  PatientAggregationService,
+};
+
+/**
+ * Main entry point for the Admin module.
+ * This module contains services and utilities intended for administrative tasks,
+ * background processing, and potentially direct use by admin interfaces or Cloud Functions.
+ */
+
+// --- Aggregation Services --- //
+// Placeholder: export * from "./aggregation/practitioner/practitioner.aggregation.service";
+// Placeholder: export * from "./aggregation/procedure/procedure.aggregation.service";
+// Placeholder: export * from "./aggregation/patient/patient.aggregation.service";
+
+// --- Other Admin Services/Utilities (Add as needed) --- //
+// Example: export * from './user-management/user-management.service';
+// Example: export * from './reporting/reporting.service';
+
+console.log("[Admin Module] Initialized and services exported.");
+
+// Note: Ensure that services exported here are properly initialized
+// if they have dependencies (like Firestore db) that need to be injected.
+// The initialization pattern might differ depending on how this module is consumed
+// (e.g., within a larger NestJS app vs. standalone Cloud Functions).

package/src/index.ts

@@ -131,7 +131,6 @@ export type {
   CreatePractitionerData,
   UpdatePractitionerData,
   PractitionerClinicProcedures,
-  PractitionerReview,
   PractitionerWorkingHours,
   PractitionerClinicWorkingHours,
   CreateDraftPractitionerData,
@@ -160,15 +159,12 @@ export type {
   ClinicContactInfo,
   WorkingHours,
   ClinicTags,
-  ClinicReview,
   ClinicAdminSignupData,
   ContactPerson,
   AdminToken,
   AdminInfo,
   CreateAdminTokenData,
   DoctorInfo,
-  ServiceInfo,
-  ReviewInfo,
   CreateDefaultClinicGroupData,
   ClinicGroupSetupData,
   ClinicBranchSetupData,
@@ -291,3 +287,31 @@ export type {
   UpdateProcedureData,
 } from "./types/procedure";
 export { PROCEDURES_COLLECTION } from "./types/procedure";
+
+// Review types
+export type {
+  ClinicReview,
+  PractitionerReview,
+  ProcedureReview,
+  ClinicReviewInfo,
+  PractitionerReviewInfo,
+  ProcedureReviewInfo,
+  Review,
+} from "./types/reviews";
+
+export { REVIEWS_COLLECTION } from "./types/reviews/index";
+
+// Review schemas
+export {
+  clinicReviewSchema,
+  createClinicReviewSchema,
+  practitionerReviewSchema,
+  createPractitionerReviewSchema,
+  procedureReviewSchema,
+  createProcedureReviewSchema,
+  clinicReviewInfoSchema,
+  practitionerReviewInfoSchema,
+  procedureReviewInfoSchema,
+  reviewSchema,
+  createReviewSchema,
+} from "./validations/reviews.schema";

package/src/services/calendar/calendar-refactored.service.ts

@@ -1107,7 +1107,7 @@ export class CalendarServiceV2 extends BaseService {
       appointmentId,
       clinicId,
       eventTime: appointment.eventTime,
-      description: appointment.description,
+      description: appointment.description || "",
       doctorId: appointment.practitionerProfileId || "",
       patientId: appointment.patientProfileId || "",
       status,