prow-authority 3.6.3

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

@@ -0,0 +1,160 @@
+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 licenseLimitDao from "../../daos/license-limit-dao";
+import { addLicenseLimitSchema, updateLicenseLimitSchema } from "../../schemas/admin/license-limit-schemas";
+import { DBRecord, LicenseLimit } from "../../types/admin/license-limit-types";
+import licenseController from "./license-controller";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<LicenseLimit, `id`>;
+type Update = DeepPartial<Omit<LicenseLimit, `id`>>;
+
+class LicenseLimitCtrl {
+
+  public readonly get = async (id: number): Promise<LicenseLimit[]> => {
+    try {
+      const db = await licenseLimitDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<LicenseLimit>, options: Modifiers = {}): Promise<LicenseLimit[]> => {
+    try {
+      const db = await licenseLimitDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<LicenseLimit[]> => {
+    try {
+      await Validator.validateAsync(addLicenseLimitSchema, data);
+      await this.check(data);
+
+      const { insertId } = await licenseLimitDao.add({
+        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_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<LicenseLimit[]> => {
+    try {
+      await Validator.validateAsync(updateLicenseLimitSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `LicenseLimit with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as LicenseLimit;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await licenseLimitDao.update({ id: id }, {
+        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_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: `LicenseLimit with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await licenseLimitDao.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 | LicenseLimit, old?: LicenseLimit): Promise<void> => {
+    try {
+      if (!old || data.license !== old.license) {
+        const license = (await licenseController.list({ id: data.license, enabled: true }))[0];
+        if (!license) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `No enabled license ${data.license} found.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<LicenseLimit[]> => {
+    try {
+      const response: LicenseLimit[] = [];
+
+      for (const record of records) {
+        const p: LicenseLimit = {
+          id: record.id,
+          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_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 licenseLimitController = new LicenseLimitCtrl();
+export default licenseLimitController;

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

@@ -0,0 +1,115 @@
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import { NotificationEventNames } from "../../../helpers/authority";
+import nconf from "../../../helpers/config";
+import notifications from "../../../helpers/notifications";
+import { Organization } from "../../types/admin/organization-types";
+import { UserOrganization } from "../../types/admin/user-organization-types";
+import { User, UserStatus } from "../../types/admin/user-types";
+import { TempCodeType } from "../../types/auth/otp-types";
+import tempCodeController from "../auth/temp-code-controller";
+import userController from "./user-controller";
+
+class NotificationController {
+
+  public readonly confirmation = async (id: User[`id`]): Promise<{ done: true }> => {
+    try {
+      const user = (await userController.get(id, { password: false }))[0];
+      if (!user) { throw new Error(`No user found with id ${id}`); }
+
+      if (user.status !== UserStatus.Pending) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `User is already confirmed.`,
+        });
+      }
+
+      const confirmation = await tempCodeController.generate(TempCodeType.Confirmation, user);
+
+      await notifications.gmail({
+        template: nconf.get(`SERVICES:NOTIFICATIONS:GMAIL:TEMPLATES:CONFIRMATION`),
+        locale: user.preferences.language,
+        to: [user.email],
+        arguments: confirmation,
+      });
+
+      return { done: true };
+    } catch (e) { throw e; }
+  };
+
+  public readonly password = async (id: User[`id`]): Promise<{ done: true }> => {
+    try {
+      const user = (await userController.get(id, { password: false }))[0];
+      if (!user) { throw new Error(`No user found with id ${id}`); }
+
+      if (user.status === UserStatus.Blocked) {
+        throw new APIError({
+          code: StatusCodes.FORBIDDEN,
+          detail: `User is blocked.`,
+        });
+      }
+
+      const password = await tempCodeController.generate(TempCodeType.Password, user);
+
+      await notifications.gmail({
+        template: nconf.get(`SERVICES:NOTIFICATIONS:GMAIL:TEMPLATES:PASSWORD`),
+        locale: user.preferences.language,
+        to: [user.email],
+        arguments: password,
+      });
+
+      return { done: true };
+    } catch (e) { throw e; }
+  };
+
+  public readonly otp = async (id: User[`id`]): Promise<{ done: true }> => {
+    try {
+      const user = (await userController.get(id, { password: false }))[0];
+      if (!user) { throw new Error(`No user found with id ${id}`); }
+
+      if (user.status === UserStatus.Blocked) {
+        throw new APIError({
+          code: StatusCodes.FORBIDDEN,
+          detail: `User is blocked.`,
+        });
+      }
+
+      const otp = await tempCodeController.generate(TempCodeType.OTP, user);
+
+      await notifications.gmail({
+        template: nconf.get(`SERVICES:NOTIFICATIONS:GMAIL:TEMPLATES:OTP`),
+        locale: user.preferences.language,
+        to: [user.email],
+        arguments: otp,
+      });
+
+      return { done: true };
+    } catch (e) { throw e; }
+  };
+
+  public readonly invitation = async (user: User, access: UserOrganization, organization: Organization): Promise<{ done: true }> => {
+    try {
+      await notifications.gmail({
+        template: nconf.get(`SERVICES:NOTIFICATIONS:GMAIL:TEMPLATES:INVITATION`),
+        locale: user.preferences.language,
+        to: [user.email],
+        arguments: {
+          event: NotificationEventNames.MemberInvited,
+          data: {
+            organization: organization,
+            role: access.role,
+            cta: {
+              organizations: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_LIST`),
+              preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+            },
+          },
+        },
+      });
+
+      return { done: true };
+    } catch (e) { throw e; }
+  };
+
+}
+
+const notificationController = new NotificationController();
+export default notificationController;

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

@@ -0,0 +1,210 @@
+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/uuids";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Schema, Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import organizationDao from "../../daos/organization-dao";
+import { addOrganizationSchema, updateOrganizationSchema } from "../../schemas/admin/organization-schemas";
+import { DBRecord, Organization, OrganizationStatus } from "../../types/admin/organization-types";
+import { uploadFile, deleteFile } from "../../../helpers/s3";
+import { performance } from "perf_hooks";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<Organization, `id` | `uuid` | `created_date` | `modified_date`>;
+
+type Update = DeepPartial<Add>;
+
+type Options = { timestamp?: true, deletion?: boolean };
+
+class OrganizationCtrl {
+  public readonly get = async (id: number, options: Options = {}): Promise<Organization[]> => {
+    try {
+      const db = await organizationDao.get({ id: id });
+      const response = await this.parse(db, options);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<Organization>, options: Options & Modifiers = {}): Promise<Organization[]> => {
+    try {
+      const db = await organizationDao.list({ ...params }, options);
+      const response = await this.parse(db, options);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add, options: Options = {}): Promise<Organization[]> => {
+    try {
+      Validator.validate(addOrganizationSchema, data);
+      await this.check(data);
+
+      const uuid = await this.getFreeUUID();
+
+      if (data.properties.image) {
+        data.properties.image =
+          data.properties.image.startsWith(`http`) ?
+            data.properties.image :
+            await uploadFile({
+              entity: `organizations`,
+              uuid: uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      if (data.properties.cover) {
+        data.properties.cover =
+          data.properties.cover.startsWith(`http`) ?
+            data.properties.cover :
+            await uploadFile({
+              entity: `organizations`,
+              uuid: uuid,
+              name: `cover`,
+            }, data.properties.cover);
+      }
+
+      const { insertId } = await organizationDao.add({
+        uuid: uuid,
+        properties: data.properties,
+        billing: data.billing,
+        preferences: data.preferences,
+        status: data.status,
+        metadata: data.metadata,
+        internal: data.internal,
+      });
+
+      return await this.get(insertId, options);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update, options: Options = {}): Promise<Organization[]> => {
+    try {
+      Validator.validate(updateOrganizationSchema(options.deletion), data);
+
+      const old = (await this.get(id, {}))[0];
+      if (!old) { throw new Error(`Organization with id ${id} doesn't exist`); }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as Organization;
+
+      await this.check(merged, old);
+
+      if (data.properties?.image === null && old.properties.image) {
+        await deleteFile({
+          entity: `organizations`,
+          uuid: merged.uuid,
+          name: `avatar`,
+        });
+        merged.properties.image = null;
+      } else if (data.properties?.image) {
+        merged.properties.image =
+          data.properties.image.startsWith(`http`) ?
+            data.properties.image :
+            await uploadFile({
+              entity: `organizations`,
+              uuid: merged.uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      if (data.properties?.cover === null && old.properties.cover) {
+        await deleteFile({
+          entity: `organizations`,
+          uuid: merged.uuid,
+          name: `cover`,
+        });
+        merged.properties.cover = null;
+      } else if (data.properties?.cover) {
+        merged.properties.cover =
+          data.properties.cover.startsWith(`http`) ?
+            data.properties.cover :
+            await uploadFile({
+              entity: `organizations`,
+              uuid: merged.uuid,
+              name: `cover`,
+            }, data.properties.cover);
+      }
+
+      const { affectedRows } = await organizationDao.update({ id: id }, {
+        uuid: old.uuid,
+        properties: merged.properties,
+        billing: merged.billing,
+        preferences: merged.preferences,
+        status: merged.status,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) { throw new Error(`Could not update organization with id ${id}`); }
+
+      return await this.get(id, options);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      Validator.validate(Schema.number(), id);
+      const { affectedRows } = await organizationDao.delete({ 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 organizationDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private readonly check = async (data: Add | Organization, old?: Organization): Promise<void> => {
+    try {
+      // nothing to check at the moment
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  private readonly parse = async (records: DBRecord[], options: Options = {}): Promise<Organization[]> => {
+    try {
+      const response: Organization[] = [];
+
+      for (const record of records) {
+        // ignore deleted organizations
+        if (!Object.values(OrganizationStatus).includes(record.status)) { continue; }
+
+        const p: Organization = {
+          id: record.id,
+          uuid: record.uuid,
+          properties: {
+            name: record.properties.name,
+            activity: record.properties.activity,
+            ...record.properties.image ? { image: `${record.properties.image}${options.timestamp ? `?ts=${performance.now()}` : ``}` } : {},
+            ...record.properties.cover ? { cover: `${record.properties.cover}${options.timestamp ? `?ts=${performance.now()}` : ``}` } : {},
+          },
+          billing: record.billing,
+          preferences: record.preferences,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          status: record.status,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const organizationController = new OrganizationCtrl();
+export default organizationController;