prow-authority 3.6.3

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

@@ -0,0 +1,109 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/organization-types';
+import { Modifiers } from '../common-types';
+
+class OrganizationDao {
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `organization`,
+        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: `organization`,
+        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 organization (uuid, properties, billing, preferences, metadata, internal, created_date, modified_date, status) values (?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.billing || {}),
+        JSON.stringify(data.preferences || {}),
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        new Date(),
+        new Date(),
+        data.status,
+      ];
+      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 organization set
+        uuid = ?,
+        properties = ?,
+        preferences = ?,
+        billing = ?,
+        metadata = ?,
+        internal = ?,
+        modified_date = ?,
+        status = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.preferences || {}),
+        JSON.stringify(data.billing || {}),
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        new Date(),
+        data.status,
+        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: `organization`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const organizationDao = new OrganizationDao();
+export default organizationDao;

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

@@ -0,0 +1,117 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBPrices, DBRecord } from '../types/admin/organization-license-types';
+import { Modifiers } from '../common-types';
+
+class OrganizationLicenseDao {
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        // view for enabled computed value
+        from: `organization_license_enabled`,
+        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: `*`,
+        // view for enabled computed value
+        from: `organization_license_enabled`,
+        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 | `enabled`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into organization_license (uuid, organization, service, type, associated, original, billing, properties, data, start_date, end_date, metadata, internal) values (?,?,?,?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.service,
+        data.type,
+        data.associated,
+        data.original,
+        data.billing,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.data || {}),
+        data.start_date ? new Date(data.start_date) : null,
+        data.end_date ? new Date(data.end_date) : null,
+        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` | keyof DBPrices | `enabled`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update organization_license set
+        uuid = ?,
+        organization = ?,
+        service = ?,
+        type = ?,
+        associated = ?,
+        original = ?,
+        billing = ?,
+        properties = ?,
+        data = ?,
+        start_date = ?,
+        end_date = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.service,
+        data.type,
+        data.associated,
+        data.original,
+        data.billing,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.data || {}),
+        data.start_date ? new Date(data.start_date) : null,
+        data.end_date ? new Date(data.end_date) : null,
+        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: `organization_license`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const organizationLicenseDao = new OrganizationLicenseDao();
+export default organizationLicenseDao;

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

@@ -0,0 +1,157 @@
+import { MySQL, Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/organization-license-limit-types';
+import _ from 'lodash';
+import { Modifiers } from '../common-types';
+
+class OrganizationLicenseLimitDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `organization_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: `organization_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 count = async (params: Where<DBRecord>, group: string[] = []): Promise<({ count: number } & Record<string, any>)[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: _.compact([
+          ...group,
+          { field: `count(id)`, alias: `count` },
+        ]),
+        from: `organization_license_limit`,
+        where: params,
+        ...group.length > 0 && { group: group },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly sum = async (sum: string, params: Where<DBRecord>, group: string[] = []): Promise<({ sum: string } & Record<string, any>)[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: _.compact([
+          ...group,
+          { field: `sum(${MySQL[`getKey`](sum)})`, alias: `sum` },
+        ]),
+        from: `organization_license_limit`,
+        where: params,
+        ...group.length > 0 && { group: group },
+      });
+      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 organization_license_limit (organization, license, name, \`limit\`, period, monthly_price_abs, annual_price_abs, overconsume, overconsume_monthly_price_per_unit, overconsume_annual_price_per_unit, metadata) values (?,?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.organization,
+        data.license,
+        data.name,
+        data.limit,
+        data.period,
+        data.monthly_price_abs,
+        data.annual_price_abs,
+        data.overconsume,
+        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`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update organization_license_limit set
+        organization = ?,
+        license = ?,
+        name = ?,
+        \`limit\` = ?,
+        period = ?,
+        monthly_price_abs = ?,
+        annual_price_abs = ?,
+        overconsume = ?,
+        overconsume_monthly_price_per_unit = ?,
+        overconsume_annual_price_per_unit = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.organization,
+        data.license,
+        data.name,
+        data.limit,
+        data.period,
+        data.monthly_price_abs,
+        data.annual_price_abs,
+        data.overconsume,
+        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: `organization_license_limit`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const organizationLicenseLimitDao = new OrganizationLicenseLimitDao();
+export default organizationLicenseLimitDao;

package/src/v1/daos/organization-usage-dao.ts

@@ -0,0 +1,115 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { Modifiers } from '../common-types';
+import { DBRecord } from '../types/admin/organization-usage-types';
+
+class OrganizationUsageDao {
+
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `organization_usage`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord> | Where<DBRecord>[], modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `organization_usage`,
+        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) },
+          },
+        },
+      });
+
+      // ÑAPA: force index
+      const forcedIndexQuery = q.replace(`from organization_usage`, `from organization_usage force index (idx_lookup_optimized)`);
+
+      const response = await mySql.promiseQuery(forcedIndexQuery, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Omit<DBRecord, `id` | `date`>): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into organization_usage (organization, service, name, count) values (?,?,?,?)`;
+      const p = [
+        data.organization,
+        data.service,
+        data.name,
+        data.count,
+      ];
+      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` | `date`>): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update organization_usage set
+        organization = ?,
+        service = ?,
+        name = ?,
+        count = ?
+      where id = ?`;
+      const p = [
+        data.organization,
+        data.service,
+        data.name,
+        data.count,
+        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: `organization_usage`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly sum = async (params: Where<DBRecord>): Promise<{ total: number }[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: [{ field: `sum(count)`, alias: `total` }],
+        from: `organization_usage`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const organizationUsageDao = new OrganizationUsageDao();
+export default organizationUsageDao;

package/src/v1/daos/payment-method-dao.ts

@@ -0,0 +1,110 @@
+import mySql from "../../helpers/mysql";
+import { Modifiers } from "../common-types";
+import { DBRecord } from "../types/admin/payment-method-types";
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+
+class PaymentMethodDao {
+
+  public readonly get = async (params: Pick<DBRecord, `id`>): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `payment_method`,
+        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: `payment_method`,
+        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 payment_method (uuid, organization, type, properties, enabled, created_date, modified_date, metadata, internal) values (?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.type,
+        JSON.stringify(data.properties || {}),
+        data.enabled,
+        new Date(),
+        new 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 payment_method set
+        uuid = ?,
+        organization = ?,
+        type = ?,
+        properties = ?,
+        enabled = ?,
+        modified_date = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.organization,
+        data.type,
+        JSON.stringify(data.properties || {}),
+        data.enabled,
+        new 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: `payment_method`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const paymentMethodDao = new PaymentMethodDao();
+export default paymentMethodDao;