prow-authority 3.6.3

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

@@ -0,0 +1,206 @@
+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 { deleteFile, uploadFile } from "../../../helpers/s3";
+import { ALPHANUMERIC_CHARSET, generateRandomString } from "../../../helpers/random";
+import serviceDao from "../../daos/service-dao";
+import { addServiceSchema, updateServiceSchema } from "../../schemas/admin/service-schemas";
+import { DBRecord, Service } from "../../types/admin/service-types";
+import nconf from "../../../helpers/config";
+import { performance } from "perf_hooks";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<Service, `id` | `uuid` | `enabled` | `created_date` | `modified_date`>;
+type Update = DeepPartial<Omit<Service, `id` | `uuid` | `created_date` | `modified_date`>>;
+
+class ServiceCtrl {
+
+  private readonly SERVICE_TOKEN_LENGTH = 100;
+
+  public readonly get = async (id: number): Promise<Service[]> => {
+    try {
+      const db = await serviceDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<Service>, options: Modifiers = {}): Promise<Service[]> => {
+    try {
+      const db = await serviceDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<Service[]> => {
+    try {
+      await Validator.validateAsync(addServiceSchema, 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: `services`,
+              uuid: uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      const { insertId } = await serviceDao.add({
+        uuid: uuid,
+        token: generateRandomString(ALPHANUMERIC_CHARSET, nconf.get(`SERVICES:AUTH:SERVICE:LENGTH`)),
+        properties: data.properties,
+        preferences: data.preferences,
+        enabled: true,
+        metadata: data.metadata,
+        internal: data.internal,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<Service[]> => {
+    try {
+      await Validator.validateAsync(updateServiceSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as Service;
+
+      await this.check(merged, old);
+
+      if (data.properties?.image === null && old.properties.image) {
+        await deleteFile({
+          entity: `services`,
+          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: `services`,
+              uuid: merged.uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      if (data.token) { merged.token = generateRandomString(ALPHANUMERIC_CHARSET, nconf.get(`SERVICES:AUTH:SERVICE:LENGTH`)); }
+
+      const { affectedRows } = await serviceDao.update({ id: id }, {
+        uuid: merged.uuid,
+        token: merged.token,
+        properties: merged.properties,
+        preferences: merged.preferences,
+        enabled: merged.enabled,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update service with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const service = (await this.get(id))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await serviceDao.delete({ id: service.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete service 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 serviceDao.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 | Service, old?: Service): Promise<void> => {
+    try {
+      // TODO: nothing to check
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<Service[]> => {
+    try {
+      const response: Service[] = [];
+
+      for (const record of records) {
+        const p: Service = {
+          id: record.id,
+          uuid: record.uuid,
+          token: record.token,
+          properties: {
+            name: record.properties.name,
+            description: record.properties.description,
+            home: record.properties.home,
+            image: `${record.properties.image}?ts=${performance.now()}`,
+          },
+          preferences: record.preferences,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const serviceController = new ServiceCtrl();
+export default serviceController;

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

@@ -0,0 +1,166 @@
+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 serviceNotificationDao from "../../daos/service-notification-dao";
+import { addServiceNotificationSchema, updateServiceNotificationSchema } from "../../schemas/admin/service-notification-schemas";
+import { DBRecord, ServiceNotification } from "../../types/admin/service-notification-types";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<ServiceNotification, `id` | `enabled` | `created_date` | `modified_date`>;
+type Update = DeepPartial<Omit<ServiceNotification, `id` | `created_date` | `modified_date`>>;
+
+class ServiceNotificationCtrl {
+
+  public readonly get = async (id: number): Promise<ServiceNotification[]> => {
+    try {
+      const db = await serviceNotificationDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, options: Modifiers = {}): Promise<ServiceNotification[]> => {
+    try {
+      const db = await serviceNotificationDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<ServiceNotification[]> => {
+    try {
+      await Validator.validateAsync(addServiceNotificationSchema, data);
+      await this.check(data);
+
+      const { insertId } = await serviceNotificationDao.add({
+        service: data.service,
+        event: data.event,
+        template: data.template,
+        scope: data.scope,
+        default: data.default,
+        enabled: true,
+        metadata: data.metadata,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<ServiceNotification[]> => {
+    try {
+      await Validator.validateAsync(updateServiceNotificationSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service notification with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as ServiceNotification;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await serviceNotificationDao.update({ id: id }, {
+        service: merged.service,
+        event: merged.event,
+        template: merged.template,
+        scope: merged.scope,
+        default: merged.default,
+        enabled: merged.enabled,
+        metadata: merged.metadata,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update service notification with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const serviceNotification = (await this.get(id))[0];
+      if (!serviceNotification) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service notification with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await serviceNotificationDao.delete({ id: serviceNotification.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete service notification with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | ServiceNotification, old?: ServiceNotification): Promise<void> => {
+    try {
+      if (!old || data.service !== old.service || data.event !== old.event) {
+        const existing = await this.list({ service: data.service, event: data.event, enabled: true });
+        const conflict = existing.find((e) => !old || e.id !== old.id);
+        if (conflict) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `A service notification for service ${data.service} and event '${data.event}' already exists (id: ${conflict.id}).`,
+          });
+        }
+      }
+
+      if (data.scope && data.scope.roles) {
+        const allowed = [`owner`, `admin`, `staff`];
+        if (!Array.isArray(data.scope.roles) || !data.scope.roles.every((r) => allowed.includes(r))) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `scope.roles must be a subset of ${JSON.stringify(allowed)}.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<ServiceNotification[]> => {
+    try {
+      const response: ServiceNotification[] = [];
+
+      for (const record of records) {
+        const p: ServiceNotification = {
+          id: record.id,
+          service: record.service,
+          event: record.event,
+          template: record.template,
+          scope: record.scope,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          default: record.default ? true : false,
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+        };
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const serviceNotificationController = new ServiceNotificationCtrl();
+export default serviceNotificationController;

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

@@ -0,0 +1,282 @@
+import { Hash } from "@beseif-solutions/utility-functions/dist/utils/crypto-utils";
+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 _ from "lodash";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import nconf from "../../../helpers/config";
+import { deleteFile, uploadFile } from "../../../helpers/s3";
+import userDao from "../../daos/user-dao";
+import { addUserSchema, updateUserSchema } from "../../schemas/admin/user-schemas";
+import { UserOrganizationRole } from "../../types/admin/user-organization-types";
+import { DBRecord, User, UserStatus } from "../../types/admin/user-types";
+import identityTokenController from "../auth/identity-token-controller";
+import userOrganizationController from "./user-organization-controller";
+import { performance } from "perf_hooks";
+import { Modifiers } from "../../common-types";
+
+type Add = Partial<Omit<User, `id` | `uuid` | `status` | `created_date` | `modified_date`>>;
+
+type Update = DeepPartial<Omit<User, `id` | `uuid` | `status` | `created_date` | `modified_date`>>;
+
+type Options = { password: boolean, timestamp?: true };
+
+class UserCtrl {
+
+  public readonly get = async (id: number, options: Options): Promise<User[]> => {
+    try {
+      const db = await userDao.get({ id: id });
+      const response = await this.parse(db, options);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<User>, options: Options & Modifiers): Promise<User[]> => {
+    try {
+      const db = await userDao.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<User[]> => {
+    try {
+      await Validator.validateAsync(addUserSchema, 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: `users`,
+              uuid: uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      const { insertId } = await userDao.add({
+        uuid: uuid,
+        email: data.email,
+        password: data.password ? this.hashPassword(data.password) : null,
+        properties: data.properties,
+        preferences: data.preferences,
+        utm: data.utm,
+        referrer: data.referrer,
+        omnipotent: data.omnipotent,
+        status: UserStatus.Pending,
+        metadata: data.metadata,
+      });
+
+      return await this.get(insertId, options);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update, options: Options): Promise<User[]> => {
+    try {
+      await Validator.validateAsync(updateUserSchema, data);
+
+      const old = (await this.get(id, { password: true }))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as User;
+
+      await this.check(merged, old);
+
+      if (data.properties?.image === null && old.properties.image) {
+        await deleteFile({
+          entity: `users`,
+          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: `users`,
+              uuid: merged.uuid,
+              name: `avatar`,
+            }, data.properties.image);
+      }
+
+      const { affectedRows } = await userDao.update({ id: id }, {
+        uuid: merged.uuid,
+        email: merged.email,
+        password: merged.password,
+        properties: merged.properties,
+        preferences: merged.preferences,
+        utm: merged.utm,
+        referrer: merged.referrer,
+        omnipotent: merged.omnipotent,
+        status: merged.status,
+        metadata: merged.metadata,
+        // if password is updated require a login (except if confirmation is not done)
+        ...data.password ? {
+          password: this.hashPassword(data.password),
+          status: old.status !== UserStatus.Pending ? UserStatus.Expired : UserStatus.Pending,
+        } : {},
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update user with id ${id}`,
+        });
+      }
+
+      return await this.get(id, options);
+    } catch (e) { throw e; }
+
+  };
+
+  private readonly status = async (id: number, status: UserStatus, options: Options): Promise<User[]> => {
+    try {
+      const old = (await this.get(id, { password: true }))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await userDao.update({ id: id }, {
+        ...old,
+        status: status,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update user with id ${id}`,
+        });
+      }
+
+      return await this.get(id, options);
+    } catch (e) { throw e; }
+  };
+
+  public readonly activate = async (id: number, options: Options): Promise<User[]> =>
+    this.status(id, UserStatus.Active, options);
+
+  public readonly block = async (id: number, options: Options): Promise<User[]> =>
+    this.status(id, UserStatus.Blocked, options);
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const user = (await this.get(id, { password: true }))[0];
+      if (!user) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User with id ${id} not found.`,
+        });
+      }
+
+      // check user organization accesses
+      const accesses = await userOrganizationController.list({ user: user.id, enabled: true });
+      const owner = accesses.filter((access) => access.role === UserOrganizationRole.Owner);
+      if (owner.length > 0) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `This user is the owner of ${owner.length} organization${owner.length === 1 ? `` : `s`}. Please remove ${owner.length === 1 ? `it` : `them`} or change the ownership before deleting the user.`,
+        });
+      }
+
+      // empty authorizations
+      await identityTokenController.deleteAll(user);
+
+      const { affectedRows } = await userDao.delete({ id: user.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not delete user with id ${id}`,
+        });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  public readonly hashPassword = (password: string) =>
+    Hash.sha256(password, nconf.get(`SERVICES:AUTH:SALT`));
+
+  private readonly getFreeUUID = async (): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await userDao.list({ uuid: uuid }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | User, old?: User): Promise<void> => {
+    try {
+      if (!old || data.email !== old.email) {
+        const exists = (await this.list({ email: data.email }, { password: false }))[0];
+        if (exists) {
+          throw new APIError({
+            code: StatusCodes.CONFLICT,
+            detail: `User with email ${data.email} already exists.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[], options: Options): Promise<User[]> => {
+    try {
+      const response: User[] = [];
+
+      for (const record of records) {
+        if (!_.includes(UserStatus, record.status)) { continue; }
+
+        const p: User = {
+          id: record.id,
+          uuid: record.uuid,
+          email: record.email,
+          password: options.password ? record.password : record.password ? `********` : null,
+          properties: {
+            name: record.properties.name,
+            surnames: record.properties.surnames,
+            ...record.properties.image ? { image: `${record.properties.image}${options.timestamp ? `?ts=${performance.now()}` : ``}` } : {},
+          },
+          preferences: {
+            language: record.preferences.language || `en`,
+            communications: record.preferences.communications,
+          },
+          utm: record.utm,
+          referrer: record.referrer,
+          omnipotent: record.omnipotent ? true : false,
+          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,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const userController = new UserCtrl();
+export default userController;