Merge pull request #652 from credebl/develop-to-qa

merge: develop to qa

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

@@ -1570,7 +1570,7 @@ export class AgentServiceService {
         .then(async response => response);
       return schemaRequest;
     } catch (error) {
-      this.logger.error(`Error in schema endorsement request in agent service : ${JSON.stringify(error)}`);
+      this.logger.error(`Error in createW3CSchema request in agent service : ${JSON.stringify(error)}`);
     }
   }
 

apps/api-gateway/src/authz/guards/org-roles.guard.ts

@@ -84,7 +84,7 @@ export class OrgRolesGuard implements CanActivate {
       return false;
 
     } else {
-      throw new BadRequestException('organization is required');
+      throw new BadRequestException('Please provide valid orgId');
     }
 
     // Sending user friendly message if a user attempts to access an API that is inaccessible to their role

apps/api-gateway/src/dtos/create-schema.dto.ts

@@ -72,20 +72,44 @@ export class CreateSchemaDto {
 }
 
 export class CreateW3CSchemaDto {
-    @ApiProperty()
-    @IsNotEmpty({ message: 'schemaObject is required' })
-    schema: object;
+    @ApiProperty({
+        type: [],
+        'example': [
+            {
+                title: 'name',
+                type: 'string'
+            }
+        ]
+    })
+    @IsNotEmpty({ message: 'Schema attributes are required' })
+    schemaAttributes: SchemaAttributes [];
 
     @ApiProperty()
     @IsString({ message: 'schemaName must be a string' })
-    @Transform(({ value }) => trim(value))
+    @Transform(({ value }) => value.trim())
     @IsNotEmpty({ message: 'schemaName is required' })
     schemaName: string;
 
     @ApiProperty()
     @IsString({ message: 'did must be a string' })
-    @Transform(({ value }) => trim(value))
+    @Transform(({ value }) => value.trim())
     @IsNotEmpty({ message: 'did is required' })
     did: string;
-
+
+    @ApiProperty()
+    @IsString({ message: 'description must be a string' })
+    @IsNotEmpty({ message: 'description is required' })
+    description: string;
 }
+
+export class SchemaAttributes {
+    @ApiProperty()
+    @IsNotEmpty({ message: 'type is required' })
+    @IsString({ message: 'type must be a string' })
+    type: string;
+
+    @ApiProperty()
+    @IsNotEmpty({ message: 'title is required' })
+    @IsString({ message: 'title must be a string' })
+    title: string;
+}

apps/api-gateway/src/interfaces/ISchemaSearch.interface.ts

@@ -12,7 +12,12 @@ export interface ISchemaSearchPayload {
 
 
 export interface W3CSchemaPayload {
-    schema: object;
+    schemaAttributes: W3CSchemaAttributes [];
     schemaName: string;
     did: string;
  }
+
+ interface W3CSchemaAttributes {
+    type: string,
+    title: string
+ }

apps/ledger/src/schema/interfaces/schema-payload.interface.ts

@@ -72,11 +72,17 @@ export interface ISchemaExist {
    version: string;
 }
 
-interface SchemaPayload {
-    schema: object,
+export interface SchemaPayload {
+    schemaAttributes: W3CSchemaAttributes [],
     schemaName: string,
-    did: string
+    did: string,
+    description: string
   }
+
+  export interface W3CSchemaAttributes {
+    type: string,
+    title: string,
+ }
 
 export interface W3CSchemaPayload {
     schemaPayload: SchemaPayload,
@@ -86,5 +92,11 @@ export interface W3CSchemaPayload {
 export interface W3CCreateSchema {
     url: string,
     orgId: string,
-    schemaRequestPayload: SchemaPayload
+    schemaRequestPayload: object
 }  
+
+export interface IdAttribute extends W3CSchemaAttributes {
+    format: string;
+    order?: string
+}   
+

apps/ledger/src/schema/schema.controller.ts

@@ -27,7 +27,8 @@ export class SchemaController {
 
   @MessagePattern({ cmd: 'create-w3c-schema' })
   async createW3CSchema(payload: W3CSchemaPayload): Promise<object> {
-    return this.schemaService.createW3CSchema(payload);
+    const {orgId, schemaPayload} = payload;
+    return this.schemaService.createW3CSchema(orgId, schemaPayload);
   }
 
   @MessagePattern({ cmd: 'get-schema-by-id' })

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

@@ -11,7 +11,7 @@ import { ClientProxy, RpcException } from '@nestjs/microservices';
 import { BaseService } from 'libs/service/base.service';
 import { SchemaRepository } from './repositories/schema.repository';
 import { schema } from '@prisma/client';
-import { ISchema, ISchemaCredDeffSearchInterface, ISchemaExist, ISchemaPayload, ISchemaSearchCriteria, W3CCreateSchema, W3CSchemaPayload } from './interfaces/schema-payload.interface';
+import { ISchema, ISchemaCredDeffSearchInterface, ISchemaExist, ISchemaPayload, ISchemaSearchCriteria, SchemaPayload, W3CCreateSchema } from './interfaces/schema-payload.interface';
 import { ResponseMessages } from '@credebl/common/response-messages';
 import { IUserRequestInterface } from './interfaces/schema.interface';
 import { CreateSchemaAgentRedirection, GetSchemaAgentRedirection } from './schema.interface';
@@ -242,17 +242,15 @@ export class SchemaService extends BaseService {
     }
   }
 
-  async createW3CSchema(
-    schemaRequestPayload: W3CSchemaPayload
-  ): Promise<object> {
+  async createW3CSchema(orgId:string, schemaPayload: SchemaPayload): Promise<object> {
     try {
-      const { orgId } = schemaRequestPayload;
+      const { description, did, schemaAttributes, schemaName} = schemaPayload;
       const agentDetails = await this.schemaRepository.getAgentDetailsByOrgId(orgId);
       if (!agentDetails) {
-        throw new NotFoundException(
-          ResponseMessages.schema.error.agentDetailsNotFound,
-          { cause: new Error(), description: ResponseMessages.errorMessages.notFound }
-        );
+        throw new NotFoundException(ResponseMessages.schema.error.agentDetailsNotFound, {
+          cause: new Error(),
+          description: ResponseMessages.errorMessages.notFound
+        });
       }
       const { agentEndPoint } = agentDetails;
       const getAgentDetails = await this.schemaRepository.getAgentType(orgId);
@@ -264,21 +262,217 @@ export class SchemaService extends BaseService {
         const { tenantId } = await this.schemaRepository.getAgentDetailsByOrgId(orgId);
         url = `${agentEndPoint}${CommonConstants.SHARED_CREATE_POLYGON_W3C_SCHEMA}${tenantId}`;
       }
+
+      const schemaObject = await this.w3cSchemaBuilder(schemaAttributes, schemaName, description);
+
+      if (!schemaObject) {
+        throw new BadRequestException(ResponseMessages.schema.error.schemaBuilder, {
+          cause: new Error(),
+          description: ResponseMessages.errorMessages.badRequest
+        });
+      }
+      const agentSchemaPayload = {
+        schema:schemaObject,
+        did,
+        schemaName
+      };
+
       const W3cSchemaPayload = {
         url,
         orgId,
-        schemaRequestPayload: schemaRequestPayload.schemaPayload
+        schemaRequestPayload: agentSchemaPayload
       };
       return this._createW3CSchema(W3cSchemaPayload);
     } catch (error) {
-      this.logger.error(
-        `[createSchema] - outer Error: ${JSON.stringify(error)}`
-      );
+      this.logger.error(`[createSchema] - outer Error: ${JSON.stringify(error)}`);
       throw new RpcException(error.error ? error.error.message : error.message);
     }
   }
-
 
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  private async w3cSchemaBuilder(schemaAttributes, schemaName: string, description: string) {
+    const schemaAttributeJson = schemaAttributes.map((attribute, index) => ({
+      [attribute.title]: {
+        type: attribute.type.toLowerCase(),
+        order: index,
+        title: attribute.title
+      }
+    }));
+
+    // Add the format property to the id key
+    schemaAttributeJson.unshift({
+      id: {
+        type: 'string',
+        format: 'uri'
+      }
+    });
+
+    const nestedObject = {};
+    schemaAttributeJson.forEach((obj) => {
+      // eslint-disable-next-line prefer-destructuring
+      const key = Object.keys(obj)[0];
+      nestedObject[key] = obj[key];
+    });
+
+     const schemaNameObject = {}; 
+     schemaNameObject[schemaName] = {
+     "const": schemaName
+     };
+     const date = new Date().toISOString();
+
+    const W3CSchema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      $id: `${date}-${schemaName}`,
+      type: 'object',
+      required: ['@context', 'issuer', 'issuanceDate', 'type', 'credentialSubject'],
+      properties: {
+        '@context': {
+          $ref: '#/definitions/context'
+        },
+        type: {
+          type: 'array',
+          items: {
+            anyOf: [
+              {
+                $ref: '#/definitions/VerifiableCredential'
+              },
+              {
+                const: `#/definitions/$${schemaName}`
+              }
+            ]
+          }
+        },
+        credentialSubject: {
+          $ref: '#/definitions/credentialSubject'
+        },
+        id: {
+          type: 'string',
+          format: 'uri'
+        },
+        issuer: {
+          $ref: '#/definitions/uriOrId'
+        },
+        issuanceDate: {
+          type: 'string',
+          format: 'date-time'
+        },
+        expirationDate: {
+          type: 'string',
+          format: 'date-time'
+        },
+        credentialStatus: {
+          $ref: '#/definitions/credentialStatus'
+        },
+        credentialSchema: {
+          $ref: '#/definitions/credentialSchema'
+        }
+      },
+      definitions: {
+        context: {
+          type: 'array',
+          items: [
+            {
+              const: 'https://www.w3.org/2018/credentials/v1'
+            }
+          ],
+          additionalItems: {
+            oneOf: [
+              {
+                type: 'string',
+                format: 'uri'
+              },
+              {
+                type: 'object'
+              },
+              {
+                type: 'array',
+                items: {
+                  $ref: '#/definitions/context'
+                }
+              }
+            ]
+          },
+          minItems: 1,
+          uniqueItems: true
+        },
+        credentialSubject: {
+          type: 'object',
+          required: ['id'],
+          additionalProperties: false,
+          properties: nestedObject
+        },
+        VerifiableCredential: {
+          const: 'VerifiableCredential'
+        },
+        credentialSchema: {
+          oneOf: [
+            {
+              $ref: '#/definitions/idAndType'
+            },
+            {
+              type: 'array',
+              items: {
+                $ref: '#/definitions/idAndType'
+              },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        credentialStatus: {
+          oneOf: [
+            {
+              $ref: '#/definitions/idAndType'
+            },
+            {
+              type: 'array',
+              items: {
+                $ref: '#/definitions/idAndType'
+              },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        idAndType: {
+          type: 'object',
+          required: ['id', 'type'],
+          properties: {
+            id: {
+              type: 'string',
+              format: 'uri'
+            },
+            type: {
+              type: 'string'
+            }
+          }
+        },
+        uriOrId: {
+          oneOf: [
+            {
+              type: 'string',
+              format: 'uri'
+            },
+            {
+              type: 'object',
+              required: ['id'],
+              properties: {
+                id: {
+                  type: 'string',
+                  format: 'uri'
+                }
+              }
+            }
+          ]
+        },
+        ...schemaNameObject
+      },
+      title: schemaName,
+      description: `${description}`
+    };
+    return W3CSchema;
+  }
+
   async _createSchema(payload: CreateSchemaAgentRedirection): Promise<{
     response: string;
   }> {

apps/verification/src/verification.service.ts

@@ -489,7 +489,7 @@ export class VerificationService {
     this.emailData.emailFrom = platformConfigData.emailFrom;
     this.emailData.emailTo = email;
     this.emailData.emailSubject = `${process.env.PLATFORM_NAME} Platform: Verification of Your Credentials`;
-    this.emailData.emailHtml = await this.outOfBandVerification.outOfBandVerification(email, organizationDetails.name, outOfBandVerificationQrCode);
+    this.emailData.emailHtml = await this.outOfBandVerification.outOfBandVerification(email, organizationDetails.name, shortenedUrl);
     this.emailData.emailAttachments = [
       {
         filename: 'qrcode.png',