change folder structure

src/command/management/role/roleCommand.ts

@@ -0,0 +1,12 @@
+export interface CreateRoleCommand {
+  role: string;
+}
+
+export interface UpdateRoleCommand {
+  id: number;
+  role: string;
+}
+
+export interface DeleteRoleCommand {
+  id: number;
+}

src/command/management/role/roleCommandHandler.ts

@@ -0,0 +1,67 @@
+import { dataSource } from "../../../data-source";
+import { role } from "../../../entity/management/role";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import InternalException from "../../../exceptions/internalException";
+import { CreateRoleCommand, DeleteRoleCommand, UpdateRoleCommand } from "./roleCommand";
+
+export default abstract class RoleCommandHandler {
+  /**
+   * @description create role
+   * @param {CreateRoleCommand} createRole
+   * @returns {Promise<number>}
+   */
+  static async create(createRole: CreateRoleCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(role)
+      .values({
+        role: createRole.role,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "role", err);
+      });
+  }
+
+  /**
+   * @description update role
+   * @param {UpdateRoleCommand} updateRole
+   * @returns {Promise<void>}
+   */
+  static async update(updateRole: UpdateRoleCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(role)
+      .set({
+        role: updateRole.role,
+      })
+      .where("id = :id", { id: updateRole.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "role", err);
+      });
+  }
+
+  /**
+   * @description delete role
+   * @param {DeleteRoleCommand} deleteRole
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteRole: DeleteRoleCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(role)
+      .where("id = :id", { id: deleteRole.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "role", err);
+      });
+  }
+}

src/command/management/role/rolePermissionCommand.ts

@@ -0,0 +1,16 @@
+import { PermissionString } from "../../../type/permissionTypes";
+
+export interface CreateRolePermissionCommand {
+  permission: PermissionString;
+  roleId: number;
+}
+
+export interface DeleteRolePermissionCommand {
+  permission: PermissionString;
+  roleId: number;
+}
+
+export interface UpdateRolePermissionsCommand {
+  roleId: number;
+  permissions: Array<PermissionString>;
+}

src/command/management/role/rolePermissionCommandHandler.ts

@@ -0,0 +1,75 @@
+import { DeleteResult, EntityManager, InsertResult } from "typeorm";
+import { dataSource } from "../../../data-source";
+import { rolePermission } from "../../../entity/management/role_permission";
+import InternalException from "../../../exceptions/internalException";
+import RoleService from "../../../service/management/roleService";
+import {
+  CreateRolePermissionCommand,
+  DeleteRolePermissionCommand,
+  UpdateRolePermissionsCommand,
+} from "./rolePermissionCommand";
+import PermissionHelper from "../../../helpers/permissionHelper";
+import RolePermissionService from "../../../service/management/rolePermissionService";
+import { PermissionString } from "../../../type/permissionTypes";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+
+export default abstract class RolePermissionCommandHandler {
+  /**
+   * @description update role permissions
+   * @param {UpdateRolePermissionsCommand} updateRolePermissions
+   * @returns {Promise<void>}
+   */
+  static async updatePermissions(updateRolePermissions: UpdateRolePermissionsCommand): Promise<void> {
+    let currentPermissions = (await RolePermissionService.getByRole(updateRolePermissions.roleId)).map(
+      (r) => r.permission
+    );
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newPermissions = PermissionHelper.getWhatToAdd(currentPermissions, updateRolePermissions.permissions);
+        let removePermissions = PermissionHelper.getWhatToRemove(currentPermissions, updateRolePermissions.permissions);
+        if (newPermissions.length != 0) {
+          await this.updatePermissionsAdd(manager, updateRolePermissions.roleId, newPermissions);
+        }
+        if (removePermissions.length != 0) {
+          await this.updatePermissionsRemove(manager, updateRolePermissions.roleId, removePermissions);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "rolePermissions", err);
+      });
+  }
+
+  private static async updatePermissionsAdd(
+    manager: EntityManager,
+    roleId: number,
+    permissions: Array<PermissionString>
+  ): Promise<InsertResult> {
+    return await manager
+      .createQueryBuilder()
+      .insert()
+      .into(rolePermission)
+      .values(
+        permissions.map((p) => ({
+          permission: p,
+          roleId: roleId,
+        }))
+      )
+      .orIgnore()
+      .execute();
+  }
+
+  private static async updatePermissionsRemove(
+    manager: EntityManager,
+    roleId: number,
+    permissions: Array<PermissionString>
+  ): Promise<DeleteResult> {
+    return await manager
+      .createQueryBuilder()
+      .delete()
+      .from(rolePermission)
+      .where("roleId = :id", { id: roleId })
+      .andWhere("permission IN (:...permission)", { permission: permissions })
+      .execute();
+  }
+}

src/command/management/user/inviteCommand.ts

@@ -0,0 +1,12 @@
+export interface CreateInviteCommand {
+  mail: string;
+  username: string;
+  firstname: string;
+  lastname: string;
+  secret: string;
+}
+
+export interface DeleteInviteCommand {
+  token: string;
+  mail: string;
+}

src/command/management/user/inviteCommandHandler.ts

@@ -0,0 +1,75 @@
+import { dataSource } from "../../../data-source";
+import { invite } from "../../../entity/management/invite";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import InternalException from "../../../exceptions/internalException";
+import { StringHelper } from "../../../helpers/stringHelper";
+import { CreateInviteCommand, DeleteInviteCommand } from "./inviteCommand";
+
+export default abstract class InviteCommandHandler {
+  /**
+   * @description create user
+   * @param CreateInviteCommand
+   * @returns {Promise<string>}
+   */
+  static async create(createInvite: CreateInviteCommand): Promise<string> {
+    const token = StringHelper.random(32);
+
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(invite)
+      .values({
+        mail: createInvite.mail,
+        token: token,
+        username: createInvite.username,
+        firstname: createInvite.firstname,
+        lastname: createInvite.lastname,
+        secret: createInvite.secret,
+      })
+      .orUpdate(["firstName", "lastName", "token", "secret"], ["mail"])
+      .execute()
+      .then((result) => {
+        return token;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "invite", err);
+      });
+  }
+
+  /**
+   * @description delete invite by mail and token
+   * @param DeleteInviteCommand
+   * @returns {Promise<any>}
+   */
+  static async deleteByTokenAndMail(deleteInvite: DeleteInviteCommand): Promise<any> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(invite)
+      .where("invite.token = :token", { token: deleteInvite.token })
+      .andWhere("invite.mail = :mail", { mail: deleteInvite.mail })
+      .execute()
+      .then((res) => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "invite", err);
+      });
+  }
+
+  /**
+   * @description delete invite by mail
+   * @param DeleteByMailInviteCommand
+   * @returns {Promise<any>}
+   */
+  static async deleteByMail(mail: string): Promise<any> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(invite)
+      .where("invite.mail = :mail", { mail })
+      .execute()
+      .then((res) => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "invite", err);
+      });
+  }
+}

src/command/management/user/userCommand.ts

@@ -0,0 +1,35 @@
+export interface CreateUserCommand {
+  mail: string;
+  username: string;
+  firstname: string;
+  lastname: string;
+  secret: string;
+  isOwner: boolean;
+}
+
+export interface UpdateUserCommand {
+  id: string;
+  mail: string;
+  username: string;
+  firstname: string;
+  lastname: string;
+}
+
+export interface UpdateUserSecretCommand {
+  id: string;
+  secret: string;
+}
+
+export interface TransferUserOwnerCommand {
+  fromId: string;
+  toId: string;
+}
+
+export interface UpdateUserRolesCommand {
+  id: string;
+  roleIds: Array<number>;
+}
+
+export interface DeleteUserCommand {
+  id: string;
+}

src/command/management/user/userCommandHandler.ts

@@ -0,0 +1,170 @@
+import { EntityManager } from "typeorm";
+import { dataSource } from "../../../data-source";
+import { user } from "../../../entity/management/user";
+import InternalException from "../../../exceptions/internalException";
+import {
+  CreateUserCommand,
+  DeleteUserCommand,
+  TransferUserOwnerCommand,
+  UpdateUserCommand,
+  UpdateUserRolesCommand,
+  UpdateUserSecretCommand,
+} from "./userCommand";
+import UserService from "../../../service/management/userService";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+
+export default abstract class UserCommandHandler {
+  /**
+   * @description create user
+   * @param {CreateUserCommand} createUser
+   * @returns {Promise<string>}
+   */
+  static async create(createUser: CreateUserCommand): Promise<string> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(user)
+      .values({
+        username: createUser.username,
+        mail: createUser.mail,
+        firstname: createUser.firstname,
+        lastname: createUser.lastname,
+        secret: createUser.secret,
+        isOwner: createUser.isOwner,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "user", err);
+      });
+  }
+
+  /**
+   * @description update user
+   * @param {UpdateUserCommand} updateUser
+   * @returns {Promise<void>}
+   */
+  static async update(updateUser: UpdateUserCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(user)
+      .set({
+        mail: updateUser.mail,
+        firstname: updateUser.firstname,
+        lastname: updateUser.lastname,
+        username: updateUser.username,
+      })
+      .where("id = :id", { id: updateUser.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "user", err);
+      });
+  }
+
+  /**
+   * @description update user
+   * @param {UpdateUserSecretCommand} updateUser
+   * @returns {Promise<void>}
+   */
+  static async updateSecret(updateUser: UpdateUserSecretCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(user)
+      .set({
+        secret: updateUser.secret,
+      })
+      .where("id = :id", { id: updateUser.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "user", err);
+      });
+  }
+
+  /**
+   * @description update user roles
+   * @param {UpdateUserRolesCommand} updateUserRoles
+   * @returns {Promise<void>}
+   */
+  static async updateRoles(updateUserRoles: UpdateUserRolesCommand): Promise<void> {
+    let currentRoles = (await UserService.getAssignedRolesByUserId(updateUserRoles.id)).map((r) => r.id);
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newRoles = updateUserRoles.roleIds.filter((r) => !currentRoles.includes(r));
+        let removeRoles = currentRoles.filter((r) => !updateUserRoles.roleIds.includes(r));
+
+        for (let role of newRoles) {
+          await this.updateRolesAdd(manager, updateUserRoles.id, role);
+        }
+
+        for (let role of removeRoles) {
+          await this.updateRolesRemove(manager, updateUserRoles.id, role);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "userRoles", err);
+      });
+  }
+
+  private static async updateRolesAdd(manager: EntityManager, userId: string, roleId: number): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "roles").of(userId).add(roleId);
+  }
+
+  private static async updateRolesRemove(manager: EntityManager, userId: string, roleId: number): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "roles").of(userId).remove(roleId);
+  }
+
+  /**
+   * @description transfer ownership
+   * @param {TransferUserOwnerCommand} transferOwnership
+   * @returns {Promise<void>}
+   */
+  static async transferOwnership(transferOwnership: TransferUserOwnerCommand): Promise<void> {
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        await manager
+          .createQueryBuilder()
+          .update(user)
+          .set({
+            isOwner: false,
+          })
+          .where("id = :id", { id: transferOwnership.fromId })
+          .execute();
+
+        await manager
+          .createQueryBuilder()
+          .update(user)
+          .set({
+            isOwner: true,
+          })
+          .where("id = :id", { id: transferOwnership.toId })
+          .execute();
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("ABORT", "transfer owner", err);
+      });
+  }
+
+  /**
+   * @description delete user
+   * @param DeleteUserCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteUser: DeleteUserCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(user)
+      .where("id = :id", { id: deleteUser.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "user", err);
+      });
+  }
+}

src/command/management/user/userPermissionCommand.ts

@@ -0,0 +1,16 @@
+import { PermissionString } from "../../../type/permissionTypes";
+
+export interface CreateUserPermissionCommand {
+  permission: PermissionString;
+  userId: string;
+}
+
+export interface DeleteUserPermissionCommand {
+  permission: PermissionString;
+  userId: string;
+}
+
+export interface UpdateUserPermissionsCommand {
+  userId: string;
+  permissions: Array<PermissionString>;
+}

src/command/management/user/userPermissionCommandHandler.ts

@@ -0,0 +1,76 @@
+import { DeleteResult, EntityManager, InsertResult } from "typeorm";
+import { dataSource } from "../../../data-source";
+import { user } from "../../../entity/management/user";
+import { userPermission } from "../../../entity/management/user_permission";
+import InternalException from "../../../exceptions/internalException";
+import {
+  CreateUserPermissionCommand,
+  DeleteUserPermissionCommand,
+  UpdateUserPermissionsCommand,
+} from "./userPermissionCommand";
+import UserPermissionService from "../../../service/management/userPermissionService";
+import PermissionHelper from "../../../helpers/permissionHelper";
+import { PermissionString } from "../../../type/permissionTypes";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+
+export default abstract class UserPermissionCommandHandler {
+  /**
+   * @description update user permissions
+   * @param {UpdateUserPermissionsCommand} updateUserPermissions
+   * @returns {Promise<void>}
+   */
+  static async updatePermissions(updateUserPermissions: UpdateUserPermissionsCommand): Promise<void> {
+    let currentPermissions = (await UserPermissionService.getByUser(updateUserPermissions.userId)).map(
+      (r) => r.permission
+    );
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newPermissions = PermissionHelper.getWhatToAdd(currentPermissions, updateUserPermissions.permissions);
+        let removePermissions = PermissionHelper.getWhatToRemove(currentPermissions, updateUserPermissions.permissions);
+
+        if (newPermissions.length != 0) {
+          await this.updatePermissionsAdd(manager, updateUserPermissions.userId, newPermissions);
+        }
+        if (removePermissions.length != 0) {
+          await this.updatePermissionsRemove(manager, updateUserPermissions.userId, removePermissions);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "userPermissions", err);
+      });
+  }
+
+  private static async updatePermissionsAdd(
+    manager: EntityManager,
+    userId: string,
+    permissions: Array<PermissionString>
+  ): Promise<InsertResult> {
+    return await manager
+      .createQueryBuilder()
+      .insert()
+      .into(userPermission)
+      .values(
+        permissions.map((p) => ({
+          permission: p,
+          userId: userId,
+        }))
+      )
+      .orIgnore()
+      .execute();
+  }
+
+  private static async updatePermissionsRemove(
+    manager: EntityManager,
+    userId: string,
+    permissions: Array<PermissionString>
+  ): Promise<DeleteResult> {
+    return await manager
+      .createQueryBuilder()
+      .delete()
+      .from(userPermission)
+      .where("userId = :id", { id: userId })
+      .andWhere("permission IN (:...permission)", { permission: permissions })
+      .execute();
+  }
+}

src/command/management/webapi/webapiCommand.ts

@@ -0,0 +1,19 @@
+export interface CreateWebapiCommand {
+  title: string;
+  token: string;
+  expiry?: Date;
+}
+
+export interface UpdateWebapiCommand {
+  id: number;
+  title: string;
+  expiry?: Date;
+}
+
+export interface UpdateLastUsageWebapiCommand {
+  id: number;
+}
+
+export interface DeleteWebapiCommand {
+  id: number;
+}

src/command/management/webapi/webapiCommandHandler.ts

@@ -0,0 +1,95 @@
+import { dataSource } from "../../../data-source";
+import { webapi } from "../../../entity/management/webapi";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import InternalException from "../../../exceptions/internalException";
+import {
+  CreateWebapiCommand,
+  DeleteWebapiCommand,
+  UpdateLastUsageWebapiCommand,
+  UpdateWebapiCommand,
+} from "./webapiCommand";
+
+export default abstract class WebapiCommandHandler {
+  /**
+   * @description create api
+   * @param {CreateWebapiCommand} createWebapi
+   * @returns {Promise<number>}
+   */
+  static async create(createWebapi: CreateWebapiCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(webapi)
+      .values({
+        token: createWebapi.token,
+        title: createWebapi.title,
+        expiry: createWebapi.expiry,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].token;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "webapi", err);
+      });
+  }
+
+  /**
+   * @description update api
+   * @param {UpdateWebapiCommand} updateWebapi
+   * @returns {Promise<void>}
+   */
+  static async update(updateWebapi: UpdateWebapiCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(webapi)
+      .set({
+        title: updateWebapi.title,
+        expiry: updateWebapi.expiry,
+      })
+      .where("id = :id", { id: updateWebapi.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "webapi", err);
+      });
+  }
+
+  /**
+   * @description update api usage
+   * @param {UpdateLastUsageWebapiCommand} updateWebapi
+   * @returns {Promise<void>}
+   */
+  static async updateUsage(updateWebapi: UpdateLastUsageWebapiCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(webapi)
+      .set({
+        lastUsage: new Date(),
+      })
+      .where("id = :id", { id: updateWebapi.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "webapi", err);
+      });
+  }
+
+  /**
+   * @description delete api
+   * @param {DeleteWebapiCommand} deleteWebapi
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteWebapi: DeleteWebapiCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(webapi)
+      .where("id = :id", { id: deleteWebapi.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "webapi", err);
+      });
+  }
+}

src/command/management/webapi/webapiPermissionCommand.ts

@@ -0,0 +1,16 @@
+import { PermissionString } from "../../../type/permissionTypes";
+
+export interface CreateWebapiPermissionCommand {
+  permission: PermissionString;
+  webapiId: number;
+}
+
+export interface DeleteWebapiPermissionCommand {
+  permission: PermissionString;
+  webapiId: number;
+}
+
+export interface UpdateWebapiPermissionsCommand {
+  webapiId: number;
+  permissions: Array<PermissionString>;
+}

src/command/management/webapi/webapiPermissionCommandHandler.ts

@@ -0,0 +1,78 @@
+import { DeleteResult, EntityManager, InsertResult } from "typeorm";
+import { dataSource } from "../../../data-source";
+import { webapiPermission } from "../../../entity/management/webapi_permission";
+import InternalException from "../../../exceptions/internalException";
+import WebapiService from "../../../service/management/webapiService";
+import {
+  CreateWebapiPermissionCommand,
+  DeleteWebapiPermissionCommand,
+  UpdateWebapiPermissionsCommand,
+} from "./webapiPermissionCommand";
+import PermissionHelper from "../../../helpers/permissionHelper";
+import WebapiPermissionService from "../../../service/management/webapiPermissionService";
+import { PermissionString } from "../../../type/permissionTypes";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+
+export default abstract class WebapiPermissionCommandHandler {
+  /**
+   * @description update api permissions
+   * @param {UpdateWebapiPermissionsCommand} updateWebapiPermissions
+   * @returns {Promise<void>}
+   */
+  static async updatePermissions(updateWebapiPermissions: UpdateWebapiPermissionsCommand): Promise<void> {
+    let currentPermissions = (await WebapiPermissionService.getByApi(updateWebapiPermissions.webapiId)).map(
+      (r) => r.permission
+    );
+    return await dataSource.manager
+      .transaction(async (manager) => {
+        let newPermissions = PermissionHelper.getWhatToAdd(currentPermissions, updateWebapiPermissions.permissions);
+        let removePermissions = PermissionHelper.getWhatToRemove(
+          currentPermissions,
+          updateWebapiPermissions.permissions
+        );
+        if (newPermissions.length != 0) {
+          await this.updatePermissionsAdd(manager, updateWebapiPermissions.webapiId, newPermissions);
+        }
+        if (removePermissions.length != 0) {
+          await this.updatePermissionsRemove(manager, updateWebapiPermissions.webapiId, removePermissions);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "webapiPermission", err);
+      });
+  }
+
+  private static async updatePermissionsAdd(
+    manager: EntityManager,
+    webapiId: number,
+    permissions: Array<PermissionString>
+  ): Promise<InsertResult> {
+    return await manager
+      .createQueryBuilder()
+      .insert()
+      .into(webapiPermission)
+      .values(
+        permissions.map((p) => ({
+          permission: p,
+          webapiId: webapiId,
+        }))
+      )
+      .orIgnore()
+      .execute();
+  }
+
+  private static async updatePermissionsRemove(
+    manager: EntityManager,
+    webapiId: number,
+    permissions: Array<PermissionString>
+  ): Promise<DeleteResult> {
+    return await manager
+      .createQueryBuilder()
+      .delete()
+      .from(webapiPermission)
+      .where("webapiId = :id", { id: webapiId })
+      .andWhere("permission IN (:...permission)", { permission: permissions })
+      .execute();
+  }
+}