prow-authority 3.6.3

package/src/v1/daos/accounting-seat-dao.ts

@@ -0,0 +1,111 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/accounting-seat-types';
+import { Modifiers } from '../common-types';
+
+class AccountingSeatDao {
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `accounting_seat`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `accounting_seat`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (data: Omit<DBRecord, `id`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into accounting_seat (uuid, organization, invoice, date, amount, done, metadata, internal) values (?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.invoice,
+        new Date(data.date),
+        data.amount,
+        data.done ? 1 : 0,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (params: Pick<DBRecord, `id`>, data: Omit<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update accounting_seat set
+        uuid = ?,
+        organization = ?,
+        invoice = ?,
+        date = ?,
+        amount = ?,
+        done = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.invoice,
+        new Date(data.date),
+        data.amount,
+        data.done ? 1 : 0,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (params: Pick<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `accounting_seat`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly deleteIf = async (params: Where<DBRecord>): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `accounting_seat`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+}
+
+const accountingSeatDao = new AccountingSeatDao();
+export default accountingSeatDao;

package/src/v1/daos/billing-cycle-dao.ts

@@ -0,0 +1,107 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/billing-cycle-types';
+import { Modifiers } from '../common-types';
+
+class BillingCycleDao {
+
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `billing_cycle`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `billing_cycle`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Omit<DBRecord, `id` | `created_date` | `modified_date`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into billing_cycle (uuid, organization, trial, start_date, end_date, metadata, internal) values (?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.trial,
+        new Date(data.start_date),
+        new Date(data.end_date),
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (params: Pick<DBRecord, `id`>, data: Omit<DBRecord, `id` | `created_date` | `modified_date`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update billing_cycle set
+        uuid = ?,
+        organization = ?,
+        trial = ?,
+        start_date = ?,
+        end_date = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.trial,
+        new Date(data.start_date),
+        new Date(data.end_date),
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (params: Pick<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `billing_cycle`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+}
+
+const billingCycleDao = new BillingCycleDao();
+export default billingCycleDao;

package/src/v1/daos/invoice-dao.ts

@@ -0,0 +1,131 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/invoice-types';
+import { Modifiers } from '../common-types';
+
+class InvoiceDao {
+
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `invoice`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `invoice`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Omit<DBRecord, `id`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into invoice (uuid, organization, date, method, amount, tax_code, tax_percentage, concepts, billing, status, invoice, number, payment, metadata, internal) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.organization,
+        new Date(data.date),
+        data.method,
+        data.amount,
+        data.tax_code,
+        data.tax_percentage,
+        JSON.stringify(data.concepts || []),
+        JSON.stringify(data.billing || {}),
+        data.status,
+        data.invoice,
+        data.number || null,
+        data.payment,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (params: Pick<DBRecord, `id`>, data: Omit<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update invoice set
+        uuid = ?,
+        organization = ?,
+        date = ?,
+        method = ?,
+        amount = ?,
+        tax_code = ?,
+        tax_percentage = ?,
+        concepts = ?,
+        billing = ?,
+        status = ?,
+        invoice = ?,
+        number = ?,
+        payment = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.organization,
+        new Date(data.date),
+        data.method,
+        data.amount,
+        data.tax_code,
+        data.tax_percentage,
+        JSON.stringify(data.concepts || []),
+        JSON.stringify(data.billing || {}),
+        data.status,
+        data.invoice,
+        data.number || null,
+        data.payment,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (params: Pick<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `invoice`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+}
+
+const invoiceDao = new InvoiceDao();
+export default invoiceDao;

package/src/v1/daos/license-dao.ts

@@ -0,0 +1,152 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBPrices, DBRecord } from '../types/admin/license-types';
+import { DBRecord as LicenseLimit } from '../types/admin/license-limit-types';
+import { Modifiers } from '../common-types';
+
+class LicenseDao {
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `license_prices`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `license_prices`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Omit<DBRecord, `id` | keyof DBPrices | `created_date` | `modified_date`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into license (uuid, service, type, associated, properties, data, created_date, modified_date, public, enabled, metadata) values (?,?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.service,
+        data.type,
+        data.associated,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.data || {}),
+        new Date(),
+        new Date(),
+        data.public,
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (params: Pick<DBRecord, `id`>, data: Omit<DBRecord, `id` | keyof DBPrices | `created_date` | `modified_date`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update license set
+        uuid = ?,
+        service = ?,
+        type = ?,
+        associated = ?,
+        properties = ?,
+        data = ?,
+        modified_date = ?,
+        public = ?,
+        enabled = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.service,
+        data.type,
+        data.associated,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.data || {}),
+        new Date(),
+        data.public,
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (params: Pick<DBRecord, `id`>): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `license`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly prices = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBPrices[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<{ l: DBRecord, ll: LicenseLimit }>({
+        select: [
+          { field: `sum(ll.monthly_price_abs)`, alias: `monthly_price` },
+          { field: `sum(ll.annual_price_abs)`, alias: `annual_price` },
+        ],
+        from: {
+          table: `license`,
+          alias: `l`,
+          join: [
+            {
+              type: `inner`,
+              table: `license_limit`,
+              alias: `ll`,
+              on: [
+                {
+                  origin: `id`,
+                  rel: `=`,
+                  destiny: `license`,
+                },
+              ],
+            },
+          ],
+        },
+        where: { l: params },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const licenseDao = new LicenseDao();
+export default licenseDao;

package/src/v1/daos/license-limit-dao.ts

@@ -0,0 +1,120 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/license-limit-types';
+import { Modifiers } from '../common-types';
+
+class LicenseLimitDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `license_limit`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `license_limit`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into license_limit (license, name, \`limit\`, period, monthly_price_abs, annual_price_abs, overconsume_monthly_price_per_unit, overconsume_annual_price_per_unit, metadata) values (?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.license,
+        data.name,
+        data.limit,
+        data.period,
+        data.monthly_price_abs,
+        data.annual_price_abs,
+        data.overconsume_monthly_price_per_unit,
+        data.overconsume_annual_price_per_unit,
+        JSON.stringify(data.metadata || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (
+    params: Pick<DBRecord, `id`>,
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update license_limit set
+        license = ?,
+        name = ?,
+        \`limit\` = ?,
+        period = ?,
+        monthly_price_abs = ?,
+        annual_price_abs = ?,
+        overconsume_monthly_price_per_unit = ?,
+        overconsume_annual_price_per_unit = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.license,
+        data.name,
+        data.limit,
+        data.period,
+        data.monthly_price_abs,
+        data.annual_price_abs,
+        data.overconsume_monthly_price_per_unit,
+        data.overconsume_annual_price_per_unit,
+        JSON.stringify(data.metadata || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `license_limit`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const licenseLimitDao = new LicenseLimitDao();
+export default licenseLimitDao;