prow-authority 3.6.3

package/src/v1/controllers/services/service-controller.ts

@@ -0,0 +1,474 @@
+import { Blocker } from "@beseif-solutions/utility-functions/dist/utils/concurrency-utils";
+import { Date2, Formats, Unit } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import _ from "lodash";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import authority, { LicenseLimitApproaching, LicenseLimitReached, NotificationEventNames, ServiceAccessBlocked, ServiceAccessWarning } from "../../../helpers/authority";
+import nconf from "../../../helpers/config";
+import notifications from "../../../helpers/notifications";
+import { quotaParamsSchema, quotaUsageSchema, sendNotificationSchema } from "../../schemas/services/service-schemas";
+import { LimitNotification, OrganizationStatus, ServiceInformation } from "../../types/admin/organization-types";
+import { OrganizationUsage } from "../../types/admin/organization-usage-types";
+import { ServiceNotification } from "../../types/admin/service-notification-types";
+import { UserOrganization, UserOrganizationRole } from "../../types/admin/user-organization-types";
+import { UserStatus } from "../../types/admin/user-types";
+import { BearerAuthorization } from "../../types/auth/common-types";
+import { PublicOrganization, PublicOrganizationLicense } from "../../types/organizations/public-organization-types";
+import { NotificationContext, Quota, QuotaParams, QuotaUsage, SendNotificationData, ServiceEnvironment } from "../../types/services/service-types";
+import { PublicUser } from "../../types/users/public-user-types";
+import organizationController from "../admin/organization-controller";
+import organizationLicenseLimitController from "../admin/organization-license-limit-controller";
+import organizationUsageController from "../admin/organization-usage-controller";
+import serviceNotificationController from "../admin/service-notification-controller";
+import userController from "../admin/user-controller";
+import userOrganizationController from "../admin/user-organization-controller";
+import organizationTokenController from "../auth/organization-token-controller";
+import billingController from "../billing/billing-controller";
+import publicOrganizationController from "../organizations/public-organization-controller";
+import publicUserController from "../users/public-user-controller";
+import { LicenseLimit } from "../../types/admin/license-limit-types";
+import { BillingCycle } from "../../types/admin/billing-cycle-types";
+
+class ServiceController {
+
+
+  private readonly blocker = new Blocker<[organization: string, service: string, limit: string]>();
+  constructor() {
+    this.blocker.getKey = async (organization, service, limit) => `${organization}:${service}:${limit}`;
+  }
+
+  // public information for services
+  public readonly getOrganizationByUUID = async (organizationUUID: string): Promise<PublicOrganization> => {
+    try {
+      const organization = (await organizationController.list({ uuid: organizationUUID, status: { is: OrganizationStatus.Blocked, inverse: true } }, { timestamp: true }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Organization ${organizationUUID} not found.`,
+        });
+      }
+      return (await publicOrganizationController.parse(null, [organization]))[0];
+    } catch (e) { throw e; }
+  };
+
+  public readonly getUserByUUID = async (userUUID: string): Promise<PublicUser> => {
+    try {
+      const user = (await userController.list({ uuid: userUUID, status: UserStatus.Active }, { password: false, timestamp: true }))[0];
+      if (!user) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User ${userUUID} not found.`,
+        });
+      }
+      return (await publicUserController.parseUser([user]))[0];
+    } catch (e) { throw e; }
+  };
+
+  // service as organization
+  public readonly authorize = async (env: ServiceEnvironment): Promise<BearerAuthorization> => {
+    try {
+      return organizationTokenController.authorize(env.organization);
+    } catch (e) { throw e; }
+  };
+
+  public readonly getOrganization = async (env: ServiceEnvironment): Promise<PublicOrganization> => {
+    try {
+      const response = (await publicOrganizationController.parse(null, [env.organization]))[0];
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly getLicenses = async (env: ServiceEnvironment): Promise<PublicOrganizationLicense[]> => {
+    try {
+      const response = await publicOrganizationController.parseLicenses(env.organization, env.licenses);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly getQuota = async (env: ServiceEnvironment, params: QuotaParams): Promise<Quota[]> => {
+    try {
+      Validator.validate(quotaParamsSchema, params);
+
+      // get limitations
+      const limits = await organizationLicenseLimitController.list({
+        license: { in: env.licenses.map((l) => l.id) },
+        ...params.name ? { name: { in: params.name } } : {},
+      });
+
+      // get usages
+      const queries: Where<OrganizationUsage>[] = [];
+
+      const { cycle, now } = await billingController.cycleContext(env.organization, params.date);
+
+      const byPeriod = _.groupBy(limits, (l) => l.period);
+
+      if (byPeriod[`monthly`]) {
+        const monthlyScope = this.getLimitScope(`monthly`, cycle, now);
+
+        queries.push({
+          service: env.service.id,
+          organization: env.organization.id,
+          name: { in: byPeriod[`monthly`].map((l) => l.name) },
+          date: { gte: monthlyScope.start as any, lt: monthlyScope.end as any },
+        });
+      }
+
+      if (byPeriod[`lifetime`]) {
+        queries.push({
+          service: env.service.id,
+          organization: env.organization.id,
+          name: { in: byPeriod[`lifetime`].map((l) => l.name) },
+        });
+      }
+
+      const usages = queries.length > 0 ? await organizationUsageController.list(queries) : [];
+
+      // parse
+      const response: Quota[] = _.map(_.groupBy(limits, (l) => l.name), ((sameLimits, name): Quota => {
+
+        const period = sameLimits[0].period;
+        const scope = this.getLimitScope(period, cycle, now);
+
+        return {
+          period: period,
+          name: name,
+          overconsume: !cycle.trial && sameLimits.some((l) => l.overconsume),
+          limit: _.sum(sameLimits.map((sl) => sl.limit)),
+          used: _.sum(usages.filter((u) => u.name === name).map((u) => u.count)),
+          ...scope ? { resets: scope.end.format(Formats.ISO) } : {},
+        };
+      }));
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly checkQuota = async (env: ServiceEnvironment): Promise<void> => {
+    try {
+      const exceededLimits = (await serviceController.getQuota(env, {}))
+        .filter((q) => q.used > q.limit && q.period === `lifetime` && !q.overconsume);
+
+      if (exceededLimits.length > 0) {
+        const information = await this.getOrganizationServiceInformation(env);
+
+        // register when a limit was exceeded
+        if (!information.exceeded_date) { information.exceeded_date = Date2.current().format(Formats.ISO); }
+
+        if (!information.blocked) {
+          // get owner
+          const access = (await userOrganizationController.list({ organization: env.organization.id, role: UserOrganizationRole.Owner }))[0];
+          if (!access) { throw new Error(`No owner found for organization ${env.organization.properties.name}`); }
+
+          const owner = (await userController.get(access.user, { password: false }))[0];
+          if (!owner) { throw new Error(`No owner found for organization ${env.organization.properties.name}`); }
+
+          const exceeded = new Date2(information.exceeded_date);
+          const today = Date2.current();
+
+          const diffInDays = Math.abs(today.toMoment().diff(exceeded.toMoment(), `days`));
+
+          const MARGIN = nconf.get(`SERVICES:SCHEDULE:LIMITS:MARGIN`);
+
+          if (diffInDays < MARGIN) {
+            const key = today.format(Formats.SqlDate);
+
+            if (!information.notifications.access[key]) {
+              // send email
+              await authority.notify<ServiceAccessWarning>(env.organization.uuid, {
+                event: NotificationEventNames.ServiceAccessWarning,
+                data: {
+                  days: MARGIN - diffInDays,
+                  organization: env.organization,
+                  cta: {
+                    usage: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_USAGE`),
+                    preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+                  },
+                },
+              });
+
+              // register notification to avoid duplicated emails
+              information.notifications.access[key] = true;
+            }
+          } else {
+            // send email
+            await authority.notify<ServiceAccessBlocked>(env.organization.uuid, {
+              event: NotificationEventNames.ServiceAccessBlocked,
+              data: {
+                organization: env.organization,
+                service: env.service,
+                cta: {
+                  usage: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_USAGE`),
+                  upgrade: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_BILLING`),
+                  preferences: nconf.get(`SERVICES:NOTIFICATIONS:PREFERENCES_URL`),
+                },
+              },
+            });
+
+            // block access to service
+            information.blocked = true;
+          }
+        }
+
+        await this.updateOrganizationServiceInformation(env, information);
+      } else if (env.organization.internal.services[env.service.uuid]) {
+        await this.updateOrganizationServiceInformation(env, {
+          blocked: false,
+          exceeded_date: null,
+          notifications: {
+            access: null,
+          },
+        });
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly validateQuotaUsage = async (env: ServiceEnvironment, data: QuotaUsage): Promise<{ possible: boolean }> => {
+    try {
+      Validator.validate(quotaUsageSchema, data);
+
+      const quota = (await this.getQuota(env, { name: [data.name] }))[0];
+      if (!quota) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Invalid name for quota usage.`,
+        });
+      }
+
+      const futureUsed = quota.used + data.count;
+
+      return { possible: quota.overconsume || futureUsed <= quota.limit && futureUsed >= 0 };
+    } catch (e) { throw e; }
+  };
+
+  public readonly registerQuotaUsage = async (env: ServiceEnvironment, data: QuotaUsage): Promise<void> => {
+    try {
+      Validator.validate(quotaUsageSchema, data);
+
+      if (data.count === 0) { return; }
+
+      const limits = await organizationLicenseLimitController.list({
+        license: { in: env.licenses.map((l) => l.id) },
+        name: data.name,
+      });
+      if (!limits.length) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Invalid name for quota usage.`,
+        });
+      }
+
+      await organizationUsageController.add({
+        service: env.service.id,
+        organization: env.organization.id,
+        name: data.name,
+        count: data.count,
+      });
+
+      // check and notify quota limits (non blocking)
+      setImmediate(async () => this.checkAndNotifyQuotaLimits(env, data.name));
+    } catch (e) { throw e; }
+  };
+
+  public readonly sendNotification = async (env: ServiceEnvironment, data: SendNotificationData): Promise<{ sent: number }> => {
+    try {
+      Validator.validate(sendNotificationSchema, data);
+
+      const notificationConfig = (await serviceNotificationController.list({
+        service: env.service.id,
+        event: data.event,
+        enabled: true,
+      }))[0];
+      if (!notificationConfig) { return { sent: 0 }; }
+
+      const organizationUsers = await userOrganizationController.list({
+        organization: env.organization.id,
+        enabled: true,
+      });
+
+      const recipients: { email: string, language: string }[] = [];
+      for (const organizationUser of organizationUsers) {
+        const shouldNotify = await this.shouldNotifyUser(notificationConfig, organizationUser, { event: data.event, context: data.context || {} });
+
+        if (shouldNotify) {
+          const recipient = (await userController.get(organizationUser.user, { password: false }))[0];
+          if (recipient) { recipients.push({ email: recipient.email, language: recipient.preferences.language }); }
+        }
+      }
+
+      if (recipients.length > 0) {
+        for (const recipient of recipients) {
+          const params = {
+            template: notificationConfig.template,
+            locale: data.locale || recipient.language,
+            to: [recipient.email],
+            arguments: {
+              event: data.event,
+              service: env.service,
+              organization: env.organization,
+              data: data.data || {},
+            },
+            ...data.attachments ? { attachments: data.attachments } : {},
+          };
+
+          await notifications.gmail(params);
+        }
+      }
+
+      return { sent: recipients.length };
+    } catch (e) { throw e; }
+  };
+
+  private readonly checkAndNotifyQuotaLimits = async (env: ServiceEnvironment, name: string): Promise<void> => {
+    try {
+      await this.blocker.block(env.organization.uuid, env.service.uuid, name);
+
+      const ALERT_THRESHOLD = nconf.get(`SERVICES:AUTHORITY:LICENSES:ALERT_THRESHOLD`);
+      const FULL_THRESHOLD = 100;
+
+      // get and validate quota
+      const quota = (await this.getQuota(env, { name: [name] }))[0];
+
+      // ignore limits if overconsume is activated or limits don't reset
+      if (quota.overconsume || !quota.resets) { return; }
+
+      const currentPercentage = (quota.used / quota.limit) * FULL_THRESHOLD;
+      const information = await this.getOrganizationServiceInformation(env);
+      const limitInfo: LimitNotification = _.get(
+        information,
+        [`notifications`, `limits`, name],
+        { approaching: false, reached: false, lastPercentage: undefined }
+      );
+
+      const isReached = currentPercentage >= FULL_THRESHOLD;
+      const isApproaching = currentPercentage >= ALERT_THRESHOLD && !isReached;
+
+      if (isReached && !limitInfo.reached) {
+        await authority.notify<LicenseLimitReached>(env.organization.uuid, {
+          event: NotificationEventNames.LicenseLimitReached,
+          data: {
+            limit: quota,
+            organization: env.organization,
+            cta: {
+              upgrade: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_BILLING`),
+              preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+            },
+          },
+        });
+      } else if (isApproaching && !limitInfo.approaching && !limitInfo.reached) {
+        await authority.notify<LicenseLimitApproaching>(env.organization.uuid, {
+          event: NotificationEventNames.LicenseLimitApproaching,
+          data: {
+            limit: {
+              ...quota,
+              percentage: currentPercentage,
+            },
+            organization: env.organization,
+            cta: {
+              upgrade: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_BILLING`),
+              preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+            },
+          },
+        });
+      }
+
+      limitInfo.approaching = isApproaching;
+      limitInfo.reached = isReached;
+      limitInfo.lastPercentage = currentPercentage;
+
+      await this.updateOrganizationServiceInformation(env, {
+        notifications: { limits: { [name]: limitInfo } },
+      });
+    } catch (e) {
+      console.log(`Error while checking and notifying quota limits:`, e);
+    } finally {
+      await this.blocker.unblock(env.organization.uuid, env.service.uuid, name);
+    }
+  };
+
+  private readonly shouldNotifyUser = async (
+    config: ServiceNotification,
+    organizationUser: UserOrganization,
+    data: { event: string, context: NotificationContext }
+  ): Promise<boolean> => {
+    try {
+      const { event, context } = data;
+
+      // by configuration policy
+      if (!config.scope.roles.includes(organizationUser.role)) { return false; }
+
+      // by preferences
+      const eventPreference = _.get(organizationUser, `preferences.notifications.${event}`, config.default);
+      if (typeof eventPreference === `boolean`) { return eventPreference; }
+
+      for (const key of Object.keys(context)) {
+        const arr = eventPreference[key] || [];
+        if (arr.includes(context[key])) { return true; }
+      }
+
+      return false;
+    } catch { return false; }
+  };
+
+  public readonly getLimitScope = (period: LicenseLimit[`period`], cycle: BillingCycle, now: Date2): { start: Date2, end: Date2 } => {
+    try {
+      const add: Record<LicenseLimit[`period`], Unit> = {
+        lifetime: null,
+        monthly: Unit.Months,
+      };
+
+      const unit = add[period];
+      if (!unit) { return null; }
+
+      const cycleStart = new Date2(cycle.start_date);
+      const cycleEnd = new Date2(cycle.end_date);
+      const current = new Date2(now);
+
+      if (current.isBefore(cycleStart) || current.isAfter(cycleEnd)) { throw new Error(`Current date is outside the billing cycle range.`); }
+
+      let start = new Date2(cycle.start_date);
+      let end = new Date2(cycle.start_date).add(1, unit);
+
+      while (current.isAfter(end) || current.isEqual(end)) {
+        start = start.add(1, unit);
+        end = end.add(1, unit);
+      }
+
+      if (end.isAfter(cycleEnd)) { end = cycleEnd; }
+
+      return { start: start, end: end };
+    } catch (e) { throw e; }
+  };
+
+  private readonly getOrganizationServiceInformation = async (env: ServiceEnvironment): Promise<ServiceInformation> => {
+    try {
+      const org = (await organizationController.get(env.organization.id))[0];
+      if (!org) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Organization not found.`,
+        });
+      }
+
+      const information: ServiceInformation = JSON2.deepMerge({
+        blocked: false,
+        notifications: {
+          access: {},
+          limits: {},
+        },
+      }, _.get(org.internal, `services.${env.service.uuid}`, {}));
+      return information;
+    } catch (e) { throw e; }
+  };
+
+  private readonly updateOrganizationServiceInformation = async (env: ServiceEnvironment, information: DeepPartial<ServiceInformation>): Promise<void> => {
+    try {
+      await organizationController.update(env.organization.id, { internal: { services: { [env.service.uuid]: information } } });
+    } catch (e) { throw e; }
+  };
+
+}
+
+const serviceController = new ServiceController();
+export default serviceController;