maestro/src/modules/roles/roles.service.ts

import { BadRequestException, Inject, Injectable } from '@nestjs/common';
import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
import { RolesProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
import {
  CreateRoleReq,
  GetRolesByCustomerReq,
  GrantPermissionsToRoleReq,
  RevokePermissionsFromRoleReq,
  RoleDto,
  SetRolePermissionsReq,
  SetRoleUsersReq,
  UpdateRoleReq,
} from './dto/entities';
import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
import { Metadata } from '@grpc/grpc-js';
import { ClientGrpc } from '@nestjs/microservices';
import { Permission } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/entities';
import { lastValueFrom } from 'rxjs';
import { PermissionsService } from '../permissions/permissions.service';
import { LanguageEnum } from 'src/utils/languages.enum';
import { RequestUser } from 'src/decorators/user.decorator';
import { DucClient } from '../duc/client.config';

interface GetRolesPermissionsName {
  id: string;
  name: string;
  description: string;
  permissions: Permission[];
  isPublic?: boolean;
  createdAt: string;
  updatedAt: string;
  usage: string;
}
@Injectable()
export class RolesService {
  logger: DadosferaLogger;
  private language: LanguageEnum = LanguageEnum.ptbr;
  private rolesClientService: RolesProtoService;
  constructor(
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
    @Inject(DucClient.name) private readonly grpcClient: ClientGrpc,
    private permissionsService: PermissionsService,
  ) {
    this.logger = dadosferaLogger.logger;
  }
  setLanguage(lang: LanguageEnum = LanguageEnum.ptbr) {
    if (Object.values(LanguageEnum).includes(lang)) this.language = lang;
    this.language = lang;
  }

  onModuleInit() {
    this.rolesClientService = this.grpcClient.getService<RolesProtoService>(
      ProtoServices.RolesProtoService,
    );
  }

  async getRolesById(id: string, { access_token }: RequestUser) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const role = await lastValueFrom(
      this.rolesClientService.RoleFindOneById(
        {
          id,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async roleSearch(filters: GetRolesByCustomerReq, { customer_id }) {
    let { permissionId: 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.RoleSearch({
        customerId: customer_id,
        getUsers: isGetUsers,
        permissionIds: [],
        permissionSeqIds,
        canUntoggleLogic: filters.canUntoggleLogic,
      }),
    );
    const rolesTreated = this.getRolesPermissionsName(roles.roles);
    return { roles: rolesTreated };
  }

  async createRole(
    data: CreateRoleReq,
    { customer_id, access_token }: RequestUser,
  ) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const { description, name, permissionIds, userIds } = data;
    const role = await lastValueFrom(
      this.rolesClientService.RoleCreate(
        {
          customerId: customer_id,
          name,
          permissionIds: [],
          permissionSeqIds: permissionIds,
          description,
          userIds,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async removeRole(id: string, { access_token }: RequestUser) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    return lastValueFrom(this.rolesClientService.RoleRemove({ id }, meta));
  }
  async grantPermissionsToRole(
    { roleId, permissionIds }: GrantPermissionsToRoleReq,
    { access_token }: RequestUser,
  ) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const role = await lastValueFrom(
      this.rolesClientService.GrantPermissionsToRole(
        {
          permissionIds: [],
          roleId,
          permissionSeqIds: permissionIds,
        },
        meta,
      ),
    );

    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async revokePermissionFromRole(
    { roleId, permissionIds }: RevokePermissionsFromRoleReq,
    { access_token }: RequestUser,
  ) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const role = await lastValueFrom(
      this.rolesClientService.RevokePermissionsFromRole(
        {
          permissionIds: [],
          roleId,
          permissionSeqIds: permissionIds,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async updateRole(
    id: string,
    req: UpdateRoleReq,
    { access_token }: RequestUser,
  ) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const { description, name } = req;
    const role = await lastValueFrom(
      this.rolesClientService.RoleUpdate(
        {
          id,
          description,
          name,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async setRolePermissions(
    req: SetRolePermissionsReq,
    { access_token }: RequestUser,
  ) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const { roleId: id, permissionIds } = req;
    const clearPermissions =
      Array.isArray(permissionIds) && permissionIds.length === 0;
    const role = await lastValueFrom(
      this.rolesClientService.RoleSetPermissions(
        {
          id,
          permissionSeqIds: permissionIds,
          clearPermissions,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }

  async setRoleUsers(req: SetRoleUsersReq, { access_token }: RequestUser) {
    const meta = new Metadata();
    meta.add('access_token', access_token);
    const { roleId: id, userIds } = req;
    const clearUsers = Array.isArray(userIds) && userIds.length === 0;
    const role = await lastValueFrom(
      this.rolesClientService.RoleSetUsers(
        {
          id,
          userIds,
          clearUsers,
        },
        meta,
      ),
    );
    const [roleTreated] = this.getRolesPermissionsName([role.role]);
    return { role: roleTreated };
  }
  getRolesPermissionsName(roles: GetRolesPermissionsName[]): RoleDto[] {
    const newRoles: RoleDto[] = [];
    for (const role of roles) {
      const allPermissions = this.permissionsService.getAllPermissions(
        this.language,
      );
      const newPermissions = role.permissions.map((p) => {
        const permission = allPermissions.find((per) => per.seqid === p.seqid);
        return {
          ...p,
          name: permission.name,
          id: p.seqid,
        };
      });
      const newRole: RoleDto = {
        ...role,
        permissions: newPermissions,
        isPublic: role.isPublic,
      };
      newRoles.push(newRole);
    }
    return newRoles;
  }
}