prow-authority 3.6.3

package/src/v1/controllers/admin/payment-method-controller.ts

@@ -0,0 +1,173 @@
+import { Date2, Formats } 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 { newUUIDv4 } from "@beseif-solutions/utility-functions/dist/utils/string-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import paymentMethodDao from "../../daos/payment-method-dao";
+import { addPaymentMethodSchema, updatePaymentMethodSchema } from "../../schemas/admin/payment-method-schemas";
+import { DBRecord, PaymentMethod } from "../../types/admin/payment-method-types";
+import organizationController from "./organization-controller";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<PaymentMethod, `id` | `uuid` | `created_date` | `modified_date`>;
+type Update = DeepPartial<Omit<PaymentMethod, `id` | `uuid` | `created_date` | `modified_date`>>;
+
+class PaymentMethodCtrl {
+
+  public readonly get = async (id: number): Promise<PaymentMethod[]> => {
+    try {
+      const db = await paymentMethodDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<PaymentMethod>, options: Modifiers = {}): Promise<PaymentMethod[]> => {
+    try {
+      const db = await paymentMethodDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<PaymentMethod[]> => {
+    try {
+      await Validator.validateAsync(addPaymentMethodSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await paymentMethodDao.add({
+        uuid: uuid,
+        organization: data.organization,
+        type: data.type,
+        properties: data.properties,
+        enabled: data.enabled,
+        metadata: data.metadata,
+        internal: data.internal,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<PaymentMethod[]> => {
+    try {
+      await Validator.validateAsync(updatePaymentMethodSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `PaymentMethod with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as PaymentMethod;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await paymentMethodDao.update({ id: id }, {
+        uuid: merged.uuid,
+        organization: merged.organization,
+        type: merged.type,
+        properties: merged.properties,
+        enabled: merged.enabled,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update paymentMethod with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const paymentMethod = (await this.get(id))[0];
+      if (!paymentMethod) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `PaymentMethod with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await paymentMethodDao.delete({ id: paymentMethod.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete paymentMethod with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly getFreeUUID = async (): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await paymentMethodDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | PaymentMethod, old?: PaymentMethod): Promise<void> => {
+    try {
+      if (!old || data.organization !== old.organization) {
+        const organization = (await organizationController.list({ id: data.organization, status: { is: OrganizationStatus.Blocked, inverse: true } }))[0];
+        if (!organization) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No active organization ${data.organization} found.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<PaymentMethod[]> => {
+    try {
+      const response: PaymentMethod[] = [];
+
+      for (const record of records) {
+        const p: PaymentMethod = {
+          id: record.id,
+          uuid: record.uuid,
+          organization: record.organization,
+          type: record.type,
+          properties: record.properties,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const paymentMethodController = new PaymentMethodCtrl();
+export default paymentMethodController;

package/src/v1/controllers/admin/policy-controller.ts

@@ -0,0 +1,138 @@
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import { newUUIDv4 } from "@beseif-solutions/utility-functions/dist/utils/string-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import policyDao from '../../daos/policy-dao';
+import { addPolicySchema, updatePolicySchema } from '../../schemas/admin/policy-schemas';
+import { DBRecord, Policy } from '../../types/admin/policy-types';
+import { Modifiers } from '../../common-types';
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+
+type Add = Omit<Policy, 'id' | 'uuid'>;
+type Update = DeepPartial<Omit<Policy, 'id' | 'uuid'>>;
+
+class PolicyController {
+  public readonly get = async (id: number): Promise<Policy[]> => {
+    try {
+      const db = await policyDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<Policy>, options: Modifiers = {}): Promise<Policy[]> => {
+    try {
+      const db = await policyDao.list(params, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (data: Add): Promise<Policy[]> => {
+    try {
+      await Validator.validateAsync(addPolicySchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await policyDao.add({
+        uuid: uuid,
+        name: data.name,
+        metadata: data.metadata || {},
+        internal: data.internal || {},
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<Policy[]> => {
+    try {
+      await Validator.validateAsync(updatePolicySchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Policy with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as Policy;
+      await this.check(merged, old);
+
+      const { affectedRows } = await policyDao.update({ id: id }, {
+        uuid: merged.uuid,
+        name: merged.name,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update policy with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const policy = (await this.get(id))[0];
+      if (!policy) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Policy with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await policyDao.delete({ id: id });
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly getFreeUUID = async (): Promise<string> => {
+    try {
+      const uuid = newUUIDv4();
+      const db = await policyDao.list({ uuid: uuid });
+      if (db.length > 0) {
+        return await this.getFreeUUID();
+      }
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | Policy, old?: Policy): Promise<void> => {
+    try {
+      if (!old || data.name !== old.name) {
+        const exists = (await this.list({ name: data.name }))[0];
+        if (exists && (!old || exists.id !== old.id)) {
+          throw new APIError({
+            code: StatusCodes.CONFLICT,
+            detail: `Policy with name '${data.name}' already exists.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (data: DBRecord[]): Promise<Policy[]> => {
+    try {
+      const response: Policy[] = data.map((record) => ({
+        id: record.id,
+        uuid: record.uuid,
+        name: record.name,
+        metadata: record.metadata,
+        internal: record.internal,
+      }));
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const policyController = new PolicyController();
+export default policyController;

package/src/v1/controllers/admin/policy-version-controller.ts

@@ -0,0 +1,143 @@
+import { Date2, Formats } from "@beseif-solutions/utility-functions/dist/utils/date-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 APIError, { StatusCodes } from '../../../helpers/api-error';
+import policyVersionDao from '../../daos/policy-version-dao';
+import { addPolicyVersionSchema, updatePolicyVersionSchema } from '../../schemas/admin/policy-schemas';
+import { DBRecord, PolicyVersion } from '../../types/admin/policy-version-types';
+import { Modifiers } from '../../common-types';
+import policyController from './policy-controller';
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+
+type Add = Omit<PolicyVersion, 'id' | 'uuid' | 'created_date'>;
+type Update = DeepPartial<Omit<PolicyVersion, 'id' | 'uuid' | 'created_date'>>;
+
+class PolicyVersionController {
+  public readonly get = async (id: number): Promise<PolicyVersion[]> => {
+    try {
+      const db = await policyVersionDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<PolicyVersion>, options: Modifiers = {}): Promise<PolicyVersion[]> => {
+    try {
+      const db = await policyVersionDao.list(params, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (data: Add): Promise<PolicyVersion[]> => {
+    try {
+      await Validator.validateAsync(addPolicyVersionSchema, data);
+      await this.check(data);
+
+      const { insertId } = await policyVersionDao.add({
+        policy: data.policy,
+        version: data.version,
+        url: data.url,
+        metadata: data.metadata || {},
+        internal: data.internal || {},
+        effective_date: data.effective_date,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<PolicyVersion[]> => {
+    try {
+      await Validator.validateAsync(updatePolicyVersionSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Policy version with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as PolicyVersion;
+      await this.check(merged, old);
+
+      const { affectedRows } = await policyVersionDao.update({ id: id }, {
+        policy: merged.policy,
+        version: merged.version,
+        url: merged.url,
+        metadata: merged.metadata,
+        internal: merged.internal,
+        effective_date: merged.effective_date,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update policy version with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const version = (await this.get(id))[0];
+      if (!version) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Policy version with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await policyVersionDao.delete({ id: id });
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | PolicyVersion, old?: PolicyVersion): Promise<void> => {
+    try {
+      // verify policy exists
+      const policy = (await policyController.get(data.policy))[0];
+      if (!policy) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Policy with id ${data.policy} not found.`,
+        });
+      }
+
+      // check for duplicate version for the same policy
+      if (!old || data.policy !== old.policy || data.version !== old.version) {
+        const exists = (await this.list({ policy: data.policy, version: data.version }))[0];
+        if (exists && (!old || exists.id !== old.id)) {
+          throw new APIError({
+            code: StatusCodes.CONFLICT,
+            detail: `Policy version '${data.version}' already exists for policy ${data.policy}.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (data: DBRecord[]): Promise<PolicyVersion[]> => {
+    try {
+      const response: PolicyVersion[] = data.map((record) => ({
+        id: record.id,
+        policy: record.policy,
+        version: record.version,
+        url: record.url,
+        created_date: new Date2(record.created_date).format(Formats.ISO),
+        effective_date: record.effective_date ? new Date2(record.effective_date).format(Formats.ISO) : null,
+        metadata: record.metadata,
+        internal: record.internal,
+      }));
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const policyVersionController = new PolicyVersionController();
+export default policyVersionController;

package/src/v1/controllers/admin/schedule-controller.ts

@@ -0,0 +1,181 @@
+import { Scheduler } from "@beseif-solutions/utility-functions/dist/utils/scheduling-utils";
+import nconf from "../../../helpers/config";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import { ServiceEnvironment } from "../../types/services/service-types";
+import serviceController from "../services/service-controller";
+import organizationController from "./organization-controller";
+import organizationLicenseController from "./organization-license-controller";
+import adminServiceController from "./service-controller";
+import { Requester } from "@beseif-solutions/utility-functions/dist/utils/http-utils";
+import _ from "lodash";
+import billingController from "../billing/billing-controller";
+import { LicenseType } from "../../types/admin/license-types";
+import authority from "../../../helpers/authority";
+
+class ScheduleController {
+
+  constructor() {
+    Scheduler.schedule({
+      expression: nconf.get(`SERVICES:SCHEDULE:LIMITS:EXPRESSION`),
+      name: `Organization limits check`,
+      description: `Check limits for all organizations`,
+      task: this.limits,
+    })
+      .then((task) => { console.log(`[*] Scheduled: ${task.name}`.green); })
+      .catch((e) => { console.log(`[!] Could not schedule`.red, e); });
+
+    Scheduler.schedule({
+      expression: nconf.get(`SERVICES:SCHEDULE:LICENSES:EXPRESSION`),
+      name: `Organization license change (fallback)`,
+      task: this.licenseChangeFallback,
+    })
+      .then((task) => { console.log(`[*] Scheduled: ${task.name}`.green); })
+      .catch((e) => { console.log(`[!] Could not schedule`.red, e); });
+
+    Scheduler.schedule({
+      expression: nconf.get(`SERVICES:SCHEDULE:BILLING:CYCLES:EXPRESSION`),
+      name: `Organization billing cycle (fallback)`,
+      task: this.billingCycles,
+    })
+      .then((task) => { console.log(`[*] Scheduled: ${task.name}`.green); })
+      .catch((e) => { console.log(`[!] Could not schedule`.red, e); });
+
+    Scheduler.schedule({
+      expression: nconf.get(`SERVICES:SCHEDULE:BILLING:INVOICES:EXPRESSION`),
+      name: `Organization invoices (fallback)`,
+      task: this.invoices,
+    })
+      .then((task) => { console.log(`[*] Scheduled: ${task.name}`.green); })
+      .catch((e) => { console.log(`[!] Could not schedule`.red, e); });
+  }
+
+  public readonly limits = async (): Promise<void> => {
+    try {
+      console.log(`[>] Checking limits for all organizations`.yellow);
+
+      const [organizations, services] = await Promise.all([
+        organizationController.list({ status: OrganizationStatus.Active }),
+        adminServiceController.list({ enabled: true }),
+      ]);
+
+      const orgService = services.find((s) => s.uuid === authority.configuration.uuid);
+      if (!orgService) { throw new Error(`Root service not found.`); }
+
+      for (const organization of organizations) {
+        try {
+          console.log(`Checking limits for organization ${organization.id}`.blue);
+
+          const licenses = await organizationLicenseController.list({
+            organization: organization.id,
+            service: { in: services.map((s) => s.id) },
+            enabled: true,
+          });
+
+          const noLifetimeLicenses = licenses.filter((l) => l.type === LicenseType.Base && l.service !== orgService.id);
+
+          if (noLifetimeLicenses.length === 0) {
+            console.log(`  > No active licenses for organization ${organization.id}, skipping limits check`.blue);
+            continue;
+          }
+
+          const byService = _.groupBy(noLifetimeLicenses, (l) => l.service);
+
+          for (const service of services) {
+            try {
+              const serviceLicenses = byService[service.id] || [];
+              if (serviceLicenses.length === 0) {
+                console.log(`  > No active licenses for organization ${organization.id} on service ${service.id}, skipping limits check`.blue);
+                continue;
+              }
+
+              const env: ServiceEnvironment = {
+                organization: organization,
+                service: service,
+                licenses: serviceLicenses,
+              };
+
+              console.log(`  > Checking limits for organization ${organization.id} on service ${service.id}`.blue);
+
+              await serviceController.checkQuota(env);
+            } catch (e) { console.log(e); }
+          }
+        } catch (e) { console.log(e); }
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly licenseChangeFallback = async (): Promise<void> => {
+    try {
+      const licenses = await organizationLicenseController.list({
+        enabled: true,
+        internal: { notified: false },
+      });
+
+      const [organizations, services] = await Promise.all([
+        organizationController.list({ id: { in: _.uniq(licenses.map((l) => l.organization)) } }),
+        adminServiceController.list({ id: { in: _.uniq(licenses.map((l) => l.service)) }, enabled: true }),
+      ]);
+
+      for (const l of licenses) {
+        try {
+          const organization = organizations.find((o) => o.id === l.organization);
+          if (!organization) { throw new Error(`Organization with id ${l.organization} not found.`); }
+
+          const service = services.find((s) => s.id === l.service);
+          if (!service) { throw new Error(`Service with id ${l.service} not found.`); }
+
+          if (service.internal.host && service.internal.organization?.modified) {
+            console.log(`[>] Notifying organization ${l.organization} license change`.yellow);
+
+            await Requester.patch(`${service.internal.organization?.modified}/${organization.uuid}`,
+              null,
+              {
+                baseURL: service.internal.host,
+                headers: {
+                  "x-service-uuid": service.uuid,
+                  "x-service-token": service.token,
+                },
+              });
+          }
+
+          await organizationLicenseController.update(l.id, { internal: { notified: null } });
+        } catch (e) { console.error(`Failed to notify organization license ${l.id}`, e); }
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly billingCycles = async (): Promise<void> => {
+    try {
+      const organizations = await organizationController.list({
+        status: { is: OrganizationStatus.Blocked, inverse: true },
+      });
+
+      for (const organization of organizations) {
+        try {
+          await billingController.cycleContext(organization);
+        } catch (e) { console.log(`Could not generate organization ${organization.id} cycle`, e); }
+
+        try {
+          await billingController.trialWarningCheck(organization);
+        } catch (e) { console.log(`Could not check trial warning for organization ${organization.id}`, e); }
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly invoices = async (): Promise<void> => {
+    try {
+      const organizations = await organizationController.list({
+        status: { is: OrganizationStatus.Blocked, inverse: true },
+      });
+
+      for (const organization of organizations) {
+        try {
+          await billingController.generateLicensesInvoice(organization);
+        } catch (e) { console.log(`Could not generate organization ${organization.id} invoice`, e); }
+      }
+    } catch (e) { throw e; }
+  };
+}
+
+const scheduleController = new ScheduleController();
+export default scheduleController;