@blackcode_sa/metaestetics-api 1.15.16 → 1.15.17-staging.1

package/src/admin/mailing/practitionerInvite/existing-practitioner-invite.mailing.ts

@@ -1,611 +1,611 @@
-import * as admin from "firebase-admin";
-import { BaseMailingService } from "../base.mailing.service";
-import { existingPractitionerInvitationTemplate } from "./templates/existing-practitioner-invitation.template";
-import { inviteAcceptedNotificationTemplate } from "./templates/invite-accepted-notification.template";
-import { inviteRejectedNotificationTemplate } from "./templates/invite-rejected-notification.template";
-import { Logger } from "../../logger";
-
-// Import specific types and collection constants
-import {
-  PractitionerInvite,
-  PractitionerInviteStatus,
-} from "../../../types/clinic/practitioner-invite.types";
-import {
-  Practitioner,
-  PRACTITIONERS_COLLECTION,
-} from "../../../types/practitioner";
-import { Clinic, CLINICS_COLLECTION } from "../../../types/clinic";
-
-// Define minimal interface for the mailgun.js client
-interface NewMailgunMessagesAPI {
-  create(domain: string, data: any): Promise<any>;
-}
-interface NewMailgunClient {
-  messages: NewMailgunMessagesAPI;
-}
-
-/**
- * Interface for sending practitioner invitation email data
- */
-export interface ExistingPractitionerInviteEmailData {
-  /** The practitioner invite object */
-  invite: PractitionerInvite;
-
-  /** Practitioner details */
-  practitioner: {
-    firstName: string;
-    lastName: string;
-    email: string;
-    specialties?: string[];
-    profileImageUrl?: string | null;
-  };
-
-  /** Clinic details */
-  clinic: {
-    name: string;
-    address: string;
-    contactEmail: string;
-    contactPhone?: string;
-  };
-
-  /** URLs for accept/reject actions */
-  urls: {
-    acceptUrl: string;
-    rejectUrl: string;
-  };
-
-  /** Configuration options */
-  options?: {
-    customSubject?: string;
-    fromAddress?: string;
-    mailgunDomain?: string;
-  };
-}
-
-/**
- * Interface for clinic admin notification email data
- */
-export interface ClinicAdminNotificationData {
-  /** The practitioner invite object */
-  invite: PractitionerInvite;
-
-  /** Practitioner details */
-  practitioner: {
-    firstName: string;
-    lastName: string;
-    specialties?: string[];
-    profileImageUrl?: string | null;
-    experienceYears?: number;
-  };
-
-  /** Clinic details */
-  clinic: {
-    name: string;
-    adminName?: string;
-    adminEmail: string;
-  };
-
-  /** Additional context */
-  context: {
-    invitationDate: string;
-    responseDate: string;
-    rejectionReason?: string;
-  };
-
-  /** URLs for dashboard access */
-  urls: {
-    clinicDashboardUrl: string;
-    practitionerProfileUrl?: string;
-    findPractitionersUrl?: string;
-  };
-
-  /** Configuration options */
-  options?: {
-    customSubject?: string;
-    fromAddress?: string;
-    mailgunDomain?: string;
-  };
-}
-
-/**
- * Service for sending existing practitioner invitation emails
- * This service handles the email flow for inviting active practitioners to join clinics
- */
-export class ExistingPractitionerInviteMailingService extends BaseMailingService {
-  private readonly DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
-  private readonly DEFAULT_FROM_ADDRESS =
-    "Metaesthetics <no-reply@mg.metaesthetics.net>";
-
-  /**
-   * Constructor for ExistingPractitionerInviteMailingService
-   * @param firestore Firestore instance provided by the caller
-   * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
-   */
-  constructor(
-    firestore: FirebaseFirestore.Firestore,
-    mailgunClient: NewMailgunClient
-  ) {
-    super(firestore, mailgunClient);
-  }
-
-  /**
-   * Sends an invitation email to an existing practitioner
-   * @param data The invitation email data
-   * @returns Promise resolved when email is sent
-   */
-  async sendPractitionerInvitationEmail(
-    data: ExistingPractitionerInviteEmailData
-  ): Promise<any> {
-    try {
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Sending invitation email to practitioner",
-        data.practitioner.email
-      );
-
-      // Format working hours for display
-      const workingHours = this.formatWorkingHours(
-        data.invite.proposedWorkingHours
-      );
-
-      // Format expiration date - using createdAt + 30 days as default expiry
-      const expiryDate = new Date(data.invite.createdAt.toDate());
-      expiryDate.setDate(expiryDate.getDate() + 30); // 30 days from creation
-
-      const expirationDate = expiryDate.toLocaleDateString("en-US", {
-        weekday: "long",
-        year: "numeric",
-        month: "long",
-        day: "numeric",
-      });
-
-      // Practitioner full name
-      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
-
-      // Template variables
-      const templateVariables = {
-        clinicName: data.clinic.name,
-        practitionerName,
-        clinicAddress: data.clinic.address,
-        workingHours,
-        expirationDate,
-        acceptUrl: data.urls.acceptUrl,
-        rejectUrl: data.urls.rejectUrl,
-        contactEmail: data.clinic.contactEmail,
-        contactPhone: data.clinic.contactPhone || "Contact clinic directly",
-        currentYear: new Date().getFullYear().toString(),
-      };
-
-      // Render HTML email
-      const html = this.renderTemplate(
-        existingPractitionerInvitationTemplate,
-        templateVariables
-      );
-
-      // Email configuration
-      const subject =
-        data.options?.customSubject || `Invitation to Join ${data.clinic.name}`;
-      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
-      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
-
-      const mailgunData = {
-        to: data.practitioner.email,
-        from,
-        subject,
-        html,
-      };
-
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Sending email with data:",
-        {
-          domain,
-          to: mailgunData.to,
-          from: mailgunData.from,
-          subject: mailgunData.subject,
-          hasHtml: !!mailgunData.html,
-        }
-      );
-
-      // Send the email
-      const result = await this.sendEmail(domain, mailgunData);
-
-      // Log success
-      await this.logEmailAttempt(
-        {
-          to: data.practitioner.email,
-          subject,
-          templateName: "existing_practitioner_invitation",
-        },
-        true
-      );
-
-      return result;
-    } catch (error: any) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error sending practitioner invitation:",
-        {
-          errorMessage: error.message,
-          errorDetails: error.details,
-          errorStatus: error.status,
-          stack: error.stack,
-        }
-      );
-
-      // Log failure
-      await this.logEmailAttempt(
-        {
-          to: data.practitioner.email,
-          subject:
-            data.options?.customSubject ||
-            `Invitation to Join ${data.clinic.name}`,
-          templateName: "existing_practitioner_invitation",
-        },
-        false,
-        error
-      );
-
-      throw error;
-    }
-  }
-
-  /**
-   * Sends a notification email to clinic admin when practitioner accepts invitation
-   * @param data The notification email data
-   * @returns Promise resolved when email is sent
-   */
-  async sendAcceptedNotificationEmail(
-    data: ClinicAdminNotificationData
-  ): Promise<any> {
-    try {
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Sending acceptance notification to clinic admin",
-        data.clinic.adminEmail
-      );
-
-      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
-      const workingHours = this.formatWorkingHours(
-        data.invite.proposedWorkingHours
-      );
-
-      // Template variables - ensure all values are strings
-      const templateVariables: Record<string, string> = {
-        clinicName: data.clinic.name,
-        clinicAdminName: data.clinic.adminName || "Admin",
-        practitionerName,
-        practitionerPhoto: data.practitioner.profileImageUrl || "",
-        practitionerSpecialties:
-          data.practitioner.specialties?.join(", ") || "",
-        practitionerExperience:
-          data.practitioner.experienceYears?.toString() || "",
-        invitationDate: data.context.invitationDate,
-        acceptedDate: data.context.responseDate,
-        workingHours,
-        clinicDashboardUrl: data.urls.clinicDashboardUrl,
-        practitionerProfileUrl: data.urls.practitionerProfileUrl || "#",
-        currentYear: new Date().getFullYear().toString(),
-      };
-
-      // Render HTML email
-      const html = this.renderTemplate(
-        inviteAcceptedNotificationTemplate,
-        templateVariables
-      );
-
-      // Email configuration
-      const subject =
-        data.options?.customSubject ||
-        `Great News! Dr. ${practitionerName} Accepted Your Invitation`;
-      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
-      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
-
-      const mailgunData = {
-        to: data.clinic.adminEmail,
-        from,
-        subject,
-        html,
-      };
-
-      // Send the email
-      const result = await this.sendEmail(domain, mailgunData);
-
-      // Log success
-      await this.logEmailAttempt(
-        {
-          to: data.clinic.adminEmail,
-          subject,
-          templateName: "invite_accepted_notification",
-        },
-        true
-      );
-
-      return result;
-    } catch (error: any) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error sending acceptance notification:",
-        error
-      );
-
-      // Log failure
-      await this.logEmailAttempt(
-        {
-          to: data.clinic.adminEmail,
-          subject: data.options?.customSubject || "Invitation Accepted",
-          templateName: "invite_accepted_notification",
-        },
-        false,
-        error
-      );
-
-      throw error;
-    }
-  }
-
-  /**
-   * Sends a notification email to clinic admin when practitioner rejects invitation
-   * @param data The notification email data
-   * @returns Promise resolved when email is sent
-   */
-  async sendRejectedNotificationEmail(
-    data: ClinicAdminNotificationData
-  ): Promise<any> {
-    try {
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Sending rejection notification to clinic admin",
-        data.clinic.adminEmail
-      );
-
-      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
-
-      // Template variables - ensure all values are strings
-      const templateVariables: Record<string, string> = {
-        clinicName: data.clinic.name,
-        clinicAdminName: data.clinic.adminName || "Admin",
-        practitionerName,
-        practitionerPhoto: data.practitioner.profileImageUrl || "",
-        practitionerSpecialties:
-          data.practitioner.specialties?.join(", ") || "",
-        invitationDate: data.context.invitationDate,
-        rejectedDate: data.context.responseDate,
-        rejectionReason: data.context.rejectionReason || "",
-        findPractitionersUrl: data.urls.findPractitionersUrl || "#",
-        clinicDashboardUrl: data.urls.clinicDashboardUrl,
-        currentYear: new Date().getFullYear().toString(),
-      };
-
-      // Render HTML email
-      const html = this.renderTemplate(
-        inviteRejectedNotificationTemplate,
-        templateVariables
-      );
-
-      // Email configuration
-      const subject =
-        data.options?.customSubject ||
-        `Invitation Update: Dr. ${practitionerName} Declined`;
-      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
-      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
-
-      const mailgunData = {
-        to: data.clinic.adminEmail,
-        from,
-        subject,
-        html,
-      };
-
-      // Send the email
-      const result = await this.sendEmail(domain, mailgunData);
-
-      // Log success
-      await this.logEmailAttempt(
-        {
-          to: data.clinic.adminEmail,
-          subject,
-          templateName: "invite_rejected_notification",
-        },
-        true
-      );
-
-      return result;
-    } catch (error: any) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error sending rejection notification:",
-        error
-      );
-
-      // Log failure
-      await this.logEmailAttempt(
-        {
-          to: data.clinic.adminEmail,
-          subject: data.options?.customSubject || "Invitation Declined",
-          templateName: "invite_rejected_notification",
-        },
-        false,
-        error
-      );
-
-      throw error;
-    }
-  }
-
-  /**
-   * Handles the practitioner invite creation event
-   * Fetches necessary data and sends the invitation email to the practitioner
-   * @param invite The practitioner invite object
-   * @param mailgunConfig Mailgun configuration
-   * @returns Promise resolved when the email is sent
-   */
-  async handleInviteCreationEvent(
-    invite: PractitionerInvite,
-    mailgunConfig: {
-      fromAddress: string;
-      domain: string;
-      acceptUrl: string;
-      rejectUrl: string;
-    }
-  ): Promise<void> {
-    try {
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Handling invite creation event for invite:",
-        invite.id
-      );
-
-      // Validate invite data
-      if (!invite || !invite.id || !invite.practitionerId || !invite.clinicId) {
-        throw new Error(
-          `Invalid invite data: Missing required properties. Invite ID: ${invite?.id}`
-        );
-      }
-
-      // Only send email for pending invites
-      if (invite.status !== PractitionerInviteStatus.PENDING) {
-        Logger.info(
-          "[ExistingPractitionerInviteMailingService] Invite is not pending, skipping email",
-          { inviteId: invite.id, status: invite.status }
-        );
-        return;
-      }
-
-      // Fetch practitioner and clinic data
-      const [practitioner, clinic] = await Promise.all([
-        this.fetchPractitionerById(invite.practitionerId),
-        this.fetchClinicById(invite.clinicId),
-      ]);
-
-      if (!practitioner) {
-        throw new Error(`Practitioner ${invite.practitionerId} not found`);
-      }
-
-      if (!clinic) {
-        throw new Error(`Clinic ${invite.clinicId} not found`);
-      }
-
-      // Prepare email data
-      const emailData: ExistingPractitionerInviteEmailData = {
-        invite,
-        practitioner: {
-          firstName: practitioner.basicInfo.firstName || "",
-          lastName: practitioner.basicInfo.lastName || "",
-          email: practitioner.basicInfo.email || "",
-          specialties:
-            practitioner.certification?.specialties?.map(
-              (s: any) => s.name || s
-            ) || [],
-          profileImageUrl:
-            typeof practitioner.basicInfo.profileImageUrl === "string"
-              ? practitioner.basicInfo.profileImageUrl
-              : null,
-        },
-        clinic: {
-          name: clinic.name || "Medical Clinic",
-          address: this.formatClinicAddress(clinic.location),
-          contactEmail: clinic.contactInfo.email || "contact@clinic.com",
-          contactPhone: clinic.contactInfo.phoneNumber,
-        },
-        urls: {
-          acceptUrl: mailgunConfig.acceptUrl,
-          rejectUrl: mailgunConfig.rejectUrl,
-        },
-        options: {
-          fromAddress: mailgunConfig.fromAddress,
-          mailgunDomain: mailgunConfig.domain,
-        },
-      };
-
-      // Send the invitation email
-      await this.sendPractitionerInvitationEmail(emailData);
-
-      Logger.info(
-        "[ExistingPractitionerInviteMailingService] Invitation email sent successfully"
-      );
-    } catch (error: any) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error handling invite creation event:",
-        {
-          errorMessage: error.message,
-          errorDetails: error.details,
-          errorStatus: error.status,
-          stack: error.stack,
-          inviteId: invite?.id,
-        }
-      );
-      throw error;
-    }
-  }
-
-  // --- Private Helper Methods ---
-
-  /**
-   * Formats working hours for display in emails
-   * @param workingHours The working hours object
-   * @returns Formatted string representation
-   */
-  private formatWorkingHours(workingHours: any): string {
-    if (!workingHours) return "To be determined";
-
-    // This is a simplified formatter - you may want to enhance based on your actual working hours structure
-    return Object.entries(workingHours)
-      .map(([day, hours]) => `${day}: ${hours}`)
-      .join(", ");
-  }
-
-  /**
-   * Formats clinic address for display
-   * @param location The clinic location object
-   * @returns Formatted address string
-   */
-  private formatClinicAddress(location: any): string {
-    if (!location) return "Address not specified";
-
-    const parts = [
-      location.street,
-      location.city,
-      location.state,
-      location.country,
-    ].filter(Boolean);
-
-    return parts.join(", ");
-  }
-
-  /**
-   * Fetches a practitioner by ID
-   * @param practitionerId The practitioner ID
-   * @returns The practitioner or null if not found
-   */
-  private async fetchPractitionerById(
-    practitionerId: string
-  ): Promise<Practitioner | null> {
-    try {
-      const doc = await this.db
-        .collection(PRACTITIONERS_COLLECTION)
-        .doc(practitionerId)
-        .get();
-      return doc.exists ? (doc.data() as Practitioner) : null;
-    } catch (error) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error fetching practitioner:",
-        error
-      );
-      return null;
-    }
-  }
-
-  /**
-   * Fetches a clinic by ID
-   * @param clinicId The clinic ID
-   * @returns The clinic or null if not found
-   */
-  private async fetchClinicById(clinicId: string): Promise<Clinic | null> {
-    try {
-      const doc = await this.db
-        .collection(CLINICS_COLLECTION)
-        .doc(clinicId)
-        .get();
-      return doc.exists ? (doc.data() as Clinic) : null;
-    } catch (error) {
-      Logger.error(
-        "[ExistingPractitionerInviteMailingService] Error fetching clinic:",
-        error
-      );
-      return null;
-    }
-  }
-}
+import * as admin from "firebase-admin";
+import { BaseMailingService } from "../base.mailing.service";
+import { existingPractitionerInvitationTemplate } from "./templates/existing-practitioner-invitation.template";
+import { inviteAcceptedNotificationTemplate } from "./templates/invite-accepted-notification.template";
+import { inviteRejectedNotificationTemplate } from "./templates/invite-rejected-notification.template";
+import { Logger } from "../../logger";
+
+// Import specific types and collection constants
+import {
+  PractitionerInvite,
+  PractitionerInviteStatus,
+} from "../../../types/clinic/practitioner-invite.types";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../../types/practitioner";
+import { Clinic, CLINICS_COLLECTION } from "../../../types/clinic";
+
+// Define minimal interface for the mailgun.js client
+interface NewMailgunMessagesAPI {
+  create(domain: string, data: any): Promise<any>;
+}
+interface NewMailgunClient {
+  messages: NewMailgunMessagesAPI;
+}
+
+/**
+ * Interface for sending practitioner invitation email data
+ */
+export interface ExistingPractitionerInviteEmailData {
+  /** The practitioner invite object */
+  invite: PractitionerInvite;
+
+  /** Practitioner details */
+  practitioner: {
+    firstName: string;
+    lastName: string;
+    email: string;
+    specialties?: string[];
+    profileImageUrl?: string | null;
+  };
+
+  /** Clinic details */
+  clinic: {
+    name: string;
+    address: string;
+    contactEmail: string;
+    contactPhone?: string;
+  };
+
+  /** URLs for accept/reject actions */
+  urls: {
+    acceptUrl: string;
+    rejectUrl: string;
+  };
+
+  /** Configuration options */
+  options?: {
+    customSubject?: string;
+    fromAddress?: string;
+    mailgunDomain?: string;
+  };
+}
+
+/**
+ * Interface for clinic admin notification email data
+ */
+export interface ClinicAdminNotificationData {
+  /** The practitioner invite object */
+  invite: PractitionerInvite;
+
+  /** Practitioner details */
+  practitioner: {
+    firstName: string;
+    lastName: string;
+    specialties?: string[];
+    profileImageUrl?: string | null;
+    experienceYears?: number;
+  };
+
+  /** Clinic details */
+  clinic: {
+    name: string;
+    adminName?: string;
+    adminEmail: string;
+  };
+
+  /** Additional context */
+  context: {
+    invitationDate: string;
+    responseDate: string;
+    rejectionReason?: string;
+  };
+
+  /** URLs for dashboard access */
+  urls: {
+    clinicDashboardUrl: string;
+    practitionerProfileUrl?: string;
+    findPractitionersUrl?: string;
+  };
+
+  /** Configuration options */
+  options?: {
+    customSubject?: string;
+    fromAddress?: string;
+    mailgunDomain?: string;
+  };
+}
+
+/**
+ * Service for sending existing practitioner invitation emails
+ * This service handles the email flow for inviting active practitioners to join clinics
+ */
+export class ExistingPractitionerInviteMailingService extends BaseMailingService {
+  private readonly DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
+  private readonly DEFAULT_FROM_ADDRESS =
+    "Metaesthetics <no-reply@mg.metaesthetics.net>";
+
+  /**
+   * Constructor for ExistingPractitionerInviteMailingService
+   * @param firestore Firestore instance provided by the caller
+   * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
+   */
+  constructor(
+    firestore: FirebaseFirestore.Firestore,
+    mailgunClient: NewMailgunClient
+  ) {
+    super(firestore, mailgunClient);
+  }
+
+  /**
+   * Sends an invitation email to an existing practitioner
+   * @param data The invitation email data
+   * @returns Promise resolved when email is sent
+   */
+  async sendPractitionerInvitationEmail(
+    data: ExistingPractitionerInviteEmailData
+  ): Promise<any> {
+    try {
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Sending invitation email to practitioner",
+        data.practitioner.email
+      );
+
+      // Format working hours for display
+      const workingHours = this.formatWorkingHours(
+        data.invite.proposedWorkingHours
+      );
+
+      // Format expiration date - using createdAt + 30 days as default expiry
+      const expiryDate = new Date(data.invite.createdAt.toDate());
+      expiryDate.setDate(expiryDate.getDate() + 30); // 30 days from creation
+
+      const expirationDate = expiryDate.toLocaleDateString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+      });
+
+      // Practitioner full name
+      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
+
+      // Template variables
+      const templateVariables = {
+        clinicName: data.clinic.name,
+        practitionerName,
+        clinicAddress: data.clinic.address,
+        workingHours,
+        expirationDate,
+        acceptUrl: data.urls.acceptUrl,
+        rejectUrl: data.urls.rejectUrl,
+        contactEmail: data.clinic.contactEmail,
+        contactPhone: data.clinic.contactPhone || "Contact clinic directly",
+        currentYear: new Date().getFullYear().toString(),
+      };
+
+      // Render HTML email
+      const html = this.renderTemplate(
+        existingPractitionerInvitationTemplate,
+        templateVariables
+      );
+
+      // Email configuration
+      const subject =
+        data.options?.customSubject || `Invitation to Join ${data.clinic.name}`;
+      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
+      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
+
+      const mailgunData = {
+        to: data.practitioner.email,
+        from,
+        subject,
+        html,
+      };
+
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Sending email with data:",
+        {
+          domain,
+          to: mailgunData.to,
+          from: mailgunData.from,
+          subject: mailgunData.subject,
+          hasHtml: !!mailgunData.html,
+        }
+      );
+
+      // Send the email
+      const result = await this.sendEmail(domain, mailgunData);
+
+      // Log success
+      await this.logEmailAttempt(
+        {
+          to: data.practitioner.email,
+          subject,
+          templateName: "existing_practitioner_invitation",
+        },
+        true
+      );
+
+      return result;
+    } catch (error: any) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error sending practitioner invitation:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+        }
+      );
+
+      // Log failure
+      await this.logEmailAttempt(
+        {
+          to: data.practitioner.email,
+          subject:
+            data.options?.customSubject ||
+            `Invitation to Join ${data.clinic.name}`,
+          templateName: "existing_practitioner_invitation",
+        },
+        false,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Sends a notification email to clinic admin when practitioner accepts invitation
+   * @param data The notification email data
+   * @returns Promise resolved when email is sent
+   */
+  async sendAcceptedNotificationEmail(
+    data: ClinicAdminNotificationData
+  ): Promise<any> {
+    try {
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Sending acceptance notification to clinic admin",
+        data.clinic.adminEmail
+      );
+
+      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
+      const workingHours = this.formatWorkingHours(
+        data.invite.proposedWorkingHours
+      );
+
+      // Template variables - ensure all values are strings
+      const templateVariables: Record<string, string> = {
+        clinicName: data.clinic.name,
+        clinicAdminName: data.clinic.adminName || "Admin",
+        practitionerName,
+        practitionerPhoto: data.practitioner.profileImageUrl || "",
+        practitionerSpecialties:
+          data.practitioner.specialties?.join(", ") || "",
+        practitionerExperience:
+          data.practitioner.experienceYears?.toString() || "",
+        invitationDate: data.context.invitationDate,
+        acceptedDate: data.context.responseDate,
+        workingHours,
+        clinicDashboardUrl: data.urls.clinicDashboardUrl,
+        practitionerProfileUrl: data.urls.practitionerProfileUrl || "#",
+        currentYear: new Date().getFullYear().toString(),
+      };
+
+      // Render HTML email
+      const html = this.renderTemplate(
+        inviteAcceptedNotificationTemplate,
+        templateVariables
+      );
+
+      // Email configuration
+      const subject =
+        data.options?.customSubject ||
+        `Great News! Dr. ${practitionerName} Accepted Your Invitation`;
+      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
+      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
+
+      const mailgunData = {
+        to: data.clinic.adminEmail,
+        from,
+        subject,
+        html,
+      };
+
+      // Send the email
+      const result = await this.sendEmail(domain, mailgunData);
+
+      // Log success
+      await this.logEmailAttempt(
+        {
+          to: data.clinic.adminEmail,
+          subject,
+          templateName: "invite_accepted_notification",
+        },
+        true
+      );
+
+      return result;
+    } catch (error: any) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error sending acceptance notification:",
+        error
+      );
+
+      // Log failure
+      await this.logEmailAttempt(
+        {
+          to: data.clinic.adminEmail,
+          subject: data.options?.customSubject || "Invitation Accepted",
+          templateName: "invite_accepted_notification",
+        },
+        false,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Sends a notification email to clinic admin when practitioner rejects invitation
+   * @param data The notification email data
+   * @returns Promise resolved when email is sent
+   */
+  async sendRejectedNotificationEmail(
+    data: ClinicAdminNotificationData
+  ): Promise<any> {
+    try {
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Sending rejection notification to clinic admin",
+        data.clinic.adminEmail
+      );
+
+      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
+
+      // Template variables - ensure all values are strings
+      const templateVariables: Record<string, string> = {
+        clinicName: data.clinic.name,
+        clinicAdminName: data.clinic.adminName || "Admin",
+        practitionerName,
+        practitionerPhoto: data.practitioner.profileImageUrl || "",
+        practitionerSpecialties:
+          data.practitioner.specialties?.join(", ") || "",
+        invitationDate: data.context.invitationDate,
+        rejectedDate: data.context.responseDate,
+        rejectionReason: data.context.rejectionReason || "",
+        findPractitionersUrl: data.urls.findPractitionersUrl || "#",
+        clinicDashboardUrl: data.urls.clinicDashboardUrl,
+        currentYear: new Date().getFullYear().toString(),
+      };
+
+      // Render HTML email
+      const html = this.renderTemplate(
+        inviteRejectedNotificationTemplate,
+        templateVariables
+      );
+
+      // Email configuration
+      const subject =
+        data.options?.customSubject ||
+        `Invitation Update: Dr. ${practitionerName} Declined`;
+      const from = data.options?.fromAddress || this.DEFAULT_FROM_ADDRESS;
+      const domain = data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
+
+      const mailgunData = {
+        to: data.clinic.adminEmail,
+        from,
+        subject,
+        html,
+      };
+
+      // Send the email
+      const result = await this.sendEmail(domain, mailgunData);
+
+      // Log success
+      await this.logEmailAttempt(
+        {
+          to: data.clinic.adminEmail,
+          subject,
+          templateName: "invite_rejected_notification",
+        },
+        true
+      );
+
+      return result;
+    } catch (error: any) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error sending rejection notification:",
+        error
+      );
+
+      // Log failure
+      await this.logEmailAttempt(
+        {
+          to: data.clinic.adminEmail,
+          subject: data.options?.customSubject || "Invitation Declined",
+          templateName: "invite_rejected_notification",
+        },
+        false,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Handles the practitioner invite creation event
+   * Fetches necessary data and sends the invitation email to the practitioner
+   * @param invite The practitioner invite object
+   * @param mailgunConfig Mailgun configuration
+   * @returns Promise resolved when the email is sent
+   */
+  async handleInviteCreationEvent(
+    invite: PractitionerInvite,
+    mailgunConfig: {
+      fromAddress: string;
+      domain: string;
+      acceptUrl: string;
+      rejectUrl: string;
+    }
+  ): Promise<void> {
+    try {
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Handling invite creation event for invite:",
+        invite.id
+      );
+
+      // Validate invite data
+      if (!invite || !invite.id || !invite.practitionerId || !invite.clinicId) {
+        throw new Error(
+          `Invalid invite data: Missing required properties. Invite ID: ${invite?.id}`
+        );
+      }
+
+      // Only send email for pending invites
+      if (invite.status !== PractitionerInviteStatus.PENDING) {
+        Logger.info(
+          "[ExistingPractitionerInviteMailingService] Invite is not pending, skipping email",
+          { inviteId: invite.id, status: invite.status }
+        );
+        return;
+      }
+
+      // Fetch practitioner and clinic data
+      const [practitioner, clinic] = await Promise.all([
+        this.fetchPractitionerById(invite.practitionerId),
+        this.fetchClinicById(invite.clinicId),
+      ]);
+
+      if (!practitioner) {
+        throw new Error(`Practitioner ${invite.practitionerId} not found`);
+      }
+
+      if (!clinic) {
+        throw new Error(`Clinic ${invite.clinicId} not found`);
+      }
+
+      // Prepare email data
+      const emailData: ExistingPractitionerInviteEmailData = {
+        invite,
+        practitioner: {
+          firstName: practitioner.basicInfo.firstName || "",
+          lastName: practitioner.basicInfo.lastName || "",
+          email: practitioner.basicInfo.email || "",
+          specialties:
+            practitioner.certification?.specialties?.map(
+              (s: any) => s.name || s
+            ) || [],
+          profileImageUrl:
+            typeof practitioner.basicInfo.profileImageUrl === "string"
+              ? practitioner.basicInfo.profileImageUrl
+              : null,
+        },
+        clinic: {
+          name: clinic.name || "Medical Clinic",
+          address: this.formatClinicAddress(clinic.location),
+          contactEmail: clinic.contactInfo.email || "contact@clinic.com",
+          contactPhone: clinic.contactInfo.phoneNumber,
+        },
+        urls: {
+          acceptUrl: mailgunConfig.acceptUrl,
+          rejectUrl: mailgunConfig.rejectUrl,
+        },
+        options: {
+          fromAddress: mailgunConfig.fromAddress,
+          mailgunDomain: mailgunConfig.domain,
+        },
+      };
+
+      // Send the invitation email
+      await this.sendPractitionerInvitationEmail(emailData);
+
+      Logger.info(
+        "[ExistingPractitionerInviteMailingService] Invitation email sent successfully"
+      );
+    } catch (error: any) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error handling invite creation event:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+          inviteId: invite?.id,
+        }
+      );
+      throw error;
+    }
+  }
+
+  // --- Private Helper Methods ---
+
+  /**
+   * Formats working hours for display in emails
+   * @param workingHours The working hours object
+   * @returns Formatted string representation
+   */
+  private formatWorkingHours(workingHours: any): string {
+    if (!workingHours) return "To be determined";
+
+    // This is a simplified formatter - you may want to enhance based on your actual working hours structure
+    return Object.entries(workingHours)
+      .map(([day, hours]) => `${day}: ${hours}`)
+      .join(", ");
+  }
+
+  /**
+   * Formats clinic address for display
+   * @param location The clinic location object
+   * @returns Formatted address string
+   */
+  private formatClinicAddress(location: any): string {
+    if (!location) return "Address not specified";
+
+    const parts = [
+      location.street,
+      location.city,
+      location.state,
+      location.country,
+    ].filter(Boolean);
+
+    return parts.join(", ");
+  }
+
+  /**
+   * Fetches a practitioner by ID
+   * @param practitionerId The practitioner ID
+   * @returns The practitioner or null if not found
+   */
+  private async fetchPractitionerById(
+    practitionerId: string
+  ): Promise<Practitioner | null> {
+    try {
+      const doc = await this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId)
+        .get();
+      return doc.exists ? (doc.data() as Practitioner) : null;
+    } catch (error) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error fetching practitioner:",
+        error
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Fetches a clinic by ID
+   * @param clinicId The clinic ID
+   * @returns The clinic or null if not found
+   */
+  private async fetchClinicById(clinicId: string): Promise<Clinic | null> {
+    try {
+      const doc = await this.db
+        .collection(CLINICS_COLLECTION)
+        .doc(clinicId)
+        .get();
+      return doc.exists ? (doc.data() as Clinic) : null;
+    } catch (error) {
+      Logger.error(
+        "[ExistingPractitionerInviteMailingService] Error fetching clinic:",
+        error
+      );
+      return null;
+    }
+  }
+}