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 }