@blackcode_sa/metaestetics-api 1.7.33 → 1.7.35

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

@@ -0,0 +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 =
+    "MetaEstetics <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;
+    }
+  }
+}