path: root/c2ec/bank-integration.go

package main

import (
	"bytes"
	"context"
	"fmt"
	http "net/http"
	"strconv"
	"time"
)

const BANK_INTEGRATION_CONFIG_ENDPOINT = "/config"
const WITHDRAWAL_OPERATION = "/withdrawal-operation"

const WOPID_PARAMETER = "wopid"
const BANK_INTEGRATION_CONFIG_PATTERN = BANK_INTEGRATION_CONFIG_ENDPOINT
const WITHDRAWAL_OPERATION_PATTERN = WITHDRAWAL_OPERATION
const WITHDRAWAL_OPERATION_BY_WOPID_PATTERN = WITHDRAWAL_OPERATION + "/{" + WOPID_PARAMETER + "}"
const WITHDRAWAL_OPERATION_PAYMENT_PATTERN = WITHDRAWAL_OPERATION_BY_WOPID_PATTERN + "/payment"
const WITHDRAWAL_OPERATION_ABORTION_PATTERN = WITHDRAWAL_OPERATION_BY_WOPID_PATTERN + "/abort"

const DEFAULT_LONG_POLL_MS = 1000
const DEFAULT_OLD_STATE = PENDING

// https://docs.taler.net/core/api-exchange.html#tsref-type-CurrencySpecification
type CurrencySpecification struct {
	Name                            string `json:"name"`
	Currency                        string `json:"currency"`
	NumFractionalInputDigits        int    `json:"num_fractional_input_digits"`
	NumFractionalNormalDigits       int    `json:"num_fractional_normal_digits"`
	NumFractionalTrailingZeroDigits int    `json:"num_fractional_trailing_zero_digits"`
	AltUnitNames                    string `json:"alt_unit_names"`
}

// https://docs.taler.net/core/api-bank-integration.html#tsref-type-BankIntegrationConfig
type BankIntegrationConfig struct {
	Name                  string                `json:"name"`
	Version               string                `json:"version"`
	Implementation        string                `json:"implementation"`
	Currency              string                `json:"currency"`
	CurrencySpecification CurrencySpecification `json:"currency_specification"`
}

type C2ECWithdrawRegistration struct {
	ReservePubKey EddsaPublicKey `json:"reserve_pub_key"`
	TerminalId    uint64         `json:"terminal_id"`
}

type C2ECWithdrawalStatus struct {
	Status        WithdrawalOperationStatus `json:"status"`
	Amount        Amount                    `json:"amount"`
	SenderWire    string                    `json:"sender_wire"`
	WireTypes     []string                  `json:"wire_types"`
	ReservePubKey EddsaPublicKey            `json:"selected_reserve_pub"`
}

type C2ECPaymentNotification struct {
	ProviderTransactionId string `json:"provider_transaction_id"`
	Amount                Amount `json:"amount"`
	Fees                  Amount `json:"fees"`
}

func bankIntegrationConfig(res http.ResponseWriter, req *http.Request) {

	cfg := BankIntegrationConfig{
		Name:    "taler-bank-integration",
		Version: "0:0:1",
	}

	serializedCfg, err := NewJsonCodec[BankIntegrationConfig]().EncodeToBytes(&cfg)
	if err != nil {
		LogInfo("bank-integration-api", fmt.Sprintf("failed serializing config: %s", err.Error()))
		res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		return
	}

	res.WriteHeader(HTTP_OK)
	res.Write(serializedCfg)
}

func handleWithdrawalRegistration(res http.ResponseWriter, req *http.Request) {

	jsonCodec := NewJsonCodec[C2ECWithdrawRegistration]()
	registration, err := ReadStructFromBody(req, jsonCodec)
	if err != nil {
		LogWarn("bank-integration-api", fmt.Sprintf("invalid body for withdrawal registration error=%s", err.Error()))
		err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAW_REGISTRATION_INVALID_REQ",
			Title:    "invalid request",
			Detail:   "the registration request for the withdrawal is malformed (error: " + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	// read and validate the wopid path parameter
	wopid := req.PathValue(WOPID_PARAMETER)
	wopid, err = ParseWopid(wopid)
	if err != nil {
		LogWarn("bank-integration-api", "wopid "+wopid+" not valid")
		if wopid == "" {
			err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_INVALID_PATH_PARAMETER",
				Title:    "invalid request path parameter",
				Detail:   "the withdrawal status request path parameter 'wopid' is malformed",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
	}

	err = DB.RegisterWithdrawal(
		WithdrawalIdentifier(wopid),
		registration.ReservePubKey,
		registration.TerminalId,
	)

	if err != nil {

		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAW_REGISTRATION_DB_FAILURE",
			Title:    "database failure",
			Detail:   "the registration of the withdrawal failed due to db failure (error:" + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	res.WriteHeader(HTTP_NO_CONTENT)
}

// Get status of withdrawal associated with the given WOPID
//
// Parameters:
//   - long_poll_ms (optional):
//     milliseconds to wait for state to change
//     given old_state until responding
//   - old_state (optional):
//     Default is 'pending'
func handleWithdrawalStatus(res http.ResponseWriter, req *http.Request) {

	// read and validate request query parameters
	shouldStartLongPoll := true
	longPollMilli := DEFAULT_LONG_POLL_MS
	if longPollMilliPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"long_poll_ms", strconv.Atoi, req, res,
	); accepted {
		if longPollMilliPtr != nil {
			longPollMilli = *longPollMilliPtr
		} else {
			// this means parameter was not given.
			// no long polling (simple get)
			shouldStartLongPoll = false
		}
	} else {
		shouldStartLongPoll = false
	}

	// read and validate the wopid path parameter
	wopid := req.PathValue(WOPID_PARAMETER)
	wopid, err := ParseWopid(wopid)
	if err != nil {
		LogWarn("bank-integration-api", "wopid "+wopid+" not valid")
		if wopid == "" {
			err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_INVALID_PATH_PARAMETER",
				Title:    "invalid request path parameter",
				Detail:   "the withdrawal status request path parameter 'wopid' is malformed",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
	}

	if shouldStartLongPoll {

		timeoutCtx, cancelFunc := context.WithTimeout(
			req.Context(),
			time.Duration(longPollMilli)*time.Millisecond,
		)
		defer cancelFunc()

		statusChannel := make(chan WithdrawalOperationStatus)
		errChan := make(chan error)

		go DB.ListenForWithdrawalStatusChange(timeoutCtx, WithdrawalIdentifier(wopid), statusChannel, errChan)
		for {
			select {
			case <-timeoutCtx.Done():
				err := WriteProblem(res, HTTP_NO_CONTENT, &RFC9457Problem{
					TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_LONG_POLL_TIME_EXCEEDED",
					Title:    "time exceeded",
					Detail:   fmt.Sprintf("long poll ended due to timeout: %dms", longPollMilli),
					Instance: req.RequestURI,
				})
				if err != nil {
					res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
				}
				return
			case err := <-errChan:
				err = WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
					TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_INTERNAL_SERVER_ERROR",
					Title:    "internal server error",
					Detail:   err.Error(),
					Instance: req.RequestURI,
				})
				if err != nil {
					res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
				}
				return
			case <-statusChannel:
				getWithdrawalOrWriteError(wopid, res, req.RequestURI)
				return
			}
		}
	}

	getWithdrawalOrWriteError(wopid, res, req.RequestURI)
}

func handlePaymentNotification(res http.ResponseWriter, req *http.Request) {

	wopid := req.PathValue(WOPID_PARAMETER)
	wopid, err := ParseWopid(wopid)
	if err != nil {
		LogWarn("bank-integration-api", "wopid "+wopid+" not valid")
		if wopid == "" {
			err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_INVALID_PATH_PARAMETER",
				Title:    "invalid request path parameter",
				Detail:   "the withdrawal status request path parameter 'wopid' is malformed",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
	}

	jsonCodec := NewJsonCodec[C2ECPaymentNotification]()
	paymentNotification, err := ReadStructFromBody(req, jsonCodec)
	if err != nil {
		LogWarn("bank-integration-api", fmt.Sprintf("invalid body for payment notification error=%s", err.Error()))
		err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAW_REGISTRATION_INVALID_REQ",
			Title:    "invalid request",
			Detail:   "the payment notification request for the withdrawal is malformed (error: " + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	err = DB.NotifyPayment(
		WithdrawalIdentifier(wopid),
		paymentNotification.ProviderTransactionId,
		paymentNotification.Amount,
		paymentNotification.Amount,
	)
	if err != nil {
		err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_PAYMENT_NOTIFICATION_FAILED",
			Title:    "payment notification failed",
			Detail:   "the payment notification failed during the processing of the message: " + err.Error(),
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	res.WriteHeader(HTTP_NO_CONTENT)
}

func handleWithdrawalAbort(res http.ResponseWriter, req *http.Request) {

	res.WriteHeader(HTTP_OK)
	res.Write(bytes.NewBufferString("retrieved withdrawal operation abortion request").Bytes())
}

// Tries to load a WithdrawalOperationStatus from the database. If no
// entry could been found, it will write the correct error to the response.
func getWithdrawalOrWriteError(wopid string, res http.ResponseWriter, reqUri string) {
	// read the withdrawal from the database
	withdrawal, err := DB.GetWithdrawalByWopid(wopid)
	if err != nil {

		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAWAL_STATUS_DB_FAILURE",
			Title:    "database failure",
			Detail:   "db failure while requesting withdrawal (error=" + err.Error() + ")",
			Instance: reqUri,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	if withdrawal == nil {
		// not found -> 404
		err := WriteProblem(res, HTTP_NOT_FOUND, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAWAL_NOT_FOUND",
			Title:    "Not Found",
			Detail:   "No withdrawal with wopid=" + wopid + " could been found.",
			Instance: reqUri,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	// return the C2ECWithdrawalStatus
	if amount, err := ToAmount(withdrawal.Amount); err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAWAL_STATUS_CONVERSION_FAILURE",
			Title:    "conversion failure",
			Detail:   "failed converting amount object (error:" + err.Error() + ")",
			Instance: reqUri,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	} else {
		withdrawalStatusBytes, err := NewJsonCodec[C2ECWithdrawalStatus]().EncodeToBytes(&C2ECWithdrawalStatus{
			Status: withdrawal.WithdrawalStatus,
			Amount: *amount,
		})
		if err != nil {
			err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_WITHDRAWAL_STATUS_CONVERSION_FAILURE",
				Title:    "conversion failure",
				Detail:   "failed converting C2ECWithdrawalStatus object (error:" + err.Error() + ")",
				Instance: reqUri,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
		res.WriteHeader(HTTP_OK)
		res.Write(withdrawalStatusBytes)
	}
}