merge: DEV to QA

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

@@ -1812,13 +1812,13 @@ export class AgentServiceService {
     }
   }
 
-  async sendBasicMessage(questionPayload: IBasicMessage, url: string, orgId: string): Promise<object> {
+  async sendBasicMessage(messagePayload: 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 } })
+      const basicMessageRes = await this.commonService
+        .httpPost(url, messagePayload, { headers: { authorization: getApiKey } })
         .then(async (response) => response);
-      return sendQuestionRes;
+      return basicMessageRes;
     } catch (error) {
       this.logger.error(`Error in sendBasicMessage in agent service : ${JSON.stringify(error)}`);
       throw error;

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

@@ -367,7 +367,7 @@ export class ConnectionController {
   }
 
   @Post('/orgs/:orgId/basic-message/:connectionId')
-    @ApiOperation({ summary: '', description: 'send question' })
+    @ApiOperation({ summary: 'Send basic message', description: 'Send basic message' })
     @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 })

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

@@ -28,7 +28,7 @@ export class ConnectionService extends BaseService {
     basicMessageDto: BasicMessageDto
   ): Promise<object> {
     try {
-      return this.sendNatsMessage(this.connectionServiceProxy, 'send-basic-message', basicMessageDto);
+      return this.sendNatsMessage(this.connectionServiceProxy, 'send-basic-message-on-connection', basicMessageDto);
     } catch (error) {
       throw new RpcException(error.response);
     }

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

@@ -464,6 +464,12 @@ export class OOBCredentialDtoWithEmail {
   @IsOptional()
   credentialType: IssueCredentialType;
 
+  @ApiPropertyOptional({ default: true })
+  @IsOptional()
+  @IsNotEmpty({ message: 'please provide valid value for isReuseConnection' })
+  @IsBoolean({ message: 'isReuseConnection must be a boolean' })
+  isReuseConnection?: boolean;
+
   imageUrl?: string;
 
   orgId: string;

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

@@ -633,9 +633,9 @@ async downloadBulkIssuanceCSVTemplate(
   async outOfBandCredentialOffer(
     @User() user: IUserRequest,
     @Body() outOfBandCredentialDto: OOBCredentialDtoWithEmail,
-    @Query('credentialType') credentialType: IssueCredentialType = IssueCredentialType.INDY,
     @Param('orgId') orgId: string,
-    @Res() res: Response
+    @Res() res: Response,
+    @Query('credentialType') credentialType: IssueCredentialType = IssueCredentialType.INDY
   ): Promise<Response> {
     outOfBandCredentialDto.orgId = orgId;
     outOfBandCredentialDto.credentialType = credentialType;

apps/connection/src/connection.controller.ts

@@ -102,7 +102,7 @@ export class ConnectionController {
     return this.connectionService.deleteConnectionRecords(orgId, userDetails);
   }
 
-  @MessagePattern({ cmd: 'send-basic-message' })
+  @MessagePattern({ cmd: 'send-basic-message-on-connection' })
   async sendBasicMessage(payload: {content: string, orgId: string, connectionId: string}): Promise<object> {
     return this.connectionService.sendBasicMesage(payload);
   }

apps/issuance/interfaces/issuance.interfaces.ts

@@ -170,6 +170,7 @@ export interface OutOfBandCredentialOfferPayload {
   emailId?: string;
   attributes?: IAttributes[];
   protocolVersion?: string;
+  isReuseConnection?: boolean;
   goalCode?: string,
   parentThreadId?: string,
   willConfirm?: boolean,
@@ -282,6 +283,7 @@ export interface SendEmailCredentialOffer {
   index: number;
   credentialType: IssueCredentialType; 
   protocolVersion: string;
+  isReuseConnection?: boolean;
   attributes: IAttributes[]; 
   credentialDefinitionId: string; 
   outOfBandCredential: OutOfBandCredentialOfferPayload;
@@ -341,6 +343,7 @@ export interface IQueuePayload{
   certificate?: string;
   size?: string;
   orientation?: string;
+  isReuseConnection?: boolean;
 }
 
 interface FileDetails {

apps/issuance/src/issuance.service.ts

@@ -557,7 +557,8 @@ async outOfBandCredentialOffer(outOfBandCredential: OutOfBandCredentialOfferPayl
       protocolVersion,
       attributes,
       emailId,
-      credentialType
+      credentialType,
+      isReuseConnection
     } = outOfBandCredential;
 
     if (IssueCredentialType.JSONLD === credentialType) {
@@ -637,6 +638,7 @@ async outOfBandCredentialOffer(outOfBandCredential: OutOfBandCredentialOfferPayl
       index: number;
       credentialType: IssueCredentialType;
       protocolVersion: string;
+      isReuseConnection?: boolean;
       attributes: IAttributes[];
       credentialDefinitionId: string;
       outOfBandCredential: OutOfBandCredentialOfferPayload;
@@ -652,6 +654,7 @@ async outOfBandCredentialOffer(outOfBandCredential: OutOfBandCredentialOfferPayl
     } = {
       credentialType,
       protocolVersion,
+      isReuseConnection,
       attributes,
       credentialDefinitionId,
       outOfBandCredential,
@@ -735,12 +738,22 @@ async sendEmailForCredentialOffer(sendEmailCredentialOffer: SendEmailCredentialO
     orgId,
     organizationDetails,
     platformName,
-    organizationLogoUrl
+    organizationLogoUrl,
+    isReuseConnection
   } = sendEmailCredentialOffer;
   const iterationNo = index + 1;
   try {
 
 
+    let invitationDid: string | undefined;
+    if (true === isReuseConnection) {
+      const data: agent_invitations[] = await this.issuanceRepository.getInvitationDidByOrgId(orgId);
+       if (data && 0 < data.length) {
+        const [firstElement] = data;
+        invitationDid = firstElement?.invitationDid ?? undefined;
+    }
+    }
+
     let outOfBandIssuancePayload;
     if (IssueCredentialType.INDY === credentialType) {
 
@@ -759,7 +772,8 @@ async sendEmailForCredentialOffer(sendEmailCredentialOffer: SendEmailCredentialO
         parentThreadId: outOfBandCredential.parentThreadId || undefined,
         willConfirm: outOfBandCredential.willConfirm || undefined,
         label: organisation?.name,
-        imageUrl: organisation?.logoUrl || outOfBandCredential?.imageUrl
+        imageUrl: organisation?.logoUrl || outOfBandCredential?.imageUrl,
+        invitationDid: invitationDid || undefined
       };
     }
 
@@ -779,7 +793,8 @@ async sendEmailForCredentialOffer(sendEmailCredentialOffer: SendEmailCredentialO
         parentThreadId: outOfBandCredential.parentThreadId || undefined,
         willConfirm: outOfBandCredential.willConfirm || undefined,
         label: organisation?.name,
-        imageUrl: organisation?.logoUrl || outOfBandCredential?.imageUrl
+        imageUrl: organisation?.logoUrl || outOfBandCredential?.imageUrl,
+        invitationDid: invitationDid || undefined
       };
 
       const payloadAttributes = outOfBandIssuancePayload?.credentialFormats?.jsonld?.credential?.credentialSubject;
@@ -1519,7 +1534,6 @@ return newCacheKey;
     const { orgId } = jobDetails;
 
     const agentDetails = await this.issuanceRepository.getAgentEndPoint(orgId);
-
     const { organisation, orgDid } = agentDetails;
     let prettyVc;
     let isErrorOccurred = false;
@@ -1532,7 +1546,8 @@ return newCacheKey;
           label: organisation?.name,
           attributes: [],
           emailId: jobDetails?.credential_data?.email_identifier,
-          credentialType: IssueCredentialType.INDY
+          credentialType: IssueCredentialType.INDY,
+          isReuseConnection: true
         };
         for (const key in jobDetails?.credential_data) {
 
@@ -1549,8 +1564,8 @@ return newCacheKey;
         schemaLedgerId,
         credentialData: jobDetails.credential_data,
         orgDid,
-        orgId
-
+        orgId,
+        isReuseConnection: true
       };
 
       prettyVc = {
@@ -1561,6 +1576,7 @@ return newCacheKey;
 
       oobIssuancepayload = await createOobJsonldIssuancePayload(JsonldCredentialDetails, prettyVc);
       }
+
       const oobCredentials = await this.outOfBandCredentialOffer(
         oobIssuancepayload, jobDetails?.platformName, jobDetails?.organizationLogoUrl, prettyVc);
       if (oobCredentials) {

apps/verification/src/verification.service.ts

@@ -784,6 +784,12 @@ export class VerificationService {
 
           const verifiableCredential = verifiableCredentials[index]?.credentialSubject;
 
+          if (getProofPresentationById?.response) {
+            certificate =
+              getProofPresentationById?.response?.presentation?.presentationExchange?.verifiableCredential[0].prettyVc
+                ?.certificate;
+          }
+
           if (
             requestedAttributesForPresentationExchangeFormat &&
             Array.isArray(requestedAttributesForPresentationExchangeFormat)

libs/common/src/cast.helper.ts

@@ -302,7 +302,7 @@ export const validateEmail = (email: string): boolean => {
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/explicit-function-return-type
 export const createOobJsonldIssuancePayload = (JsonldCredentialDetails: IJsonldCredential, prettyVc: IPrettyVc) => {
-  const {credentialData, orgDid, orgId, schemaLedgerId, schemaName} = JsonldCredentialDetails;
+  const {credentialData, orgDid, orgId, schemaLedgerId, schemaName, isReuseConnection} = JsonldCredentialDetails;
   const credentialSubject = { };
 
   const proofType = (orgDid?.includes(DidMethod.POLYGON)) ? ProofType.POLYGON_PROOFTYPE : ProofType.NO_LEDGER_PROOFTYPE;
@@ -339,7 +339,8 @@ export const createOobJsonldIssuancePayload = (JsonldCredentialDetails: IJsonldC
     'comment': 'string',
     'protocolVersion': 'v2',
     'credentialType': 'jsonld',
-    orgId
+    orgId,
+    isReuseConnection
   };
 };
 

libs/common/src/interfaces/issuance.interface.ts

@@ -26,6 +26,7 @@ export interface IIssuedCredential {
     credentialData: CredentialData
     orgDid: string;
     orgId: string;
+    isReuseConnection?: boolean;
   }
 
   export interface ICredentialOfferResponse {

libs/prisma-service/prisma/data/credebl-master-table.json

@@ -137,12 +137,12 @@
     },
     {
       "name": "NA",
-      "networkType": "",
-      "poolConfig": "",
+      "networkType": "NA",
+      "poolConfig": "NA",
       "isActive": true,
-      "networkString": "",
-      "nymTxnEndpoint": "",
-      "indyNamespace": ""
+      "networkString": "NA",
+      "nymTxnEndpoint": "NA",
+      "indyNamespace": "no_ledger"
     }
   ],
   "endorseData": [

libs/prisma-service/prisma/seed.ts

@@ -374,6 +374,81 @@ const createUserRole = async (): Promise<void> => {
     }
 };
 
+const migrateOrgAgentDids = async (): Promise<void> => {
+    try {
+        const orgAgents = await prisma.org_agents.findMany({
+            where: {
+                walletName: {
+                    not: 'platform-admin'
+                }
+            }
+        });
+
+        const orgDids = orgAgents.map((agent) => agent.orgDid).filter((did) => null !== did && '' !== did);
+        const existingDids = await prisma.org_dids.findMany({
+            where: {
+                did: {
+                    in: orgDids
+                }
+            }
+        });
+
+        // If there are org DIDs that do not exist in org_dids table
+        if (orgDids.length !== existingDids.length) {
+            const newOrgAgents = orgAgents.filter(
+                (agent) => !existingDids.some((did) => did.did === agent.orgDid)
+            );
+
+            const newDidRecords = newOrgAgents.map((agent) => ({
+                orgId: agent.orgId,
+                did: agent.orgDid,
+                didDocument: agent.didDocument,
+                isPrimaryDid: true,
+                createdBy: agent.createdBy,
+                lastChangedBy: agent.lastChangedBy,
+                orgAgentId: agent.id
+            }));
+
+            const didInsertResult = await prisma.org_dids.createMany({
+                data: newDidRecords
+            });
+
+            logger.log(didInsertResult);
+        } else {
+            logger.log('No new DIDs to migrate in migrateOrgAgentDids');
+        }
+    } catch (error) {
+        logger.error('An error occurred during migrateOrgAgentDids:', error);
+    }
+};
+
+const addSchemaType = async (): Promise<void> => {
+    try {
+        const emptyTypeSchemaList = await prisma.schema.findMany({
+            where: {
+              OR: [
+                { type: null },
+                { type: '' }
+              ]
+            }
+        });
+        if (0 < emptyTypeSchemaList.length) {
+            const updatePromises = emptyTypeSchemaList.map((schema) => prisma.schema.update({
+                    where: { id: schema.id },
+                    data: { type: 'indy' }
+                })
+            );
+           await Promise.all(updatePromises);
+
+            logger.log('Schemas updated successfully');
+        } else {
+            logger.log('No schemas to update');
+        }
+    } catch (error) {
+        logger.error('An error occurred during addSchemaType:', error);
+    }
+};
+
 async function main(): Promise<void> {
 
     await createPlatformConfig();
@@ -388,9 +463,10 @@ async function main(): Promise<void> {
     await createEcosystemConfig();
     await createLedgerConfig();
     await createUserRole();
+    await migrateOrgAgentDids();
+    await addSchemaType();
 }
 
-
 main()
     .then(async () => {
         await prisma.$disconnect();