maestro/src/modules/permissions/permissions.service.ts

import {
  OnApplicationBootstrap,
  OnModuleInit,
  Inject,
  Injectable,
} from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { lastValueFrom } from 'rxjs';

import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc';
import { PermissionsProtoService as PermissionsServiceInterface } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service';
import { InjectPermissionsRequest } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/messages';
import { DadosferaLogger } from '@dadosfera/dadosfera-logs';
import {
  PERMISSIONS,
  PermissionUsages,
  PermissionsObjectGroup,
  PermissionsObjectPermissionTranslated,
} from '../../authentication/permissions.enum';
import ErrorBuilder from '../../utils/ErrorBuilder';
import { PermissionGroupPermission, PermissionGroup } from './dto/entities';
import { LanguageEnum } from 'src/utils/languages.enum';

@Injectable()
export class PermissionsService
  implements OnModuleInit, OnApplicationBootstrap
{
  logger: DadosferaLogger;

  private permissionsClientService: PermissionsServiceInterface;
  constructor(
    @Inject(DadosferaLogger)
    dadosferaLogger: DadosferaLogger,
    @Inject('DUC_PACKAGE') private readonly grpcClient: ClientGrpc,
  ) {
    this.logger = dadosferaLogger.logger;
  }

  onModuleInit() {
    this.permissionsClientService =
      this.grpcClient.getService<PermissionsServiceInterface>(
        ProtoServices.PermissionsProtoService,
      );
  }

  // internally used to send permissions to duc on microservice startup
  async onApplicationBootstrap() {
    this.logger.info('sending permissions to DUC...');

    const permissions = Object.values(PERMISSIONS).flatMap((namespace) =>
      Object.values(namespace.permissions),
    );

    return this.injectPermissions({
      permissions,
    }).catch((err: ErrorBuilder) => {
      if (
        err.code === 'No connection established' &&
        process.env.LOCAL_ENV === 'true'
      ) {
        return this.logger.info(
          "couldn't connect to DUC. suppresing in local env",
        );
      }

      throw err;
    });
  }

  async injectPermissions({ permissions }: InjectPermissionsRequest) {
    this.logger.info('InjectPermissions');

    return lastValueFrom(
      this.permissionsClientService.InjectPermissions({ permissions }),
    );
  }
  getPermissionsGrouped(
    permissionUsage?: PermissionUsages,
    language: LanguageEnum = LanguageEnum.ptbr,
  ): PermissionGroup[] {
    const groups: PermissionGroup[] = [];
    for (const key in PERMISSIONS) {
      const permissionGroup: PermissionsObjectGroup = PERMISSIONS[key];
      const title = permissionGroup.title[language];
      const permissions: PermissionGroupPermission[] = Object.values(
        permissionGroup.permissions,
      )
        .filter(({ usage }) =>
          permissionUsage ? usage === permissionUsage : true,
        )
        .map(({ seqid, name }) => ({ id: seqid, name: name[language] }));
      if (permissions?.length)
        groups.push({
          title,
          permissions,
        });
    }
    return groups;
  }
  getAllPermissions(language: LanguageEnum = LanguageEnum.ptbr) {
    let permissions: PermissionsObjectPermissionTranslated[] = [];
    for (const key in PERMISSIONS) {
      const permissionGroup: PermissionsObjectGroup = PERMISSIONS[key];
      const permissionGroupPermissions: PermissionsObjectPermissionTranslated[] =
        Object.values(permissionGroup.permissions).map((p) => ({
          ...p,
          name: p.name[language],
        }));
      permissions = permissions.concat(permissionGroupPermissions);
    }
    return permissions;
  }
  getPermissionsBySeqId(seqIds: number[]) {
    const permissionGroupPermissions = this.getAllPermissions();

    return permissionGroupPermissions.filter((p) => seqIds.includes(p.seqid));
  }
}