merge: DEV to QA (27-08-2024)

apps/agent-service/src/agent-service.controller.ts

@@ -261,6 +261,11 @@ export class AgentServiceController {
     return this.agentServiceService.sendQuestion(payload.questionPayload, payload.url, payload.orgId);
   }
 
+  @MessagePattern({ cmd: 'agent-send-basic-message' })
+  async sendBasicMessage(payload: { url, orgId, content }): Promise<object> {
+    return this.agentServiceService.sendBasicMessage(payload.content, payload.url, payload.orgId);
+  }
+
   @MessagePattern({ cmd: 'agent-get-question-answer-record' })
   async getQuestionAnswersRecord(payload: { url: string, orgId: string }): Promise<object> {
     return this.agentServiceService.getQuestionAnswersRecord(payload.url, payload.orgId);

apps/agent-service/src/agent-service.service.ts

@@ -53,7 +53,8 @@ import {
   AgentHealthData,
   IAgentStore,
   IAgentConfigure,
-  OrgDid
+  OrgDid,
+  IBasicMessage
 } from './interface/agent-service.interface';
 import { AgentSpinUpStatus, AgentType, DidMethod, Ledgers, OrgAgentType, PromiseResult } from '@credebl/enum/enum';
 import { AgentServiceRepository } from './repositories/agent-service.repository';
@@ -1811,6 +1812,19 @@ export class AgentServiceService {
     }
   }
 
+  async sendBasicMessage(questionPayload: IBasicMessage, url: string, orgId: string): Promise<object> {
+    try {
+      const getApiKey = await this.getOrgAgentApiKey(orgId);
+      const sendQuestionRes = await this.commonService
+        .httpPost(url, questionPayload, { headers: { authorization: getApiKey } })
+        .then(async (response) => response);
+      return sendQuestionRes;
+    } catch (error) {
+      this.logger.error(`Error in sendBasicMessage in agent service : ${JSON.stringify(error)}`);
+      throw error;
+    }
+  }
+
   async getQuestionAnswersRecord(url: string, orgId: string): Promise<object> {
     try {
       const getQuestionAnswersRecord = await this.agentCall(url, orgId);

apps/agent-service/src/interface/agent-service.interface.ts

@@ -550,6 +550,9 @@ export interface IQuestionPayload {
   connectionId: string;
   tenantId: string;
 }
+export interface IBasicMessage {
+  content: string;
+}
 interface Ledger {
   id: string;
   createDateTime: string;

apps/api-gateway/src/cloud-wallet/cloud-wallet.controller.ts

@@ -507,7 +507,7 @@ export class CloudWalletController {
         * @returns Credential list
     */
     @Post('/basic-message/:connectionId')
-    @ApiOperation({ summary: 'Send basic message', description: 'Send basic message' })
+    @ApiOperation({ summary: 'send question', description: 'send question' })
     @ApiResponse({ status: HttpStatus.CREATED, description: 'Created', type: ApiResponseDto })
     @UseGuards(AuthGuard('jwt'), UserRoleGuard)
     async sendBasicMessage(

apps/api-gateway/src/connection/connection.controller.ts

@@ -20,7 +20,7 @@ import { ApiResponseDto } from '../dtos/apiResponse.dto';
 import { IConnectionSearchCriteria } from '../interfaces/IConnectionSearch.interface';
 import { SortFields } from 'apps/connection/src/enum/connection.enum';
 import { ClientProxy} from '@nestjs/microservices';
-import { QuestionAnswerWebhookDto, QuestionDto} from './dtos/question-answer.dto';
+import { BasicMessageDto, QuestionAnswerWebhookDto, QuestionDto} from './dtos/question-answer.dto';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { user } from '@prisma/client';
 @UseFilters(CustomExceptionFilter)
@@ -365,4 +365,29 @@ export class ConnectionController {
     };
     return res.status(HttpStatus.OK).json(finalResponse);
   }
+
+  @Post('/orgs/:orgId/basic-message/:connectionId')
+    @ApiOperation({ summary: '', description: 'send question' })
+    @UseGuards(AuthGuard('jwt'), OrgRolesGuard)
+    @Roles(OrgRoles.OWNER, OrgRoles.ADMIN, OrgRoles.ISSUER, OrgRoles.VERIFIER, OrgRoles.MEMBER, OrgRoles.HOLDER, OrgRoles.SUPER_ADMIN, OrgRoles.PLATFORM_ADMIN)
+    @ApiResponse({ status: HttpStatus.CREATED, description: 'Created', type: ApiResponseDto })
+    async sendBasicMessage(
+        @Param('orgId') orgId: string,
+        @Param('connectionId') connectionId: string,
+        @Body() basicMessageDto: BasicMessageDto,
+        @User() reqUser: IUserRequestInterface,
+        @Res() res: Response
+    ): Promise<Response> {
+
+        basicMessageDto.orgId = orgId;
+        basicMessageDto.connectionId = connectionId;
+        const basicMesgResponse = await this.connectionService.sendBasicMessage(basicMessageDto);
+        const finalResponse: IResponse = {
+            statusCode: HttpStatus.CREATED,
+            message: ResponseMessages.connection.success.basicMessage,
+            data: basicMesgResponse
+        };
+        return res.status(HttpStatus.CREATED).json(finalResponse);
+
+    }
 }

apps/api-gateway/src/connection/connection.service.ts

@@ -6,7 +6,7 @@ import { ConnectionDto, CreateOutOfBandConnectionInvitation, ReceiveInvitationDt
 import { IReceiveInvitationRes, IUserRequestInterface } from './interfaces';
 import { IConnectionList, IDeletedConnectionsRecord } from '@credebl/common/interfaces/connection.interface';
 import { AgentConnectionSearchCriteria, IConnectionDetailsById, IConnectionSearchCriteria } from '../interfaces/IConnectionSearch.interface';
-import { QuestionDto } from './dtos/question-answer.dto';
+import { BasicMessageDto, QuestionDto } from './dtos/question-answer.dto';
 import { user } from '@prisma/client';
 @Injectable()
 export class ConnectionService extends BaseService {
@@ -24,6 +24,16 @@ export class ConnectionService extends BaseService {
     }
   }
 
+  sendBasicMessage(
+    basicMessageDto: BasicMessageDto
+  ): Promise<object> {
+    try {
+      return this.sendNatsMessage(this.connectionServiceProxy, 'send-basic-message', basicMessageDto);
+    } catch (error) {
+      throw new RpcException(error.response);
+    }
+  }
+
   getConnectionWebhook(
     connectionDto: ConnectionDto,
     orgId: string

apps/api-gateway/src/connection/dtos/connection.dto.ts

@@ -41,6 +41,10 @@ export class CreateOutOfBandConnectionInvitation {
         @ApiPropertyOptional()
         @IsOptional()
         multiUseInvitation?: boolean;
+
+        @ApiPropertyOptional()
+        @IsOptional()
+        IsReuseConnection?: boolean;
 
         @ApiPropertyOptional()
         @IsOptional()
@@ -206,6 +210,14 @@ export class ConnectionDto {
     @ApiPropertyOptional()
     @IsOptional()
     orgId: string;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    outOfBandRecord?: object;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    reuseThreadId?: string;
 }
 
 class ReceiveInvitationCommonDto {

apps/api-gateway/src/connection/dtos/question-answer.dto.ts

@@ -35,6 +35,17 @@ export class QuestionDto {
     connectionId: string;
 }
 
+export class BasicMessageDto {
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString({ message: 'content must be a string' })
+    @IsNotEmpty({ message: 'please provide valid content' })
+    content: string;
+
+    orgId: string;
+    connectionId: string;
+}
+
 export class QuestionAnswerWebhookDto {
 
 

apps/connection/src/connection.controller.ts

@@ -13,7 +13,7 @@ import {
 } from './interfaces/connection.interfaces';
 import { IConnectionList, IDeletedConnectionsRecord } from '@credebl/common/interfaces/connection.interface';
 import { IConnectionDetailsById } from 'apps/api-gateway/src/interfaces/IConnectionSearch.interface';
-import { IQuestionPayload } from './interfaces/question-answer.interfaces';
+import { IQuestionPayload } from './interfaces/messaging.interfaces';
 import { user } from '@prisma/client';
 @Controller()
 export class ConnectionController {
@@ -101,4 +101,9 @@ export class ConnectionController {
     const { orgId, userDetails } = payload;
     return this.connectionService.deleteConnectionRecords(orgId, userDetails);
   }
+
+  @MessagePattern({ cmd: 'send-basic-message' })
+  async sendBasicMessage(payload: {content: string, orgId: string, connectionId: string}): Promise<object> {
+    return this.connectionService.sendBasicMesage(payload);
+  }
 }

apps/connection/src/connection.repository.ts

@@ -377,4 +377,21 @@ export class ConnectionRepository {
       throw error;
     }
   }
+
+   // eslint-disable-next-line camelcase
+   async getInvitationDidByOrgId(orgId: string): Promise<agent_invitations[]> {
+    try {
+      return this.prisma.agent_invitations.findMany({
+        where: {
+          orgId
+        },
+        orderBy: {
+          createDateTime: 'asc'
+        }
+      });
+    } catch (error) {
+      this.logger.error(`Error in getInvitationDid in connection repository: ${error.message}`);
+      throw error;
+    }
+  }
 }

apps/connection/src/connection.service.ts

@@ -23,9 +23,10 @@ import { Cache } from 'cache-manager';
 import { CACHE_MANAGER } from '@nestjs/cache-manager';
 import { IConnectionList, ICreateConnectionUrl, IDeletedConnectionsRecord } from '@credebl/common/interfaces/connection.interface';
 import { IConnectionDetailsById } from 'apps/api-gateway/src/interfaces/IConnectionSearch.interface';
-import { IQuestionPayload } from './interfaces/question-answer.interfaces';
+import { IBasicMessage, IQuestionPayload } from './interfaces/messaging.interfaces';
 import { RecordType, user } from '@prisma/client';
 import { UserActivityRepository } from 'libs/user-activity/repositories';
+import { agent_invitations } from '@prisma/client';
 @Injectable()
 export class ConnectionService {
   constructor(
@@ -635,7 +636,8 @@ export class ConnectionService {
         orgId,
         routing,
         recipientKey,
-        invitationDid
+        invitationDid,
+        IsReuseConnection
       } = payload?.createOutOfBandConnectionInvitation;
 
       const agentDetails = await this.connectionRepository.getAgentEndPoint(
@@ -647,6 +649,21 @@ export class ConnectionService {
       if (!agentDetails) {
         throw new NotFoundException(ResponseMessages.connection.error.agentEndPointNotFound);
       }
+
+      let legacyinvitationDid;
+      if (IsReuseConnection) {
+        const data: agent_invitations[] = await this.connectionRepository.getInvitationDidByOrgId(orgId);
+           if (data && 0 < data.length) {
+            const [firstElement] = data;
+            legacyinvitationDid = firstElement?.invitationDid ?? undefined;
+
+            this.logger.log('legacyinvitationDid:', legacyinvitationDid);
+        }
+      }
+      const connectionInvitationDid = invitationDid ? invitationDid : legacyinvitationDid;
+
+      this.logger.log('connectionInvitationDid:', connectionInvitationDid);
+
 
       this.logger.log(`logoUrl:::, ${organisation.logoUrl}`);
       const connectionPayload = {
@@ -663,7 +680,7 @@ export class ConnectionService {
         routing: routing || undefined,
         messages: messages || undefined,
         recipientKey: recipientKey || undefined,
-        invitationDid: invitationDid || undefined
+        invitationDid: connectionInvitationDid || undefined
       };
 
       const createConnectionInvitationFlag = 'connection-invitation';
@@ -824,5 +841,56 @@ export class ConnectionService {
         this.logger.error(`[deleteConnectionRecords] - error in deleting connection records: ${JSON.stringify(error)}`);
         throw new RpcException(error.response ? error.response : error);
     }
-}
+  }
+
+
+  async sendBasicMesage(payload: IBasicMessage): Promise<object> {
+    const { content, orgId, connectionId } = payload;
+    try {
+      const agentDetails = await this.connectionRepository.getAgentEndPoint(orgId);
+
+      const { agentEndPoint } = agentDetails;
+
+      if (!agentDetails) {
+        throw new NotFoundException(ResponseMessages.connection.error.agentEndPointNotFound);
+      }
+
+      const questionPayload = {
+        content
+      };
+
+      const organizationAgentType = await this.connectionRepository.getOrgAgentType(agentDetails?.orgAgentTypeId);
+      const label = 'send-basic-message';
+      const agentUrl = await this.commonService.sendBasicMessageAgentUrl(
+        label,
+        organizationAgentType,
+        agentEndPoint,
+        agentDetails?.tenantId,
+        connectionId
+      );
+
+      const sendBasicMessage = await this._sendBasicMessageToAgent(questionPayload, agentUrl, orgId);
+      return sendBasicMessage;
+    } catch (error) {
+      this.logger.error(`[sendBasicMesage] - error in send basic message: ${error}`);
+      if (error && error?.status && error?.status?.message && error?.status?.message?.error) {
+        throw new RpcException({
+          message: error?.status?.message?.error?.reason
+            ? error?.status?.message?.error?.reason
+            : error?.status?.message?.error,
+          statusCode: error?.status?.code
+        });
+      } else {
+        throw new RpcException(error.response ? error.response : error);
+      }
+    }
+  }
+
+  async _sendBasicMessageToAgent(content: IBasicMessage, url: string, orgId: string): Promise<object> {
+    const pattern = { cmd: 'agent-send-basic-message' };
+    const payload = { content, url, orgId };
+    // eslint-disable-next-line no-return-await
+    return await this.natsCall(pattern, payload);
+  }
+
 }

apps/connection/src/interfaces/connection.interfaces.ts

@@ -280,6 +280,7 @@ export interface ICreateConnectionInvitation {
   messages?: object[];
   multiUseInvitation?: boolean;
   autoAcceptConnection?: boolean;
+  IsReuseConnection?: boolean;
   routing?: object;
   appendedAttachments?: object[];
   orgId?: string;

apps/connection/src/interfaces/messaging.interfaces.ts

@@ -0,0 +1,19 @@
+export interface IValidResponses {
+  text: string;
+}
+
+export interface IQuestionPayload {
+  detail: string;
+  validResponses: IValidResponses[];
+  question: string;
+  orgId?: string;
+  connectionId?: string;
+  tenantId?: string;
+}
+
+export interface IBasicMessage {
+  content: string;
+  orgId?: string;
+  connectionId?: string;
+  tenantId?: string;
+}

apps/ledger/src/schema/schema.service.ts

@@ -5,9 +5,7 @@ import {
   Inject,
   ConflictException,
   Injectable,
-  NotAcceptableException, NotFoundException,
-  ForbiddenException
-} from '@nestjs/common';
+  NotAcceptableException, NotFoundException} from '@nestjs/common';
 import { ClientProxy, RpcException } from '@nestjs/microservices';
 import { BaseService } from 'libs/service/base.service';
 import { SchemaRepository } from './repositories/schema.repository';
@@ -664,10 +662,6 @@ export class SchemaService extends BaseService {
 
       const orgAgentType = await this.schemaRepository.getOrgAgentType(getAgentDetails.org_agents[0].orgAgentTypeId);
 
-      if (getSchemaDetails?.orgId !== orgId) {
-        throw new ForbiddenException(ResponseMessages.organisation.error.orgNotMatch);
-      }
-
       let schemaResponse;
       if (getSchemaDetails?.type === SchemaType.INDY) {
         if (OrgAgentType.DEDICATED === orgAgentType) {