@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

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,25 @@ 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, PractitionerToken } 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";
+
+// Import mailing services
+import { BaseMailingService } from "./mailing/base.mailing.service";
+import { PractitionerInviteMailingService } from "./mailing/practitionerInvite/practitionerInvite.mailing";
+
+// Re-export types
 export type {
   Notification,
   BaseNotification,
@@ -16,13 +33,52 @@ 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, PractitionerToken } 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,
+};
+
+// Export mailing services
+export { BaseMailingService, PractitionerInviteMailingService };
+
+/**
+ * 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/admin/mailing/README.md

@@ -0,0 +1,95 @@
+# Mailing Services
+
+This module provides mailing services for sending automated emails from the application using Mailgun.
+
+## Setup
+
+### 1. Install Dependencies
+
+Make sure to install the required dependencies:
+
+```bash
+npm install mailgun-js firebase-admin firebase-functions
+```
+
+### 2. Configure Mailgun
+
+To use the mailing services, you need to configure Mailgun credentials in your Firebase project:
+
+```bash
+firebase functions:config:set mailgun.api_key="your-mailgun-api-key" mailgun.domain="your-mailgun-domain" mailgun.from="MedClinic <no-reply@your-domain.com>"
+```
+
+To enable test mode (emails won't actually be sent):
+
+```bash
+firebase functions:config:set mailgun.test_mode="true"
+```
+
+### 3. Deploy Cloud Functions
+
+Deploy the cloud functions to start handling email sending events:
+
+```bash
+firebase deploy --only functions
+```
+
+## Available Services
+
+### Practitioner Invitation Service
+
+Sends email invitations to practitioners when they are invited to join a clinic.
+
+#### How it works:
+
+1. When a new practitioner token is created in the Firestore database, the `onPractitionerTokenCreated` cloud function is triggered.
+2. The function uses the `PractitionerInviteMailingService` to send an invitation email to the practitioner.
+3. The email contains the token needed to claim their profile and instructions for registration.
+
+#### Example Usage in Code:
+
+```typescript
+import { PractitionerInviteMailingService } from "./admin/mailing";
+
+// Create a new instance of the service
+const mailingService = new PractitionerInviteMailingService();
+
+// Send an invitation email
+await mailingService.sendInvitationEmail({
+  token: {
+    id: "token-id",
+    token: "ABC123",
+    practitionerId: "practitioner-id",
+    email: "doctor@example.com",
+    clinicId: "clinic-id",
+    expiresAt: admin.firestore.Timestamp.fromDate(new Date()),
+  },
+  practitioner: {
+    firstName: "John",
+    lastName: "Doe",
+  },
+  clinic: {
+    name: "Example Clinic",
+    contactEmail: "admin@example.com",
+    contactName: "Clinic Admin",
+  },
+  options: {
+    registrationUrl: "https://your-app.com/register",
+    customSubject: "Join Our Clinic",
+  },
+});
+```
+
+## Adding New Mailing Services
+
+To add a new mailing service:
+
+1. Create a new directory in the `mailing` folder for your service
+2. Create a service class that extends `BaseMailingService`
+3. Create an HTML template in a `templates` subfolder
+4. Create a cloud function to trigger the email sending
+5. Export your new service in the index files
+
+## Logging
+
+All email sending attempts are logged to the `email_logs` collection in Firestore for tracking and debugging purposes.