prow-authority 3.6.3

package/src/v1/controllers/admin/billing-cycle-controller.ts

@@ -0,0 +1,171 @@
+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 billingCycleDao from "../../daos/billing-cycle-dao";
+import { addBillingCycleSchema, updateBillingCycleSchema } from "../../schemas/admin/billing-cycle-schemas";
+import { BillingCycle, DBRecord } from "../../types/admin/billing-cycle-types";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import organizationController from "./organization-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<BillingCycle, `id` | `uuid`>;
+type Update = DeepPartial<Omit<BillingCycle, `id` | `uuid`>>;
+
+class BillingCycleCtrl {
+
+  public readonly get = async (id: number): Promise<BillingCycle[]> => {
+    try {
+      const db = await billingCycleDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<BillingCycle>, options: Modifiers = {}): Promise<BillingCycle[]> => {
+    try {
+      const db = await billingCycleDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<BillingCycle[]> => {
+    try {
+      await Validator.validateAsync(addBillingCycleSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await billingCycleDao.add({
+        uuid: uuid,
+        organization: data.organization,
+        trial: data.trial,
+        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<BillingCycle[]> => {
+    try {
+      await Validator.validateAsync(updateBillingCycleSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Billing cycle with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as BillingCycle;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await billingCycleDao.update({ id: id }, {
+        uuid: merged.uuid,
+        organization: merged.organization,
+        trial: merged.trial,
+        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 billing cycle with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const billingCycle = (await this.get(id))[0];
+      if (!billingCycle) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Billing cycle with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await billingCycleDao.delete({ id: billingCycle.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete billing cycle 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 billingCycleDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | BillingCycle, old?: BillingCycle): 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<BillingCycle[]> => {
+    try {
+      const response: BillingCycle[] = [];
+
+      for (const record of records) {
+        const p: BillingCycle = {
+          id: record.id,
+          uuid: record.uuid,
+          organization: record.organization,
+          trial: (record.trial as any) === 1,
+          start_date: new Date2(record.start_date).format(Formats.ISO),
+          end_date: new Date2(record.end_date).format(Formats.ISO),
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const billingCycleController = new BillingCycleCtrl();
+export default billingCycleController;

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

@@ -0,0 +1,222 @@
+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 invoiceDao from "../../daos/invoice-dao";
+import { addInvoiceSchema, updateInvoiceSchema } from "../../schemas/admin/invoice-schemas";
+import { DBRecord, Invoice } from "../../types/admin/invoice-types";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import organizationController from "./organization-controller";
+import paymentMethodController from "./payment-method-controller";
+import _ from "lodash";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<Invoice, `id` | `uuid` | `amount` | `tax` | `base`>;
+type Update = DeepPartial<Omit<Invoice, `id` | `uuid` | `amount` | `tax` | `base`>>;
+
+class InvoiceCtrl {
+
+  public readonly get = async (id: number): Promise<Invoice[]> => {
+    try {
+      const db = await invoiceDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<Invoice>, options: Modifiers = {}): Promise<Invoice[]> => {
+    try {
+      const db = await invoiceDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<Invoice[]> => {
+    try {
+      await Validator.validateAsync(addInvoiceSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await invoiceDao.add({
+        uuid: uuid,
+        organization: data.organization,
+        date: data.date,
+        amount: this.getAmount(data),
+        tax_code: data.tax_code,
+        tax_percentage: data.tax_percentage,
+        concepts: data.concepts,
+        billing: data.billing,
+        status: data.status,
+        invoice: data.invoice,
+        number: data.number,
+        payment: data.payment,
+        method: data.method,
+        metadata: data.metadata,
+        internal: data.internal,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<Invoice[]> => {
+    try {
+      await Validator.validateAsync(updateInvoiceSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Billing cycle with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as Invoice;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await invoiceDao.update({ id: id }, {
+        uuid: merged.uuid,
+        organization: merged.organization,
+        date: merged.date,
+        amount: this.getAmount(merged),
+        tax_code: merged.tax_code,
+        tax_percentage: merged.tax_percentage,
+        concepts: merged.concepts,
+        billing: merged.billing,
+        status: merged.status,
+        invoice: merged.invoice,
+        number: merged.number,
+        payment: merged.payment,
+        method: merged.method,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update billing cycle with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const invoice = (await this.get(id))[0];
+      if (!invoice) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Billing cycle with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await invoiceDao.delete({ id: invoice.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete billing cycle 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 invoiceDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly PERCENT = 100;
+  private readonly getAmount = (invoice: Pick<Invoice, `concepts` | `tax_percentage`>): number => {
+    try {
+      const base = _.sum(invoice.concepts.map((c) => c.price));
+      const tax = (invoice.tax_percentage / this.PERCENT) * base;
+      return base + tax;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | Invoice, old?: Invoice): 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.`,
+          });
+        }
+      }
+
+      if (data.method && (!old || data.method !== old.method)) {
+        const method = (await paymentMethodController.list({ id: data.method, organization: data.organization }))[0];
+        if (!method) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No active method ${data.method} found.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<Invoice[]> => {
+    try {
+      const response: Invoice[] = [];
+
+      for (const record of records) {
+
+        const total = parseFloat(record.amount as any);
+        const base = _.sum(record.concepts.map((c) => c.price));
+
+        const p: Invoice = {
+          id: record.id,
+          uuid: record.uuid,
+          organization: record.organization,
+          date: new Date2(record.date).format(Formats.ISO),
+          base: base,
+          tax_code: record.tax_code,
+          tax_percentage: parseFloat(record.tax_percentage as any),
+          tax: total - base,
+          amount: total,
+          concepts: record.concepts,
+          billing: record.billing,
+          status: record.status,
+          invoice: record.invoice,
+          number: record.number,
+          payment: record.payment,
+          method: record.method,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const invoiceController = new InvoiceCtrl();
+export default invoiceController;

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

@@ -0,0 +1,190 @@
+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 licenseDao from "../../daos/license-dao";
+import { addLicenseSchema, updateLicenseSchema } from "../../schemas/admin/license-schemas";
+import { DBRecord, License, Prices } from "../../types/admin/license-types";
+import serviceController from "./service-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<License, `id` | keyof Prices | `created_date` | `modified_date`>;
+type Update = DeepPartial<Omit<License, `id` | keyof Prices | `created_date` | `modified_date`>>;
+
+class LicenseCtrl {
+
+  public readonly get = async (id: number): Promise<License[]> => {
+    try {
+      const db = await licenseDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<License>, options: Modifiers = {}): Promise<License[]> => {
+    try {
+      const db = await licenseDao.list({ ...params } as any, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<License[]> => {
+    try {
+      await Validator.validateAsync(addLicenseSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await licenseDao.add({
+        uuid: uuid,
+        service: data.service,
+        type: data.type,
+        associated: data.associated,
+        properties: data.properties,
+        data: data.data,
+        public: data.public,
+        enabled: data.enabled,
+        metadata: data.metadata,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<License[]> => {
+    try {
+      await Validator.validateAsync(updateLicenseSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `License with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as License;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await licenseDao.update({ id: id }, {
+        uuid: merged.uuid,
+        service: merged.service,
+        type: merged.type,
+        associated: merged.associated,
+        properties: merged.properties,
+        data: merged.data,
+        public: merged.public,
+        enabled: merged.enabled,
+        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: `License with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await licenseDao.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 getFreeUUID = async (): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await licenseDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | License, old?: License): 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.associated && data.associated !== old.associated)) {
+        const associatedLicense = (await licenseDao.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 parse = async (records: DBRecord[]): Promise<License[]> => {
+    try {
+      const response: License[] = [];
+
+      for (const record of records) {
+        const p: License = {
+          id: record.id,
+          uuid: record.uuid,
+          service: record.service,
+          type: record.type,
+          associated: record.associated || null,
+          properties: record.properties,
+          data: record.data,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          public: record.public,
+          annual_price: parseFloat(record.annual_price || `0`),
+          monthly_price: parseFloat(record.monthly_price || `0`),
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const licenseController = new LicenseCtrl();
+export default licenseController;