prow-authority 3.6.3

package/src/v1/controllers/admin/organization-license-controller.ts

@@ -0,0 +1,224 @@
+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 organizationLicenseDao from "../../daos/organization-license-dao";
+import { addOrganizationLicenseSchema, updateOrganizationLicenseSchema } from "../../schemas/admin/organization-license-schemas";
+import { DBRecord, OrganizationLicense } from "../../types/admin/organization-license-types";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import licenseController from "./license-controller";
+import organizationController from "./organization-controller";
+import serviceController from "./service-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<OrganizationLicense, `id` | `uuid` | `annual_price` | `monthly_price` | `enabled`>;
+type Update = DeepPartial<Omit<OrganizationLicense, `id` | `uuid` | `annual_price` | `monthly_price` | `enabled`>>;
+
+class OrganizationLicenseCtrl {
+
+  public readonly get = async (id: number): Promise<OrganizationLicense[]> => {
+    try {
+      const db = await organizationLicenseDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<OrganizationLicense>, options: Modifiers = {}): Promise<OrganizationLicense[]> => {
+    try {
+      const db = await organizationLicenseDao.list({ ...params } as any, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<OrganizationLicense[]> => {
+    try {
+      await Validator.validateAsync(addOrganizationLicenseSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await organizationLicenseDao.add({
+        uuid: uuid,
+        service: data.service,
+        organization: data.organization,
+        type: data.type,
+        associated: data.associated,
+        original: data.original,
+        billing: data.billing,
+        properties: data.properties,
+        data: data.data,
+        start_date: data.start_date,
+        end_date: data.end_date,
+        metadata: data.metadata,
+        internal: data.internal,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<OrganizationLicense[]> => {
+    try {
+      await Validator.validateAsync(updateOrganizationLicenseSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `OrganizationLicense with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as OrganizationLicense;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await organizationLicenseDao.update({ id: id }, {
+        uuid: merged.uuid,
+        service: merged.service,
+        organization: merged.organization,
+        type: merged.type,
+        associated: merged.associated,
+        original: merged.original,
+        billing: merged.billing,
+        properties: merged.properties,
+        data: merged.data,
+        start_date: merged.start_date,
+        end_date: merged.end_date,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update license with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const license = (await this.get(id))[0];
+      if (!license) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `OrganizationLicense with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await organizationLicenseDao.delete({ id: license.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete license with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | OrganizationLicense, old?: OrganizationLicense): Promise<void> => {
+    try {
+      if (!old || data.service !== old.service) {
+        const service = (await serviceController.list({ id: data.service, enabled: true }))[0];
+        if (!service) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled service ${data.service} found.`,
+          });
+        }
+      }
+
+      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.`,
+          });
+        }
+      }
+
+      if (!old || data.original !== old.original) {
+        const originalLicense = (await licenseController.list({ id: data.original }))[0];
+        if (!originalLicense) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled original license with id ${data.original} found.`,
+          });
+        }
+      }
+
+      if (!old || (data.associated && data.associated !== old.associated)) {
+        const associatedLicense = (await organizationLicenseDao.list({ id: data.associated }))[0];
+        if (!associatedLicense) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled associated license with id ${data.associated} found.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly getFreeUUID = async (): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await organizationLicenseDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<OrganizationLicense[]> => {
+    try {
+      const response: OrganizationLicense[] = [];
+
+      for (const record of records) {
+        const p: OrganizationLicense = {
+          id: record.id,
+          uuid: record.uuid,
+          service: record.service,
+          organization: record.organization,
+          associated: record.associated,
+          original: record.original,
+          type: record.type,
+          billing: record.billing,
+          properties: record.properties,
+          data: record.data,
+          start_date: new Date2(record.start_date).format(Formats.ISO),
+          end_date: record.end_date ? new Date2(record.end_date).format(Formats.ISO) : null,
+          annual_price: parseFloat(record.annual_price || `0`),
+          monthly_price: parseFloat(record.monthly_price || `0`),
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const organizationLicenseController = new OrganizationLicenseCtrl();
+export default organizationLicenseController;

package/src/v1/controllers/admin/organization-license-limit-controller.ts

@@ -0,0 +1,196 @@
+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 APIError, { StatusCodes } from "../../../helpers/api-error";
+import organizationOrganizationLicenseLimitDao from "../../daos/organization-license-limit-dao";
+import { addOrganizationLicenseLimitSchema, updateOrganizationLicenseLimitSchema } from "../../schemas/admin/organization-license-limit-schemas";
+import { DBRecord, OrganizationLicenseLimit } from "../../types/admin/organization-license-limit-types";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import organizationController from "./organization-controller";
+import organizationLicenseController from "./organization-license-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<OrganizationLicenseLimit, `id`>;
+type Update = DeepPartial<Omit<OrganizationLicenseLimit, `id`>>;
+
+class OrganizationLicenseLimitCtrl {
+
+  public readonly get = async (id: number): Promise<OrganizationLicenseLimit[]> => {
+    try {
+      const db = await organizationOrganizationLicenseLimitDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<OrganizationLicenseLimit>, options: Modifiers = {}): Promise<OrganizationLicenseLimit[]> => {
+    try {
+      const db = await organizationOrganizationLicenseLimitDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly sum = async (sum: string, params: Where<OrganizationLicenseLimit>, group: string[] = []) => {
+    try {
+      const response = await organizationOrganizationLicenseLimitDao.sum(sum, { ...params }, group);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly count = async (params: Where<OrganizationLicenseLimit>, group: string[] = []) => {
+    try {
+      const response = await organizationOrganizationLicenseLimitDao.count({ ...params }, group);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<OrganizationLicenseLimit[]> => {
+    try {
+      await Validator.validateAsync(addOrganizationLicenseLimitSchema, data);
+      await this.check(data);
+
+      const { insertId } = await organizationOrganizationLicenseLimitDao.add({
+        organization: data.organization,
+        license: data.license,
+        name: data.name,
+        limit: data.limit,
+        period: data.period,
+        monthly_price_abs: data.monthly_price_abs,
+        annual_price_abs: data.annual_price_abs,
+        overconsume: data.overconsume,
+        overconsume_monthly_price_per_unit: data.overconsume_monthly_price_per_unit,
+        overconsume_annual_price_per_unit: data.overconsume_annual_price_per_unit,
+        metadata: data.metadata,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<OrganizationLicenseLimit[]> => {
+    try {
+      await Validator.validateAsync(updateOrganizationLicenseLimitSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `OrganizationLicenseLimit with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as OrganizationLicenseLimit;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await organizationOrganizationLicenseLimitDao.update({ id: id }, {
+        organization: merged.organization,
+        license: merged.license,
+        name: merged.name,
+        limit: merged.limit,
+        period: merged.period,
+        monthly_price_abs: merged.monthly_price_abs,
+        annual_price_abs: merged.annual_price_abs,
+        overconsume: merged.overconsume,
+        overconsume_monthly_price_per_unit: merged.overconsume_monthly_price_per_unit,
+        overconsume_annual_price_per_unit: merged.overconsume_annual_price_per_unit,
+        metadata: merged.metadata,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update license with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const license = (await this.get(id))[0];
+      if (!license) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `OrganizationLicenseLimit with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await organizationOrganizationLicenseLimitDao.delete({ id: license.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete license with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | OrganizationLicenseLimit, old?: OrganizationLicenseLimit): Promise<void> => {
+    try {
+      if (!old || data.license !== old.license) {
+        const license = (await organizationLicenseController.list({ id: data.license }))[0];
+        if (!license) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled license ${data.license} found.`,
+          });
+        }
+      }
+
+      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<OrganizationLicenseLimit[]> => {
+    try {
+      const response: OrganizationLicenseLimit[] = [];
+
+      for (const record of records) {
+        const p: OrganizationLicenseLimit = {
+          id: record.id,
+          organization: record.organization,
+          license: record.license,
+          name: record.name,
+          limit: record.limit,
+          period: record.period,
+          monthly_price_abs: parseFloat(record.monthly_price_abs as any),
+          annual_price_abs: parseFloat(record.annual_price_abs as any),
+          overconsume: record.overconsume ? true : false,
+          overconsume_monthly_price_per_unit: record.overconsume_monthly_price_per_unit ? parseFloat(record.overconsume_monthly_price_per_unit as any) : null,
+          overconsume_annual_price_per_unit: record.overconsume_annual_price_per_unit ? parseFloat(record.overconsume_annual_price_per_unit as any) : null,
+          metadata: record.metadata,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const organizationLicenseLimitController = new OrganizationLicenseLimitCtrl();
+export default organizationLicenseLimitController;

package/src/v1/controllers/admin/organization-usage-controller.ts

@@ -0,0 +1,167 @@
+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 { 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 organizationUsageDao from "../../daos/organization-usage-dao";
+import { addOrganizationUsageSchema, updateOrganizationUsageSchema } from "../../schemas/admin/organization-usage-schemas";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import { DBRecord, OrganizationUsage, Sum } from "../../types/admin/organization-usage-types";
+import organizationController from "./organization-controller";
+import serviceController from "./service-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<OrganizationUsage, `id` | `date`>;
+type Update = DeepPartial<Omit<OrganizationUsage, `id` | `date`>>;
+
+class OrganizationUsageCtrl {
+
+  public readonly get = async (id: number): Promise<OrganizationUsage[]> => {
+    try {
+      const db = await organizationUsageDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<OrganizationUsage> | Where<OrganizationUsage>[], options: Modifiers = {}): Promise<OrganizationUsage[]> => {
+    try {
+      const db = await organizationUsageDao.list(params, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<OrganizationUsage[]> => {
+    try {
+      await Validator.validateAsync(addOrganizationUsageSchema, data);
+      await this.check(data);
+
+      const { insertId } = await organizationUsageDao.add({
+        service: data.service,
+        organization: data.organization,
+        name: data.name,
+        count: data.count,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<OrganizationUsage[]> => {
+    try {
+      await Validator.validateAsync(updateOrganizationUsageSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `OrganizationUsage with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as OrganizationUsage;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await organizationUsageDao.update({ id: id }, {
+        service: merged.service,
+        organization: merged.organization,
+        name: merged.name,
+        count: merged.count,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update license with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const license = (await this.get(id))[0];
+      if (!license) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Organization usage with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await organizationUsageDao.delete({ id: license.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete license with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  public readonly sum = async (params: Where<OrganizationUsage>): Promise<Sum[]> => {
+    try {
+      const db = await organizationUsageDao.sum(params);
+      const response = db.map((d): Sum => ({ total: parseFloat(d.total as any) }));
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | OrganizationUsage, old?: OrganizationUsage): Promise<void> => {
+    try {
+      if (!old || data.service !== old.service) {
+        const service = (await serviceController.list({ id: data.service, enabled: true }))[0];
+        if (!service) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled service ${data.service} found.`,
+          });
+        }
+      }
+
+      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<OrganizationUsage[]> => {
+    try {
+      const response: OrganizationUsage[] = [];
+
+      for (const record of records) {
+        const p: OrganizationUsage = {
+          id: record.id,
+          service: record.service,
+          organization: record.organization,
+          name: record.name,
+          count: parseFloat(record.count as any),
+          date: new Date2(record.date).format(Formats.ISO),
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const organizationUsageController = new OrganizationUsageCtrl();
+export default organizationUsageController;