@oneuptime/common 7.0.2928 → 7.0.2972

package/build/dist/Server/Services/ProjectService.js

@@ -0,0 +1,854 @@
+import { IsBillingEnabled, getAllEnvVars } from "../EnvironmentConfig";
+import AllMeteredPlans from "../Types/Billing/MeteredPlan/AllMeteredPlans";
+import QueryHelper from "../Types/Database/QueryHelper";
+import logger from "../Utils/Logger";
+import AccessTokenService from "./AccessTokenService";
+import BillingService from "./BillingService";
+import DatabaseService from "./DatabaseService";
+import IncidentSeverityService from "./IncidentSeverityService";
+import IncidentStateService from "./IncidentStateService";
+import MailService from "./MailService";
+import MonitorStatusService from "./MonitorStatusService";
+import NotificationService from "./NotificationService";
+import PromoCodeService from "./PromoCodeService";
+import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
+import TeamMemberService from "./TeamMemberService";
+import TeamPermissionService from "./TeamPermissionService";
+import TeamService from "./TeamService";
+import UserNotificationRuleService from "./UserNotificationRuleService";
+import UserNotificationSettingService from "./UserNotificationSettingService";
+import UserService from "./UserService";
+import SubscriptionPlan from "../../Types/Billing/SubscriptionPlan";
+import { Black, Green, Moroon500, Red, Yellow } from "../../Types/BrandColors";
+import Color from "../../Types/Color";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import OneUptimeDate from "../../Types/Date";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import BadDataException from "../../Types/Exception/BadDataException";
+import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import IncidentSeverity from "Common/Models/DatabaseModels/IncidentSeverity";
+import IncidentState from "Common/Models/DatabaseModels/IncidentState";
+import MonitorStatus from "Common/Models/DatabaseModels/MonitorStatus";
+import Model from "Common/Models/DatabaseModels/Project";
+import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
+import Team from "Common/Models/DatabaseModels/Team";
+import TeamMember from "Common/Models/DatabaseModels/TeamMember";
+import TeamPermission from "Common/Models/DatabaseModels/TeamPermission";
+import { In } from "typeorm";
+export class ProjectService extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    getPlanType(planId) {
+        if (!SubscriptionPlan.isValidPlanId(planId, getAllEnvVars())) {
+            throw new BadDataException("Plan is invalid.");
+        }
+        return SubscriptionPlan.getPlanType(planId);
+    }
+    async onBeforeCreate(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!data.data.name) {
+            throw new BadDataException("Project name is required");
+        }
+        if (data.props.userId) {
+            data.data.createdByUserId = data.props.userId;
+        }
+        else {
+            throw new NotAuthorizedException("User should be logged in to create the project.");
+        }
+        const user = await UserService.findOneById({
+            id: data.props.userId,
+            select: {
+                name: true,
+                email: true,
+                companyPhoneNumber: true,
+                companyName: true,
+                utmCampaign: true,
+                utmSource: true,
+                utmMedium: true,
+                utmTerm: true,
+                utmContent: true,
+                utmUrl: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!user) {
+            throw new BadDataException("User not found.");
+        }
+        if (IsBillingEnabled) {
+            if (!data.data.paymentProviderPlanId) {
+                throw new BadDataException("Plan required to create the project.");
+            }
+            data.data.planName = this.getPlanType(data.data.paymentProviderPlanId);
+            if (data.data.paymentProviderPromoCode) {
+                // check if it exists in promcode table. Not all promocodes are in the table, only reseller ones are.
+                // If they are not in the table, allow projetc creation to proceed.
+                // If they are in the project table, then see if anyn restrictions on reseller plan apply and if it does,
+                // apply those restictions to the project.
+                const promoCode = await PromoCodeService.findOneBy({
+                    query: {
+                        promoCodeId: data.data.paymentProviderPromoCode,
+                    },
+                    select: {
+                        isPromoCodeUsed: true,
+                        userEmail: true,
+                        resellerPlan: {
+                            _id: true,
+                            planType: true,
+                            monitorLimit: true,
+                            teamMemberLimit: true,
+                        },
+                        resellerId: true,
+                        resellerLicenseId: true,
+                        planType: true,
+                        resellerPlanId: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (promoCode) {
+                    // check if the same user is creating the project.
+                    if (((_a = promoCode.userEmail) === null || _a === void 0 ? void 0 : _a.toString()) !== ((_b = user.email) === null || _b === void 0 ? void 0 : _b.toString())) {
+                        throw new BadDataException("This promocode is assigned to a different user and cannot be used.");
+                    }
+                    if (promoCode.isPromoCodeUsed) {
+                        throw new BadDataException("This promocode has already been used.");
+                    }
+                    if ((_c = promoCode.resellerPlan) === null || _c === void 0 ? void 0 : _c.monitorLimit) {
+                        data.data.activeMonitorsLimit =
+                            (_d = promoCode.resellerPlan) === null || _d === void 0 ? void 0 : _d.monitorLimit;
+                    }
+                    if ((_e = promoCode.resellerPlan) === null || _e === void 0 ? void 0 : _e.teamMemberLimit) {
+                        data.data.seatLimit = (_f = promoCode.resellerPlan) === null || _f === void 0 ? void 0 : _f.teamMemberLimit;
+                    }
+                    if (promoCode.planType !== data.data.planName) {
+                        throw new BadDataException("Promocode is not valid for this plan. Please select the " +
+                            promoCode.planType +
+                            " plan.");
+                    }
+                    if (promoCode.resellerLicenseId) {
+                        data.data.resellerLicenseId = promoCode.resellerLicenseId;
+                    }
+                    if (promoCode.resellerId) {
+                        data.data.resellerId = promoCode.resellerId;
+                    }
+                    if (promoCode.resellerPlanId) {
+                        data.data.resellerPlanId = promoCode.resellerPlanId;
+                    }
+                }
+            }
+            if (data.data.paymentProviderPromoCode &&
+                !(await BillingService.isPromoCodeValid(data.data.paymentProviderPromoCode))) {
+                throw new BadDataException("Promo code is invalid.");
+            }
+            // check if promocode is valid.
+        }
+        // check if the user has the project with the same name. If yes, reject.
+        let existingProjectWithSameNameCount = 0;
+        if (data.props.userGlobalAccessPermission &&
+            ((_g = data.props.userGlobalAccessPermission) === null || _g === void 0 ? void 0 : _g.projectIds.length) > 0) {
+            existingProjectWithSameNameCount = (await this.countBy({
+                query: {
+                    _id: QueryHelper.any(((_h = data.props.userGlobalAccessPermission) === null || _h === void 0 ? void 0 : _h.projectIds.map((item) => {
+                        return item.toString();
+                    })) || []),
+                    name: QueryHelper.findWithSameText(data.data.name),
+                },
+                props: {
+                    isRoot: true,
+                },
+            })).toNumber();
+        }
+        if (existingProjectWithSameNameCount > 0) {
+            throw new BadDataException("Project with the same name already exists");
+        }
+        data.data.createdOwnerName = user.name;
+        data.data.createdOwnerEmail = user.email;
+        data.data.createdOwnerPhone = user.companyPhoneNumber;
+        data.data.createdOwnerCompanyName = user.companyName;
+        // UTM info.
+        data.data.utmCampaign = user.utmCampaign;
+        data.data.utmSource = user.utmSource;
+        data.data.utmMedium = user.utmMedium;
+        data.data.utmTerm = user.utmTerm;
+        data.data.utmContent = user.utmContent;
+        data.data.utmUrl = user.utmUrl;
+        return Promise.resolve({ createBy: data, carryForward: null });
+    }
+    async onBeforeUpdate(updateBy) {
+        var _a, _b, _c, _d;
+        if (IsBillingEnabled) {
+            if (updateBy.data.enableAutoRechargeSmsOrCallBalance) {
+                await NotificationService.rechargeIfBalanceIsLow(new ObjectID(updateBy.query._id), {
+                    autoRechargeSmsOrCallByBalanceInUSD: updateBy.data
+                        .autoRechargeSmsOrCallByBalanceInUSD,
+                    autoRechargeSmsOrCallWhenCurrentBalanceFallsInUSD: updateBy.data
+                        .autoRechargeSmsOrCallWhenCurrentBalanceFallsInUSD,
+                    enableAutoRechargeSmsOrCallBalance: updateBy.data
+                        .enableAutoRechargeSmsOrCallBalance,
+                });
+            }
+            if (updateBy.data.paymentProviderPlanId) {
+                // payment provider id changed.
+                const project = await this.findOneById({
+                    id: new ObjectID(updateBy.query._id),
+                    select: {
+                        paymentProviderSubscriptionId: true,
+                        paymentProviderMeteredSubscriptionId: true,
+                        paymentProviderSubscriptionSeats: true,
+                        paymentProviderPlanId: true,
+                        trialEndsAt: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (!project) {
+                    throw new BadDataException("Project not found");
+                }
+                if (project.paymentProviderPlanId !== updateBy.data.paymentProviderPlanId) {
+                    logger.debug("Changing plan for project " + project.id);
+                    const plan = SubscriptionPlan.getSubscriptionPlanById(updateBy.data.paymentProviderPlanId, getAllEnvVars());
+                    if (!plan) {
+                        throw new BadDataException("Invalid plan");
+                    }
+                    logger.debug("Changing plan for project " +
+                        ((_a = project.id) === null || _a === void 0 ? void 0 : _a.toString()) +
+                        " to " +
+                        plan.getName());
+                    if (!project.paymentProviderSubscriptionSeats) {
+                        project.paymentProviderSubscriptionSeats =
+                            await TeamMemberService.getUniqueTeamMemberCountInProject(project.id);
+                    }
+                    logger.debug("Changing plan for project " +
+                        ((_b = project.id) === null || _b === void 0 ? void 0 : _b.toString()) +
+                        " to " +
+                        plan.getName() +
+                        " with seats " +
+                        project.paymentProviderSubscriptionSeats);
+                    const subscription = await BillingService.changePlan({
+                        projectId: project.id,
+                        subscriptionId: project.paymentProviderSubscriptionId,
+                        meteredSubscriptionId: project.paymentProviderMeteredSubscriptionId,
+                        serverMeteredPlans: AllMeteredPlans,
+                        newPlan: plan,
+                        quantity: project.paymentProviderSubscriptionSeats,
+                        isYearly: plan.getYearlyPlanId() === updateBy.data.paymentProviderPlanId,
+                        endTrialAt: project.trialEndsAt,
+                    });
+                    logger.debug("Changing plan for project " +
+                        ((_c = project.id) === null || _c === void 0 ? void 0 : _c.toString()) +
+                        " to " +
+                        plan.getName() +
+                        " with seats " +
+                        project.paymentProviderSubscriptionSeats +
+                        " completed.");
+                    await this.updateOneById({
+                        id: new ObjectID(updateBy.query._id),
+                        data: {
+                            paymentProviderSubscriptionId: subscription.subscriptionId,
+                            paymentProviderMeteredSubscriptionId: subscription.meteredSubscriptionId,
+                            trialEndsAt: subscription.trialEndsAt || new Date(),
+                            planName: SubscriptionPlan.getPlanType(updateBy.data.paymentProviderPlanId),
+                        },
+                        props: {
+                            isRoot: true,
+                            ignoreHooks: true,
+                        },
+                    });
+                    logger.debug("Changing plan for project " +
+                        ((_d = project.id) === null || _d === void 0 ? void 0 : _d.toString()) +
+                        " to " +
+                        plan.getName() +
+                        " with seats " +
+                        project.paymentProviderSubscriptionSeats +
+                        " completed and project updated.");
+                }
+            }
+        }
+        return { updateBy, carryForward: [] };
+    }
+    async addDefaultScheduledMaintenanceState(createdItem) {
+        let createdScheduledMaintenanceState = new ScheduledMaintenanceState();
+        createdScheduledMaintenanceState.name = "Scheduled";
+        createdScheduledMaintenanceState.description =
+            "When an event is scheduled, it belongs to this state";
+        createdScheduledMaintenanceState.color = Black;
+        createdScheduledMaintenanceState.isScheduledState = true;
+        createdScheduledMaintenanceState.projectId = createdItem.id;
+        createdScheduledMaintenanceState.order = 1;
+        createdScheduledMaintenanceState =
+            await ScheduledMaintenanceStateService.create({
+                data: createdScheduledMaintenanceState,
+                props: {
+                    isRoot: true,
+                },
+            });
+        let ongoingScheduledMaintenanceState = new ScheduledMaintenanceState();
+        ongoingScheduledMaintenanceState.name = "Ongoing";
+        ongoingScheduledMaintenanceState.description =
+            "When an event is ongoing, it belongs to this state.";
+        ongoingScheduledMaintenanceState.color = Yellow;
+        ongoingScheduledMaintenanceState.isOngoingState = true;
+        ongoingScheduledMaintenanceState.projectId = createdItem.id;
+        ongoingScheduledMaintenanceState.order = 2;
+        ongoingScheduledMaintenanceState =
+            await ScheduledMaintenanceStateService.create({
+                data: ongoingScheduledMaintenanceState,
+                props: {
+                    isRoot: true,
+                },
+            });
+        let endedScheduledMaintenanceState = new ScheduledMaintenanceState();
+        endedScheduledMaintenanceState.name = "Ended";
+        endedScheduledMaintenanceState.description =
+            "Scheduled maintenance events switch to this state when they end.";
+        endedScheduledMaintenanceState.color = new Color("#4A4A4A");
+        endedScheduledMaintenanceState.isEndedState = true;
+        endedScheduledMaintenanceState.projectId = createdItem.id;
+        endedScheduledMaintenanceState.order = 3;
+        endedScheduledMaintenanceState =
+            await ScheduledMaintenanceStateService.create({
+                data: endedScheduledMaintenanceState,
+                props: {
+                    isRoot: true,
+                },
+            });
+        let completedScheduledMaintenanceState = new ScheduledMaintenanceState();
+        completedScheduledMaintenanceState.name = "Completed";
+        completedScheduledMaintenanceState.description =
+            "When an event is completed, it belongs to this state.";
+        completedScheduledMaintenanceState.color = Green;
+        completedScheduledMaintenanceState.isResolvedState = true;
+        completedScheduledMaintenanceState.projectId = createdItem.id;
+        completedScheduledMaintenanceState.order = 4;
+        completedScheduledMaintenanceState =
+            await ScheduledMaintenanceStateService.create({
+                data: completedScheduledMaintenanceState,
+                props: {
+                    isRoot: true,
+                },
+            });
+        return createdItem;
+    }
+    async onCreateSuccess(_onCreate, createdItem) {
+        // Create billing.
+        if (IsBillingEnabled) {
+            const customerId = await BillingService.createCustomer({
+                name: createdItem.name,
+                email: createdItem.createdOwnerEmail,
+                id: createdItem.id,
+            });
+            const plan = SubscriptionPlan.getSubscriptionPlanById(createdItem.paymentProviderPlanId, getAllEnvVars());
+            if (!plan) {
+                throw new BadDataException("Invalid plan.");
+            }
+            // add subscription to this customer.
+            const { subscriptionId, meteredSubscriptionId, trialEndsAt } = await BillingService.subscribeToPlan({
+                projectId: createdItem.id,
+                customerId,
+                serverMeteredPlans: AllMeteredPlans,
+                plan,
+                quantity: 1,
+                isYearly: plan.getYearlyPlanId() === createdItem.paymentProviderPlanId,
+                trial: true,
+                promoCode: createdItem.paymentProviderPromoCode,
+            });
+            await this.updateOneById({
+                id: createdItem.id,
+                data: {
+                    paymentProviderCustomerId: customerId,
+                    paymentProviderSubscriptionId: subscriptionId,
+                    paymentProviderMeteredSubscriptionId: meteredSubscriptionId,
+                    paymentProviderSubscriptionSeats: 1,
+                    trialEndsAt: (trialEndsAt || null),
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            // mark the promo code as used it it exists.
+            if (createdItem.paymentProviderPromoCode) {
+                await PromoCodeService.updateOneBy({
+                    query: {
+                        promoCodeId: createdItem.paymentProviderPromoCode,
+                    },
+                    data: {
+                        isPromoCodeUsed: true,
+                        promoCodeUsedAt: OneUptimeDate.getCurrentDate(),
+                        projectId: createdItem.id,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            }
+        }
+        createdItem = await this.addDefaultIncidentSeverity(createdItem);
+        createdItem = await this.addDefaultProjectTeams(createdItem);
+        createdItem = await this.addDefaultMonitorStatus(createdItem);
+        createdItem = await this.addDefaultIncidentState(createdItem);
+        createdItem = await this.addDefaultScheduledMaintenanceState(createdItem);
+        return createdItem;
+    }
+    async addDefaultIncidentState(createdItem) {
+        let createdIncidentState = new IncidentState();
+        createdIncidentState.name = "Identified";
+        createdIncidentState.description =
+            "When an incident is created, it belongs to this state";
+        createdIncidentState.color = Red;
+        createdIncidentState.isCreatedState = true;
+        createdIncidentState.projectId = createdItem.id;
+        createdIncidentState.order = 1;
+        createdIncidentState = await IncidentStateService.create({
+            data: createdIncidentState,
+            props: {
+                isRoot: true,
+            },
+        });
+        let acknowledgedIncidentState = new IncidentState();
+        acknowledgedIncidentState.name = "Acknowledged";
+        acknowledgedIncidentState.description =
+            "When an incident is acknowledged, it belongs to this state.";
+        acknowledgedIncidentState.color = Yellow;
+        acknowledgedIncidentState.isAcknowledgedState = true;
+        acknowledgedIncidentState.projectId = createdItem.id;
+        acknowledgedIncidentState.order = 2;
+        acknowledgedIncidentState = await IncidentStateService.create({
+            data: acknowledgedIncidentState,
+            props: {
+                isRoot: true,
+            },
+        });
+        let resolvedIncidentState = new IncidentState();
+        resolvedIncidentState.name = "Resolved";
+        resolvedIncidentState.description =
+            "When an incident is resolved, it belongs to this state.";
+        resolvedIncidentState.color = Green;
+        resolvedIncidentState.isResolvedState = true;
+        resolvedIncidentState.projectId = createdItem.id;
+        resolvedIncidentState.order = 3;
+        resolvedIncidentState = await IncidentStateService.create({
+            data: resolvedIncidentState,
+            props: {
+                isRoot: true,
+            },
+        });
+        return createdItem;
+    }
+    async addDefaultIncidentSeverity(createdItem) {
+        let criticalIncident = new IncidentSeverity();
+        criticalIncident.name = "Critical Incident";
+        criticalIncident.description =
+            "Issues causing very high impact to customers. Immediate response is required. Examples include a full outage, or a data breach.";
+        criticalIncident.color = Moroon500;
+        criticalIncident.projectId = createdItem.id;
+        criticalIncident.order = 1;
+        criticalIncident = await IncidentSeverityService.create({
+            data: criticalIncident,
+            props: {
+                isRoot: true,
+            },
+        });
+        let majorIncident = new IncidentSeverity();
+        majorIncident.name = "Major Incident";
+        majorIncident.description =
+            "Issues causing significant impact. Immediate response is usually required. We might have some workarounds that mitigate the impact on customers. Examples include an important sub-system failing.";
+        majorIncident.color = Red;
+        majorIncident.projectId = createdItem.id;
+        majorIncident.order = 2;
+        majorIncident = await IncidentSeverityService.create({
+            data: majorIncident,
+            props: {
+                isRoot: true,
+            },
+        });
+        let minorIncident = new IncidentSeverity();
+        minorIncident.name = "Minor Incident";
+        minorIncident.description =
+            "Issues with low impact, which can usually be handled within working hours. Most customers are unlikely to notice any problems. Examples include a slight drop in application performance.";
+        minorIncident.color = Yellow;
+        minorIncident.projectId = createdItem.id;
+        minorIncident.order = 3;
+        minorIncident = await IncidentSeverityService.create({
+            data: minorIncident,
+            props: {
+                isRoot: true,
+            },
+        });
+        return createdItem;
+    }
+    async addDefaultMonitorStatus(createdItem) {
+        let operationalStatus = new MonitorStatus();
+        operationalStatus.name = "Operational";
+        operationalStatus.description = "Monitor operating normally";
+        operationalStatus.projectId = createdItem.id;
+        operationalStatus.priority = 1;
+        operationalStatus.isOperationalState = true;
+        operationalStatus.color = Green;
+        operationalStatus = await MonitorStatusService.create({
+            data: operationalStatus,
+            props: {
+                isRoot: true,
+            },
+        });
+        let degradedStatus = new MonitorStatus();
+        degradedStatus.name = "Degraded";
+        degradedStatus.description = "Monitor is operating at reduced performance.";
+        degradedStatus.priority = 2;
+        degradedStatus.projectId = createdItem.id;
+        degradedStatus.color = Yellow;
+        degradedStatus = await MonitorStatusService.create({
+            data: degradedStatus,
+            props: {
+                isRoot: true,
+            },
+        });
+        let downStatus = new MonitorStatus();
+        downStatus.name = "Offline";
+        downStatus.description = "Monitor is offline.";
+        downStatus.isOfflineState = true;
+        downStatus.projectId = createdItem.id;
+        downStatus.priority = 3;
+        downStatus.color = Red;
+        downStatus = await MonitorStatusService.create({
+            data: downStatus,
+            props: {
+                isRoot: true,
+            },
+        });
+        return createdItem;
+    }
+    async addDefaultProjectTeams(createdItem) {
+        // add a team member.
+        // Owner Team.
+        let ownerTeam = new Team();
+        ownerTeam.projectId = createdItem.id;
+        ownerTeam.name = "Owners";
+        ownerTeam.shouldHaveAtLeastOneMember = true;
+        ownerTeam.isPermissionsEditable = false;
+        ownerTeam.isTeamEditable = false;
+        ownerTeam.isTeamDeleteable = false;
+        ownerTeam.description =
+            "This team is for project owners. Adding team members to this team will give them root level permissions.";
+        ownerTeam = await TeamService.create({
+            data: ownerTeam,
+            props: {
+                isRoot: true,
+            },
+        });
+        // Add current user to owners team.
+        let ownerTeamMember = new TeamMember();
+        ownerTeamMember.projectId = createdItem.id;
+        ownerTeamMember.userId = createdItem.createdByUserId;
+        ownerTeamMember.hasAcceptedInvitation = true;
+        ownerTeamMember.invitationAcceptedAt = OneUptimeDate.getCurrentDate();
+        ownerTeamMember.teamId = ownerTeam.id;
+        ownerTeamMember = await TeamMemberService.create({
+            data: ownerTeamMember,
+            props: {
+                isRoot: true,
+                ignoreHooks: true,
+            },
+        });
+        // Add permissions for this team.
+        const ownerPermissions = new TeamPermission();
+        ownerPermissions.permission = Permission.ProjectOwner;
+        ownerPermissions.teamId = ownerTeam.id;
+        ownerPermissions.projectId = createdItem.id;
+        await TeamPermissionService.create({
+            data: ownerPermissions,
+            props: {
+                isRoot: true,
+                ignoreHooks: true,
+            },
+        });
+        // Admin Team.
+        const adminTeam = new Team();
+        adminTeam.projectId = createdItem.id;
+        adminTeam.name = "Admin";
+        adminTeam.isPermissionsEditable = false;
+        adminTeam.isTeamDeleteable = false;
+        adminTeam.isTeamEditable = false;
+        adminTeam.description =
+            "This team is for project admins. Admins can invite members to any team and create project resources.";
+        await TeamService.create({
+            data: adminTeam,
+            props: {
+                isRoot: true,
+            },
+        });
+        const adminPermissions = new TeamPermission();
+        adminPermissions.permission = Permission.ProjectAdmin;
+        adminPermissions.teamId = adminTeam.id;
+        adminPermissions.projectId = createdItem.id;
+        await TeamPermissionService.create({
+            data: adminPermissions,
+            props: {
+                isRoot: true,
+                ignoreHooks: true,
+            },
+        });
+        // Members Team.
+        const memberTeam = new Team();
+        memberTeam.projectId = createdItem.id;
+        memberTeam.isPermissionsEditable = true;
+        memberTeam.name = "Members";
+        memberTeam.isTeamDeleteable = true;
+        memberTeam.description =
+            "This team is for project members. Members can interact with any project resources like monitors, incidents, etc.";
+        await TeamService.create({
+            data: memberTeam,
+            props: {
+                isRoot: true,
+            },
+        });
+        const memberPermissions = new TeamPermission();
+        memberPermissions.permission = Permission.ProjectMember;
+        memberPermissions.teamId = memberTeam.id;
+        memberPermissions.projectId = createdItem.id;
+        await TeamPermissionService.create({
+            data: memberPermissions,
+            props: {
+                isRoot: true,
+                ignoreHooks: true,
+            },
+        });
+        await AccessTokenService.refreshUserAllPermissions(createdItem.createdByUserId);
+        const user = await UserService.findOneById({
+            id: createdItem.createdByUserId,
+            props: {
+                isRoot: true,
+            },
+            select: {
+                isEmailVerified: true,
+                email: true,
+            },
+        });
+        if (user && user.isEmailVerified) {
+            await UserNotificationRuleService.addDefaultNotificationRuleForUser(createdItem.id, user.id, user.email);
+            await UserNotificationSettingService.addDefaultNotificationSettingsForUser(user.id, createdItem.id);
+        }
+        return createdItem;
+    }
+    async updateLastActive(projectId) {
+        await this.updateOneById({
+            id: projectId,
+            data: {
+                lastActive: OneUptimeDate.getCurrentDate(),
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    async getOwners(projectId) {
+        if (!projectId) {
+            throw new BadDataException("Project ID is required");
+        }
+        // get teams with project owner permissions.
+        const teamPermissions = await TeamPermissionService.findBy({
+            query: {
+                projectId: projectId,
+                permission: Permission.ProjectOwner,
+            },
+            props: {
+                isRoot: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            select: {
+                teamId: true,
+            },
+        });
+        if (teamPermissions.length === 0) {
+            return [];
+        }
+        const teamIds = teamPermissions.map((item) => {
+            return item.teamId;
+        });
+        return TeamMemberService.getUsersInTeams(teamIds);
+    }
+    async onBeforeFind(findBy) {
+        var _a, _b;
+        // if user has no project id, then he should not be able to access any project.
+        if ((!findBy.props.isRoot &&
+            !((_a = findBy.props.userGlobalAccessPermission) === null || _a === void 0 ? void 0 : _a.projectIds)) ||
+            ((_b = findBy.props.userGlobalAccessPermission) === null || _b === void 0 ? void 0 : _b.projectIds.length) === 0) {
+            findBy.props.isRoot = true;
+            findBy.query._id = In([]); // should not get any projects.
+        }
+        return { findBy, carryForward: null };
+    }
+    async onBeforeDelete(deleteBy) {
+        if (IsBillingEnabled) {
+            const projects = await this.findBy({
+                query: deleteBy.query,
+                props: deleteBy.props,
+                limit: LIMIT_MAX,
+                skip: 0,
+                select: {
+                    _id: true,
+                    paymentProviderSubscriptionId: true,
+                    paymentProviderMeteredSubscriptionId: true,
+                },
+            });
+            return { deleteBy, carryForward: projects };
+        }
+        return { deleteBy, carryForward: [] };
+    }
+    async onDeleteSuccess(onDelete, _itemIdsBeforeDelete) {
+        // get project id
+        if (IsBillingEnabled) {
+            for (const project of onDelete.carryForward) {
+                if (project.paymentProviderSubscriptionId) {
+                    await BillingService.cancelSubscription(project.paymentProviderSubscriptionId);
+                }
+                if (project.paymentProviderMeteredSubscriptionId) {
+                    await BillingService.cancelSubscription(project.paymentProviderMeteredSubscriptionId);
+                }
+            }
+        }
+        return onDelete;
+    }
+    async getCurrentPlan(projectId) {
+        if (!IsBillingEnabled) {
+            return { plan: null, isSubscriptionUnpaid: false };
+        }
+        const project = await this.findOneById({
+            id: projectId,
+            select: {
+                paymentProviderPlanId: true,
+                paymentProviderSubscriptionStatus: true,
+                paymentProviderMeteredSubscriptionStatus: true,
+            },
+            props: {
+                isRoot: true,
+                ignoreHooks: true,
+            },
+        });
+        if (!project) {
+            throw new BadDataException("Project ID is invalid");
+        }
+        if (!project.paymentProviderPlanId) {
+            throw new BadDataException("Project does not have any plans");
+        }
+        const plan = SubscriptionPlan.getPlanType(project.paymentProviderPlanId, getAllEnvVars());
+        return {
+            plan: plan,
+            isSubscriptionUnpaid: !BillingService.isSubscriptionActive(project.paymentProviderSubscriptionStatus) ||
+                !BillingService.isSubscriptionActive(project.paymentProviderMeteredSubscriptionStatus),
+        };
+    }
+    async sendEmailToProjectOwners(projectId, subject, message) {
+        const owners = await this.getOwners(projectId);
+        if (owners.length === 0) {
+            return;
+        }
+        const emails = owners.map((owner) => {
+            return owner.email;
+        });
+        for (const email of emails) {
+            MailService.sendMail({
+                toEmail: email,
+                templateType: EmailTemplateType.SimpleMessage,
+                vars: {
+                    subject: subject,
+                    message: message,
+                },
+                subject: subject,
+            }, {
+                projectId,
+            }).catch((err) => {
+                logger.error(err);
+            });
+        }
+    }
+    async reactiveSubscription(projectId) {
+        logger.debug("Reactivating subscription for project " + projectId);
+        const project = await this.findOneById({
+            id: projectId,
+            props: {
+                isRoot: true,
+            },
+            select: {
+                _id: true,
+                paymentProviderCustomerId: true,
+                paymentProviderSubscriptionId: true,
+                paymentProviderMeteredSubscriptionId: true,
+                paymentProviderSubscriptionSeats: true,
+                paymentProviderPlanId: true,
+            },
+        });
+        if (!project) {
+            throw new BadDataException("Project not found");
+        }
+        if (!project.paymentProviderCustomerId) {
+            throw new BadDataException("Payment Provider customer not found");
+        }
+        if (!project.paymentProviderSubscriptionId) {
+            throw new BadDataException("Payment Provider subscription not found");
+        }
+        if (!project.paymentProviderMeteredSubscriptionId) {
+            throw new BadDataException("Payment Provider metered subscription not found");
+        }
+        if (!project.paymentProviderSubscriptionSeats) {
+            throw new BadDataException("Payment Provider subscription seats not found");
+        }
+        if (!project.paymentProviderPlanId) {
+            throw new BadDataException("Payment Provider plan id not found");
+        }
+        const subscriptionPlan = SubscriptionPlan.getSubscriptionPlanById(project.paymentProviderPlanId, getAllEnvVars());
+        if (!subscriptionPlan) {
+            throw new BadDataException("Subscription plan not found");
+        }
+        const result = await BillingService.changePlan({
+            projectId: project.id,
+            subscriptionId: project.paymentProviderSubscriptionId,
+            meteredSubscriptionId: project.paymentProviderMeteredSubscriptionId,
+            serverMeteredPlans: AllMeteredPlans,
+            newPlan: subscriptionPlan,
+            quantity: project.paymentProviderSubscriptionSeats,
+            isYearly: SubscriptionPlan.isYearlyPlan(project.paymentProviderPlanId),
+            endTrialAt: undefined,
+        });
+        // refresh subscription status.
+        const subscriptionState = await BillingService.getSubscriptionStatus(result.subscriptionId);
+        const meteredSubscriptionState = await BillingService.getSubscriptionStatus(project.paymentProviderMeteredSubscriptionId);
+        // now update project with new subscription id.
+        await this.updateOneById({
+            id: project.id,
+            data: {
+                paymentProviderSubscriptionId: result.subscriptionId,
+                paymentProviderMeteredSubscriptionId: result.meteredSubscriptionId,
+                paymentProviderSubscriptionStatus: subscriptionState,
+                paymentProviderMeteredSubscriptionStatus: meteredSubscriptionState,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    async isSMSNotificationsEnabled(projectId) {
+        const project = await this.findOneById({
+            id: projectId,
+            select: {
+                enableSmsNotifications: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!project) {
+            throw new BadDataException("Project not found");
+        }
+        return Boolean(project.enableSmsNotifications);
+    }
+}
+export default new ProjectService();
+//# sourceMappingURL=ProjectService.js.map