api_present_proof_service.go

/*
 * Aries Agent Test Harness Backchannel API
 *
 * This page documents the backchannel API the test harness uses to communicate with agents under tests.  For more information checkout the [Aries Interoperability Information](http://aries-interop.info) page.
 *
 * API version: 1.0.0
 * Generated by: OpenAPI Generator (https://openapi-generator.tech)
 */

package openapi

import (
	"context"
	"log"
	"net/http"

	"github.com/findy-network/findy-agent-backchannel/agent"
)

func getProofStatus(verifier bool, state agent.PresentProofState) PresentProofState {
	res := PRESENT_PROOF_DONE
	switch state {
	case agent.StateProofProposal:
		res = PRESENT_PROOF_PROPOSAL_RECEIVED
		if !verifier {
			res = PRESENT_PROOF_PROPOSAL_SENT
		}
	case agent.StateProofRequest:
		res = PRESENT_PROOF_REQUEST_SENT
		if !verifier {
			res = PRESENT_PROOF_REQUEST_RECEIVED
		}
	case agent.StateProofPresentation:
		res = PRESENT_PROOF_PRESENTATION_RECEIVED
		if !verifier {
			res = PRESENT_PROOF_PRESENTATION_SENT
		}
	case agent.StateProofDone:
		res = PRESENT_PROOF_DONE
	}
	return res
}

// PresentProofApiService is a service that implements the logic for the PresentProofApiServicer
// This service should implement the business logic for every endpoint for the PresentProofApi API.
// Include any external packages or services that will be required by this service.
type PresentProofApiService struct {
	a *agent.Agent
}

// NewPresentProofApiService creates a default api service
func NewPresentProofApiService(a *agent.Agent) PresentProofApiServicer {
	return &PresentProofApiService{a: a}
}

// PresentProofGetByThreadId - Get presentation exchange record by thread id
func (s *PresentProofApiService) PresentProofGetByThreadId(ctx context.Context, presentationExchangeThreadId string) (ImplResponse, error) {
	verifier, state, err := s.a.GetProof(presentationExchangeThreadId)
	if err != nil {
		return Response(http.StatusNotFound, nil), err
	}

	res := getProofStatus(verifier, state)
	log.Println("PresentProofGetByThreadId Proof status ", res, presentationExchangeThreadId)

	return Response(200, PresentProofOperationResponse{
		State:    res,
		ThreadId: presentationExchangeThreadId,
	}), nil

}

// PresentProofSendPresentation - Send presentation
func (s *PresentProofApiService) PresentProofSendPresentation(ctx context.Context, presentProofSendPresentationRequest PresentProofSendPresentationRequest) (ImplResponse, error) {

	threadId, err := s.a.SendProofPresentation(presentProofSendPresentationRequest.Id)
	if err == nil {
		return Response(200, PresentProofOperationResponse{State: PRESENT_PROOF_PRESENTATION_SENT, ThreadId: threadId}), nil
	}

	return Response(http.StatusInternalServerError, nil), err
}

// PresentProofSendProposal - Send presentation proposal
func (s *PresentProofApiService) PresentProofSendProposal(ctx context.Context, presentProofSendProposalRequest PresentProofSendProposalRequest) (ImplResponse, error) {
	connectionID := presentProofSendProposalRequest.Data.ConnectionId
	proposalAttributes := presentProofSendProposalRequest.Data.PresentationProposal.Attributes
	attributes := make([]*agent.ProofAttribute, 0)
	for _, attr := range proposalAttributes {
		attributes = append(attributes, &agent.ProofAttribute{
			Name:      attr.Name,
			CredDefID: attr.CredDefId,
		})
	}

	threadId, err := s.a.ProposeProof(connectionID, attributes)
	if err == nil {
		return Response(200, PresentProofOperationResponse{State: PRESENT_PROOF_PROPOSAL_SENT, ThreadId: threadId}), nil
	}

	return Response(http.StatusInternalServerError, nil), err
}

// PresentProofSendRequest - Send presentation request
func (s *PresentProofApiService) PresentProofSendRequest(ctx context.Context, presentProofSendRequestRequest PresentProofSendRequestRequest) (r ImplResponse, err error) {
	connectionID := presentProofSendRequestRequest.Data.ConnectionId
	proposalAttributes := presentProofSendRequestRequest.Data.PresentationRequest.ProofRequest.Data.RequestedAttributes
	attributes := make([]*agent.ProofAttribute, 0)
	for key, value := range proposalAttributes {
		if value.Name != "" {
			attributes = append(attributes, &agent.ProofAttribute{
				Name: value.Name,
				ID:   key,
			})
		} else {
			for _, name := range value.Names {
				attributes = append(attributes, &agent.ProofAttribute{
					Name: name,
					ID:   key,
				})
			}
		}
	}

	proposalPredicates := presentProofSendRequestRequest.Data.PresentationRequest.ProofRequest.Data.RequestedPredicates
	predicates := make([]*agent.ProofPredicate, 0)
	for key, value := range proposalPredicates {
		valueMap := value.(map[string]interface{})
		predicates = append(predicates, &agent.ProofPredicate{
			ID:     key,
			Name:   valueMap["name"].(string),
			PType:  valueMap["p_type"].(string),
			PValue: int64(valueMap["p_value"].(float64)), // TODO: check does indy support float or int
		})
	}

	threadId, err := s.a.RequestProof(connectionID, attributes, predicates)
	if err == nil {
		return Response(200, PresentProofOperationResponse{State: PRESENT_PROOF_REQUEST_SENT, ThreadId: threadId}), nil
	}

	return Response(http.StatusInternalServerError, nil), err
}

// PresentProofVerifyPresentation - Verify presentation
func (s *PresentProofApiService) PresentProofVerifyPresentation(ctx context.Context, presentProofVerifyPresentationRequest PresentProofVerifyPresentationRequest) (ImplResponse, error) {

	err := s.a.VerifyPresentation(presentProofVerifyPresentationRequest.Id)
	if err != nil {
		return Response(http.StatusInternalServerError, nil), err
	}

	verifier, state, err := s.a.GetProof(presentProofVerifyPresentationRequest.Id)
	if err != nil {
		return Response(http.StatusNotFound, nil), err
	}

	res := getProofStatus(verifier, state)
	log.Println("PresentProofVerifyPresentation Proof status ", res, presentProofVerifyPresentationRequest.Id)

	return Response(200, PresentProofOperationResponse{
		State:    res,
		ThreadId: presentProofVerifyPresentationRequest.Id,
	}), nil
}