@oneuptime/common 7.0.3707 → 7.0.3712

package/Server/Services/StatusPageSubscriberService.ts

@@ -39,28 +39,38 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     data: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
+    logger.debug("onBeforeCreate called with data:");
+    logger.debug(data);
+
     if (!data.data.statusPageId) {
+      logger.debug("Status Page ID is missing.");
       throw new BadDataException("Status Page ID is required.");
     }
 
     if (!data.data.projectId) {
+      logger.debug("Project ID is missing.");
       throw new BadDataException("Project ID is required.");
     }
 
     const projectId: ObjectID = data.data.projectId;
+    logger.debug(`Project ID: ${projectId}`);
 
     // if the project is on the free plan, then only allow 1 status page.
     if (IsBillingEnabled) {
+      logger.debug("Billing is enabled.");
       const currentPlan: CurrentPlan =
         await ProjectService.getCurrentPlan(projectId);
+      logger.debug(`Current Plan: ${JSON.stringify(currentPlan)}`);
 
       if (currentPlan.isSubscriptionUnpaid) {
+        logger.debug("Subscription is unpaid.");
         throw new BadDataException(
           "Your subscription is unpaid. Please update your payment method and to add subscribers.",
         );
       }
 
       if (currentPlan.plan === PlanType.Free) {
+        logger.debug("Current plan is Free.");
         const subscribersCount: PositiveNumber = await this.countBy({
           query: {
             projectId: projectId,
@@ -69,8 +79,12 @@ export class Service extends DatabaseService<Model> {
             isRoot: true,
           },
         });
+        logger.debug(`Subscribers Count: ${subscribersCount.toNumber()}`);
 
         if (subscribersCount.toNumber() >= AllowedSubscribersCountInFreePlan) {
+          logger.debug(
+            "Reached maximum allowed subscriber limit for the free plan.",
+          );
           throw new BadDataException(
             `You have reached the maximum allowed subscriber limit for the free plan. Please upgrade your plan to add more subscribers.`,
           );
@@ -81,6 +95,7 @@ export class Service extends DatabaseService<Model> {
     let subscriber: Model | null = null;
 
     if (data.data.subscriberEmail) {
+      logger.debug(`Subscriber Email: ${data.data.subscriberEmail}`);
       subscriber = await this.findOneBy({
         query: {
           statusPageId: data.data.statusPageId,
@@ -95,15 +110,18 @@ export class Service extends DatabaseService<Model> {
           ignoreHooks: true,
         },
       });
+      logger.debug(`Found Subscriber by Email: ${JSON.stringify(subscriber)}`);
     }
 
     if (data.data.subscriberPhone) {
+      logger.debug(`Subscriber Phone: ${data.data.subscriberPhone}`);
       // check if this project has SMS enabled.
-
       const isSMSEnabled: boolean =
         await ProjectService.isSMSNotificationsEnabled(projectId);
+      logger.debug(`Is SMS Enabled: ${isSMSEnabled}`);
 
       if (!isSMSEnabled) {
+        logger.debug("SMS notifications are not enabled for this project.");
         throw new BadDataException(
           "SMS notifications are not enabled for this project. Please enable SMS notifications in the Project Settings > Notifications Settings.",
         );
@@ -123,9 +141,11 @@ export class Service extends DatabaseService<Model> {
           ignoreHooks: true,
         },
       });
+      logger.debug(`Found Subscriber by Phone: ${JSON.stringify(subscriber)}`);
     }
 
     if (subscriber && !subscriber.isUnsubscribed) {
+      logger.debug("Subscriber is already subscribed and not unsubscribed.");
       throw new BadDataException(
         "You are already subscribed to this status page.",
       );
@@ -133,6 +153,7 @@ export class Service extends DatabaseService<Model> {
 
     // if the user is unsubscribed, delete this record and it'll create a new one.
     if (subscriber) {
+      logger.debug("Subscriber is unsubscribed. Deleting old record.");
       await this.deleteOneBy({
         query: {
           _id: subscriber?._id as string,
@@ -146,6 +167,7 @@ export class Service extends DatabaseService<Model> {
 
     const statuspages: Array<StatusPage> =
       await this.getStatusPagesToSendNotification([data.data.statusPageId]);
+    logger.debug(`Status Pages: ${JSON.stringify(statuspages)}`);
 
     const statuspage: StatusPage | undefined = statuspages.find(
       (statuspage: StatusPage) => {
@@ -156,26 +178,39 @@ export class Service extends DatabaseService<Model> {
     );
 
     if (!statuspage || !statuspage.projectId) {
+      logger.debug("Status Page not found or Project ID is missing.");
       throw new BadDataException("Status Page not found");
     }
 
     data.data.projectId = statuspage.projectId;
+    logger.debug(`Updated Project ID: ${data.data.projectId}`);
 
     const isEmailSubscriber: boolean = Boolean(data.data.subscriberEmail);
     const isSubscriptionConfirmed: boolean = Boolean(
       data.data.isSubscriptionConfirmed,
     );
+    logger.debug(`Is Email Subscriber: ${isEmailSubscriber}`);
+    logger.debug(`Is Subscription Confirmed: ${isSubscriptionConfirmed}`);
 
     if (isEmailSubscriber && !isSubscriptionConfirmed) {
       data.data.isSubscriptionConfirmed = false;
     } else {
       data.data.isSubscriptionConfirmed = true; // if the subscriber is not email, then set it to true for SMS subscribers.
     }
+    logger.debug(
+      `Final Subscription Confirmed: ${data.data.isSubscriptionConfirmed}`,
+    );
 
     data.data.subscriptionConfirmationToken = NumberUtil.getRandomNumber(
       100000,
       999999,
     ).toString();
+    logger.debug(
+      `Subscription Confirmation Token: ${data.data.subscriptionConfirmationToken}`,
+    );
+
+    logger.debug("onBeforeCreate processed data:");
+    logger.debug(data);
 
     return { createBy: data, carryForward: statuspage };
   }
@@ -184,23 +219,30 @@ export class Service extends DatabaseService<Model> {
     onCreate: OnCreate<Model>,
     createdItem: Model,
   ): Promise<Model> {
+    logger.debug("onCreateSuccess called with createdItem:");
+    logger.debug(createdItem);
+
     if (!createdItem.statusPageId) {
+      logger.debug("Status Page ID is missing in createdItem.");
       return createdItem;
     }
 
     const statusPageURL: string = await StatusPageService.getStatusPageURL(
       createdItem.statusPageId,
     );
+    logger.debug(`Status Page URL: ${statusPageURL}`);
 
     const statusPageName: string =
       onCreate.carryForward.pageTitle ||
       onCreate.carryForward.name ||
       "Status Page";
+    logger.debug(`Status Page Name: ${statusPageName}`);
 
     const unsubscribeLink: string = this.getUnsubscribeLink(
       URL.fromString(statusPageURL),
       createdItem.id!,
     ).toString();
+    logger.debug(`Unsubscribe Link: ${unsubscribeLink}`);
 
     if (
       createdItem.statusPageId &&
@@ -208,6 +250,9 @@ export class Service extends DatabaseService<Model> {
       createdItem._id &&
       createdItem.sendYouHaveSubscribedMessage
     ) {
+      logger.debug(
+        "Subscriber has a phone number and sendYouHaveSubscribedMessage is true.",
+      );
       const statusPage: StatusPage | null = await StatusPageService.findOneBy({
         query: {
           _id: createdItem.statusPageId.toString(),
@@ -227,9 +272,14 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (!statusPage) {
+        logger.debug("Status Page not found.");
         return createdItem;
       }
 
+      logger.debug(
+        `Status Page Call SMS Config: ${JSON.stringify(statusPage.callSmsConfig)}`,
+      );
+
       SmsService.sendSms(
         {
           to: createdItem.subscriberPhone,
@@ -252,34 +302,41 @@ export class Service extends DatabaseService<Model> {
       createdItem.subscriberEmail &&
       createdItem._id
     ) {
-      // Call mail service and send an email.
-
-      // get status page domain for this status page.
-      // if the domain is not found, use the internal status page preview link.
-
+      logger.debug("Subscriber has an email.");
       const isSubcriptionConfirmed: boolean = Boolean(
         createdItem.isSubscriptionConfirmed,
       );
+      logger.debug(`Is Subscription Confirmed: ${isSubcriptionConfirmed}`);
 
       if (!isSubcriptionConfirmed) {
+        logger.debug(
+          "Subscription is not confirmed. Sending confirmation email.",
+        );
         await this.sendConfirmSubscriptionEmail({
           subscriberId: createdItem.id!,
         });
       }
 
       if (isSubcriptionConfirmed && createdItem.sendYouHaveSubscribedMessage) {
+        logger.debug(
+          "Subscription is confirmed and sendYouHaveSubscribedMessage is true. Sending 'You have subscribed' email.",
+        );
         await this.sendYouHaveSubscribedEmail({
           subscriberId: createdItem.id!,
         });
       }
     }
 
+    logger.debug("onCreateSuccess completed.");
     return createdItem;
   }
 
   public async sendConfirmSubscriptionEmail(data: {
     subscriberId: ObjectID;
   }): Promise<void> {
+    logger.debug("sendConfirmSubscriptionEmail called with data:");
+    logger.debug(data);
+
     // get subscriber
     const subscriber: Model | null = await this.findOneBy({
       query: {
@@ -298,9 +355,11 @@ export class Service extends DatabaseService<Model> {
         ignoreHooks: true,
       },
     });
+    logger.debug(`Found Subscriber: ${JSON.stringify(subscriber)}`);
 
     // get status page
     if (!subscriber || !subscriber.statusPageId) {
+      logger.debug("Subscriber or Status Page ID is missing.");
       return;
     }
 
@@ -329,27 +388,34 @@ export class Service extends DatabaseService<Model> {
         ignoreHooks: true,
       },
     });
+    logger.debug(`Found Status Page: ${JSON.stringify(statusPage)}`);
 
     if (!statusPage || !statusPage.id) {
+      logger.debug("Status Page not found or ID is missing.");
       return;
     }
 
     const statusPageURL: string = await StatusPageService.getStatusPageURL(
       statusPage.id,
     );
+    logger.debug(`Status Page URL: ${statusPageURL}`);
 
     const statusPageName: string =
       statusPage.pageTitle || statusPage.name || "Status Page";
+    logger.debug(`Status Page Name: ${statusPageName}`);
 
     const host: Hostname = await DatabaseConfig.getHost();
+    logger.debug(`Host: ${host}`);
 
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+    logger.debug(`HTTP Protocol: ${httpProtocol}`);
 
     const confirmSubscriptionLink: string = this.getConfirmSubscriptionLink({
       statusPageUrl: statusPageURL,
       confirmationToken: subscriber.subscriptionConfirmationToken || "",
       statusPageSubscriberId: subscriber.id!,
     }).toString();
+    logger.debug(`Confirm Subscription Link: ${confirmSubscriptionLink}`);
 
     if (
       subscriber.statusPageId &&
@@ -360,6 +426,7 @@ export class Service extends DatabaseService<Model> {
         URL.fromString(statusPageURL),
         subscriber.id!,
       ).toString();
+      logger.debug(`Unsubscribe URL: ${unsubscribeUrl}`);
 
       MailService.sendMail(
         {
@@ -391,12 +458,18 @@ export class Service extends DatabaseService<Model> {
       ).catch((err: Error) => {
         logger.error(err);
       });
+      logger.debug("Confirmation email sent.");
+    } else {
+      logger.debug("Subscriber email or ID is missing.");
     }
   }
 
   public async sendYouHaveSubscribedEmail(data: {
     subscriberId: ObjectID;
   }): Promise<void> {
+    logger.debug("sendYouHaveSubscribedEmail called with data:");
+    logger.debug(data);
+
     // get subscriber
     const subscriber: Model | null = await this.findOneBy({
       query: {
@@ -414,9 +487,11 @@ export class Service extends DatabaseService<Model> {
         ignoreHooks: true,
       },
     });
+    logger.debug(`Found Subscriber: ${JSON.stringify(subscriber)}`);
 
     // get status page
     if (!subscriber || !subscriber.statusPageId) {
+      logger.debug("Subscriber or Status Page ID is missing.");
       return;
     }
 
@@ -445,32 +520,40 @@ export class Service extends DatabaseService<Model> {
         ignoreHooks: true,
       },
     });
+    logger.debug(`Found Status Page: ${JSON.stringify(statusPage)}`);
 
     if (!statusPage || !statusPage.id) {
+      logger.debug("Status Page not found or ID is missing.");
       return;
     }
 
     const statusPageURL: string = await StatusPageService.getStatusPageURL(
       statusPage.id,
     );
+    logger.debug(`Status Page URL: ${statusPageURL}`);
 
     const statusPageName: string =
       statusPage.pageTitle || statusPage.name || "Status Page";
+    logger.debug(`Status Page Name: ${statusPageName}`);
 
     const host: Hostname = await DatabaseConfig.getHost();
+    logger.debug(`Host: ${host}`);
 
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+    logger.debug(`HTTP Protocol: ${httpProtocol}`);
 
     const unsubscribeLink: string = this.getUnsubscribeLink(
       URL.fromString(statusPageURL),
       subscriber.id!,
     ).toString();
+    logger.debug(`Unsubscribe Link: ${unsubscribeLink}`);
 
     if (
       subscriber.statusPageId &&
       subscriber.subscriberEmail &&
       subscriber._id
     ) {
+      logger.debug("Subscriber has an email and ID.");
       MailService.sendMail(
         {
           toEmail: subscriber.subscriberEmail,
@@ -498,8 +581,12 @@ export class Service extends DatabaseService<Model> {
           ),
         },
       ).catch((err: Error) => {
+        logger.error("Error sending subscription email:");
         logger.error(err);
       });
+      logger.debug("Subscription email sent successfully.");
+    } else {
+      logger.debug("Subscriber email or ID is missing.");
     }
   }
 
@@ -508,16 +595,31 @@ export class Service extends DatabaseService<Model> {
     confirmationToken: string;
     statusPageSubscriberId: ObjectID;
   }): URL {
-    return URL.fromString(data.statusPageUrl).addRoute(
+    logger.debug("getConfirmSubscriptionLink called with data:");
+    logger.debug(data);
+
+    const confirmSubscriptionLink: URL = URL.fromString(
+      data.statusPageUrl,
+    ).addRoute(
       `/confirm-subscription/${data.statusPageSubscriberId.toString()}?verification-token=${data.confirmationToken}`,
     );
+
+    logger.debug(
+      `Generated Confirm Subscription Link: ${confirmSubscriptionLink.toString()}`,
+    );
+    return confirmSubscriptionLink;
   }
 
   public async getSubscribersByStatusPage(
     statusPageId: ObjectID,
     props: DatabaseCommonInteractionProps,
   ): Promise<Array<Model>> {
-    return await this.findBy({
+    logger.debug("getSubscribersByStatusPage called with statusPageId:");
+    logger.debug(statusPageId);
+    logger.debug("DatabaseCommonInteractionProps:");
+    logger.debug(props);
+
+    const subscribers: Array<Model> = await this.findBy({
       query: {
         statusPageId: statusPageId,
         isUnsubscribed: false,
@@ -537,15 +639,30 @@ export class Service extends DatabaseService<Model> {
       limit: LIMIT_MAX,
       props: props,
     });
+
+    logger.debug("Found subscribers:");
+    logger.debug(subscribers);
+
+    return subscribers;
   }
 
   public getUnsubscribeLink(
     statusPageUrl: URL,
     statusPageSubscriberId: ObjectID,
   ): URL {
-    return URL.fromString(statusPageUrl.toString()).addRoute(
-      "/update-subscription/" + statusPageSubscriberId.toString(),
-    );
+    logger.debug("getUnsubscribeLink called with statusPageUrl:");
+    logger.debug(statusPageUrl);
+    logger.debug("statusPageSubscriberId:");
+    logger.debug(statusPageSubscriberId);
+
+    const unsubscribeLink: URL = URL.fromString(
+      statusPageUrl.toString(),
+    ).addRoute("/update-subscription/" + statusPageSubscriberId.toString());
+
+    logger.debug("Generated Unsubscribe Link:");
+    logger.debug(unsubscribeLink);
+
+    return unsubscribeLink;
   }
 
   public shouldSendNotification(data: {
@@ -554,9 +671,13 @@ export class Service extends DatabaseService<Model> {
     statusPage: StatusPage;
     eventType: StatusPageEventType;
   }): boolean {
+    logger.debug("shouldSendNotification called with data:");
+    logger.debug(data);
+
     let shouldSendNotification: boolean = true; // default to true.
 
     if (data.subscriber.isUnsubscribed) {
+      logger.debug("Subscriber is unsubscribed.");
       shouldSendNotification = false;
       return shouldSendNotification;
     }
@@ -566,6 +687,9 @@ export class Service extends DatabaseService<Model> {
       !data.subscriber.isSubscribedToAllResources &&
       data.eventType !== StatusPageEventType.Announcement // announcements dont have resources
     ) {
+      logger.debug(
+        "Subscriber can choose resources and is not subscribed to all resources.",
+      );
       const subscriberResourceIds: Array<string> =
         data.subscriber.statusPageResources?.map(
           (resource: StatusPageResource) => {
@@ -573,21 +697,27 @@ export class Service extends DatabaseService<Model> {
           },
         ) || [];
 
+      logger.debug(`Subscriber Resource IDs: ${subscriberResourceIds}`);
+
       let shouldSendNotificationForResource: boolean = false;
 
       if (subscriberResourceIds.length === 0) {
+        logger.debug("Subscriber has no resource IDs.");
         shouldSendNotificationForResource = false;
       } else {
         for (const resource of data.statusPageResources) {
+          logger.debug(`Checking resource: ${resource.id}`);
           if (
             subscriberResourceIds.includes(resource.id?.toString() as string)
           ) {
+            logger.debug("Resource ID matches subscriber's resource ID.");
             shouldSendNotificationForResource = true;
           }
         }
       }
 
       if (!shouldSendNotificationForResource) {
+        logger.debug("Should not send notification for resource.");
         shouldSendNotification = false;
       }
     }
@@ -598,27 +728,40 @@ export class Service extends DatabaseService<Model> {
       data.statusPage.allowSubscribersToChooseEventTypes &&
       !data.subscriber.isSubscribedToAllEventTypes
     ) {
+      logger.debug(
+        "Subscriber can choose event types and is not subscribed to all event types.",
+      );
       const subscriberEventTypes: Array<StatusPageEventType> =
         data.subscriber.statusPageEventTypes || [];
 
+      logger.debug(`Subscriber Event Types: ${subscriberEventTypes}`);
+
       let shouldSendNotificationForEventType: boolean = false;
 
       if (subscriberEventTypes.includes(data.eventType)) {
+        logger.debug("Event type matches subscriber's event type.");
         shouldSendNotificationForEventType = true;
       }
 
       if (!shouldSendNotificationForEventType) {
+        logger.debug("Should not send notification for event type.");
         shouldSendNotification = false;
       }
     }
 
+    logger.debug(
+      `Final decision on shouldSendNotification: ${shouldSendNotification}`,
+    );
     return shouldSendNotification;
   }
 
   public async getStatusPagesToSendNotification(
     statusPageIds: Array<ObjectID>,
   ): Promise<Array<StatusPage>> {
-    return await StatusPageService.findBy({
+    logger.debug("getStatusPagesToSendNotification called with statusPageIds:");
+    logger.debug(statusPageIds);
+
+    const statusPages: Array<StatusPage> = await StatusPageService.findBy({
       query: {
         _id: QueryHelper.any(statusPageIds),
       },
@@ -659,6 +802,11 @@ export class Service extends DatabaseService<Model> {
         isReportEnabled: true,
       },
     });
+
+    logger.debug("Found status pages:");
+    logger.debug(statusPages);
+
+    return statusPages;
   }
 }
 export default new Service();