Files
hardlink/internal/paybridge/client.go
T

524 lines
14 KiB
Go

package paybridge
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/v2/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/v2/paymentstatus"
"github.com/gorilla/websocket"
log "github.com/sirupsen/logrus"
)
type Client struct {
PrintReceipt func(string)
URL string
APIKey string
TimeoutSeconds int
}
func NewClient(url, apiKey string, timeoutSeconds int) *Client {
if timeoutSeconds <= 0 {
timeoutSeconds = 300
}
return &Client{
URL: url,
APIKey: apiKey,
TimeoutSeconds: timeoutSeconds,
}
}
func (c *Client) Sale(ctx context.Context, req paymentsvc.SaleRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
if req.Currency == "" {
req.Currency = "GBP"
}
payBridgeReq := PaymentRequest{
RequestID: req.RequestID,
Amount: req.Amount,
Currency: req.Currency,
Operation: "SALE",
TimeoutSeconds: c.TimeoutSeconds,
}
result, err := c.doPayment(ctx, payBridgeReq, onStatus)
if result != nil {
result.Terminal = payBridgeTerminalResult(result)
if c.PrintReceipt != nil {
c.PrintReceipt(result.CustomerReceipt)
}
}
return result, err
}
func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (returned *paymentsvc.Result, resultErr error) {
stage := "configure_connection"
var httpStatus int
defer func() {
if resultErr != nil || (returned != nil && payBridgeTerminalResult(returned).Outcome == "unknown") {
fields := log.Fields{
"provider": "paybridge", "operation": "sale", "stage": stage,
"request_id": req.RequestID, "transaction_reference": req.RequestID,
"error_category": paymentsvc.SafeErrorCategory(resultErr),
}
if returned != nil {
if returned.RequestID != "" {
fields["transaction_reference"] = returned.RequestID
}
if returned.TransactionID != "" {
fields["provider_transaction_id"] = returned.TransactionID
}
if returned.ReferenceNumber != "" {
fields["provider_reference"] = returned.ReferenceNumber
}
}
if ctx.Err() != nil {
fields["error_category"] = paymentsvc.SafeErrorCategory(ctx.Err())
} else if errors.Is(resultErr, ErrConnectionFailed) {
fields["error_category"] = "connection_failure"
} else if errors.Is(resultErr, ErrAuthFailed) {
fields["error_category"] = "authentication_failed"
} else if errors.Is(resultErr, ErrUnexpectedMessage) {
fields["error_category"] = "invalid_response"
}
var closeError *websocket.CloseError
if errors.As(resultErr, &closeError) {
fields["error_category"] = "response_lost"
fields["websocket_close_code"] = closeError.Code
}
if httpStatus != 0 {
fields["http_status"] = httpStatus
}
log.WithFields(fields).Warn("PayBridge payment requires reconciliation")
}
}()
emitStatus(onStatus, paymentstatus.Starting)
connectURL, err := c.connectURL()
if err != nil {
return nil, err
}
stage = "connect"
ws, response, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
if err != nil {
if response != nil {
httpStatus = response.StatusCode
if response.Body != nil {
response.Body.Close()
}
}
return nil, fmt.Errorf("%w: %v", ErrConnectionFailed, err)
}
defer ws.Close()
done := make(chan struct{})
defer close(done)
go func() {
select {
case <-ctx.Done():
_ = ws.Close()
case <-done:
}
}()
stage = "authenticate"
jwt, err := c.readAuthSuccess(ws)
if err != nil {
return nil, err
}
log.Info("PayBridge authentication successful")
emitStatus(onStatus, paymentstatus.Started)
stage = "send_payment"
if err := ws.WriteJSON(Envelope{
Type: types.MesTypePaymentRequest,
JWT: jwt,
Data: req,
Timestamp: time.Now().UnixMilli(),
}); err != nil {
return nil, fmt.Errorf("send PayBridge payment_request: %w", err)
}
log.WithFields(log.Fields{
"requestId": req.RequestID,
"operation": req.Operation,
"amount": req.Amount,
"currency": req.Currency,
}).Info("PayBridge payment request sent")
emitStatus(onStatus, paymentstatus.RequestSent)
for {
stage = "read_result"
_, raw, err := ws.ReadMessage()
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("read PayBridge message: %w", err)
}
var head struct {
Type string `json:"type"`
}
if err := json.Unmarshal(raw, &head); err != nil {
return nil, fmt.Errorf("decode PayBridge message header: %w", err)
}
messageType := strings.ToLower(head.Type)
switch messageType {
case types.MesTypePaymentStatusUpdate:
stage = "decode_status"
var update StatusUpdateEnvelope
if err := json.Unmarshal(raw, &update); err != nil {
return nil, fmt.Errorf("decode payment_status_update: %w", err)
}
statusCode, known := mapPayBridgeStatus(
update.Data.Status,
update.Data.Code,
)
log.WithField("status", statusCode).Info("PayBridge status update")
if !known {
log.Warn("Unknown PayBridge status update")
}
emitStatus(onStatus, statusCode)
case types.MesTypePaymentAccepted:
log.Info("PayBridge payment request accepted")
emitStatus(onStatus, paymentstatus.Accepted)
case types.MesTypePaymentResult:
stage = "decode_result"
var result PaymentResultEnvelope
// log.Println("PayBridge payment result raw:", string(raw))
if err := json.Unmarshal(raw, &result); err != nil {
return nil, fmt.Errorf("decode payment_result: %w", err)
}
mapped := mapPaymentResult(result)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
"success": mapped.Success,
}).Info("PayBridge payment result received")
emitStatus(
onStatus,
mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
)
return mapped, nil
case types.MesTypePaymentError:
stage = "decode_payment_error"
var paymentErr PaymentErrorEnvelope
if err := json.Unmarshal(raw, &paymentErr); err != nil {
return nil, fmt.Errorf("decode payment_error: %w", err)
}
mapped := mapPaymentError(req, paymentErr)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapPayBridgeFinalStatus(mapped.Status, false),
"error_category": "provider_error",
}).Warn("PayBridge payment error received")
emitStatus(
onStatus,
mapPayBridgeFinalStatus(mapped.Status, false),
)
return mapped, nil
case types.ResultError:
stage = "provider_error"
var genericErr struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(raw, &genericErr); err != nil {
return nil, fmt.Errorf(
"%w: %s",
ErrUnexpectedMessage,
string(raw),
)
}
log.WithFields(log.Fields{"provider": "paybridge", "request_id": req.RequestID,
"error_category": "provider_error"}).Error("PayBridge error message received")
emitStatus(onStatus, paymentstatus.Error)
if genericErr.Error.Message != "" {
return nil, fmt.Errorf(
"%w: %s: %s",
ErrUnexpectedMessage,
genericErr.Error.Code,
genericErr.Error.Message,
)
}
return nil, fmt.Errorf(
"%w: %s",
ErrUnexpectedMessage,
string(raw),
)
case types.MesTypeAuthSuccess:
log.Info("Additional PayBridge auth_success message received")
default:
log.Warn("Unknown PayBridge intermediate message type")
emitStatus(onStatus, paymentstatus.Processing)
}
}
}
func (c *Client) connectURL() (string, error) {
u, err := url.Parse(c.URL)
if err != nil {
return "", fmt.Errorf(
"parse PayBridge WebSocket URL: %w",
err,
)
}
q := u.Query()
q.Set("api_key", c.APIKey)
u.RawQuery = q.Encode()
return u.String(), nil
}
func (c *Client) readAuthSuccess(ws *websocket.Conn) (string, error) {
if err := ws.SetReadDeadline(
time.Now().Add(10 * time.Second),
); err != nil {
return "", fmt.Errorf(
"%w: set auth read deadline: %v",
ErrAuthFailed,
err,
)
}
defer ws.SetReadDeadline(time.Time{})
_, raw, err := ws.ReadMessage()
if err != nil {
return "", fmt.Errorf(
"%w: read auth_success: %v",
ErrAuthFailed,
err,
)
}
var auth struct {
Type string `json:"type"`
JWT string `json:"jwt"`
}
if err := json.Unmarshal(raw, &auth); err != nil {
return "", fmt.Errorf(
"%w: decode auth_success: %v",
ErrAuthFailed,
err,
)
}
if !strings.EqualFold(
auth.Type,
types.MesTypeAuthSuccess,
) {
return "", fmt.Errorf(
"%w: expected auth_success, got %s: %s",
ErrAuthFailed,
auth.Type,
string(raw),
)
}
if auth.JWT == "" {
return "", fmt.Errorf(
"%w: auth_success did not contain jwt",
ErrAuthFailed,
)
}
return auth.JWT, nil
}
func emitStatus(
onStatus paymentsvc.StatusHandler,
code string,
) {
if onStatus == nil || code == "" {
return
}
onStatus(paymentsvc.StatusUpdate{
Code: code,
})
}
func mapPayBridgeStatus(
status string,
code string,
) (string, bool) {
normalizedStatus := strings.ToLower(
strings.TrimSpace(status),
)
switch normalizedStatus {
case payBridgeMessageInsertOrSwipeCard,
payBridgeMessageInsertSwipeOrPresentCard:
return paymentstatus.PresentCard, true
case payBridgeMessageInsertCard:
return paymentstatus.InsertCard, true
case payBridgeMessagePleaseWait:
return paymentstatus.PleaseWait, true
case payBridgeMessageDoNotRemoveCard:
return paymentstatus.DoNotRemoveCard, true
case payBridgeMessageTryAnotherInterface:
return paymentstatus.TryAnotherInterface, true
case payBridgeMessagePIN:
return paymentstatus.EnterPIN, true
case payBridgeMessagePINAgain:
return paymentstatus.EnterPINAgain, true
case payBridgeMessageTransactionCancelled:
return paymentstatus.Cancelled, true
case payBridgeMessageProcessing:
return paymentstatus.Processing, true
case payBridgeMessageApproved:
// Это ещё промежуточный статус.
// Финальный успех определяется только по payment_result.
return paymentstatus.Authorized, true
case payBridgeMessageDeclined:
return paymentstatus.Declined, true
}
// Fallback по фактически обнаруженным кодам терминала.
switch strings.TrimSpace(code) {
case payBridgeCodeInsertCard:
return paymentstatus.InsertCard, true
case payBridgeCodeEnterPIN:
return paymentstatus.EnterPIN, true
case payBridgeCodeCancelled:
return paymentstatus.Cancelled, true
case payBridgeCodePleaseWait:
return paymentstatus.PleaseWait, true
case payBridgeCodePresentCard, payBridgeCodePresentCardAlternate:
return paymentstatus.PresentCard, true
case payBridgeCodeEnterPINAgain:
return paymentstatus.EnterPINAgain, true
case payBridgeCodeTryAnotherInterface:
return paymentstatus.TryAnotherInterface, true
case payBridgeCodeDoNotRemoveCard:
return paymentstatus.DoNotRemoveCard, true
}
// Пока назначение кодов 200, 201, 205 и 210 неизвестно.
// Они останутся в логах, но на экране будет общий статус.
return paymentstatus.Processing, false
}
func mapPayBridgeFinalStatus(
status string,
success bool,
) string {
if success && strings.EqualFold(status, payBridgeFinalStatusApproved) {
return paymentstatus.Approved
}
switch strings.ToUpper(status) {
case payBridgeFinalStatusDeclined:
return paymentstatus.Declined
case payBridgeFinalStatusCancelled:
return paymentstatus.Cancelled
case payBridgeFinalStatusTimeout:
return paymentstatus.Timeout
case payBridgeFinalStatusVoided:
return paymentstatus.Voided
case payBridgeFinalStatusVoidedDailyLimitExceeded:
return paymentstatus.DailyLimitExceeded
case payBridgeFinalStatusDailyLimitVoidFailed:
return paymentstatus.VoidFailed
case payBridgeFinalStatusDailyLimitValidationError:
return paymentstatus.LimitValidationError
case payBridgeFinalStatusError, payBridgeFinalStatusFailed:
return paymentstatus.Error
default:
return paymentstatus.Error
}
}
func (*Client) ValidatePreauth(paymentsvc.SaleRequest) error { return paymentsvc.ErrPreauthUnsupported }
func (*Client) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return nil, paymentsvc.ErrPreauthUnsupported
}
func payBridgeTerminalResult(r *paymentsvc.Result) paymentapi.Result {
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "paybridge", AmountMinor: r.Amount, CurrencyCode: r.Currency, TransactionReference: r.RequestID, CardType: r.CardType, MaskedCardNumber: creditcall.MaskedCardNumber(r.CardNumber), ExpiryDate: r.ExpiryDate, CardHash: r.CardHash, CardReference: r.CardReference, AuthorizationCode: r.AuthCode, LastFour: r.LastFourDigits, Message: "Payment outcome uncertain; contact reception"}
if r.Success && strings.EqualFold(r.Status, payBridgeFinalStatusApproved) {
final.Outcome, final.Message = "approved", "Payment approved"
return final
}
switch strings.ToUpper(r.Status) {
case payBridgeFinalStatusDeclined:
final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined"
case payBridgeFinalStatusCancelled:
final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled"
}
return final
}