change folder structure

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();
+  }
+}