webhook

type Handler ¶

type Handler interface {
	Callback(context.Context, *Request) (*Reply, error)
}

func New(webhook *url.URL) Handler

type Mock ¶

type Mock struct {
	OnCallback func(context.Context, *Request) (*Reply, error)
	Callbacks  int
}

Mock implements the webhook Handler and is used for testing webhook interactions.

func (m *Mock) Callback(ctx context.Context, req *Request) (*Reply, error)

func (m *Mock) Reset()

func (m *Mock) UseError(err error)

func (m *Mock) UseFixture(path string) (err error)

func (m *Mock) UseReply(rep *Reply)

type Payload ¶

type Payload struct {
	Identity    *ivms101.IdentityPayload `json:"identity"`
	Pending     *generic.Pending         `json:"pending,omitempty"`
	Transaction *generic.Transaction     `json:"transaction,omitempty"`
	SentAt      string                   `json:"sent_at"`
	ReceivedAt  string                   `json:"received_at,omitempty"`
}

Payload is a denormalized representation of a TRISA payload that includes type-specific data structures. The payload should always have an identity IVMS101 payload and a sent at timestamp. It will have either a pending message or a transaction but not both. If payload is in an envelope with an accepted or completed transfer state it will have a received at timestamp as well.

func (p *Payload) IsZero() bool

func (p *Payload) Proto() (payload *trisa.Payload, err error)

type Reply ¶

type Reply struct {
	TransactionID  uuid.UUID    `json:"transaction_id"`
	Error          *trisa.Error `json:"error,omitempty"`
	Payload        *Payload     `json:"payload,omitempty"`
	TransferAction string       `json:"transfer_action,omitempty"`
}

Reply represents the expected response from the callback webhook to the Envoy node. Either an error or a pending message is returned in the common case, though Envoy will also handle synchronous compliance responses.

func MockErrorReply(_ context.Context, req *Request) (*Reply, error)

func MockPendingReply(_ context.Context, req *Request) (*Reply, error)

func (r *Reply) TransferState() trisa.TransferState

type Request ¶

type Request struct {
	TransactionID uuid.UUID         `json:"transaction_id"`
	Timestamp     string            `json:"timestamp"`
	Counterparty  *api.Counterparty `json:"counterparty"`
	HMAC          string            `json:"hmac_signature,omitempty"`
	PKS           string            `json:"public_key_signature,omitempty"`
	TransferState string            `json:"transfer_state,omitempty"`
	Error         *trisa.Error      `json:"error,omitempty"`
	Payload       *Payload          `json:"payload,omitempty"`
}

The Request object is sent to the webhook via a POST http call. The request represents an incoming message to the server as an unsealed, decrypted secure envelope (whether the request came from a TRISA or TRP remote client). The request is guaranteed to have a transaction ID, timestamp, and counterparty. If it has a payload, then it will also have an HMAC signature and public key signature. Requests will have either errors or payloads, but not both.

func (r *Request) AddPayload(payload *trisa.Payload) (err error)

type Webhook ¶

type Webhook struct {
	// contains filtered or unexported fields
}

Webhook implements the Handler to make POST requests to the webhook URL.

func (h *Webhook) Callback(ctx context.Context, out *Request) (in *Reply, err error)