feat(hardlink): unify kiosk payments and finalize legacy cleanup

This commit is contained in:
2026-11-04 17:43:10 +00:00
parent 568adc034b
commit 814d87768d
57 changed files with 3624 additions and 1762 deletions
+99 -25
View File
@@ -3,19 +3,24 @@ package paybridge
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
"github.com/gorilla/websocket"
log "github.com/sirupsen/logrus"
)
type Client struct {
PrintReceipt func(string)
URL string
APIKey string
TimeoutSeconds int
@@ -46,10 +51,57 @@ func (c *Client) Sale(ctx context.Context, req paymentsvc.SaleRequest, onStatus
TimeoutSeconds: c.TimeoutSeconds,
}
return c.doPayment(ctx, payBridgeReq, onStatus)
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) (*paymentsvc.Result, error) {
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()
@@ -57,8 +109,15 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
return nil, err
}
ws, _, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
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()
@@ -74,6 +133,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
}
}()
stage = "authenticate"
jwt, err := c.readAuthSuccess(ws)
if err != nil {
return nil, err
@@ -82,6 +142,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.Info("PayBridge authentication successful")
emitStatus(onStatus, paymentstatus.Started)
stage = "send_payment"
if err := ws.WriteJSON(Envelope{
Type: types.MesTypePaymentRequest,
JWT: jwt,
@@ -101,6 +162,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
emitStatus(onStatus, paymentstatus.RequestSent)
for {
stage = "read_result"
_, raw, err := ws.ReadMessage()
if err != nil {
if ctx.Err() != nil {
@@ -122,26 +184,20 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
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)
}
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Info("PayBridge status update")
statusCode, known := mapPayBridgeStatus(
update.Data.Status,
update.Data.Code,
)
log.WithField("status", statusCode).Info("PayBridge status update")
if !known {
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Warn("Unknown PayBridge status update")
log.Warn("Unknown PayBridge status update")
}
emitStatus(onStatus, statusCode)
@@ -151,6 +207,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
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 {
@@ -162,7 +219,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"status": mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
"success": mapped.Success,
}).Info("PayBridge payment result received")
@@ -174,6 +231,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
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)
@@ -182,10 +240,10 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
mapped := mapPaymentError(req, paymentErr)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"error": mapped.ErrorMessage,
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapPayBridgeFinalStatus(mapped.Status, false),
"error_category": "provider_error",
}).Warn("PayBridge payment error received")
emitStatus(
@@ -196,6 +254,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
return mapped, nil
case types.ResultError:
stage = "provider_error"
var genericErr struct {
Error struct {
Code string `json:"code"`
@@ -211,10 +270,8 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
)
}
log.WithFields(log.Fields{
"code": genericErr.Error.Code,
"message": genericErr.Error.Message,
}).Error("PayBridge error message received")
log.WithFields(log.Fields{"provider": "paybridge", "request_id": req.RequestID,
"error_category": "provider_error"}).Error("PayBridge error message received")
emitStatus(onStatus, paymentstatus.Error)
@@ -237,10 +294,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.Info("Additional PayBridge auth_success message received")
default:
log.WithField(
"messageType",
head.Type,
).Warn("Unknown PayBridge intermediate message type")
log.Warn("Unknown PayBridge intermediate message type")
emitStatus(onStatus, paymentstatus.Processing)
}
@@ -447,3 +501,23 @@ func mapPayBridgeFinalStatus(
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
}
+162
View File
@@ -0,0 +1,162 @@
package paybridge
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"github.com/gorilla/websocket"
log "github.com/sirupsen/logrus"
logtest "github.com/sirupsen/logrus/hooks/test"
)
func paybridgeDiagnosticLog(t *testing.T) *logtest.Hook {
t.Helper()
logger := log.StandardLogger()
oldOutput := logger.Out
oldHooks := logger.ReplaceHooks(make(log.LevelHooks))
hook := logtest.NewGlobal()
log.SetOutput(io.Discard)
t.Cleanup(func() { log.SetOutput(oldOutput); logger.ReplaceHooks(oldHooks) })
return hook
}
func TestPayBridgeFailureDiagnosticsKeepIdentityAndDoNotRetry(t *testing.T) {
for _, failure := range []string{"connect", "auth", "lost", "malformed", "uncertain", "provider_error", "payment_error", "cancelled"} {
t.Run(failure, func(t *testing.T) {
hook := paybridgeDiagnosticLog(t)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
var financialPosts atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Query().Get("api_key") != "SYNTH-CREDENTIAL" {
t.Error("PayBridge connection omitted synthetic credential")
}
if failure == "connect" {
http.Error(w, "SYNTH-RAW-SECRET", 503)
return
}
connection, err := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if err != nil {
t.Error(err)
return
}
defer connection.Close()
auth := `{"type":"auth_success","jwt":"SYNTH-JWT-PRIVATE"}`
if failure == "auth" {
auth = `{"type":"SYNTH-RAW-SECRET","jwt":"SYNTH-JWT-PRIVATE"}`
}
if err := connection.WriteMessage(websocket.TextMessage, []byte(auth)); err != nil {
t.Error(err)
return
}
if failure == "auth" {
return
}
var request struct {
Data PaymentRequest `json:"data"`
}
if err := connection.ReadJSON(&request); err != nil {
t.Error(err)
return
}
financialPosts.Add(1)
if request.Data.RequestID != "SYNTH-REQUEST" || request.Data.Amount != 2500 {
t.Errorf("PayBridge dispatched %+v, want original request identity/amount", request.Data)
}
body := ""
switch failure {
case "lost":
if err := connection.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.ClosePolicyViolation, "SYNTH-RAW-SECRET"), time.Now().Add(time.Second)); err != nil {
t.Error(err)
}
return
case "malformed":
body = `{"type":"payment_result","data":"SYNTH-RAW-SECRET"}`
case "uncertain":
body = `{"type":"payment_result","data":{"requestId":"SYNTH-REQUEST","transactionId":"SYNTH-PROVIDER-TXN","referenceNumber":"SYNTH-PROVIDER-REF","success":false,"status":"TIMEOUT","errorMessage":"SYNTH-RAW-SECRET card 4111111111111111","amount":2500}}`
case "provider_error":
body = `{"type":"error","error":{"code":"SYNTH-PRIVATE-CODE","message":"SYNTH-RAW-SECRET"}}`
case "payment_error":
body = `{"type":"payment_error","data":{"transactionId":"SYNTH-PROVIDER-TXN","status":"TIMEOUT","error":"SYNTH-RAW-SECRET"}}`
case "cancelled":
cancel()
return
}
if err := connection.WriteMessage(websocket.TextMessage, []byte(body)); err != nil {
t.Error(err)
}
}))
t.Cleanup(server.Close)
client := NewClient("ws"+strings.TrimPrefix(server.URL, "http"), "SYNTH-CREDENTIAL", 5)
result, err := client.Sale(ctx, paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Amount: 2500, Currency: "GBP"}, nil)
wantPosts := int32(1)
if failure == "connect" || failure == "auth" {
wantPosts = 0
}
if financialPosts.Load() != wantPosts {
t.Errorf("Sale(%s) dispatches=%d, want %d without retry", failure, financialPosts.Load(), wantPosts)
}
if failure == "uncertain" || failure == "payment_error" {
if err != nil || result == nil || result.Terminal.Outcome != "unknown" || result.Terminal.Retryable {
t.Fatalf("Sale(%s)=%+v/%v, want unchanged nonretryable unknown", failure, result, err)
}
if !strings.Contains(result.ErrorMessage, "SYNTH-RAW-SECRET") {
t.Error("diagnostic changes mutated the existing provider result")
}
} else if result != nil || err == nil {
t.Fatalf("Sale(%s)=%+v/%v, want original nil-result failure", failure, result, err)
}
if failure == "connect" && !errors.Is(err, ErrConnectionFailed) {
t.Errorf("Sale(connect) error=%v, want ErrConnectionFailed", err)
}
if failure == "cancelled" && !errors.Is(err, context.Canceled) {
t.Errorf("Sale(cancelled) error=%v, want context.Canceled", err)
}
var diagnostic *log.Entry
for _, entry := range hook.AllEntries() {
data, _ := json.Marshal(entry.Data)
for _, secret := range []string{"SYNTH-CREDENTIAL", "SYNTH-JWT-PRIVATE", "SYNTH-RAW-SECRET", "SYNTH-PRIVATE-CODE", "4111111111111111"} {
if strings.Contains(string(data)+entry.Message, secret) {
t.Errorf("Sale(%s) logged sensitive marker %q", failure, secret)
}
}
if entry.Message == "PayBridge payment requires reconciliation" {
diagnostic = entry
}
}
if diagnostic == nil {
t.Fatal("Sale failure emitted no reconciliation diagnostic")
}
for key, want := range map[string]string{"provider": "paybridge", "request_id": "SYNTH-REQUEST", "transaction_reference": "SYNTH-REQUEST"} {
if diagnostic.Data[key] != want {
t.Errorf("Sale(%s) diagnostic[%s]=%v, want %s", failure, key, diagnostic.Data[key], want)
}
}
stages := map[string]string{"connect": "connect", "auth": "authenticate", "lost": "read_result", "malformed": "decode_result", "uncertain": "decode_result", "provider_error": "provider_error", "payment_error": "decode_payment_error", "cancelled": "read_result"}
categories := map[string]string{"connect": "connection_failure", "auth": "authentication_failed", "lost": "response_lost", "malformed": "invalid_response", "uncertain": "unresolved_result", "provider_error": "invalid_response", "payment_error": "unresolved_result", "cancelled": "cancelled"}
if diagnostic.Data["stage"] != stages[failure] || diagnostic.Data["error_category"] != categories[failure] {
t.Errorf("Sale(%s) diagnostic=%v, want stage=%s category=%s", failure, diagnostic.Data, stages[failure], categories[failure])
}
if failure == "lost" && diagnostic.Data["websocket_close_code"] != websocket.ClosePolicyViolation {
t.Errorf("Sale(lost) close code=%v, want 1008", diagnostic.Data["websocket_close_code"])
}
if failure == "connect" && diagnostic.Data["http_status"] != 503 {
t.Errorf("Sale(connect) HTTP status=%v, want 503", diagnostic.Data["http_status"])
}
if failure == "uncertain" || failure == "payment_error" {
if diagnostic.Data["provider_transaction_id"] != "SYNTH-PROVIDER-TXN" {
t.Errorf("Sale(%s) provider transaction=%v, want retained identity", failure, diagnostic.Data["provider_transaction_id"])
}
}
})
}
}
+20
View File
@@ -0,0 +1,20 @@
package paybridge
import (
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"testing"
)
func TestTerminalResultKeepsExistingIdentityAndMetadata(t *testing.T) {
raw := &paymentsvc.Result{Success: true, Status: "APPROVED", RequestID: "SYNTH-REQUEST", TransactionID: "SYNTH-PROVIDER-ID", Amount: 1234, Currency: "EUR", CardNumber: "************1133", CardType: "Visa", ExpiryDate: "1228", CardHash: "SYNTH-HASH", CardReference: "SYNTH-CARD"}
result := payBridgeTerminalResult(raw)
if result.Outcome != "approved" || result.TransactionReference != "SYNTH-REQUEST" || result.MaskedCardNumber != raw.CardNumber || result.CardHash != raw.CardHash || result.CardReference != raw.CardReference {
t.Errorf("payBridgeTerminalResult(%+v)=%+v, want current request identity and unchanged metadata", raw, result)
}
}
func TestTimeoutTerminalResultIsUncertain(t *testing.T) {
result := payBridgeTerminalResult(&paymentsvc.Result{Status: "TIMEOUT"})
if result.Outcome != "unknown" || result.Retryable {
t.Errorf("payBridgeTerminalResult(TIMEOUT)=%+v, want nonretryable unknown", result)
}
}