[Reputation Oracle] NDA (#3132)

* add NDA module and related functionality

* refactor: rename nda_signed to nda_signed_url and update related logic

* [Human App] NDA (#3146)

* feat: add NDA module with service, controller, and related functionality

* feat: add HTTP status code to signNDA endpoint and update tests to use ndaServiceMock

* Move user within the signNDA tests as it is not being modified

* Clean user instance for each test

* Remove async from beforeEach

Co-authored-by: Dmitry Nechay <lelekkofe@gmail.com>

---------

Co-authored-by: portuu3 <61605646+portuu3@users.noreply.github.com>
Co-authored-by: Dmitry Nechay <lelekkofe@gmail.com>

Author: 3 people

packages/apps/human-app/server/src/app.module.ts

@@ -43,6 +43,8 @@ import { EnvironmentConfigService } from './common/config/environment-config.ser
 import { ForbidUnauthorizedHostMiddleware } from './common/middleware/host-check.middleware';
 import { HealthModule } from './modules/health/health.module';
 import { UiConfigurationModule } from './modules/ui-configuration/ui-configuration.module';
+import { NDAModule } from './modules/nda/nda.module';
+import { NDAController } from './modules/nda/nda.controller';
 
 const JOI_BOOLEAN_STRING_SCHEMA = Joi.string().valid('true', 'false');
 
@@ -125,6 +127,7 @@ const JOI_BOOLEAN_STRING_SCHEMA = Joi.string().valid('true', 'false');
     CronJobModule,
     HealthModule,
     UiConfigurationModule,
+    NDAModule,
   ],
   controllers: [
     AppController,
@@ -137,6 +140,7 @@ const JOI_BOOLEAN_STRING_SCHEMA = Joi.string().valid('true', 'false');
     HCaptchaController,
     RegisterAddressController,
     TokenRefreshController,
+    NDAController,
   ],
   exports: [HttpModule],
   providers: [EnvironmentConfigService],

packages/apps/human-app/server/src/common/config/gateway-config.service.ts

@@ -110,6 +110,16 @@ export class GatewayConfigService {
               method: HttpMethod.GET,
               headers: this.JSON_HEADER,
             },
+            [ReputationOracleEndpoints.GET_LATEST_NDA]: {
+              endpoint: '/nda/latest',
+              method: HttpMethod.GET,
+              headers: this.JSON_HEADER,
+            },
+            [ReputationOracleEndpoints.SIGN_NDA]: {
+              endpoint: '/nda/sign',
+              method: HttpMethod.POST,
+              headers: this.JSON_HEADER,
+            },
           } as Record<ReputationOracleEndpoints, GatewayEndpointConfig>,
         },
         [ExternalApiName.HCAPTCHA_LABELING_STATS]: {

packages/apps/human-app/server/src/common/enums/reputation-oracle-endpoints.ts

@@ -16,6 +16,8 @@ export enum ReputationOracleEndpoints {
   KYC_ON_CHAIN = 'kyc_on_chain',
   REGISTRATION_IN_EXCHANGE_ORACLE = 'registration_in_exchange_oracle',
   GET_REGISTRATION_IN_EXCHANGE_ORACLES = 'get_registration_in_exchange_oracles',
+  GET_LATEST_NDA = 'GET_LATEST_NDA',
+  SIGN_NDA = 'SIGN_NDA',
 }
 export enum HCaptchaLabelingStatsEndpoints {
   USER_STATS = 'user_stats',

packages/apps/human-app/server/src/integrations/reputation-oracle/reputation-oracle.gateway.ts

@@ -76,6 +76,13 @@ import {
   SigninOperatorData,
   SigninOperatorResponse,
 } from '../../modules/user-operator/model/operator-signin.model';
+import {
+  GetNDACommand,
+  GetNDAResponse,
+  SignNDACommand,
+  SignNDAData,
+  SignNDAResponse,
+} from '../../modules/nda/model/nda.model';
 
 @Injectable()
 export class ReputationOracleGateway {
@@ -329,6 +336,25 @@ export class ReputationOracleGateway {
     return this.handleRequestToReputationOracle<TokenRefreshResponse>(options);
   }
 
+  async getLatestNDA(command: GetNDACommand) {
+    const options = this.getEndpointOptions(
+      ReputationOracleEndpoints.GET_LATEST_NDA,
+      undefined,
+      command.token,
+    );
+    return this.handleRequestToReputationOracle<GetNDAResponse>(options);
+  }
+
+  async sendSignedNDA(command: SignNDACommand) {
+    const data = this.mapper.map(command, SignNDACommand, SignNDAData);
+    const options = this.getEndpointOptions(
+      ReputationOracleEndpoints.SIGN_NDA,
+      data,
+      command.token,
+    );
+    return this.handleRequestToReputationOracle<SignNDAResponse>(options);
+  }
+
   sendKycOnChain(token: string) {
     const options = this.getEndpointOptions(
       ReputationOracleEndpoints.KYC_ON_CHAIN,

packages/apps/human-app/server/src/integrations/reputation-oracle/reputation-oracle.mapper.profile.ts

@@ -57,6 +57,7 @@ import {
   SigninOperatorCommand,
   SigninOperatorData,
 } from '../../modules/user-operator/model/operator-signin.model';
+import { SignNDACommand, SignNDAData } from '../../modules/nda/model/nda.model';
 
 @Injectable()
 export class ReputationOracleProfile extends AutomapperProfile {
@@ -143,6 +144,15 @@ export class ReputationOracleProfile extends AutomapperProfile {
           destination: new SnakeCaseNamingConvention(),
         }),
       );
+      createMap(
+        mapper,
+        SignNDACommand,
+        SignNDAData,
+        namingConventions({
+          source: new CamelCaseNamingConvention(),
+          destination: new SnakeCaseNamingConvention(),
+        }),
+      );
     };
   }
 }

packages/apps/human-app/server/src/modules/nda/model/nda.model.ts

@@ -0,0 +1,34 @@
+import { AutoMap } from '@automapper/classes';
+import { IsString, IsUrl } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class GetNDACommand {
+  token: string;
+}
+
+export class GetNDAResponse {
+  url: string;
+}
+
+export class SignNDADto {
+  @AutoMap()
+  @IsUrl()
+  @IsString()
+  @ApiProperty({ example: 'string' })
+  url: string;
+}
+
+export class SignNDACommand {
+  @AutoMap()
+  url: string;
+  token: string;
+}
+
+export class SignNDAData {
+  @AutoMap()
+  url: string;
+}
+
+export class SignNDAResponse {
+  message: string;
+}

packages/apps/human-app/server/src/modules/nda/nda.controller.ts

@@ -0,0 +1,56 @@
+import { Mapper } from '@automapper/core';
+import { InjectMapper } from '@automapper/nestjs';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  Post,
+  UsePipes,
+  ValidationPipe,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Authorization } from '../../common/config/params-decorators';
+import { GetNDACommand, SignNDACommand, SignNDADto } from './model/nda.model';
+import { NDAService } from './nda.service';
+
+@Controller('/nda')
+@ApiTags('NDA')
+@UsePipes(new ValidationPipe())
+@ApiBearerAuth()
+export class NDAController {
+  @InjectMapper() private readonly mapper: Mapper;
+
+  constructor(
+    private readonly ndaService: NDAService,
+    @InjectMapper() mapper: Mapper,
+  ) {
+    this.mapper = mapper;
+  }
+
+  @ApiOperation({
+    summary: 'Retrieves latest NDA URL',
+    description:
+      'Retrieves the latest NDA URL that users must sign to join the oracle',
+  })
+  @Get('/')
+  async getLatestNDA(@Authorization() token: string) {
+    const command = new GetNDACommand();
+    command.token = token;
+    return this.ndaService.getLatestNDA(command);
+  }
+
+  @ApiOperation({
+    summary: 'Sign NDA',
+    description:
+      'Signs the NDA with the provided URL. The URL must match the latest NDA URL.',
+  })
+  @HttpCode(200)
+  @Post('sign')
+  async signNDA(@Body() dto: SignNDADto, @Authorization() token: string) {
+    const command = this.mapper.map(dto, SignNDADto, SignNDACommand);
+    command.token = token;
+    await this.ndaService.signNDA(command);
+    return { message: 'NDA signed successfully' };
+  }
+}

packages/apps/human-app/server/src/modules/nda/nda.mapper.profile.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CamelCaseNamingConvention,
+  createMap,
+  Mapper,
+  namingConventions,
+  SnakeCaseNamingConvention,
+} from '@automapper/core';
+import { AutomapperProfile, InjectMapper } from '@automapper/nestjs';
+import { SignNDACommand, SignNDADto } from './model/nda.model';
+
+@Injectable()
+export class SignNDAProfile extends AutomapperProfile {
+  constructor(@InjectMapper() mapper: Mapper) {
+    super(mapper);
+  }
+
+  override get profile() {
+    return (mapper: Mapper) => {
+      createMap(
+        mapper,
+        SignNDADto,
+        SignNDACommand,
+        namingConventions({
+          source: new SnakeCaseNamingConvention(),
+          destination: new CamelCaseNamingConvention(),
+        }),
+      );
+    };
+  }
+}

packages/apps/human-app/server/src/modules/nda/nda.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { NDAService } from 'src/modules/nda/nda.service';
+import { ReputationOracleModule } from '../../integrations/reputation-oracle/reputation-oracle.module';
+import { SignNDAProfile } from './nda.mapper.profile';
+
+@Module({
+  imports: [ReputationOracleModule],
+  providers: [NDAService, SignNDAProfile],
+  exports: [NDAService],
+})
+export class NDAModule {}

packages/apps/human-app/server/src/modules/nda/nda.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { ReputationOracleGateway } from '../../integrations/reputation-oracle/reputation-oracle.gateway';
+import {
+  GetNDACommand,
+  GetNDAResponse,
+  SignNDACommand,
+  SignNDAResponse,
+} from './model/nda.model';
+
+@Injectable()
+export class NDAService {
+  constructor(private readonly gateway: ReputationOracleGateway) {}
+
+  async getLatestNDA(command: GetNDACommand): Promise<GetNDAResponse> {
+    return this.gateway.getLatestNDA(command);
+  }
+
+  async signNDA(command: SignNDACommand): Promise<SignNDAResponse> {
+    return await this.gateway.sendSignedNDA(command);
+  }
+}