@oneuptime/common 12.0.18 → 12.0.20

package/Server/Services/ProjectService.ts

@@ -16,6 +16,8 @@ import UpdateBy from "../Types/Database/UpdateBy";
 import logger, { LogAttributes } from "../Utils/Logger";
 import Errors from "../Utils/Errors";
 import ProductAnalytics from "../Utils/ProductAnalytics";
+import MarketingEventUtil from "../Utils/Marketing/MarketingEventUtil";
+import { MarketingEventType } from "../../Types/Marketing/MarketingEvent";
 import SessionReplayGateCacheStore from "../Utils/SessionReplay/SessionReplayGateCacheStore";
 import AccessTokenService from "./AccessTokenService";
 import BillingService from "./BillingService";
@@ -558,10 +560,21 @@ export class ProjectService extends DatabaseService<Model> {
         trialEndsAt: true,
         paymentProviderCustomerId: true,
         createdOwnerEmail: true,
+        /*
+         * The full attribution set, not just the three UTMs the analytics
+         * properties carry: the outbound plan-change conversion is the only
+         * place the campaign that won a customer is ever reported, and a
+         * column left unselected reaches the receiver as empty rather than as
+         * an error.
+         */
         utmSource: true,
         utmMedium: true,
         utmCampaign: true,
+        utmTerm: true,
+        utmContent: true,
+        utmUrl: true,
         clickIds: true,
+        firstTouchAttribution: true,
       },
       props: {
         isRoot: true,
@@ -884,6 +897,98 @@ These are no longer recorded against the project and have to be cancelled by han
     );
   }
 
+  /*
+   * The first-subscription conversion.
+   *
+   * A project created directly on a paid plan never passes through changePlan,
+   * so the plan-change pass below never sees it — and could not report it if
+   * it did, because direction is decided by plan ORDER and a first plan has no
+   * previous tier to compare against. That left the most bid-worthy self-serve
+   * conversion there is emitting nothing at all: a visitor could click an ad,
+   * sign up, pick Growth and pay, and no channel carried a single event.
+   *
+   * It is its own event rather than an upgrade with an empty old_plan because
+   * this is new business and an upgrade is expansion. Mixing them is a
+   * distinction nothing downstream could restore.
+   *
+   * Free projects reach here too — a project on the free plan is still
+   * subscribed at the payment provider — so the paid check is what keeps this
+   * a revenue event.
+   */
+  private captureSubscriptionStartedAnalytics(data: {
+    project: Model;
+    plan: SubscriptionPlan;
+    planId: string;
+    seats: number;
+  }): void {
+    if (!data.project.createdOwnerEmail) {
+      return;
+    }
+
+    // Per-month amount, or null when unknown (custom pricing / unknown plan).
+    const monthlyAmountInUSD: number | null = data.plan.isCustomPricing()
+      ? null
+      : data.plan.getYearlyPlanId() === data.planId
+        ? data.plan.getYearlySubscriptionAmountInUSD()
+        : data.plan.getMonthlySubscriptionAmountInUSD();
+
+    const planIsPaid: boolean =
+      data.plan.isCustomPricing() ||
+      (monthlyAmountInUSD !== null && monthlyAmountInUSD > 0);
+
+    if (!planIsPaid) {
+      return;
+    }
+
+    const properties: JSONObject = {
+      project_id: data.project.id?.toString() || "",
+      new_plan: data.plan.getName(),
+      seats: data.seats,
+      /*
+       * Always true. The project went straight from not existing to paying,
+       * which is the acquisition this event exists to report.
+       */
+      is_paid_conversion: true,
+      has_custom_pricing: data.plan.isCustomPricing(),
+      utm_source: data.project.utmSource || "",
+      utm_medium: data.project.utmMedium || "",
+      utm_campaign: data.project.utmCampaign || "",
+      utm_term: data.project.utmTerm || "",
+      utm_content: data.project.utmContent || "",
+      click_ids: data.project.clickIds || {},
+    };
+
+    if (monthlyAmountInUSD !== null) {
+      properties["new_monthly_amount_in_usd"] = monthlyAmountInUSD;
+      // Value for ROAS reporting: monthly recurring revenue at the start.
+      properties["value"] = monthlyAmountInUSD * data.seats;
+      properties["currency"] = "USD";
+    }
+
+    ProductAnalytics.capture({
+      event: "server/subscription_started",
+      distinctId: data.project.createdOwnerEmail.toString(),
+      properties: properties,
+    });
+
+    MarketingEventUtil.emitInBackground(
+      MarketingEventUtil.buildEvent({
+        eventType: MarketingEventType.SubscriptionStarted,
+        /*
+         * Naturally unique: a project has exactly one first subscription, so a
+         * queue retry carries the identical id and the receiver dedupes it.
+         * Unlike a plan change, this needs no timestamp to separate it from
+         * the next one — there is no next one.
+         */
+        eventId: `${MarketingEventType.SubscriptionStarted}:${data.project.id?.toString()}`,
+        occurredAt: data.project.createdAt || new Date(),
+        email: data.project.createdOwnerEmail.toString(),
+        attributionSource: data.project,
+        data: properties,
+      }),
+    );
+  }
+
   /*
    * The paid-conversion event for ad platforms: fires server-side (immune to
    * ad blockers) whenever a project's subscription plan changes, with enough
@@ -982,6 +1087,60 @@ These are no longer recorded against the project and have to be cancelled by han
       distinctId: data.project.createdOwnerEmail.toString(),
       properties: properties,
     });
+
+    this.emitPlanChangeMarketingEvent({
+      project: data.project,
+      properties: properties,
+      isUpgrade: properties["is_upgrade"] === true,
+      isDowngrade: properties["is_downgrade"] === true,
+    });
+  }
+
+  /*
+   * The outbound subscription_upgraded / subscription_downgraded conversions.
+   *
+   * Rides on the analytics pass above rather than on the plan-change path
+   * directly, because that is where "is this an upgrade" is already decided —
+   * by plan ORDER, not price, so a monthly-to-yearly switch at the same tier
+   * is neither. Duplicating that comparison here is how the two would
+   * eventually disagree about what a customer did.
+   *
+   * Only real tier movements are emitted. A first plan on a project with no
+   * previous one has no direction (both flags read false, since oldPlanOrder
+   * is null), and an interval change is not a conversion — sending either as
+   * an upgrade would inflate exactly the number this exists to report.
+   */
+  private emitPlanChangeMarketingEvent(data: {
+    project: Model;
+    properties: JSONObject;
+    isUpgrade: boolean;
+    isDowngrade: boolean;
+  }): void {
+    if (!data.isUpgrade && !data.isDowngrade) {
+      return;
+    }
+
+    const eventType: MarketingEventType = data.isUpgrade
+      ? MarketingEventType.SubscriptionUpgraded
+      : MarketingEventType.SubscriptionDowngraded;
+
+    const occurredAt: Date = new Date();
+
+    MarketingEventUtil.emitInBackground(
+      MarketingEventUtil.buildEvent({
+        eventType: eventType,
+        /*
+         * A project can legitimately upgrade, downgrade and upgrade again, so
+         * unlike a signup or a booking there is no naturally unique key —
+         * the instant is what separates one change from the next.
+         */
+        eventId: `${eventType}:${data.project.id?.toString()}:${occurredAt.toISOString()}`,
+        occurredAt: occurredAt,
+        email: data.project.createdOwnerEmail?.toString(),
+        attributionSource: data.project,
+        data: data.properties,
+      }),
+    );
   }
 
   private async sendSubscriptionChangeWebhookSlackNotification(
@@ -1219,6 +1378,18 @@ These are no longer recorded against the project and have to be cancelled by han
         },
       });
 
+      /*
+       * Raised after the row is written, mirroring changePlan: the write is
+       * what makes the subscription real to OneUptime, and the conversion
+       * describes a subscription that exists.
+       */
+      this.captureSubscriptionStartedAnalytics({
+        project: createdItem,
+        plan: plan,
+        planId: createdItem.paymentProviderPlanId!,
+        seats: 1,
+      });
+
       // mark the promo code as used it it exists.
 
       if (createdItem.paymentProviderPromoCode) {

package/Server/Services/UserMicrosoftTeamsService.ts

@@ -0,0 +1,208 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import UserNotificationRuleService, {
+  NotificationDeletionImpact,
+  NotificationMethodChannel,
+} from "./UserNotificationRuleService";
+import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
+import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
+import logger from "../Utils/Logger";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import WorkspaceProjectAuthToken from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import Model from "../../Models/DatabaseModels/UserMicrosoftTeams";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      await UserNotificationRuleService.deleteBy({
+        query: {
+          userMicrosoftTeamsId: item.id!,
+          projectId: item.projectId!,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
+  /**
+   * What this user would lose if this Microsoft Teams account were deleted.
+   * Ask BEFORE calling delete; nothing here refuses anything.
+   *
+   * The hook directly above deletes every UserNotificationRule that points at
+   * this account, and the foreign key is onDelete: "CASCADE" so the rows would
+   * go even if it did not.
+   */
+  @CaptureSpan()
+  public async getDeletionImpact(data: {
+    itemId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<NotificationDeletionImpact> {
+    return UserNotificationRuleService.getNotificationMethodDeletionImpact({
+      projectId: data.projectId,
+      methodType: NotificationMethodChannel.MicrosoftTeams,
+      methodId: data.itemId,
+    });
+  }
+
+  /*
+   * A Microsoft Teams notification method is a POINTER at the user's existing
+   * workspace link, not a hand-typed address: the Microsoft Entra user id is
+   * resolved from the user's own WorkspaceUserAuthToken and never accepted
+   * from the request. That is why creation IS verification — the OAuth dance
+   * that wrote the auth-token row already proved the person controls that
+   * Microsoft Teams account.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.props.isRoot && createBy.data.isVerified) {
+      throw new BadDataException("isVerified cannot be set to true");
+    }
+
+    if (!createBy.props.isRoot && createBy.data.microsoftTeamsUserId) {
+      throw new BadDataException("microsoftTeamsUserId cannot be set directly");
+    }
+
+    if (!createBy.data.projectId || !createBy.data.userId) {
+      throw new BadDataException("projectId and userId are required");
+    }
+
+    const projectId: ObjectID = new ObjectID(
+      createBy.data.projectId.toString(),
+    );
+    const userId: ObjectID = new ObjectID(createBy.data.userId.toString());
+
+    /*
+     * One workspace link per (user, project) means a second row would be an
+     * exact duplicate of the first.
+     */
+    const existingCount: number = (
+      await this.countBy({
+        query: {
+          projectId: projectId,
+          userId: userId,
+        },
+        props: {
+          isRoot: true,
+        },
+      })
+    ).toNumber();
+
+    if (existingCount > 0) {
+      throw new BadDataException(
+        "Microsoft Teams is already added as a notification method for this project.",
+      );
+    }
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.getProjectAuth({
+        projectId: projectId,
+        workspaceType: WorkspaceType.MicrosoftTeams,
+      });
+
+    if (!projectAuth || !projectAuth.authToken) {
+      throw new BadDataException(
+        "This project is not connected to Microsoft Teams. Please ask a project admin to connect Microsoft Teams in Project Settings > Microsoft Teams Integration.",
+      );
+    }
+
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.getUserAuth({
+        projectId: projectId,
+        userId: userId,
+        workspaceType: WorkspaceType.MicrosoftTeams,
+      });
+
+    if (!userAuth || !userAuth.workspaceUserId) {
+      throw new BadDataException(
+        "Your Microsoft Teams account is not connected to OneUptime for this project. Please go to User Settings > Microsoft Teams Integration and connect your Microsoft Teams account first.",
+      );
+    }
+
+    createBy.data.microsoftTeamsUserId = userAuth.workspaceUserId;
+    createBy.data.isVerified = true;
+
+    /* Display label only — captured when the user linked their account. */
+    const displayName: string | undefined = (
+      userAuth.miscData as JSONObject | undefined
+    )?.["displayName"] as string | undefined;
+
+    if (displayName) {
+      createBy.data.microsoftTeamsUserName = displayName;
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    /*
+     * The row is born verified (creation is gated on the live workspace
+     * link), so default on-call rules are seeded at create time — same as
+     * webhooks.
+     */
+    if (createdItem.projectId && createdItem.userId && createdItem.id) {
+      try {
+        await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+          {
+            projectId: createdItem.projectId,
+            userId: createdItem.userId,
+            notificationMethod: {
+              userMicrosoftTeamsId: createdItem.id,
+            },
+          },
+        );
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
+    return createdItem;
+  }
+}
+
+export default new Service();

package/Server/Services/UserNotificationMethodAdminService.ts

@@ -17,6 +17,8 @@ import UserPushService from "./UserPushService";
 import UserService from "./UserService";
 import UserSmsService from "./UserSmsService";
 import UserTelegramService from "./UserTelegramService";
+import UserSlackService from "./UserSlackService";
+import UserMicrosoftTeamsService from "./UserMicrosoftTeamsService";
 import UserWebhookService from "./UserWebhookService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import type AuditLogServiceType from "./AuditLogService";
@@ -42,6 +44,8 @@ import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserPush from "../../Models/DatabaseModels/UserPush";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
+import UserSlack from "../../Models/DatabaseModels/UserSlack";
+import UserMicrosoftTeams from "../../Models/DatabaseModels/UserMicrosoftTeams";
 import UserWebhook from "../../Models/DatabaseModels/UserWebhook";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 
@@ -66,7 +70,8 @@ import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
  * filters, sort columns appended after the guard had run. The models are still
  * CurrentUser-only. Nothing in this file changes that, and an administrator's
  * every direct read or write of UserEmail, UserSMS, UserCall, UserWhatsApp,
- * UserTelegram, UserPush and UserWebhook is still refused.
+ * UserTelegram, UserSlack, UserMicrosoftTeams, UserPush and UserWebhook is
+ * still refused.
  *
  * What this file does instead is a NARROW, SERVER-SIDE, AUDITED capability
  * that runs as root on the admin's behalf and never hands them the row:
@@ -88,7 +93,7 @@ import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
  *     notification methods page as an unverified method they did not add — on
  *     top of the mail this service sends them.
  *
- *   - REMOVE is allowed on all seven channels, because offboarding a stale
+ *   - REMOVE is allowed on all nine channels, because offboarding a stale
  *     device is a real administrative job and the owner may well be gone. It is
  *     the destructive direction, so it is the one with a preview attached:
  *     UserNotificationRuleService.getNotificationMethodDeletionImpact says how
@@ -100,7 +105,10 @@ import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
  *     omissions are not oversights. Push is a device token minted by a browser
  *     or a phone at registration time; there is nothing an admin could type.
  *     Telegram needs the account holder to message the bot before a chat id
- *     exists. Webhook is the one that is deliberately refused rather than
+ *     exists. Slack and Microsoft Teams are pointers at the owner's own OAuth
+ *     workspace link, which only the owner can establish — and an admin-created
+ *     row would be live immediately, since creation is verification for those
+ *     two. Webhook is the one that is deliberately refused rather than
  *     merely impractical: UserWebhook has no isVerified column at all, so an
  *     admin-created webhook would be live the moment it was written, which is
  *     exactly the silent-redirect this whole design is built to prevent.
@@ -139,7 +147,7 @@ export interface AdminNotificationMethodView {
 
 /**
  * The four channels an administrator may CREATE. See the header for why the
- * other three are absent; this enum is the single place that decides, and both
+ * other five are absent; this enum is the single place that decides, and both
  * the API's validation and the service's own dispatch read it.
  */
 export enum AdminAddableChannel {
@@ -751,6 +759,160 @@ export class UserNotificationMethodAdminService extends BaseService {
           });
         },
       },
+      {
+        methodType: ReadinessMethodType.Slack,
+        isAdminAddable: false,
+        modelType: UserSlack,
+        list: async (data: {
+          projectId: ObjectID;
+          userId: ObjectID;
+        }): Promise<Array<AdminNotificationMethodView>> => {
+          const rows: Array<UserSlack> = await UserSlackService.findBy({
+            query: { projectId: data.projectId, userId: data.userId },
+            /*
+             * The username only — never slackUserId, which is the addressable
+             * target the bot sends to. Same rule OnCallReadinessService
+             * follows.
+             */
+            select: {
+              _id: true,
+              slackUserName: true,
+              isVerified: true,
+              createdAt: true,
+            },
+            sort: { createdAt: SortOrder.Ascending },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: { isRoot: true },
+          });
+
+          return rows.map((row: UserSlack): AdminNotificationMethodView => {
+            return this.toView({
+              row: row,
+              methodType: ReadinessMethodType.Slack,
+              isAdminAddable: false,
+              identifier: row.slackUserName,
+              kind: MaskedIdentifierKind.Handle,
+              isVerified: row.isVerified,
+            });
+          });
+        },
+        findOwnedRow: async (data: {
+          methodId: ObjectID;
+          projectId: ObjectID;
+          userId: ObjectID;
+        }): Promise<AdminNotificationMethodView | null> => {
+          const row: UserSlack | null = await UserSlackService.findOneBy({
+            query: {
+              _id: data.methodId,
+              projectId: data.projectId,
+              userId: data.userId,
+            },
+            select: {
+              _id: true,
+              slackUserName: true,
+              isVerified: true,
+            },
+            props: { isRoot: true },
+          });
+
+          return row
+            ? this.toView({
+                row: row,
+                methodType: ReadinessMethodType.Slack,
+                isAdminAddable: false,
+                identifier: row.slackUserName,
+                kind: MaskedIdentifierKind.Handle,
+                isVerified: row.isVerified,
+              })
+            : null;
+        },
+        deleteRow: async (data: { methodId: ObjectID }): Promise<void> => {
+          await UserSlackService.deleteOneById({
+            id: data.methodId,
+            props: { isRoot: true },
+          });
+        },
+      },
+      {
+        methodType: ReadinessMethodType.MicrosoftTeams,
+        isAdminAddable: false,
+        modelType: UserMicrosoftTeams,
+        list: async (data: {
+          projectId: ObjectID;
+          userId: ObjectID;
+        }): Promise<Array<AdminNotificationMethodView>> => {
+          const rows: Array<UserMicrosoftTeams> =
+            await UserMicrosoftTeamsService.findBy({
+              query: { projectId: data.projectId, userId: data.userId },
+              /*
+               * The display name only — never microsoftTeamsUserId, which is
+               * the addressable target the bot sends to. Same rule
+               * OnCallReadinessService follows.
+               */
+              select: {
+                _id: true,
+                microsoftTeamsUserName: true,
+                isVerified: true,
+                createdAt: true,
+              },
+              sort: { createdAt: SortOrder.Ascending },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: { isRoot: true },
+            });
+
+          return rows.map(
+            (row: UserMicrosoftTeams): AdminNotificationMethodView => {
+              return this.toView({
+                row: row,
+                methodType: ReadinessMethodType.MicrosoftTeams,
+                isAdminAddable: false,
+                identifier: row.microsoftTeamsUserName,
+                kind: MaskedIdentifierKind.Handle,
+                isVerified: row.isVerified,
+              });
+            },
+          );
+        },
+        findOwnedRow: async (data: {
+          methodId: ObjectID;
+          projectId: ObjectID;
+          userId: ObjectID;
+        }): Promise<AdminNotificationMethodView | null> => {
+          const row: UserMicrosoftTeams | null =
+            await UserMicrosoftTeamsService.findOneBy({
+              query: {
+                _id: data.methodId,
+                projectId: data.projectId,
+                userId: data.userId,
+              },
+              select: {
+                _id: true,
+                microsoftTeamsUserName: true,
+                isVerified: true,
+              },
+              props: { isRoot: true },
+            });
+
+          return row
+            ? this.toView({
+                row: row,
+                methodType: ReadinessMethodType.MicrosoftTeams,
+                isAdminAddable: false,
+                identifier: row.microsoftTeamsUserName,
+                kind: MaskedIdentifierKind.Handle,
+                isVerified: row.isVerified,
+              })
+            : null;
+        },
+        deleteRow: async (data: { methodId: ObjectID }): Promise<void> => {
+          await UserMicrosoftTeamsService.deleteOneById({
+            id: data.methodId,
+            props: { isRoot: true },
+          });
+        },
+      },
       {
         methodType: ReadinessMethodType.Webhook,
         isAdminAddable: false,
@@ -966,7 +1128,7 @@ export class UserNotificationMethodAdminService extends BaseService {
        * the feature to somebody probing it.
        */
       throw new BadDataException(
-        `A project administrator can only add Email, SMS, Call and WhatsApp notification methods for another user. Push, Telegram and webhook methods have to be added by the person who owns the device.`,
+        `A project administrator can only add Email, SMS, Call and WhatsApp notification methods for another user. Push, Telegram, Slack, Microsoft Teams and webhook methods have to be added by the person who owns the device or account.`,
       );
     }