CI: .

Beta -> main

.ebextensions/imdsv2.config

@@ -0,0 +1,7 @@
+Resources:
+  AWSEBAutoScalingLaunchConfiguration:
+    Properties:
+      MetadataOptions:
+        HttpEndpoint: enabled
+        HttpPutResponseHopLimit: 2
+        HttpTokens: required

.github/workflows/deploy-manually.yml

@@ -2,117 +2,110 @@ name: Deploy
 on:
   push:
     branches:
-      - alpha
-      - beta
       - main
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Deployment environment'
+        required: true
+        type: choice
+        options:
+          - dev
+          - stg
+          - prd
 
 jobs:
   extract_environment:
     runs-on: ubuntu-latest
     outputs:
       environment: ${{ steps.extract_environment.outputs.environment }}
+    env:
+      EVENT: ${{ github.event_name }}
+      DEPLOY_ENV: ${{ github.event.inputs.environment }}
     steps:
       - name: Extract Environment
         run: |
-          if [ ${GITHUB_REF} == "refs/heads/main" ]; then
+          if [ ${EVENT} == "workflow_dispatch" ]; then
+            echo "##[set-output name=environment;]$(echo ${DEPLOY_ENV})"
+          elif [ ${GITHUB_REF} == "refs/heads/main" ]; then
             echo "##[set-output name=environment;]$(echo "prd")"
-          elif [ ${GITHUB_REF} == "refs/heads/alpha" ]; then
-            echo "##[set-output name=environment;]$(echo "dev")"
-          elif [ ${GITHUB_REF} == "refs/heads/beta" ]; then
-            echo "##[set-output name=environment;]$(echo "stg")"
           fi
         id: extract_environment
 
   semantic_release:
     runs-on: ubuntu-latest
     outputs:
+      #new_release_published: ${{ steps.semantic.outputs.last_release_version != steps.semantic.outputs.new_release_version }}
       new_release_published: ${{ steps.semantic.outputs.new_release_published }}
       new_release_version: ${{ steps.semantic.outputs.new_release_version }}
+      test: ${{ (steps.semantic.outputs.new_release_published == 'true' && steps.semantic.outputs.new_release_version) || (github.event_name == 'workflow_dispatch' && '0.0.0') }}
+      testt: ${{ (needs.semantic_release.outputs.new_release_published == 'true' && needs.semantic_release.outputs.new_release_version) || '1.0.0' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Semantic Release
+      - if: github.event_name != 'workflow_dispatch'
+        name: Semantic Release
         uses: cycjimmy/semantic-release-action@v2
         id: semantic
         with:
           semantic_version: 16
           extra_plugins: |
-            @saithodev/semantic-release-backmerge
             conventional-changelog-eslint
           branches: |
             [
-              'main',
-              {
-                name: 'alpha',
-                prerelease: true
-              },
-              {
-                name: 'beta',
-                prerelease: true
-              }
+              'main'
             ]
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
   deploy:
+    if: ${{ (github.event_name != 'workflow_dispatch' && needs.semantic_release.outputs.new_release_published == 'true') || 'true' }}
     needs: [extract_environment, semantic_release]
-    runs-on: [self-hosted, "${{ needs.extract_environment.outputs.environment }}"]
+    runs-on:
+      [self-hosted, '${{ needs.extract_environment.outputs.environment }}']
 
     steps:
+      - name: print
+        env:
+          EVENT: ${{ github.event_name }}
+          IMAGE_TAG: ${{ needs.semantic_release.outputs.test }}
+          IMAGE_TAGG: ${{ needs.semantic_release.outputs.testT }}
+        run: echo ${IMAGE_TAG} ${IMAGE_TAGG} ${EVENT}
+
       - name: Checkout
         uses: actions/checkout@v2
 
       - name: Update Pip
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         run: |
           python3 -m pip install --upgrade pip
 
       - name: Install Docker Compose
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         run: |
           python3 -m pip install docker-compose --upgrade
 
       - name: Install AWS CLI
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         run: |
           python3 -m pip install awscli --upgrade
 
       - name: Install AWS Elastic Beanstalk CLI
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         run: |
           python3 -m pip install awsebcli --upgrade
 
       - name: Configure AWS Region
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         uses: aws-actions/configure-aws-credentials@v1
         id: aws
         with:
           aws-region: us-east-1
 
-      - name: Extract Environment
-        if: needs.semantic_release.outputs.new_release_published == 'true'
-        shell: bash
-        run: |
-          if [ ${GITHUB_REF} == "refs/heads/main" ]; then
-            echo "##[set-output name=result;]$(echo "prd")"
-          elif [ ${GITHUB_REF} == "refs/heads/alpha" ]; then
-            echo "##[set-output name=result;]$(echo "dev")"
-          elif [ ${GITHUB_REF} == "refs/heads/beta" ]; then
-            echo "##[set-output name=result;]$(echo "stg")"
-          fi
-        id: extract_environment
-
       - name: Login to AWS ECR
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         id: login_ecr
         uses: aws-actions/amazon-ecr-login@v1
 
       - name: Build, Tag, and Push Image to AWS ECR
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         env:
-          ENV: ${{ steps.extract_environment.outputs.result }}
+          ENV: ${{ needs.extract_environment.outputs.environment }}
           IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
           ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -121,9 +114,8 @@ jobs:
           docker-compose -f build.docker-compose.yml push
 
       - name: Create ZIP file to Deploy AWS Beanstalk
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         env:
-          ENV: ${{ steps.extract_environment.outputs.result }}
+          ENV: ${{ needs.extract_environment.outputs.environment }}
           IMAGE_TAG: ${{ needs.semantic_release.outputs.new_release_version }}
           ACCOUNT_ID: ${{ steps.aws.outputs.aws-account-id }}
         run: |
@@ -133,11 +125,10 @@ jobs:
           zip deploy.zip docker-compose.yml  -r .ebextensions
 
       - name: Deploy AWS Beanstalk
-        if: needs.semantic_release.outputs.new_release_published == 'true'
         env:
-          ENV: ${{ steps.extract_environment.outputs.result }}
+          ENV: ${{ needs.extract_environment.outputs.environment }}
           AWS_REGION: us-east-1
-          APP_NAME: maestro
+          APP_NAME: ${{ github.event.repository.name }}
         run: |
           eb use $APP_NAME-$ENV
           echo -e "deploy:\n  artifact: deploy.zip" >> .elasticbeanstalk/config.yml

.gitignore

@@ -29,7 +29,7 @@ lerna-debug.log*
 
 # IDE - VSCode
 .vscode/*
-!.vscode/settings.json
+#!.vscode/settings.json
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json

.releaserc.json

@@ -26,18 +26,6 @@
         "preset": "eslint"
       }
     ],
-    [
-      "@saithodev/semantic-release-backmerge",
-      {
-        "branches": [
-          { "from": "main", "to": "alpha" },
-          { "from": "main", "to": "beta" }
-        ],
-        "backmergeStrategy": "merge",
-        "clearWorkspace": true,
-        "restoreWorkspace": true
-      }
-    ],
     "@semantic-release/npm",
     "@semantic-release/github"
   ]

README.md

@@ -1,4 +1,4 @@
 <p align="center">
   <image src="./assets/maestro.svg" style="width:10rem">
-  <h1 align="center">Maestro</h1> 
-</p>
+  <h1 align="center">Maestro</h1>  
+</p>  

package.json

@@ -29,11 +29,11 @@
     "@nestjs/mapped-types": "*",
     "@nestjs/microservices": "^8.4.3",
     "@nestjs/platform-express": "^8.4.3",
+    "@nestjs/schedule": "^1.1.0",
     "@nestjs/swagger": "^5.2.1",
-    "@victorradael/protospack": "^1.5.5",
+    "@victorradael/protospack": "2.3.0",
     "axios": "^0.25.0",
     "dotenv": "^14.2.0",
-    "grpc": "^1.24.11",
     "helmet": "^5.0.2",
     "jsonwebtoken": "^8.5.1",
     "jwk-to-pem": "^2.0.5",

src/clients/auth/client.config.ts

@@ -10,7 +10,9 @@ export class AuthClient {
       options: {
         url: process.env.DUC_URL,
         package: DucPackages,
-        credentials: credentials.createSsl(),
+        credentials: process.env.LOCAL_ENV
+          ? undefined
+          : credentials.createSsl(),
         protoPath: DucProtoFilePath,
         loader: {
           enums: String,

src/clients/auth/client.service.ts

@@ -2,12 +2,18 @@ import { OnModuleInit, Inject } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 
 import {
-  AuthServiceInterface,
   DucServicesNames,
+  AuthServiceInterface,
+  AuthSignInRequest,
+  AuthRefreshAccessTokenRequest,
+  AuthConfirmationRequest,
+  AuthResendConfirmationCodeRequest,
+  AuthEnableTotpMfaRequest,
+  AuthDisableTotpMfaRequest,
+  AuthDismissTotpMfaRequest,
+  AuthVerifyTotpMfaRequest,
 } from '@victorradael/protospack';
 
-import { ILogin } from './interfaces';
-
 export class AuthClientService implements OnModuleInit {
   private authService: AuthServiceInterface;
   constructor(
@@ -20,11 +26,99 @@ export class AuthClientService implements OnModuleInit {
     );
   }
 
-  async signIn({ username, password }: ILogin): Promise<any> {
+  async signIn({ username, password, totp }: AuthSignInRequest): Promise<any> {
     console.log('AuthClientService', 'SignIn');
 
+    return new Promise((resolve, reject) => {
+      this.authService.signIn({ username, password, totp }).subscribe({
+        next: resolve,
+        //error: (err) => reject(err.details),
+        error: (err) => {
+          console.log(err);
+          reject(err.details);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async enableTotpMFA({
+    accessToken,
+    password,
+  }: AuthEnableTotpMfaRequest): Promise<any> {
+    console.log('AuthClientService', 'enableTotpMFA');
+
+    return new Promise((resolve, reject) => {
+      this.authService.enableTotpMfa({ accessToken, password }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async disableTotpMFA({
+    accessToken,
+    password,
+  }: AuthDisableTotpMfaRequest): Promise<any> {
+    console.log('AuthClientService', 'disableTotpMFA');
+
+    return new Promise((resolve, reject) => {
+      this.authService.disableTotpMfa({ accessToken, password }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async dismissTotpMFA({
+    accessToken,
+  }: AuthDismissTotpMfaRequest): Promise<any> {
+    console.log('AuthClientService', 'dismissTotpMFA');
+
+    return new Promise((resolve, reject) => {
+      this.authService.dismissTotpMfa({ accessToken }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async verifyTotp({
+    accessToken,
+    totp,
+  }: AuthVerifyTotpMfaRequest): Promise<any> {
+    console.log('AuthClientService', 'disableTotpMFA');
+
+    return new Promise((resolve, reject) => {
+      this.authService.verifyTotp({ accessToken, totp }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async confirmRegister({
+    username,
+    code,
+  }: AuthConfirmationRequest): Promise<any> {
+    console.log('AuthClientService', 'confirmRegister');
+
     const tokens = await new Promise((resolve, reject) => {
-      this.authService.signIn({ username, password }).subscribe({
+      this.authService.confirmRegister({ username, code }).subscribe({
         next(x) {
           resolve(x);
         },
@@ -43,4 +137,51 @@ export class AuthClientService implements OnModuleInit {
       });
     return tokens;
   }
+
+  async resendeConfirmationCode({
+    username,
+  }: AuthResendConfirmationCodeRequest): Promise<any> {
+    console.log('AuthClientService', 'resendConfirmationCode');
+
+    const authResendConfirmationCodeRequestReturn = await new Promise(
+      (resolve, reject) => {
+        this.authService.resendConfirmationCode({ username }).subscribe({
+          next(x) {
+            resolve(x);
+          },
+          error(err) {
+            console.log('Observable Error');
+            reject(err);
+          },
+          complete() {
+            console.log('done');
+          },
+        });
+      },
+    )
+      .then((res) => res)
+      .catch((err) => {
+        throw new Error(err);
+      });
+    return authResendConfirmationCodeRequestReturn;
+  }
+
+  async refreshAccessToken({
+    username,
+    refreshToken,
+  }: AuthRefreshAccessTokenRequest): Promise<any> {
+    console.log('AuthClientService', 'RefreshAccessToken');
+
+    return new Promise((resolve, reject) => {
+      this.authService
+        .refreshAccessToken({ username, refreshToken })
+        .subscribe({
+          next: resolve,
+          error: (err) => reject(err.details),
+          complete() {
+            console.log('done');
+          },
+        });
+    });
+  }
 }

src/clients/auth/interfaces.d.ts

@@ -1,4 +0,0 @@
-export interface ILogin {
-  username: string;
-  password: string;
-}

src/clients/inputs/client.config.ts

@@ -10,7 +10,9 @@ export class InputsClientConfiguration {
       options: {
         url: process.env.INFACTORY_URL,
         package: InputPackages,
-        credentials: credentials.createSsl(),
+        credentials: process.env.LOCAL_ENV
+          ? undefined
+          : credentials.createSsl(),
         protoPath: InputProtoFilePath,
         loader: {
           enums: String,

src/clients/inputs/client.service.ts

@@ -1,16 +1,18 @@
 import { OnModuleInit, Inject } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
-import { InputService } from '@victorradael/protospack';
+import {
+  InputCreateResponse,
+  InputCreateS3Request,
+  InputNewCreateRequest,
+  InputService,
+  TestConnectionGetColumnsRequest,
+  TestConnectionRequest,
+} from '@victorradael/protospack';
 import {
   objectCamelToSnake,
   objectSnakeToCamel,
 } from 'src/utils/CaseConverter';
-import {
-  ICreateInputRequest,
-  IIdRequest,
-  ITestConnectionRequest,
-  UpdateInputRequest,
-} from './interfaces';
+import { IIdRequest, UpdateInputRequest } from './interfaces';
 
 export class InputsClientService implements OnModuleInit {
   private inputService: InputService;
@@ -23,11 +25,36 @@ export class InputsClientService implements OnModuleInit {
       this.grpcClient.getService<InputService>('InputService');
   }
 
-  async create(createInputDto: ICreateInputRequest) {
+  async create(createInputDto: InputNewCreateRequest) {
     console.log('InputClientService', 'Create');
 
     const createInputResponse = await new Promise((resolve, reject) => {
-      this.inputService.Create(objectSnakeToCamel(createInputDto)).subscribe({
+      this.inputService
+        .NewCreate(objectSnakeToCamel(createInputDto))
+        .subscribe({
+          next(x) {
+            resolve(objectCamelToSnake(x));
+          },
+          error(err) {
+            console.log('Observable Error');
+            reject(err);
+          },
+          complete() {
+            console.log('done');
+          },
+        });
+    }).catch((err) => {
+      throw new Error(err);
+    });
+
+    return createInputResponse;
+  }
+
+  async createS3Inputs(createInputDto: InputCreateS3Request) {
+    console.log('InputClientService', 'Create');
+
+    const createInputResponse = await new Promise((resolve, reject) => {
+      this.inputService.CreateS3(objectSnakeToCamel(createInputDto)).subscribe({
         next(x) {
           resolve(objectCamelToSnake(x));
         },
@@ -147,10 +174,10 @@ export class InputsClientService implements OnModuleInit {
     return removeInputResponse;
   }
 
-  async testConnection(data: ITestConnectionRequest) {
+  async testConnection(data: TestConnectionRequest) {
     console.log('InputClientService', 'TestConnection');
     const testConnectionResponse = await new Promise((resolve, reject) => {
-      this.inputService.TestConnection(objectSnakeToCamel(data)).subscribe({
+      this.inputService.NewTestConnection(objectSnakeToCamel(data)).subscribe({
         next(x) {
           resolve(objectCamelToSnake(x));
         },
@@ -170,4 +197,28 @@ export class InputsClientService implements OnModuleInit {
 
     return testConnectionResponse;
   }
+
+  async getColumns(data: TestConnectionGetColumnsRequest) {
+    console.log('InputClientService', 'TestConnection/Get-Columns');
+    const getColumnsResponse = await new Promise((resolve, reject) => {
+      this.inputService.GetColumns(objectSnakeToCamel(data)).subscribe({
+        next(x) {
+          resolve(objectCamelToSnake(x));
+        },
+        error(err) {
+          console.log('Observable Error');
+          reject(err);
+        },
+        complete() {
+          console.log('done');
+        },
+      });
+    })
+      .then((res) => res)
+      .catch((err) => {
+        throw new Error(err);
+      });
+
+    return getColumnsResponse;
+  }
 }

src/clients/outputs/client.config.ts

@@ -9,7 +9,9 @@ export class OutputsClientConfiguration {
       options: {
         url: process.env.OTFACTORY_URL,
         package: OutputPackages,
-        credentials: credentials.createSsl(),
+        credentials: process.env.LOCAL_ENV
+          ? undefined
+          : credentials.createSsl(),
         protoPath: OutputProtoFilePath,
         loader: {
           enums: String,

src/clients/pipelines/client.config.ts

@@ -12,7 +12,9 @@ export class PipelinesClientConfiguration {
       options: {
         url: process.env.PIFACTORY_URL,
         package: PipelinePackages,
-        credentials: credentials.createSsl(),
+        credentials: process.env.LOCAL_ENV
+          ? undefined
+          : credentials.createSsl(),
         protoPath: PipelineProtoFilePath,
         loader: {
           enums: String,

src/clients/pipelines/client.service.ts

@@ -61,7 +61,7 @@ export class PipelinesClientService implements OnModuleInit {
     const findAllPipelineResponse = await new Promise((resolve, reject) => {
       this.pipelineService.FindAll(objectSnakeToCamel(data)).subscribe({
         next(x) {
-          resolve(x);
+          resolve(x.pipelines);
         },
         error(err) {
           console.log('Observable Error');
@@ -182,22 +182,31 @@ export class PipelinesClientService implements OnModuleInit {
     return logsPipelineResponse;
   }
 
-  async getPipelineStatus(data: IIdRequest) {
+  async getPipelineStatus(data) {
     console.log('PipelinesClientService', 'GetPipelineStatus');
 
     const statusPipelineResponse = await new Promise((resolve, reject) => {
-      this.pipelineService.getPipelineStatus(data).subscribe({
-        next(x) {
-          resolve(x);
-        },
-        error(err) {
-          console.log('Observable Error');
-          reject(err);
-        },
-        complete() {
-          console.log('done');
-        },
-      });
+      this.pipelineService
+        .getPipelineStatus(objectSnakeToCamel(data))
+        .subscribe({
+          next(x) {
+            const statusArray = x.status.sort((a, b) => {
+              if (a.id < b.id) {
+                return 1;
+              } else {
+                return -1;
+              }
+            });
+            resolve({ status: statusArray });
+          },
+          error(err) {
+            console.log('Observable Error');
+            reject(err);
+          },
+          complete() {
+            console.log('done');
+          },
+        });
     })
       .then((res) => res)
       .catch((err) => {
@@ -214,6 +223,11 @@ export class PipelinesClientService implements OnModuleInit {
         .triggerPipeline(objectSnakeToCamel({ id, info }))
         .subscribe({
           next(x) {
+            if (x.status == false) {
+              reject(
+                'This pipeline is not ready yet to execute, Try again later!',
+              );
+            }
             resolve(x);
           },
           error(err) {

src/clients/transformations/client.config.ts

@@ -10,7 +10,7 @@ export class TransformationsClientConfiguration {
     return {
       transport: Transport.GRPC,
       options: {
-        url: process.env.TRFACTORY_URL,
+        url: process.env.INFACTORY_URL,
         package: TransformationPackages,
         credentials: credentials.createSsl(),
         protoPath: TransformationProtoFilePath,

src/middlewares/authentication.ts

@@ -17,9 +17,11 @@ export class LoggerMiddleware implements NestMiddleware {
     const idToken = request.get('Dadosfera-User');
     const accessToken = request.get('Authorization');
     const privateKey = process.env.JWT_PRIVATE_KEY;
-
+    let requiredRoute = '';
     const requiredMethod = request.method.trim();
-    const requiredRoute = request.route.path.split('/')[1].trim();
+    if (request.route.path.split('/').length >= 2) {
+      requiredRoute = request.route.path.split('/')[1].trim();
+    }
 
     verify(idToken, privateKey, (err) => {
       if (err) {
@@ -29,6 +31,7 @@ export class LoggerMiddleware implements NestMiddleware {
     const jwtDecoded: any = decode(idToken);
 
     const permissions = jwtDecoded.user.permissions;
+
     const clienId = jwtDecoded.user.customerId;
     const customer = jwtDecoded.user.customer;
     const userId = jwtDecoded.user.id;
@@ -36,16 +39,20 @@ export class LoggerMiddleware implements NestMiddleware {
     await verifyToken(accessToken);
 
     let havePermission = false;
-    permissions.forEach((permission) => {
+    const permission = permissions.find((permission) => {
       permission = permission.split('/');
       const method = permission[0].trim();
       const route = permission[1].trim();
 
       if (method === requiredMethod && route === requiredRoute) {
-        havePermission = true;
+        return permission;
       }
     });
 
+    if (permission) {
+      havePermission = true;
+    }
+
     if (havePermission) {
       request.body.info = {
         customer_id: clienId,

src/modules/auth/auth.controller.ts

@@ -1,27 +1,148 @@
-import { Body, Controller, Post, UnauthorizedException } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Headers,
+  Post,
+  HttpCode,
+  HttpStatus,
+  UnauthorizedException,
+} from '@nestjs/common';
+import {
+  AuthSignInRequest,
+  AuthRefreshAccessTokenRequest,
+  AuthEnableTotpMfaRequest,
+  AuthDisableTotpMfaRequest,
+  AuthVerifyTotpMfaRequest,
+} from '@victorradael/protospack';
 
 import { AuthClientService } from 'src/clients/auth/client.service';
 
-interface ISignIn {
-  username: string;
-  password: string;
-}
+import ErrorBuilder from '../../utils/ErrorBuilder';
 
 @Controller('auth')
 export class AuthController {
   constructor(private authClient: AuthClientService) {}
 
+  // DEPRECADO!
   @Post()
-  async signIn(@Body() { username, password }: ISignIn) {
+  @HttpCode(HttpStatus.OK)
+  async signIn_old(@Body() body: AuthSignInRequest) {
+    console.log(`/auth`, 'SignIn_old');
+
+    return this.signIn(body);
+  }
+
+  @Post('login')
+  @HttpCode(HttpStatus.OK)
+  async signIn_login(@Body() body: AuthSignInRequest) {
+    console.log(`/auth`, 'SignIn_login');
+
+    return this.signIn(body);
+  }
+
+  @Post('sign-in')
+  @HttpCode(HttpStatus.OK)
+  async signIn(@Body() { username, password, totp }: AuthSignInRequest) {
     console.log(`/auth`, 'SignIn');
 
     const tokens = await this.authClient
-      .signIn({ username, password })
-      .then((result) => result)
+      .signIn({ username, password, totp })
       .catch((err) => {
-        throw new UnauthorizedException(err.message);
+        throw ErrorBuilder(err);
       });
 
     return tokens;
   }
+
+  @Post('refresh-access-token')
+  @HttpCode(HttpStatus.OK)
+  async refreshAccessToken(
+    @Body() { username, refreshToken }: AuthRefreshAccessTokenRequest,
+  ) {
+    console.log(`/auth`, 'RefreshAccessToken');
+
+    const accessToken = await this.authClient
+      .refreshAccessToken({ username, refreshToken })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return accessToken;
+  }
+
+  @Post('enable-totp')
+  @HttpCode(HttpStatus.OK)
+  async enableTotpMFA(
+    @Body() body: AuthEnableTotpMfaRequest,
+    @Headers() headers,
+  ) {
+    console.log(`/auth`, 'enable-totp');
+
+    const { password } = body;
+    const { authorization: accessToken } = headers;
+
+    const response = await this.authClient
+      .enableTotpMFA({ accessToken, password })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('disable-totp')
+  @HttpCode(HttpStatus.OK)
+  async disableTotpMFA(
+    @Body() body: AuthDisableTotpMfaRequest,
+    @Headers() headers,
+  ) {
+    console.log(`/auth`, 'disable-totp');
+
+    const { password } = body;
+    const { authorization: accessToken } = headers;
+
+    const response = await this.authClient
+      .disableTotpMFA({ accessToken, password })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('dismiss-totp')
+  @HttpCode(HttpStatus.OK)
+  async dismissTotpMFA(@Headers() headers) {
+    console.log(`/auth`, 'disable-totp');
+
+    const { authorization: accessToken } = headers;
+
+    const response = await this.authClient
+      .dismissTotpMFA({ accessToken })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('verify-totp')
+  @HttpCode(HttpStatus.OK)
+  async verifyTotp(
+    @Body() body: AuthVerifyTotpMfaRequest,
+    @Headers() headers,
+  ): Promise<any> {
+    console.log(`/auth`, 'enable-totp');
+
+    const { totp } = body;
+    const { authorization: accessToken } = headers;
+
+    const response = await this.authClient
+      .verifyTotp({ accessToken, totp })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
 }

src/modules/catalog/catalog.controller.ts

@@ -1,4 +1,12 @@
-import { Body, Controller, Delete, Get, Param, Post } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Query,
+} from '@nestjs/common';
 import { CatalogService } from './catalog.service';
 
 @Controller('catalog')
@@ -9,9 +17,7 @@ export class CatalogController {
   async catalogAll(@Body() body) {
     console.log(`/catalog`, 'ON CATALOG ALL ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.catalogAll(body);
+    const res = await this.catalogService.catalogAll(body);
 
     return res;
   }
@@ -20,9 +26,7 @@ export class CatalogController {
   async dataAppsAll(@Body() body) {
     console.log(`/catalog`, 'ON FIND ALL DATA APPS ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.dataAppsAll(body);
+    const res = await this.catalogService.dataAppsAll(body);
 
     return res;
   }
@@ -31,9 +35,8 @@ export class CatalogController {
   async dataAppsOne(@Param() params, @Body() body) {
     console.log(`/catalog`, 'ON FIND ONE DATA APP ROUTE');
     const { id } = params;
-    const catalogService = new CatalogService();
 
-    const res = await catalogService.dataAppsOne(body, id);
+    const res = await this.catalogService.dataAppsOne(id, body);
 
     return res;
   }
@@ -42,9 +45,7 @@ export class CatalogController {
   async getAllDashboardMetabase(@Body() body) {
     console.log(`/catalog`, 'ON GET ALL DASHBOARDS METABASE ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getAllDashboardMetabase(body);
+    const res = await this.catalogService.getAllDashboardMetabase(body);
 
     return res;
   }
@@ -54,66 +55,58 @@ export class CatalogController {
     const { id } = params;
     console.log(`/catalog`, 'ON GET ONE DASHBOARD METABASE ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getOneDashboardMetabase(body, id);
+    const res = await this.catalogService.getOneDashboardMetabase(id, body);
 
     return res;
   }
 
   @Get('table-metadata')
-  async getAllTableMetadata(@Body() body) {
+  async getAllTableMetadata(@Body() body, @Query() query) {
     console.log(`/catalog`, 'ON GET ALL TABLES METADATA ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getAllTableMetadata(body);
-
-    return res;
+    if (!query) {
+      const res = await this.catalogService.getAllTableMetadata(body);
+      return res;
+    } else {
+      const res = await this.catalogService.getOneTableMetadata(body, query);
+      return res;
+    }
   }
 
-  @Delete('table-metadata')
+  @Delete('table-metadata/:id')
   async deleteOneTableMetadata(@Param() params, @Body() body) {
     const { id } = params;
     console.log(`/catalog`, 'ON DELETE ONE TABLE METADATA ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.deleteOneTableMetadata(body, id);
+    const res = await this.catalogService.deleteOneTableMetadata(id, body);
 
     return res;
   }
 
   @Get('column-metadata')
-  async getOneColumnMetadata(@Body() body) {
+  async getOneColumnMetadata(@Body() body, @Query() params) {
     console.log(`/catalog`, 'ON GET ONE COLUMN METADATA ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getOneColumnMetadata(body);
+    const res = await this.catalogService.getOneColumnMetadata(body, params);
 
     return res;
   }
 
-  @Delete('column-metadata')
+  @Delete('column-metadata/:id')
   async deleteOneColumnMetadata(@Param() params, @Body() body) {
     console.log(`/catalog`, 'ON DELETE ONE COLUMN METADATA ROUTE');
     const { id } = params;
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.deleteOneColumnMetadata(body, id);
+    const res = await this.catalogService.deleteOneColumnMetadata(id, body);
 
     return res;
   }
 
   @Get('data-preview')
-  async getOneDataPreview(@Body() body) {
+  async getOneDataPreview(@Body() body, @Query() params) {
     console.log(`/catalog`, 'ON GET ONE DATAPREVIEW ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getOneDataPreview(body);
+    const res = await this.catalogService.getOneDataPreview(body, params);
 
     return res;
   }
@@ -122,9 +115,16 @@ export class CatalogController {
   async getDataStatus(@Body() body) {
     console.log(`/catalog`, 'ON GET DATA STATUS ROUTE');
 
-    const catalogService = new CatalogService();
+    const res = await this.catalogService.getDataStatus(body);
 
-    const res = await catalogService.getDataStatus(body);
+    return res;
+  }
+
+  @Get('data-status')
+  async createDataStatus(@Body() body) {
+    console.log(`/catalog`, 'ON CREATE DATA STATUS ROUTE');
+
+    const res = await this.catalogService.createDataStatus(body);
 
     return res;
   }
@@ -133,9 +133,16 @@ export class CatalogController {
   async getDataDescription(@Body() body) {
     console.log(`/catalog`, 'ON GET DATA DESCRIPTION ROUTE');
 
-    const catalogService = new CatalogService();
+    const res = await this.catalogService.getDataDescription(body);
 
-    const res = await catalogService.getDataDescription(body);
+    return res;
+  }
+
+  @Post('data-description')
+  async createDataDescription(@Body() body) {
+    console.log(`/catalog`, 'ON CREATE DATA DESCRIPTION ROUTE');
+
+    const res = await this.catalogService.createDataDescription(body);
 
     return res;
   }
@@ -144,9 +151,16 @@ export class CatalogController {
   async getDataDocs(@Body() body) {
     console.log(`/catalog`, 'ON GET DATA DOCS ROUTE');
 
-    const catalogService = new CatalogService();
+    const res = await this.catalogService.getDataDocs(body);
 
-    const res = await catalogService.getDataDocs(body);
+    return res;
+  }
+
+  @Post('data-docs')
+  async createDataDocs(@Body() body) {
+    console.log(`/catalog`, 'ON CREATE DATA DOCS ROUTE');
+
+    const res = await this.catalogService.createDataDocs(body);
 
     return res;
   }
@@ -155,43 +169,58 @@ export class CatalogController {
   async getDataRating(@Body() body) {
     console.log(`/catalog`, 'ON GET DATA RATING ROUTE');
 
-    const catalogService = new CatalogService();
+    const res = await this.catalogService.getDataRating(body);
 
-    const res = await catalogService.getDataRating(body);
+    return res;
+  }
+
+  @Post('data-rating')
+  async createDataRating(@Body() body) {
+    console.log(`/catalog`, 'ON GET DATA RATING ROUTE');
+
+    const res = await this.catalogService.createDataRating(body);
 
     return res;
   }
 
   @Get('summary-rating/:id')
-  async getSummaryRating(@Param() params, @Body() body) {
+  async getSummaryRating() {
     console.log(`/catalog`, 'ON GET SUMMARY RATING ROUTE');
-    const { id } = params;
+    //const { id } = params;
 
-    const catalogService = new CatalogService();
+    //
 
-    const res = await catalogService.getSummaryRating(id, body);
+    //const res = await this.catalogService.getSummaryRating(id, body);
 
-    return res;
+    return {
+      avg_rating: 0,
+      rating_count: 0,
+    };
   }
 
   @Get('data-comment')
   async getDataComment(@Body() body) {
     console.log(`/catalog`, 'ON GET DATA COMMENT ROUTE');
 
-    const catalogService = new CatalogService();
+    const res = await this.catalogService.getDataComment(body);
 
-    const res = await catalogService.getDataComment(body);
+    return res;
+  }
+
+  @Post('data-comment')
+  async createDataComment(@Body() body) {
+    console.log(`/catalog`, 'ON GET DATA COMMENT ROUTE');
+
+    const res = await this.catalogService.createDataComment(body);
 
     return res;
   }
 
   @Get('data-review')
-  async getDataReview(@Body() body) {
+  async getDataReview(@Body() body, @Query() params) {
     console.log(`/catalog`, 'ON GET DATA REVIEW ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getDataReview(body);
+    const res = await this.catalogService.getDataReview(body, params);
 
     return res;
   }
@@ -200,9 +229,7 @@ export class CatalogController {
   async createTags(@Body() body) {
     console.log(`/catalog`, 'ON CREATE TAG ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.createTags(body);
+    const res = await this.catalogService.createTags(body);
 
     return res;
   }
@@ -211,9 +238,7 @@ export class CatalogController {
   async findAllTags(@Body() body) {
     console.log(`/catalog`, 'ON FIND ALL TAGS ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.findAllTags(body);
+    const res = await this.catalogService.findAllTags(body);
 
     return res;
   }
@@ -223,9 +248,7 @@ export class CatalogController {
     console.log(`/catalog`, 'ON DELETE TAG ROUTE');
     const { id } = params;
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.deleteTags(body, id);
+    const res = await this.catalogService.deleteTags(id, body);
 
     return res;
   }
@@ -234,9 +257,7 @@ export class CatalogController {
   async createTableTags(@Body() body) {
     console.log(`/catalog`, 'ON CREATE TABLE TAG ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.createTableTags(body);
+    const res = await this.catalogService.createTableTags(body);
 
     return res;
   }
@@ -245,21 +266,17 @@ export class CatalogController {
   async getAllTableTags(@Body() body) {
     console.log(`/catalog`, 'ON GET ALL TABLE TAGS ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.findAllTableTags(body);
+    const res = await this.catalogService.findAllTableTags(body);
 
     return res;
   }
 
-  @Delete('table-tags')
+  @Delete('table-tags/:id')
   async deleteTableTags(@Param() params, @Body() body) {
     console.log(`/catalog`, 'ON CREATE TABLE TAGS ROUTE');
     const { id } = params;
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.deleteTableTags(body, id);
+    const res = await this.catalogService.deleteTableTags(id, body);
 
     return res;
   }
@@ -268,21 +285,17 @@ export class CatalogController {
   async getTableRules(@Body() body) {
     console.log(`/catalog`, 'ON GET TABLE RULES ROUTE');
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.getTableRules(body);
+    const res = await this.catalogService.getTableRules(body);
 
     return res;
   }
 
-  @Delete('table-rules')
+  @Delete('table-rules/:id')
   async deleteTableRules(@Param() params, @Body() body) {
     console.log(`/catalog`, 'ON DELETE TABLE RULES ROUTE');
     const { id } = params;
 
-    const catalogService = new CatalogService();
-
-    const res = await catalogService.deleteTableRules(body, id);
+    const res = await this.catalogService.deleteTableRules(id, body);
 
     return res;
   }

src/modules/catalog/catalog.service.ts

@@ -1,308 +1,260 @@
 import axios from 'axios';
 
 class CatalogService {
+  _getNimbusUrl(body) {
+    const customer = body.info.customer.toLowerCase();
+
+    if (process.env.ENV === 'prd') {
+      return `https://nimbus-${customer}.dadosfera.ai`;
+    }
+
+    return `https://nimbus-${customer}.${process.env.ENV}.dadosfera.ai`;
+  }
+
   async catalogAll(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/all/`,
-    );
-    console.log(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/all/`,
-    );
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/all/`);
+
     return data;
   }
 
   async dataAppsAll(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data_apps/`,
-    );
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data_apps/`);
     return data;
   }
 
   async dataAppsOne(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data_apps/${id}/`,
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(
+      `${nimbusUrl}/api/catalog/data_apps/${id}/`,
     );
+
     return data;
   }
 
   async getAllDashboardMetabase(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/dashboard-metabase/`,
+      `${nimbusUrl}/api/catalog/dashboard-metabase/`,
     );
     return data;
   }
 
-  async getOneDashboardMetabase(body, id) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+  async getOneDashboardMetabase(id, body) {
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/dashboard-metabase/${id}`,
+      `${nimbusUrl}/api/catalog/dashboard-metabase/${id}`,
     );
+    console.log(data);
+
+    // const [, path] = data.iframe_url.split('.dadosfera');
+    // const host = `httpss://metabase-${body.info.customer.toLowerCase()}.dadosfera.ai`;
+    // data.iframe_url = host + path;
+
     return data;
   }
 
   async getAllTableMetadata(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-metadata/`,
+      `${nimbusUrl}/api/catalog/table-metadata/`,
+    );
+    return data;
+  }
+
+  async getOneTableMetadata(body, params) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(
+      `${nimbusUrl}/api/catalog/table-metadata/`,
+      { params: params },
     );
     return data;
   }
 
   async deleteOneTableMetadata(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-metadata/${id}`,
+      `${nimbusUrl}/api/catalog/table-metadata/${id}`,
     );
     return data;
   }
 
-  async getOneColumnMetadata(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+  async getOneColumnMetadata(body, params) {
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/column-metadata/`,
+      `${nimbusUrl}/api/catalog/column-metadata/`,
+      { params: params },
     );
     return data;
   }
 
   async deleteOneColumnMetadata(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/column-metadata/${id}/`,
+      `${nimbusUrl}/api/catalog/column-metadata/${id}/`,
     );
     return data;
   }
 
-  async getOneDataPreview(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-preview/`,
-    );
+  async getOneDataPreview(body, params) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-preview/`, {
+      params: params,
+    });
     return data;
   }
 
   async getDataStatus(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-status/`);
+    return data;
+  }
 
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-status/`,
+  async createDataStatus(body) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(
+      `${nimbusUrl}/api/catalog/data-status/`,
+      body,
     );
     return data;
   }
 
   async getDataDescription(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-description/`,
+      `${nimbusUrl}/api/catalog/data-description/`,
+    );
+    return data;
+  }
+
+  async createDataDescription(body) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(
+      `${nimbusUrl}/api/catalog/data-description/`,
+      body,
     );
     return data;
   }
 
   async getDataDocs(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-docs/`);
+    return data;
+  }
 
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-docs/`,
+  async createDataDocs(body) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(
+      `${nimbusUrl}/api/catalog/data-docs/`,
+      body,
     );
     return data;
   }
 
   async getDataRating(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-rating/`);
+    return data;
+  }
 
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-rating/`,
+  async createDataRating(body) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(
+      `${nimbusUrl}/api/catalog/data-rating/`,
+      body,
     );
     return data;
   }
 
   async getSummaryRating(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/summary-rating/${id}`,
+      `${nimbusUrl}/api/catalog/summary-rating/${id}`,
     );
     return data;
   }
 
   async getDataComment(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-comment/`);
+    return data;
+  }
 
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-comment/`,
+  async createDataComment(body) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(
+      `${nimbusUrl}/api/catalog/data-comment/`,
+      body,
     );
     return data;
   }
 
-  async getDataReview(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/data-review/`,
-    );
+  async getDataReview(body, params) {
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/data-review/`, {
+      params: params,
+    });
     return data;
   }
 
   async createTags(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.post(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/tags/`,
-      body,
-    );
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.post(`${nimbusUrl}/api/catalog/tags/`, body);
     return data;
   }
 
   async findAllTags(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/tags/`,
-      body,
-    );
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.get(`${nimbusUrl}/api/catalog/tags/`, body);
     return data;
   }
 
   async findAllTableTags(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-tags/`,
+      `${nimbusUrl}/api/catalog/table-tags/`,
       body,
     );
     return data;
   }
 
   async deleteTags(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
-    const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/tags/${id}`,
-    );
+    const nimbusUrl = this._getNimbusUrl(body);
+    const { data } = await axios.delete(`${nimbusUrl}/api/catalog/tags/${id}`);
     return data;
   }
 
   async createTableTags(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.post(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-tags/`,
+      `${nimbusUrl}/api/catalog/table-tags/`,
       body,
     );
     return data;
   }
 
   async deleteTableTags(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-tags/${id}`,
+      `${nimbusUrl}/api/catalog/table-tags/${id}`,
     );
     return data;
   }
 
   async getTableRules(body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.get(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-rules/`,
+      `${nimbusUrl}/api/catalog/table-rules/`,
       body,
     );
     return data;
   }
 
   async deleteTableRules(id, body) {
-    const customer =
-      body.info.customer.toLowerCase() === 'dadosfera'
-        ? ``
-        : `-${body.info.customer.toLowerCase()}`;
-
+    const nimbusUrl = this._getNimbusUrl(body);
     const { data } = await axios.delete(
-      `${process.env.NIMBUS_BASE_URL}${customer}.${process.env.ENV}.dadosfera/api/catalog/table-rules/${id}`,
+      `${nimbusUrl}/api/catalog/table-rules/${id}`,
     );
     return data;
   }

src/modules/inputs/inputs.controller.ts

@@ -9,10 +9,8 @@ import {
 } from '@nestjs/common';
 import { InputsService } from './inputs.service';
 import { InputsClientService } from 'src/clients/inputs/client.service';
-import {
-  ICreateInputRequest,
-  UpdateInputRequest,
-} from 'src/clients/inputs/interfaces';
+import { UpdateInputRequest } from 'src/clients/inputs/interfaces';
+import { InputNewCreateRequest } from '@victorradael/protospack';
 
 @Controller('inputs')
 export class InputsController {
@@ -28,8 +26,21 @@ export class InputsController {
     return response;
   }
 
+  @Post('/test-connection/get-columns')
+  async getColumns(@Body() data) {
+    console.log(
+      `/test-connection/get-columns`,
+      'ON TEST CONNECTION GET COLUMNS ROUTE',
+    );
+
+    const inputService = new InputsService(this.inputsClientService);
+    const response = await inputService.getColumns(data);
+
+    return response;
+  }
+
   @Post()
-  async create(@Body() createInputDto: ICreateInputRequest) {
+  async create(@Body() createInputDto: InputNewCreateRequest) {
     console.log(`/input`, 'ON CREATE ROUTE');
 
     const inputService = new InputsService(this.inputsClientService);

src/modules/inputs/inputs.service.ts

@@ -1,20 +1,33 @@
 import { Body, HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import { Timeout } from '@nestjs/schedule';
 import { InputsClientService } from 'src/clients/inputs/client.service';
-import {
-  ICreateInputRequest,
-  IIdRequest,
-  Info,
-} from 'src/clients/inputs/interfaces';
+import { IIdRequest, Info } from 'src/clients/inputs/interfaces';
 
 @Injectable()
 export class InputsService {
   constructor(private inputClient: InputsClientService) {}
 
-  async create(@Body() data: ICreateInputRequest) {
+  async create(@Body() data) {
     try {
-      const createInputResponse = await this.inputClient.create(data);
-
-      return createInputResponse;
+      if (
+        data.plugin == 'csv' ||
+        data.plugin == 'json' ||
+        data.plugin == 'parquet'
+      ) {
+        const { info, ...input } = data;
+        const inputPayload = this.generateInputS3Payload(input);
+        const createInputResponse = await this.inputClient.createS3Inputs({
+          input: inputPayload,
+          info,
+        });
+        return createInputResponse;
+      } else {
+        const createInputResponse: any = await this.inputClient.create(data);
+        if (createInputResponse?.input?.input_jdbc) {
+          return { input: createInputResponse?.input?.input_jdbc };
+        }
+        return createInputResponse;
+      }
     } catch (err) {
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
@@ -63,6 +76,7 @@ export class InputsService {
     }
   }
 
+  @Timeout(60000 * 10) // Timeout set for 10 minutes
   async testConnection(data) {
     try {
       const testConnectionInputResponse = await this.inputClient.testConnection(
@@ -74,4 +88,40 @@ export class InputsService {
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
   }
+
+  async getColumns(data) {
+    try {
+      const testConnectionGetColumnsResponse =
+        await this.inputClient.getColumns(data);
+
+      return testConnectionGetColumnsResponse;
+    } catch (err) {
+      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
+    }
+  }
+
+  generateInputS3Payload(payload) {
+    const { credentials, plugin } = payload;
+    if (!credentials) return payload;
+
+    const {
+      client_aws_access_key_id,
+      client_aws_secret_access_key,
+      file_format_params,
+      format_file_params,
+      client_bucket,
+      file_to_extract,
+    } = credentials;
+    const formatedPayload = {
+      plugin,
+      source_bucket: client_bucket,
+      source_prefix: file_to_extract,
+      auth_parameters: {
+        aws_access_key_id: client_aws_access_key_id,
+        aws_secret_access_key: client_aws_secret_access_key,
+      },
+      file_format_params: file_format_params || format_file_params,
+    };
+    return formatedPayload;
+  }
 }

src/modules/pipelines/pipelines.controller.ts

@@ -14,13 +14,13 @@ import { PipelinesService } from './pipelines.service';
 export class PipelinesController {
   constructor(private pipelinesClientService: PipelinesClientService) {}
 
-  @Get('start/:id')
+  @Post('start/:id')
   async activate(@Param() params, @Body() body) {
     const { id } = params;
     const { info } = body;
 
     console.log(
-      process.env.DEV_URL + `/transformation/start/${id}`,
+      process.env.DEV_URL + `/pipeline/start/${id}`,
       'ON START PIPELINE ROUTE',
     );
 

src/modules/pipelines/pipelines.service.ts

@@ -7,13 +7,20 @@ import { objectCamelToSnake } from 'src/utils/CaseConverter';
 export class PipelinesService {
   constructor(private pipelineClient: PipelinesClientService) {}
 
+  adjustPayload(payload) {
+    payload.input = payload.input?.input_s3 || payload.input?.input_jdbc;
+  }
+
   async create(createPipelineDto) {
     try {
       const createPipelineResponse = await this.pipelineClient.create(
         createPipelineDto,
       );
 
-      return objectCamelToSnake(createPipelineResponse);
+      const pipeline = objectCamelToSnake(createPipelineResponse);
+      this.adjustPayload(pipeline.pipeline);
+
+      return pipeline;
     } catch (err) {
       console.log(err);
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
@@ -23,7 +30,11 @@ export class PipelinesService {
   async findOne(data: IIdRequest) {
     try {
       const findOnePipelineResponse = await this.pipelineClient.findOne(data);
-      return objectCamelToSnake(findOnePipelineResponse);
+
+      const pipeline = objectCamelToSnake(findOnePipelineResponse);
+      this.adjustPayload(pipeline.pipeline);
+
+      return pipeline;
     } catch (err) {
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
@@ -33,7 +44,11 @@ export class PipelinesService {
     try {
       const findAllPipelineResponse = await this.pipelineClient.findAll(data);
 
-      return objectCamelToSnake(findAllPipelineResponse);
+      const pipelines = objectCamelToSnake(findAllPipelineResponse);
+      pipelines.forEach((pipeline) => {
+        this.adjustPayload(pipeline);
+      });
+      return { pipelines };
     } catch (err) {
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }
@@ -47,7 +62,10 @@ export class PipelinesService {
         ...data,
       });
 
-      return objectCamelToSnake(updatePipelineResponse);
+      const pipeline = objectCamelToSnake(updatePipelineResponse);
+      this.adjustPayload(pipeline);
+
+      return pipeline;
     } catch (err) {
       throw new HttpException(err.message, HttpStatus.NOT_FOUND);
     }

src/utils/ErrorBuilder.ts

@@ -0,0 +1,106 @@
+import { HttpStatus, HttpException } from '@nestjs/common';
+
+import ErrorCodes from './errorCodes';
+
+function Builder({ statusCode, message, error, code }) {
+  return new HttpException({ statusCode, message, error, code }, statusCode);
+}
+
+export default function ErrorBuilder(code: string) {
+  console.log(code);
+
+  switch (code) {
+    case ErrorCodes.AUTH.WRONG_CREDENTIALS:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não autenticado',
+        message: 'Usuário ou senha incorretos',
+        code,
+      });
+
+    case ErrorCodes.AUTH.WRONG_PASSWORD_CONFIRMATION:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Senha incorreta',
+        message: 'Confirmação de senha incorreta',
+        code,
+      });
+
+    case ErrorCodes.AUTH.TOTP_NOT_ENABLED:
+      return Builder({
+        statusCode: HttpStatus.PRECONDITION_FAILED,
+        error: 'Não permitido',
+        message: 'A autenticação multifator não está habilitada',
+        code,
+      });
+
+    case ErrorCodes.AUTH.TOTP_ALREADY_ENABLED:
+      return Builder({
+        statusCode: HttpStatus.PRECONDITION_FAILED,
+        error: 'Não permitido',
+        message: 'A autenticação multifator já está habilitada',
+        code,
+      });
+
+    case ErrorCodes.AUTH.TOTP_ALREADY_DISABLED:
+      return Builder({
+        statusCode: HttpStatus.PRECONDITION_FAILED,
+        error: 'Não permitido',
+        message: 'A autenticação multifator já está desabilitada',
+        code,
+      });
+
+    case ErrorCodes.AUTH.TOTP_REQUIRED:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não autenticado',
+        message: 'Informe o token de autenticação multifator',
+        code,
+      });
+
+    case ErrorCodes.AUTH.CODE_MISMATCH:
+    case ErrorCodes.AUTH.CODE_ALREADY_USED:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não autenticado',
+        message: 'Token de autenticação multifator inválido',
+        code,
+      });
+
+    case ErrorCodes.RATE_LIMIT:
+      return Builder({
+        statusCode: HttpStatus.TOO_MANY_REQUESTS,
+        error: 'Limite excedido',
+        message:
+          'Você tentou realizar essa operação muitas vezes. Tente novamente mais tarde',
+        code,
+      });
+
+    case ErrorCodes.AUTH.UNAUTHORIZED:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não autenticado',
+        message: 'É necessário estar logado para realizar essa operação',
+        code,
+      });
+
+    case ErrorCodes.AUTH.FORBIDDEN:
+      return Builder({
+        statusCode: HttpStatus.FORBIDDEN,
+        error: 'Não autorizado',
+        message:
+          'Você não tem permissões suficientes para realizar essa operação',
+        code,
+      });
+
+    case ErrorCodes.UNKNOWN:
+    default:
+      return Builder({
+        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+        error: 'Desconhecido',
+        message:
+          'Erro desconhecido. Tente novamente ou entre em contato com o suporte',
+        code: ErrorCodes.UNKNOWN,
+      });
+  }
+}

src/utils/errorCodes.ts

@@ -0,0 +1,20 @@
+export const Auth = {
+  UNAUTHORIZED: 'AUTH.UNAUTHORIZED',
+  FORBIDDEN: 'AUTH.FORBIDDEN',
+  WRONG_CREDENTIALS: 'AUTH.WRONG_CREDENTIALS',
+  WRONG_PASSWORD_CONFIRMATION: 'AUTH.WRONG_PASSWORD_CONFIRMATION',
+  TOTP_NOT_ENABLED: 'AUTH.TOTP_NOT_ENABLED',
+  TOTP_ALREADY_ENABLED: 'AUTH.TOTP_ALREADY_ENABLED',
+  TOTP_ALREADY_DISABLED: 'AUTH.TOTP_ALREADY_DISABLED',
+  TOTP_REQUIRED: 'AUTH.TOTP_REQUIRED',
+  CODE_MISMATCH: 'AUTH.CODE_MISMATCH',
+  CODE_ALREADY_USED: 'AUTH.CODE_ALREADY_USED',
+};
+
+const ErrorCodes = {
+  UNKNOWN: 'UNKNOWN',
+  RATE_LIMIT: 'RATE_LIMIT',
+  AUTH: Auth,
+};
+
+export default ErrorCodes;