FEAT: Roles WIP

src/modules/roles/dto/entities.ts

@@ -1,30 +1,39 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { ApiProperty, ApiPropertyOptional, OmitType } from '@nestjs/swagger';
 import { Permission } from 'src/modules/permissions/dto/entities';
-import { UserWithoutRoles } from 'src/modules/users/dtos/entities';
+import {
+  Customer,
+  UserNoRolesAndCustomer,
+} from 'src/modules/users/dtos/entities';
 export class Role {
   @ApiProperty()
   id: string;
   @ApiProperty()
   name: string;
+  @ApiProperty()
+  description: string;
   @ApiPropertyOptional({ type: () => [Permission] })
   permissions: Permission[];
-  @ApiPropertyOptional({ type: () => [UserWithoutRoles] })
-  users: UserWithoutRoles[];
+  @ApiPropertyOptional({ type: () => [UserNoRolesAndCustomer] })
+  users: UserNoRolesAndCustomer[];
   @ApiProperty()
   createdAt: string;
   @ApiProperty()
   updatedAt: string;
+  @ApiProperty({ type: () => Customer })
+  customer?: Customer;
 }
 
+export class CustomerRole extends OmitType(Role, ['customer']) {}
+
 export enum TrueOrFalseEnum {
   true = 'true',
   false = 'false',
 }
 export class GetRolesByCustomerReq {
   @ApiPropertyOptional()
-  permission_id: string[];
+  permissionIds: string[];
   @ApiPropertyOptional({ enum: TrueOrFalseEnum })
-  get_users: TrueOrFalseEnum;
+  getUsers: TrueOrFalseEnum;
 }
 
 export class GetRolesByCustomerRes {
@@ -35,7 +44,7 @@ export class CreateRoleReq {
   @ApiProperty()
   name: string;
   @ApiProperty()
-  permissionIds: string[];
+  permissionIds: number[];
   @ApiPropertyOptional()
   userIds: string[];
   @ApiProperty()
@@ -43,7 +52,7 @@ export class CreateRoleReq {
 }
 export class CreateRoleRes {
   @ApiProperty()
-  role: Role;
+  role: CustomerRole;
 }
 
 export class AssignPermissionsToRoleReq {

src/modules/roles/roles.controller.ts

@@ -9,25 +9,28 @@ import {
   Post,
   Put,
   Query,
+  UseFilters,
 } from '@nestjs/common';
-import { ApiResponse, ApiTags } from '@nestjs/swagger';
-import { User } from 'src/authentication/user.decorator';
+import { ApiCreatedResponse, ApiOkResponse, ApiTags } from '@nestjs/swagger';
+import { RequestUser, User } from 'src/authentication/user.decorator';
 import { DadosferaLogger } from 'dadosfera-logs';
 import { RolesService } from './roles.service';
 import {
-  AssignPermissionsToRoleReq,
-  AssignPermissionsToRoleRes,
+  AssignPermissionsToRoleReq as grantPermissionsToRoleReq,
+  AssignPermissionsToRoleRes as GrantPermissionsToRoleRes,
   CreateRoleReq,
   CreateRoleRes,
   GetRolesByCustomerReq,
   GetRolesByCustomerRes,
-  UnassignPermissionsToRoleReq,
-  UnassignPermissionsToRoleRes,
+  UnassignPermissionsToRoleReq as RevokePermissionsToRoleReq,
+  UnassignPermissionsToRoleRes as RevokePermissionsToRoleRes,
   UpdateRoleReq,
   UpdateRoleRes,
 } from './dto/entities';
+import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter';
 
 @ApiTags('Roles')
+@UseFilters(new GrpcToHttpExceptionFilter())
 @Controller('roles')
 export class RolesController {
   logger: any;
@@ -39,46 +42,57 @@ export class RolesController {
   ) {
     this.logger = dadosferaLogger.logger;
   }
+
   @Get()
-  @ApiResponse({ type: GetRolesByCustomerRes })
+  @ApiOkResponse({ type: GetRolesByCustomerRes })
   async getRolesByCustomer(
-    @User() user,
+    @User() user: RequestUser,
     @Query() filters: GetRolesByCustomerReq,
   ) {
     this.logger.info('getRolesByCustomer', { user });
-    this.rolesService.getRolesByCustomer(filters);
+    return await this.rolesService.getRolesByCustomer(
+      filters,
+      user.customer_id,
+    );
   }
+
   @Post()
-  @ApiResponse({ type: CreateRoleRes })
-  async createRole(@User() user, @Body() body: CreateRoleReq) {
+  @ApiCreatedResponse({ type: CreateRoleRes })
+  async createRole(@User() user: RequestUser, @Body() body: CreateRoleReq) {
     this.logger.info('createRole', { user });
+    return await this.rolesService.createRole(body, user.customer_id);
   }
+
   @Delete(':id')
-  async deleteRole(@User() user, @Param('id') id: string) {
+  async deleteRole(@User() user: RequestUser, @Param('id') id: string) {
     this.logger.info('deleteRole', { user });
     return await this.rolesService.removeRole(id);
   }
+
   @Put('permissions')
-  @ApiResponse({ type: AssignPermissionsToRoleRes })
-  async assignPermissionsToRole(
-    @User() user,
-    @Body() body: AssignPermissionsToRoleReq,
+  @ApiOkResponse({ type: GrantPermissionsToRoleRes })
+  async grantPermissionsToRole(
+    @User() user: RequestUser,
+    @Body() body: grantPermissionsToRoleReq,
   ) {
-    this.logger.info('assignPermissionsToRole', { user });
+    this.logger.info('grantPermissionsToRole', { user });
+    return await this.rolesService.grantPermissionsToRole(body);
   }
 
   @Delete('permissions')
-  @ApiResponse({ type: UnassignPermissionsToRoleRes })
-  async unassignPermissionsToRole(
-    @User() user,
-    @Body() body: UnassignPermissionsToRoleReq,
+  @ApiOkResponse({ type: RevokePermissionsToRoleRes })
+  async revokePermissionsToRole(
+    @User() user: RequestUser,
+    @Body() body: RevokePermissionsToRoleReq,
   ) {
-    this.logger.info('unassignPermissionsToRole', { user });
+    this.logger.info('revokePermissionsToRole', { user });
+    return await this.rolesService.revokePermissionToRole(body);
   }
+
   @Patch(':id')
-  @ApiResponse({ type: UpdateRoleRes })
+  @ApiOkResponse({ type: UpdateRoleRes })
   async updateRole(
-    @User() user,
+    @User() user: RequestUser,
     @Param('id') id: string,
     @Body() body: UpdateRoleReq,
   ) {

src/modules/roles/roles.module.ts

@@ -4,6 +4,7 @@ import { DucClient } from 'src/clients/duc/client.config';
 import { RolesController } from './roles.controller';
 import { RolesService } from './roles.service';
 import { DadosferaLogger } from 'dadosfera-logs';
+import { PermissionsModule } from '../permissions/permissions.module';
 
 const ducClient = new DucClient();
 
@@ -15,6 +16,7 @@ const ducClient = new DucClient();
         ...ducClient.config(),
       },
     ]),
+    PermissionsModule,
   ],
   controllers: [RolesController],
   providers: [RolesService, DadosferaLogger],

src/modules/roles/roles.service.ts

@@ -1,10 +1,16 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ProtoServices } from 'protospack-v2/dist/lib/Duc';
 import { RolesProtoService } from 'protospack-v2/dist/lib/Duc/interfaces/write-service';
-import { GetRolesByCustomerReq } from './dto/entities';
+import { CreateRoleReq, GetRolesByCustomerReq, Role } from './dto/entities';
 import { DadosferaLogger } from 'dadosfera-logs';
 import { ClientGrpc } from '@nestjs/microservices';
 import { lastValueFrom } from 'rxjs';
+import { PermissionsService } from '../permissions/permissions.service';
+import {
+  GrantPermissionsToRoleRequest,
+  RevokePermissionsFromRoleRequest,
+  RoleUpdateRequest,
+} from 'protospack-v2/dist/lib/Duc/interfaces/messages';
 
 @Injectable()
 export class RolesService {
@@ -15,22 +21,97 @@ export class RolesService {
     @Inject(DadosferaLogger)
     dadosferaLogger: DadosferaLogger,
     @Inject('DUC_PACKAGE') private readonly grpcClient: ClientGrpc,
+    private permissionsService: PermissionsService,
   ) {
     this.logger = dadosferaLogger.logger;
   }
 
   onModuleInit() {
     this.rolesClientService = this.grpcClient.getService<RolesProtoService>(
-      ProtoServices.UsersProtoService,
+      ProtoServices.RolesProtoService,
     );
   }
-  async getRolesByCustomer(filters: GetRolesByCustomerReq) {
-    let { permission_id } = filters;
-    if (!Array.isArray(permission_id)) permission_id = [permission_id];
-    const { get_users } = filters;
-    const is_get_users = get_users === 'true';
+  async getRolesByCustomer(filters: GetRolesByCustomerReq, customerId: string) {
+    let { permissionIds } = filters;
+    if (permissionIds && !Array.isArray(permissionIds))
+      permissionIds = [permissionIds];
+    const { getUsers } = filters;
+    const isGetUsers = getUsers === 'true';
+    const permissionSeqIds =
+      permissionIds?.map((id) => {
+        const seqId = Number(id);
+        if (isNaN(seqId))
+          throw new BadRequestException(`permissionId ${id} not valid`);
+        return seqId;
+      }) || [];
+    const roles = await lastValueFrom(
+      this.rolesClientService.RoleFindAllByCustomerId({
+        customerId,
+        getUsers: isGetUsers,
+        permissionIds: [],
+        permissionSeqIds,
+      }),
+    );
+    const rolesTreated = this.getRolesPermissionsName(roles.roles);
+    return { roles: rolesTreated };
   }
+
+  async createRole(data: CreateRoleReq, customerId: string) {
+    const { description, name, permissionIds, userIds } = data;
+    const role = await lastValueFrom(
+      this.rolesClientService.RoleCreate({
+        customerId,
+        name,
+        permissionIds: [],
+        permissionSeqIds: permissionIds,
+        description,
+        userIds,
+      }),
+    );
+    const [roleTreated] = this.getRolesPermissionsName([role.role]);
+    return { role: roleTreated };
+  }
+
   async removeRole(id: string) {
     return lastValueFrom(this.rolesClientService.RoleRemove({ id }));
   }
+  async grantPermissionsToRole({
+    roleId,
+    permissionIds,
+  }: GrantPermissionsToRoleRequest) {
+    const role = await lastValueFrom(
+      this.rolesClientService.GrantPermissionsToRole({
+        permissionIds,
+        roleId,
+      }),
+    );
+  }
+
+  async revokePermissionToRole({
+    roleId,
+    permissionIds,
+  }: RevokePermissionsFromRoleRequest) {
+    const role = await lastValueFrom(
+      this.rolesClientService.RevokePermissionsFromRole({
+        permissionIds,
+        roleId,
+      }),
+    );
+  }
+
+  async updateRole(req: RoleUpdateRequest) {
+    const role = await lastValueFrom(this.rolesClientService.RoleUpdate(req));
+  }
+  getRolesPermissionsName(roles: Role[]) {
+    for (const role of roles) {
+      const permisisonSeqIds = role.permissions.map((p) => p.seqid);
+      const permissions =
+        this.permissionsService.getPermissionsBySeqId(permisisonSeqIds);
+      role.permissions.forEach((p) => {
+        const permission = permissions.find((per) => per.seqid === p.seqid);
+        p.name = permission.name;
+      });
+    }
+    return roles;
+  }
 }