diff --git a/src/modules/catalog/share/share.controller.ts b/src/modules/catalog/share/share.controller.ts new file mode 100644 index 0000000..a5240bf --- /dev/null +++ b/src/modules/catalog/share/share.controller.ts @@ -0,0 +1,87 @@ +import { + Controller, + Get, + Inject, + Param, + UseFilters, +} from '@nestjs/common'; +import { + ApiHeaders, + ApiTags, +} from '@nestjs/swagger'; +import { DadosferaLogger } from '@dadosfera/dadosfera-logs'; +import { RequestUser, User } from 'src/decorators/user.decorator'; +import { + IColumnsMetadataResponse, + IDocsResponse, + IPreviewResponse, + +} from '../dtos'; +import { GrpcToHttpExceptionFilter } from 'src/error/grpc-to-http-exception.filter'; +import { Language } from 'src/decorators/language.decorator'; +import { LanguageEnum } from 'src/utils/languages.enum'; +import { ShareService } from './share.service'; + +@ApiTags('Catalog') +@ApiHeaders([{ name: 'dadosfera-lang', enum: LanguageEnum, required: false }]) +@Controller('catalog/data-asset/share') +@UseFilters(new GrpcToHttpExceptionFilter()) +export class ShareController { + logger: DadosferaLogger; + constructor( + @Inject(DadosferaLogger) + dadosferaLogger: DadosferaLogger, + private catalogShareService: ShareService, + ) { + this.logger = dadosferaLogger.logger; + } + + @Get('/:id') + async getShareDataAsset( + @Param('id') id: string, + @User() user: RequestUser + ) { + this.logger.info(`GET //:id`); + return await this.catalogShareService.getOneDataAssetPublic(id, user); + } + + @Get('/:id/columns-metadata') + async getShareDataAssetColumnsMetadata( + @Language() language: LanguageEnum, + @Param('id') id: string, + @User() user: RequestUser + ): Promise { + this.logger.info(`GET /:id/columns-metadata`); + + const columns_metadata = + await this.catalogShareService.getDatasetColumnsMetadata(id, user); + + + return { columns_metadata }; + } + + @Get('/:id/preview') + async getShareDataAssetPreview( + @Language() language: LanguageEnum, + @Param('id') id: string, + @User() user: RequestUser + ): Promise { + this.logger.info(`GET /:id/preview`); + const preview = await this.catalogShareService.getDatasetPreview(id, user); + + return { preview }; + } + + @Get('/:id/docs') + async getShareDataAssetDocs( + @Language() language: LanguageEnum, + @Param('id') id: string, + @User() user: RequestUser + ): Promise { + this.logger.info(`GET /:id/docs`); + const docs = await this.catalogShareService.getDataDocs(id, user); + + return { docs }; + } + +} diff --git a/src/modules/catalog/share/share.module.ts b/src/modules/catalog/share/share.module.ts new file mode 100644 index 0000000..1f0c7fb --- /dev/null +++ b/src/modules/catalog/share/share.module.ts @@ -0,0 +1,26 @@ +import { Module } from "@nestjs/common"; +import { CatalogClientConfiguration } from "../catalog-client"; +import { ClientsModule } from "@nestjs/microservices"; +import { RolesModule } from "src/modules/roles/roles.module"; +import { UsersModule } from "src/modules/users/users.module"; +import { CustomersModule } from "src/modules/customers/customers.module"; +import { ShareMetadataModule } from "src/modules/share-metadata/share-metadata.module"; +import { ShareController } from "./share.controller"; +import DadosferaLogger from "@dadosfera/dadosfera-logs"; +import { ShareService } from "./share.service"; + +const client = new CatalogClientConfiguration(); + +@Module({ + imports: [ + ClientsModule.register([client.providerOptions]), + UsersModule, + RolesModule, + CustomersModule, + ShareMetadataModule + ], + controllers: [ShareController], + providers: [ShareService, DadosferaLogger], + exports: [ShareModule], +}) +export class ShareModule {} \ No newline at end of file diff --git a/src/modules/catalog/share/share.service.ts b/src/modules/catalog/share/share.service.ts new file mode 100644 index 0000000..b81096a --- /dev/null +++ b/src/modules/catalog/share/share.service.ts @@ -0,0 +1,231 @@ +import DadosferaLogger from '@dadosfera/dadosfera-logs'; +import { + ProtoServices, + ReadService, +} from '@dadosfera/protospack-v2/dist/lib/Catalog'; +import { + ForbiddenException, + Inject, + NotFoundException, + OnModuleInit, +} from '@nestjs/common'; +import { CatalogClientConfiguration } from '../catalog-client'; +import { ClientGrpc } from '@nestjs/microservices'; +import { UsersService } from 'src/modules/users/users.service'; +import { RolesService } from 'src/modules/roles/roles.service'; +import { RequestUser } from 'src/decorators/user.decorator'; +import { PackTheMetadata } from 'src/utils/PackTheMetadata'; +import { PERMISSIONS_GROUPS } from 'src/authentication/permissions.enum'; +import { Metadata } from '@grpc/grpc-js'; +import { lastValueFrom } from 'rxjs'; +import { ShareMetadataService } from 'src/modules/share-metadata/share-metadata.service'; +import { isJWT } from 'class-validator'; + +export class ShareService implements OnModuleInit { + catalogReadService: ReadService.CatalogReadServices; + logger: DadosferaLogger; + + constructor( + @Inject(DadosferaLogger) + dadosferaLogger: DadosferaLogger, + @Inject(CatalogClientConfiguration.name) + private readonly grpcClient: ClientGrpc, + private readonly userService: UsersService, + private readonly roleService: RolesService, + private shareMetadataService: ShareMetadataService, + ) { + this.logger = dadosferaLogger.logger; + } + + onModuleInit() { + this.catalogReadService = + this.grpcClient.getService( + ProtoServices.CatalogReadServices, + ); + } + + async getDatasetColumnsMetadata(id: string, user: RequestUser) { + const shareMetadata = await this.getShareMetadata(id, user); + const metadata = PackTheMetadata({ + customer_id: shareMetadata.customerId, + customer_name: shareMetadata.customerName, + }); + const { columns_metadata } = await lastValueFrom( + this.catalogReadService.GetDatasetColumnsMetadata( + { id: shareMetadata.assetId, type: undefined }, + metadata, + ), + ); + const result = JSON.parse(columns_metadata); + return result; + } + + async getDatasetPreview(id: string, user: RequestUser) { + const shareMetadata = await this.getShareMetadata(id, user); + const metadata = PackTheMetadata({ + customer_id: shareMetadata.customerId, + customer_name: shareMetadata.customerName, + }); + const { preview } = await lastValueFrom( + this.catalogReadService.GetDatasetPreview( + { id: shareMetadata.assetId, type: undefined }, + metadata, + ), + ); + const result = JSON.parse(preview); + return result; + } + + async getOneDataAssetPublic(id: string, user: RequestUser) { + this.logger.info("getOneDataAssetPublic: " + JSON.stringify({ + id, + userId: user?.user_id, + customerId: user?.customer_id + })) + try { + const shareMetadata = await this.getShareMetadata(id, user); + + this.logger.info("shareMetadata: " + JSON.stringify(shareMetadata)) + const metadata = PackTheMetadata({ + customer_id: shareMetadata.customerId, + customer_name: shareMetadata.customerName, + }); + + const { data_asset } = await this.getOneDataAsset({ + customer_id: shareMetadata.customerId, + id: shareMetadata.assetId, + metadata, + }); + this.logger.info('found asset: ' + JSON.stringify(data_asset)); + delete data_asset.p_roles; + delete data_asset.p_users; + data_asset.share_type = 'public'; + if (data_asset.share_type !== 'public') throw new NotFoundException(); + + return { data_asset }; + } catch (error) { + this.logger.error(error); + throw error; + } + + } + + private async getOneDataAsset(data: { + id: string; + customer_id: string; + metadata: Metadata; + }) { + const { customer_id, id, metadata } = data; + const { data_asset } = await lastValueFrom( + this.catalogReadService.GetOneDataAsset( + { id, type: undefined }, + metadata, + ), + ); + let asset = JSON.parse(data_asset); + asset = { + ...asset, + p_roles: asset.roles, + p_users: asset.users, + }; + asset = await this.getAssetsUsersAndRoles([asset], customer_id); + + return { data_asset: asset[0] }; + } + + async getDataDocs(id: string, user: RequestUser) { + const shareMetadata = await this.getShareMetadata(id, user); + const metadata = PackTheMetadata({ + customer_id: shareMetadata.customerId, + customer_name: shareMetadata.customerName, + }); + + const { documentation } = await lastValueFrom( + this.catalogReadService.GetDatasetDoc({ id, type: undefined }, metadata), + ); + console.log(documentation); + const docs = JSON.parse(documentation); + return docs; + } + + private async getAssetsUsersAndRoles( + data_assets: Array, + customer_id: string, + ) { + const { users: customer_users } = + await this.userService.findAllUsersByCustomerId(customer_id); + const { roles: customer_roles } = await this.roleService.roleSearch( + {}, + { customer_id }, + ); + return data_assets.map((data_asset) => { + const owner = customer_users.find( + (u) => u.id === data_asset.owner, + )?.username; + + const roles = []; + const users = []; + for (const role_id of data_asset.roles) { + const role = customer_roles.find((r) => r.id === role_id); + if (role) roles.push({ id: role.id, name: role.name }); + } + for (const user_id of data_asset.users) { + const user = customer_users.find((r) => r.id === user_id); + if (user) users.push({ id: user.id, username: user.username }); + } + return { + ...data_asset, + roles, + users, + owner, + } as typeof data_asset; + }); + } + + // private async validateShareAssign(token: string) { + // const tokenDecoded = jwt.decode(token, { + // complete: true, + // }); + + // jwt.verify(token, this.pemValue, { + // algorithms: ['RS256'], + // }); + + // const shareId = (tokenDecoded.payload as JwtPayload).sub; + // const metadata = PackTheMetadata({}); + // return await this.shareMetadataService.get(shareId, metadata); + // } + + private async getShareMetadata(id: string, user: RequestUser) { + const metadata = PackTheMetadata({}); + const info = await this.shareMetadataService.get(id, metadata); + if (isJWT(id) && info ){ + return info; + } + + if (info.type === 'private') { + if (!user) { + throw new ForbiddenException( + 'You do not have permission to access this data asset.', + ); + } + + const is_data_manager = user.permissions.includes( + PERMISSIONS_GROUPS.CATALOG.permissions.DATA_MANAGER.seqid, + ); + + const is_get = user.permissions.includes( + PERMISSIONS_GROUPS.CATALOG.permissions.GET.seqid, + ); + + if (is_data_manager || is_get) { + return; + } + + throw new ForbiddenException( + 'You do not have permission to access this data asset.', + ); + } + return info; + } +} diff --git a/src/modules/share-metadata/dto/create-share-metadata.dto.ts b/src/modules/share-metadata/dto/create-share-metadata.dto.ts new file mode 100644 index 0000000..db06de6 --- /dev/null +++ b/src/modules/share-metadata/dto/create-share-metadata.dto.ts @@ -0,0 +1,9 @@ +export class CreateShareMetadataDto { + assetId: string; + proposedId: string; +} + +export class UpdateShareMetadataDto { + shareId: string; + type: string; +} diff --git a/src/modules/share-metadata/share-metadata.controller.ts b/src/modules/share-metadata/share-metadata.controller.ts new file mode 100644 index 0000000..bfa6ca5 --- /dev/null +++ b/src/modules/share-metadata/share-metadata.controller.ts @@ -0,0 +1,31 @@ +import { Controller, Get, Body, Param, Put, Patch } from '@nestjs/common'; +import { ShareMetadataService } from './share-metadata.service'; +import { Authenticated } from 'src/decorators/authentication.decorator'; +import { RequestUser, User } from 'src/decorators/user.decorator'; +import { PackTheMetadata } from 'src/utils/PackTheMetadata'; +import { CreateShareMetadataDto, UpdateShareMetadataDto } from './dto/create-share-metadata.dto'; + +@Controller('share') +@Authenticated() +export class ShareMetadataController { + constructor(private readonly shareMetadataService: ShareMetadataService) {} + + @Put('/') + findOrcreate(@Body() data: CreateShareMetadataDto, @User() user: RequestUser) { + const metadata = PackTheMetadata(user); + return this.shareMetadataService.create(data, metadata); + } + + @Patch('/') + updateShareType(@Body() data: UpdateShareMetadataDto, @User() user: RequestUser) { + const metadata = PackTheMetadata(user); + return this.shareMetadataService.updateShare(data, metadata); + } + + + @Get('/:id') + get(@Param('id') id: string, @User() user: RequestUser) { + const metadata = PackTheMetadata(user); + return this.shareMetadataService.get(id, metadata); + } +} diff --git a/src/modules/share-metadata/share-metadata.module.ts b/src/modules/share-metadata/share-metadata.module.ts new file mode 100644 index 0000000..f75e78e --- /dev/null +++ b/src/modules/share-metadata/share-metadata.module.ts @@ -0,0 +1,16 @@ +import { Module } from '@nestjs/common'; +import { ShareMetadataService } from './share-metadata.service'; +import { ShareMetadataController } from './share-metadata.controller'; +import { DucClient } from '../duc/client.config'; +import { ClientsModule } from '@nestjs/microservices'; +import DadosferaLogger from '@dadosfera/dadosfera-logs'; + +const client = new DucClient(); + +@Module({ + imports: [ClientsModule.register([client.providerOptions])], + controllers: [ShareMetadataController], + providers: [ShareMetadataService, DadosferaLogger], + exports: [ShareMetadataService] +}) +export class ShareMetadataModule {} diff --git a/src/modules/share-metadata/share-metadata.service.ts b/src/modules/share-metadata/share-metadata.service.ts new file mode 100644 index 0000000..0915faa --- /dev/null +++ b/src/modules/share-metadata/share-metadata.service.ts @@ -0,0 +1,61 @@ +import { Inject, Injectable, OnModuleInit } from '@nestjs/common'; +import { Metadata } from '@grpc/grpc-js'; +import { ClientGrpc } from '@nestjs/microservices'; +import { DucClient } from '../duc/client.config'; +import DadosferaLogger from '@dadosfera/dadosfera-logs'; +import { ShareMetadataProtoService } from '@dadosfera/protospack-v2/dist/lib/Duc/interfaces/write-service'; +import { lastValueFrom } from 'rxjs'; +import { ProtoServices } from '@dadosfera/protospack-v2/dist/lib/Duc'; +import { CreateShareMetadataDto, UpdateShareMetadataDto } from './dto/create-share-metadata.dto'; + +@Injectable() +export class ShareMetadataService implements OnModuleInit { + ducService: ShareMetadataProtoService; + logger: DadosferaLogger; + + constructor( + @Inject(DadosferaLogger) + dadosferaLogger: DadosferaLogger, + @Inject(DucClient.name) private readonly grpcClient: ClientGrpc, + ) { + this.logger = dadosferaLogger.logger; + } + + onModuleInit() { + this.ducService =this.grpcClient.getService( + ProtoServices.ShareMetadataProtoService, + ); + } + + create(createShareDto: CreateShareMetadataDto, metadata: Metadata) { + return lastValueFrom( + this.ducService.FindOrCreateShareMetadata( + { + assetId: createShareDto.assetId, + proposedId: createShareDto.proposedId + }, + metadata, + ), + ); + } + + updateShare(updateShare: UpdateShareMetadataDto, metadata: Metadata) { + return lastValueFrom( + this.ducService.ChangeShareMetadataType( + updateShare, + metadata, + ), + ); + } + + get(id: string, metadata: Metadata) { + return lastValueFrom( + this.ducService.GetShareMetadata( + { + id, + }, + metadata, + ), + ); + } +}