feat(gl): expose ledger application and grpc operations
This commit is contained in:
@@ -0,0 +1,408 @@
|
||||
package grpcadapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
applicationledger "gl/application/ledger"
|
||||
domain "gl/domain/ledger"
|
||||
ledgerv1 "gl/gen/ledger/v1"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
"google.golang.org/protobuf/types/known/timestamppb"
|
||||
)
|
||||
|
||||
func (h *Handler) AppendJournal(ctx context.Context, request *ledgerv1.AppendJournalRequest) (*ledgerv1.AppendJournalResponse, error) {
|
||||
command, err := appendJournalCommand(request)
|
||||
if err != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
result, err := h.ledger.AppendJournal(ctx, command)
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
return &ledgerv1.AppendJournalResponse{
|
||||
Journal: journalMessage(result.Journal),
|
||||
AlreadyExisted: result.AlreadyExisted,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *Handler) AppendTransactionEvent(ctx context.Context, request *ledgerv1.AppendTransactionEventRequest) (*ledgerv1.AppendTransactionEventResponse, error) {
|
||||
occurredAt, err := requiredTime(request.GetOccurredAt(), "occurred_at")
|
||||
if err != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
event, alreadyExisted, err := h.ledger.AppendEvent(ctx, applicationledger.AppendEventCommand{
|
||||
SourceService: request.GetSourceService(),
|
||||
IdempotencyKey: request.GetIdempotencyKey(),
|
||||
SourceTransactionID: request.GetSourceTransactionId(),
|
||||
TrackingCode: request.GetTrackingCode(),
|
||||
EventVersion: request.GetEventVersion(),
|
||||
State: transactionState(request.GetState()),
|
||||
ErrorCode: request.GetErrorCode(),
|
||||
ErrorMessage: request.GetErrorMessage(),
|
||||
OccurredAt: occurredAt,
|
||||
CorrelationID: request.GetCorrelationId(),
|
||||
ActorID: request.GetActorId(),
|
||||
Blockchain: blockchainReference(request.GetBlockchain()),
|
||||
Metadata: request.GetMetadata(),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
return &ledgerv1.AppendTransactionEventResponse{
|
||||
Event: eventMessage(event),
|
||||
AlreadyExisted: alreadyExisted,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *Handler) GetJournal(ctx context.Context, request *ledgerv1.GetJournalRequest) (*ledgerv1.Journal, error) {
|
||||
var journalID, idempotencyKey string
|
||||
switch lookup := request.GetLookup().(type) {
|
||||
case *ledgerv1.GetJournalRequest_JournalId:
|
||||
journalID = lookup.JournalId
|
||||
case *ledgerv1.GetJournalRequest_IdempotencyKey:
|
||||
idempotencyKey = lookup.IdempotencyKey
|
||||
}
|
||||
journal, err := h.ledger.GetJournal(ctx, journalID, idempotencyKey)
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
return journalMessage(journal), nil
|
||||
}
|
||||
|
||||
func (h *Handler) ListEntries(ctx context.Context, request *ledgerv1.ListEntriesRequest) (*ledgerv1.ListEntriesResponse, error) {
|
||||
command := applicationledger.ListCommand{
|
||||
PageSize: request.GetPageSize(),
|
||||
PageToken: request.GetPageToken(),
|
||||
}
|
||||
if request.Account != nil {
|
||||
account := accountReference(request.Account)
|
||||
command.Account = &account
|
||||
}
|
||||
if request.AssetId != nil {
|
||||
assetID := request.GetAssetId()
|
||||
command.AssetID = &assetID
|
||||
}
|
||||
var err error
|
||||
if request.RecordedFrom != nil {
|
||||
value, parseErr := requiredTime(request.RecordedFrom, "recorded_from")
|
||||
if parseErr != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, parseErr.Error())
|
||||
}
|
||||
command.RecordedFrom = &value
|
||||
}
|
||||
if request.RecordedTo != nil {
|
||||
value, parseErr := requiredTime(request.RecordedTo, "recorded_to")
|
||||
if parseErr != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, parseErr.Error())
|
||||
}
|
||||
command.RecordedTo = &value
|
||||
}
|
||||
journals, nextPageToken, err := h.ledger.List(ctx, command)
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
response := &ledgerv1.ListEntriesResponse{
|
||||
Journals: make([]*ledgerv1.Journal, 0, len(journals)),
|
||||
NextPageToken: nextPageToken,
|
||||
}
|
||||
for _, journal := range journals {
|
||||
response.Journals = append(response.Journals, journalMessage(journal))
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (h *Handler) GetBalance(ctx context.Context, request *ledgerv1.GetBalanceRequest) (*ledgerv1.GetBalanceResponse, error) {
|
||||
if request.Account == nil {
|
||||
return nil, status.Error(codes.InvalidArgument, "account is required")
|
||||
}
|
||||
asOf := time.Now().UTC()
|
||||
if request.AsOf != nil {
|
||||
value, err := requiredTime(request.AsOf, "as_of")
|
||||
if err != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
asOf = value
|
||||
}
|
||||
account := accountReference(request.Account)
|
||||
balance, err := h.ledger.Balance(ctx, account, asOf)
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
return &ledgerv1.GetBalanceResponse{
|
||||
Account: accountMessage(account),
|
||||
Balance: balance.String(),
|
||||
AsOf: timestamppb.New(asOf),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *Handler) ReplayJournals(ctx context.Context, request *ledgerv1.ReplayJournalsRequest) (*ledgerv1.ReplayJournalsResponse, error) {
|
||||
commands := make([]applicationledger.AppendJournalCommand, 0, len(request.GetJournals()))
|
||||
for _, journal := range request.GetJournals() {
|
||||
command, err := appendJournalCommand(journal)
|
||||
if err != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
commands = append(commands, command)
|
||||
}
|
||||
results, err := h.ledger.Replay(ctx, commands)
|
||||
if err != nil {
|
||||
return nil, rpcError(err)
|
||||
}
|
||||
response := &ledgerv1.ReplayJournalsResponse{Results: make([]*ledgerv1.ReplayJournalResult, 0, len(results))}
|
||||
for _, result := range results {
|
||||
response.Results = append(response.Results, &ledgerv1.ReplayJournalResult{
|
||||
IdempotencyKey: result.Journal.IdempotencyKey,
|
||||
Journal: journalMessage(result.Journal),
|
||||
AlreadyExisted: result.AlreadyExisted,
|
||||
})
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func appendJournalCommand(request *ledgerv1.AppendJournalRequest) (applicationledger.AppendJournalCommand, error) {
|
||||
occurredAt, err := requiredTime(request.GetOccurredAt(), "occurred_at")
|
||||
if err != nil {
|
||||
return applicationledger.AppendJournalCommand{}, err
|
||||
}
|
||||
command := applicationledger.AppendJournalCommand{
|
||||
SourceService: request.GetSourceService(),
|
||||
IdempotencyKey: request.GetIdempotencyKey(),
|
||||
SourceTransactionID: request.GetSourceTransactionId(),
|
||||
TrackingCode: request.GetTrackingCode(),
|
||||
EffectKind: request.GetEffectKind(),
|
||||
EventVersion: request.GetEventVersion(),
|
||||
ReversalOfJournalID: request.GetReversalOfJournalId(),
|
||||
OccurredAt: occurredAt,
|
||||
CorrelationID: request.GetCorrelationId(),
|
||||
ActorID: request.GetActorId(),
|
||||
Blockchain: blockchainReference(request.GetBlockchain()),
|
||||
Metadata: request.GetMetadata(),
|
||||
Entries: make([]applicationledger.EntryCommand, 0, len(request.GetEntries())),
|
||||
}
|
||||
for _, entry := range request.GetEntries() {
|
||||
if entry.Account == nil {
|
||||
return applicationledger.AppendJournalCommand{}, errors.New("entry account is required")
|
||||
}
|
||||
command.Entries = append(command.Entries, applicationledger.EntryCommand{
|
||||
LineNumber: entry.GetLineNumber(),
|
||||
Account: accountReference(entry.Account),
|
||||
Amount: entry.GetAmount(),
|
||||
Description: entry.GetDescription(),
|
||||
})
|
||||
}
|
||||
return command, nil
|
||||
}
|
||||
|
||||
func requiredTime(value *timestamppb.Timestamp, field string) (time.Time, error) {
|
||||
if value == nil {
|
||||
return time.Time{}, errors.New(field + " is required")
|
||||
}
|
||||
if err := value.CheckValid(); err != nil {
|
||||
return time.Time{}, errors.New(field + " is invalid: " + err.Error())
|
||||
}
|
||||
return value.AsTime().UTC(), nil
|
||||
}
|
||||
|
||||
func accountReference(value *ledgerv1.AccountReference) domain.AccountReference {
|
||||
return domain.AccountReference{
|
||||
Class: accountClass(value.GetAccountClass()),
|
||||
OwnerType: value.GetOwnerType(),
|
||||
OwnerID: value.GetOwnerId(),
|
||||
AssetID: value.GetAssetId(),
|
||||
}
|
||||
}
|
||||
|
||||
func accountClass(value ledgerv1.AccountClass) domain.AccountClass {
|
||||
switch value {
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_USER_AVAILABLE:
|
||||
return domain.AccountClassUserAvailable
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_USER_FROZEN:
|
||||
return domain.AccountClassUserFrozen
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN:
|
||||
return domain.AccountClassExternalBlockchain
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_TREASURY:
|
||||
return domain.AccountClassTreasury
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_MARKET_CLEARING:
|
||||
return domain.AccountClassMarketClearing
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_IPG_CLEARING:
|
||||
return domain.AccountClassIPGClearing
|
||||
case ledgerv1.AccountClass_ACCOUNT_CLASS_COMMISSION_REVENUE:
|
||||
return domain.AccountClassCommissionRevenue
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func accountClassMessage(value domain.AccountClass) ledgerv1.AccountClass {
|
||||
switch value {
|
||||
case domain.AccountClassUserAvailable:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_USER_AVAILABLE
|
||||
case domain.AccountClassUserFrozen:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_USER_FROZEN
|
||||
case domain.AccountClassExternalBlockchain:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN
|
||||
case domain.AccountClassTreasury:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_TREASURY
|
||||
case domain.AccountClassMarketClearing:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_MARKET_CLEARING
|
||||
case domain.AccountClassIPGClearing:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_IPG_CLEARING
|
||||
case domain.AccountClassCommissionRevenue:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_COMMISSION_REVENUE
|
||||
default:
|
||||
return ledgerv1.AccountClass_ACCOUNT_CLASS_UNSPECIFIED
|
||||
}
|
||||
}
|
||||
|
||||
func transactionState(value ledgerv1.TransactionState) domain.TransactionState {
|
||||
switch value {
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_CREATED:
|
||||
return domain.TransactionStateCreated
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_PENDING_TRANSACTION:
|
||||
return domain.TransactionStatePendingTransaction
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_PENDING_ADMIN:
|
||||
return domain.TransactionStatePendingAdmin
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_SUCCESSFUL:
|
||||
return domain.TransactionStateSuccessful
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_FAILED:
|
||||
return domain.TransactionStateFailed
|
||||
case ledgerv1.TransactionState_TRANSACTION_STATE_SUSPENDED:
|
||||
return domain.TransactionStateSuspended
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func transactionStateMessage(value domain.TransactionState) ledgerv1.TransactionState {
|
||||
switch value {
|
||||
case domain.TransactionStateCreated:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_CREATED
|
||||
case domain.TransactionStatePendingTransaction:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_PENDING_TRANSACTION
|
||||
case domain.TransactionStatePendingAdmin:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_PENDING_ADMIN
|
||||
case domain.TransactionStateSuccessful:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_SUCCESSFUL
|
||||
case domain.TransactionStateFailed:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_FAILED
|
||||
case domain.TransactionStateSuspended:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_SUSPENDED
|
||||
default:
|
||||
return ledgerv1.TransactionState_TRANSACTION_STATE_UNSPECIFIED
|
||||
}
|
||||
}
|
||||
|
||||
func blockchainReference(value *ledgerv1.BlockchainReference) domain.BlockchainReference {
|
||||
if value == nil {
|
||||
return domain.BlockchainReference{}
|
||||
}
|
||||
return domain.BlockchainReference{
|
||||
Network: value.GetNetwork(),
|
||||
TransactionHash: value.GetTransactionHash(),
|
||||
LedgerSequence: value.GetLedgerSequence(),
|
||||
}
|
||||
}
|
||||
|
||||
func journalMessage(value domain.Journal) *ledgerv1.Journal {
|
||||
message := &ledgerv1.Journal{
|
||||
JournalId: value.ID,
|
||||
SourceService: value.SourceService,
|
||||
IdempotencyKey: value.IdempotencyKey,
|
||||
SourceTransactionId: value.SourceTransactionID,
|
||||
TrackingCode: value.TrackingCode,
|
||||
EffectKind: value.EffectKind,
|
||||
EventVersion: value.EventVersion,
|
||||
OccurredAt: timestampMessage(value.OccurredAt),
|
||||
RecordedAt: timestampMessage(value.RecordedAt),
|
||||
CorrelationId: value.CorrelationID,
|
||||
ActorId: value.ActorID,
|
||||
Blockchain: blockchainMessage(value.Blockchain),
|
||||
Metadata: value.Metadata,
|
||||
PayloadHash: value.PayloadHash,
|
||||
Entries: make([]*ledgerv1.JournalEntry, 0, len(value.Entries)),
|
||||
}
|
||||
if value.ReversalOfJournalID != "" {
|
||||
message.ReversalOfJournalId = &value.ReversalOfJournalID
|
||||
}
|
||||
for _, entry := range value.Entries {
|
||||
message.Entries = append(message.Entries, &ledgerv1.JournalEntry{
|
||||
LineNumber: entry.LineNumber,
|
||||
Account: accountMessage(entry.Account),
|
||||
Amount: entry.Amount.String(),
|
||||
Description: entry.Description,
|
||||
})
|
||||
}
|
||||
return message
|
||||
}
|
||||
|
||||
func eventMessage(value domain.TransactionEvent) *ledgerv1.TransactionEvent {
|
||||
return &ledgerv1.TransactionEvent{
|
||||
EventId: value.ID,
|
||||
Event: &ledgerv1.AppendTransactionEventRequest{
|
||||
SourceService: value.SourceService,
|
||||
IdempotencyKey: value.IdempotencyKey,
|
||||
SourceTransactionId: value.SourceTransactionID,
|
||||
TrackingCode: value.TrackingCode,
|
||||
EventVersion: value.EventVersion,
|
||||
State: transactionStateMessage(value.State),
|
||||
ErrorCode: value.ErrorCode,
|
||||
ErrorMessage: value.ErrorMessage,
|
||||
OccurredAt: timestampMessage(value.OccurredAt),
|
||||
CorrelationId: value.CorrelationID,
|
||||
ActorId: value.ActorID,
|
||||
Blockchain: blockchainMessage(value.Blockchain),
|
||||
Metadata: value.Metadata,
|
||||
},
|
||||
RecordedAt: timestampMessage(value.RecordedAt),
|
||||
PayloadHash: value.PayloadHash,
|
||||
}
|
||||
}
|
||||
|
||||
func accountMessage(value domain.AccountReference) *ledgerv1.AccountReference {
|
||||
return &ledgerv1.AccountReference{
|
||||
AccountClass: accountClassMessage(value.Class),
|
||||
OwnerType: value.OwnerType,
|
||||
OwnerId: value.OwnerID,
|
||||
AssetId: value.AssetID,
|
||||
}
|
||||
}
|
||||
|
||||
func blockchainMessage(value domain.BlockchainReference) *ledgerv1.BlockchainReference {
|
||||
return &ledgerv1.BlockchainReference{
|
||||
Network: value.Network,
|
||||
TransactionHash: value.TransactionHash,
|
||||
LedgerSequence: value.LedgerSequence,
|
||||
}
|
||||
}
|
||||
|
||||
func timestampMessage(value time.Time) *timestamppb.Timestamp {
|
||||
if value.IsZero() {
|
||||
return nil
|
||||
}
|
||||
return timestamppb.New(value)
|
||||
}
|
||||
|
||||
func rpcError(err error) error {
|
||||
switch {
|
||||
case errors.Is(err, applicationledger.ErrInvalidArgument):
|
||||
return status.Error(codes.InvalidArgument, err.Error())
|
||||
case errors.Is(err, domain.ErrNotFound):
|
||||
return status.Error(codes.NotFound, err.Error())
|
||||
case errors.Is(err, domain.ErrIdempotencyConflict):
|
||||
return status.Error(codes.AlreadyExists, err.Error())
|
||||
case errors.Is(err, domain.ErrIncompleteJournal):
|
||||
return status.Error(codes.FailedPrecondition, err.Error())
|
||||
case errors.Is(err, domain.ErrAlreadyReversed):
|
||||
return status.Error(codes.FailedPrecondition, err.Error())
|
||||
case errors.Is(err, context.Canceled):
|
||||
return status.Error(codes.Canceled, err.Error())
|
||||
case errors.Is(err, context.DeadlineExceeded):
|
||||
return status.Error(codes.DeadlineExceeded, err.Error())
|
||||
default:
|
||||
return status.Error(codes.Internal, "internal ledger error")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user