524 lines
14 KiB
Go
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
|
|
}
|