@oneuptime/common 7.0.3515 → 7.0.3526

package/Models/DatabaseModels/Incident.ts

@@ -853,7 +853,12 @@ export default class Incident extends BaseModel {
       Permission.ProjectMember,
       Permission.ReadProjectIncident,
     ],
-    update: [],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectIncident,
+    ],
   })
   @TableColumn({
     type: TableColumnType.Markdown,

package/Models/DatabaseModels/ScheduledMaintenanceFeed.ts

@@ -23,12 +23,20 @@ import Color from "../../Types/Color";
 
 export enum ScheduledMaintenanceFeedEventType {
   PublicNote = "PublicNote",
-  SubscriberEmailSent = "SubscriberEmailSent",
-  OwnerEmailSent = "OwnerEmailSent",
+  SubscriberNotificationSent = "SubscriberNotificationSent",
+  OwnerNotificationSent = "OwnerNotificationSent",
+  OwnerUserAdded = "OwnerUserAdded",
+  OwnerTeamAdded = "OwnerTeamAdded",
   ScheduledMaintenanceCreated = "ScheduledMaintenanceCreated",
-  ScheduledMaintenanceAcknowledged = "ScheduledMaintenanceAcknowledged",
-  ScheduledMaintenanceResolved = "ScheduledMaintenanceResolved",
+  ScheduledMaintenanceStateChanged = "ScheduledMaintenanceStateChanged",
   PrivateNote = "PrivateNote",
+  ScheduledMaintenanceUpdated = "ScheduledMaintenanceUpdated",
+  RootCause = "RootCause",
+  RemediationNotes = "RemediationNotes",
+  OwnerUserRemoved = "OwnerUserRemoved",
+  OwnerTeamRemoved = "OwnerTeamRemoved",
+  OnCallPolicy = "OnCallPolicy",
+  OnCallNotification = "OnCallNotification",
 }
 
 @EnableDocumentation()
@@ -332,7 +340,7 @@ export default class ScheduledMaintenanceFeed extends BaseModel {
     required: true,
     title: "Log (in Markdown)",
     description:
-      "Log of the entire scheduledMaintenance state change in Markdown",
+      "Log of the entire scheduled maintenance state change in Markdown",
   })
   @Column({
     type: ColumnType.Markdown,
@@ -403,13 +411,13 @@ export default class ScheduledMaintenanceFeed extends BaseModel {
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
       Permission.ProjectMember,
-      Permission.CreateIncidentFeed,
+      Permission.CreateScheduledMaintenanceFeed,
     ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
       Permission.ProjectMember,
-      Permission.ReadIncidentFeed,
+      Permission.ReadScheduledMaintenanceFeed,
     ],
     update: [],
   })

package/Server/API/BillingInvoiceAPI.ts

@@ -14,7 +14,6 @@ import {
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
-import SubscriptionStatus from "Common/Types/Billing/SubscriptionStatus";
 import BadDataException from "Common/Types/Exception/BadDataException";
 import { JSONObject } from "Common/Types/JSON";
 import Permission, { UserPermission } from "Common/Types/Permission";
@@ -127,37 +126,8 @@ export default class UserAPI extends BaseAPI<
             },
           });
 
-          // refresh subscription status.
-          const subscriptionState: SubscriptionStatus =
-            await BillingService.getSubscriptionStatus(
-              project.paymentProviderSubscriptionId as string,
-            );
-
-          const meteredSubscriptionState: SubscriptionStatus =
-            await BillingService.getSubscriptionStatus(
-              project.paymentProviderMeteredSubscriptionId as string,
-            );
-
-          // if subscription is cancelled, create a new subscription and update project.
-
-          if (
-            meteredSubscriptionState === SubscriptionStatus.Canceled ||
-            subscriptionState === SubscriptionStatus.Canceled
-          ) {
-            await ProjectService.reactiveSubscription(project.id!);
-          }
-
-          await ProjectService.updateOneById({
-            id: project.id!,
-            data: {
-              paymentProviderSubscriptionStatus: subscriptionState,
-              paymentProviderMeteredSubscriptionStatus:
-                meteredSubscriptionState,
-            },
-            props: {
-              isRoot: true,
-              ignoreHooks: true,
-            },
+          await BillingInvoiceService.refreshSubscriptionStatus({
+            projectId: project.id!,
           });
 
           return Response.sendEmptySuccessResponse(req, res);

package/Server/Services/AlertFeedService.ts

@@ -4,6 +4,7 @@ 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, {
   AlertFeedEventType,
@@ -27,54 +28,60 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
-  }): Promise<Model> {
-    if (!data.alertId) {
-      throw new BadDataException("Alert ID is required");
-    }
+  }): Promise<void> {
+    try {
+      if (!data.alertId) {
+        throw new BadDataException("Alert ID is required");
+      }
 
-    if (!data.feedInfoInMarkdown) {
-      throw new BadDataException("Log in markdown is required");
-    }
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
 
-    if (!data.alertFeedEventType) {
-      throw new BadDataException("Alert log event is required");
-    }
+      if (!data.alertFeedEventType) {
+        throw new BadDataException("Alert log event is required");
+      }
 
-    if (!data.projectId) {
-      throw new BadDataException("Project ID is required");
-    }
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
 
-    const alertFeed: Model = new Model();
+      const alertFeed: Model = new Model();
 
-    if (!data.displayColor) {
-      data.displayColor = Blue500;
-    }
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
 
-    if (data.userId) {
-      alertFeed.userId = data.userId;
-    }
+      if (data.userId) {
+        alertFeed.userId = data.userId;
+      }
 
-    alertFeed.displayColor = data.displayColor;
+      alertFeed.displayColor = data.displayColor;
 
-    alertFeed.alertId = data.alertId;
-    alertFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
-    alertFeed.alertFeedEventType = data.alertFeedEventType;
-    alertFeed.projectId = data.projectId;
+      alertFeed.alertId = data.alertId;
+      alertFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      alertFeed.alertFeedEventType = data.alertFeedEventType;
+      alertFeed.projectId = data.projectId;
 
-    if (!data.postedAt) {
-      alertFeed.postedAt = OneUptimeDate.getCurrentDate();
-    }
+      if (!data.postedAt) {
+        alertFeed.postedAt = OneUptimeDate.getCurrentDate();
+      }
 
-    if (data.moreInformationInMarkdown) {
-      alertFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
-    }
+      if (data.moreInformationInMarkdown) {
+        alertFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+      }
 
-    return await this.create({
-      data: alertFeed,
-      props: {
-        isRoot: true,
-      },
-    });
+      await this.create({
+        data: alertFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error("AlertFeedService.createAlertFeed");
+      logger.error(error);
+      // we dont want to throw the error here, as this is a non-critical operation
+    }
   }
 }
 

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/IncidentService.ts

@@ -662,6 +662,24 @@ ${onUpdate.updateBy.data.title || "No title provided."}
           });
         }
 
+        if (onUpdate.updateBy.data.rootCause) {
+          // add incident feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Incident root cause was updated.** Here's the new root cause.
+      
+${onUpdate.updateBy.data.rootCause || "No root cause provided."}
+        `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
         if (onUpdate.updateBy.data.description) {
           // add incident feed.
           const createdByUserId: ObjectID | undefined | null =