@oneuptime/common 7.0.3517 → 7.0.3538

package/Server/Services/BillingInvoiceService.ts

@@ -10,6 +10,11 @@ import Model, {
   InvoiceStatus,
 } from "Common/Models/DatabaseModels/BillingInvoice";
 import Project from "Common/Models/DatabaseModels/Project";
+import SubscriptionStatus from "../../Types/Billing/SubscriptionStatus";
+import ObjectID from "../../Types/ObjectID";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import logger from "../Utils/Logger";
+import OneUptimeDate from "../../Types/Date";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -17,6 +22,166 @@ export class Service extends DatabaseService<Model> {
     this.setDoNotAllowDelete(true);
   }
 
+  public async refreshSubscriptionStatus(data: {
+    projectId: ObjectID;
+  }): Promise<void> {
+    let mutex: SemaphoreMutex | null = null;
+
+    try {
+      mutex = await Semaphore.lock({
+        key: data.projectId.toString(),
+        namespace: "BillingInoviceService.refreshSubscriptionStatus",
+        lockTimeout: 15000,
+        acquireTimeout: 20000,
+      });
+      logger.debug(
+        "Mutex acquired - " +
+          data.projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+    } catch (err) {
+      logger.debug(
+        "Mutex acquire failed - " +
+          data.projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+      logger.error(err);
+    }
+
+    let project: Project | null = await ProjectService.findOneById({
+      id: data.projectId,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+        paymentProviderCustomerId: true,
+        paymentProviderSubscriptionId: true,
+        paymentProviderMeteredSubscriptionId: true,
+      },
+    });
+
+    // refresh the subscription status. This is a hack to ensure that the subscription status is always up to date.
+    // This is because the subscription status can change at any time and we need to ensure that the subscription status is always up to date.
+
+    if (!project) {
+      throw new BadDataException("Project not found");
+    }
+
+    if (!project.paymentProviderCustomerId) {
+      throw new BadDataException("Payment provider customer id not found.");
+    }
+
+    let subscriptionState: SubscriptionStatus =
+      await BillingService.getSubscriptionStatus(
+        project.paymentProviderSubscriptionId as string,
+      );
+
+    let meteredSubscriptionState: SubscriptionStatus =
+      await BillingService.getSubscriptionStatus(
+        project.paymentProviderMeteredSubscriptionId as string,
+      );
+
+    // update the project.
+
+    await ProjectService.updateOneById({
+      id: project.id!,
+      data: {
+        paymentProviderSubscriptionStatus: subscriptionState,
+        paymentProviderMeteredSubscriptionStatus: meteredSubscriptionState,
+      },
+      props: {
+        isRoot: true,
+        ignoreHooks: true,
+      },
+    });
+
+    if (
+      meteredSubscriptionState === SubscriptionStatus.Canceled ||
+      subscriptionState === SubscriptionStatus.Canceled
+    ) {
+      // check if all invoices are paid. If yes, then reactivate the subscription.
+
+      const invoices: Array<Invoice> = await BillingService.getInvoices(
+        project.paymentProviderCustomerId,
+      );
+
+      let allInvoicesPaid: boolean = true;
+
+      for (const invoice of invoices) {
+        if (
+          invoice.status === InvoiceStatus.Open ||
+          invoice.status === InvoiceStatus.Uncollectible
+        ) {
+          allInvoicesPaid = false;
+          break;
+        }
+      }
+
+      if (allInvoicesPaid) {
+        await ProjectService.reactiveSubscription(project.id!);
+        project = await ProjectService.findOneById({
+          id: data.projectId,
+          props: {
+            isRoot: true,
+          },
+          select: {
+            _id: true,
+            paymentProviderCustomerId: true,
+            paymentProviderSubscriptionId: true,
+            paymentProviderMeteredSubscriptionId: true,
+          },
+        });
+
+        if (!project) {
+          throw new BadDataException("Project not found");
+        }
+
+        subscriptionState = await BillingService.getSubscriptionStatus(
+          project.paymentProviderSubscriptionId as string,
+        );
+
+        meteredSubscriptionState = await BillingService.getSubscriptionStatus(
+          project.paymentProviderMeteredSubscriptionId as string,
+        );
+
+        await ProjectService.updateOneById({
+          id: project.id!,
+          data: {
+            paymentProviderSubscriptionStatus: subscriptionState,
+            paymentProviderMeteredSubscriptionStatus: meteredSubscriptionState,
+          },
+          props: {
+            isRoot: true,
+            ignoreHooks: true,
+          },
+        });
+      }
+    }
+
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+        logger.debug(
+          "Mutex released - " +
+            data.projectId.toString() +
+            " at " +
+            OneUptimeDate.getCurrentDateAsFormattedString(),
+        );
+      } catch (err) {
+        logger.debug(
+          "Mutex release failed - " +
+            data.projectId.toString() +
+            " at " +
+            OneUptimeDate.getCurrentDateAsFormattedString(),
+        );
+        logger.error(err);
+      }
+    }
+  }
+
   protected override async onBeforeFind(
     findBy: FindBy<Model>,
   ): Promise<OnFind<Model>> {
@@ -37,6 +202,11 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
+    // refresh the subscription status. This is a hack to ensure that the subscription status is always up to date.
+    // This is because the subscription status can change at any time and we need to ensure that the subscription status is always up to date.
+
+    await this.refreshSubscriptionStatus({ projectId: findBy.props.tenantId! });
+
     if (!project) {
       throw new BadDataException("Project not found");
     }

package/Server/Services/IncidentFeedService.ts

@@ -28,61 +28,66 @@ export class Service extends DatabaseService<IncidentFeed> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
-  }): Promise<IncidentFeed> {
-    logger.debug("IncidentFeedService.createIncidentFeed");
-    logger.debug(data);
-
-    const incidentFeed: IncidentFeed = new IncidentFeed();
-
-    if (!data.incidentId) {
-      throw new BadDataException("Incident ID is required");
-    }
-
-    if (!data.feedInfoInMarkdown) {
-      throw new BadDataException("Log in markdown is required");
-    }
-
-    if (!data.incidentFeedEventType) {
-      throw new BadDataException("Incident log event is required");
-    }
-
-    if (!data.projectId) {
-      throw new BadDataException("Project ID is required");
-    }
-
-    if (!data.displayColor) {
-      data.displayColor = Blue500;
+  }): Promise<void> {
+    try {
+      logger.debug("IncidentFeedService.createIncidentFeed");
+      logger.debug(data);
+
+      const incidentFeed: IncidentFeed = new IncidentFeed();
+
+      if (!data.incidentId) {
+        throw new BadDataException("Incident ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.incidentFeedEventType) {
+        throw new BadDataException("Incident log event is required");
+      }
+
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
+
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
+
+      incidentFeed.displayColor = data.displayColor;
+      incidentFeed.incidentId = data.incidentId;
+      incidentFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      incidentFeed.incidentFeedEventType = data.incidentFeedEventType;
+      incidentFeed.projectId = data.projectId;
+
+      if (!data.postedAt) {
+        incidentFeed.postedAt = OneUptimeDate.getCurrentDate();
+      }
+
+      if (data.userId) {
+        incidentFeed.userId = data.userId;
+      }
+
+      if (data.moreInformationInMarkdown) {
+        incidentFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+      }
+
+      const createdIncidentFeed: IncidentFeed = await this.create({
+        data: incidentFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      logger.debug("Incident Feed created");
+      logger.debug(createdIncidentFeed);
+    } catch (e) {
+      logger.error("Error in creating incident feed");
+      logger.error(e);
+
+      // we dont throw this error as it is not a critical error
     }
-
-    incidentFeed.displayColor = data.displayColor;
-    incidentFeed.incidentId = data.incidentId;
-    incidentFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
-    incidentFeed.incidentFeedEventType = data.incidentFeedEventType;
-    incidentFeed.projectId = data.projectId;
-
-    if (!data.postedAt) {
-      incidentFeed.postedAt = OneUptimeDate.getCurrentDate();
-    }
-
-    if (data.userId) {
-      incidentFeed.userId = data.userId;
-    }
-
-    if (data.moreInformationInMarkdown) {
-      incidentFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
-    }
-
-    const createdIncidentFeed: IncidentFeed = await this.create({
-      data: incidentFeed,
-      props: {
-        isRoot: true,
-      },
-    });
-
-    logger.debug("Incident Feed created");
-    logger.debug(createdIncidentFeed);
-
-    return createdIncidentFeed;
   }
 }
 

package/Server/Services/IncidentInternalNoteService.ts

@@ -1,10 +1,11 @@
 import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/IncidentInternalNote";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import { Blue500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -33,6 +34,50 @@ ${createdItem.note}
 
     return createdItem;
   }
+
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          incidentId: true,
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        await IncidentFeedService.createIncidentFeed({
+          incidentId: updatedItem.incidentId!,
+          projectId: updatedItem.projectId!,
+          incidentFeedEventType: IncidentFeedEventType.PrivateNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+
+          feedInfoInMarkdown: `**Updated Internal / Private Note**
+
+${updatedItem.note}
+          `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentPublicNoteService.ts

@@ -1,12 +1,13 @@
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import Model from "Common/Models/DatabaseModels/IncidentPublicNote";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
-import { Indigo500 } from "../../Types/BrandColors";
+import { Blue500, Indigo500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -47,6 +48,50 @@ ${createdItem.note}
 
     return createdItem;
   }
+
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          incidentId: true,
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        await IncidentFeedService.createIncidentFeed({
+          incidentId: updatedItem.incidentId!,
+          projectId: updatedItem.projectId!,
+          incidentFeedEventType: IncidentFeedEventType.PublicNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+
+          feedInfoInMarkdown: `**Updated Public Note**
+  
+${updatedItem.note}
+            `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -30,6 +30,7 @@ import OnCallDutyPolicyEscalationRuleTeam from "Common/Models/DatabaseModels/OnC
 import OnCallDutyPolicyEscalationRuleUser from "Common/Models/DatabaseModels/OnCallDutyPolicyEscalationRuleUser";
 import OnCallDutyPolicyExecutionLogTimeline from "Common/Models/DatabaseModels/OnCallDutyPolicyExecutionLogTimeline";
 import User from "Common/Models/DatabaseModels/User";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public async startRuleExecution(
@@ -37,12 +38,13 @@ export class Service extends DatabaseService<Model> {
     options: {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
+      triggeredByAlertId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId: ObjectID;
       onCallPolicyId: ObjectID;
     },
   ): Promise<void> {
-    // add log timeline.
+    logger.debug(`Starting rule execution for ruleId: ${ruleId.toString()}`);
 
     const rule: Model | null = await this.findOneById({
       id: ruleId,
@@ -62,6 +64,8 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    logger.debug(`Found rule: ${JSON.stringify(rule)}`);
+
     await OnCallDutyPolicyExecutionLogService.updateOneById({
       id: options.onCallPolicyExecutionLogId,
       data: {
@@ -75,6 +79,8 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
+    logger.debug(`Updated execution log for ruleId: ${ruleId.toString()}`);
+
     type GetNewLogFunction = () => OnCallDutyPolicyExecutionLogTimeline;
 
     const getNewLog: GetNewLogFunction =
@@ -92,6 +98,10 @@ export class Service extends DatabaseService<Model> {
           log.triggeredByIncidentId = options.triggeredByIncidentId;
         }
 
+        if (options.triggeredByAlertId) {
+          log.triggeredByAlertId = options.triggeredByAlertId;
+        }
+
         return log;
       };
 
@@ -105,6 +115,16 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    if (
+      UserNotificationEventType.AlertCreated ===
+        options.userNotificationEventType &&
+      !options.triggeredByAlertId
+    ) {
+      throw new BadDataException(
+        "triggeredByAlertId is required when userNotificationEventType is IncidentCreated",
+      );
+    }
+
     const usersInRule: Array<OnCallDutyPolicyEscalationRuleUser> =
       await OnCallDutyPolicyEscalationRuleUserService.findBy({
         query: {
@@ -120,6 +140,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+    logger.debug(`Found users in rule: ${JSON.stringify(usersInRule)}`);
+
     const teamsInRule: Array<OnCallDutyPolicyEscalationRuleTeam> =
       await OnCallDutyPolicyEscalationRuleTeamService.findBy({
         query: {
@@ -135,6 +157,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+    logger.debug(`Found teams in rule: ${JSON.stringify(teamsInRule)}`);
+
     const schedulesInRule: Array<OnCallDutyPolicyEscalationRuleSchedule> =
       await OnCallDutyPolicyEscalationRuleScheduleService.findBy({
         query: {
@@ -150,7 +174,7 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    // get unique users and notify all the users.
+    logger.debug(`Found schedules in rule: ${JSON.stringify(schedulesInRule)}`);
 
     type StartUserNotificationRuleExecutionFunction = (
       userId: ObjectID,
@@ -164,7 +188,9 @@ export class Service extends DatabaseService<Model> {
         teamId: ObjectID | null,
         scheduleId: ObjectID | null,
       ): Promise<void> => {
-        // no users in this rule. Skipping.
+        logger.debug(
+          `Starting notification rule execution for userId: ${userId.toString()}`,
+        );
         let log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage = "Sending notification to user.";
         log.status = OnCallDutyExecutionLogTimelineStatus.Executing;
@@ -189,6 +215,7 @@ export class Service extends DatabaseService<Model> {
           {
             userNotificationEventType: options.userNotificationEventType!,
             triggeredByIncidentId: options.triggeredByIncidentId || undefined,
+            triggeredByAlertId: options.triggeredByAlertId || undefined,
             onCallPolicyExecutionLogId: options.onCallPolicyExecutionLogId,
             onCallPolicyId: options.onCallPolicyId,
             onCallPolicyEscalationRuleId: ruleId,
@@ -220,7 +247,6 @@ export class Service extends DatabaseService<Model> {
             null,
           );
         } else {
-          // no users in this rule. Skipping.
           const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
           log.statusMessage =
             "Skipped because notification sent to this user already.";
@@ -247,7 +273,6 @@ export class Service extends DatabaseService<Model> {
         uniqueUserIds.push(userRule.userId!);
         await startUserNotificationRuleExecution(userRule.userId!, null, null);
       } else {
-        // no users in this rule. Skipping.
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because notification sent to this user already.";
@@ -264,23 +289,16 @@ export class Service extends DatabaseService<Model> {
     }
 
     for (const scheduleRule of schedulesInRule) {
-      // get layers and users in this schedule and find a user to notify.
-
       const userIdInSchedule: ObjectID | null =
         await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
           scheduleRule.onCallDutyPolicyScheduleId!,
         );
 
       if (!userIdInSchedule) {
-        // no user active in this schedule. Skipping.
-
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
-
         log.statusMessage =
           "Skipped because no active users are found in this schedule.";
-
         log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
-
         log.onCallDutyScheduleId = scheduleRule.onCallDutyPolicyScheduleId!;
 
         await OnCallDutyPolicyExecutionLogTimelineService.create({
@@ -305,7 +323,6 @@ export class Service extends DatabaseService<Model> {
           scheduleRule.onCallDutyPolicyScheduleId!,
         );
       } else {
-        // no users in this rule. Skipping.
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because notification sent to this user already.";
@@ -323,7 +340,6 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (uniqueUserIds.length === 0) {
-      // no users in this rule. Skipping.
       const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
       log.statusMessage = "Skipped because no users in this rule.";
       log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
@@ -335,6 +351,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
     }
+
+    logger.debug(`Completed rule execution for ruleId: ${ruleId.toString()}`);
   }
 
   public constructor() {