user and role controllers

src/command/rolePermissionCommand.ts

@@ -6,5 +6,11 @@ export interface CreateRolePermissionCommand {
 }
 
 export interface DeleteRolePermissionCommand {
-  id: number;
+  permission: PermissionString;
+  roleId: number;
+}
+
+export interface UpdateRolePermissionsCommand {
+  roleId: number;
+  permissions: Array<PermissionString>;
 }

src/command/rolePermissionCommandHandler.ts

@@ -1,10 +1,58 @@
+import { EntityManager } from "typeorm";
 import { dataSource } from "../data-source";
 import { rolePermission } from "../entity/role_permission";
 import InternalException from "../exceptions/internalException";
 import RoleService from "../service/roleService";
-import { CreateRolePermissionCommand, DeleteRolePermissionCommand } from "./rolePermissionCommand";
+import {
+  CreateRolePermissionCommand,
+  DeleteRolePermissionCommand,
+  UpdateRolePermissionsCommand,
+} from "./rolePermissionCommand";
+import PermissionHelper from "../helpers/permissionHelper";
+import RolePermissionService from "../service/rolePermissionService";
+import { role } from "../entity/role";
+
+export default abstract class RolePermissionCommandHandler {
+  /**
+   * @description update role permissions
+   * @param UpdateRolePermissionsCommand
+   * @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);
+
+        for (let permission of newPermissions) {
+          await this.updatePermissionsAdd(manager, updateRolePermissions.roleId, permission);
+        }
+
+        for (let permission of removePermissions) {
+          await this.updatePermissionsRemove(manager, updateRolePermissions.roleId, permission);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed saving role permissions");
+      });
+  }
+
+  private static async updatePermissionsAdd(manager: EntityManager, userId: number, permission: string): Promise<void> {
+    return await manager.createQueryBuilder().relation(role, "permissions").of(userId).add(permission);
+  }
+
+  private static async updatePermissionsRemove(
+    manager: EntityManager,
+    userId: number,
+    permission: string
+  ): Promise<void> {
+    return await manager.createQueryBuilder().relation(role, "permissions").of(userId).remove(permission);
+  }
 
-export default abstract class UserPermissionCommandHandler {
   /**
    * @description grant permission to user
    * @param CreateRolePermissionCommand
@@ -38,7 +86,8 @@ export default abstract class UserPermissionCommandHandler {
       .createQueryBuilder()
       .delete()
       .from(rolePermission)
-      .where("permission.id = :id", { id: deletePermission.id })
+      .where("roleId = :id", { id: deletePermission.roleId })
+      .andWhere("permission = :permission", { permission: deletePermission.permission })
       .execute()
       .then((res) => {})
       .catch((err) => {

src/command/userCommand.ts

@@ -5,3 +5,20 @@ export interface CreateUserCommand {
   lastname: string;
   secret: string;
 }
+
+export interface UpdateUserCommand {
+  id: number;
+  mail: string;
+  username: string;
+  firstname: string;
+  lastname: string;
+}
+
+export interface UpdateUserRolesCommand {
+  id: number;
+  roleIds: Array<number>;
+}
+
+export interface DeleteUserCommand {
+  id: number;
+}

src/command/userCommandHandler.ts

@@ -1,7 +1,9 @@
+import { EntityManager } from "typeorm";
 import { dataSource } from "../data-source";
 import { user } from "../entity/user";
 import InternalException from "../exceptions/internalException";
-import { CreateUserCommand } from "./userCommand";
+import { CreateUserCommand, DeleteUserCommand, UpdateUserCommand, UpdateUserRolesCommand } from "./userCommand";
+import UserService from "../service/userService";
 
 export default abstract class UserCommandHandler {
   /**
@@ -29,4 +31,79 @@ export default abstract class UserCommandHandler {
         throw new InternalException("Failed saving user");
       });
   }
+
+  /**
+   * @description update user
+   * @param UpdateUserCommand
+   * @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 InternalException("Failed updating user");
+      });
+  }
+
+  /**
+   * @description update user roles
+   * @param UpdateUserRolesCommand
+   * @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 = currentRoles.filter((r) => !updateUserRoles.roleIds.includes(r));
+        let removeRoles = updateUserRoles.roleIds.filter((r) => !currentRoles.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 InternalException("Failed saving user roles");
+      });
+  }
+
+  private static async updateRolesAdd(manager: EntityManager, userId: number, roleId: number): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "roles").of(userId).add(roleId);
+  }
+
+  private static async updateRolesRemove(manager: EntityManager, userId: number, roleId: number): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "roles").of(userId).remove(roleId);
+  }
+
+  /**
+   * @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 InternalException("Failed deleting user");
+      });
+  }
 }

src/command/userPermissionCommand.ts

@@ -6,5 +6,11 @@ export interface CreateUserPermissionCommand {
 }
 
 export interface DeleteUserPermissionCommand {
-  id: number;
+  permission: PermissionString;
+  userId: number;
+}
+
+export interface UpdateUserPermissionsCommand {
+  userId: number;
+  permissions: Array<PermissionString>;
 }

src/command/userPermissionCommandHandler.ts

@@ -1,10 +1,57 @@
+import { EntityManager } from "typeorm";
 import { dataSource } from "../data-source";
+import { user } from "../entity/user";
 import { userPermission } from "../entity/user_permission";
 import InternalException from "../exceptions/internalException";
-import UserService from "../service/userService";
-import { CreateUserPermissionCommand, DeleteUserPermissionCommand } from "./userPermissionCommand";
+import {
+  CreateUserPermissionCommand,
+  DeleteUserPermissionCommand,
+  UpdateUserPermissionsCommand,
+} from "./userPermissionCommand";
+import UserPermissionService from "../service/userPermissionService";
+import PermissionHelper from "../helpers/permissionHelper";
 
 export default abstract class UserPermissionCommandHandler {
+  /**
+   * @description update user permissions
+   * @param UpdateUserPermissionsCommand
+   * @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);
+
+        for (let permission of newPermissions) {
+          await this.updatePermissionsAdd(manager, updateUserPermissions.userId, permission);
+        }
+
+        for (let permission of removePermissions) {
+          await this.updatePermissionsRemove(manager, updateUserPermissions.userId, permission);
+        }
+      })
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed saving user permissions");
+      });
+  }
+
+  private static async updatePermissionsAdd(manager: EntityManager, userId: number, permission: string): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "permissions").of(userId).add(permission);
+  }
+
+  private static async updatePermissionsRemove(
+    manager: EntityManager,
+    userId: number,
+    permission: string
+  ): Promise<void> {
+    return await manager.createQueryBuilder().relation(user, "permissions").of(userId).remove(permission);
+  }
+
   /**
    * @description grant permission to user
    * @param CreateUserPermissionCommand
@@ -17,7 +64,7 @@ export default abstract class UserPermissionCommandHandler {
       .into(userPermission)
       .values({
         permission: createPermission.permission,
-        user: await UserService.getById(createPermission.userId),
+        userId: createPermission.userId,
       })
       .execute()
       .then((result) => {
@@ -38,7 +85,8 @@ export default abstract class UserPermissionCommandHandler {
       .createQueryBuilder()
       .delete()
       .from(userPermission)
-      .where("permission.id = :id", { id: deletePermission.id })
+      .where("userId = :id", { id: deletePermission.userId })
+      .andWhere("permission = :permission", { permission: deletePermission.permission })
       .execute()
       .then((res) => {})
       .catch((err) => {