FIX: Better error handling on input creation

Merge pull request #102 from dadosfera/fix/error-handling

.ebextensions/01_setup_swap.config

@@ -0,0 +1,3 @@
+container_commands:
+    01setup_swap:
+        command: "bash .ebextensions/setup_swap.sh"

.ebextensions/setup_swap.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+SWAPFILE=/var/swapfile
+SWAP_MEGABYTES=1024
+
+if [ -f $SWAPFILE ]; then
+    echo "Swapfile $SWAPFILE found, assuming already setup"
+    exit;
+fi
+
+/bin/dd if=/dev/zero of=$SWAPFILE bs=1M count=$SWAP_MEGABYTES
+/bin/chmod 600 $SWAPFILE
+/sbin/mkswap $SWAPFILE
+/sbin/swapon $SWAPFILE

.nvmrc

@@ -0,0 +1 @@
+18

package.json

@@ -31,8 +31,9 @@
     "@nestjs/platform-express": "^8.4.3",
     "@nestjs/schedule": "^1.1.0",
     "@nestjs/swagger": "^5.2.1",
-    "@victorradael/protospack": "2.4.1",
+    "@victorradael/protospack": "2.4.2-1",
     "axios": "^0.25.0",
+    "cron-parser": "^4.4.0",
     "dotenv": "^14.2.0",
     "helmet": "^5.0.2",
     "jsonwebtoken": "^8.5.1",
@@ -42,8 +43,8 @@
     "rxjs": "^7.5.5",
     "swagger-ui-express": "^4.3.0"
   },
-  "overrides":{
-    "busboy@<1.6.0":"1.6.0"
+  "overrides": {
+    "multer": "1.4.5-lts.1"
   },
   "devDependencies": {
     "@nestjs/cli": "^8.2.4",

src/clients/auth/client.service.ts

@@ -12,6 +12,10 @@ import {
   AuthDisableTotpMfaRequest,
   AuthDismissTotpMfaRequest,
   AuthVerifyTotpMfaRequest,
+  AuthChangePasswordRequest,
+  AuthResetPasswordRequest,
+  AuthVerifyResetPasswordCodeRequest,
+  AuthConfirmResetPasswordRequest,
 } from '@victorradael/protospack';
 
 export class AuthClientService implements OnModuleInit {
@@ -32,11 +36,7 @@ export class AuthClientService implements OnModuleInit {
     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);
-        },
+        error: (err) => reject(err.details),
         complete() {
           console.log('done');
         },
@@ -181,4 +181,79 @@ export class AuthClientService implements OnModuleInit {
       });
     });
   }
+
+  async changePassword({
+    accessToken,
+    oldPassword,
+    newPassword,
+  }: AuthChangePasswordRequest): Promise<any> {
+    console.log('AuthClientService', 'ChangePassword');
+
+    return new Promise((resolve, reject) => {
+      this.authService
+        .changePassword({
+          accessToken,
+          oldPassword,
+          newPassword,
+        })
+        .subscribe({
+          next: resolve,
+          error: (err) => reject(err.details),
+          complete() {
+            console.log('done');
+          },
+        });
+    });
+  }
+
+  async resetPassword({ username }: AuthResetPasswordRequest): Promise<any> {
+    console.log('AuthClientService', 'resetPassword');
+
+    return new Promise((resolve, reject) => {
+      this.authService.resetPassword({ username }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async verifyResetPasswordCode({
+    username,
+    code,
+  }: AuthVerifyResetPasswordCodeRequest): Promise<any> {
+    console.log('AuthClientService', 'verifyResetPasswordCode');
+
+    return new Promise((resolve, reject) => {
+      this.authService.verifyResetPasswordCode({ username, code }).subscribe({
+        next: resolve,
+        error: (err) => reject(err.details),
+        complete() {
+          console.log('done');
+        },
+      });
+    });
+  }
+
+  async confirmResetPassword({
+    username,
+    code,
+    newPassword,
+  }: AuthConfirmResetPasswordRequest): Promise<any> {
+    console.log('AuthClientService', 'confirmResetPassword');
+
+    return new Promise((resolve, reject) => {
+      this.authService
+        .confirmResetPassword({ username, code, newPassword })
+        .subscribe({
+          next: resolve,
+          error: (err) => reject(err.details),
+          complete() {
+            console.log('done');
+          },
+        });
+    });
+  }
 }

src/clients/pipelines/client.service.ts

@@ -1,4 +1,4 @@
-import { Inject, OnModuleInit } from '@nestjs/common';
+import { HttpException, Inject, OnModuleInit } from '@nestjs/common';
 import { ClientGrpc, Payload } from '@nestjs/microservices';
 import {
   PipelineServicesNames,
@@ -49,7 +49,10 @@ export class PipelinesClientService implements OnModuleInit {
     })
       .then((res) => res)
       .catch((err) => {
-        throw new Error(err);
+        if (err.details == 'Invalid Request') {
+          throw new HttpException(err.details, 400);
+        }
+        throw new HttpException(err.details, 500);
       });
 
     return createPipelineResponse;

src/middlewares/authentication.ts

@@ -32,9 +32,10 @@ export class LoggerMiddleware implements NestMiddleware {
 
     const permissions = jwtDecoded.user.permissions;
 
-    const clienId = jwtDecoded.user.customerId;
+    const clientId = jwtDecoded.user.customerId;
     const customer = jwtDecoded.user.customer;
     const userId = jwtDecoded.user.id;
+    const customer_tier = jwtDecoded.user.customer_tier;
 
     await verifyToken(accessToken);
 
@@ -55,11 +56,11 @@ export class LoggerMiddleware implements NestMiddleware {
 
     if (havePermission) {
       request.body.info = {
-        customer_id: clienId,
+        customer_id: clientId,
         user_id: userId,
         customer,
+        customer_tier,
       };
-
       next();
     } else {
       throw new ForbiddenException();

src/modules/auth/auth.controller.ts

@@ -5,7 +5,6 @@ import {
   Post,
   HttpCode,
   HttpStatus,
-  UnauthorizedException,
 } from '@nestjs/common';
 import {
   AuthSignInRequest,
@@ -13,6 +12,10 @@ import {
   AuthEnableTotpMfaRequest,
   AuthDisableTotpMfaRequest,
   AuthVerifyTotpMfaRequest,
+  AuthChangePasswordRequest,
+  AuthResetPasswordRequest,
+  AuthVerifyResetPasswordCodeRequest,
+  AuthConfirmResetPasswordRequest,
 } from '@victorradael/protospack';
 
 import { AuthClientService } from 'src/clients/auth/client.service';
@@ -145,4 +148,80 @@ export class AuthController {
 
     return response;
   }
+
+  @Post('change-password')
+  @HttpCode(HttpStatus.OK)
+  async changePassword(
+    @Body() body: AuthChangePasswordRequest,
+    @Headers() headers,
+  ): Promise<any> {
+    console.log(`/auth`, 'change-password');
+
+    const { oldPassword, newPassword } = body;
+    const { authorization: accessToken } = headers;
+
+    const response = await this.authClient
+      .changePassword({
+        accessToken,
+        oldPassword,
+        newPassword,
+      })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('reset-password')
+  @HttpCode(HttpStatus.OK)
+  async resetPassword(@Body() body: AuthResetPasswordRequest): Promise<any> {
+    console.log(`/auth`, 'reset-password');
+
+    const { username } = body;
+
+    const response = await this.authClient
+      .resetPassword({ username })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('verify-reset-password-code')
+  @HttpCode(HttpStatus.OK)
+  async verifyResetPasswordCode(
+    @Body() body: AuthVerifyResetPasswordCodeRequest,
+  ): Promise<any> {
+    console.log(`/auth`, 'verify-reset-password-code');
+
+    const { username, code } = body;
+
+    const response = await this.authClient
+      .verifyResetPasswordCode({ username, code })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
+
+  @Post('confirm-reset-password')
+  @HttpCode(HttpStatus.OK)
+  async confirmResetPassword(
+    @Body() body: AuthConfirmResetPasswordRequest,
+  ): Promise<any> {
+    console.log(`/auth`, 'confirm-reset-password');
+
+    const { username, code, newPassword } = body;
+
+    const response = await this.authClient
+      .confirmResetPassword({ username, code, newPassword })
+      .catch((err) => {
+        throw ErrorBuilder(err);
+      });
+
+    return response;
+  }
 }

src/modules/inputs/inputs.service.ts

@@ -1,16 +1,52 @@
 import { Body, HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { Timeout } from '@nestjs/schedule';
+import CronParser, { CronExpression } from 'cron-parser';
 import { InputsClientService } from 'src/clients/inputs/client.service';
 import { IIdRequest, Info } from 'src/clients/inputs/interfaces';
 
 @Injectable()
 export class InputsService {
   constructor(private inputClient: InputsClientService) {}
+  secondsInADay = 60 * 60 * 24;
+  secondsInAnHour = 60 * 60;
 
   adjustInputPayload(payload) {
     return payload?.input_s3 || payload?.input_jdbc;
   }
+  getDifferenceInSeconds(date1: Date, date2: Date) {
+    const diffInMs = Math.abs(date2.getTime() - date1.getTime());
+    return diffInMs / 1000;
+  }
+  validateCron(data) {
+    const { info, cron } = data;
+    const { customer_tier } = info;
+    if (!cron) return;
+    let interval: CronExpression;
+    try {
+      interval = CronParser.parseExpression(cron);
+    } catch (error) {
+      throw new HttpException(
+        'Intervalo de tempo inválido',
+        HttpStatus.BAD_REQUEST,
+      );
+    }
+    const nextDate = interval.next().toDate();
+    const afterNextDate = interval.next().toDate();
+    const secondsApart = this.getDifferenceInSeconds(nextDate, afterNextDate);
+    if (customer_tier === 'BASIC' && secondsApart < this.secondsInADay) {
+      throw new HttpException(
+        'Intervalo de tempo não pode ser inferior a um dia.',
+        HttpStatus.FORBIDDEN,
+      );
+    } else if (secondsApart < this.secondsInAnHour) {
+      throw new HttpException(
+        'Intervalo de tempo não pode ser inferior a uma hora.',
+        HttpStatus.FORBIDDEN,
+      );
+    }
+  }
   async create(@Body() data) {
+    this.validateCron(data);
     try {
       if (
         data.plugin == 'csv' ||
@@ -65,6 +101,7 @@ export class InputsService {
   }
 
   async update(id: string, data, info: Info) {
+    this.validateCron({ ...data, info });
     try {
       const updateInputResponse: any = await this.inputClient.update({
         id,

src/utils/ErrorBuilder.ts

@@ -67,6 +67,30 @@ export default function ErrorBuilder(code: string) {
         code,
       });
 
+    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_EXPIRED:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não permitido',
+        message: 'Token para recuperar senha expirado',
+        code,
+      });
+
+    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_INVALID:
+      return Builder({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        error: 'Não permitido',
+        message: 'Token para recuperar senha inválido',
+        code,
+      });
+
+    case ErrorCodes.AUTH.WEAK_NEW_PASSWORD:
+      return Builder({
+        statusCode: HttpStatus.BAD_REQUEST,
+        error: 'Não permitido',
+        message: 'Senha muito fraca. Escolha uma senha mais forte',
+        code,
+      });
+
     case ErrorCodes.RATE_LIMIT:
       return Builder({
         statusCode: HttpStatus.TOO_MANY_REQUESTS,
@@ -93,6 +117,7 @@ export default function ErrorBuilder(code: string) {
         code,
       });
 
+    case ErrorCodes.INTERNAL:
     case ErrorCodes.UNKNOWN:
     default:
       return Builder({

src/utils/errorCodes.ts

@@ -1,4 +1,4 @@
-export const Auth = {
+export const AUTH = {
   UNAUTHORIZED: 'AUTH.UNAUTHORIZED',
   FORBIDDEN: 'AUTH.FORBIDDEN',
   WRONG_CREDENTIALS: 'AUTH.WRONG_CREDENTIALS',
@@ -9,12 +9,16 @@ export const Auth = {
   TOTP_REQUIRED: 'AUTH.TOTP_REQUIRED',
   CODE_MISMATCH: 'AUTH.CODE_MISMATCH',
   CODE_ALREADY_USED: 'AUTH.CODE_ALREADY_USED',
+  RESET_PASSWORD_CODE_EXPIRED: 'AUTH.RESET_PASSWORD_CODE_EXPIRED',
+  RESET_PASSWORD_CODE_INVALID: 'AUTH.RESET_PASSWORD_CODE_INVALID',
+  WEAK_NEW_PASSWORD: 'AUTH.WEAK_NEW_PASSWORD',
 };
 
 const ErrorCodes = {
   UNKNOWN: 'UNKNOWN',
   RATE_LIMIT: 'RATE_LIMIT',
-  AUTH: Auth,
+  INTERNAL: 'INTERNAL',
+  AUTH,
 };
 
 export default ErrorCodes;