agent.consumer.service.ts

import {
  Injectable,
  Logger,
  OnModuleDestroy,
  OnModuleInit,
} from "@nestjs/common";
import { AgentService } from "../asker/agent.service";
import { ConsumerService } from "@ocm-engine/nats";
import { ConfigService } from "@nestjs/config";
import { IConfAgent } from "@ocm-engine/config";
import { GatewayClient } from "@ocm-engine/clients";
import {
  AcceptCredentialOfferRequestDto,
  AcceptProofRequestDto,
  CONNECTION_ACCEPT,
  CONNECTION_CREATE,
  CONNECTION_GET,
  CONNECTION_LIST,
  CreateCredentialDefinitionRequsetDto,
  CreateInvitationResponseDto,
  CreateSchemaRequestDto,
  CRED_DEF_CREATE,
  CRED_ISSUE,
  CRED_LIST,
  CRED_OFFER_ACCEPT,
  CRED_OFFER_LIST,
  GetConnectionRequestDto,
  GetSchemaRequestDto,
  IssueCredentialRequestDto,
  IssueProofRequestDto,
  PROOF_ACCEPT,
  PROOF_ISSUE,
  PROOF_LIST,
  SCHEMA_CREATE,
  SCHEMA_GET,
  SCHEMA_LIST,
} from "@ocm-engine/dtos";

@Injectable()
export class AgentConsumerService implements OnModuleInit, OnModuleDestroy {
  private readonly logger = new Logger(AgentConsumerService.name);
  constructor(
    private readonly agentService: AgentService,
    private readonly consumerService: ConsumerService,
    private readonly configService: ConfigService,
    private readonly gatewayClient: GatewayClient,
  ) {}

  async onModuleInit(): Promise<void> {
    const config = this.configService.get<IConfAgent>("agent");

    if (config?.agentIsRest) {
      this.logger.log(
        "Agent is configured as rest, there is no need for consumer!",
      );
      return;
    }

    await this.consumerService.subscribe(async (event) => {
      this.logger.debug(JSON.stringify(event, null, 2));
      let data;
      let dto;

      switch (event.type) {
        case CONNECTION_CREATE:
          data = await this.agentService.createInvitation();
          break;
        case CONNECTION_ACCEPT:
          dto = event.data as CreateInvitationResponseDto;
          data = await this.agentService.acceptInvitation(dto.invitationUrl);
          break;

        case CONNECTION_LIST:
          data = await this.agentService.fetchConnections();
          break;

        case CONNECTION_GET:
          dto = event.data as GetConnectionRequestDto;
          data = await this.agentService.getConnectionById(dto.connectionId);
          break;

        case SCHEMA_CREATE:
          dto = event.data as CreateSchemaRequestDto;
          data = await this.agentService.createSchema(dto);
          break;
        case SCHEMA_LIST:
          data = await this.agentService.fetchSchemas();
          break;

        case SCHEMA_GET:
          dto = event.data as GetSchemaRequestDto;
          data = await this.agentService.getSchemaById(dto.schemaId);
          break;
        case CRED_DEF_CREATE:
          data = await this.agentService.createCredentialDefinition(
            event.data as CreateCredentialDefinitionRequsetDto,
          );
          break;

        case CRED_ISSUE:
          data = await this.agentService.issueCredential(
            event.data as IssueCredentialRequestDto,
          );
          break;

        case CRED_LIST:
          data = await this.agentService.credentials();
          break;

        case CRED_OFFER_LIST:
          data = await this.agentService.credentialByStatedOfferReceived();
          break;

        case CRED_OFFER_ACCEPT:
          dto = event.data as AcceptCredentialOfferRequestDto;
          data = await this.agentService.acceptCredential(
            dto.credentialRecordId,
          );
          break;

        case PROOF_ISSUE:
          dto = event.data as IssueProofRequestDto;
          data = await this.agentService.issueProof(dto);
          break;

        case PROOF_LIST:
          data = await this.agentService.proofs();
          break;

        case PROOF_ACCEPT:
          dto = event.data as AcceptProofRequestDto;
          data = await this.agentService.acceptProof(dto.proofRecordId);
          break;
      }

      event.data = data;
      this.logger.debug(`before sending ${JSON.stringify(event, null, 2)}`);
      this.gatewayClient.sendPayload(event);

      return;
    });
  }

  async onModuleDestroy(): Promise<void> {
    this.logger.log("disconnecting from broker");
    await this.consumerService.disconnect();
  }
}