@oneuptime/common 7.0.3035 → 7.0.3038

package/Server/Infrastructure/Postgres/SchemaMigrations/1725881475134-MigrationName.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725881475134 implements MigrationInterface {
+  public name = "MigrationName1725881475134";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "templateName" character varying(100) NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "templateDescription" character varying(500) NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "templateDescription"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "templateName"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1725884177663-MigrationName.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725884177663 implements MigrationInterface {
+  public name = "MigrationName1725884177663";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP CONSTRAINT "FK_aea47be8b8af9673e9639e7dae3"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_aea47be8b8af9673e9639e7dae"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "currentScheduledMaintenanceStateId"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "currentScheduledMaintenanceStateId" uuid NOT NULL`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_aea47be8b8af9673e9639e7dae" ON "ScheduledMaintenanceTemplate" ("currentScheduledMaintenanceStateId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD CONSTRAINT "FK_aea47be8b8af9673e9639e7dae3" FOREIGN KEY ("currentScheduledMaintenanceStateId") REFERENCES "ScheduledMaintenanceState"("_id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1725898621366-MigrationName.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725898621366 implements MigrationInterface {
+  public name = "MigrationName1725898621366";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "isRecurringEvent" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ALTER COLUMN "startsAt" DROP NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ALTER COLUMN "endsAt" DROP NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ALTER COLUMN "endsAt" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ALTER COLUMN "startsAt" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "isRecurringEvent"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1725900315712-MigrationName.ts

@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725900315712 implements MigrationInterface {
+  public name = "MigrationName1725900315712";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "startsAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "endsAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "firstEventScheduledAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "firstEventStartsAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "firstEventEndsAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "scheduleNextEventAt" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "scheduleNextEventAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "firstEventEndsAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "firstEventStartsAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "firstEventScheduledAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "endsAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "startsAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1725901024444-MigrationName.ts

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725901024444 implements MigrationInterface {
+  public name = "MigrationName1725901024444";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "scheduleNextEventAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "scheduleNextEventAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" DROP COLUMN "scheduleNextEventAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceTemplate" ADD "scheduleNextEventAt" boolean NOT NULL`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -51,6 +51,13 @@ import { MigrationName1725379949648 } from "./1725379949648-MigrationName";
 import { MigrationName1725551629492 } from "./1725551629492-MigrationName";
 import { MigrationName1725556630384 } from "./1725556630384-MigrationName";
 import { MigrationName1725618842598 } from "./1725618842598-MigrationName";
+import { MigrationName1725880508430 } from "./1725880508430-MigrationName";
+import { MigrationName1725881099935 } from "./1725881099935-MigrationName";
+import { MigrationName1725881475134 } from "./1725881475134-MigrationName";
+import { MigrationName1725884177663 } from "./1725884177663-MigrationName";
+import { MigrationName1725898621366 } from "./1725898621366-MigrationName";
+import { MigrationName1725900315712 } from "./1725900315712-MigrationName";
+import { MigrationName1725901024444 } from "./1725901024444-MigrationName";
 
 export default [
   InitialMigration,
@@ -106,4 +113,11 @@ export default [
   MigrationName1725551629492,
   MigrationName1725556630384,
   MigrationName1725618842598,
+  MigrationName1725880508430,
+  MigrationName1725881099935,
+  MigrationName1725881475134,
+  MigrationName1725884177663,
+  MigrationName1725898621366,
+  MigrationName1725900315712,
+  MigrationName1725901024444,
 ];

package/Server/Services/Index.ts

@@ -133,6 +133,9 @@ import TelemetryAttributeService from "./TelemetryAttributeService";
 import TelemetryExceptionService from "./TelemetryExceptionService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
 import CopilotActionTypePriorityService from "./CopilotActionTypePriorityService";
+import ScheduledMaintenanceTemplateService from "./ScheduledMaintenanceTemplateService";
+import ScheduledMaintenanceTemplateOwnerTeamService from "./ScheduledMaintenanceTemplateOwnerTeamService";
+import ScheduledMaintenanceTemplateOwnerUserService from "./ScheduledMaintenanceTemplateOwnerUserService";
 
 const services: Array<BaseService> = [
   AcmeCertificateService,
@@ -277,6 +280,11 @@ const services: Array<BaseService> = [
   CopilotActionTypePriorityService,
 
   TelemetryExceptionService,
+
+  // scheduled maintenance templates
+  ScheduledMaintenanceTemplateService,
+  ScheduledMaintenanceTemplateOwnerTeamService,
+  ScheduledMaintenanceTemplateOwnerUserService,
 ];
 
 export const AnalyticsServices: Array<

package/Server/Services/ScheduledMaintenanceService.ts

@@ -76,7 +76,7 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
-    if (!createBy.props.tenantId) {
+    if (!createBy.props.tenantId && !createBy.data.projectId) {
       throw new BadDataException(
         "ProjectId required to create scheduled maintenane.",
       );

package/Server/Services/ScheduledMaintenanceTemplateOwnerTeamService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerTeam";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceTemplateOwnerUserService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerUser";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceTemplateService.ts

@@ -0,0 +1,318 @@
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import ScheduledMaintenanceTemplateOwnerTeamService from "./ScheduledMaintenanceTemplateOwnerTeamService";
+import ScheduledMaintenanceTemplateOwnerUserService from "./ScheduledMaintenanceTemplateOwnerUserService";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import ObjectID from "../../Types/ObjectID";
+import Typeof from "../../Types/Typeof";
+import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplate";
+import ScheduledMaintenanceTemplateOwnerTeam from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerTeam";
+import ScheduledMaintenanceTemplateOwnerUser from "Common/Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerUser";
+import CreateBy from "../Types/Database/CreateBy";
+import OneUptimeDate from "../../Types/Date";
+import Recurring from "../../Types/Events/Recurring";
+import UpdateBy from "../Types/Database/UpdateBy";
+import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public validateEventTemplate(template: Model): void {
+    // if recurring then start, end, scheduled time should not be null and all of them should be in the future.
+    if (template.isRecurringEvent) {
+      const startDate: Date | undefined = template.firstEventStartsAt;
+      const endDate: Date | undefined = template.firstEventEndsAt;
+      const scheduledTime: Date | undefined = template.firstEventScheduledAt;
+
+      if (!startDate) {
+        throw new BadDataException(
+          "Start date is required for recurring events.",
+        );
+      }
+
+      if (!endDate) {
+        throw new BadDataException(
+          "End date is required for recurring events.",
+        );
+      }
+
+      if (!scheduledTime) {
+        throw new BadDataException(
+          "Scheduled time is required for recurring events.",
+        );
+      }
+
+      // check if all dates are in the future.
+
+      if (OneUptimeDate.isInTheFuture(startDate) === false) {
+        throw new BadDataException("Start date should be in the future.");
+      }
+
+      if (OneUptimeDate.isInTheFuture(endDate) === false) {
+        throw new BadDataException("End date should be in the future.");
+      }
+
+      if (OneUptimeDate.isInTheFuture(scheduledTime) === false) {
+        throw new BadDataException("Scheduled time should be in the future.");
+      }
+
+      // make sure scheduedDate is < start date
+      if (!OneUptimeDate.isBefore(scheduledTime, startDate)) {
+        throw new BadDataException(
+          "Scheduled time should be less than start date.",
+        );
+      }
+
+      // make sure scheduledDate is < end date
+
+      if (!OneUptimeDate.isBefore(scheduledTime, endDate)) {
+        throw new BadDataException(
+          "Scheduled time should be less than end date.",
+        );
+      }
+
+      // make sure start date is < end date
+
+      if (!OneUptimeDate.isBefore(startDate, endDate)) {
+        throw new BadDataException("Start date should be less than end date.");
+      }
+
+      // check recurring internval
+
+      if (template.recurringInterval === undefined) {
+        throw new BadDataException(
+          "Recurring interval is required for recurring events.",
+        );
+      }
+    }
+  }
+
+  public getNextEventTime(data: {
+    dateAndTime: Date;
+    recurringInterval: Recurring;
+  }): Date {
+    // check if firstScheduledAt is in the future, and if yes return that.
+
+    if (OneUptimeDate.isInTheFuture(data.dateAndTime)) {
+      return data.dateAndTime;
+    }
+
+    // if not then calculate the next event time.
+
+    return Recurring.getNextDate(data.dateAndTime, data.recurringInterval);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateEventTemplate(createBy.data);
+
+    if (createBy.data.isRecurringEvent) {
+      // if all is good then the next scheduled at time should be set.
+      createBy.data.scheduleNextEventAt = this.getNextEventTime({
+        dateAndTime: createBy.data.firstEventScheduledAt!,
+        recurringInterval: createBy.data.recurringInterval!,
+      });
+    }
+
+    return {
+      createBy: createBy,
+      carryForward: false,
+    };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const newTemplate: QueryDeepPartialEntity<Model> = updateBy.data;
+
+    const existingTemplates: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        _id: true,
+        isRecurringEvent: true,
+        firstEventScheduledAt: true,
+        recurringInterval: true,
+        firstEventEndsAt: true,
+        firstEventStartsAt: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const template of existingTemplates) {
+      let isRecurring: boolean = Boolean(template.isRecurringEvent);
+
+      if (Object.keys(newTemplate).includes("isRecurringEvent")) {
+        isRecurring = newTemplate.isRecurringEvent as boolean;
+      }
+
+      let firstEventScheduledAt: Date | undefined =
+        template.firstEventScheduledAt;
+
+      if (Object.keys(newTemplate).includes("firstEventScheduledAt")) {
+        firstEventScheduledAt = newTemplate.firstEventScheduledAt as Date;
+      }
+
+      let recurringInterval: Recurring | undefined = template.recurringInterval;
+
+      if (Object.keys(newTemplate).includes("recurringInterval")) {
+        recurringInterval = newTemplate.recurringInterval as Recurring;
+      }
+
+      let firstEventEndsAt: Date | undefined = template.firstEventEndsAt;
+
+      if (Object.keys(newTemplate).includes("firstEventEndsAt")) {
+        firstEventEndsAt = newTemplate.firstEventEndsAt as Date;
+      }
+
+      let firstEventStartsAt: Date | undefined = template.firstEventStartsAt;
+
+      if (Object.keys(newTemplate).includes("firstEventStartsAt")) {
+        firstEventStartsAt = newTemplate.firstEventStartsAt as Date;
+      }
+
+      if (isRecurring) {
+        // make sure all are not null.
+
+        if (!firstEventScheduledAt) {
+          throw new BadDataException(
+            "First event scheduled at is required for recurring events.",
+          );
+        }
+
+        if (!recurringInterval) {
+          throw new BadDataException(
+            "Recurring interval is required for recurring events.",
+          );
+        }
+
+        if (!firstEventEndsAt) {
+          throw new BadDataException(
+            "First event ends at is required for recurring events.",
+          );
+        }
+
+        if (!firstEventStartsAt) {
+          throw new BadDataException(
+            "First event starts at is required for recurring events.",
+          );
+        }
+
+        // make sure scheduedDate is < start date
+        if (
+          !OneUptimeDate.isBefore(firstEventScheduledAt, firstEventStartsAt)
+        ) {
+          throw new BadDataException(
+            "Scheduled time should be less than start date.",
+          );
+        }
+
+        // make sure scheduledDate is < end date
+
+        if (!OneUptimeDate.isBefore(firstEventScheduledAt, firstEventEndsAt)) {
+          throw new BadDataException(
+            "Scheduled time should be less than end date.",
+          );
+        }
+
+        // make sure start date is < end date
+
+        if (!OneUptimeDate.isBefore(firstEventStartsAt, firstEventEndsAt)) {
+          throw new BadDataException(
+            "Start date should be less than end date.",
+          );
+        }
+
+        // now get next interval time.
+
+        newTemplate.scheduleNextEventAt = this.getNextEventTime({
+          dateAndTime: firstEventScheduledAt,
+          recurringInterval: recurringInterval,
+        });
+      }
+    }
+
+    updateBy.data = newTemplate;
+
+    return {
+      updateBy: updateBy,
+      carryForward: false,
+    };
+  }
+
+  protected override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add owners.
+
+    if (
+      createdItem.projectId &&
+      createdItem.id &&
+      onCreate.createBy.miscDataProps &&
+      (onCreate.createBy.miscDataProps["ownerTeams"] ||
+        onCreate.createBy.miscDataProps["ownerUsers"])
+    ) {
+      await this.addOwners(
+        createdItem.projectId,
+        createdItem.id,
+        (onCreate.createBy.miscDataProps["ownerUsers"] as Array<ObjectID>) ||
+          [],
+        (onCreate.createBy.miscDataProps["ownerTeams"] as Array<ObjectID>) ||
+          [],
+        onCreate.createBy.props,
+      );
+    }
+
+    return createdItem;
+  }
+
+  public async addOwners(
+    projectId: ObjectID,
+    scheduledMaintenanceTemplateId: ObjectID,
+    userIds: Array<ObjectID>,
+    teamIds: Array<ObjectID>,
+    props: DatabaseCommonInteractionProps,
+  ): Promise<void> {
+    for (let teamId of teamIds) {
+      if (typeof teamId === Typeof.String) {
+        teamId = new ObjectID(teamId.toString());
+      }
+
+      const teamOwner: ScheduledMaintenanceTemplateOwnerTeam =
+        new ScheduledMaintenanceTemplateOwnerTeam();
+      teamOwner.scheduledMaintenanceTemplateId = scheduledMaintenanceTemplateId;
+      teamOwner.projectId = projectId;
+      teamOwner.teamId = teamId;
+
+      await ScheduledMaintenanceTemplateOwnerTeamService.create({
+        data: teamOwner,
+        props: props,
+      });
+    }
+
+    for (let userId of userIds) {
+      if (typeof userId === Typeof.String) {
+        userId = new ObjectID(userId.toString());
+      }
+      const teamOwner: ScheduledMaintenanceTemplateOwnerUser =
+        new ScheduledMaintenanceTemplateOwnerUser();
+      teamOwner.scheduledMaintenanceTemplateId = scheduledMaintenanceTemplateId;
+      teamOwner.projectId = projectId;
+      teamOwner.userId = userId;
+      await ScheduledMaintenanceTemplateOwnerUserService.create({
+        data: teamOwner,
+        props: props,
+      });
+    }
+  }
+}
+export default new Service();