@oneuptime/common 9.4.11 → 9.4.13

package/Server/Services/BillingService.ts

@@ -1,8 +1,16 @@
-import { BillingPrivateKey, IsBillingEnabled } from "../EnvironmentConfig";
+import {
+  BillingPrivateKey,
+  BillingWebhookSecret,
+  IsBillingEnabled,
+  DashboardClientUrl,
+} from "../EnvironmentConfig";
+import Project from "../../Models/DatabaseModels/Project";
 import ServerMeteredPlan from "../Types/Billing/MeteredPlan/ServerMeteredPlan";
 import Errors from "../Utils/Errors";
 import logger from "../Utils/Logger";
 import BaseService from "./BaseService";
+import MailService from "./MailService";
+import ProjectService from "./ProjectService";
 import SubscriptionPlan from "../../Types/Billing/SubscriptionPlan";
 import SubscriptionStatus, {
   SubscriptionStatusUtil,
@@ -10,6 +18,7 @@ import SubscriptionStatus, {
 import OneUptimeDate from "../../Types/Date";
 import Dictionary from "../../Types/Dictionary";
 import Email from "../../Types/Email";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import APIException from "../../Types/Exception/ApiException";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ProductType from "../../Types/MeteredPlan/ProductType";
@@ -86,8 +95,16 @@ export class BillingService extends BaseService {
     businessDetails: string,
     countryCode?: string | null,
     financeAccountingEmail?: string | null,
+    sendInvoicesByEmail?: boolean | null,
   ): Promise<void> {
+    logger.debug(
+      `[Invoice Email] updateCustomerBusinessDetails called - customerId: ${id}, sendInvoicesByEmail: ${sendInvoicesByEmail}`,
+    );
+
     if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, skipping updateCustomerBusinessDetails for customer ${id}`,
+      );
       throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
     }
     /*
@@ -133,6 +150,14 @@ export class BillingService extends BaseService {
       // Remove if cleared
       metadata["finance_accounting_email"] = "";
     }
+    if (sendInvoicesByEmail !== undefined && sendInvoicesByEmail !== null) {
+      metadata["send_invoices_by_email"] = sendInvoicesByEmail
+        ? "true"
+        : "false";
+      logger.debug(
+        `[Invoice Email] Setting send_invoices_by_email metadata to "${metadata["send_invoices_by_email"]}" for customer ${id}`,
+      );
+    }
 
     const updateParams: Stripe.CustomerUpdateParams = {
       metadata,
@@ -169,7 +194,11 @@ export class BillingService extends BaseService {
       } as any;
     }
 
+    logger.debug(
+      `[Invoice Email] Updating Stripe customer ${id} with metadata: ${JSON.stringify(metadata)}`,
+    );
     await this.stripe.customers.update(id, updateParams);
+    logger.debug(`[Invoice Email] Successfully updated Stripe customer ${id}`);
   }
 
   @CaptureSpan()
@@ -924,12 +953,169 @@ export class BillingService extends BaseService {
     return billingInvoices;
   }
 
+  @CaptureSpan()
+  public async sendInvoiceByEmail(
+    invoiceId: string,
+    recipientEmail?: Email,
+    projectId?: ObjectID,
+  ): Promise<void> {
+    logger.debug(
+      `[Invoice Email] sendInvoiceByEmail called for invoice: ${invoiceId}, recipientEmail: ${recipientEmail?.toString()}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, skipping send for invoice: ${invoiceId}`,
+      );
+      throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
+    }
+
+    try {
+      // Fetch invoice details from Stripe
+      logger.debug(
+        `[Invoice Email] Fetching invoice ${invoiceId} details from Stripe`,
+      );
+      const stripeInvoice: Stripe.Invoice =
+        await this.stripe.invoices.retrieve(invoiceId);
+
+      if (!stripeInvoice) {
+        logger.error(
+          `[Invoice Email] Invoice ${invoiceId} not found in Stripe`,
+        );
+        return;
+      }
+
+      // Determine recipient email
+      let toEmail: Email | undefined = recipientEmail;
+      if (!toEmail && stripeInvoice.customer_email) {
+        toEmail = new Email(stripeInvoice.customer_email);
+      }
+
+      if (!toEmail) {
+        logger.error(
+          `[Invoice Email] No recipient email found for invoice ${invoiceId}`,
+        );
+        return;
+      }
+
+      // Format invoice data for email
+      const invoiceNumber: string = stripeInvoice.number || invoiceId;
+      const invoiceDate: string = stripeInvoice.created
+        ? OneUptimeDate.getDateAsFormattedString(
+            new Date(stripeInvoice.created * 1000),
+          )
+        : OneUptimeDate.getDateAsFormattedString(
+            OneUptimeDate.getCurrentDate(),
+          );
+      const amount: string = `${(stripeInvoice.amount_due / 100).toFixed(2)} ${stripeInvoice.currency?.toUpperCase() || "USD"}`;
+      const invoicePdfUrl: string | undefined =
+        stripeInvoice.invoice_pdf || undefined;
+      const description: string | undefined =
+        stripeInvoice.description || undefined;
+
+      // Build dashboard link
+      let dashboardLink: string | undefined = undefined;
+      if (projectId && DashboardClientUrl) {
+        dashboardLink = `${DashboardClientUrl.toString()}/dashboard/${projectId.toString()}/settings/billing`;
+      }
+
+      logger.debug(
+        `[Invoice Email] Sending invoice email to ${toEmail.toString()} - Invoice #${invoiceNumber}, Amount: ${amount}`,
+      );
+
+      // Send email via OneUptime MailService
+      await MailService.sendMail(
+        {
+          toEmail: toEmail,
+          templateType: EmailTemplateType.Invoice,
+          vars: {
+            invoiceNumber: invoiceNumber,
+            invoiceDate: invoiceDate,
+            amount: amount,
+            description: description || "",
+            invoicePdfUrl: invoicePdfUrl || "",
+            dashboardLink: dashboardLink || "",
+          },
+          subject: `Invoice #${invoiceNumber} from OneUptime`,
+        },
+        {
+          projectId: projectId,
+        },
+      );
+
+      logger.debug(
+        `[Invoice Email] Successfully sent invoice ${invoiceId} email to ${toEmail.toString()}`,
+      );
+    } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to send invoice ${invoiceId} by email: ${err}`,
+      );
+      // Don't throw - sending email is not critical
+    }
+  }
+
+  @CaptureSpan()
+  public async shouldSendInvoicesByEmail(customerId: string): Promise<boolean> {
+    logger.debug(
+      `[Invoice Email] shouldSendInvoicesByEmail called for customer: ${customerId}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, returning false for customer: ${customerId}`,
+      );
+      return false;
+    }
+
+    try {
+      logger.debug(
+        `[Invoice Email] Retrieving customer ${customerId} from Stripe to check preference`,
+      );
+      const customer: Stripe.Response<
+        Stripe.Customer | Stripe.DeletedCustomer
+      > = await this.stripe.customers.retrieve(customerId);
+
+      if (!customer || customer.deleted) {
+        logger.debug(
+          `[Invoice Email] Customer ${customerId} not found or deleted, returning false`,
+        );
+        return false;
+      }
+
+      const metadata: Stripe.Metadata = (customer as Stripe.Customer).metadata;
+      const sendInvoicesByEmail: boolean =
+        metadata?.["send_invoices_by_email"] === "true";
+      logger.debug(
+        `[Invoice Email] Customer ${customerId} metadata.send_invoices_by_email = "${metadata?.["send_invoices_by_email"]}", result: ${sendInvoicesByEmail}`,
+      );
+      return sendInvoicesByEmail;
+    } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to check invoice email preference for customer ${customerId}: ${err}`,
+      );
+      return false;
+    }
+  }
+
   @CaptureSpan()
   public async generateInvoiceAndChargeCustomer(
     customerId: string,
     itemText: string,
     amountInUsd: number,
+    options?: {
+      sendInvoiceByEmail?: boolean | undefined;
+      recipientEmail?: Email | undefined;
+      projectId?: ObjectID | undefined;
+    },
   ): Promise<void> {
+    const sendInvoiceByEmail: boolean = options?.sendInvoiceByEmail || false;
+    const recipientEmail: Email | undefined = options?.recipientEmail;
+    const projectId: ObjectID | undefined = options?.projectId;
+
+    logger.debug(
+      `[Invoice Email] generateInvoiceAndChargeCustomer called - customer: ${customerId}, amount: $${amountInUsd}, sendInvoiceByEmail: ${sendInvoiceByEmail}, recipientEmail: ${recipientEmail?.toString()}, projectId: ${projectId?.toString()}`,
+    );
+
     const invoice: Stripe.Invoice = await this.stripe.invoices.create({
       customer: customerId,
       auto_advance: true, // do not automatically charge.
@@ -937,9 +1123,16 @@ export class BillingService extends BaseService {
     });
 
     if (!invoice || !invoice.id) {
+      logger.error(
+        `[Invoice Email] Failed to create invoice for customer ${customerId}`,
+      );
       throw new APIException(Errors.BillingService.INVOICE_NOT_GENERATED);
     }
 
+    logger.debug(
+      `[Invoice Email] Created invoice ${invoice.id} for customer ${customerId}`,
+    );
+
     await this.stripe.invoiceItems.create({
       invoice: invoice.id,
       amount: amountInUsd * 100,
@@ -947,11 +1140,32 @@ export class BillingService extends BaseService {
       customer: customerId,
     });
 
+    logger.debug(
+      `[Invoice Email] Added invoice item to invoice ${invoice.id}: ${itemText}, $${amountInUsd}`,
+    );
+
     await this.stripe.invoices.finalizeInvoice(invoice.id!);
+    logger.debug(`[Invoice Email] Finalized invoice ${invoice.id}`);
 
     try {
       await this.payInvoice(customerId, invoice.id!);
+      logger.debug(`[Invoice Email] Paid invoice ${invoice.id}`);
+
+      // Send invoice by email if requested
+      if (sendInvoiceByEmail) {
+        logger.debug(
+          `[Invoice Email] sendInvoiceByEmail is true, sending invoice ${invoice.id} by email`,
+        );
+        await this.sendInvoiceByEmail(invoice.id!, recipientEmail, projectId);
+      } else {
+        logger.debug(
+          `[Invoice Email] sendInvoiceByEmail is false, skipping email for invoice ${invoice.id}`,
+        );
+      }
     } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to pay invoice ${invoice.id}, voiding: ${err}`,
+      );
       // mark invoice as failed and do not collect payment.
       await this.voidInvoice(invoice.id!);
       throw err;
@@ -1035,6 +1249,140 @@ export class BillingService extends BaseService {
       "Plan with productType " + productType + " not found",
     );
   }
+
+  @CaptureSpan()
+  public verifyWebhookSignature(
+    payload: string | Buffer,
+    signature: string,
+  ): Stripe.Event {
+    logger.debug(`[Invoice Email] verifyWebhookSignature called`);
+
+    if (!BillingWebhookSecret) {
+      logger.error(`[Invoice Email] Billing webhook secret is not configured`);
+      throw new BadDataException("Billing webhook secret is not configured");
+    }
+
+    logger.debug(
+      `[Invoice Email] Verifying webhook signature with secret (length: ${BillingWebhookSecret.length})`,
+    );
+    const event: Stripe.Event = this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      BillingWebhookSecret,
+    );
+    logger.debug(
+      `[Invoice Email] Webhook signature verified, event type: ${event.type}, event id: ${event.id}`,
+    );
+    return event;
+  }
+
+  @CaptureSpan()
+  public async handleWebhookEvent(event: Stripe.Event): Promise<void> {
+    logger.debug(
+      `[Invoice Email] handleWebhookEvent called - event type: ${event.type}, event id: ${event.id}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, ignoring webhook event ${event.id}`,
+      );
+      return;
+    }
+
+    // Handle invoice.finalized event to send invoice by email if customer has opted in
+    if (event.type === "invoice.finalized") {
+      logger.debug(
+        `[Invoice Email] Processing invoice.finalized event ${event.id}`,
+      );
+      const invoice: Stripe.Invoice = event.data.object as Stripe.Invoice;
+
+      logger.debug(
+        `[Invoice Email] Invoice details - id: ${invoice.id}, number: ${invoice.number}, customer: ${invoice.customer}, status: ${invoice.status}`,
+      );
+
+      if (!invoice.customer) {
+        logger.debug(
+          `[Invoice Email] No customer on invoice ${invoice.id}, skipping`,
+        );
+        return;
+      }
+
+      const customerId: string =
+        typeof invoice.customer === "string"
+          ? invoice.customer
+          : invoice.customer.id;
+
+      logger.debug(
+        `[Invoice Email] Extracted customer ID: ${customerId} from invoice ${invoice.id}`,
+      );
+
+      try {
+        logger.debug(
+          `[Invoice Email] Checking if customer ${customerId} has invoice emails enabled`,
+        );
+        const shouldSend: boolean =
+          await this.shouldSendInvoicesByEmail(customerId);
+
+        if (shouldSend && invoice.id) {
+          logger.debug(
+            `[Invoice Email] Customer ${customerId} has invoice emails enabled, looking up project`,
+          );
+
+          // Find the project by Stripe customer ID
+          const project: Project | null = await ProjectService.findOneBy({
+            query: {
+              paymentProviderCustomerId: customerId,
+            },
+            select: {
+              _id: true,
+              financeAccountingEmail: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          let recipientEmail: Email | undefined = undefined;
+          let projectId: ObjectID | undefined = undefined;
+
+          if (project) {
+            projectId = project.id || undefined;
+            if (project.financeAccountingEmail) {
+              recipientEmail = new Email(project.financeAccountingEmail);
+            }
+            logger.debug(
+              `[Invoice Email] Found project ${projectId?.toString()}, financeAccountingEmail: ${recipientEmail?.toString()}`,
+            );
+          } else {
+            logger.debug(
+              `[Invoice Email] No project found for customer ${customerId}, will use Stripe customer email`,
+            );
+          }
+
+          logger.debug(
+            `[Invoice Email] Sending invoice ${invoice.id} by email`,
+          );
+          await this.sendInvoiceByEmail(invoice.id, recipientEmail, projectId);
+          logger.debug(
+            `[Invoice Email] Successfully processed invoice.finalized - sent invoice ${invoice.id} by email`,
+          );
+        } else {
+          logger.debug(
+            `[Invoice Email] Customer ${customerId} has invoice emails disabled (shouldSend: ${shouldSend}), skipping email for invoice ${invoice.id}`,
+          );
+        }
+      } catch (err) {
+        logger.error(
+          `[Invoice Email] Failed to send invoice by email for invoice ${invoice.id}: ${err}`,
+        );
+        // Don't throw - webhook should still return success
+      }
+    } else {
+      logger.debug(
+        `[Invoice Email] Ignoring event type ${event.type}, not invoice.finalized`,
+      );
+    }
+  }
 }
 
 export default new BillingService();

package/Server/Services/CallService.ts

@@ -29,6 +29,7 @@ export class CallService extends BaseService {
       incidentId?: ObjectID | undefined;
       alertId?: ObjectID | undefined;
       alertEpisodeId?: ObjectID | undefined;
+      incidentEpisodeId?: ObjectID | undefined;
       scheduledMaintenanceId?: ObjectID | undefined;
       statusPageId?: ObjectID | undefined;
       statusPageAnnouncementId?: ObjectID | undefined;

package/Server/Services/IncidentEpisodeFeedService.ts

@@ -0,0 +1,94 @@
+import { Blue500 } from "../../Types/BrandColors";
+import Color from "../../Types/Color";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  IncidentEpisodeFeedEventType,
+} from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createIncidentEpisodeFeedItem(data: {
+    incidentEpisodeId: ObjectID;
+    feedInfoInMarkdown: string;
+    incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<void> {
+    try {
+      if (!data.incidentEpisodeId) {
+        throw new BadDataException("Incident Episode ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.incidentEpisodeFeedEventType) {
+        throw new BadDataException("Incident episode log event is required");
+      }
+
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
+
+      const incidentEpisodeFeed: Model = new Model();
+
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
+
+      if (data.userId) {
+        incidentEpisodeFeed.userId = data.userId;
+      }
+
+      incidentEpisodeFeed.displayColor = data.displayColor;
+
+      incidentEpisodeFeed.incidentEpisodeId = data.incidentEpisodeId;
+      incidentEpisodeFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      incidentEpisodeFeed.incidentEpisodeFeedEventType =
+        data.incidentEpisodeFeedEventType;
+      incidentEpisodeFeed.projectId = data.projectId;
+
+      if (!data.postedAt) {
+        incidentEpisodeFeed.postedAt = OneUptimeDate.getCurrentDate();
+      } else {
+        incidentEpisodeFeed.postedAt = data.postedAt;
+      }
+
+      if (data.moreInformationInMarkdown) {
+        incidentEpisodeFeed.moreInformationInMarkdown =
+          data.moreInformationInMarkdown;
+      }
+
+      await this.create({
+        data: incidentEpisodeFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error("IncidentEpisodeFeedService.createIncidentEpisodeFeedItem");
+      logger.error(error);
+      // we dont want to throw the error here, as this is a non-critical operation
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentEpisodeInternalNoteService.ts

@@ -0,0 +1,71 @@
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentEpisodeInternalNote";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import File from "../../Models/DatabaseModels/File";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async addNote(data: {
+    userId: ObjectID;
+    incidentEpisodeId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+    attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.incidentEpisodeId = data.incidentEpisodeId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
+    if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
+      internalNote.attachments = data.attachmentFileIds.map(
+        (fileId: ObjectID) => {
+          const file: File = new File();
+          file.id = fileId;
+          return file;
+        },
+      );
+    }
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    incidentEpisodeId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        incidentEpisodeId: data.incidentEpisodeId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+}
+
+export default new Service();