@blackcode_sa/metaestetics-api 1.14.29 → 1.14.34

package/src/admin/mailing/patientInvite/patientInvite.mailing.ts

@@ -0,0 +1,415 @@
+import * as admin from "firebase-admin";
+import { BaseMailingService } from "../base.mailing.service";
+import { patientInvitationTemplate } from "./templates/invitation.template";
+import { Logger } from "../../logger";
+import {
+  PatientProfile,
+  PatientSensitiveInfo,
+  PATIENTS_COLLECTION,
+  PATIENT_SENSITIVE_INFO_COLLECTION,
+} from "../../../types/patient";
+import {
+  PatientToken,
+  PatientTokenStatus,
+  INVITE_TOKENS_COLLECTION,
+} from "../../../types/patient/token.types";
+import { Clinic, CLINICS_COLLECTION } from "../../../types/clinic";
+
+/**
+ * Minimal interface for the mailgun.js client if not importing full types
+ */
+interface NewMailgunMessagesAPI {
+  create(domain: string, data: any): Promise<any>;
+}
+interface NewMailgunClient {
+  messages: NewMailgunMessagesAPI;
+}
+
+/**
+ * Interface for the data required to send a patient invitation email
+ */
+export interface PatientInviteEmailData {
+  /** The token object from the patient service */
+  token: {
+    id: string;
+    token: string;
+    patientId: string;
+    email: string;
+    clinicId: string;
+    expiresAt: admin.firestore.Timestamp;
+  };
+
+  /** Patient basic info */
+  patient: {
+    firstName: string;
+    lastName: string;
+  };
+
+  /** Clinic info */
+  clinic: {
+    name: string;
+    contactEmail: string;
+    contactName?: string;
+  };
+
+  /** Config options */
+  options?: {
+    registrationUrl?: string;
+    customSubject?: string;
+    fromAddress?: string;
+    mailgunDomain?: string;
+  };
+}
+
+/**
+ * Service for sending patient invitation emails
+ * Follows the same pattern as PractitionerInviteMailingService
+ */
+export class PatientInviteMailingService extends BaseMailingService {
+  private readonly DEFAULT_REGISTRATION_URL =
+    "https://metaesthetics.net/patient/register";
+  private readonly DEFAULT_SUBJECT =
+    "Claim Your Patient Profile - MetaEsthetics";
+  private readonly DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
+
+  /**
+   * Constructor for PatientInviteMailingService
+   * @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 a patient invitation email
+   * @param data - The patient invitation data
+   * @returns Promise resolved when email is sent
+   */
+  async sendInvitationEmail(data: PatientInviteEmailData): Promise<any> {
+    try {
+      Logger.info(
+        "[PatientInviteMailingService] Sending invitation email to",
+        data.token.email
+      );
+
+      // Format expiration date
+      const expirationDate = data.token.expiresAt
+        .toDate()
+        .toLocaleDateString("en-US", {
+          weekday: "long",
+          year: "numeric",
+          month: "long",
+          day: "numeric",
+        });
+
+      // Registration URL
+      const registrationUrl =
+        data.options?.registrationUrl || this.DEFAULT_REGISTRATION_URL;
+
+      // Contact information
+      const contactName = data.clinic.contactName || "Clinic Administrator";
+      const contactEmail = data.clinic.contactEmail;
+
+      // Subject line
+      const subject = data.options?.customSubject || this.DEFAULT_SUBJECT;
+
+      // Determine 'from' address
+      const fromAddress =
+        data.options?.fromAddress ||
+        `MetaEsthetics <no-reply@${
+          data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN
+        }>`;
+
+      // Current year for copyright
+      const currentYear = new Date().getFullYear().toString();
+
+      // Patient full name
+      const patientName = `${data.patient.firstName} ${data.patient.lastName}`;
+
+      // Prepare template variables
+      const templateVariables = {
+        clinicName: data.clinic.name,
+        patientName,
+        inviteToken: data.token.token,
+        expirationDate,
+        registrationUrl,
+        contactName,
+        contactEmail,
+        currentYear,
+      };
+
+      // Debug log for template variables (excluding token for security)
+      Logger.info("[PatientInviteMailingService] Template variables:", {
+        clinicName: templateVariables.clinicName,
+        patientName: templateVariables.patientName,
+        expirationDate: templateVariables.expirationDate,
+        registrationUrl: templateVariables.registrationUrl,
+        contactName: templateVariables.contactName,
+        contactEmail: templateVariables.contactEmail,
+        hasInviteToken: !!templateVariables.inviteToken,
+      });
+
+      // Render HTML email
+      const html = this.renderTemplate(
+        patientInvitationTemplate,
+        templateVariables
+      );
+
+      // Data for the sendEmail method
+      const mailgunSendData = {
+        to: data.token.email,
+        from: fromAddress,
+        subject,
+        html,
+      };
+
+      // Determine the domain to use for sending
+      const domainToSendFrom =
+        data.options?.mailgunDomain || this.DEFAULT_MAILGUN_DOMAIN;
+
+      Logger.info("[PatientInviteMailingService] Sending email with data:", {
+        domain: domainToSendFrom,
+        to: mailgunSendData.to,
+        from: mailgunSendData.from,
+        subject: mailgunSendData.subject,
+        hasHtml: !!mailgunSendData.html,
+      });
+
+      // Call the sendEmail method from BaseMailingService
+      const result = await this.sendEmail(domainToSendFrom, mailgunSendData);
+
+      // Log success
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject,
+          templateName: "patient_invitation",
+        },
+        true
+      );
+
+      return result;
+    } catch (error: any) {
+      Logger.error(
+        "[PatientInviteMailingService] Error sending invitation email:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+        }
+      );
+
+      // Log failure
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject: data.options?.customSubject || this.DEFAULT_SUBJECT,
+          templateName: "patient_invitation",
+        },
+        false,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Handles the patient token creation event from Cloud Functions.
+   * Fetches necessary data and sends the invitation email.
+   * @param tokenData - The fully typed token object including its id
+   * @param mailgunConfig - Mailgun configuration (from, domain, optional registrationUrl)
+   * @returns Promise resolved when the email is sent
+   */
+  async handleTokenCreationEvent(
+    tokenData: PatientToken,
+    mailgunConfig: {
+      fromAddress: string;
+      domain: string;
+      registrationUrl?: string;
+    }
+  ): Promise<void> {
+    try {
+      Logger.info(
+        "[PatientInviteMailingService] Handling token creation event for token:",
+        tokenData.id
+      );
+
+      // Validate token data
+      if (!tokenData || !tokenData.id || !tokenData.token || !tokenData.email) {
+        throw new Error(
+          `Invalid token data: Missing required properties. Token ID: ${tokenData?.id}`
+        );
+      }
+
+      if (!tokenData.patientId) {
+        throw new Error(
+          `Token ${tokenData.id} is missing patientId reference`
+        );
+      }
+
+      if (!tokenData.clinicId) {
+        throw new Error(`Token ${tokenData.id} is missing clinicId reference`);
+      }
+
+      if (!tokenData.expiresAt) {
+        throw new Error(`Token ${tokenData.id} is missing expiration date`);
+      }
+
+      // Validate token status (handle both enum and string values)
+      if (
+        tokenData.status !== PatientTokenStatus.ACTIVE &&
+        String(tokenData.status).toLowerCase() !== "active"
+      ) {
+        Logger.warn(
+          "[PatientInviteMailingService] Token is not active, skipping email.",
+          { tokenId: tokenData.id, status: tokenData.status }
+        );
+        return;
+      }
+
+      Logger.info(
+        `[PatientInviteMailingService] Token status validation:`,
+        {
+          tokenId: tokenData.id,
+          status: tokenData.status,
+          statusType: typeof tokenData.status,
+        }
+      );
+
+      // Get patient profile data
+      Logger.info(
+        `[PatientInviteMailingService] Fetching patient data: ${tokenData.patientId}`
+      );
+      const patientRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(tokenData.patientId);
+      const patientDoc = await patientRef.get();
+
+      if (!patientDoc.exists) {
+        throw new Error(`Patient ${tokenData.patientId} not found`);
+      }
+
+      const patientData = patientDoc.data() as PatientProfile;
+      if (!patientData) {
+        throw new Error(
+          `Patient ${tokenData.patientId} has invalid data structure`
+        );
+      }
+
+      // Get patient sensitive info for name
+      const sensitiveInfoRef = patientRef
+        .collection(PATIENT_SENSITIVE_INFO_COLLECTION)
+        .doc(tokenData.patientId);
+      const sensitiveInfoDoc = await sensitiveInfoRef.get();
+
+      let firstName = "Patient";
+      let lastName = "";
+
+      if (sensitiveInfoDoc.exists) {
+        const sensitiveInfo = sensitiveInfoDoc.data() as PatientSensitiveInfo;
+        firstName = sensitiveInfo?.firstName || "Patient";
+        lastName = sensitiveInfo?.lastName || "";
+      } else {
+        // Fall back to displayName if no sensitive info
+        Logger.warn(
+          `[PatientInviteMailingService] No sensitive info found for patient ${tokenData.patientId}, using displayName`
+        );
+        const displayNameParts = (patientData.displayName || "Patient").split(" ");
+        firstName = displayNameParts[0] || "Patient";
+        lastName = displayNameParts.slice(1).join(" ") || "";
+      }
+
+      Logger.info(
+        `[PatientInviteMailingService] Patient found: ${firstName} ${lastName}`
+      );
+
+      // Get clinic data
+      Logger.info(
+        `[PatientInviteMailingService] Fetching clinic data: ${tokenData.clinicId}`
+      );
+      const clinicRef = this.db
+        .collection(CLINICS_COLLECTION)
+        .doc(tokenData.clinicId);
+      const clinicDoc = await clinicRef.get();
+
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${tokenData.clinicId} not found`);
+      }
+
+      const clinicData = clinicDoc.data() as Clinic;
+      if (!clinicData || !clinicData.contactInfo) {
+        throw new Error(
+          `Clinic ${tokenData.clinicId} has invalid data structure`
+        );
+      }
+
+      Logger.info(
+        `[PatientInviteMailingService] Clinic found: ${clinicData.name}`
+      );
+
+      // Validate fromAddress
+      if (!mailgunConfig.fromAddress) {
+        Logger.warn(
+          "[PatientInviteMailingService] No fromAddress provided, using default"
+        );
+        mailgunConfig.fromAddress = `MetaEsthetics <no-reply@${this.DEFAULT_MAILGUN_DOMAIN}>`;
+      }
+
+      // Prepare email data
+      const emailData: PatientInviteEmailData = {
+        token: {
+          id: tokenData.id,
+          token: tokenData.token,
+          patientId: tokenData.patientId,
+          email: tokenData.email,
+          clinicId: tokenData.clinicId,
+          expiresAt: tokenData.expiresAt as unknown as admin.firestore.Timestamp,
+        },
+        patient: {
+          firstName,
+          lastName,
+        },
+        clinic: {
+          name: clinicData.name || "Medical Clinic",
+          contactEmail: clinicData.contactInfo.email || "contact@clinic.com",
+          contactName: "Clinic Admin",
+        },
+        options: {
+          fromAddress: mailgunConfig.fromAddress,
+          mailgunDomain: mailgunConfig.domain,
+          registrationUrl: mailgunConfig.registrationUrl,
+        },
+      };
+
+      Logger.info(
+        "[PatientInviteMailingService] Email data prepared, sending invitation"
+      );
+
+      // Send the invitation email
+      await this.sendInvitationEmail(emailData);
+
+      Logger.info(
+        "[PatientInviteMailingService] Invitation email sent successfully"
+      );
+    } catch (error: any) {
+      Logger.error(
+        "[PatientInviteMailingService] Error handling token creation event:",
+        {
+          errorMessage: error.message,
+          errorDetails: error.details,
+          errorStatus: error.status,
+          stack: error.stack,
+          tokenId: tokenData?.id,
+        }
+      );
+      throw error;
+    }
+  }
+}
+

package/src/admin/mailing/patientInvite/templates/invitation.template.ts

@@ -0,0 +1,105 @@
+/**
+ * HTML email template for patient invitation to claim their profile
+ */
+export const patientInvitationTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Claim Your Patient Profile at {{clinicName}}</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      margin: 0;
+      padding: 0;
+    }
+    .container {
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    .header {
+      background-color: #4A90E2;
+      padding: 20px;
+      text-align: center;
+      color: white;
+    }
+    .content {
+      padding: 20px;
+      background-color: #f9f9f9;
+    }
+    .footer {
+      padding: 20px;
+      text-align: center;
+      font-size: 12px;
+      color: #888;
+    }
+    .token {
+      font-size: 24px;
+      font-weight: bold;
+      color: #4A90E2;
+      padding: 10px;
+      background-color: #e9f0f9;
+      border-radius: 4px;
+      display: inline-block;
+      letter-spacing: 2px;
+      margin: 10px 0;
+    }
+    .info-box {
+      background-color: #fff;
+      border-left: 4px solid #4A90E2;
+      padding: 15px;
+      margin: 20px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>Welcome to MetaEsthetics</h1>
+    </div>
+    <div class="content">
+      <p>Hello {{patientName}},</p>
+      
+      <p>A patient profile has been created for you at <strong>{{clinicName}}</strong>. You can now claim this profile to access your personal health dashboard and appointment history.</p>
+      
+      <div class="info-box">
+        <p><strong>What you'll get access to:</strong></p>
+        <ul>
+          <li>Your complete treatment history</li>
+          <li>Upcoming appointment details</li>
+          <li>Pre and post-treatment instructions</li>
+          <li>Direct messaging with your clinic</li>
+        </ul>
+      </div>
+      
+      <p>To claim your profile, use this registration token:</p>
+      
+      <div style="text-align: center;">
+        <span class="token">{{inviteToken}}</span>
+      </div>
+      
+      <p><strong>Important:</strong> This token will expire on <strong>{{expirationDate}}</strong>.</p>
+      
+      <p>To create your account:</p>
+      <ol>
+        <li>Download the <strong>MetaEsthetics</strong> app from the App Store (iOS) or Google Play Store (Android)</li>
+        <li>Open the app and create an account using your email address</li>
+        <li>When prompted, enter the token shown above</li>
+        <li>Your profile will be automatically linked to your new account</li>
+      </ol>
+      
+      <p>If you have any questions or didn't expect this email, please contact {{contactName}} at {{contactEmail}}.</p>
+    </div>
+    <div class="footer">
+      <p>This is an automated message from {{clinicName}}. Please do not reply to this email.</p>
+      <p>&copy; {{currentYear}} MetaEsthetics. All rights reserved.</p>
+    </div>
+  </div>
+</body>
+</html>
+`;
+

package/src/services/analytics/analytics.service.ts

@@ -644,8 +644,11 @@ export class AnalyticsService extends BaseService {
       }
     }
 
-    // Fall back to calculation
-    const appointments = await this.fetchAppointments(undefined, dateRange);
+    // Fall back to calculation - filter by clinic if specified
+    const filters: AnalyticsFilters | undefined = options?.clinicBranchId
+      ? { clinicBranchId: options.clinicBranchId }
+      : undefined;
+    const appointments = await this.fetchAppointments(filters, dateRange);
     const canceled = getCanceledAppointments(appointments);
 
     if (groupBy === 'clinic') {
@@ -941,8 +944,11 @@ export class AnalyticsService extends BaseService {
       }
     }
 
-    // Fall back to calculation
-    const appointments = await this.fetchAppointments(undefined, dateRange);
+    // Fall back to calculation - filter by clinic if specified
+    const filters: AnalyticsFilters | undefined = options?.clinicBranchId
+      ? { clinicBranchId: options.clinicBranchId }
+      : undefined;
+    const appointments = await this.fetchAppointments(filters, dateRange);
     const noShow = getNoShowAppointments(appointments);
 
     if (groupBy === 'clinic') {