Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1969aaa1d2 | ||
|
|
c8cbd1e7a3 | ||
|
|
afb8bb0e9e | ||
|
|
93ff67fbb1 | ||
|
|
ea578fe03e | ||
|
|
5e99a8e0d4 | ||
|
|
fbf652720c | ||
|
|
478d260ebe | ||
|
|
2a3a5bee7b | ||
|
|
fa2c92c8ab | ||
|
|
8ecdfd8cf7 | ||
|
|
f5ff78e60e | ||
|
|
ffd814e076 | ||
|
|
b982698ccd | ||
|
|
af151fd389 | ||
|
|
20fcbe5499 | ||
|
|
c6c2b40f37 | ||
|
|
8f093159cd | ||
|
|
e1549dda2f | ||
|
|
163ac0e808 | ||
|
|
19cfbf185b |
+1
-1
@@ -42,6 +42,6 @@ _cgo_export.*
|
||||
|
||||
_testmain.go
|
||||
|
||||
*.exe
|
||||
*.exe*
|
||||
*.test
|
||||
*.prof
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
# CreditCall payment streaming
|
||||
|
||||
Deploy ChipDNAClientCLI, then hardlink, then Operafyne. No database or configuration
|
||||
migration is needed. The existing CreditCall provider selection enables the new
|
||||
SALE and PREAUTH routes; CreditCall does not implement the generic payment provider interface.
|
||||
|
||||
## Contracts
|
||||
|
||||
`POST /api/payment/sale` accepts the existing JSON sale request, for example
|
||||
`{"amount":1234,"confirmNo":"BOOKING-123","currency":"GBP"}`. Amount remains in
|
||||
minor units. CreditCall uses its existing SDK transaction reference generation.
|
||||
|
||||
`POST /api/payment/preauth` accepts string fields `amount`, `transactionType`
|
||||
and `checkoutDate`. Positive preauth sends the existing `Sale` input and checkout
|
||||
string; zero-value verification sends `{"amount":"","transactionType":"AccountVerification","checkoutDate":""}`.
|
||||
The returned `ACCOUNT VERIFICATION` type is matched case-insensitively and succeeds
|
||||
without persistence. Returned approved `SALE` schedules existing SQL persistence
|
||||
using provider-returned `TOTAL_AMOUNT`, never the request amount. PREAUTH does not
|
||||
confirm. Checkout remains departure-derived midnight UTC in the existing string
|
||||
format; SQL's existing date conversion and 48-hour release calculation are unchanged.
|
||||
|
||||
For CreditCall, responses contain newline-delimited JSON:
|
||||
|
||||
```json
|
||||
{"type":"status","code":"PAYMENT_PRESENT_CARD"}
|
||||
{"type":"result","result":{"outcome":"approved","message":"Payment approved","httpStatus":200,"status":{"code":200,"message":"Approved"},"transactionReference":"native-reference","cardType":"Visa","maskedCardNumber":"************1234","expiryDate":"1228","cardHash":"existing-hash","cardReference":"existing-card-reference"}}
|
||||
```
|
||||
|
||||
`outcome` is `approved`, `declined`, `cancelled`, `timeout`, or `error`. Approval
|
||||
is produced only by the shared CreditCall transaction/finalization core, including
|
||||
SALE confirmation behavior; PREAUTH uses its existing unconfirmed-result rules. `httpStatus` preserves the equivalent legacy
|
||||
operation status even after streaming commits HTTP 200. `status` preserves the
|
||||
existing processor `StatusRec`. Failure `message` preserves the plain description
|
||||
used by the legacy flow, including its existing interpretation quirks.
|
||||
|
||||
Card fields are emitted only on success. Unmasked or unexpected card-number data
|
||||
is omitted; encoding is not masking. Receipts and raw SDK parameter bags are not
|
||||
sent to Operafyne. The new adapter never builds a redirect URL. Dojo and PayBridge
|
||||
continue using their existing `{"type":"result","response":...}` contract.
|
||||
|
||||
Hardlink calls `POST /start-transaction-stream/` on ChipDNAClientCLI with
|
||||
`{"amount":"1234","transactionType":"Sale"}`. Its NDJSON consists of allowlisted
|
||||
`status` frames (`source`, `value`), a single `result` containing allowlisted SDK
|
||||
fields, or a sanitized `error`. `TRANSACTION_TYPE` and optional `TOTAL_AMOUNT`
|
||||
are included only when returned by the provider. They are never synthesized and
|
||||
are not added to the kiosk-facing result. AccountVerification normally omits
|
||||
`TOTAL_AMOUNT`. Receipt XML may be a JSON string field needed by
|
||||
hardlink's existing receipt handler; it is never a raw line in the stream.
|
||||
SALE confirmation continues through the existing, separate XML endpoint.
|
||||
|
||||
## Lifetime and compatibility
|
||||
|
||||
- `/start-transaction/`, `/takepayment`, and `/takepreauth` retain their existing
|
||||
external contracts. Both SALE and PREAUTH now stream to Operafyne; existing SQL
|
||||
persistence/release behavior remains unchanged.
|
||||
- Operafyne uses a private 120-second CreditCall client for SALE and PREAUTH.
|
||||
This is only the kiosk wait boundary; Dojo/PayBridge clients are unchanged.
|
||||
Timeout/cancellation is technical, not an authoritative decline or automatically
|
||||
retryable result. It never triggers a second start or legacy endpoint fallback.
|
||||
- Validation uses the inbound request. At financial dispatch handoff, hardlink
|
||||
detaches cancellation with `context.WithoutCancel`. Inbound cancellation and
|
||||
write failures control only delivery; result processing, SALE confirmation,
|
||||
receipts and PREAUTH persistence scheduling continue independently.
|
||||
- Start and each SALE confirmation call retain their independent 300-second timeout.
|
||||
Confirmation still uses two attempts, retrying transport/read errors with the
|
||||
existing two-second delay. The generic whole-operation timeout is not used.
|
||||
- Kiosk cancellation or failed/blocked kiosk delivery does not cancel upstream reading,
|
||||
confirmation, receipt handling, or PREAUTH persistence scheduling. Progress queues may drop hints when full;
|
||||
final results have a separate slot and are delivered at most once.
|
||||
- Only the response writer writes frames. Transaction execution never waits
|
||||
for progress delivery. No additional delivery timer or whole-operation deadline
|
||||
shortens the existing HTTP call bounds.
|
||||
- Native SDK 3.17 updates use `UPDATE`; card notifications use `NOTIFICATION`,
|
||||
retained as `CARD_STATUS` on the internal wire. Normal progress does not require
|
||||
a reference: it is accepted only inside the existing serial transaction's active
|
||||
observational window. A supplied nonempty reference must match. The window opens
|
||||
immediately before the SDK start call and closes immediately at
|
||||
`TransactionFinished`; finalization never waits for card removal.
|
||||
- `CardRemovalRequested` and `CardRemovalEnforced` follow the same active-window
|
||||
rule as other progress, including when no reference is supplied. Real Miura
|
||||
insertion-recovery sequences can repeat present-card and remove-card prompts
|
||||
within one transaction; these repeated prompts are not deduplicated. Outside
|
||||
the active window they are discarded. `Removed` remains omitted even with a
|
||||
reference, and the existing `Inserted` mapping is unchanged.
|
||||
- Ownership is best-effort UI observation. SDK 3.17 does not establish that every
|
||||
queued reference-less callback, including removal, has drained before another transaction
|
||||
starts. Such a callback may briefly display stale progress in a later active
|
||||
window. This accepted limitation must never affect success, decline, cancellation,
|
||||
timeout outcomes, confirmation, retry, receipts, PMS posting, or business state.
|
||||
- After timeout, an ambiguous start error, an asynchronous SDK error during an
|
||||
active window, or reference reuse/overlap, progress remains suppressed for that
|
||||
`Client` lifetime across SALE and PREAUTH. New transactions, elapsed time, callbacks and automatic
|
||||
reconnect do not reset the guard. Payments remain enabled.
|
||||
- Only the exact synchronous `ClientNotConnectedToServer` error safely clears an
|
||||
unsuppressed window and releases its unused reference: SDK 3.17 `StartCommand`
|
||||
returns it before `SendRequest`. Validation errors, mixed errors and all other
|
||||
unproven errors suppress observation. Safe pre-dispatch rejection never clears
|
||||
an existing suppression latch.
|
||||
- Progress cannot approve, decline, confirm, cancel, or retry a transaction.
|
||||
`OnlineAuthCompleted` means waiting; `Removed` and unknown events are omitted.
|
||||
|
||||
## Automated verification
|
||||
|
||||
In hardlink, use `go test -count=1 -skip '^Test_SendMail$' ./...` to exclude the
|
||||
existing test that sends real email. Focused tests cover legacy parity, malformed
|
||||
XML/NDJSON, retained confirmation fields and receipts, retries, disconnects,
|
||||
backpressure, field filtering, and conservative status mapping. Race checks cover
|
||||
the changed handler and mapper packages. No test proves absence of orphan holds.
|
||||
|
||||
In ChipDNAClientCLI, build `ChipDnaClient.sln` and `Tests/StreamingTests.csproj`
|
||||
with MSBuild, then run `Tests/bin/Debug/ChipDNAClient.StreamingTests.exe`. The
|
||||
test executable links the production streaming code and needs no terminal.
|
||||
|
||||
In Operafyne, run `go test -count=1 ./...`; the service tests cover structured
|
||||
CreditCall SALE/PREAUTH, unchanged legacy requests, the 120-second UX boundary,
|
||||
cancellation after dispatch, failure/retry parity, and existing
|
||||
Dojo/PayBridge response handling. Run `go vet ./...`, `go build ./...`, and
|
||||
`git diff --check` in both Go repositories.
|
||||
|
||||
Physical account-verification testing confirmed approved `ACCOUNT VERIFICATION`
|
||||
with no `TOTAL_AMOUNT`. A monetary `/takepayment` test confirmed returned minor
|
||||
units; positive PREAUTH through the new transport still needs physical Miura
|
||||
validation. Automated tests do not replace that check. Receipt fields such as
|
||||
`NoChargeDeclaration` retain the existing provider-entry rendering behavior.
|
||||
@@ -0,0 +1,329 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/signal"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/tarm/serial"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/cms"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/bootstrap"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dojo"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/handlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/logging"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paybridge"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
|
||||
)
|
||||
|
||||
const (
|
||||
buildVersion = "v2.0.1"
|
||||
serviceName = "hardlink"
|
||||
pollingFrequency = 8 * time.Second
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Load config
|
||||
cfg := config.ReadHardlinkConfig()
|
||||
printer.PrinterName = cfg.PrinterName
|
||||
lockserver.Cert = cfg.Cert
|
||||
lockserver.LockServerURL = cfg.LockserverURL
|
||||
mail.SendErrorEmails = cfg.SendErrorEmails
|
||||
|
||||
// Root context for background goroutines
|
||||
// rootCtx, rootCancel := context.WithCancel(context.Background())
|
||||
// defer rootCancel()
|
||||
|
||||
var (
|
||||
dispPort *serial.Port
|
||||
disp *dispenser.Client
|
||||
cardWellStatus string
|
||||
)
|
||||
|
||||
// Setup logging and get file handle
|
||||
logFile, err := logging.SetupLogging(cfg.LogDir, serviceName, buildVersion)
|
||||
if err != nil {
|
||||
log.Printf("Failed to set up logging: %v\n", err)
|
||||
}
|
||||
if logFile != nil {
|
||||
defer logFile.Close()
|
||||
}
|
||||
|
||||
// Initialize dispenser
|
||||
if !cfg.TestMode {
|
||||
dispenser.SerialPort = cfg.DispenserPort
|
||||
dispenser.Address = []byte(cfg.DispenserAdrr)
|
||||
|
||||
dispPort, err = dispenser.InitializeDispenser()
|
||||
if err != nil {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dispenser Initialization Error", fmt.Errorf("failed to initialize dispenser: %v", err))
|
||||
}
|
||||
defer dispPort.Close()
|
||||
|
||||
disp = dispenser.NewClient(dispPort, 32)
|
||||
defer disp.Close()
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
|
||||
cardWellStatus, err = disp.DispenserPrepare(ctx)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("%s; wrong dispenser address: %s", err, cfg.DispenserAdrr)
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dispenser Preparation Error", err)
|
||||
}
|
||||
fmt.Println(cardWellStatus)
|
||||
}
|
||||
|
||||
// Test lock-server connection
|
||||
switch strings.ToLower(cfg.LockType) {
|
||||
case lockserver.TLJ:
|
||||
// TLJ uses HTTP - skip TCP probe here
|
||||
default:
|
||||
lockConn, err := lockserver.InitializeServerConnection(cfg.LockserverURL)
|
||||
if err != nil {
|
||||
fmt.Println(err.Error())
|
||||
log.Errorf(err.Error())
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Lock Server Connection Error", err.Error())
|
||||
} else {
|
||||
fmt.Printf("Connected to the lock server successfuly at %s\n", cfg.LockserverURL)
|
||||
log.Infof("Connected to the lock server successfuly at %s", cfg.LockserverURL)
|
||||
lockConn.Close()
|
||||
}
|
||||
}
|
||||
|
||||
database, err := bootstrap.OpenDB(&cfg)
|
||||
if err != nil {
|
||||
log.Warnf("DB init failed: %v", err)
|
||||
}
|
||||
if database != nil {
|
||||
defer database.Close()
|
||||
}
|
||||
|
||||
// Create App and wire routes
|
||||
app := handlers.NewApp(disp, cfg.LockType, cfg.EncoderAddress, cardWellStatus, database, &cfg)
|
||||
|
||||
if cfg.IsPayment {
|
||||
fmt.Println("Payment processing is enabled")
|
||||
log.Info("Payment processing is enabled")
|
||||
|
||||
var provider paymentsvc.Provider
|
||||
reservationSystem, err := cms.ReadHotel(cfg.Hotel, cfg.CMSBaseURL)
|
||||
if err != nil {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to read hotel from CMS", fmt.Errorf("failed to read hotel from CMS: %v", err))
|
||||
}
|
||||
|
||||
paymentProvider := reservationSystem.PaymentSystem
|
||||
if paymentProvider == 0 {
|
||||
paymentProvider = cms.PaymentSystemIndex(cfg.PaymentProvider)
|
||||
}
|
||||
|
||||
switch paymentProvider {
|
||||
case cmstypes.PaySystemCreditCall:
|
||||
// CreditCall streaming shares its proven legacy transaction core.
|
||||
app.EnableCreditCallStreaming()
|
||||
startChipDnaClient()
|
||||
|
||||
go func() {
|
||||
time.Sleep(30 * time.Second)
|
||||
|
||||
pdqStatus, err := creditcall.ReadPdqStatus(cfg.Hotel, cfg.Kiosk)
|
||||
if err != nil {
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "PDQ Status Read Error", err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fmt.Printf("\nPDQ available: %v\n", pdqStatus.IsAvailable)
|
||||
log.Infof("PDQ available: %v", pdqStatus.IsAvailable)
|
||||
}()
|
||||
|
||||
log.Info("CreditCall payment provider enabled")
|
||||
fmt.Println("CreditCall payment provider enabled")
|
||||
|
||||
case cmstypes.PaySystemPayBridge:
|
||||
websocketURL := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
|
||||
|
||||
if websocketURL == "" {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "PayBridge websocket URL not found", fmt.Errorf("payment provider paybridge requires paybridge.websocket_url"))
|
||||
}
|
||||
if reservationSystem.PaymentGatewayAPIKeyWeb == "" {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway API Key not found", fmt.Errorf("payment provider paybridge requires paybridge.api_key"))
|
||||
}
|
||||
|
||||
provider = paybridge.NewClient(
|
||||
websocketURL,
|
||||
reservationSystem.PaymentGatewayAPIKeyWeb,
|
||||
cfg.TimeoutSeconds,
|
||||
)
|
||||
|
||||
case cmstypes.PaySystemDojo:
|
||||
TerminalID := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
|
||||
|
||||
if TerminalID == "" {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dojo Terminal ID not found", fmt.Errorf("payment provider dojo requires a terminal ID for kiosk %q in the CMS", cfg.Kiosk))
|
||||
}
|
||||
if reservationSystem.PaymentGatewayURL == "" {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway URL not found", fmt.Errorf("payment provider dojo requires dojo.websocket_url"))
|
||||
}
|
||||
|
||||
dojoClient, err := dojo.NewClient(dojo.Config{
|
||||
BaseURL: reservationSystem.PaymentGatewayURL,
|
||||
APIKey: reservationSystem.PaymentGatewayAPIKeyWeb,
|
||||
SoftwareHouseID: reservationSystem.PaymentGatewaySiteIDEPOS,
|
||||
Version: reservationSystem.PaymentGatewayPasswordEPOS,
|
||||
TerminalID: TerminalID,
|
||||
})
|
||||
if err != nil {
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to create Dojo client", err)
|
||||
}
|
||||
|
||||
provider = dojoClient
|
||||
|
||||
case cmstypes.PaySystemNone:
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "No payment provider selected", fmt.Errorf("payment processing is enabled, but no payment provider selected; expected creditcall, paybridge or dojo"))
|
||||
|
||||
default:
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Unsupported Payment Provider", fmt.Errorf(
|
||||
"unsupported payment provider %q; expected creditcall, paybridge or dojo",
|
||||
cfg.PaymentProvider,
|
||||
))
|
||||
}
|
||||
|
||||
// PayBridge and Dojo use the generic payment service.
|
||||
if provider != nil {
|
||||
app.SetPaymentService(paymentsvc.NewService(provider))
|
||||
log.Infof("Payment provider enabled for POST /api/payment/sale: %s", cmstypes.PaySystemNames[paymentProvider])
|
||||
fmt.Printf("Payment provider enabled for POST /api/payment/sale: %s\n", cmstypes.PaySystemNames[paymentProvider])
|
||||
}
|
||||
} else {
|
||||
fmt.Println("Payment processing is disabled")
|
||||
log.Info("Payment processing is disabled")
|
||||
}
|
||||
|
||||
// Update cardWellStatus when dispenser status changes
|
||||
if !cfg.TestMode && disp != nil {
|
||||
// Set initial cardWellStatus
|
||||
app.SetCardWellStatus(cardWellStatus)
|
||||
|
||||
// Set up callback to update cardWellStatus when dispenser status changes
|
||||
disp.OnStockUpdate(func(stock string) {
|
||||
app.SetCardWellStatus(stock)
|
||||
})
|
||||
|
||||
// Start polling for dispenser status every 10 seconds
|
||||
disp.StartPolling(pollingFrequency)
|
||||
}
|
||||
|
||||
mux := http.NewServeMux()
|
||||
app.RegisterRoutes(mux)
|
||||
|
||||
addr := fmt.Sprintf(":%d", cfg.Port)
|
||||
log.Infof("Starting HTTP server on http://localhost%s", addr)
|
||||
fmt.Printf("Starting HTTP server on http://localhost%s", addr)
|
||||
|
||||
if err := http.ListenAndServe(addr, mux); err != nil {
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
}
|
||||
|
||||
// func readTicketLayout() printer.LayoutOptions {
|
||||
// const layoutName = "TicketLayout.xml"
|
||||
// var layout printer.LayoutOptions
|
||||
|
||||
// // 1) Read the file
|
||||
// data, err := os.ReadFile(layoutName)
|
||||
// if err != nil {
|
||||
// errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
|
||||
// }
|
||||
|
||||
// // 2) Unmarshal into your struct
|
||||
// if err := xml.Unmarshal(data, &layout); err != nil {
|
||||
// errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
|
||||
// }
|
||||
|
||||
// return layout
|
||||
// }
|
||||
|
||||
func startChipDnaClient() {
|
||||
startClient := func() (*exec.Cmd, error) {
|
||||
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
|
||||
err := cmd.Start()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to start ChipDnaClient: %v", err)
|
||||
}
|
||||
log.Infof("ChipDnaClient started with PID %d", cmd.Process.Pid)
|
||||
return cmd, nil
|
||||
}
|
||||
|
||||
cmd, err := startClient()
|
||||
if err != nil {
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
|
||||
// Restart loop
|
||||
go func() {
|
||||
for {
|
||||
err := cmd.Wait()
|
||||
if err != nil {
|
||||
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
|
||||
fmt.Printf("ChipDnaClient exited unexpectedly: %v", err)
|
||||
time.Sleep(2 * time.Second)
|
||||
cmd, err = startClient()
|
||||
if err != nil {
|
||||
log.Errorf("Restart failed: %v", err)
|
||||
return
|
||||
}
|
||||
log.Info("ChipDnaClient restarted successfully")
|
||||
fmt.Printf("ChipDnaClient restarted successfully")
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
// Handle shutdown signals
|
||||
sigs := make(chan os.Signal, 1)
|
||||
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
||||
go func() {
|
||||
<-sigs
|
||||
log.Info("Shutting down...")
|
||||
if cmd.Process != nil {
|
||||
log.Info("Sending SIGTERM to ChipDnaClient...")
|
||||
_ = cmd.Process.Signal(syscall.SIGTERM)
|
||||
// wait up to 5s for graceful shutdown
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- cmd.Wait() }()
|
||||
select {
|
||||
case <-time.After(5 * time.Second):
|
||||
log.Warn("ChipDnaClient did not exit in time, killing...")
|
||||
_ = cmd.Process.Kill()
|
||||
case err := <-done:
|
||||
log.Infof("ChipDnaClient exited cleanly: %v", err)
|
||||
}
|
||||
}
|
||||
os.Exit(0)
|
||||
}()
|
||||
}
|
||||
|
||||
func pdqSerialForKiosk(pdqs []cmstypes.PDQRec, kiosk int) string {
|
||||
for _, item := range pdqs {
|
||||
if item.Kiosk == kiosk {
|
||||
return item.Serial
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
// Package cms provides functions to read hotel records from the CMS and retrieve their reservation system configuration.
|
||||
package cms
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
)
|
||||
|
||||
// ReadHotel gets the hotel record from CMS and returns its reservation system
|
||||
// configuration if the record has been updated since the last read.
|
||||
func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, error) {
|
||||
var reservationSystem cmstypes.ReservationSystemRec
|
||||
|
||||
if hotelCode == "" {
|
||||
return reservationSystem, errors.New("hotel code is empty")
|
||||
}
|
||||
|
||||
if CMSBaseURL == "" {
|
||||
return reservationSystem, errors.New("CMS base URL is empty")
|
||||
}
|
||||
|
||||
var request cmstypes.RequestRec
|
||||
|
||||
request.Auth.ID = hotelCode
|
||||
request.Auth.APIKey = cmstypes.APIKey
|
||||
request.Auth.Hotel = hotelCode
|
||||
request.Data = hotelCode
|
||||
|
||||
requestData, err := json.Marshal(request)
|
||||
if err != nil {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"marshal CMS hotel request: %w",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
requestURL := CMSBaseURL + cmstypes.APIHotelDetails
|
||||
|
||||
req, err := http.NewRequest(http.MethodPost, requestURL, bytes.NewReader(requestData))
|
||||
if err != nil {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"create CMS hotel request: %w",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Accept", "application/json")
|
||||
|
||||
client := &http.Client{
|
||||
Timeout: 15 * time.Second,
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"perform CMS hotel request: %w",
|
||||
err,
|
||||
)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"read CMS hotel response: %w",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
if resp.StatusCode < http.StatusOK ||
|
||||
resp.StatusCode >= http.StatusMultipleChoices {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"CMS hotel request returned HTTP %s: %s",
|
||||
resp.Status,
|
||||
string(body),
|
||||
)
|
||||
}
|
||||
|
||||
var hotelResponse cmstypes.HotelResponseRec
|
||||
|
||||
if err := json.Unmarshal(body, &hotelResponse); err != nil {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"unmarshal CMS hotel response: %w",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
if hotelResponse.Status.Code != cmstypes.StatusSuccessCode {
|
||||
return reservationSystem, fmt.Errorf(
|
||||
"CMS hotel request failed: %s",
|
||||
hotelResponse.Status.Message,
|
||||
)
|
||||
}
|
||||
|
||||
if hotelResponse.TheHotel.Updated <= -1 {
|
||||
return reservationSystem, errors.New(
|
||||
"hotel record not updated since last read",
|
||||
)
|
||||
}
|
||||
|
||||
return hotelResponse.TheHotel.ReservationSystem, nil
|
||||
}
|
||||
|
||||
func PaymentSystemIndex(name string) int {
|
||||
for i, paySystemName := range cmstypes.PaySystemNames {
|
||||
if strings.EqualFold(paySystemName, name) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
+233
@@ -0,0 +1,233 @@
|
||||
package cms
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
)
|
||||
|
||||
func TestReadHotelSuccess(t *testing.T) {
|
||||
const hotelCode = "gb-test-hotel"
|
||||
|
||||
expected := cmstypes.ReservationSystemRec{}
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(
|
||||
func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost {
|
||||
t.Errorf(
|
||||
"expected method %s, got %s",
|
||||
http.MethodPost,
|
||||
r.Method,
|
||||
)
|
||||
}
|
||||
|
||||
if r.URL.Path != cmstypes.APIHotelDetails {
|
||||
t.Errorf(
|
||||
"expected path %q, got %q",
|
||||
cmstypes.APIHotelDetails,
|
||||
r.URL.Path,
|
||||
)
|
||||
}
|
||||
|
||||
if contentType := r.Header.Get("Content-Type"); contentType != "application/json" {
|
||||
t.Errorf(
|
||||
"expected Content-Type application/json, got %q",
|
||||
contentType,
|
||||
)
|
||||
}
|
||||
|
||||
if accept := r.Header.Get("Accept"); accept != "application/json" {
|
||||
t.Errorf(
|
||||
"expected Accept application/json, got %q",
|
||||
accept,
|
||||
)
|
||||
}
|
||||
|
||||
var request cmstypes.RequestRec
|
||||
|
||||
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
||||
t.Errorf("decode request: %v", err)
|
||||
http.Error(w, "invalid request", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
if request.Auth.ID != hotelCode {
|
||||
t.Errorf(
|
||||
"expected auth ID %q, got %q",
|
||||
hotelCode,
|
||||
request.Auth.ID,
|
||||
)
|
||||
}
|
||||
|
||||
if request.Auth.Hotel != hotelCode {
|
||||
t.Errorf(
|
||||
"expected auth hotel %q, got %q",
|
||||
hotelCode,
|
||||
request.Auth.Hotel,
|
||||
)
|
||||
}
|
||||
|
||||
if request.Auth.APIKey != cmstypes.APIKey {
|
||||
t.Errorf(
|
||||
"expected API key %q, got %q",
|
||||
cmstypes.APIKey,
|
||||
request.Auth.APIKey,
|
||||
)
|
||||
}
|
||||
|
||||
if request.Data != hotelCode {
|
||||
t.Errorf(
|
||||
"expected request data %q, got %q",
|
||||
hotelCode,
|
||||
request.Data,
|
||||
)
|
||||
}
|
||||
|
||||
response := cmstypes.HotelResponseRec{}
|
||||
response.Status.Code = cmstypes.StatusSuccessCode
|
||||
response.TheHotel.Updated = 1
|
||||
response.TheHotel.ReservationSystem = expected
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
if err := json.NewEncoder(w).Encode(response); err != nil {
|
||||
t.Errorf("encode response: %v", err)
|
||||
}
|
||||
},
|
||||
))
|
||||
defer server.Close()
|
||||
|
||||
got, err := ReadHotel(hotelCode, server.URL)
|
||||
if err != nil {
|
||||
t.Fatalf("ReadHotel returned an unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(got, expected) {
|
||||
t.Errorf(
|
||||
"unexpected reservation system:\ngot: %+v\nwant: %+v",
|
||||
got,
|
||||
expected,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadHotelValidation(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
hotelCode string
|
||||
cmsBaseURL string
|
||||
wantMessage string
|
||||
}{
|
||||
{
|
||||
name: "empty hotel code",
|
||||
hotelCode: "",
|
||||
cmsBaseURL: "http://example.com",
|
||||
wantMessage: "hotel code is empty",
|
||||
},
|
||||
{
|
||||
name: "empty CMS base URL",
|
||||
hotelCode: "gb-test-hotel",
|
||||
cmsBaseURL: "",
|
||||
wantMessage: "CMS base URL is empty",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
_, err := ReadHotel(test.hotelCode, test.cmsBaseURL)
|
||||
if err == nil {
|
||||
t.Fatal("expected an error, got nil")
|
||||
}
|
||||
|
||||
if err.Error() != test.wantMessage {
|
||||
t.Errorf(
|
||||
"expected error %q, got %q",
|
||||
test.wantMessage,
|
||||
err.Error(),
|
||||
)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadHotelNotUpdated(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(
|
||||
func(w http.ResponseWriter, _ *http.Request) {
|
||||
response := cmstypes.HotelResponseRec{}
|
||||
response.Status.Code = cmstypes.StatusSuccessCode
|
||||
response.TheHotel.Updated = -1
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
if err := json.NewEncoder(w).Encode(response); err != nil {
|
||||
t.Errorf("encode response: %v", err)
|
||||
}
|
||||
},
|
||||
))
|
||||
defer server.Close()
|
||||
|
||||
_, err := ReadHotel("gb-test-hotel", server.URL)
|
||||
if err == nil {
|
||||
t.Fatal("expected an error, got nil")
|
||||
}
|
||||
|
||||
const expected = "hotel record not updated since last read"
|
||||
|
||||
if err.Error() != expected {
|
||||
t.Errorf("expected error %q, got %q", expected, err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadHotelHTTPError(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(
|
||||
func(w http.ResponseWriter, _ *http.Request) {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
|
||||
if _, err := io.WriteString(w, "CMS unavailable"); err != nil {
|
||||
t.Errorf("write response: %v", err)
|
||||
}
|
||||
},
|
||||
))
|
||||
defer server.Close()
|
||||
|
||||
_, err := ReadHotel("gb-test-hotel", server.URL)
|
||||
if err == nil {
|
||||
t.Fatal("expected an error, got nil")
|
||||
}
|
||||
|
||||
if !strings.Contains(err.Error(), "HTTP 500 Internal Server Error") {
|
||||
t.Errorf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
if !strings.Contains(err.Error(), "CMS unavailable") {
|
||||
t.Errorf("expected response body in error, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadHotelInvalidJSON(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(
|
||||
func(w http.ResponseWriter, _ *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
if _, err := io.WriteString(w, `{invalid JSON`); err != nil {
|
||||
t.Errorf("write response: %v", err)
|
||||
}
|
||||
},
|
||||
))
|
||||
defer server.Close()
|
||||
|
||||
_, err := ReadHotel("gb-test-hotel", server.URL)
|
||||
if err == nil {
|
||||
t.Fatal("expected an error, got nil")
|
||||
}
|
||||
|
||||
if !strings.Contains(err.Error(), "unmarshal CMS hotel response") {
|
||||
t.Errorf("unexpected error: %v", err)
|
||||
}
|
||||
}
|
||||
+22
-15
@@ -1,3 +1,4 @@
|
||||
// Package config handles reading and parsing configuration from config.yml.
|
||||
package config
|
||||
|
||||
import (
|
||||
@@ -5,15 +6,15 @@ import (
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
||||
log "github.com/sirupsen/logrus"
|
||||
yaml "gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// configRec holds values from config.yml.
|
||||
// ConfigRec holds values from config.yml.
|
||||
type ConfigRec struct {
|
||||
Port int `yaml:"port"`
|
||||
LockserverUrl string `yaml:"lockservUrl"`
|
||||
LockserverURL string `yaml:"lockservUrl"`
|
||||
LockType string `yaml:"lockType"`
|
||||
EncoderAddress string `yaml:"encoderAddr"`
|
||||
Cert string `yaml:"cert"`
|
||||
@@ -21,22 +22,25 @@ type ConfigRec struct {
|
||||
DispenserAdrr string `yaml:"dispensAddr"`
|
||||
PrinterName string `yaml:"printerName"`
|
||||
LogDir string `yaml:"logdir"`
|
||||
Dbport int `yaml:"dbport"` // Port for the database connection
|
||||
Dbname string `yaml:"dbname"` // Database name for the connection
|
||||
Dbuser string `yaml:"dbuser"` // User for the database connection
|
||||
Dbpassword string `yaml:"dbpassword"` // Password for the database connection
|
||||
Dbport int `yaml:"dbport"`
|
||||
Dbname string `yaml:"dbname"`
|
||||
Dbuser string `yaml:"dbuser"`
|
||||
Dbpassword string `yaml:"dbpassword"`
|
||||
CMSBaseURL string `yaml:"cmsurl"`
|
||||
IsPayment bool `yaml:"isPayment"`
|
||||
TestMode bool `yaml:"testMode"`
|
||||
Hotel string `yaml:"hotel"`
|
||||
Kiosk int `yaml:"kiosk"`
|
||||
SendErrorEmails []string `yaml:"senderroremails"`
|
||||
PaymentProvider string `yaml:"paymentProvider"`
|
||||
TimeoutSeconds int `yaml:"timeoutSeconds"`
|
||||
}
|
||||
|
||||
// ReadConfig reads config.yml and applies defaults.
|
||||
// ReadHardlinkConfig reads config.yml and applies defaults.
|
||||
func ReadHardlinkConfig() ConfigRec {
|
||||
var cfg ConfigRec
|
||||
const configName = "config.yml"
|
||||
defaultPort := 9091
|
||||
const defaultPort = 9091
|
||||
sep := string(os.PathSeparator)
|
||||
|
||||
data, err := os.ReadFile(configName)
|
||||
@@ -51,8 +55,7 @@ func ReadHardlinkConfig() ConfigRec {
|
||||
}
|
||||
|
||||
if cfg.LockType == "" {
|
||||
err = fmt.Errorf("LockType is required in %s", configName)
|
||||
errorhandlers.FatalError(err)
|
||||
errorhandlers.FatalError(fmt.Errorf("LockType is required in %s", configName))
|
||||
}
|
||||
cfg.LockType = strings.ToLower(cfg.LockType)
|
||||
|
||||
@@ -63,8 +66,13 @@ func ReadHardlinkConfig() ConfigRec {
|
||||
}
|
||||
|
||||
if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" {
|
||||
err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
|
||||
log.Warnf(err.Error())
|
||||
log.Warnf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
|
||||
}
|
||||
|
||||
cfg.PaymentProvider = strings.ToLower(strings.TrimSpace(cfg.PaymentProvider))
|
||||
|
||||
if cfg.TimeoutSeconds <= 0 {
|
||||
cfg.TimeoutSeconds = 300
|
||||
}
|
||||
|
||||
return cfg
|
||||
@@ -83,8 +91,7 @@ func ReadPreauthReleaserConfig() ConfigRec {
|
||||
}
|
||||
|
||||
if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" {
|
||||
err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
|
||||
errorhandlers.FatalError(err)
|
||||
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "PreauthReleaser Database Configuration Error", fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName))
|
||||
}
|
||||
|
||||
if cfg.LogDir == "" {
|
||||
|
||||
@@ -3,10 +3,12 @@ module gitea.futuresens.co.uk/futuresens/hardlink
|
||||
go 1.23.2
|
||||
|
||||
require (
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200
|
||||
gitea.futuresens.co.uk/futuresens/logging v1.0.9
|
||||
github.com/alexbrainman/printer v0.0.0-20200912035444-f40f26f0bdeb
|
||||
github.com/denisenkom/go-mssqldb v0.12.3
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/gorilla/websocket v1.5.3
|
||||
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394
|
||||
github.com/sirupsen/logrus v1.9.3
|
||||
github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190 h1:OxP911wT8HQqBJ20KIZcBxi898rsYHhhCkne2u45p1A=
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190/go.mod h1:ABMUkdm+3VGrkuoCJsXMfPPud9GHDOwBb1NiifFqxes=
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200 h1:CRGAuhwecpOwY1CAuC038NFyw6EFulVG554HbUqfezI=
|
||||
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200/go.mod h1:ABMUkdm+3VGrkuoCJsXMfPPud9GHDOwBb1NiifFqxes=
|
||||
gitea.futuresens.co.uk/futuresens/fscrypto v0.0.0-20221125125050-9acaffd21362 h1:MnhYo7XtsECCU+5yVMo3tZZOOSOKGkl7NpOvTAieBTo=
|
||||
gitea.futuresens.co.uk/futuresens/fscrypto v0.0.0-20221125125050-9acaffd21362/go.mod h1:p95ouVfK4qyC20D3/k9QLsWSxD2pdweWiY6vcYi9hpM=
|
||||
gitea.futuresens.co.uk/futuresens/logging v1.0.9 h1:uvCQq/plecB0z/bUWOhFhwyYUWGPkTBZHsYNL+3RFvI=
|
||||
@@ -19,6 +19,10 @@ github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZ
|
||||
github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
|
||||
github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
|
||||
github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
|
||||
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
|
||||
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394 h1:+6kiV40vfmh17TDlZG15C2uGje1/XBGT32j6xKmUkqM=
|
||||
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394/go.mod h1:ogN8Sxy3n5VKLhQxbtSBM3ICG/VgjXS/akQJIoDSrgA=
|
||||
github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8=
|
||||
|
||||
@@ -6,10 +6,10 @@ import (
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/bootstrap"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/logging"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/logging"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
@@ -32,7 +32,7 @@ func main() {
|
||||
}
|
||||
defer database.Close()
|
||||
|
||||
if err := payment.ReleasePreauthorizations(database); err != nil {
|
||||
if err := creditcall.ReleasePreauthorizations(database); err != nil {
|
||||
log.Error(err)
|
||||
fmt.Println(err)
|
||||
} else {
|
||||
|
||||
@@ -5,7 +5,7 @@ import (
|
||||
"database/sql"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/db"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
|
||||
)
|
||||
|
||||
func OpenDB(cfg *config.ConfigRec) (*sql.DB, error) {
|
||||
@@ -1,4 +1,4 @@
|
||||
package payment
|
||||
package creditcall
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
@@ -11,7 +11,7 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
package payment
|
||||
package creditcall
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
@@ -9,7 +9,7 @@ import (
|
||||
"strings"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
_ "github.com/denisenkom/go-mssqldb"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
@@ -82,7 +82,6 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML)
|
||||
|
||||
for _, e := range trResult.Entries {
|
||||
switch e.Key {
|
||||
|
||||
case types.ReceiptData, types.ReceiptDataMerchant:
|
||||
// intentionally ignored
|
||||
|
||||
@@ -100,7 +99,7 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML)
|
||||
}
|
||||
}
|
||||
|
||||
// BuildRedirectURL builds the redirect URL to send the guest to after payment.
|
||||
// BuildPaymentRedirectURL builds the redirect URL to send the guest to after payment.
|
||||
func BuildPaymentRedirectURL(result map[string]string) string {
|
||||
res := result[types.TransactionResult]
|
||||
|
||||
@@ -126,6 +125,15 @@ func BuildPaymentRedirectURL(result map[string]string) string {
|
||||
}
|
||||
|
||||
func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
|
||||
approved, persist := PreauthDecision(result)
|
||||
if approved {
|
||||
return BuildSuccessURL(result), persist
|
||||
}
|
||||
return BuildFailureURL(result[types.TransactionResult], result[types.Errors]), false
|
||||
}
|
||||
|
||||
// PreauthDecision preserves the returned-type approval and persistence rules.
|
||||
func PreauthDecision(result map[string]string) (approved, persist bool) {
|
||||
res := result[types.TransactionResult]
|
||||
tType := result[types.TransactionType]
|
||||
|
||||
@@ -137,7 +145,7 @@ func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
|
||||
log.WithField(types.LogResult, result[types.TransactionResult]).
|
||||
Info("Account verification approved")
|
||||
|
||||
return BuildSuccessURL(result), false
|
||||
return true, false
|
||||
|
||||
// Transaction type Sale?
|
||||
case strings.EqualFold(tType, types.SaleTransactionType):
|
||||
@@ -145,18 +153,19 @@ func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
|
||||
log.WithField(types.LogResult, result[types.ConfirmResult]).
|
||||
Info("Amount preauthorized successfully")
|
||||
|
||||
return BuildSuccessURL(result), true
|
||||
return true, true
|
||||
}
|
||||
}
|
||||
|
||||
// Not approved
|
||||
return BuildFailureURL(res, result[types.Errors]), false
|
||||
return false, false
|
||||
}
|
||||
|
||||
func BuildSuccessURL(result map[string]string) string {
|
||||
q := url.Values{}
|
||||
q.Set("CardNumber", hex.EncodeToString([]byte(result[types.PAN_MASKED])))
|
||||
q.Set("ExpiryDate", hex.EncodeToString([]byte(result[types.EXPIRY_DATE])))
|
||||
q.Set("CardNumber", hex.EncodeToString([]byte(result[types.PanMasked])))
|
||||
q.Set("CardType", hex.EncodeToString([]byte(result[types.CardType])))
|
||||
q.Set("ExpiryDate", hex.EncodeToString([]byte(result[types.ExpiryDate])))
|
||||
q.Set("TxnReference", result[types.Reference])
|
||||
q.Set("CardHash", hex.EncodeToString([]byte(result[types.CardHash])))
|
||||
q.Set("CardReference", hex.EncodeToString([]byte(result[types.CardReference])))
|
||||
@@ -168,9 +177,7 @@ func BuildSuccessURL(result map[string]string) string {
|
||||
|
||||
func BuildFailureURL(msgType, description string) string {
|
||||
q := url.Values{}
|
||||
if msgType != "" {
|
||||
description = fmt.Sprintf("Transaction %s", strings.ToLower(msgType))
|
||||
}
|
||||
description = FailureDescription(msgType, description)
|
||||
if description != "" {
|
||||
msgType = types.ResultError
|
||||
}
|
||||
@@ -185,3 +192,12 @@ func BuildFailureURL(msgType, description string) string {
|
||||
RawQuery: q.Encode(),
|
||||
}).String()
|
||||
}
|
||||
|
||||
// FailureDescription preserves the description used by the legacy payment flow
|
||||
// without requiring structured consumers to construct a redirect URL.
|
||||
func FailureDescription(msgType, description string) string {
|
||||
if msgType != "" {
|
||||
return fmt.Sprintf("Transaction %s", strings.ToLower(msgType))
|
||||
}
|
||||
return description
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package payment
|
||||
package creditcall
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
@@ -11,8 +11,8 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/db"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package creditcall
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
)
|
||||
|
||||
func TestPreauthLegacyDecision(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, result, kind string
|
||||
approved, save bool
|
||||
}{
|
||||
{"sale", "APPROVED", "SALE", true, true},
|
||||
{"verification", "APPROVED", "ACCOUNT VERIFICATION", true, false},
|
||||
{"mixed case", "Approved", "Account Verification", true, false},
|
||||
{"request spelling is not result spelling", "APPROVED", "AccountVerification", false, false},
|
||||
{"missing type", "APPROVED", "", false, false},
|
||||
{"declined sale", "DECLINED", "SALE", false, false},
|
||||
{"declined verification", "DECLINED", "ACCOUNT VERIFICATION", false, false},
|
||||
{"missing result", "", "SALE", false, false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.kind, types.Errors: "provider detail"}
|
||||
redirect, save := BuildPreauthRedirectURL(fields)
|
||||
if strings.HasPrefix(redirect, "/successful?") != tc.approved || save != tc.save {
|
||||
t.Errorf("BuildPreauthRedirectURL(%v) = %q,%t, want approved=%t save=%t", fields, redirect, save, tc.approved, tc.save)
|
||||
}
|
||||
if _, ok := fields[types.TotalAmount]; ok {
|
||||
t.Error("BuildPreauthRedirectURL fabricated TOTAL_AMOUNT")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package creditcall
|
||||
|
||||
import "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
|
||||
// ProgressStatus maps informational SDK events, never financial decisions.
|
||||
func ProgressStatus(source, value string) string {
|
||||
switch source {
|
||||
case "UPDATE":
|
||||
switch value {
|
||||
case "CardRequested", "ProvideCard", "InsertOrSwipeCard", "InsertOrContactless":
|
||||
return paymentstatus.PresentCard
|
||||
case "InsertCard":
|
||||
return paymentstatus.InsertCard
|
||||
case "SwipeCard":
|
||||
return paymentstatus.SwipeCard
|
||||
case "CardRemovalRequested", "CardRemovalEnforced":
|
||||
return paymentstatus.RemoveCard
|
||||
case "PinEntryStarted", "PinEntryPrompt", "PinEntryInProgress":
|
||||
return paymentstatus.EnterPIN
|
||||
case "PinEntryFailed":
|
||||
return paymentstatus.EnterPINAgain
|
||||
case "PinEntrySuccessful", "TransactionStarted", "OnlineAuthRequested", "OnlineAuthorizeRequest":
|
||||
return paymentstatus.Processing
|
||||
case "OnlineAuthCompleted":
|
||||
return paymentstatus.PleaseWait
|
||||
}
|
||||
case "CARD_STATUS":
|
||||
switch value {
|
||||
case "Inserted":
|
||||
return paymentstatus.DoNotRemoveCard
|
||||
case "Tapped", "Swiped":
|
||||
return paymentstatus.Processing
|
||||
}
|
||||
case "SIGNATURE":
|
||||
if value == "Requested" {
|
||||
return paymentstatus.SignatureRequired
|
||||
}
|
||||
case "PAUSE":
|
||||
if value == "Paused" {
|
||||
return paymentstatus.PleaseWait
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// MaskedCardNumber excludes unmasked or unexpected SDK data from the new wire contract.
|
||||
func MaskedCardNumber(value string) string {
|
||||
digits, masks := 0, 0
|
||||
for _, ch := range value {
|
||||
switch {
|
||||
case ch >= '0' && ch <= '9':
|
||||
digits++
|
||||
case ch == '*' || ch == 'x' || ch == 'X':
|
||||
masks++
|
||||
case ch == ' ' || ch == '-':
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
if masks < 4 || digits > 10 {
|
||||
return ""
|
||||
}
|
||||
return value
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package creditcall
|
||||
|
||||
import (
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestProgressStatus(t *testing.T) {
|
||||
for _, test := range []struct{ source, value, want string }{
|
||||
{"UPDATE", "CardRequested", paymentstatus.PresentCard},
|
||||
{"UPDATE", "ProvideCard", paymentstatus.PresentCard},
|
||||
{"UPDATE", "InsertOrSwipeCard", paymentstatus.PresentCard},
|
||||
{"UPDATE", "InsertOrContactless", paymentstatus.PresentCard},
|
||||
{"UPDATE", "InsertCard", paymentstatus.InsertCard},
|
||||
{"UPDATE", "SwipeCard", paymentstatus.SwipeCard},
|
||||
{"UPDATE", "CardRemovalRequested", paymentstatus.RemoveCard},
|
||||
{"UPDATE", "CardRemovalEnforced", paymentstatus.RemoveCard},
|
||||
{"UPDATE", "PinEntryStarted", paymentstatus.EnterPIN},
|
||||
{"UPDATE", "PinEntryPrompt", paymentstatus.EnterPIN},
|
||||
{"UPDATE", "PinEntryInProgress", paymentstatus.EnterPIN},
|
||||
{"UPDATE", "PinEntryFailed", paymentstatus.EnterPINAgain},
|
||||
{"UPDATE", "PinEntrySuccessful", paymentstatus.Processing},
|
||||
{"UPDATE", "TransactionStarted", paymentstatus.Processing},
|
||||
{"UPDATE", "OnlineAuthRequested", paymentstatus.Processing},
|
||||
{"UPDATE", "OnlineAuthorizeRequest", paymentstatus.Processing},
|
||||
{"UPDATE", "OnlineAuthCompleted", paymentstatus.PleaseWait},
|
||||
{"CARD_STATUS", "Inserted", paymentstatus.DoNotRemoveCard},
|
||||
{"CARD_STATUS", "Tapped", paymentstatus.Processing},
|
||||
{"CARD_STATUS", "Swiped", paymentstatus.Processing},
|
||||
{"CARD_STATUS", "Removed", ""},
|
||||
{"SIGNATURE", "Requested", paymentstatus.SignatureRequired},
|
||||
{"PAUSE", "Paused", paymentstatus.PleaseWait},
|
||||
{"UPDATE", "Approved", ""}, {"UPDATE", "Declined", ""},
|
||||
{"UPDATE", "unknown", ""}, {"PAN", "CardRequested", ""},
|
||||
} {
|
||||
if got := ProgressStatus(test.source, test.value); got != test.want {
|
||||
t.Errorf("ProgressStatus(%q, %q) = %q, want %q", test.source, test.value, got, test.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMaskedCardNumber(t *testing.T) {
|
||||
for _, test := range []struct{ value, want string }{
|
||||
{"123456******1234", "123456******1234"}, {"************1234", "************1234"},
|
||||
{"1234567890123456", ""}, {"1234567890123456****", ""}, {"3132333435363738", ""},
|
||||
{"%B1234567890123456^NAME", ""}, {"", ""},
|
||||
} {
|
||||
if got := MaskedCardNumber(test.value); got != test.want {
|
||||
t.Errorf("MaskedCardNumber(%q) = %q, want %q", test.value, got, test.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -12,7 +12,7 @@ import (
|
||||
mssqldb "github.com/denisenkom/go-mssqldb" // for error inspection
|
||||
log "github.com/sirupsen/logrus"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
)
|
||||
|
||||
// InitMSSQL opens and pings the SQL Server instance (keeps your original behaviour)
|
||||
@@ -1,6 +1,7 @@
|
||||
package dispenser
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -22,9 +23,13 @@ const (
|
||||
|
||||
// cache freshness for "continuous status" reads (tune as you wish)
|
||||
defaultStatusTTL = 1500 * time.Millisecond
|
||||
|
||||
CardWellEmptyMessage = "Card well is empty"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrCardWellEmpty = errors.New(CardWellEmptyMessage)
|
||||
|
||||
SerialPort string
|
||||
Address []byte
|
||||
|
||||
@@ -67,10 +72,9 @@ var (
|
||||
// Status helpers
|
||||
// --------------------
|
||||
|
||||
func logStatus(statusBytes []byte) {
|
||||
func statusDescription(statusBytes []byte) string {
|
||||
if len(statusBytes) < 4 {
|
||||
log.Infof("Dispenser status: <invalid len=%d>", len(statusBytes))
|
||||
return
|
||||
return fmt.Sprintf("<invalid len=%d>", len(statusBytes))
|
||||
}
|
||||
|
||||
posStatus := []struct {
|
||||
@@ -94,13 +98,58 @@ func logStatus(statusBytes []byte) {
|
||||
result.WriteString(statusMsg + "; ")
|
||||
}
|
||||
}
|
||||
log.Infof("Dispenser status: %s", result.String())
|
||||
return result.String()
|
||||
}
|
||||
|
||||
func logStatus(statusBytes []byte) {
|
||||
log.Infof("Dispenser status: %s", statusDescription(statusBytes))
|
||||
}
|
||||
|
||||
func isAtEncoderPosition(statusBytes []byte) bool {
|
||||
return len(statusBytes) >= 4 && statusBytes[3] == 0x33
|
||||
}
|
||||
|
||||
func validateDispenserStatusData(statusBytes []byte) error {
|
||||
if len(statusBytes) != 4 {
|
||||
return fmt.Errorf("malformed dispenser status: got %d bytes, want 4", len(statusBytes))
|
||||
}
|
||||
|
||||
statusMaps := []map[byte]string{statusPos0, statusPos1, statusPos2, statusPos3}
|
||||
for position, mapper := range statusMaps {
|
||||
if _, ok := mapper[statusBytes[position]]; !ok {
|
||||
return fmt.Errorf("unknown dispenser status 0x%X at position %d", statusBytes[position], position+1)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func dispenserStatusError(statusBytes []byte) error {
|
||||
switch statusBytes[0] {
|
||||
case 0x34, 0x32, 0x36:
|
||||
return fmt.Errorf("dispenser error: %s", statusPos0[statusBytes[0]])
|
||||
}
|
||||
switch statusBytes[1] {
|
||||
case 0x32, 0x31:
|
||||
return fmt.Errorf("dispenser error: %s", statusPos1[statusBytes[1]])
|
||||
}
|
||||
switch statusBytes[2] {
|
||||
case 0x34, 0x32:
|
||||
return fmt.Errorf("dispenser error: %s", statusPos2[statusBytes[2]])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func isPreparationMoving(statusBytes []byte) bool {
|
||||
return len(statusBytes) == 4 &&
|
||||
(statusBytes[0] == 0x31 || statusBytes[1] == 0x38)
|
||||
}
|
||||
|
||||
func hasPreparationDiagnostics(statusBytes []byte) bool {
|
||||
return len(statusBytes) == 4 &&
|
||||
(statusBytes[0] != 0x30 || statusBytes[1] != 0x30 || statusBytes[2] != 0x30)
|
||||
}
|
||||
|
||||
func stockTake(statusBytes []byte) string {
|
||||
if len(statusBytes) < 4 {
|
||||
return ""
|
||||
@@ -1,6 +1,4 @@
|
||||
// --------------------
|
||||
// Queue-based client (single owner of port)
|
||||
// --------------------
|
||||
// Package dispenser provides a queue-based client (single owner of port).
|
||||
package dispenser
|
||||
|
||||
import (
|
||||
@@ -32,12 +30,25 @@ type cmdResp struct {
|
||||
err error
|
||||
}
|
||||
|
||||
type sequenceTiming struct {
|
||||
now func() time.Time
|
||||
wait func(context.Context, time.Duration) error
|
||||
}
|
||||
|
||||
const (
|
||||
sequencePollInterval = time.Second
|
||||
sequenceRetryAfter = 6 * time.Second
|
||||
sequenceTimeout = 12 * time.Second
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
port *serial.Port
|
||||
|
||||
reqCh chan cmdReq
|
||||
done chan struct{}
|
||||
|
||||
sequenceTiming sequenceTiming
|
||||
|
||||
// status cache
|
||||
mu sync.RWMutex
|
||||
lastStatus []byte
|
||||
@@ -56,15 +67,31 @@ func NewClient(port *serial.Port, queueSize int) *Client {
|
||||
queueSize = 16
|
||||
}
|
||||
c := &Client{
|
||||
port: port,
|
||||
reqCh: make(chan cmdReq, queueSize),
|
||||
done: make(chan struct{}),
|
||||
port: port,
|
||||
reqCh: make(chan cmdReq, queueSize),
|
||||
done: make(chan struct{}),
|
||||
sequenceTiming: sequenceTiming{
|
||||
now: time.Now,
|
||||
wait: waitForSequence,
|
||||
},
|
||||
statusTTL: defaultStatusTTL,
|
||||
}
|
||||
go c.loop()
|
||||
return c
|
||||
}
|
||||
|
||||
func waitForSequence(ctx context.Context, duration time.Duration) error {
|
||||
timer := time.NewTimer(duration)
|
||||
defer timer.Stop()
|
||||
|
||||
select {
|
||||
case <-timer.C:
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) Close() {
|
||||
select {
|
||||
case <-c.done:
|
||||
@@ -74,7 +101,7 @@ func (c *Client) Close() {
|
||||
}
|
||||
}
|
||||
|
||||
// Optional: tune cache TTL (how "fresh" cached status must be)
|
||||
// SetStatusTTL sets the duration for which cached status is considered fresh.
|
||||
func (c *Client) SetStatusTTL(d time.Duration) {
|
||||
c.mu.Lock()
|
||||
c.statusTTL = d
|
||||
@@ -233,7 +260,7 @@ func (c *Client) OutOfMouth(ctx context.Context) error {
|
||||
// Public sequences updated to use Client (queue)
|
||||
// --------------------
|
||||
|
||||
// DispenserPrepare: check status; if empty => ok; else ensure at encoder.
|
||||
// DispenserPrepare checks status; if empty => ok; else ensure at encoder.
|
||||
func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
|
||||
const funcName = "DispenserPrepare"
|
||||
stockStatus := ""
|
||||
@@ -270,72 +297,152 @@ func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
|
||||
return stockStatus, nil
|
||||
}
|
||||
|
||||
func (c *Client) DispenserStart(ctx context.Context) (string, error) {
|
||||
const funcName = "DispenserStart"
|
||||
stockStatus := ""
|
||||
|
||||
status, err := c.CheckStatus(ctx)
|
||||
func (c *Client) readSequenceStatus(ctx context.Context, operation string) ([]byte, string, error) {
|
||||
status, err := c.do(ctx, cmdStatus)
|
||||
if err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] check status: %w", funcName, err)
|
||||
if ctxErr := ctx.Err(); ctxErr != nil {
|
||||
return nil, "", fmt.Errorf("[%s] read status: %w", operation, ctxErr)
|
||||
}
|
||||
return nil, "", fmt.Errorf("[%s] read status: %w", operation, err)
|
||||
}
|
||||
|
||||
logStatus(status)
|
||||
stockStatus = stockTake(status)
|
||||
c.setStock(status)
|
||||
stockStatus := ""
|
||||
if len(status) == 4 {
|
||||
stockStatus = stockTake(status)
|
||||
c.setStock(status)
|
||||
logStatus(status)
|
||||
}
|
||||
return status, stockStatus, nil
|
||||
}
|
||||
|
||||
if isCardWellEmpty(status) {
|
||||
return stockStatus, fmt.Errorf(stockStatus)
|
||||
func preparationStatus(operation string, status []byte) (bool, error) {
|
||||
if len(status) != 4 {
|
||||
return false, fmt.Errorf("[%s] %w", operation, validateDispenserStatusData(status))
|
||||
}
|
||||
if isAtEncoderPosition(status) {
|
||||
if hasPreparationDiagnostics(status) {
|
||||
log.Warnf(
|
||||
"[%s] card confirmed at encoder with dispenser diagnostics: %s raw status: % X",
|
||||
operation,
|
||||
statusDescription(status),
|
||||
status,
|
||||
)
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
if err := validateDispenserStatusData(status); err != nil {
|
||||
return false, fmt.Errorf("[%s] %w", operation, err)
|
||||
}
|
||||
if isCardWellEmpty(status) {
|
||||
return false, fmt.Errorf("[%s] %w", operation, ErrCardWellEmpty)
|
||||
}
|
||||
if isPreparationMoving(status) {
|
||||
return false, nil
|
||||
}
|
||||
if err := dispenserStatusError(status); err != nil {
|
||||
return false, fmt.Errorf("[%s] %w", operation, err)
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
func (c *Client) pollForEncoderPosition(
|
||||
ctx context.Context,
|
||||
operation string,
|
||||
retryCommand func(context.Context) error,
|
||||
) (string, error) {
|
||||
started := c.sequenceTiming.now()
|
||||
halfway := started.Add(sequenceRetryAfter)
|
||||
deadline := started.Add(sequenceTimeout)
|
||||
retried := false
|
||||
stockStatus := ""
|
||||
|
||||
for {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
|
||||
}
|
||||
|
||||
now := c.sequenceTiming.now()
|
||||
if !now.Before(deadline) {
|
||||
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
|
||||
}
|
||||
|
||||
status, currentStockStatus, err := c.readSequenceStatus(ctx, operation)
|
||||
stockStatus = currentStockStatus
|
||||
if err != nil {
|
||||
return stockStatus, err
|
||||
}
|
||||
ready, err := preparationStatus(operation, status)
|
||||
if err != nil {
|
||||
return stockStatus, err
|
||||
}
|
||||
if ready {
|
||||
return stockStatus, nil
|
||||
}
|
||||
|
||||
now = c.sequenceTiming.now()
|
||||
if !now.Before(deadline) {
|
||||
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
|
||||
}
|
||||
if retryCommand != nil && !retried && !now.Before(halfway) {
|
||||
if err := retryCommand(ctx); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] retry command: %w", operation, err)
|
||||
}
|
||||
retried = true
|
||||
}
|
||||
|
||||
wait := sequencePollInterval
|
||||
if remaining := deadline.Sub(now); remaining < wait {
|
||||
wait = remaining
|
||||
}
|
||||
if err := c.sequenceTiming.wait(ctx, wait); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) prepareCardAtEncoder(ctx context.Context, operation string) (string, error) {
|
||||
status, stockStatus, err := c.readSequenceStatus(ctx, operation)
|
||||
if err != nil {
|
||||
return stockStatus, err
|
||||
}
|
||||
ready, err := preparationStatus(operation, status)
|
||||
if err != nil {
|
||||
return stockStatus, err
|
||||
}
|
||||
if ready {
|
||||
return stockStatus, nil
|
||||
}
|
||||
|
||||
if err := c.ToEncoder(ctx); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] to encoder: %w", funcName, err)
|
||||
return stockStatus, fmt.Errorf("[%s] to encoder: %w", operation, err)
|
||||
}
|
||||
|
||||
time.Sleep(delay)
|
||||
status, err = c.CheckStatus(ctx)
|
||||
if err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] re-check status: %w", funcName, err)
|
||||
}
|
||||
logStatus(status)
|
||||
stockStatus = stockTake(status)
|
||||
c.setStock(status)
|
||||
|
||||
return stockStatus, nil
|
||||
return c.pollForEncoderPosition(ctx, operation, c.ToEncoder)
|
||||
}
|
||||
|
||||
func (c *Client) DispenserFinal(ctx context.Context) (string, error) {
|
||||
const funcName = "DispenserFinal"
|
||||
stockStatus := ""
|
||||
// PrepareCurrentCard authoritatively places the card to be encoded at the encoder.
|
||||
func (c *Client) PrepareCurrentCard(ctx context.Context) (string, error) {
|
||||
return c.prepareCardAtEncoder(ctx, "PrepareCurrentCard")
|
||||
}
|
||||
|
||||
// DeliverCurrentCard presents the encoded card and confirms command acceptance.
|
||||
func (c *Client) DeliverCurrentCard(ctx context.Context) (string, error) {
|
||||
const operation = "DeliverCurrentCard"
|
||||
|
||||
if err := c.OutOfMouth(ctx); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] out of mouth: %w", funcName, err)
|
||||
return "", fmt.Errorf("[%s] out of mouth: %w", operation, err)
|
||||
}
|
||||
|
||||
time.Sleep(delay)
|
||||
status, err := c.CheckStatus(ctx)
|
||||
if err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] check status: %w", funcName, err)
|
||||
}
|
||||
logStatus(status)
|
||||
stockStatus = stockTake(status)
|
||||
c.setStock(status)
|
||||
|
||||
time.Sleep(delay)
|
||||
if err := c.ToEncoder(ctx); err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] to encoder: %w", funcName, err)
|
||||
}
|
||||
|
||||
time.Sleep(delay)
|
||||
status, err = c.CheckStatus(ctx)
|
||||
if err != nil {
|
||||
return stockStatus, fmt.Errorf("[%s] re-check status: %w", funcName, err)
|
||||
}
|
||||
logStatus(status)
|
||||
stockStatus = stockTake(status)
|
||||
c.setStock(status)
|
||||
|
||||
return stockStatus, nil
|
||||
return "", nil
|
||||
}
|
||||
|
||||
// BeginPrepareNextCard starts moving the next card to the encoder without waiting for readiness.
|
||||
func (c *Client) BeginPrepareNextCard(ctx context.Context) error {
|
||||
if err := c.ToEncoder(ctx); err != nil {
|
||||
return fmt.Errorf("[BeginPrepareNextCard] to encoder: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PrepareNextCard places a new card at the encoder for a later issuance attempt.
|
||||
func (c *Client) PrepareNextCard(ctx context.Context) (string, error) {
|
||||
return c.prepareCardAtEncoder(ctx, "PrepareNextCard")
|
||||
}
|
||||
@@ -0,0 +1,404 @@
|
||||
package dispenser
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type fakeSequenceDevice struct {
|
||||
statusResponses []cmdResp
|
||||
commandErrors map[cmdType][]error
|
||||
commands []cmdType
|
||||
}
|
||||
|
||||
func newSequenceTestClient(t *testing.T, statusResponses ...cmdResp) (*Client, *fakeSequenceDevice) {
|
||||
t.Helper()
|
||||
|
||||
device := &fakeSequenceDevice{
|
||||
statusResponses: append([]cmdResp(nil), statusResponses...),
|
||||
commandErrors: make(map[cmdType][]error),
|
||||
}
|
||||
now := time.Date(2026, time.July, 23, 12, 0, 0, 0, time.UTC)
|
||||
client := &Client{
|
||||
reqCh: make(chan cmdReq),
|
||||
done: make(chan struct{}),
|
||||
sequenceTiming: sequenceTiming{
|
||||
now: func() time.Time {
|
||||
return now
|
||||
},
|
||||
wait: func(ctx context.Context, duration time.Duration) error {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
default:
|
||||
now = now.Add(duration)
|
||||
return nil
|
||||
}
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case <-client.done:
|
||||
return
|
||||
case request := <-client.reqCh:
|
||||
device.commands = append(device.commands, request.typ)
|
||||
if request.typ == cmdStatus {
|
||||
if len(device.statusResponses) == 0 {
|
||||
request.respCh <- cmdResp{err: errors.New("unexpected status read")}
|
||||
continue
|
||||
}
|
||||
response := device.statusResponses[0]
|
||||
device.statusResponses = device.statusResponses[1:]
|
||||
request.respCh <- response
|
||||
continue
|
||||
}
|
||||
|
||||
var err error
|
||||
if queued := device.commandErrors[request.typ]; len(queued) > 0 {
|
||||
err = queued[0]
|
||||
device.commandErrors[request.typ] = queued[1:]
|
||||
}
|
||||
request.respCh <- cmdResp{err: err}
|
||||
}
|
||||
}
|
||||
}()
|
||||
t.Cleanup(client.Close)
|
||||
|
||||
return client, device
|
||||
}
|
||||
|
||||
func status(position byte) []byte {
|
||||
return []byte{0x30, 0x30, 0x30, position}
|
||||
}
|
||||
|
||||
func commandCount(commands []cmdType, target cmdType) int {
|
||||
count := 0
|
||||
for _, command := range commands {
|
||||
if command == target {
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardAcceptsEncoderPositionWithStaleDiagnostics(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
status []byte
|
||||
wantStock string
|
||||
}{
|
||||
{
|
||||
name: "dispense error and jam",
|
||||
status: []byte{0x30, 0x32, 0x32, 0x33},
|
||||
wantStock: "Card jammed",
|
||||
},
|
||||
{
|
||||
name: "supply diagnostics",
|
||||
status: []byte{0x32, 0x30, 0x31, 0x33},
|
||||
wantStock: "Card pre-empty",
|
||||
},
|
||||
{
|
||||
name: "combined stale jam and supply diagnostics",
|
||||
status: []byte{0x30, 0x32, 0x33, 0x33},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
var logOutput bytes.Buffer
|
||||
standardLogger := log.StandardLogger()
|
||||
previousOutput := standardLogger.Out
|
||||
standardLogger.SetOutput(&logOutput)
|
||||
t.Cleanup(func() {
|
||||
standardLogger.SetOutput(previousOutput)
|
||||
})
|
||||
|
||||
client, device := newSequenceTestClient(t, cmdResp{status: test.status})
|
||||
|
||||
stock, err := client.PrepareCurrentCard(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stock != test.wantStock {
|
||||
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
|
||||
t.Fatalf("to-encoder commands = %d, want 0", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 1 {
|
||||
t.Fatalf("status reads = %d, want 1", got)
|
||||
}
|
||||
logged := logOutput.String()
|
||||
if !strings.Contains(logged, "card confirmed at encoder") ||
|
||||
!strings.Contains(logged, statusDescription(test.status)) ||
|
||||
!strings.Contains(logged, "raw status") {
|
||||
t.Fatalf("encoder diagnostic log = %q", logged)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardPollingAllowsTransientMovementWithStaleErrors(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t,
|
||||
cmdResp{status: status(0x34)},
|
||||
cmdResp{status: []byte{0x31, 0x38, 0x32, 0x30}},
|
||||
cmdResp{status: []byte{0x30, 0x32, 0x32, 0x33}},
|
||||
)
|
||||
|
||||
stock, err := client.PrepareCurrentCard(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stock != "Card jammed" {
|
||||
t.Fatalf("stock status = %q, want Card jammed", stock)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
|
||||
t.Fatalf("to-encoder commands = %d, want 1", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 3 {
|
||||
t.Fatalf("status reads = %d, want 3", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardRejectsFailureWithoutEncoderOrMovement(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
response cmdResp
|
||||
wantError string
|
||||
wantStock string
|
||||
}{
|
||||
{
|
||||
name: "status read error",
|
||||
response: cmdResp{err: errors.New("serial read failed")},
|
||||
wantError: "serial read failed",
|
||||
},
|
||||
{
|
||||
name: "malformed status",
|
||||
response: cmdResp{status: []byte{0x30, 0x30, 0x31}},
|
||||
wantError: "malformed dispenser status",
|
||||
},
|
||||
{
|
||||
name: "unknown status",
|
||||
response: cmdResp{status: []byte{0x30, 0x30, 0x30, 0x39}},
|
||||
wantError: "unknown dispenser status",
|
||||
},
|
||||
{
|
||||
name: "jammed preparation",
|
||||
response: cmdResp{status: []byte{0x30, 0x30, 0x32, 0x34}},
|
||||
wantError: "Card jammed",
|
||||
wantStock: "Card jammed",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
client, _ := newSequenceTestClient(t, test.response)
|
||||
|
||||
stock, err := client.PrepareCurrentCard(context.Background())
|
||||
if err == nil || !strings.Contains(err.Error(), test.wantError) {
|
||||
t.Fatalf("error = %v, want containing %q", err, test.wantError)
|
||||
}
|
||||
if stock != test.wantStock {
|
||||
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardReturnsAuthoritativeEmptyWellError(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t, cmdResp{status: status(0x38)})
|
||||
|
||||
stock, err := client.PrepareCurrentCard(context.Background())
|
||||
if !errors.Is(err, ErrCardWellEmpty) {
|
||||
t.Fatalf("error = %v, want ErrCardWellEmpty", err)
|
||||
}
|
||||
if stock != "Card empty" {
|
||||
t.Fatalf("stock status = %q, want Card empty", stock)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
|
||||
t.Fatalf("to-encoder commands = %d, want 0", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliverCurrentCardSucceedsAfterCommandAcceptanceWithoutStatusPolling(t *testing.T) {
|
||||
staleStatus := []byte{0x30, 0x32, 0x32, 0x33}
|
||||
client, device := newSequenceTestClient(t, cmdResp{status: staleStatus})
|
||||
|
||||
stock, err := client.DeliverCurrentCard(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stock != "" {
|
||||
t.Fatalf("stock status = %q, want empty", stock)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdOutOfMouth); got != 1 {
|
||||
t.Fatalf("out-of-mouth commands = %d, want 1", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 0 {
|
||||
t.Fatalf("status reads = %d, want 0", got)
|
||||
}
|
||||
if len(device.statusResponses) != 1 {
|
||||
t.Fatalf("queued status responses = %d, want stale status unread", len(device.statusResponses))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliverCurrentCardRejectsCommandFailures(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
err error
|
||||
}{
|
||||
{name: "serial dispatch failure", err: errors.New("serial write failed")},
|
||||
{name: "invalid acknowledgement", err: errors.New("unexpected response status")},
|
||||
{name: "missing acknowledgement", err: errors.New("no response from dispenser")},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t)
|
||||
device.commandErrors[cmdOutOfMouth] = []error{test.err}
|
||||
|
||||
_, err := client.DeliverCurrentCard(context.Background())
|
||||
if err == nil || !strings.Contains(err.Error(), test.err.Error()) {
|
||||
t.Fatalf("error = %v, want containing %q", err, test.err)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdOutOfMouth); got != 1 {
|
||||
t.Fatalf("out-of-mouth commands = %d, want 1", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 0 {
|
||||
t.Fatalf("status reads = %d, want 0", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliverCurrentCardPreservesContextCancellation(t *testing.T) {
|
||||
client, _ := newSequenceTestClient(t)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
|
||||
_, err := client.DeliverCurrentCard(ctx)
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("error = %v, want context.Canceled", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardRetriesOnceThenTimesOut(t *testing.T) {
|
||||
responses := make([]cmdResp, 13)
|
||||
for index := range responses {
|
||||
responses[index] = cmdResp{status: status(0x34)}
|
||||
}
|
||||
client, device := newSequenceTestClient(t, responses...)
|
||||
|
||||
_, err := client.PrepareCurrentCard(context.Background())
|
||||
if err == nil || !strings.Contains(err.Error(), "timed out") {
|
||||
t.Fatalf("error = %v, want preparation timeout", err)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 2 {
|
||||
t.Fatalf("to-encoder commands = %d, want initial command plus one halfway retry", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 13 {
|
||||
t.Fatalf("status reads = %d, want 13", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCurrentCardPropagatesContextCancellation(t *testing.T) {
|
||||
client, _ := newSequenceTestClient(t,
|
||||
cmdResp{status: status(0x34)},
|
||||
cmdResp{status: status(0x34)},
|
||||
)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
client.sequenceTiming.wait = func(context.Context, time.Duration) error {
|
||||
cancel()
|
||||
return ctx.Err()
|
||||
}
|
||||
|
||||
_, err := client.PrepareCurrentCard(ctx)
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("error = %v, want context.Canceled", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBeginPrepareNextCardDispatchesWithoutReadinessPolling(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t)
|
||||
|
||||
if err := client.BeginPrepareNextCard(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
|
||||
t.Fatalf("to-encoder commands = %d, want 1", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 0 {
|
||||
t.Fatalf("status reads = %d, want 0", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBeginPrepareNextCardReturnsDispatchFailureWithoutPolling(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t)
|
||||
device.commandErrors[cmdToEncoder] = []error{errors.New("dispatch failed")}
|
||||
|
||||
err := client.BeginPrepareNextCard(context.Background())
|
||||
if err == nil || !strings.Contains(err.Error(), "dispatch failed") {
|
||||
t.Fatalf("error = %v, want dispatch failure", err)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
|
||||
t.Fatalf("to-encoder commands = %d, want 1", got)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdStatus); got != 0 {
|
||||
t.Fatalf("status reads = %d, want 0", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrepareCardAtEncoderRequiresConfirmedEncoderState(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
responses []cmdResp
|
||||
wantError string
|
||||
wantToEncoder int
|
||||
}{
|
||||
{
|
||||
name: "already at encoder",
|
||||
responses: []cmdResp{{status: status(0x33)}},
|
||||
wantToEncoder: 0,
|
||||
},
|
||||
{
|
||||
name: "moves ready card to encoder",
|
||||
responses: []cmdResp{
|
||||
{status: status(0x34)},
|
||||
{status: status(0x33)},
|
||||
},
|
||||
wantToEncoder: 1,
|
||||
},
|
||||
{
|
||||
name: "empty card well",
|
||||
responses: []cmdResp{{status: status(0x38)}},
|
||||
wantError: CardWellEmptyMessage,
|
||||
wantToEncoder: 0,
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
client, device := newSequenceTestClient(t, test.responses...)
|
||||
|
||||
_, err := client.PrepareNextCard(context.Background())
|
||||
if test.wantError == "" && err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if test.wantError != "" && (err == nil || !strings.Contains(err.Error(), test.wantError)) {
|
||||
t.Fatalf("error = %v, want containing %q", err, test.wantError)
|
||||
}
|
||||
if got := commandCount(device.commands, cmdToEncoder); got != test.wantToEncoder {
|
||||
t.Fatalf("to-encoder commands = %d, want %d", got, test.wantToEncoder)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,674 @@
|
||||
package dojo
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
BaseURL string
|
||||
APIKey string
|
||||
SoftwareHouseID string
|
||||
Version string
|
||||
TerminalID string
|
||||
}
|
||||
|
||||
type Client struct {
|
||||
baseURL string
|
||||
apiKey string
|
||||
version string
|
||||
softwareHouseID string
|
||||
terminalID string
|
||||
httpClient *http.Client
|
||||
}
|
||||
|
||||
const (
|
||||
dojoTerminalUnavailableStatus = "TERMINAL_UNAVAILABLE"
|
||||
dojoTerminalUnavailableMessage = "Payment terminal is unavailable"
|
||||
)
|
||||
|
||||
type httpResponseError struct {
|
||||
StatusCode int
|
||||
Body string
|
||||
}
|
||||
|
||||
func (e *httpResponseError) Error() string {
|
||||
return fmt.Sprintf("Dojo returned HTTP %d: %s", e.StatusCode, e.Body)
|
||||
}
|
||||
|
||||
type terminalSessionWithUpdates struct {
|
||||
terminalSessionResponse
|
||||
|
||||
NotificationEvents []terminalNotificationEvent `json:"notificationEvents"`
|
||||
StatusEvents []terminalStatusEvent `json:"statusEvents"`
|
||||
}
|
||||
|
||||
type terminalNotificationEvent struct {
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
NotificationType string `json:"notificationType"`
|
||||
}
|
||||
|
||||
type terminalStatusEvent struct {
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
type terminalDisplayEvent struct {
|
||||
createdAt time.Time
|
||||
code string
|
||||
sessionStatus string
|
||||
}
|
||||
|
||||
func NewClient(cfg Config) (*Client, error) {
|
||||
if cfg.BaseURL == "" {
|
||||
return nil, fmt.Errorf("dojo base_url is required")
|
||||
}
|
||||
if cfg.APIKey == "" {
|
||||
return nil, fmt.Errorf("dojo api_key is required")
|
||||
}
|
||||
if cfg.Version == "" {
|
||||
cfg.Version = "2026-02-27"
|
||||
}
|
||||
if cfg.SoftwareHouseID == "" {
|
||||
return nil, fmt.Errorf("dojo software_house_id is required")
|
||||
}
|
||||
if cfg.TerminalID == "" {
|
||||
return nil, fmt.Errorf("dojo terminal_id is required")
|
||||
}
|
||||
|
||||
return &Client{
|
||||
baseURL: strings.TrimRight(cfg.BaseURL, "/"),
|
||||
apiKey: cfg.APIKey,
|
||||
version: cfg.Version,
|
||||
softwareHouseID: cfg.SoftwareHouseID,
|
||||
terminalID: cfg.TerminalID,
|
||||
httpClient: &http.Client{Timeout: 30 * time.Second},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (c *Client) Sale(
|
||||
ctx context.Context,
|
||||
req paymentsvc.SaleRequest,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) (*paymentsvc.Result, error) {
|
||||
if req.Currency == "" {
|
||||
req.Currency = "GBP"
|
||||
}
|
||||
|
||||
sendPaymentStatus(onStatus, paymentstatus.Starting)
|
||||
|
||||
intent, err := c.createPaymentIntent(ctx, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
session, err := c.createTerminalSession(ctx, intent.ID)
|
||||
if err != nil {
|
||||
var responseErr *httpResponseError
|
||||
if errors.As(err, &responseErr) && responseErr.StatusCode == http.StatusConflict {
|
||||
log.WithFields(log.Fields{
|
||||
"provider": "Dojo",
|
||||
"operation": "createTerminalSession",
|
||||
"status": responseErr.StatusCode,
|
||||
"terminal_unavailable": true,
|
||||
}).Warn(dojoTerminalUnavailableMessage)
|
||||
|
||||
sendPaymentStatus(onStatus, paymentstatus.TerminalUnavailable)
|
||||
result := c.baseResult(req, nil)
|
||||
result.Status = dojoTerminalUnavailableStatus
|
||||
result.ErrorMessage = dojoTerminalUnavailableMessage
|
||||
return result, nil
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
session, err = c.waitForTerminalSession(ctx, session.ID, onStatus)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch strings.ToLower(session.Status) {
|
||||
case types.ResultCaptured, types.ResultSignatureAccepted:
|
||||
intent, err = c.getPaymentIntent(ctx, intent.ID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if strings.ToLower(intent.Status) != types.ResultCaptured {
|
||||
return nil, fmt.Errorf("Dojo terminal session is %s but payment intent is %s", session.Status, intent.Status)
|
||||
}
|
||||
result := c.mapCapturedResult(req, intent)
|
||||
result.CustomerReceipt = receiptToText(session.Receipt)
|
||||
return result, nil
|
||||
|
||||
case types.ResultCancelled, types.ResultCanceled, types.ResultDeclined, types.ResultExpired, types.ResultSignatureRejected:
|
||||
return c.mapTerminalFailure(req, session), nil
|
||||
|
||||
case types.ResultSignatureRequired:
|
||||
result := c.baseResult(req, session.PaymentDetails)
|
||||
result.Status = "SIGNATURE_VERIFICATION_REQUIRED"
|
||||
result.ErrorMessage = "Dojo signature verification is required but is not supported"
|
||||
return result, nil
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("unexpected final Dojo terminal session status %q", session.Status)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) createPaymentIntent(ctx context.Context, req paymentsvc.SaleRequest) (*paymentIntentResponse, error) {
|
||||
payload := createPaymentIntentRequest{
|
||||
Amount: money{
|
||||
Value: req.Amount,
|
||||
CurrencyCode: req.Currency,
|
||||
},
|
||||
Reference: dojoReference(req),
|
||||
CaptureMode: "Auto",
|
||||
}
|
||||
|
||||
var response paymentIntentResponse
|
||||
if err := c.doJSON(ctx, http.MethodPost, "/payment-intents", payload, false, &response); err != nil {
|
||||
return nil, fmt.Errorf("create Dojo payment intent: %w", err)
|
||||
}
|
||||
if response.ID == "" {
|
||||
return nil, fmt.Errorf("create Dojo payment intent: response did not contain id")
|
||||
}
|
||||
|
||||
return &response, nil
|
||||
}
|
||||
|
||||
func (c *Client) createTerminalSession(ctx context.Context, paymentIntentID string) (*terminalSessionResponse, error) {
|
||||
payload := createTerminalSessionRequest{
|
||||
TerminalID: c.terminalID,
|
||||
Details: terminalSessionDetails{
|
||||
SessionType: "Sale",
|
||||
Sale: terminalSessionSale{
|
||||
PaymentIntentID: paymentIntentID,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var response terminalSessionResponse
|
||||
if err := c.doJSON(ctx, http.MethodPost, "/terminal-sessions", payload, true, &response); err != nil {
|
||||
return nil, fmt.Errorf("create Dojo terminal session: %w", err)
|
||||
}
|
||||
if response.ID == "" {
|
||||
return nil, fmt.Errorf("create Dojo terminal session: response did not contain id")
|
||||
}
|
||||
|
||||
return &response, nil
|
||||
}
|
||||
|
||||
func (c *Client) waitForTerminalSession(
|
||||
ctx context.Context,
|
||||
terminalSessionID string,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) (*terminalSessionResponse, error) {
|
||||
ticker := time.NewTicker(time.Second)
|
||||
defer ticker.Stop()
|
||||
|
||||
notificationCount := 0
|
||||
statusCount := 0
|
||||
lastSessionStatus := ""
|
||||
signatureRejected := false
|
||||
|
||||
for {
|
||||
session, err := c.getTerminalSession(ctx, terminalSessionID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
log.Println("session status:", session.Status)
|
||||
|
||||
emitNewTerminalSessionEvents(
|
||||
session,
|
||||
¬ificationCount,
|
||||
&statusCount,
|
||||
&lastSessionStatus,
|
||||
onStatus,
|
||||
)
|
||||
|
||||
currentStatus := strings.ToLower(session.Status)
|
||||
if currentStatus != lastSessionStatus {
|
||||
lastSessionStatus = currentStatus
|
||||
sendPaymentStatus(
|
||||
onStatus,
|
||||
mapDojoSessionStatus(session.Status),
|
||||
)
|
||||
}
|
||||
|
||||
switch currentStatus {
|
||||
case types.ResultInitiateRequested,
|
||||
types.ResultInitiated,
|
||||
types.ResultAuthorized,
|
||||
types.ResultCancelRequested:
|
||||
|
||||
case types.ResultSignatureRequired:
|
||||
if !signatureRejected {
|
||||
sendPaymentStatus(
|
||||
onStatus,
|
||||
paymentstatus.SignatureRejecting,
|
||||
)
|
||||
|
||||
rejectedSession, err := c.rejectSignature(
|
||||
ctx,
|
||||
terminalSessionID,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
signatureRejected = true
|
||||
|
||||
if rejectedSession != nil {
|
||||
rejectedStatus := strings.ToLower(
|
||||
rejectedSession.Status,
|
||||
)
|
||||
|
||||
if rejectedStatus != lastSessionStatus {
|
||||
lastSessionStatus = rejectedStatus
|
||||
sendPaymentStatus(
|
||||
onStatus,
|
||||
mapDojoSessionStatus(
|
||||
rejectedSession.Status,
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
switch rejectedStatus {
|
||||
case types.ResultCaptured,
|
||||
types.ResultCancelled,
|
||||
types.ResultCanceled,
|
||||
types.ResultDeclined,
|
||||
types.ResultExpired,
|
||||
types.ResultSignatureAccepted,
|
||||
types.ResultSignatureRejected:
|
||||
return rejectedSession, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
case types.ResultCaptured,
|
||||
types.ResultCancelled,
|
||||
types.ResultCanceled,
|
||||
types.ResultDeclined,
|
||||
types.ResultExpired,
|
||||
types.ResultSignatureAccepted,
|
||||
types.ResultSignatureRejected:
|
||||
return &session.terminalSessionResponse, nil
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf(
|
||||
"unexpected Dojo terminal session status %q",
|
||||
session.Status,
|
||||
)
|
||||
}
|
||||
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
|
||||
case <-ticker.C:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func emitNewTerminalSessionEvents(
|
||||
session *terminalSessionWithUpdates,
|
||||
notificationCount *int,
|
||||
statusCount *int,
|
||||
lastSessionStatus *string,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) {
|
||||
if *notificationCount > len(session.NotificationEvents) {
|
||||
*notificationCount = len(session.NotificationEvents)
|
||||
}
|
||||
if *statusCount > len(session.StatusEvents) {
|
||||
*statusCount = len(session.StatusEvents)
|
||||
}
|
||||
|
||||
newEventCount := len(session.NotificationEvents) - *notificationCount +
|
||||
len(session.StatusEvents) - *statusCount
|
||||
events := make([]terminalDisplayEvent, 0, newEventCount)
|
||||
|
||||
// Add status events first so a notification wins when timestamps are equal.
|
||||
for *statusCount < len(session.StatusEvents) {
|
||||
event := session.StatusEvents[*statusCount]
|
||||
*statusCount = *statusCount + 1
|
||||
|
||||
events = append(events, terminalDisplayEvent{
|
||||
createdAt: event.CreatedAt,
|
||||
code: mapDojoSessionStatus(event.Status),
|
||||
sessionStatus: event.Status,
|
||||
})
|
||||
}
|
||||
|
||||
for *notificationCount < len(session.NotificationEvents) {
|
||||
event := session.NotificationEvents[*notificationCount]
|
||||
*notificationCount = *notificationCount + 1
|
||||
|
||||
events = append(events, terminalDisplayEvent{
|
||||
createdAt: event.CreatedAt,
|
||||
code: mapDojoNotification(event.NotificationType),
|
||||
})
|
||||
}
|
||||
|
||||
sort.SliceStable(events, func(i, j int) bool {
|
||||
return events[i].createdAt.Before(events[j].createdAt)
|
||||
})
|
||||
|
||||
for _, event := range events {
|
||||
if event.sessionStatus != "" {
|
||||
*lastSessionStatus = strings.ToLower(event.sessionStatus)
|
||||
}
|
||||
|
||||
sendPaymentStatus(onStatus, event.code)
|
||||
}
|
||||
}
|
||||
|
||||
func sendPaymentStatus(
|
||||
handler paymentsvc.StatusHandler,
|
||||
code string,
|
||||
) {
|
||||
if handler == nil || code == "" {
|
||||
return
|
||||
}
|
||||
|
||||
handler(paymentsvc.StatusUpdate{
|
||||
Code: code,
|
||||
})
|
||||
}
|
||||
|
||||
func mapDojoNotification(notification string) string {
|
||||
switch notification {
|
||||
case "PresentCard":
|
||||
return paymentstatus.PresentCard
|
||||
|
||||
case "InsertCard":
|
||||
return paymentstatus.InsertCard
|
||||
|
||||
case "SwipeCard":
|
||||
return paymentstatus.SwipeCard
|
||||
|
||||
case "EnterPin":
|
||||
return paymentstatus.EnterPIN
|
||||
|
||||
case "RemoveCard":
|
||||
return paymentstatus.RemoveCard
|
||||
|
||||
case "PleaseWait":
|
||||
return paymentstatus.PleaseWait
|
||||
|
||||
default:
|
||||
return dojoFallbackStatusCode(
|
||||
paymentstatus.DojoNotificationPrefix,
|
||||
notification,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func mapDojoSessionStatus(status string) string {
|
||||
switch strings.ToLower(status) {
|
||||
case types.ResultInitiateRequested:
|
||||
return paymentstatus.Starting
|
||||
|
||||
case types.ResultInitiated:
|
||||
return paymentstatus.Started
|
||||
|
||||
case types.ResultAuthorized:
|
||||
return paymentstatus.Authorized
|
||||
|
||||
case types.ResultCancelRequested:
|
||||
return paymentstatus.Cancelling
|
||||
|
||||
case types.ResultSignatureRequired:
|
||||
return paymentstatus.SignatureRequired
|
||||
|
||||
case types.ResultCaptured, types.ResultSignatureAccepted:
|
||||
return paymentstatus.Approved
|
||||
|
||||
case types.ResultCancelled, types.ResultCanceled:
|
||||
return paymentstatus.Cancelled
|
||||
|
||||
case types.ResultDeclined:
|
||||
return paymentstatus.Declined
|
||||
|
||||
case types.ResultExpired:
|
||||
return paymentstatus.Expired
|
||||
|
||||
case types.ResultSignatureRejected:
|
||||
return paymentstatus.SignatureRejected
|
||||
|
||||
default:
|
||||
return dojoFallbackStatusCode(
|
||||
paymentstatus.DojoStatusPrefix,
|
||||
status,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func dojoFallbackStatusCode(prefix, value string) string {
|
||||
value = strings.TrimSpace(value)
|
||||
if value == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
replacer := strings.NewReplacer(
|
||||
" ", "_",
|
||||
"-", "_",
|
||||
)
|
||||
|
||||
return prefix + strings.ToUpper(replacer.Replace(value))
|
||||
}
|
||||
|
||||
func (c *Client) rejectSignature(ctx context.Context, terminalSessionID string) (*terminalSessionResponse, error) {
|
||||
payload := signatureVerificationRequest{
|
||||
Accepted: false,
|
||||
}
|
||||
|
||||
var response terminalSessionResponse
|
||||
path := "/terminal-sessions/" + url.PathEscape(terminalSessionID) + "/signature"
|
||||
|
||||
if err := c.doJSON(ctx, http.MethodPut, path, payload, true, &response); err != nil {
|
||||
return nil, fmt.Errorf("reject Dojo signature verification: %w", err)
|
||||
}
|
||||
|
||||
return &response, nil
|
||||
}
|
||||
|
||||
func (c *Client) getTerminalSession(
|
||||
ctx context.Context,
|
||||
terminalSessionID string,
|
||||
) (*terminalSessionWithUpdates, error) {
|
||||
var response terminalSessionWithUpdates
|
||||
path := "/terminal-sessions/" + url.PathEscape(terminalSessionID)
|
||||
if err := c.doJSON(ctx, http.MethodGet, path, nil, true, &response); err != nil {
|
||||
return nil, fmt.Errorf("get Dojo terminal session: %w", err)
|
||||
}
|
||||
return &response, nil
|
||||
}
|
||||
|
||||
func (c *Client) getPaymentIntent(ctx context.Context, paymentIntentID string) (*paymentIntentResponse, error) {
|
||||
var response paymentIntentResponse
|
||||
path := "/payment-intents/" + url.PathEscape(paymentIntentID) + "?returnCanceled=true"
|
||||
if err := c.doJSON(ctx, http.MethodGet, path, nil, false, &response); err != nil {
|
||||
return nil, fmt.Errorf("get Dojo payment intent: %w", err)
|
||||
}
|
||||
return &response, nil
|
||||
}
|
||||
|
||||
func (c *Client) mapCapturedResult(req paymentsvc.SaleRequest, intent *paymentIntentResponse) *paymentsvc.Result {
|
||||
result := c.baseResult(req, intent.PaymentDetails)
|
||||
result.Success = true
|
||||
result.Status = "APPROVED"
|
||||
|
||||
if intent.Amount.Value != 0 {
|
||||
result.Amount = intent.Amount.Value
|
||||
}
|
||||
if intent.Amount.CurrencyCode != "" {
|
||||
result.Currency = intent.Amount.CurrencyCode
|
||||
}
|
||||
if result.Message == "" {
|
||||
result.Message = "Payment approved"
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
func (c *Client) mapTerminalFailure(req paymentsvc.SaleRequest, session *terminalSessionResponse) *paymentsvc.Result {
|
||||
result := c.baseResult(req, session.PaymentDetails)
|
||||
result.Status = strings.ToUpper(session.Status)
|
||||
result.ErrorMessage = "Dojo terminal session ended with status " + session.Status
|
||||
result.CustomerReceipt = receiptToText(session.Receipt)
|
||||
return result
|
||||
}
|
||||
|
||||
func (c *Client) baseResult(req paymentsvc.SaleRequest, details *paymentDetails) *paymentsvc.Result {
|
||||
result := &paymentsvc.Result{
|
||||
RequestID: req.RequestID,
|
||||
Operation: "SALE",
|
||||
Amount: req.Amount,
|
||||
Currency: req.Currency,
|
||||
DeviceUsed: c.terminalID,
|
||||
DeviceType: "Dojo Terminal",
|
||||
}
|
||||
|
||||
if details == nil {
|
||||
return result
|
||||
}
|
||||
|
||||
result.TransactionID = details.TransactionID
|
||||
result.ReferenceNumber = req.RequestID
|
||||
result.AuthCode = details.AuthCode
|
||||
result.Message = details.Message
|
||||
result.CardNumber = details.Card.CardNumber
|
||||
result.CardType = details.Card.CardType
|
||||
result.ExpiryDate = details.Card.ExpiryDate
|
||||
result.LastFourDigits = details.Card.Last4PAN
|
||||
if result.LastFourDigits == "" {
|
||||
result.LastFourDigits = lastFour(details.Card.CardNumber)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
func (c *Client) doJSON(ctx context.Context, method, path string, payload any, terminalRequest bool, target any) error {
|
||||
var body io.Reader
|
||||
if payload != nil {
|
||||
encoded, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("encode request: %w", err)
|
||||
}
|
||||
body = bytes.NewReader(encoded)
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, method, c.baseURL+path, body)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create request: %w", err)
|
||||
}
|
||||
|
||||
req.Header.Set("Authorization", "Basic "+c.apiKey)
|
||||
req.Header.Set("Version", c.version)
|
||||
req.Header.Set("Accept", "application/json")
|
||||
if payload != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
if terminalRequest {
|
||||
req.Header.Set("software-house-id", c.softwareHouseID)
|
||||
}
|
||||
|
||||
resp, err := c.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("send request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
responseBody, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return fmt.Errorf("read response: %w", err)
|
||||
}
|
||||
// log.Println("Dojo payment result raw:", string(responseBody))
|
||||
if resp.StatusCode < http.StatusOK ||
|
||||
resp.StatusCode >= http.StatusMultipleChoices {
|
||||
return &httpResponseError{
|
||||
StatusCode: resp.StatusCode,
|
||||
Body: strings.TrimSpace(string(responseBody)),
|
||||
}
|
||||
}
|
||||
|
||||
if target == nil || len(responseBody) == 0 {
|
||||
return nil
|
||||
}
|
||||
if err := json.Unmarshal(responseBody, target); err != nil {
|
||||
return fmt.Errorf("decode response: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func dojoReference(req paymentsvc.SaleRequest) string {
|
||||
reference := req.RequestID
|
||||
if reference == "" {
|
||||
reference = req.Reference
|
||||
}
|
||||
|
||||
runes := []rune(reference)
|
||||
if len(runes) > 60 {
|
||||
runes = runes[:60]
|
||||
}
|
||||
return string(runes)
|
||||
}
|
||||
|
||||
func receiptToText(receipt *receipt) string {
|
||||
if receipt == nil {
|
||||
return ""
|
||||
}
|
||||
|
||||
var builder strings.Builder
|
||||
|
||||
for _, line := range receipt.Lines {
|
||||
if line.LineType != "Text" || line.Text == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
builder.WriteString(normalizeReceiptText(line.Text.Value))
|
||||
builder.WriteByte('\n')
|
||||
}
|
||||
|
||||
return builder.String()
|
||||
}
|
||||
|
||||
func lastFour(cardNumber string) string {
|
||||
digits := make([]byte, 0, len(cardNumber))
|
||||
for i := 0; i < len(cardNumber); i++ {
|
||||
if cardNumber[i] >= '0' && cardNumber[i] <= '9' {
|
||||
digits = append(digits, cardNumber[i])
|
||||
}
|
||||
}
|
||||
if len(digits) <= 4 {
|
||||
return string(digits)
|
||||
}
|
||||
return string(digits[len(digits)-4:])
|
||||
}
|
||||
|
||||
func normalizeReceiptText(value string) string {
|
||||
replacer := strings.NewReplacer(
|
||||
"£", "GBP ",
|
||||
"€", "EUR ",
|
||||
"$", "USD ",
|
||||
)
|
||||
|
||||
return replacer.Replace(value)
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
package dojo
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"reflect"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
const terminalUnavailableBody = `{"detail":"the terminal is either offline or currently in use","errors":{},"status":409,"title":"terminal unavailable","traceId":"trace-secret","type":"https://docs.dojo.tech/problems/terminal-unavailable"}`
|
||||
|
||||
func TestDoJSONReturnsStructuredHTTPResponseError(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
w.WriteHeader(http.StatusConflict)
|
||||
_, _ = w.Write([]byte(" " + terminalUnavailableBody + " "))
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newDojoTestClient(t, server)
|
||||
err := client.doJSON(context.Background(), http.MethodPost, "/payment-intents", nil, false, nil)
|
||||
|
||||
var responseErr *httpResponseError
|
||||
if !errors.As(err, &responseErr) {
|
||||
t.Fatalf("error = %T %v, want *httpResponseError", err, err)
|
||||
}
|
||||
if responseErr.StatusCode != http.StatusConflict {
|
||||
t.Fatalf("StatusCode = %d, want %d", responseErr.StatusCode, http.StatusConflict)
|
||||
}
|
||||
if responseErr.Body != terminalUnavailableBody {
|
||||
t.Fatalf("Body = %q, want retained trimmed response", responseErr.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaleMapsCreateTerminalSessionConflictToTerminalUnavailable(t *testing.T) {
|
||||
var paymentIntentRequests atomic.Int32
|
||||
var terminalSessionRequests atomic.Int32
|
||||
var unexpectedRequests atomic.Int32
|
||||
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
switch {
|
||||
case r.Method == http.MethodPost && r.URL.Path == "/payment-intents":
|
||||
paymentIntentRequests.Add(1)
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = fmt.Fprintln(w, `{"id":"intent-123"}`)
|
||||
case r.Method == http.MethodPost && r.URL.Path == "/terminal-sessions":
|
||||
terminalSessionRequests.Add(1)
|
||||
w.Header().Set("Content-Type", "application/problem+json")
|
||||
w.WriteHeader(http.StatusConflict)
|
||||
_, _ = fmt.Fprintln(w, terminalUnavailableBody)
|
||||
default:
|
||||
unexpectedRequests.Add(1)
|
||||
http.Error(w, "unexpected request", http.StatusInternalServerError)
|
||||
}
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newDojoTestClient(t, server)
|
||||
request := paymentsvc.SaleRequest{
|
||||
RequestID: "REQ-123",
|
||||
Reference: "BOOKING-123",
|
||||
Amount: 10852,
|
||||
Currency: "GBP",
|
||||
}
|
||||
var statuses []string
|
||||
result, err := client.Sale(context.Background(), request, func(update paymentsvc.StatusUpdate) {
|
||||
statuses = append(statuses, update.Code)
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result == nil {
|
||||
t.Fatal("Sale returned nil result")
|
||||
}
|
||||
if result.Success || result.Status == "APPROVED" {
|
||||
t.Fatalf("result was accidentally successful: %+v", result)
|
||||
}
|
||||
if result.Status != dojoTerminalUnavailableStatus || result.ErrorMessage != dojoTerminalUnavailableMessage {
|
||||
t.Fatalf("terminal-unavailable result = %+v", result)
|
||||
}
|
||||
if result.RequestID != request.RequestID ||
|
||||
result.Operation != "SALE" ||
|
||||
result.Amount != request.Amount ||
|
||||
result.Currency != request.Currency ||
|
||||
result.DeviceUsed != "terminal-1" ||
|
||||
result.DeviceType != "Dojo Terminal" {
|
||||
t.Fatalf("base result fields were not retained: %+v", result)
|
||||
}
|
||||
if result.TransactionID != "" || result.CustomerReceipt != "" || result.MerchantReceipt != "" {
|
||||
t.Fatalf("terminal-unavailable result invented transaction data: %+v", result)
|
||||
}
|
||||
if !reflect.DeepEqual(statuses, []string{paymentstatus.Starting, paymentstatus.TerminalUnavailable}) {
|
||||
t.Fatalf("statuses = %#v", statuses)
|
||||
}
|
||||
if paymentIntentRequests.Load() != 1 || terminalSessionRequests.Load() != 1 || unexpectedRequests.Load() != 0 {
|
||||
t.Fatalf(
|
||||
"requests: intent=%d terminal=%d unexpected=%d",
|
||||
paymentIntentRequests.Load(),
|
||||
terminalSessionRequests.Load(),
|
||||
unexpectedRequests.Load(),
|
||||
)
|
||||
}
|
||||
|
||||
resultText := fmt.Sprintf("%+v", result)
|
||||
for _, forbidden := range []string{"offline or currently in use", "trace-secret", "docs.dojo.tech", terminalUnavailableBody} {
|
||||
if strings.Contains(resultText, forbidden) {
|
||||
t.Fatalf("result exposed %q: %s", forbidden, resultText)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaleDoesNotClassifyPaymentIntentConflictAsTerminalUnavailable(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path != "/payment-intents" {
|
||||
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
||||
}
|
||||
w.WriteHeader(http.StatusConflict)
|
||||
_, _ = fmt.Fprintln(w, terminalUnavailableBody)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newDojoTestClient(t, server)
|
||||
var statuses []string
|
||||
result, err := client.Sale(context.Background(), paymentsvc.SaleRequest{
|
||||
RequestID: "REQ-123",
|
||||
Amount: 10852,
|
||||
Currency: "GBP",
|
||||
}, func(update paymentsvc.StatusUpdate) {
|
||||
statuses = append(statuses, update.Code)
|
||||
})
|
||||
|
||||
if result != nil || err == nil {
|
||||
t.Fatalf("Sale result/error = %+v/%v, want nil generic error", result, err)
|
||||
}
|
||||
var responseErr *httpResponseError
|
||||
if !errors.As(err, &responseErr) || responseErr.StatusCode != http.StatusConflict {
|
||||
t.Fatalf("error = %T %v, want wrapped HTTP 409", err, err)
|
||||
}
|
||||
if !reflect.DeepEqual(statuses, []string{paymentstatus.Starting}) {
|
||||
t.Fatalf("statuses = %#v, want only PAYMENT_STARTING", statuses)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaleRetainsGenericCreateTerminalSessionErrors(t *testing.T) {
|
||||
for _, statusCode := range []int{http.StatusBadRequest, http.StatusBadGateway} {
|
||||
t.Run(http.StatusText(statusCode), func(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
switch r.URL.Path {
|
||||
case "/payment-intents":
|
||||
_, _ = fmt.Fprintln(w, `{"id":"intent-123"}`)
|
||||
case "/terminal-sessions":
|
||||
w.WriteHeader(statusCode)
|
||||
_, _ = fmt.Fprintln(w, `{"detail":"provider failure"}`)
|
||||
default:
|
||||
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
||||
}
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newDojoTestClient(t, server)
|
||||
result, err := client.Sale(context.Background(), paymentsvc.SaleRequest{
|
||||
RequestID: "REQ-123",
|
||||
Amount: 10852,
|
||||
Currency: "GBP",
|
||||
}, nil)
|
||||
|
||||
if result != nil || err == nil {
|
||||
t.Fatalf("Sale result/error = %+v/%v, want nil generic error", result, err)
|
||||
}
|
||||
var responseErr *httpResponseError
|
||||
if !errors.As(err, &responseErr) || responseErr.StatusCode != statusCode {
|
||||
t.Fatalf("error = %T %v, want wrapped HTTP %d", err, err, statusCode)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func newDojoTestClient(t *testing.T, server *httptest.Server) *Client {
|
||||
t.Helper()
|
||||
client, err := NewClient(Config{
|
||||
BaseURL: server.URL,
|
||||
APIKey: "test-api-key",
|
||||
SoftwareHouseID: "software-house-1",
|
||||
TerminalID: "terminal-1",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
client.httpClient = server.Client()
|
||||
return client
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package dojo
|
||||
|
||||
type money struct {
|
||||
Value int64 `json:"value"`
|
||||
CurrencyCode string `json:"currencyCode"`
|
||||
}
|
||||
|
||||
type createPaymentIntentRequest struct {
|
||||
Amount money `json:"amount"`
|
||||
Reference string `json:"reference"`
|
||||
CaptureMode string `json:"captureMode"`
|
||||
}
|
||||
|
||||
type createTerminalSessionRequest struct {
|
||||
TerminalID string `json:"terminalId"`
|
||||
Details terminalSessionDetails `json:"details"`
|
||||
}
|
||||
|
||||
type terminalSessionDetails struct {
|
||||
SessionType string `json:"sessionType"`
|
||||
Sale terminalSessionSale `json:"sale"`
|
||||
}
|
||||
|
||||
type terminalSessionSale struct {
|
||||
PaymentIntentID string `json:"paymentIntentId"`
|
||||
}
|
||||
|
||||
type signatureVerificationRequest struct {
|
||||
Accepted bool `json:"accepted"`
|
||||
}
|
||||
|
||||
type terminalSessionResponse struct {
|
||||
ID string `json:"id"`
|
||||
Status string `json:"status"`
|
||||
TerminalID string `json:"terminalId"`
|
||||
PaymentDetails *paymentDetails `json:"paymentDetails"`
|
||||
Receipt *receipt `json:"receipt,omitempty"`
|
||||
}
|
||||
|
||||
type receipt struct {
|
||||
Lines []receiptLine `json:"lines"`
|
||||
}
|
||||
|
||||
type receiptLine struct {
|
||||
LineType string `json:"lineType"`
|
||||
Text *receiptText `json:"text,omitempty"`
|
||||
}
|
||||
|
||||
type receiptText struct {
|
||||
Align string `json:"align"`
|
||||
EmphasisBold bool `json:"emphasisBold"`
|
||||
Size string `json:"size"`
|
||||
Value string `json:"value"`
|
||||
}
|
||||
|
||||
type paymentIntentResponse struct {
|
||||
ID string `json:"id"`
|
||||
Status string `json:"status"`
|
||||
Reference string `json:"reference"`
|
||||
Amount money `json:"amount"`
|
||||
PaymentDetails *paymentDetails `json:"paymentDetails"`
|
||||
}
|
||||
|
||||
type paymentDetails struct {
|
||||
TransactionID string `json:"transactionId"`
|
||||
TransactionDateTime string `json:"transactionDateTime"`
|
||||
Message string `json:"message"`
|
||||
AuthCode string `json:"authCode"`
|
||||
Card dojoCard `json:"card"`
|
||||
}
|
||||
|
||||
type dojoCard struct {
|
||||
CardNumber string `json:"cardNumber"`
|
||||
CardName string `json:"cardName"`
|
||||
ExpiryDate string `json:"expiryDate"`
|
||||
CardType string `json:"cardType"`
|
||||
CardFundingType string `json:"cardFundingType"`
|
||||
Last4PAN string `json:"last4PAN"`
|
||||
EntryMode string `json:"entryMode"`
|
||||
VerificationMethod string `json:"verificationMethod"`
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import (
|
||||
"os"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
@@ -28,3 +29,8 @@ func FatalError(err error) {
|
||||
fmt.Scanln()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
func FatalErrorWithMail(hotel string, kiosk int, title string, err error) {
|
||||
mail.SendEmailOnError(hotel, kiosk, title, err.Error())
|
||||
FatalError(err)
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
)
|
||||
|
||||
type creditCallPreauthRequest struct {
|
||||
Amount string `json:"amount"`
|
||||
TransactionType string `json:"transactionType"`
|
||||
CheckoutDate string `json:"checkoutDate"`
|
||||
}
|
||||
|
||||
func (app *App) streamCreditCallPreauth(w http.ResponseWriter, r *http.Request) {
|
||||
app.streamCreditCall(w, r, true)
|
||||
}
|
||||
|
||||
// executeCreditCallPreauth finalizes the existing unconfirmed transaction.
|
||||
// The outcome container and its wire projections are shared with SALE; its execution is not.
|
||||
func (app *App) executeCreditCallPreauth(ctx context.Context, request cmstypes.TransactionRec,
|
||||
start func(*http.Client) (creditcall.TransactionResultXML, error)) creditCallSaleOutcome {
|
||||
const op = logging.Op("takePreauthorization")
|
||||
outcome := creditCallSaleOutcome{
|
||||
HTTPStatus: http.StatusBadGateway,
|
||||
Status: cmstypes.StatusRec{Code: http.StatusInternalServerError, Message: "500 Internal server error"},
|
||||
}
|
||||
transaction, err := start(app.creditCallClient())
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Preauth processing error", string(op), "", "", 0)
|
||||
outcome.FailureType = types.ResultError
|
||||
outcome.FailureDescription = "No response from payment processor"
|
||||
return outcome
|
||||
}
|
||||
var result creditcall.PaymentResult
|
||||
result.FillFromTransactionResult(transaction)
|
||||
app.printCreditCallReceipt(result.CardholderReceipt)
|
||||
approved, persist := creditcall.PreauthDecision(result.Fields)
|
||||
outcome.HTTPStatus = http.StatusOK
|
||||
outcome.Status = result.Status
|
||||
outcome.Payment = result
|
||||
outcome.Approved = approved
|
||||
outcome.FailureType = result.Fields[types.TransactionResult]
|
||||
outcome.FailureDescription = result.Fields[types.Errors]
|
||||
if persist {
|
||||
go app.persistPreauth(ctx, result.Fields, request.CheckoutDate)
|
||||
}
|
||||
return outcome
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"database/sql/driver"
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"reflect"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
type preauthTestConnector struct {
|
||||
inserts chan []driver.NamedValue
|
||||
count atomic.Int32
|
||||
}
|
||||
|
||||
func (c *preauthTestConnector) Connect(context.Context) (driver.Conn, error) {
|
||||
return &preauthTestConn{c}, nil
|
||||
}
|
||||
func (c *preauthTestConnector) Driver() driver.Driver { return preauthTestDriver{c} }
|
||||
|
||||
type preauthTestDriver struct{ c *preauthTestConnector }
|
||||
|
||||
func (d preauthTestDriver) Open(string) (driver.Conn, error) { return &preauthTestConn{d.c}, nil }
|
||||
|
||||
type preauthTestConn struct{ c *preauthTestConnector }
|
||||
|
||||
func (*preauthTestConn) Prepare(string) (driver.Stmt, error) {
|
||||
return nil, errors.New("unexpected prepare")
|
||||
}
|
||||
func (*preauthTestConn) Close() error { return nil }
|
||||
func (*preauthTestConn) Begin() (driver.Tx, error) { return nil, errors.New("unexpected begin") }
|
||||
func (*preauthTestConn) Ping(context.Context) error { return nil }
|
||||
func (c *preauthTestConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
|
||||
if ctx.Err() != nil {
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
if !strings.Contains(query, "INSERT INTO dbo.Preauthorizations") {
|
||||
return nil, errors.New("unexpected SQL")
|
||||
}
|
||||
c.c.count.Add(1)
|
||||
c.c.inserts <- append([]driver.NamedValue(nil), args...)
|
||||
return driver.RowsAffected(1), nil
|
||||
}
|
||||
func preauthTestDatabase(t *testing.T, app *App) *preauthTestConnector {
|
||||
t.Helper()
|
||||
c := &preauthTestConnector{inserts: make(chan []driver.NamedValue, 4)}
|
||||
app.db = sql.OpenDB(c)
|
||||
app.cfg.LogDir = t.TempDir()
|
||||
t.Cleanup(func() { app.db.Close() })
|
||||
return c
|
||||
}
|
||||
func waitPreauthInsert(t *testing.T, c *preauthTestConnector) map[string]any {
|
||||
t.Helper()
|
||||
select {
|
||||
case args := <-c.inserts:
|
||||
result := map[string]any{}
|
||||
for _, arg := range args {
|
||||
result[arg.Name] = arg.Value
|
||||
}
|
||||
return result
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("preauth persistence did not reach SQL")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func preauthLegacyRequest(amount, kind, checkout string) *http.Request {
|
||||
body, _ := xml.Marshal(cmstypes.TransactionRec{AmountMinorUnits: amount, TransactionType: kind, CheckoutDate: checkout})
|
||||
r := httptest.NewRequest(http.MethodPost, "/takepreauth", strings.NewReader(string(body)))
|
||||
r.Header.Set("Content-Type", "text/xml")
|
||||
return r
|
||||
}
|
||||
|
||||
func TestCreditCallPreauthLegacyCharacterization(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, amount, requestType, result, resultType, total string
|
||||
save, approved bool
|
||||
}{
|
||||
{"positive", "12000", "Sale", "APPROVED", "SALE", "3100", true, true},
|
||||
{"declined", "12000", "Sale", "DECLINED", "SALE", "", false, false},
|
||||
{"verification", "", "AccountVerification", "APPROVED", "ACCOUNT VERIFICATION", "", false, true},
|
||||
{"verification failure", "", "AccountVerification", "DECLINED", "ACCOUNT VERIFICATION", "", false, false},
|
||||
{"unexpected type", "12000", "Sale", "APPROVED", "Refund", "", false, false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
var starts, prints int
|
||||
checkout := ""
|
||||
if tc.amount != "" {
|
||||
checkout = "2026-09-11 00:00:00 +0000"
|
||||
}
|
||||
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.resultType, types.Reference: "preauth-ref", types.PanMasked: "************1133", types.CardType: "Visa", types.ExpiryDate: "1228", types.CardHash: "card-hash", types.CardReference: "card-reference", types.ReceiptDataCardholder: "receipt"}
|
||||
if tc.total != "" {
|
||||
fields[types.TotalAmount] = tc.total
|
||||
}
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
starts++
|
||||
if r.URL.Path != "/start-transaction/" {
|
||||
t.Errorf("PREAUTH upstream path=%s, want start only", r.URL.Path)
|
||||
}
|
||||
var input cmstypes.TransactionRec
|
||||
if err := xml.NewDecoder(r.Body).Decode(&input); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if input.AmountMinorUnits != tc.amount || input.TransactionType != tc.requestType || input.CheckoutDate != checkout {
|
||||
t.Errorf("PREAUTH input=%+v, want amount=%q type=%q checkout=%q", input, tc.amount, tc.requestType, checkout)
|
||||
}
|
||||
// Legacy ignores upstream HTTP status when XML contains a result.
|
||||
w.WriteHeader(http.StatusBadGateway)
|
||||
io.WriteString(w, chipDNAFixture(t, fields))
|
||||
})
|
||||
c := preauthTestDatabase(t, app)
|
||||
app.creditCallReceipt = func(receipt string) {
|
||||
prints++
|
||||
if receipt != "receipt" {
|
||||
t.Errorf("receipt=%q, want receipt", receipt)
|
||||
}
|
||||
}
|
||||
recorder := httptest.NewRecorder()
|
||||
app.takePreauthorization(recorder, preauthLegacyRequest(tc.amount, tc.requestType, checkout))
|
||||
var response cmstypes.ResponseRec
|
||||
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if recorder.Code != 200 || response.Status.Code != 200 || starts != 1 || prints != 1 || strings.HasPrefix(response.Data, "/successful?") != tc.approved {
|
||||
t.Errorf("PREAUTH response=%+v HTTP=%d starts=%d prints=%d, want approved=%t one start/receipt", response, recorder.Code, starts, prints, tc.approved)
|
||||
}
|
||||
if tc.save {
|
||||
got := waitPreauthInsert(t, c)
|
||||
if got["TotalMinorUnits"] != "3100" || got["TxnReference"] != "preauth-ref" {
|
||||
t.Errorf("persisted=%v, want provider amount/reference", got)
|
||||
}
|
||||
departure := time.Date(2026, 9, 11, 0, 0, 0, 0, time.Local).UTC()
|
||||
if got["DepartureDate"] != departure || got["ReleaseDate"] != departure.Add(48*time.Hour) {
|
||||
t.Errorf("persisted dates=%v, want existing local midnight plus 48 hours", got)
|
||||
}
|
||||
} else if c.count.Load() != 0 {
|
||||
t.Error("non-persisting result inserted SQL")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func preauthStreamRequest(amount, kind, checkout string) *http.Request {
|
||||
body, _ := json.Marshal(creditCallPreauthRequest{Amount: amount, TransactionType: kind, CheckoutDate: checkout})
|
||||
r := httptest.NewRequest(http.MethodPost, "/api/payment/preauth", strings.NewReader(string(body)))
|
||||
r.Header.Set("Content-Type", "application/json")
|
||||
return r
|
||||
}
|
||||
|
||||
func TestCreditCallPreauthStreamingParity(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, result, kind, total string
|
||||
approved, persist bool
|
||||
}{
|
||||
{"monetary", "APPROVED", "SALE", "3100", true, true},
|
||||
{"verification", "APPROVED", "ACCOUNT VERIFICATION", "", true, false},
|
||||
{"declined", "DECLINED", "SALE", "", false, false},
|
||||
{"verification failed", "DECLINED", "ACCOUNT VERIFICATION", "", false, false},
|
||||
{"unknown approved type", "APPROVED", "AccountVerification", "", false, false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.kind, types.Reference: "preauth-ref", types.PanMasked: "************1133", types.CardType: "Visa", types.ExpiryDate: "1228", types.CardHash: "hash", types.CardReference: "cardref", types.ReceiptDataCardholder: "receipt"}
|
||||
if tc.total != "" {
|
||||
fields[types.TotalAmount] = tc.total
|
||||
}
|
||||
amount, kind, date := "12000", "Sale", "2026-09-11 00:00:00 +0000"
|
||||
if strings.Contains(tc.name, "verification") {
|
||||
amount, kind, date = "", "AccountVerification", ""
|
||||
}
|
||||
var legacy cmstypes.ResponseRec
|
||||
for _, stream := range []bool{false, true} {
|
||||
calls, prints := 0, 0
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
calls++
|
||||
if stream {
|
||||
if r.URL.Path != "/start-transaction-stream/" {
|
||||
t.Errorf("stream called %s, want one generic start", r.URL.Path)
|
||||
}
|
||||
var input creditCallPreauthRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if input.Amount != amount || input.TransactionType != kind {
|
||||
t.Errorf("upstream input=%+v, want %q/%q", input, amount, kind)
|
||||
}
|
||||
for _, event := range []struct{ source, value string }{{"UPDATE", "CardRequested"}, {"CARD_STATUS", "Inserted"}, {"UPDATE", "CardRemovalRequested"}, {"CARD_STATUS", "Removed"}, {"UPDATE", "CardRequested"}, {"UPDATE", "CardRemovalEnforced"}, {"UPDATE", "PinEntryStarted"}, {"UPDATE", "OnlineAuthCompleted"}} {
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "status", "source": event.source, "value": event.value})
|
||||
}
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
|
||||
} else {
|
||||
io.WriteString(w, chipDNAFixture(t, fields))
|
||||
}
|
||||
})
|
||||
c := preauthTestDatabase(t, app)
|
||||
app.creditCallReceipt = func(receipt string) {
|
||||
prints++
|
||||
if receipt != "receipt" {
|
||||
t.Errorf("receipt=%q, want retained receipt", receipt)
|
||||
}
|
||||
}
|
||||
recorder := httptest.NewRecorder()
|
||||
if stream {
|
||||
app.streamCreditCallPreauth(recorder, preauthStreamRequest(amount, kind, date))
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
var statuses []string
|
||||
for _, frame := range frames {
|
||||
if frame.Type == "status" {
|
||||
statuses = append(statuses, frame.Code)
|
||||
}
|
||||
}
|
||||
want := []string{paymentstatus.PresentCard, paymentstatus.DoNotRemoveCard, paymentstatus.RemoveCard, paymentstatus.PresentCard, paymentstatus.RemoveCard, paymentstatus.EnterPIN, paymentstatus.PleaseWait}
|
||||
if !reflect.DeepEqual(statuses, want) {
|
||||
t.Errorf("preauth statuses=%v, want %v", statuses, want)
|
||||
}
|
||||
final := frames[len(frames)-1].Result
|
||||
if final == nil {
|
||||
t.Fatal("missing structured final")
|
||||
}
|
||||
if (final.Outcome == "approved") != tc.approved || final.Status != legacy.Status || final.HTTPStatus != 200 {
|
||||
t.Errorf("stream final=%+v, legacy=%+v", final, legacy)
|
||||
}
|
||||
if tc.approved && (final.TransactionReference != "preauth-ref" || final.CardType != "Visa" || final.MaskedCardNumber != "************1133" || final.ExpiryDate != "1228" || final.CardHash != "hash" || final.CardReference != "cardref") {
|
||||
t.Errorf("preauth fields lost: %+v", final)
|
||||
}
|
||||
if len(frames) != len(want)+1 {
|
||||
t.Errorf("frames=%d, want one final", len(frames))
|
||||
}
|
||||
} else {
|
||||
app.takePreauthorization(recorder, preauthLegacyRequest(amount, kind, date))
|
||||
if err := json.Unmarshal(recorder.Body.Bytes(), &legacy); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if calls != 1 || prints != 1 {
|
||||
t.Errorf("calls/prints=%d/%d, want 1/1", calls, prints)
|
||||
}
|
||||
if tc.persist {
|
||||
got := waitPreauthInsert(t, c)
|
||||
if got["TotalMinorUnits"] != tc.total {
|
||||
t.Errorf("SQL amount=%v, want provider %q", got["TotalMinorUnits"], tc.total)
|
||||
}
|
||||
} else if c.count.Load() != 0 {
|
||||
t.Error("verification/failure persisted")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallInboundCancellationAfterDispatch(t *testing.T) {
|
||||
for _, preauth := range []bool{false, true} {
|
||||
t.Run(map[bool]string{false: "sale", true: "preauth"}[preauth], func(t *testing.T) {
|
||||
dispatched := make(chan struct{})
|
||||
release := make(chan struct{})
|
||||
var starts, confirms, receipts atomic.Int32
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/confirm-transaction/" {
|
||||
confirms.Add(1)
|
||||
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "APPROVED", types.ReceiptDataCardholder: "receipt"}))
|
||||
return
|
||||
}
|
||||
starts.Add(1)
|
||||
close(dispatched)
|
||||
<-release
|
||||
if r.Context().Err() != nil {
|
||||
t.Errorf("financial upstream was cancelled: %v", r.Context().Err())
|
||||
return
|
||||
}
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": map[string]string{types.TransactionResult: "APPROVED", types.TransactionType: "SALE", types.TotalAmount: "3100", types.Reference: "delayed-ref", types.ReceiptDataCardholder: "receipt"}})
|
||||
})
|
||||
c := preauthTestDatabase(t, app)
|
||||
app.creditCallReceipt = func(receipt string) {
|
||||
if receipt != "receipt" {
|
||||
t.Errorf("receipt=%q", receipt)
|
||||
}
|
||||
receipts.Add(1)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
recorder := httptest.NewRecorder()
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
if preauth {
|
||||
app.streamCreditCallPreauth(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx))
|
||||
} else {
|
||||
app.streamCreditCallSale(recorder, saleRequest(true).WithContext(ctx))
|
||||
}
|
||||
}()
|
||||
select {
|
||||
case <-dispatched:
|
||||
case <-time.After(3 * time.Second):
|
||||
close(release)
|
||||
t.Fatal("no upstream dispatch")
|
||||
}
|
||||
cancel() // Exact acceptance boundary: upstream has observed StartTransaction.
|
||||
close(release)
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("cancelled inbound request stopped finalization")
|
||||
}
|
||||
wantConfirms := int32(1)
|
||||
if preauth {
|
||||
wantConfirms = 0
|
||||
got := waitPreauthInsert(t, c)
|
||||
if got["TotalMinorUnits"] != "3100" {
|
||||
t.Errorf("delayed persistence=%v", got)
|
||||
}
|
||||
if c.count.Load() != 1 {
|
||||
t.Errorf("delayed persistence count=%d, want exactly one", c.count.Load())
|
||||
}
|
||||
}
|
||||
if starts.Load() != 1 || receipts.Load() != 1 || confirms.Load() != wantConfirms {
|
||||
t.Errorf("starts/receipts/confirms=%d/%d/%d, want 1/1/%d", starts.Load(), receipts.Load(), confirms.Load(), wantConfirms)
|
||||
}
|
||||
if recorder.Body.Len() != 0 {
|
||||
t.Errorf("cancelled delivery wrote %s", recorder.Body.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallPreauthMissingAmountNeverSynthesized(t *testing.T) {
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": map[string]string{types.TransactionResult: "APPROVED", types.TransactionType: "SALE", types.Reference: "missing-amount"}})
|
||||
})
|
||||
c := preauthTestDatabase(t, app)
|
||||
app.creditCallReceipt = func(string) {}
|
||||
recorder := httptest.NewRecorder()
|
||||
app.streamCreditCallPreauth(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000"))
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
if frames[0].Result.Outcome != "approved" {
|
||||
t.Fatalf("missing amount changed approval: %+v", frames[0].Result)
|
||||
}
|
||||
deadline := time.Now().Add(3 * time.Second)
|
||||
for {
|
||||
data, err := os.ReadFile(app.spoolPath())
|
||||
var record preauthSpoolRecord
|
||||
if err == nil && json.Unmarshal(data, &record) == nil {
|
||||
if _, ok := record.Fields[types.TotalAmount]; ok {
|
||||
t.Errorf("spool fabricated amount: %v", record.Fields)
|
||||
}
|
||||
if record.CheckoutDate != "2026-09-11 00:00:00 +0000" {
|
||||
t.Errorf("spool checkout=%q", record.CheckoutDate)
|
||||
}
|
||||
break
|
||||
}
|
||||
if time.Now().After(deadline) {
|
||||
t.Fatal("missing provider amount did not retain existing spool fallback")
|
||||
}
|
||||
time.Sleep(time.Millisecond)
|
||||
}
|
||||
if c.count.Load() != 0 {
|
||||
t.Error("SQL inserted fabricated amount")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallPreauthStreamFailureAndCancelledBeforeDispatch(t *testing.T) {
|
||||
for _, body := range []string{"", "{", "{}\n", "<xml/>\n", "{\"type\":\"result\",\"result\":{}}\n", "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"APPROVED\"}}"} {
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, body) })
|
||||
calls := 0
|
||||
transport := app.creditCallTransport
|
||||
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { calls++; return transport.RoundTrip(r) })
|
||||
app.creditCallReceipt = func(string) { t.Error("malformed stream printed receipt") }
|
||||
recorder := httptest.NewRecorder()
|
||||
app.streamCreditCallPreauth(recorder, preauthStreamRequest("", "AccountVerification", ""))
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
if calls != 1 || len(frames) != 1 || frames[0].Result.Outcome != "error" || frames[0].Result.HTTPStatus != 502 {
|
||||
t.Errorf("invalid stream %q: calls=%d frames=%+v", body, calls, frames)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
app.streamCreditCallPreauth(httptest.NewRecorder(), preauthStreamRequest("", "AccountVerification", "").WithContext(ctx))
|
||||
if calls != 1 {
|
||||
t.Error("already-cancelled request dispatched a transaction")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
// creditCallSaleOutcome is the transaction outcome before either wire format is applied.
|
||||
type creditCallSaleOutcome struct {
|
||||
HTTPStatus int
|
||||
Status cmstypes.StatusRec
|
||||
Payment creditcall.PaymentResult
|
||||
Approved bool
|
||||
FailureType string
|
||||
FailureDescription string
|
||||
}
|
||||
|
||||
func (app *App) creditCallClient() *http.Client {
|
||||
// Each start/confirm call gets the original independent timeout. In particular,
|
||||
// neither a kiosk disconnect nor a whole-sale deadline bounds confirmation.
|
||||
return &http.Client{Timeout: 300 * time.Second, Transport: app.creditCallTransport}
|
||||
}
|
||||
|
||||
func (app *App) printCreditCallReceipt(receipt string) {
|
||||
if app.creditCallReceipt != nil {
|
||||
app.creditCallReceipt(receipt)
|
||||
return
|
||||
}
|
||||
printer.PrintReceipt(receipt)
|
||||
}
|
||||
|
||||
func (app *App) executeCreditCallSale(
|
||||
request cmstypes.TransactionRec,
|
||||
start func(*http.Client) (creditcall.TransactionResultXML, error),
|
||||
) creditCallSaleOutcome {
|
||||
const op = logging.Op("takePayment")
|
||||
outcome := creditCallSaleOutcome{
|
||||
HTTPStatus: http.StatusBadGateway,
|
||||
Status: cmstypes.StatusRec{Code: http.StatusInternalServerError, Message: "500 Internal server error"},
|
||||
}
|
||||
client := app.creditCallClient()
|
||||
trResult, err := start(client)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Start transaction error", string(op), "", "", 0)
|
||||
outcome.FailureType = types.ResultError
|
||||
outcome.FailureDescription = "No response from payment processor"
|
||||
return outcome
|
||||
}
|
||||
|
||||
var result creditcall.PaymentResult
|
||||
result.FillFromTransactionResult(trResult)
|
||||
res := result.Fields[types.TransactionResult]
|
||||
if !strings.EqualFold(res, types.ResultApproved) {
|
||||
app.printCreditCallReceipt(result.CardholderReceipt)
|
||||
desc := result.Fields[types.ErrorDescription]
|
||||
if desc == "" {
|
||||
desc = result.Fields[types.Errors]
|
||||
}
|
||||
logging.Error(types.ServiceName, "Preauthorization failed", "Result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
outcome.HTTPStatus = http.StatusOK
|
||||
outcome.Status = result.Status
|
||||
outcome.Payment = result
|
||||
outcome.FailureType = res
|
||||
outcome.FailureDescription = result.Fields[types.Errors]
|
||||
return outcome
|
||||
}
|
||||
|
||||
ref := result.Fields[types.Reference]
|
||||
log.Printf("Preauth approved, reference: %s. Sending confirm...", ref)
|
||||
body, err := confirmWithRetry(client, creditcall.ConfirmTransactionRequest{
|
||||
Amount: request.AmountMinorUnits, Reference: ref,
|
||||
}, 2)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Confirm transaction error", string(op), "", "", 0)
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Error: "+err.Error())
|
||||
outcome.FailureType = types.ResultError
|
||||
outcome.FailureDescription = "ConfirmTransactionError"
|
||||
return outcome
|
||||
}
|
||||
|
||||
// Intentionally reuse both records: XML appends confirmation entries, and
|
||||
// missing confirmation fields/receipts retain their existing legacy behavior.
|
||||
if err := trResult.ParseTransactionResult(body); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse confirm result error", string(op), "", "", 0)
|
||||
}
|
||||
result.FillFromTransactionResult(trResult)
|
||||
res = result.Fields[types.TransactionResult]
|
||||
if !strings.EqualFold(res, types.ResultApproved) {
|
||||
app.printCreditCallReceipt(result.CardholderReceipt)
|
||||
desc := result.Fields[types.ErrorDescription]
|
||||
if desc == "" {
|
||||
desc = result.Fields[types.Errors]
|
||||
}
|
||||
logging.Error(types.ServiceName, "Transaction not approved after confirm", "Confirm result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
|
||||
outcome.HTTPStatus = http.StatusOK
|
||||
outcome.Status = result.Status
|
||||
outcome.Payment = result
|
||||
outcome.FailureType = res
|
||||
outcome.FailureDescription = result.Fields[types.Errors]
|
||||
return outcome
|
||||
}
|
||||
|
||||
app.printCreditCallReceipt(result.CardholderReceipt)
|
||||
log.Printf("Transaction approved and confirmed, reference: %s", ref)
|
||||
outcome.HTTPStatus = http.StatusOK
|
||||
outcome.Status = result.Status
|
||||
outcome.Payment = result
|
||||
outcome.Approved = true
|
||||
return outcome
|
||||
}
|
||||
|
||||
func (outcome creditCallSaleOutcome) legacyResponse() cmstypes.ResponseRec {
|
||||
response := cmstypes.ResponseRec{Status: outcome.Status}
|
||||
if outcome.Approved {
|
||||
response.Data = creditcall.BuildSuccessURL(outcome.Payment.Fields)
|
||||
} else {
|
||||
response.Data = creditcall.BuildFailureURL(outcome.FailureType, outcome.FailureDescription)
|
||||
}
|
||||
return response
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"reflect"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
type failedCreditCallBody struct{ closed *bool }
|
||||
|
||||
func (b failedCreditCallBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
|
||||
func (b failedCreditCallBody) Close() error { *b.closed = true; return nil }
|
||||
|
||||
func TestCreditCallConfirmationReadFailureAndHTTPStatus(t *testing.T) {
|
||||
for _, failFirstRead := range []bool{false, true} {
|
||||
calls, receipts, firstClosed := 0, 0, false
|
||||
app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(string) { receipts++ }}
|
||||
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
|
||||
calls++
|
||||
if r.URL.Path != "/confirm-transaction/" {
|
||||
t.Errorf("confirmation path=%s", r.URL.Path)
|
||||
}
|
||||
deadline, ok := r.Context().Deadline()
|
||||
if !ok || time.Until(deadline) < 299*time.Second {
|
||||
t.Errorf("confirmation call has no fresh 300-second deadline: %v", deadline)
|
||||
}
|
||||
var body io.ReadCloser = io.NopCloser(strings.NewReader(chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"})))
|
||||
if failFirstRead && calls == 1 {
|
||||
body = failedCreditCallBody{closed: &firstClosed}
|
||||
}
|
||||
// Legacy confirmation ignores HTTP status when the body can be read.
|
||||
return &http.Response{StatusCode: http.StatusServiceUnavailable, Body: body}, nil
|
||||
})
|
||||
outcome := app.executeCreditCallSale(cmstypes.TransactionRec{AmountMinorUnits: "1234"}, func(*http.Client) (creditcall.TransactionResultXML, error) {
|
||||
return creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: types.TransactionResult, Value: "Approved"}, {Key: types.Reference, Value: "ref"}}}, nil
|
||||
})
|
||||
wantCalls := 1
|
||||
if failFirstRead {
|
||||
wantCalls = 2
|
||||
}
|
||||
if calls != wantCalls || receipts != 1 || !outcome.Approved || (failFirstRead && !firstClosed) {
|
||||
t.Errorf("readFailure=%v calls/receipts/approved/closed=%d/%d/%v/%v", failFirstRead, calls, receipts, outcome.Approved, firstClosed)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallStreamFailureNeverRestartsOrConfirms(t *testing.T) {
|
||||
calls := 0
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
calls++
|
||||
if r.URL.Path != "/start-transaction-stream/" {
|
||||
t.Errorf("unexpected fallback/confirmation %s", r.URL.Path)
|
||||
}
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n{partial")
|
||||
})
|
||||
app.creditCallReceipt = func(string) { t.Error("invalid upstream stream printed receipt") }
|
||||
recorder := httptest.NewRecorder()
|
||||
app.salePayment(recorder, saleRequest(true))
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
if calls != 1 || len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "error" || frames[1].Result.HTTPStatus != 502 {
|
||||
t.Errorf("malformed stream calls=%d frames=%+v", calls, frames)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallStructuredFieldsExcludeRawData(t *testing.T) {
|
||||
result := (creditCallSaleOutcome{Approved: true, Payment: creditcall.PaymentResult{Fields: map[string]string{
|
||||
types.Reference: "ref", types.PanMasked: "1234567890123456", types.CardHash: "hash", types.CardReference: "card-ref",
|
||||
"PAN": "pan-secret", "CVV": "cvv-secret", "PIN": "pin-secret", "TRACK_DATA": "track-secret", types.ReceiptDataCardholder: "receipt-secret",
|
||||
}}}).streamResult()
|
||||
body, err := json.Marshal(result)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, forbidden := range []string{"1234567890123456", "pan-secret", "cvv-secret", "pin-secret", "track-secret", "receipt-secret", "/successful", "/unsuccessful"} {
|
||||
if bytes.Contains(body, []byte(forbidden)) {
|
||||
t.Errorf("structured result exposed %q", forbidden)
|
||||
}
|
||||
}
|
||||
if result.CardHash != "hash" || result.CardReference != "card-ref" || result.TransactionReference != "ref" {
|
||||
t.Errorf("required identifiers missing: %+v", result)
|
||||
}
|
||||
}
|
||||
|
||||
type blockedPaymentWriter struct {
|
||||
*httptest.ResponseRecorder
|
||||
started chan struct{}
|
||||
release chan struct{}
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
func (w *blockedPaymentWriter) Write(data []byte) (int, error) {
|
||||
w.once.Do(func() { close(w.started) })
|
||||
<-w.release
|
||||
return w.ResponseRecorder.Write(data)
|
||||
}
|
||||
|
||||
func TestCreditCallBackpressureCannotBlockFinalizationOrLoseFinal(t *testing.T) {
|
||||
nativeRelease, receiptPrinted := make(chan struct{}), make(chan struct{})
|
||||
var nativeOnce, deliveryOnce sync.Once
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/confirm-transaction/" {
|
||||
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"}))
|
||||
return
|
||||
}
|
||||
line := "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n"
|
||||
io.WriteString(w, line)
|
||||
w.(http.Flusher).Flush()
|
||||
<-nativeRelease
|
||||
for i := 0; i < 1000; i++ {
|
||||
io.WriteString(w, line)
|
||||
}
|
||||
io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n")
|
||||
})
|
||||
app.creditCallReceipt = func(string) { close(receiptPrinted) }
|
||||
writer := &blockedPaymentWriter{ResponseRecorder: httptest.NewRecorder(), started: make(chan struct{}), release: make(chan struct{})}
|
||||
t.Cleanup(func() {
|
||||
nativeOnce.Do(func() { close(nativeRelease) })
|
||||
deliveryOnce.Do(func() { close(writer.release) })
|
||||
})
|
||||
done := make(chan struct{})
|
||||
go func() { app.salePayment(writer, saleRequest(true)); close(done) }()
|
||||
select {
|
||||
case <-writer.started:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("progress was not live")
|
||||
}
|
||||
nativeOnce.Do(func() { close(nativeRelease) })
|
||||
select {
|
||||
case <-receiptPrinted:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("blocked writer stopped financial finalization")
|
||||
}
|
||||
deliveryOnce.Do(func() { close(writer.release) })
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("stream did not deliver final")
|
||||
}
|
||||
frames := decodePaymentStream(t, writer.Body)
|
||||
if len(frames) != 130 || frames[len(frames)-1].Result == nil || frames[len(frames)-1].Result.Outcome != "approved" {
|
||||
t.Errorf("backpressure frames=%d, last=%+v, want 129 statuses and final approval", len(frames), frames[len(frames)-1])
|
||||
}
|
||||
}
|
||||
|
||||
type creditCallRoundTrip func(*http.Request) (*http.Response, error)
|
||||
|
||||
func (f creditCallRoundTrip) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
|
||||
|
||||
func chipDNAFixture(t *testing.T, fields map[string]string) string {
|
||||
t.Helper()
|
||||
var result creditcall.TransactionResultXML
|
||||
for key, value := range fields {
|
||||
result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value})
|
||||
}
|
||||
data, err := xml.Marshal(result)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return string(data)
|
||||
}
|
||||
|
||||
func newCreditCallTestApp(t *testing.T, handler http.HandlerFunc) *App {
|
||||
t.Helper()
|
||||
server := httptest.NewServer(handler)
|
||||
t.Cleanup(server.Close)
|
||||
target, err := url.Parse(server.URL)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &App{isPayment: true, creditCallStreamEnabled: true, cfg: &config.ConfigRec{TimeoutSeconds: 1},
|
||||
creditCallTransport: creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
|
||||
clone := r.Clone(r.Context())
|
||||
clone.URL.Scheme, clone.URL.Host = target.Scheme, target.Host
|
||||
return server.Client().Transport.RoundTrip(clone)
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
func saleRequest(stream bool) *http.Request {
|
||||
if stream {
|
||||
r := httptest.NewRequest(http.MethodPost, "/api/payment/sale", strings.NewReader(`{"amount":1234}`))
|
||||
r.Header.Set("Content-Type", "application/json")
|
||||
return r
|
||||
}
|
||||
r := httptest.NewRequest(http.MethodPost, "/takepayment", strings.NewReader(`<TransactionPayload><Amount>1234</Amount><TransactionType>Sale</TransactionType></TransactionPayload>`))
|
||||
r.Header.Set("Content-Type", "text/xml")
|
||||
return r
|
||||
}
|
||||
|
||||
func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
name, startResult, confirmation string
|
||||
confirms int
|
||||
approved bool
|
||||
receipt string
|
||||
}{
|
||||
{"approved", "Approved", "Approved", 1, true, "confirm receipt"},
|
||||
{"declined", "Declined", "", 0, false, "start receipt"},
|
||||
{"cancelled", "Cancelled", "", 0, false, "start receipt"},
|
||||
{"timeout", "TIMEOUT", "", 0, false, "start receipt"},
|
||||
{"confirmation declined", "Approved", "Declined", 1, false, "confirm receipt"},
|
||||
{"confirmation omissions", "Approved", "omitted", 1, true, "start receipt"},
|
||||
{"malformed confirmation", "Approved", "malformed", 1, true, "start receipt"},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
fields := map[string]string{types.TransactionResult: test.startResult, types.Reference: "native-ref",
|
||||
types.CardType: "Visa", types.PanMasked: "************1234", types.ExpiryDate: "1228",
|
||||
types.CardHash: "hash", types.CardReference: "card-ref", types.ReceiptDataCardholder: "start receipt"}
|
||||
var legacy cmstypes.ResponseRec
|
||||
for _, streaming := range []bool{false, true} {
|
||||
var starts, confirms atomic.Int32
|
||||
var receipts []string
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
switch r.URL.Path {
|
||||
case "/start-transaction/":
|
||||
starts.Add(1)
|
||||
io.WriteString(w, chipDNAFixture(t, fields))
|
||||
case "/start-transaction-stream/":
|
||||
starts.Add(1)
|
||||
var input struct{ Amount, TransactionType string }
|
||||
if err := json.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.TransactionType != "Sale" {
|
||||
t.Errorf("stream start input = %+v, error %v", input, err)
|
||||
}
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n")
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n")
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n")
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
|
||||
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
|
||||
case "/confirm-transaction/":
|
||||
confirms.Add(1)
|
||||
var input creditcall.ConfirmTransactionRequest
|
||||
if err := xml.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.Reference != "native-ref" {
|
||||
t.Errorf("confirmation input = %+v, error %v", input, err)
|
||||
}
|
||||
switch test.confirmation {
|
||||
case "omitted":
|
||||
io.WriteString(w, "<TransactionResult/>")
|
||||
case "malformed":
|
||||
io.WriteString(w, "<TransactionResult><Entry>")
|
||||
default:
|
||||
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.confirmation, types.ReceiptDataCardholder: "confirm receipt"}))
|
||||
}
|
||||
default:
|
||||
t.Errorf("unexpected ChipDNA path %q", r.URL.Path)
|
||||
}
|
||||
})
|
||||
app.creditCallReceipt = func(receipt string) { receipts = append(receipts, receipt) }
|
||||
if got := app.creditCallClient().Timeout; got != 300*time.Second {
|
||||
t.Fatalf("per-call timeout = %v, want 300s", got)
|
||||
}
|
||||
recorder := httptest.NewRecorder()
|
||||
if streaming {
|
||||
app.salePayment(recorder, saleRequest(true))
|
||||
} else {
|
||||
app.takePayment(recorder, saleRequest(false))
|
||||
}
|
||||
if starts.Load() != 1 || int(confirms.Load()) != test.confirms {
|
||||
t.Errorf("stream=%v starts/confirms=%d/%d, want 1/%d", streaming, starts.Load(), confirms.Load(), test.confirms)
|
||||
}
|
||||
if !reflect.DeepEqual(receipts, []string{test.receipt}) {
|
||||
t.Errorf("stream=%v receipts=%v, want [%s]", streaming, receipts, test.receipt)
|
||||
}
|
||||
if !streaming {
|
||||
if err := json.Unmarshal(recorder.Body.Bytes(), &legacy); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.HasPrefix(legacy.Data, "/successful") != test.approved {
|
||||
t.Errorf("legacy result = %+v, approved want %v", legacy, test.approved)
|
||||
}
|
||||
continue
|
||||
}
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
if len(frames) != 3 || frames[0].Code != paymentstatus.PresentCard || frames[1].Code != paymentstatus.PleaseWait || frames[2].Result == nil {
|
||||
t.Fatalf("frames = %+v, want two ordered hints and one final", frames)
|
||||
}
|
||||
final := frames[2].Result
|
||||
if final.HTTPStatus != http.StatusOK || final.Status != legacy.Status || (final.Outcome == "approved") != test.approved {
|
||||
t.Errorf("structured final = %+v, legacy = %+v", final, legacy)
|
||||
}
|
||||
parsed, err := url.Parse(legacy.Data)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if test.approved {
|
||||
if final.TransactionReference != "native-ref" || final.CardType != "Visa" || final.MaskedCardNumber != "************1234" || final.CardHash != "hash" || final.CardReference != "card-ref" || final.ExpiryDate != "1228" {
|
||||
t.Errorf("retained structured fields = %+v", final)
|
||||
}
|
||||
} else if final.Message != parsed.Query().Get("Description") {
|
||||
t.Errorf("structured message = %q, legacy description = %q", final.Message, parsed.Query().Get("Description"))
|
||||
}
|
||||
if frames[2].Response != nil {
|
||||
t.Error("CreditCall stream included legacy response")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) {
|
||||
for _, streaming := range []bool{false, true} {
|
||||
var attempts int
|
||||
var times []time.Time
|
||||
app := &App{isPayment: true, creditCallStreamEnabled: true, cfg: &config.ConfigRec{}}
|
||||
app.creditCallReceipt = func(string) { t.Error("transport-failed confirmation must not print a receipt") }
|
||||
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
|
||||
if r.Context().Err() != nil {
|
||||
t.Error("transaction context was cancelled")
|
||||
}
|
||||
if r.URL.Path == "/confirm-transaction/" {
|
||||
attempts++
|
||||
times = append(times, time.Now())
|
||||
return nil, errors.New("test transport failure")
|
||||
}
|
||||
body := chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.Reference: "native-ref"})
|
||||
if streaming {
|
||||
body = "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"native-ref\"}}\n"
|
||||
}
|
||||
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body)), Header: make(http.Header)}, nil
|
||||
})
|
||||
recorder := httptest.NewRecorder()
|
||||
if streaming {
|
||||
app.salePayment(recorder, saleRequest(true))
|
||||
} else {
|
||||
app.takePayment(recorder, saleRequest(false))
|
||||
}
|
||||
if attempts != 2 {
|
||||
t.Fatalf("stream=%v confirms=%d, want 2", streaming, attempts)
|
||||
}
|
||||
if times[1].Sub(times[0]) < 2*time.Second {
|
||||
t.Errorf("retry delay=%v, want at least 2s", times[1].Sub(times[0]))
|
||||
}
|
||||
if streaming {
|
||||
frames := decodePaymentStream(t, recorder.Body)
|
||||
if len(frames) != 1 || frames[0].Result.HTTPStatus != 502 || frames[0].Result.Status.Code != 500 || frames[0].Result.Message != "Transaction error" {
|
||||
t.Fatalf("confirmation failure frames=%+v", frames)
|
||||
}
|
||||
} else if recorder.Code != 502 {
|
||||
t.Errorf("legacy confirm failure HTTP=%d, want 502", recorder.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreditCallLegacyMalformedStartAndPreauth(t *testing.T) {
|
||||
for _, test := range []struct{ name, path, result, transactionType string }{
|
||||
{"malformed sale", "/takepayment", "malformed", ""},
|
||||
{"approved account verification", "/takepreauth", "Approved", types.AccountVerificationType},
|
||||
{"declined preauth", "/takepreauth", "Declined", "Sale"},
|
||||
{"malformed preauth", "/takepreauth", "malformed", ""},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
calls, prints := 0, 0
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
calls++
|
||||
if r.URL.Path != "/start-transaction/" {
|
||||
t.Errorf("legacy/preauth path=%s", r.URL.Path)
|
||||
}
|
||||
if test.result == "malformed" {
|
||||
io.WriteString(w, "<TransactionResult><Entry>")
|
||||
return
|
||||
}
|
||||
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.result, types.TransactionType: test.transactionType}))
|
||||
})
|
||||
app.creditCallReceipt = func(string) { prints++ }
|
||||
recorder := httptest.NewRecorder()
|
||||
request := saleRequest(false)
|
||||
if test.path == "/takepreauth" {
|
||||
app.takePreauthorization(recorder, request)
|
||||
} else {
|
||||
app.takePayment(recorder, request)
|
||||
}
|
||||
var response cmstypes.ResponseRec
|
||||
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if recorder.Code != 200 || calls != 1 || prints != 1 {
|
||||
t.Errorf("legacy HTTP/calls/receipts=%d/%d/%d", recorder.Code, calls, prints)
|
||||
}
|
||||
if test.result == "malformed" && (response.Status.Code != 0 || response.Data != "/unsuccessful?Description=&MsgType=") {
|
||||
t.Errorf("malformed legacy result=%+v", response)
|
||||
}
|
||||
if test.result == "Approved" && !strings.HasPrefix(response.Data, "/successful?") {
|
||||
t.Errorf("approved preauth=%+v", response)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestChipDNAStreamRejectsIncompleteOrInvalidFrames(t *testing.T) {
|
||||
for _, body := range []string{"", "{", "{}\n", "<xml/>\n", "{\"type\":\"result\"}\n", "{\"type\":\"result\",\"result\":{}}\n", "{\"type\":\"error\",\"error\":\"sensitive diagnostic\"}\n", "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\"}}", "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n"} {
|
||||
client := &http.Client{Transport: creditCallRoundTrip(func(*http.Request) (*http.Response, error) {
|
||||
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body))}, nil
|
||||
})}
|
||||
_, err := callChipDNAStream(client, 1234, func(code string) { t.Errorf("invalid stream produced status %q", code) })
|
||||
if err == nil {
|
||||
t.Errorf("callChipDNAStream(%q) succeeded, want error", body)
|
||||
}
|
||||
if err != nil && strings.Contains(err.Error(), "sensitive diagnostic") {
|
||||
t.Error("raw diagnostic leaked")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type disconnectedPaymentWriter struct {
|
||||
header http.Header
|
||||
once sync.Once
|
||||
failed chan struct{}
|
||||
writes atomic.Int32
|
||||
}
|
||||
|
||||
func (w *disconnectedPaymentWriter) Header() http.Header { return w.header }
|
||||
func (w *disconnectedPaymentWriter) WriteHeader(int) {}
|
||||
func (w *disconnectedPaymentWriter) Flush() {}
|
||||
func (w *disconnectedPaymentWriter) Write([]byte) (int, error) {
|
||||
w.writes.Add(1)
|
||||
w.once.Do(func() { close(w.failed) })
|
||||
return 0, io.ErrClosedPipe
|
||||
}
|
||||
|
||||
func TestCreditCallDisconnectStillConfirmsAndPrints(t *testing.T) {
|
||||
release := make(chan struct{})
|
||||
var confirms atomic.Int32
|
||||
var receipts atomic.Int32
|
||||
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/confirm-transaction/" {
|
||||
confirms.Add(1)
|
||||
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.ReceiptDataCardholder: "receipt"}))
|
||||
return
|
||||
}
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n")
|
||||
w.(http.Flusher).Flush()
|
||||
<-release
|
||||
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n")
|
||||
io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n")
|
||||
})
|
||||
app.creditCallReceipt = func(receipt string) {
|
||||
if receipt != "receipt" {
|
||||
t.Errorf("receipt=%q", receipt)
|
||||
}
|
||||
receipts.Add(1)
|
||||
}
|
||||
writer := &disconnectedPaymentWriter{header: make(http.Header), failed: make(chan struct{})}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
done := make(chan struct{})
|
||||
go func() { app.salePayment(writer, saleRequest(true).WithContext(ctx)); close(done) }()
|
||||
select {
|
||||
case <-writer.failed:
|
||||
case <-time.After(5 * time.Second):
|
||||
close(release)
|
||||
t.Fatal("no live progress before final result")
|
||||
}
|
||||
cancel()
|
||||
close(release)
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("finalization stopped after disconnect")
|
||||
}
|
||||
if confirms.Load() != 1 || receipts.Load() != 1 || writer.writes.Load() != 1 {
|
||||
t.Errorf("disconnect confirms/receipts/writes=%d/%d/%d, want 1/1/1", confirms.Load(), receipts.Load(), writer.writes.Load())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
)
|
||||
|
||||
type creditCallStreamResult struct {
|
||||
Outcome string `json:"outcome"`
|
||||
Message string `json:"message"`
|
||||
HTTPStatus int `json:"httpStatus"`
|
||||
Status cmstypes.StatusRec `json:"status"`
|
||||
TransactionReference string `json:"transactionReference,omitempty"`
|
||||
CardType string `json:"cardType,omitempty"`
|
||||
MaskedCardNumber string `json:"maskedCardNumber,omitempty"`
|
||||
ExpiryDate string `json:"expiryDate,omitempty"`
|
||||
CardHash string `json:"cardHash,omitempty"`
|
||||
CardReference string `json:"cardReference,omitempty"`
|
||||
}
|
||||
|
||||
func (outcome creditCallSaleOutcome) streamResult() creditCallStreamResult {
|
||||
result := creditCallStreamResult{
|
||||
Outcome: "error", HTTPStatus: outcome.HTTPStatus, Status: outcome.Status,
|
||||
Message: creditcall.FailureDescription(outcome.FailureType, outcome.FailureDescription),
|
||||
}
|
||||
if !outcome.Approved {
|
||||
switch strings.ToLower(outcome.FailureType) {
|
||||
case "declined":
|
||||
result.Outcome = "declined"
|
||||
case "cancelled", "canceled":
|
||||
result.Outcome = "cancelled"
|
||||
case "timeout":
|
||||
result.Outcome = "timeout"
|
||||
}
|
||||
return result
|
||||
}
|
||||
fields := outcome.Payment.Fields
|
||||
result.Outcome = "approved"
|
||||
result.Message = "Payment approved"
|
||||
result.TransactionReference = fields[types.Reference]
|
||||
result.CardType = fields[types.CardType]
|
||||
result.MaskedCardNumber = creditcall.MaskedCardNumber(fields[types.PanMasked])
|
||||
result.ExpiryDate = fields[types.ExpiryDate]
|
||||
result.CardHash = fields[types.CardHash]
|
||||
result.CardReference = fields[types.CardReference]
|
||||
return result
|
||||
}
|
||||
|
||||
// EnableCreditCallStreaming selects the CreditCall core without a generic provider.
|
||||
func (app *App) EnableCreditCallStreaming() { app.creditCallStreamEnabled = true }
|
||||
|
||||
func (app *App) streamCreditCallSale(w http.ResponseWriter, r *http.Request) {
|
||||
app.streamCreditCall(w, r, false)
|
||||
}
|
||||
|
||||
func (app *App) streamCreditCall(w http.ResponseWriter, r *http.Request, preauth bool) {
|
||||
setPaymentCORS(w)
|
||||
if r.Method == http.MethodOptions {
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||||
controller := http.NewResponseController(w)
|
||||
encoder := json.NewEncoder(w)
|
||||
deliveryFailed := false
|
||||
// Only this handler writes the response. The transaction worker never waits
|
||||
// for network delivery, including when the peer stops reading without closing.
|
||||
send := func(frame paymentStreamMessage) {
|
||||
if deliveryFailed || r.Context().Err() != nil {
|
||||
deliveryFailed = true
|
||||
return
|
||||
}
|
||||
if err := encoder.Encode(frame); err != nil {
|
||||
deliveryFailed = true
|
||||
return
|
||||
}
|
||||
if err := controller.Flush(); err != nil {
|
||||
deliveryFailed = true
|
||||
return
|
||||
}
|
||||
|
||||
}
|
||||
reject := func(status int, message string) {
|
||||
result := creditCallStreamResult{Outcome: "error", Message: message, HTTPStatus: status,
|
||||
Status: cmstypes.StatusRec{Code: status, Message: http.StatusText(status)}}
|
||||
w.WriteHeader(status)
|
||||
send(paymentStreamMessage{Type: "result", Result: &result})
|
||||
}
|
||||
if preauth && !app.creditCallStreamEnabled {
|
||||
reject(http.StatusServiceUnavailable, "CreditCall preauthorization streaming is not enabled")
|
||||
return
|
||||
}
|
||||
if !app.isPayment && !app.cfg.TestMode {
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted payment while payment processing is disabled")
|
||||
reject(http.StatusServiceUnavailable, "Payment processing is disabled")
|
||||
return
|
||||
}
|
||||
if r.Method != http.MethodPost {
|
||||
reject(http.StatusMethodNotAllowed, "Method not allowed; use POST")
|
||||
return
|
||||
}
|
||||
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
|
||||
reject(http.StatusUnsupportedMediaType, "Content-Type must be application/json")
|
||||
return
|
||||
}
|
||||
defer r.Body.Close()
|
||||
var transaction cmstypes.TransactionRec
|
||||
if preauth {
|
||||
var request creditCallPreauthRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
||||
reject(http.StatusBadRequest, "Invalid JSON payload")
|
||||
return
|
||||
}
|
||||
transaction = cmstypes.TransactionRec{AmountMinorUnits: request.Amount, TransactionType: request.TransactionType, CheckoutDate: request.CheckoutDate}
|
||||
} else {
|
||||
var request SalePaymentRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
||||
reject(http.StatusBadRequest, "Invalid JSON payload")
|
||||
return
|
||||
}
|
||||
if request.Amount <= 0 {
|
||||
reject(http.StatusBadRequest, "Amount must be greater than zero")
|
||||
return
|
||||
}
|
||||
transaction = cmstypes.TransactionRec{AmountMinorUnits: strconv.FormatInt(request.Amount, 10), TransactionType: "Sale"}
|
||||
}
|
||||
if _, ok := w.(http.Flusher); !ok {
|
||||
reject(http.StatusInternalServerError, "Streaming payment updates are not supported")
|
||||
return
|
||||
}
|
||||
|
||||
// Validation belongs to the incoming request. This handoff owns financial dispatch.
|
||||
if r.Context().Err() != nil {
|
||||
return
|
||||
}
|
||||
financialContext := context.WithoutCancel(r.Context())
|
||||
progress := make(chan string, 128)
|
||||
finished := make(chan creditCallSaleOutcome, 1)
|
||||
go func() {
|
||||
start := func(client *http.Client) (creditcall.TransactionResultXML, error) {
|
||||
return callChipDNATransactionStream(financialContext, client, transaction, func(code string) {
|
||||
select {
|
||||
case progress <- code:
|
||||
default: // Observational progress may be dropped under backpressure.
|
||||
}
|
||||
})
|
||||
}
|
||||
var outcome creditCallSaleOutcome
|
||||
if preauth {
|
||||
outcome = app.executeCreditCallPreauth(financialContext, transaction, start)
|
||||
} else {
|
||||
outcome = app.executeCreditCallSale(transaction, start)
|
||||
}
|
||||
close(progress)
|
||||
finished <- outcome // Independent of the bounded progress queue.
|
||||
}()
|
||||
for {
|
||||
select {
|
||||
case code, ok := <-progress:
|
||||
if !ok {
|
||||
progress = nil
|
||||
continue
|
||||
}
|
||||
send(paymentStreamMessage{Type: "status", Code: code})
|
||||
case outcome := <-finished:
|
||||
if progress != nil {
|
||||
for code := range progress {
|
||||
send(paymentStreamMessage{Type: "status", Code: code})
|
||||
}
|
||||
}
|
||||
result := outcome.streamResult()
|
||||
send(paymentStreamMessage{Type: "result", Result: &result})
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func callChipDNAStream(client *http.Client, amount int64, onStatus func(string)) (creditcall.TransactionResultXML, error) {
|
||||
return callChipDNATransactionStream(context.Background(), client, cmstypes.TransactionRec{
|
||||
AmountMinorUnits: strconv.FormatInt(amount, 10), TransactionType: "Sale",
|
||||
}, onStatus)
|
||||
}
|
||||
|
||||
func callChipDNATransactionStream(ctx context.Context, client *http.Client, transaction cmstypes.TransactionRec, onStatus func(string)) (creditcall.TransactionResultXML, error) {
|
||||
var result creditcall.TransactionResultXML
|
||||
payload, err := json.Marshal(struct {
|
||||
Amount string `json:"amount"`
|
||||
TransactionType string `json:"transactionType"`
|
||||
}{transaction.AmountMinorUnits, transaction.TransactionType})
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
// Dispatch owns ctx; Client.Timeout retains the independent 300-second call bound.
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, types.LinkStartTransactionStream, bytes.NewReader(payload))
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Accept", "application/x-ndjson")
|
||||
response, err := client.Do(req)
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
defer response.Body.Close()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return result, fmt.Errorf("chipdna stream returned HTTP %d", response.StatusCode)
|
||||
}
|
||||
reader := bufio.NewReader(response.Body)
|
||||
for {
|
||||
line, err := reader.ReadBytes('\n')
|
||||
if err != nil {
|
||||
if errors.Is(err, io.EOF) {
|
||||
return result, fmt.Errorf("chipdna stream ended before a complete final frame")
|
||||
}
|
||||
return result, fmt.Errorf("read chipdna stream: %w", err)
|
||||
}
|
||||
var frame struct {
|
||||
Type string `json:"type"`
|
||||
Source string `json:"source"`
|
||||
Value string `json:"value"`
|
||||
Result map[string]string `json:"result"`
|
||||
}
|
||||
if err := json.Unmarshal(line, &frame); err != nil {
|
||||
return result, fmt.Errorf("invalid chipdna JSON frame")
|
||||
}
|
||||
switch frame.Type {
|
||||
case "status":
|
||||
if code := creditcall.ProgressStatus(frame.Source, frame.Value); code != "" && onStatus != nil {
|
||||
onStatus(code)
|
||||
}
|
||||
case "result":
|
||||
if len(frame.Result) == 0 {
|
||||
return result, fmt.Errorf("chipdna final frame has no transaction fields")
|
||||
}
|
||||
for key, value := range frame.Result {
|
||||
result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value})
|
||||
}
|
||||
return result, nil // Later frames cannot repeat confirmation/finalization.
|
||||
case "error":
|
||||
return result, fmt.Errorf("chipdna stream reported an error")
|
||||
default:
|
||||
return result, fmt.Errorf("unknown chipdna frame type")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@ import (
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/db"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
@@ -0,0 +1,313 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type dispenserCallResult struct {
|
||||
status string
|
||||
err error
|
||||
}
|
||||
|
||||
type fakeDoorCardDispenser struct {
|
||||
prepareCurrent dispenserCallResult
|
||||
deliverCurrent dispenserCallResult
|
||||
beginNextErr error
|
||||
beginNext func() error
|
||||
prepareNext dispenserCallResult
|
||||
calls []string
|
||||
}
|
||||
|
||||
func (d *fakeDoorCardDispenser) PrepareCurrentCard(context.Context) (string, error) {
|
||||
d.calls = append(d.calls, "prepare current")
|
||||
return d.prepareCurrent.status, d.prepareCurrent.err
|
||||
}
|
||||
|
||||
func (d *fakeDoorCardDispenser) DeliverCurrentCard(context.Context) (string, error) {
|
||||
d.calls = append(d.calls, "deliver current")
|
||||
return d.deliverCurrent.status, d.deliverCurrent.err
|
||||
}
|
||||
|
||||
func (d *fakeDoorCardDispenser) BeginPrepareNextCard(context.Context) error {
|
||||
d.calls = append(d.calls, "begin prepare next")
|
||||
if d.beginNext != nil {
|
||||
return d.beginNext()
|
||||
}
|
||||
return d.beginNextErr
|
||||
}
|
||||
|
||||
func (d *fakeDoorCardDispenser) PrepareNextCard(context.Context) (string, error) {
|
||||
d.calls = append(d.calls, "prepare next")
|
||||
return d.prepareNext.status, d.prepareNext.err
|
||||
}
|
||||
|
||||
type fakeDoorCardLockServer struct {
|
||||
sequenceErr error
|
||||
buildCalls int
|
||||
sequenceCalls int
|
||||
}
|
||||
|
||||
func (l *fakeDoorCardLockServer) BuildCommand(lockserver.DoorCardRequest, time.Time, time.Time) error {
|
||||
l.buildCalls++
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l *fakeDoorCardLockServer) LockSequence() error {
|
||||
l.sequenceCalls++
|
||||
return l.sequenceErr
|
||||
}
|
||||
|
||||
func performIssueDoorCardRequest(
|
||||
t *testing.T,
|
||||
dispenser *fakeDoorCardDispenser,
|
||||
lock *fakeDoorCardLockServer,
|
||||
) (*httptest.ResponseRecorder, cmstypes.StatusRec, *App) {
|
||||
t.Helper()
|
||||
|
||||
payload := lockserver.DoorCardRequest{
|
||||
RoomField: "101",
|
||||
CheckinTime: "2026-07-23 15:00:00 +0100",
|
||||
CheckoutTime: "2026-07-24 11:00:00 +0100",
|
||||
FollowStr: "0",
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
app := &App{
|
||||
disp: dispenser,
|
||||
lockserver: lock,
|
||||
cfg: &config.ConfigRec{},
|
||||
}
|
||||
request := httptest.NewRequest(http.MethodPost, "/issuedoorcard", bytes.NewReader(body))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
recorder := httptest.NewRecorder()
|
||||
|
||||
app.issueDoorCard(recorder, request)
|
||||
|
||||
var response cmstypes.StatusRec
|
||||
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
|
||||
t.Fatalf("decode response %q: %v", recorder.Body.String(), err)
|
||||
}
|
||||
return recorder, response, app
|
||||
}
|
||||
|
||||
func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
|
||||
encodingErr := errors.New("key encoding failed")
|
||||
tests := []struct {
|
||||
name string
|
||||
dispenser fakeDoorCardDispenser
|
||||
lockErr error
|
||||
wantHTTP int
|
||||
wantMessage string
|
||||
wantCalls []string
|
||||
wantLockSequence int
|
||||
wantCardWell string
|
||||
}{
|
||||
{
|
||||
name: "initial dispenser preparation failure is unavailable",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
prepareCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("card jammed")},
|
||||
},
|
||||
wantHTTP: http.StatusServiceUnavailable,
|
||||
wantMessage: "Dispense error: card jammed",
|
||||
wantCalls: []string{"prepare current"},
|
||||
wantCardWell: "Card jammed",
|
||||
},
|
||||
{
|
||||
name: "initial empty card well has stable message",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
prepareCurrent: dispenserCallResult{status: "Card empty", err: dispenser.ErrCardWellEmpty},
|
||||
},
|
||||
wantHTTP: http.StatusServiceUnavailable,
|
||||
wantMessage: dispenser.CardWellEmptyMessage,
|
||||
wantCalls: []string{"prepare current"},
|
||||
wantCardWell: "Card empty",
|
||||
},
|
||||
{
|
||||
name: "encoding and accepted delivery command succeed",
|
||||
wantHTTP: http.StatusOK,
|
||||
wantMessage: "Card issued successfully",
|
||||
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
|
||||
wantLockSequence: 1,
|
||||
},
|
||||
{
|
||||
name: "successful encoding with delivery command failure is unavailable",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
|
||||
},
|
||||
wantHTTP: http.StatusServiceUnavailable,
|
||||
wantMessage: "Card delivery could not be confirmed",
|
||||
wantCalls: []string{"prepare current", "deliver current"},
|
||||
wantLockSequence: 1,
|
||||
wantCardWell: "Card jammed",
|
||||
},
|
||||
{
|
||||
name: "failed next-card dispatch does not undo delivered card",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
beginNextErr: errors.New("dispatch failed"),
|
||||
},
|
||||
wantHTTP: http.StatusOK,
|
||||
wantMessage: "Card issued successfully",
|
||||
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
|
||||
wantLockSequence: 1,
|
||||
},
|
||||
{
|
||||
name: "encoding failure with safe recovery remains retryable",
|
||||
lockErr: encodingErr,
|
||||
wantHTTP: http.StatusBadGateway,
|
||||
wantMessage: encodingErr.Error(),
|
||||
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
|
||||
wantLockSequence: 1,
|
||||
},
|
||||
{
|
||||
name: "encoding failure with failed-card delivery failure is unavailable",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
|
||||
},
|
||||
lockErr: encodingErr,
|
||||
wantHTTP: http.StatusServiceUnavailable,
|
||||
wantMessage: "Dispenser recovery failed; another encoding attempt is not safe",
|
||||
wantCalls: []string{"prepare current", "deliver current"},
|
||||
wantLockSequence: 1,
|
||||
wantCardWell: "Card jammed",
|
||||
},
|
||||
{
|
||||
name: "encoding failure with empty card well has stable message",
|
||||
dispenser: fakeDoorCardDispenser{
|
||||
prepareNext: dispenserCallResult{status: "Card empty", err: dispenser.ErrCardWellEmpty},
|
||||
},
|
||||
lockErr: encodingErr,
|
||||
wantHTTP: http.StatusServiceUnavailable,
|
||||
wantMessage: dispenser.CardWellEmptyMessage,
|
||||
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
|
||||
wantLockSequence: 1,
|
||||
wantCardWell: "Card empty",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
dispenser := test.dispenser
|
||||
lock := &fakeDoorCardLockServer{sequenceErr: test.lockErr}
|
||||
|
||||
recorder, response, app := performIssueDoorCardRequest(t, &dispenser, lock)
|
||||
|
||||
if recorder.Code != test.wantHTTP {
|
||||
t.Fatalf("HTTP status = %d, want %d", recorder.Code, test.wantHTTP)
|
||||
}
|
||||
if response.Code != test.wantHTTP {
|
||||
t.Fatalf("response code = %d, want %d", response.Code, test.wantHTTP)
|
||||
}
|
||||
if response.Message != test.wantMessage {
|
||||
t.Fatalf("response message = %q, want %q", response.Message, test.wantMessage)
|
||||
}
|
||||
if !reflect.DeepEqual(dispenser.calls, test.wantCalls) {
|
||||
t.Fatalf("dispenser calls = %#v, want %#v", dispenser.calls, test.wantCalls)
|
||||
}
|
||||
if lock.sequenceCalls != test.wantLockSequence {
|
||||
t.Fatalf("lock sequence calls = %d, want %d", lock.sequenceCalls, test.wantLockSequence)
|
||||
}
|
||||
if test.wantLockSequence > 0 && lock.buildCalls != 1 {
|
||||
t.Fatalf("build command calls = %d, want 1", lock.buildCalls)
|
||||
}
|
||||
if test.wantLockSequence == 0 && lock.buildCalls != 0 {
|
||||
t.Fatalf("build command calls = %d, want 0", lock.buildCalls)
|
||||
}
|
||||
if got := app.CardWellStatus(); got != test.wantCardWell {
|
||||
t.Fatalf("card-well status = %q, want %q", got, test.wantCardWell)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type responseTrackingRecorder struct {
|
||||
*httptest.ResponseRecorder
|
||||
wroteResponse bool
|
||||
}
|
||||
|
||||
func (r *responseTrackingRecorder) WriteHeader(statusCode int) {
|
||||
r.wroteResponse = true
|
||||
r.ResponseRecorder.WriteHeader(statusCode)
|
||||
}
|
||||
|
||||
func (r *responseTrackingRecorder) Write(body []byte) (int, error) {
|
||||
r.wroteResponse = true
|
||||
return r.ResponseRecorder.Write(body)
|
||||
}
|
||||
|
||||
func TestIssueDoorCardDispatchesNextCardBeforeHTTP200(t *testing.T) {
|
||||
var recorder *responseTrackingRecorder
|
||||
dispatchCalled := false
|
||||
dispenser := &fakeDoorCardDispenser{
|
||||
beginNext: func() error {
|
||||
dispatchCalled = true
|
||||
if recorder.wroteResponse {
|
||||
t.Error("HTTP response started before next-card preparation was dispatched")
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
lock := &fakeDoorCardLockServer{}
|
||||
payload := lockserver.DoorCardRequest{
|
||||
RoomField: "101",
|
||||
CheckinTime: "2026-07-23 15:00:00 +0100",
|
||||
CheckoutTime: "2026-07-24 11:00:00 +0100",
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
app := &App{disp: dispenser, lockserver: lock, cfg: &config.ConfigRec{}}
|
||||
request := httptest.NewRequest(http.MethodPost, "/issuedoorcard", bytes.NewReader(body))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
recorder = &responseTrackingRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
|
||||
app.issueDoorCard(recorder, request)
|
||||
|
||||
if !dispatchCalled {
|
||||
t.Fatal("next-card preparation was not dispatched")
|
||||
}
|
||||
if recorder.Code != http.StatusOK {
|
||||
t.Fatalf("HTTP status = %d, want %d", recorder.Code, http.StatusOK)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssueDoorCardLogsNextCardDispatchFailureAndStillSucceeds(t *testing.T) {
|
||||
var logOutput bytes.Buffer
|
||||
standardLogger := log.StandardLogger()
|
||||
previousOutput := standardLogger.Out
|
||||
standardLogger.SetOutput(&logOutput)
|
||||
t.Cleanup(func() {
|
||||
standardLogger.SetOutput(previousOutput)
|
||||
})
|
||||
|
||||
dispenser := &fakeDoorCardDispenser{beginNextErr: errors.New("dispatch failed")}
|
||||
lock := &fakeDoorCardLockServer{}
|
||||
recorder, _, _ := performIssueDoorCardRequest(t, dispenser, lock)
|
||||
|
||||
if recorder.Code != http.StatusOK {
|
||||
t.Fatalf("HTTP status = %d, want %d", recorder.Code, http.StatusOK)
|
||||
}
|
||||
logged := logOutput.String()
|
||||
if !strings.Contains(logged, "dispatch failed") ||
|
||||
!strings.Contains(logged, "Next card preparation dispatch") {
|
||||
t.Fatalf("dispatch failure log = %q", logged)
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,8 @@ import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
@@ -13,28 +15,40 @@ import (
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/printer"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type doorCardDispenser interface {
|
||||
PrepareCurrentCard(context.Context) (string, error)
|
||||
DeliverCurrentCard(context.Context) (string, error)
|
||||
BeginPrepareNextCard(context.Context) error
|
||||
PrepareNextCard(context.Context) (string, error)
|
||||
}
|
||||
|
||||
type App struct {
|
||||
disp *dispenser.Client
|
||||
lockserver lockserver.LockServer
|
||||
isPayment bool
|
||||
db *sql.DB
|
||||
cfg *config.ConfigRec
|
||||
dbMu sync.Mutex
|
||||
cardWellMu sync.RWMutex
|
||||
cardWellStatus string
|
||||
availabilityMu sync.Mutex
|
||||
availabilityTimers map[string]*time.Timer
|
||||
disp doorCardDispenser
|
||||
lockserver lockserver.LockServer
|
||||
paymentService *paymentsvc.Service
|
||||
creditCallStreamEnabled bool
|
||||
creditCallTransport http.RoundTripper
|
||||
creditCallReceipt func(string)
|
||||
isPayment bool
|
||||
db *sql.DB
|
||||
cfg *config.ConfigRec
|
||||
dbMu sync.Mutex
|
||||
cardWellMu sync.RWMutex
|
||||
cardWellStatus string
|
||||
availabilityMu sync.Mutex
|
||||
availabilityTimers map[string]*time.Timer
|
||||
}
|
||||
|
||||
func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus string, db *sql.DB, cfg *config.ConfigRec) *App {
|
||||
@@ -50,6 +64,10 @@ func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus str
|
||||
return app
|
||||
}
|
||||
|
||||
func (app *App) SetPaymentService(service *paymentsvc.Service) {
|
||||
app.paymentService = service
|
||||
}
|
||||
|
||||
func (app *App) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("/issuedoorcard", app.issueDoorCard)
|
||||
mux.HandleFunc("/printroomticket", app.printRoomTicket)
|
||||
@@ -59,6 +77,8 @@ func (app *App) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("/testissuedoorcard", app.testIssueDoorCard)
|
||||
mux.HandleFunc("/ping-pdq", app.fetchChipDNAStatus)
|
||||
mux.HandleFunc("/logerror", app.onChipDNAError)
|
||||
mux.HandleFunc("/api/payment/sale", app.salePayment)
|
||||
mux.HandleFunc("/api/payment/preauth", app.streamCreditCallPreauth)
|
||||
}
|
||||
|
||||
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
@@ -67,9 +87,6 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
var (
|
||||
theResponse cmstypes.ResponseRec
|
||||
theRequest cmstypes.TransactionRec
|
||||
trResult payment.TransactionResultXML
|
||||
result payment.PaymentResult
|
||||
save bool
|
||||
)
|
||||
|
||||
theResponse.Status.Code = http.StatusInternalServerError
|
||||
@@ -83,7 +100,7 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
if !app.isPayment {
|
||||
if !app.cfg.TestMode {
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted preauthorization while payment processing is disabled")
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
||||
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
|
||||
return
|
||||
}
|
||||
@@ -96,13 +113,13 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
log.Println("takePreauthorization called")
|
||||
if r.Method != http.MethodPost {
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
||||
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if r.Header.Get("Content-Type") != "text/xml" {
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
||||
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
||||
return
|
||||
}
|
||||
@@ -112,14 +129,14 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
body, err := io.ReadAll(r.Body)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Failed to read request body")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
|
||||
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if err := xml.Unmarshal(body, &theRequest); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
||||
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
||||
return
|
||||
}
|
||||
@@ -130,39 +147,18 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
||||
theRequest.TransactionType,
|
||||
)
|
||||
|
||||
client := &http.Client{Timeout: 300 * time.Second}
|
||||
|
||||
// ---- START TRANSACTION ----
|
||||
|
||||
body, err = callChipDNA(client, types.LinkStartTransaction, body)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Preauth processing error", string(op), "", "", 0)
|
||||
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "No response from payment processor")
|
||||
writeTransactionResult(w, http.StatusBadGateway, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if err := trResult.ParseTransactionResult(body); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
||||
}
|
||||
|
||||
result.FillFromTransactionResult(trResult)
|
||||
|
||||
// ---- PRINT RECEIPT ----
|
||||
|
||||
printer.PrintReceipt(result.CardholderReceipt)
|
||||
|
||||
// ---- REDIRECT ----
|
||||
|
||||
theResponse.Status = result.Status
|
||||
theResponse.Data, save = payment.BuildPreauthRedirectURL(result.Fields)
|
||||
|
||||
if save {
|
||||
go app.persistPreauth(context.Background(), result.Fields, theRequest.CheckoutDate)
|
||||
}
|
||||
|
||||
writeTransactionResult(w, http.StatusOK, theResponse)
|
||||
outcome := app.executeCreditCallPreauth(context.Background(), theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
|
||||
var transaction creditcall.TransactionResultXML
|
||||
response, err := callChipDNA(client, types.LinkStartTransaction, body)
|
||||
if err != nil {
|
||||
return transaction, err
|
||||
}
|
||||
if err := transaction.ParseTransactionResult(response); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
||||
}
|
||||
return transaction, nil
|
||||
})
|
||||
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
|
||||
}
|
||||
|
||||
func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
@@ -171,8 +167,6 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
var (
|
||||
theResponse cmstypes.ResponseRec
|
||||
theRequest cmstypes.TransactionRec
|
||||
trResult payment.TransactionResultXML
|
||||
result payment.PaymentResult
|
||||
)
|
||||
|
||||
theResponse.Status.Code = http.StatusInternalServerError
|
||||
@@ -187,10 +181,11 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
if !app.cfg.TestMode {
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted payment while payment processing is disabled")
|
||||
theResponse.Status.Code = http.StatusServiceUnavailable
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
||||
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if r.Method == http.MethodOptions {
|
||||
@@ -200,13 +195,13 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
log.Println("takePayment called")
|
||||
if r.Method != http.MethodPost {
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
||||
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if r.Header.Get("Content-Type") != "text/xml" {
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
||||
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
||||
return
|
||||
}
|
||||
@@ -216,14 +211,14 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
body, err := io.ReadAll(r.Body)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Failed to read request body")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
|
||||
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if err := xml.Unmarshal(body, &theRequest); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
||||
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
||||
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
||||
return
|
||||
}
|
||||
@@ -233,90 +228,18 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
||||
theRequest.TransactionType,
|
||||
)
|
||||
|
||||
client := &http.Client{Timeout: 300 * time.Second}
|
||||
|
||||
// ---- START TRANSACTION ----
|
||||
|
||||
body, err = callChipDNA(client, types.LinkStartTransaction, body)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Start transaction error", string(op), "", "", 0)
|
||||
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "No response from payment processor")
|
||||
writeTransactionResult(w, http.StatusBadGateway, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if err := trResult.ParseTransactionResult(body); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
||||
}
|
||||
|
||||
result.FillFromTransactionResult(trResult)
|
||||
|
||||
res := result.Fields[types.TransactionResult]
|
||||
|
||||
if !strings.EqualFold(res, types.ResultApproved) {
|
||||
printer.PrintReceipt(result.CardholderReceipt)
|
||||
desc := result.Fields[types.ErrorDescription]
|
||||
if desc == "" {
|
||||
desc = result.Fields[types.Errors]
|
||||
outcome := app.executeCreditCallSale(theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
|
||||
var trResult creditcall.TransactionResultXML
|
||||
body, err := callChipDNA(client, types.LinkStartTransaction, body)
|
||||
if err != nil {
|
||||
return trResult, err
|
||||
}
|
||||
logging.Error(types.ServiceName, "Preauthorization failed", "Result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
theResponse.Status = result.Status
|
||||
theResponse.Data = payment.BuildFailureURL(res, result.Fields[types.Errors])
|
||||
|
||||
writeTransactionResult(w, http.StatusOK, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
// ---- CONFIRM TRANSACTION ----
|
||||
|
||||
ref := result.Fields[types.Reference]
|
||||
log.Printf("Preauth approved, reference: %s. Sending confirm...", ref)
|
||||
confirmReq := payment.ConfirmTransactionRequest{
|
||||
Amount: theRequest.AmountMinorUnits,
|
||||
Reference: ref,
|
||||
}
|
||||
|
||||
body, err = confirmWithRetry(client, confirmReq, 2)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Confirm transaction error", string(op), "", "", 0)
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Error: "+err.Error())
|
||||
theResponse.Data = payment.BuildFailureURL(types.ResultError, "ConfirmTransactionError")
|
||||
writeTransactionResult(w, http.StatusBadGateway, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
if err := trResult.ParseTransactionResult(body); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse confirm result error", string(op), "", "", 0)
|
||||
}
|
||||
|
||||
result.FillFromTransactionResult(trResult)
|
||||
|
||||
res = result.Fields[types.TransactionResult]
|
||||
|
||||
if !strings.EqualFold(res, types.ResultApproved) {
|
||||
printer.PrintReceipt(result.CardholderReceipt)
|
||||
desc := result.Fields[types.ErrorDescription]
|
||||
if desc == "" {
|
||||
desc = result.Fields[types.Errors]
|
||||
if err := trResult.ParseTransactionResult(body); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
||||
}
|
||||
logging.Error(types.ServiceName, "Transaction not approved after confirm", "Confirm result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
|
||||
theResponse.Status = result.Status
|
||||
theResponse.Data = payment.BuildFailureURL(res, result.Fields[types.Errors])
|
||||
|
||||
writeTransactionResult(w, http.StatusOK, theResponse)
|
||||
return
|
||||
}
|
||||
|
||||
// ---- SUCCESS ----
|
||||
|
||||
printer.PrintReceipt(result.CardholderReceipt)
|
||||
log.Printf("Transaction approved and confirmed, reference: %s", ref)
|
||||
theResponse.Status = result.Status
|
||||
theResponse.Data = payment.BuildSuccessURL(result.Fields)
|
||||
|
||||
writeTransactionResult(w, http.StatusOK, theResponse)
|
||||
return trResult, nil
|
||||
})
|
||||
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
|
||||
}
|
||||
|
||||
func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
|
||||
@@ -368,46 +291,69 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
// Ensure dispenser ready (card at encoder) BEFORE we attempt encoding.
|
||||
// With queued dispenser ops, this will not clash with polling.
|
||||
status, err := app.disp.DispenserStart(r.Context())
|
||||
status, err := app.disp.PrepareCurrentCard(r.Context())
|
||||
app.SetCardWellStatus(status)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
|
||||
if errors.Is(err, dispenser.ErrCardWellEmpty) {
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
|
||||
return
|
||||
}
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Always attempt to finalize after we have moved a card / started an issuance flow.
|
||||
// This guarantees we eject and prepare the next card even on lock failures.
|
||||
finalize := func() {
|
||||
if app.disp == nil {
|
||||
return
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
|
||||
status, ferr := app.disp.DispenserFinal(ctx)
|
||||
if ferr != nil {
|
||||
logging.Error(types.ServiceName, ferr.Error(), "Dispenser final error", string(op), "", "", 0)
|
||||
return
|
||||
}
|
||||
app.SetCardWellStatus(status)
|
||||
}
|
||||
|
||||
// doorReq.RoomField = "104"
|
||||
// build lock server command
|
||||
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
|
||||
|
||||
// lock server sequence
|
||||
if err := app.lockserver.LockSequence(); err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Key encoding", string(op), "", "", 0)
|
||||
finalize()
|
||||
errorhandlers.WriteError(w, http.StatusBadGateway, err.Error())
|
||||
encodingErr := app.lockserver.LockSequence()
|
||||
if encodingErr != nil {
|
||||
logging.Error(types.ServiceName, encodingErr.Error(), "Key encoding", string(op), "", "", 0)
|
||||
}
|
||||
|
||||
// Once encoding has started, finish the physical dispenser sequence even if
|
||||
// the HTTP client disconnects. Finalization remains bounded by one shared timeout.
|
||||
finalizeCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
status, deliveryErr := app.disp.DeliverCurrentCard(finalizeCtx)
|
||||
app.SetCardWellStatus(status)
|
||||
if deliveryErr != nil {
|
||||
if encodingErr != nil {
|
||||
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, deliveryErr)
|
||||
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
|
||||
return
|
||||
}
|
||||
|
||||
logging.Error(types.ServiceName, deliveryErr.Error(), "Card delivery", string(op), "", "", 0)
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Card delivery could not be confirmed")
|
||||
return
|
||||
}
|
||||
|
||||
// final dispenser steps
|
||||
finalize()
|
||||
if encodingErr != nil {
|
||||
status, preparationErr := app.disp.PrepareNextCard(finalizeCtx)
|
||||
app.SetCardWellStatus(status)
|
||||
if preparationErr != nil {
|
||||
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, preparationErr)
|
||||
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
|
||||
if errors.Is(preparationErr, dispenser.ErrCardWellEmpty) {
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
|
||||
return
|
||||
}
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
|
||||
return
|
||||
}
|
||||
|
||||
errorhandlers.WriteError(w, http.StatusBadGateway, encodingErr.Error())
|
||||
return
|
||||
}
|
||||
|
||||
if preparationErr := app.disp.BeginPrepareNextCard(finalizeCtx); preparationErr != nil {
|
||||
logging.Error(types.ServiceName, preparationErr.Error(), "Next card preparation dispatch", string(op), "", "", 0)
|
||||
}
|
||||
|
||||
theResponse.Code = http.StatusOK
|
||||
theResponse.Message = "Card issued successfully"
|
||||
@@ -9,8 +9,8 @@ import (
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
@@ -34,7 +34,7 @@ func callChipDNA(client *http.Client, url string, payload []byte) ([]byte, error
|
||||
return io.ReadAll(resp.Body)
|
||||
}
|
||||
|
||||
func confirmWithRetry(client *http.Client, req payment.ConfirmTransactionRequest, attempts int) ([]byte, error) {
|
||||
func confirmWithRetry(client *http.Client, req creditcall.ConfirmTransactionRequest, attempts int) ([]byte, error) {
|
||||
|
||||
payload, err := xml.Marshal(req)
|
||||
if err != nil {
|
||||
@@ -69,3 +69,14 @@ func confirmWithRetry(client *http.Client, req payment.ConfirmTransactionRequest
|
||||
|
||||
return nil, lastErr
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, payload any) {
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
w.WriteHeader(status)
|
||||
|
||||
if payload == nil {
|
||||
return
|
||||
}
|
||||
|
||||
_ = json.NewEncoder(w).Encode(payload)
|
||||
}
|
||||
@@ -0,0 +1,340 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
"github.com/google/uuid"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type SalePaymentRequest struct {
|
||||
Reference string `json:"reference,omitempty"`
|
||||
ConfirmNo string `json:"confirmNo,omitempty"`
|
||||
Amount int64 `json:"amount"`
|
||||
Currency string `json:"currency,omitempty"`
|
||||
}
|
||||
|
||||
type paymentStreamMessage struct {
|
||||
Type string `json:"type"`
|
||||
Code string `json:"code,omitempty"`
|
||||
Response *cmstypes.ResponseRec `json:"response,omitempty"`
|
||||
Result *creditCallStreamResult `json:"result,omitempty"`
|
||||
}
|
||||
|
||||
func (app *App) salePayment(w http.ResponseWriter, r *http.Request) {
|
||||
const op = logging.Op("salePayment")
|
||||
|
||||
if app.creditCallStreamEnabled {
|
||||
app.streamCreditCallSale(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
response := cmstypes.ResponseRec{
|
||||
Status: cmstypes.StatusRec{
|
||||
Code: http.StatusInternalServerError,
|
||||
Message: http.StatusText(http.StatusInternalServerError),
|
||||
},
|
||||
}
|
||||
|
||||
setPaymentCORS(w)
|
||||
|
||||
if r.Method == http.MethodOptions {
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
return
|
||||
}
|
||||
|
||||
if r.Method != http.MethodPost {
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, "Method not allowed; use POST")
|
||||
writeTransactionResult(w, http.StatusMethodNotAllowed, response)
|
||||
return
|
||||
}
|
||||
|
||||
if app.paymentService == nil {
|
||||
mail.SendEmailOnError(
|
||||
app.cfg.Hotel,
|
||||
app.cfg.Kiosk,
|
||||
"Payment Service Not Configured",
|
||||
"Payment service is not configured; cannot process payment requests",
|
||||
)
|
||||
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, "Payment service is not configured")
|
||||
writeTransactionResult(w, http.StatusInternalServerError, response)
|
||||
return
|
||||
}
|
||||
|
||||
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, "Content-Type must be application/json")
|
||||
writeTransactionResult(w, http.StatusUnsupportedMediaType, response)
|
||||
return
|
||||
}
|
||||
|
||||
defer r.Body.Close()
|
||||
|
||||
var req SalePaymentRequest
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
logging.Error(
|
||||
types.ServiceName,
|
||||
err.Error(),
|
||||
"ReadJSON",
|
||||
string(op),
|
||||
"",
|
||||
app.cfg.Hotel,
|
||||
app.cfg.Kiosk,
|
||||
)
|
||||
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, "invalid JSON payload: "+err.Error())
|
||||
writeTransactionResult(w, http.StatusBadRequest, response)
|
||||
return
|
||||
}
|
||||
|
||||
if req.Amount <= 0 {
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, "Amount must be greater than zero")
|
||||
writeTransactionResult(w, http.StatusBadRequest, response)
|
||||
return
|
||||
}
|
||||
|
||||
if req.Currency == "" {
|
||||
req.Currency = "GBP"
|
||||
}
|
||||
|
||||
if req.Reference == "" {
|
||||
req.Reference = req.ConfirmNo
|
||||
}
|
||||
|
||||
if req.Reference == "" {
|
||||
req.Reference = uuid.NewString()
|
||||
}
|
||||
|
||||
requestID := buildPaymentRequestID(req.Reference)
|
||||
|
||||
timeoutSeconds := app.cfg.TimeoutSeconds
|
||||
if timeoutSeconds <= 0 {
|
||||
timeoutSeconds = 300
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(
|
||||
r.Context(),
|
||||
time.Duration(timeoutSeconds)*time.Second,
|
||||
)
|
||||
defer cancel()
|
||||
|
||||
flusher, ok := w.(http.Flusher)
|
||||
if !ok {
|
||||
response.Data = buildPaymentFailureURL(
|
||||
types.ResultError,
|
||||
"Streaming payment updates are not supported",
|
||||
)
|
||||
writeTransactionResult(w, http.StatusInternalServerError, response)
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||||
|
||||
encoder := json.NewEncoder(w)
|
||||
|
||||
var streamMu sync.Mutex
|
||||
streamStarted := false
|
||||
streamFailed := false
|
||||
|
||||
sendStreamMessage := func(message paymentStreamMessage) {
|
||||
streamMu.Lock()
|
||||
defer streamMu.Unlock()
|
||||
|
||||
if streamFailed {
|
||||
return
|
||||
}
|
||||
|
||||
if err := encoder.Encode(message); err != nil {
|
||||
streamFailed = true
|
||||
return
|
||||
}
|
||||
|
||||
streamStarted = true
|
||||
flusher.Flush()
|
||||
}
|
||||
|
||||
onStatus := func(update paymentsvc.StatusUpdate) {
|
||||
if update.Code == "" {
|
||||
return
|
||||
}
|
||||
|
||||
sendStreamMessage(paymentStreamMessage{
|
||||
Type: "status",
|
||||
Code: update.Code,
|
||||
})
|
||||
}
|
||||
|
||||
result, err := app.paymentService.Sale(
|
||||
ctx,
|
||||
paymentsvc.SaleRequest{
|
||||
RequestID: requestID,
|
||||
Reference: req.Reference,
|
||||
Amount: req.Amount,
|
||||
Currency: req.Currency,
|
||||
},
|
||||
onStatus,
|
||||
)
|
||||
|
||||
if err != nil {
|
||||
status := http.StatusBadGateway
|
||||
if errors.Is(err, paymentsvc.ErrPaymentInProgress) {
|
||||
status = http.StatusConflict
|
||||
}
|
||||
|
||||
logging.Error(
|
||||
types.ServiceName,
|
||||
err.Error(),
|
||||
"Payment provider error",
|
||||
string(op),
|
||||
req.Reference,
|
||||
app.cfg.Hotel,
|
||||
app.cfg.Kiosk,
|
||||
)
|
||||
|
||||
response.Status.Code = status
|
||||
response.Status.Message = http.StatusText(status)
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, err.Error())
|
||||
|
||||
if !streamStarted {
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
writeTransactionResult(w, status, response)
|
||||
return
|
||||
}
|
||||
|
||||
sendStreamMessage(paymentStreamMessage{
|
||||
Type: "result",
|
||||
Response: &response,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if result == nil {
|
||||
response.Status.Code = http.StatusBadGateway
|
||||
response.Status.Message = "Empty payment result"
|
||||
response.Data = buildPaymentFailureURL(
|
||||
types.ResultError,
|
||||
"Payment provider returned an empty result",
|
||||
)
|
||||
|
||||
if !streamStarted {
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
writeTransactionResult(w, http.StatusBadGateway, response)
|
||||
return
|
||||
}
|
||||
|
||||
sendStreamMessage(paymentStreamMessage{
|
||||
Type: "result",
|
||||
Response: &response,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
response.Status.Code = http.StatusOK
|
||||
|
||||
if result.Success && strings.EqualFold(result.Status, "APPROVED") {
|
||||
printer.PrintSaleReceipt(result.CustomerReceipt)
|
||||
|
||||
response.Status.Message = result.Message
|
||||
response.Data = buildPaymentSuccessURL(result)
|
||||
|
||||
sendStreamMessage(paymentStreamMessage{
|
||||
Type: "result",
|
||||
Response: &response,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
description := result.ErrorMessage
|
||||
if description == "" {
|
||||
description = result.Message
|
||||
}
|
||||
if description == "" {
|
||||
description = result.Status
|
||||
}
|
||||
|
||||
log.Printf("Transaction failed: %s", description)
|
||||
printer.PrintSaleReceipt(result.CustomerReceipt)
|
||||
|
||||
response.Status.Message = "Payment unsuccessful"
|
||||
response.Data = buildPaymentFailureURL(types.ResultError, description)
|
||||
|
||||
sendStreamMessage(paymentStreamMessage{
|
||||
Type: "result",
|
||||
Response: &response,
|
||||
})
|
||||
}
|
||||
|
||||
func buildPaymentRequestID(reference string) string {
|
||||
const prefix = "REQ_"
|
||||
const maxLength = 60
|
||||
|
||||
suffix := fmt.Sprintf("_%d", time.Now().UnixMilli())
|
||||
maxReferenceLength := maxLength - len(prefix) - len(suffix)
|
||||
|
||||
runes := []rune(reference)
|
||||
if len(runes) > maxReferenceLength {
|
||||
runes = runes[:maxReferenceLength]
|
||||
}
|
||||
|
||||
return prefix + string(runes) + suffix
|
||||
}
|
||||
|
||||
func setPaymentCORS(w http.ResponseWriter) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
}
|
||||
|
||||
func buildPaymentSuccessURL(result *paymentsvc.Result) string {
|
||||
// txnReference := result.ReferenceNumber
|
||||
// if txnReference == "" {
|
||||
// txnReference = result.TransactionID
|
||||
// }
|
||||
|
||||
q := url.Values{}
|
||||
q.Set("CardNumber", hex.EncodeToString([]byte(result.CardNumber)))
|
||||
q.Set("CardType", hex.EncodeToString([]byte(result.CardType)))
|
||||
q.Set("ExpiryDate", hex.EncodeToString([]byte(result.ExpiryDate)))
|
||||
q.Set("TxnReference", result.RequestID)
|
||||
q.Set("CardHash", hex.EncodeToString([]byte(result.CardHash)))
|
||||
q.Set("CardReference", hex.EncodeToString([]byte(result.CardReference)))
|
||||
|
||||
return (&url.URL{
|
||||
Path: types.CheckinSuccessfulEndpoint,
|
||||
RawQuery: q.Encode(),
|
||||
}).String()
|
||||
}
|
||||
|
||||
func buildPaymentFailureURL(msgType, description string) string {
|
||||
log.WithFields(log.Fields{
|
||||
types.LogFieldError: msgType,
|
||||
types.LogFieldDescription: description,
|
||||
}).Error("Transaction failed")
|
||||
|
||||
q := url.Values{}
|
||||
q.Set("MsgType", msgType)
|
||||
q.Set("Description", description)
|
||||
|
||||
return (&url.URL{
|
||||
Path: types.CheckinUnsuccessfulEndpoint,
|
||||
RawQuery: q.Encode(),
|
||||
}).String()
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
type paymentProviderFunc func(
|
||||
context.Context,
|
||||
paymentsvc.SaleRequest,
|
||||
paymentsvc.StatusHandler,
|
||||
) (*paymentsvc.Result, error)
|
||||
|
||||
func (f paymentProviderFunc) Sale(
|
||||
ctx context.Context,
|
||||
request paymentsvc.SaleRequest,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) (*paymentsvc.Result, error) {
|
||||
return f(ctx, request, onStatus)
|
||||
}
|
||||
|
||||
func TestSalePaymentStreamsTerminalUnavailableAsAuthoritativeUnsuccessfulResult(t *testing.T) {
|
||||
provider := paymentProviderFunc(func(
|
||||
_ context.Context,
|
||||
request paymentsvc.SaleRequest,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) (*paymentsvc.Result, error) {
|
||||
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
|
||||
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.TerminalUnavailable})
|
||||
return &paymentsvc.Result{
|
||||
RequestID: request.RequestID,
|
||||
Operation: "SALE",
|
||||
Status: "TERMINAL_UNAVAILABLE",
|
||||
ErrorMessage: "Payment terminal is unavailable",
|
||||
Amount: request.Amount,
|
||||
Currency: request.Currency,
|
||||
DeviceUsed: "terminal-1",
|
||||
DeviceType: "Dojo Terminal",
|
||||
}, nil
|
||||
})
|
||||
|
||||
recorder := performSalePaymentRequest(t, provider)
|
||||
if recorder.Code != http.StatusOK {
|
||||
t.Fatalf("outer status = %d, want %d", recorder.Code, http.StatusOK)
|
||||
}
|
||||
messages := decodePaymentStream(t, recorder.Body)
|
||||
if len(messages) != 3 {
|
||||
t.Fatalf("stream messages = %#v, want two statuses and one result", messages)
|
||||
}
|
||||
if messages[0].Type != "status" || messages[0].Code != paymentstatus.Starting ||
|
||||
messages[1].Type != "status" || messages[1].Code != paymentstatus.TerminalUnavailable {
|
||||
t.Fatalf("status frames = %#v", messages[:2])
|
||||
}
|
||||
final := messages[2]
|
||||
if final.Type != "result" || final.Response == nil {
|
||||
t.Fatalf("final frame = %#v", final)
|
||||
}
|
||||
if final.Response.Status.Code != http.StatusOK {
|
||||
t.Fatalf("nested status = %d, want %d", final.Response.Status.Code, http.StatusOK)
|
||||
}
|
||||
resultURL, err := url.Parse(final.Response.Data)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
|
||||
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
|
||||
}
|
||||
if got := resultURL.Query().Get("Description"); got != "Payment terminal is unavailable" {
|
||||
t.Fatalf("Description = %q", got)
|
||||
}
|
||||
|
||||
body := recorder.Body.String()
|
||||
for _, forbidden := range []string{
|
||||
"Dojo returned HTTP 409",
|
||||
"offline or currently in use",
|
||||
"traceId",
|
||||
"docs.dojo.tech",
|
||||
} {
|
||||
if strings.Contains(body, forbidden) {
|
||||
t.Fatalf("stream exposed %q: %s", forbidden, body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSalePaymentRetainsNestedBadGatewayForProviderErrorsAfterStreamingStarts(t *testing.T) {
|
||||
provider := paymentProviderFunc(func(
|
||||
_ context.Context,
|
||||
_ paymentsvc.SaleRequest,
|
||||
onStatus paymentsvc.StatusHandler,
|
||||
) (*paymentsvc.Result, error) {
|
||||
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
|
||||
return nil, errors.New("provider failed")
|
||||
})
|
||||
|
||||
recorder := performSalePaymentRequest(t, provider)
|
||||
if recorder.Code != http.StatusOK {
|
||||
t.Fatalf("outer status = %d, want streaming status %d", recorder.Code, http.StatusOK)
|
||||
}
|
||||
messages := decodePaymentStream(t, recorder.Body)
|
||||
if len(messages) != 2 || messages[1].Type != "result" || messages[1].Response == nil {
|
||||
t.Fatalf("stream messages = %#v", messages)
|
||||
}
|
||||
if messages[1].Response.Status.Code != http.StatusBadGateway {
|
||||
t.Fatalf("nested status = %d, want %d", messages[1].Response.Status.Code, http.StatusBadGateway)
|
||||
}
|
||||
resultURL, err := url.Parse(messages[1].Response.Data)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
|
||||
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
|
||||
}
|
||||
}
|
||||
|
||||
func performSalePaymentRequest(t *testing.T, provider paymentsvc.Provider) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
app := &App{
|
||||
paymentService: paymentsvc.NewService(provider),
|
||||
cfg: &config.ConfigRec{
|
||||
Hotel: "HOTEL",
|
||||
Kiosk: 7,
|
||||
TimeoutSeconds: 5,
|
||||
},
|
||||
}
|
||||
request := httptest.NewRequest(
|
||||
http.MethodPost,
|
||||
"/api/payment/sale",
|
||||
strings.NewReader(`{"reference":"BOOKING-123","amount":10852,"currency":"GBP"}`),
|
||||
)
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
recorder := httptest.NewRecorder()
|
||||
app.salePayment(recorder, request)
|
||||
return recorder
|
||||
}
|
||||
|
||||
func decodePaymentStream(t *testing.T, body io.Reader) []paymentStreamMessage {
|
||||
t.Helper()
|
||||
decoder := json.NewDecoder(body)
|
||||
var messages []paymentStreamMessage
|
||||
for {
|
||||
var message paymentStreamMessage
|
||||
if err := decoder.Decode(&message); err != nil {
|
||||
if errors.Is(err, io.EOF) {
|
||||
return messages
|
||||
}
|
||||
t.Fatal(err)
|
||||
}
|
||||
messages = append(messages, message)
|
||||
}
|
||||
}
|
||||
@@ -9,11 +9,11 @@ import (
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/logging"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
@@ -59,7 +59,7 @@ func (app *App) testIssueDoorCard(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
// Ensure dispenser ready (card at encoder) BEFORE we attempt encoding.
|
||||
// With queued dispenser ops, this will not clash with polling.
|
||||
status, err := app.disp.DispenserStart(r.Context())
|
||||
status, err := app.disp.PrepareCurrentCard(r.Context())
|
||||
app.SetCardWellStatus(status)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
|
||||
@@ -91,7 +91,7 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
status, err := payment.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk)
|
||||
status, err := creditcall.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk)
|
||||
if err != nil {
|
||||
logging.Error(types.ServiceName, err.Error(), "fetchChipDNAStatus", string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
errorhandlers.WriteError(w, http.StatusServiceUnavailable, err.Error())
|
||||
@@ -111,7 +111,7 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
func (app *App) onChipDNAError(w http.ResponseWriter, r *http.Request) {
|
||||
const op = logging.Op("onChipDNAError")
|
||||
var tr payment.TransactionResultXML
|
||||
var tr creditcall.TransactionResultXML
|
||||
title := "ChipDNA Error"
|
||||
message := ""
|
||||
|
||||
@@ -168,10 +168,10 @@ func (app *App) onChipDNAError(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
switch e.Key {
|
||||
|
||||
case payment.KeyErrors:
|
||||
case creditcall.KeyErrors:
|
||||
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, title, e.Value)
|
||||
|
||||
case payment.KeyIsAvailable:
|
||||
case creditcall.KeyIsAvailable:
|
||||
isAvailable := strings.EqualFold(e.Value, "true")
|
||||
app.handleAvailabilityDebounced(isAvailable)
|
||||
}
|
||||
@@ -192,8 +192,13 @@ func (app *App) onChipDNAError(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
func (app *App) handleAvailabilityDebounced(isAvailable bool) {
|
||||
title := "ChipDNA Error"
|
||||
key := fmt.Sprintf("%s-%d", app.cfg.Hotel, app.cfg.Kiosk)
|
||||
const (
|
||||
debounceDay = 30
|
||||
debounceNight = 600
|
||||
title = "ChipDNA Error"
|
||||
)
|
||||
|
||||
key := app.availabilityKey()
|
||||
|
||||
app.availabilityMu.Lock()
|
||||
defer app.availabilityMu.Unlock()
|
||||
@@ -213,14 +218,21 @@ func (app *App) handleAvailabilityDebounced(isAvailable bool) {
|
||||
return
|
||||
}
|
||||
|
||||
log.Println("PDQ reported unavailable - starting 10s debounce timer")
|
||||
debounce := debounceDay
|
||||
|
||||
timer := time.AfterFunc(5*time.Second, func() {
|
||||
hour := time.Now().Hour()
|
||||
if hour < 6 {
|
||||
debounce = debounceNight
|
||||
}
|
||||
|
||||
log.Printf("PDQ reported unavailable - starting %ds debounce timer", debounce)
|
||||
|
||||
timer := time.AfterFunc(time.Duration(debounce)*time.Second, func() {
|
||||
mail.SendEmailOnError(
|
||||
app.cfg.Hotel,
|
||||
app.cfg.Kiosk,
|
||||
title,
|
||||
"ChipDNA PDQ unavailable for more than 5 seconds",
|
||||
fmt.Sprintf("ChipDNA PDQ unavailable for more than %d seconds", debounce),
|
||||
)
|
||||
|
||||
app.availabilityMu.Lock()
|
||||
@@ -230,3 +242,11 @@ func (app *App) handleAvailabilityDebounced(isAvailable bool) {
|
||||
|
||||
app.availabilityTimers[key] = timer
|
||||
}
|
||||
|
||||
func (app *App) availabilityKey() string {
|
||||
return fmt.Sprintf("hotel=%s|kiosk=%d|app=%p",
|
||||
strings.TrimSpace(app.cfg.Hotel),
|
||||
app.cfg.Kiosk,
|
||||
app,
|
||||
)
|
||||
}
|
||||
@@ -1,15 +1,16 @@
|
||||
// Package lockserver provides functionality for interacting with Assa Abloy lock servers.
|
||||
package lockserver
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"time"
|
||||
"strings"
|
||||
|
||||
"time"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
// Build key encoding request command for the Assa Abloy lock server.
|
||||
// BuildCommand builds a key encoding request command for the Assa Abloy lock server.
|
||||
func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
|
||||
ci := checkIn.Format("200601021504")
|
||||
co := checkOut.Format("200601021504")
|
||||
@@ -18,7 +19,7 @@ func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
|
||||
return nil
|
||||
}
|
||||
|
||||
// Checks heart beat of the Assa Abloy lock server and perform key encoding
|
||||
// LockSequence checks heartbeat of the Assa Abloy lock server and performs key encoding
|
||||
func (lock *AssaLockServer) LockSequence() error {
|
||||
const funcName = "AssaLockServer.LockSequence"
|
||||
|
||||
@@ -71,4 +72,3 @@ func parseAssaResponse(raw string) (string, error) {
|
||||
}
|
||||
return "Success: " + clean, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,291 @@
|
||||
package lockserver
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
const (
|
||||
kabaSTX = 0x02
|
||||
kabaETX = 0x03
|
||||
kabaACK = 0x06
|
||||
kabaNAK = 0x15
|
||||
)
|
||||
|
||||
// BuildCommand builds a key encoding request command for the dormakaba/Kaba lock server.
|
||||
// KR|KTD|WS192.168.135.20|KC2|RN41|KO000000|GA241213|TI16:56|GD241214|DT11:00|G#75|
|
||||
func (lock *KabaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
|
||||
const funcName = "DormakabaLockServer.BuildCommand"
|
||||
|
||||
room := strings.TrimSpace(doorReq.RoomField)
|
||||
if room == "" {
|
||||
return fmt.Errorf("[%s] roomField is required", funcName)
|
||||
}
|
||||
|
||||
if checkIn.IsZero() {
|
||||
return fmt.Errorf("[%s] checkin time is required", funcName)
|
||||
}
|
||||
|
||||
if checkOut.IsZero() {
|
||||
return fmt.Errorf("[%s] checkout time is required", funcName)
|
||||
}
|
||||
|
||||
ws := dormakabaWorkstationID()
|
||||
|
||||
ga := checkIn.Format("060102") // yyMMdd, example: 241213
|
||||
gd := checkOut.Format("060102") // yyMMdd, example: 241214
|
||||
ti := checkIn.Format("15:04") // HH:mm, example: 16:56
|
||||
dt := checkOut.Format("15:04") // HH:mm, example: 11:00
|
||||
|
||||
payload := fmt.Sprintf(
|
||||
"KR|KTD|WS%s|KC%s|RN%s|KO000000|GA%s|TI%s|GD%s|DT%s|G#75|",
|
||||
ws,
|
||||
lock.encoderAddr,
|
||||
room,
|
||||
ga,
|
||||
ti,
|
||||
gd,
|
||||
dt,
|
||||
)
|
||||
|
||||
lock.command = wrapKabaFrame(payload)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// LockSequence starts the link and performs key encoding.
|
||||
func (lock *KabaLockServer) LockSequence() error {
|
||||
const funcName = "KabaLockServer.LockSequence"
|
||||
|
||||
conn, err := InitializeServerConnection(LockServerURL)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
reader := bufio.NewReader(conn)
|
||||
|
||||
regs, err := lock.linkStart(conn, reader)
|
||||
if err != nil {
|
||||
return fmt.Errorf("[%s] linkStart failed: %v", funcName, err)
|
||||
}
|
||||
|
||||
for _, reg := range regs {
|
||||
log.Printf("Received: %q", reg)
|
||||
}
|
||||
|
||||
raw, err := lock.requestEncoding(conn, reader)
|
||||
if err != nil {
|
||||
return fmt.Errorf("[%s] request encoding failed: %v", funcName, err)
|
||||
}
|
||||
|
||||
log.Infof("Encoding response: %s", raw)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// linkStart sends the dormakaba/Kaba LS command.
|
||||
// LS|DA241213|TI165607|WS192.168.135.20|PW1234|
|
||||
func (lock *KabaLockServer) linkStart(conn net.Conn, reader *bufio.Reader) ([]string, error) {
|
||||
ws := dormakabaWorkstationID()
|
||||
pw := dormakabaPassword()
|
||||
|
||||
payload := fmt.Sprintf(
|
||||
"LS|DA%s|TI%s|WS%s|PW%s|",
|
||||
time.Now().Format("060102"), // yyMMdd
|
||||
time.Now().Format("150405"), // HHmmss
|
||||
ws,
|
||||
pw,
|
||||
)
|
||||
|
||||
command := wrapKabaFrame(payload)
|
||||
|
||||
log.Printf("Sending Link Start command: %q", command)
|
||||
|
||||
if _, err := conn.Write(command); err != nil {
|
||||
return nil, fmt.Errorf("failed to send Link Start command: %v", err)
|
||||
}
|
||||
|
||||
var registers []string
|
||||
timeout := 10 * time.Second
|
||||
|
||||
for {
|
||||
conn.SetReadDeadline(time.Now().Add(timeout))
|
||||
|
||||
b, err := reader.ReadByte()
|
||||
if err != nil {
|
||||
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
||||
if len(registers) > 0 {
|
||||
return registers, nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("error reading Link Start response: %v", err)
|
||||
}
|
||||
|
||||
switch b {
|
||||
case kabaACK:
|
||||
registers = append(registers, "ACK")
|
||||
continue
|
||||
|
||||
case kabaNAK:
|
||||
return registers, fmt.Errorf("received NAK after Link Start")
|
||||
|
||||
case kabaSTX:
|
||||
frame, err := readKabaFrame(conn, reader, b, timeout)
|
||||
if err != nil {
|
||||
return registers, fmt.Errorf("failed to read Link Start frame: %v", err)
|
||||
}
|
||||
|
||||
frameText := string(frame)
|
||||
registers = append(registers, frameText)
|
||||
|
||||
clean := cleanKabaFrame(frameText)
|
||||
if strings.HasPrefix(clean, "LA|") {
|
||||
return registers, nil
|
||||
}
|
||||
|
||||
default:
|
||||
log.Warnf("Ignoring unexpected byte during Link Start: 0x%X", b)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (lock *KabaLockServer) requestEncoding(conn net.Conn, reader *bufio.Reader) (string, error) {
|
||||
log.Printf("Sending Encoding command: %q", lock.command)
|
||||
|
||||
if _, err := conn.Write(lock.command); err != nil {
|
||||
return "", fmt.Errorf("failed to send Encoding command: %v", err)
|
||||
}
|
||||
|
||||
deadline := time.Now().Add(60 * time.Second)
|
||||
|
||||
for {
|
||||
remaining := time.Until(deadline)
|
||||
if remaining <= 0 {
|
||||
return "", fmt.Errorf("timeout waiting for dormakaba encoding response")
|
||||
}
|
||||
|
||||
conn.SetReadDeadline(time.Now().Add(remaining))
|
||||
|
||||
b, err := reader.ReadByte()
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("error reading encoding response: %v", err)
|
||||
}
|
||||
|
||||
switch b {
|
||||
case kabaACK:
|
||||
log.Debug("Received ACK after Encoding command")
|
||||
continue
|
||||
|
||||
case kabaNAK:
|
||||
return "", fmt.Errorf("received NAK after Encoding command")
|
||||
|
||||
case kabaSTX:
|
||||
frame, err := readKabaFrame(conn, reader, b, 60*time.Second)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("failed to read encoding response frame: %v", err)
|
||||
}
|
||||
|
||||
raw := string(frame)
|
||||
clean := cleanKabaFrame(raw)
|
||||
|
||||
log.Printf("Received Encoding frame: %q", clean)
|
||||
|
||||
if strings.HasPrefix(clean, "KA|") {
|
||||
return parseDormakabaEncodingResponse(clean)
|
||||
}
|
||||
|
||||
log.Warnf("Ignoring non-KA frame while waiting for encoding result: %q", clean)
|
||||
|
||||
default:
|
||||
log.Warnf("Ignoring unexpected byte while waiting for encoding response: 0x%X", b)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func parseDormakabaEncodingResponse(clean string) (string, error) {
|
||||
if strings.Contains(clean, "|ASOK|") {
|
||||
return "Success: " + clean, nil
|
||||
}
|
||||
|
||||
if strings.Contains(clean, "|AS") {
|
||||
return "", fmt.Errorf("negative dormakaba response: %s", clean)
|
||||
}
|
||||
|
||||
return "", fmt.Errorf("unexpected dormakaba response: %s", clean)
|
||||
}
|
||||
|
||||
func readKabaFrame(conn net.Conn, reader *bufio.Reader, firstByte byte, timeout time.Duration) ([]byte, error) {
|
||||
frame := []byte{firstByte}
|
||||
|
||||
for {
|
||||
conn.SetReadDeadline(time.Now().Add(timeout))
|
||||
|
||||
b, err := reader.ReadByte()
|
||||
if err != nil {
|
||||
return frame, fmt.Errorf("error reading frame body: %w", err)
|
||||
}
|
||||
|
||||
frame = append(frame, b)
|
||||
|
||||
if b == kabaETX {
|
||||
return frame, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func wrapKabaFrame(payload string) []byte {
|
||||
command := make([]byte, 0, len(payload)+2)
|
||||
command = append(command, kabaSTX)
|
||||
command = append(command, []byte(payload)...)
|
||||
command = append(command, kabaETX)
|
||||
|
||||
return command
|
||||
}
|
||||
|
||||
func cleanKabaFrame(raw string) string {
|
||||
return strings.Trim(raw, string([]byte{kabaSTX, kabaETX}))
|
||||
}
|
||||
|
||||
func dormakabaPassword() string {
|
||||
if strings.TrimSpace(Cert) != "" {
|
||||
return strings.TrimSpace(Cert)
|
||||
}
|
||||
|
||||
return "1234"
|
||||
}
|
||||
|
||||
func dormakabaWorkstationID() string {
|
||||
parsed, err := url.Parse(LockServerURL)
|
||||
if err == nil && parsed.Host != "" {
|
||||
host := parsed.Host
|
||||
|
||||
if h, _, splitErr := net.SplitHostPort(host); splitErr == nil {
|
||||
return h
|
||||
}
|
||||
|
||||
return strings.Trim(host, "/")
|
||||
}
|
||||
|
||||
raw := strings.TrimSpace(LockServerURL)
|
||||
raw = strings.TrimPrefix(raw, "http://")
|
||||
raw = strings.TrimPrefix(raw, "https://")
|
||||
raw = strings.Trim(raw, "/")
|
||||
|
||||
if h, _, splitErr := net.SplitHostPort(raw); splitErr == nil {
|
||||
return h
|
||||
}
|
||||
|
||||
if idx := strings.Index(raw, ":"); idx >= 0 {
|
||||
return raw[:idx]
|
||||
}
|
||||
|
||||
return raw
|
||||
}
|
||||
@@ -25,10 +25,11 @@ const (
|
||||
Omnitec = "omnitec"
|
||||
Salto = "salto"
|
||||
TLJ = "tlj"
|
||||
Dormakaba = "kaba"
|
||||
)
|
||||
|
||||
var (
|
||||
Cert string
|
||||
Cert string
|
||||
LockServerURL string
|
||||
)
|
||||
|
||||
@@ -38,6 +39,11 @@ type (
|
||||
LockSequence() error
|
||||
}
|
||||
|
||||
KabaLockServer struct {
|
||||
encoderAddr string
|
||||
command []byte
|
||||
}
|
||||
|
||||
AssaLockServer struct {
|
||||
encoderAddr string
|
||||
command string
|
||||
@@ -69,22 +75,24 @@ func NewLockServer(lockType, encoderAddr string, fatalError func(error)) LockSer
|
||||
return &SaltoLockServer{encoderAddr: encoderAddr}
|
||||
case TLJ:
|
||||
return &TLJLockServer{encoderAddr: encoderAddr}
|
||||
case Dormakaba:
|
||||
return &KabaLockServer{encoderAddr: encoderAddr}
|
||||
default:
|
||||
fatalError(fmt.Errorf("unsupported LockType: %s; must be 'assaabloy' or 'omnitec'", lockType))
|
||||
return nil // This line will never be reached, but is needed to satisfy the compiler
|
||||
}
|
||||
}
|
||||
|
||||
func InitializeServerConnection(LockserverUrl string) (net.Conn, error) {
|
||||
func InitializeServerConnection(LockserverURL string) (net.Conn, error) {
|
||||
const funcName = "InitializeServerConnection"
|
||||
// Parse the URL to extract host and port
|
||||
parsedUrl, err := url.Parse(LockserverUrl)
|
||||
parsedURL, err := url.Parse(LockserverURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("[%s] failed to parse LockserverUrl: %v", funcName, err)
|
||||
return nil, fmt.Errorf("[%s] failed to parse LockserverURL: %v", funcName, err)
|
||||
}
|
||||
|
||||
// Remove any leading/trailing slashes just in case
|
||||
address := strings.Trim(parsedUrl.Host, "/")
|
||||
address := strings.Trim(parsedURL.Host, "/")
|
||||
|
||||
// Establish a TCP connection to the Visionline server
|
||||
conn, err := net.Dial("tcp", address)
|
||||
@@ -7,12 +7,12 @@ import (
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"time"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
// Build key encoding request command for the Omnitec lock server.
|
||||
// BuildCommand builds key encoding request command for the Omnitec lock server.
|
||||
func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
|
||||
const funcName = "OmniLockServer.BuildCommand"
|
||||
hostname, err := os.Hostname()
|
||||
@@ -25,7 +25,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
|
||||
if err != nil {
|
||||
return fmt.Errorf("[%s] failed to convert lockId to integer: %v", funcName, err)
|
||||
}
|
||||
formattedLockId := fmt.Sprintf("%04d", idInt)
|
||||
formattedLockID := fmt.Sprintf("%04d", idInt)
|
||||
|
||||
// Format date/time parts
|
||||
dt := checkOut.Format("15:04") // DT = HH:mm
|
||||
@@ -37,7 +37,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
|
||||
payload := fmt.Sprintf(
|
||||
"KR|KC%s|KTD|RN%s|%s|DT%s|G#75|GA%s|GD%s|KO0000|DA%s|TI%s|",
|
||||
lock.encoderAddr,
|
||||
formattedLockId,
|
||||
formattedLockID,
|
||||
hostname,
|
||||
dt,
|
||||
ga,
|
||||
@@ -52,7 +52,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
|
||||
return nil
|
||||
}
|
||||
|
||||
// Starts link to the Omnitec lock server and perform key encoding
|
||||
// LockSequence starts link to the Omnitec lock server and perform key encoding
|
||||
func (lock *OmniLockServer) LockSequence() error {
|
||||
const funcName = "OmniLockServer.LockSequence"
|
||||
|
||||
@@ -136,4 +136,4 @@ func parseOmniResponse(raw string) (string, error) {
|
||||
return "", fmt.Errorf("negative response code: %s", clean)
|
||||
}
|
||||
return "Success: " + clean, nil
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,449 @@
|
||||
package paybridge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
"github.com/gorilla/websocket"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
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,
|
||||
}
|
||||
|
||||
return c.doPayment(ctx, payBridgeReq, onStatus)
|
||||
}
|
||||
|
||||
func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
|
||||
emitStatus(onStatus, paymentstatus.Starting)
|
||||
|
||||
connectURL, err := c.connectURL()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
ws, _, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
|
||||
if err != nil {
|
||||
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:
|
||||
}
|
||||
}()
|
||||
|
||||
jwt, err := c.readAuthSuccess(ws)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
log.Info("PayBridge authentication successful")
|
||||
emitStatus(onStatus, paymentstatus.Started)
|
||||
|
||||
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 {
|
||||
_, 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:
|
||||
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,
|
||||
)
|
||||
|
||||
if !known {
|
||||
log.WithFields(log.Fields{
|
||||
"status": update.Data.Status,
|
||||
"code": update.Data.Code,
|
||||
}).Warn("Unknown PayBridge status update")
|
||||
}
|
||||
|
||||
emitStatus(onStatus, statusCode)
|
||||
|
||||
case types.MesTypePaymentAccepted:
|
||||
log.Info("PayBridge payment request accepted")
|
||||
emitStatus(onStatus, paymentstatus.Accepted)
|
||||
|
||||
case types.MesTypePaymentResult:
|
||||
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": mapped.Status,
|
||||
"success": mapped.Success,
|
||||
}).Info("PayBridge payment result received")
|
||||
|
||||
emitStatus(
|
||||
onStatus,
|
||||
mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
|
||||
)
|
||||
|
||||
return mapped, nil
|
||||
|
||||
case types.MesTypePaymentError:
|
||||
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": mapped.Status,
|
||||
"error": mapped.ErrorMessage,
|
||||
}).Warn("PayBridge payment error received")
|
||||
|
||||
emitStatus(
|
||||
onStatus,
|
||||
mapPayBridgeFinalStatus(mapped.Status, false),
|
||||
)
|
||||
|
||||
return mapped, nil
|
||||
|
||||
case types.ResultError:
|
||||
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{
|
||||
"code": genericErr.Error.Code,
|
||||
"message": genericErr.Error.Message,
|
||||
}).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.WithField(
|
||||
"messageType",
|
||||
head.Type,
|
||||
).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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package paybridge
|
||||
|
||||
import "errors"
|
||||
|
||||
var (
|
||||
ErrConnectionFailed = errors.New("paybridge connection failed")
|
||||
ErrAuthFailed = errors.New("paybridge authentication failed")
|
||||
ErrUnexpectedMessage = errors.New("paybridge unexpected message")
|
||||
)
|
||||
@@ -0,0 +1,47 @@
|
||||
package paybridge
|
||||
|
||||
import "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
||||
|
||||
func mapPaymentResult(res PaymentResultEnvelope) *paymentsvc.Result {
|
||||
var merchantReceipt string
|
||||
if res.Data.ReceiptData.Merchant != nil {
|
||||
merchantReceipt = *res.Data.ReceiptData.Merchant
|
||||
}
|
||||
|
||||
return &paymentsvc.Result{
|
||||
Success: res.Data.Success,
|
||||
TransactionID: res.Data.TransactionID,
|
||||
RequestID: res.Data.RequestID,
|
||||
Operation: res.Data.Operation,
|
||||
Status: res.Data.Status,
|
||||
Message: res.Data.Message,
|
||||
ErrorMessage: res.Data.ErrorMessage,
|
||||
Amount: res.Data.Amount,
|
||||
Currency: res.Data.Currency,
|
||||
AuthCode: res.Data.AuthCode,
|
||||
DeviceUsed: res.Data.DeviceUsed,
|
||||
DeviceType: res.Data.DeviceType,
|
||||
ReferenceNumber: res.Data.ReferenceNumber,
|
||||
LastFourDigits: res.Data.LastFourDigits,
|
||||
CardType: res.Data.CardType,
|
||||
CardNumber: res.Data.CardNumber,
|
||||
ExpiryDate: res.Data.ExpiryDate,
|
||||
CardHash: res.Data.CardHash,
|
||||
CardReference: res.Data.CardReference,
|
||||
CustomerReceipt: res.Data.ReceiptData.Customer,
|
||||
MerchantReceipt: merchantReceipt,
|
||||
}
|
||||
}
|
||||
|
||||
func mapPaymentError(req PaymentRequest, res PaymentErrorEnvelope) *paymentsvc.Result {
|
||||
return &paymentsvc.Result{
|
||||
Success: false,
|
||||
TransactionID: res.Data.TransactionID,
|
||||
RequestID: req.RequestID,
|
||||
Operation: req.Operation,
|
||||
Status: res.Data.Status,
|
||||
ErrorMessage: res.Data.Error,
|
||||
Amount: req.Amount,
|
||||
Currency: req.Currency,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package paybridge
|
||||
|
||||
const (
|
||||
payBridgeFinalStatusApproved = "APPROVED"
|
||||
payBridgeFinalStatusDeclined = "DECLINED"
|
||||
payBridgeFinalStatusCancelled = "CANCELLED"
|
||||
payBridgeFinalStatusTimeout = "TIMEOUT"
|
||||
payBridgeFinalStatusVoided = "VOIDED"
|
||||
payBridgeFinalStatusVoidedDailyLimitExceeded = "VOIDED_DAILY_LIMIT_EXCEEDED"
|
||||
payBridgeFinalStatusDailyLimitVoidFailed = "DAILY_LIMIT_EXCEEDED_VOID_FAILED"
|
||||
payBridgeFinalStatusDailyLimitValidationError = "DAILY_LIMIT_VALIDATION_ERROR"
|
||||
payBridgeFinalStatusError = "ERROR"
|
||||
payBridgeFinalStatusFailed = "FAILED"
|
||||
)
|
||||
|
||||
const (
|
||||
payBridgeMessageInsertOrSwipeCard = "insert or swipe card"
|
||||
payBridgeMessageInsertSwipeOrPresentCard = "insert, swipe or present card"
|
||||
payBridgeMessageInsertCard = "insert card"
|
||||
payBridgeMessagePleaseWait = "please wait"
|
||||
payBridgeMessageDoNotRemoveCard = "please wait. do not remove card"
|
||||
payBridgeMessageTryAnotherInterface = "please try another interface"
|
||||
payBridgeMessagePIN = "pin"
|
||||
payBridgeMessagePINAgain = "pin again"
|
||||
payBridgeMessageTransactionCancelled = "transaction cancelled"
|
||||
payBridgeMessageProcessing = "processing"
|
||||
payBridgeMessageApproved = "approved"
|
||||
payBridgeMessageDeclined = "declined"
|
||||
)
|
||||
|
||||
const (
|
||||
payBridgeCodeInsertCard = "101"
|
||||
payBridgeCodeEnterPIN = "106"
|
||||
payBridgeCodeCancelled = "124"
|
||||
payBridgeCodePleaseWait = "1017"
|
||||
payBridgeCodePresentCard = "1109"
|
||||
payBridgeCodePresentCardAlternate = "1113"
|
||||
payBridgeCodeEnterPINAgain = "1129"
|
||||
payBridgeCodeTryAnotherInterface = "1274"
|
||||
payBridgeCodeDoNotRemoveCard = "1312"
|
||||
)
|
||||
@@ -0,0 +1,125 @@
|
||||
package paybridge
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
func TestMapPayBridgeFinalStatus(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
status string
|
||||
success bool
|
||||
want string
|
||||
}{
|
||||
{"approved success", "APPROVED", true, paymentstatus.Approved},
|
||||
{"approved without success", "APPROVED", false, paymentstatus.Error},
|
||||
{"declined", "DECLINED", false, paymentstatus.Declined},
|
||||
{"cancelled", "CANCELLED", false, paymentstatus.Cancelled},
|
||||
{"timeout", "TIMEOUT", false, paymentstatus.Timeout},
|
||||
{"voided", "VOIDED", false, paymentstatus.Voided},
|
||||
{"voided daily limit exceeded", "VOIDED_DAILY_LIMIT_EXCEEDED", false, paymentstatus.DailyLimitExceeded},
|
||||
{"daily limit void failed", "DAILY_LIMIT_EXCEEDED_VOID_FAILED", false, paymentstatus.VoidFailed},
|
||||
{"daily limit validation error", "DAILY_LIMIT_VALIDATION_ERROR", false, paymentstatus.LimitValidationError},
|
||||
{"error", "ERROR", false, paymentstatus.Error},
|
||||
{"failed", "FAILED", false, paymentstatus.Error},
|
||||
{"unknown", "UNKNOWN", false, paymentstatus.Error},
|
||||
{"approved case insensitive", "approved", true, paymentstatus.Approved},
|
||||
{"declined case insensitive", "declined", false, paymentstatus.Declined},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
got := mapPayBridgeFinalStatus(test.status, test.success)
|
||||
if got != test.want {
|
||||
t.Fatalf("got %q, want %q", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestMapPayBridgeStatusMessages(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
status string
|
||||
want string
|
||||
}{
|
||||
{"insert or swipe card", "insert or swipe card", paymentstatus.PresentCard},
|
||||
{"insert swipe or present card", "insert, swipe or present card", paymentstatus.PresentCard},
|
||||
{"insert card", "insert card", paymentstatus.InsertCard},
|
||||
{"please wait", "please wait", paymentstatus.PleaseWait},
|
||||
{"do not remove card", "please wait. do not remove card", paymentstatus.DoNotRemoveCard},
|
||||
{"try another interface", "please try another interface", paymentstatus.TryAnotherInterface},
|
||||
{"pin", "pin", paymentstatus.EnterPIN},
|
||||
{"pin again", "pin again", paymentstatus.EnterPINAgain},
|
||||
{"transaction cancelled", "transaction cancelled", paymentstatus.Cancelled},
|
||||
{"processing", "processing", paymentstatus.Processing},
|
||||
{"approved", "approved", paymentstatus.Authorized},
|
||||
{"declined", "declined", paymentstatus.Declined},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
got, matched := mapPayBridgeStatus(test.status, "")
|
||||
if !matched {
|
||||
t.Fatal("expected status to match")
|
||||
}
|
||||
if got != test.want {
|
||||
t.Fatalf("got %q, want %q", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestMapPayBridgeStatusCodes(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
want string
|
||||
}{
|
||||
{"insert card", "101", paymentstatus.InsertCard},
|
||||
{"enter pin", "106", paymentstatus.EnterPIN},
|
||||
{"cancelled", "124", paymentstatus.Cancelled},
|
||||
{"please wait", "1017", paymentstatus.PleaseWait},
|
||||
{"present card", "1109", paymentstatus.PresentCard},
|
||||
{"present card alternate", "1113", paymentstatus.PresentCard},
|
||||
{"enter pin again", "1129", paymentstatus.EnterPINAgain},
|
||||
{"try another interface", "1274", paymentstatus.TryAnotherInterface},
|
||||
{"do not remove card", "1312", paymentstatus.DoNotRemoveCard},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
got, matched := mapPayBridgeStatus("", test.code)
|
||||
if !matched {
|
||||
t.Fatal("expected code to match")
|
||||
}
|
||||
if got != test.want {
|
||||
t.Fatalf("got %q, want %q", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestMapPayBridgeStatusNormalization(t *testing.T) {
|
||||
got, matched := mapPayBridgeStatus(" PiN AgAiN ", "")
|
||||
if !matched || got != paymentstatus.EnterPINAgain {
|
||||
t.Fatalf("normalized message got (%q, %t), want (%q, true)", got, matched, paymentstatus.EnterPINAgain)
|
||||
}
|
||||
|
||||
got, matched = mapPayBridgeStatus("", " 101 ")
|
||||
if !matched || got != paymentstatus.InsertCard {
|
||||
t.Fatalf("trimmed code got (%q, %t), want (%q, true)", got, matched, paymentstatus.InsertCard)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMapPayBridgeStatusUnknown(t *testing.T) {
|
||||
got, matched := mapPayBridgeStatus("unknown message", "999")
|
||||
if matched {
|
||||
t.Fatal("unknown status and code must not match")
|
||||
}
|
||||
if got != paymentstatus.Processing {
|
||||
t.Fatalf("got %q, want %q", got, paymentstatus.Processing)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package paybridge
|
||||
|
||||
type Envelope struct {
|
||||
Type string `json:"type"`
|
||||
Data any `json:"data,omitempty"`
|
||||
Timestamp int64 `json:"timestamp,omitempty"`
|
||||
JWT string `json:"jwt,omitempty"`
|
||||
}
|
||||
|
||||
type PaymentRequest struct {
|
||||
RequestID string `json:"requestId"`
|
||||
Amount int64 `json:"amount"`
|
||||
Currency string `json:"currency"`
|
||||
Operation string `json:"operation"`
|
||||
TimeoutSeconds int `json:"timeoutSeconds,omitempty"`
|
||||
}
|
||||
|
||||
type PaymentResultEnvelope struct {
|
||||
Type string `json:"type"`
|
||||
Data struct {
|
||||
Success bool `json:"success"`
|
||||
TransactionID string `json:"transactionId"`
|
||||
RequestID string `json:"requestId"`
|
||||
Operation string `json:"operation"`
|
||||
Status string `json:"status"`
|
||||
Message string `json:"message"`
|
||||
ErrorMessage string `json:"errorMessage"`
|
||||
Amount int64 `json:"amount"`
|
||||
Currency string `json:"currency"`
|
||||
AuthCode string `json:"authCode"`
|
||||
DeviceUsed string `json:"deviceUsed"`
|
||||
DeviceType string `json:"deviceType"`
|
||||
ReferenceNumber string `json:"referenceNumber"`
|
||||
LastFourDigits string `json:"lastFourDigits"`
|
||||
CardType string `json:"cardType"`
|
||||
CardNumber string `json:"cardNumber"`
|
||||
ExpiryDate string `json:"expiryDate"`
|
||||
CardHash string `json:"cardHash"`
|
||||
CardReference string `json:"cardReference"`
|
||||
|
||||
ReceiptData struct {
|
||||
Merchant *string `json:"merchant"`
|
||||
Customer string `json:"customer"`
|
||||
} `json:"receiptData"`
|
||||
} `json:"data"`
|
||||
}
|
||||
|
||||
type PaymentErrorEnvelope struct {
|
||||
Type string `json:"type"`
|
||||
Data struct {
|
||||
TransactionID string `json:"transactionId"`
|
||||
Error string `json:"error"`
|
||||
Status string `json:"status"`
|
||||
} `json:"data"`
|
||||
}
|
||||
|
||||
type StatusUpdateEnvelope struct {
|
||||
Type string `json:"type"`
|
||||
|
||||
Data struct {
|
||||
Status string `json:"status"`
|
||||
Code string `json:"code"`
|
||||
Timestamp int64 `json:"timestamp"`
|
||||
} `json:"data"`
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package paymentsvc
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"sync"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrPaymentInProgress = errors.New("payment is already in progress")
|
||||
ErrProviderNotConfigured = errors.New("payment provider is not configured")
|
||||
)
|
||||
|
||||
type StatusUpdate struct {
|
||||
Code string `json:"code"`
|
||||
}
|
||||
|
||||
type StatusHandler func(StatusUpdate)
|
||||
|
||||
type Provider interface {
|
||||
Sale(
|
||||
ctx context.Context,
|
||||
req SaleRequest,
|
||||
onStatus StatusHandler,
|
||||
) (*Result, error)
|
||||
}
|
||||
|
||||
type Service struct {
|
||||
provider Provider
|
||||
|
||||
mu sync.Mutex
|
||||
busy bool
|
||||
}
|
||||
|
||||
func NewService(provider Provider) *Service {
|
||||
return &Service{
|
||||
provider: provider,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) Sale(
|
||||
ctx context.Context,
|
||||
req SaleRequest,
|
||||
onStatus StatusHandler,
|
||||
) (*Result, error) {
|
||||
if s == nil || s.provider == nil {
|
||||
return nil, ErrProviderNotConfigured
|
||||
}
|
||||
|
||||
s.mu.Lock()
|
||||
if s.busy {
|
||||
s.mu.Unlock()
|
||||
return nil, ErrPaymentInProgress
|
||||
}
|
||||
s.busy = true
|
||||
s.mu.Unlock()
|
||||
|
||||
defer func() {
|
||||
s.mu.Lock()
|
||||
s.busy = false
|
||||
s.mu.Unlock()
|
||||
}()
|
||||
|
||||
return s.provider.Sale(ctx, req, onStatus)
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package paymentsvc
|
||||
|
||||
type SaleRequest struct {
|
||||
RequestID string `json:"requestId"`
|
||||
Reference string `json:"reference"`
|
||||
Amount int64 `json:"amount"`
|
||||
Currency string `json:"currency"`
|
||||
}
|
||||
|
||||
type Result struct {
|
||||
Success bool `json:"success"`
|
||||
RequestID string `json:"requestId,omitempty"`
|
||||
Operation string `json:"operation,omitempty"`
|
||||
Status string `json:"status"`
|
||||
Message string `json:"message,omitempty"`
|
||||
ErrorMessage string `json:"errorMessage,omitempty"`
|
||||
|
||||
TransactionID string `json:"transactionId,omitempty"`
|
||||
ReferenceNumber string `json:"referenceNumber,omitempty"`
|
||||
AuthCode string `json:"authCode,omitempty"`
|
||||
|
||||
Amount int64 `json:"amount"`
|
||||
Currency string `json:"currency"`
|
||||
|
||||
DeviceUsed string `json:"deviceUsed,omitempty"`
|
||||
DeviceType string `json:"deviceType,omitempty"`
|
||||
|
||||
CardNumber string `json:"cardNumber,omitempty"`
|
||||
LastFourDigits string `json:"lastFourDigits,omitempty"`
|
||||
CardType string `json:"cardType,omitempty"`
|
||||
ExpiryDate string `json:"expiryDate,omitempty"`
|
||||
CardHash string `json:"cardHash,omitempty"`
|
||||
CardReference string `json:"cardReference,omitempty"`
|
||||
|
||||
CustomerReceipt string `json:"customerReceipt,omitempty"`
|
||||
MerchantReceipt string `json:"merchantReceipt,omitempty"`
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import (
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
||||
"github.com/alexbrainman/printer"
|
||||
log "github.com/sirupsen/logrus"
|
||||
imagedraw "golang.org/x/image/draw"
|
||||
@@ -39,6 +40,7 @@ type (
|
||||
Name string `xml:"customername"`
|
||||
Checkout string `xml:"checkoutdatetime"`
|
||||
RoomID string `xml:"roomno"`
|
||||
Voucher string `xml:"voucher"`
|
||||
Map string `xml:"roommap"`
|
||||
Directions string `xml:"roomdirections"`
|
||||
}
|
||||
@@ -93,7 +95,30 @@ func ParseCardholderReceipt(data []byte) ([]ReceiptEntryXML, error) {
|
||||
return tr.ReceiptEntries.ReceiptEntry, nil
|
||||
}
|
||||
|
||||
func readTicketLayout() LayoutOptions {
|
||||
var layout LayoutOptions
|
||||
|
||||
executablePath, err := os.Executable()
|
||||
if err != nil {
|
||||
errorhandlers.FatalError(fmt.Errorf("failed to locate application executable: %v", err))
|
||||
}
|
||||
|
||||
layoutName := filepath.Join(filepath.Dir(executablePath), "TicketLayout.xml")
|
||||
data, err := os.ReadFile(layoutName)
|
||||
if err != nil {
|
||||
errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
|
||||
}
|
||||
|
||||
if err := xml.Unmarshal(data, &layout); err != nil {
|
||||
errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
|
||||
}
|
||||
|
||||
return layout
|
||||
}
|
||||
|
||||
func BuildRoomTicket(details RoomDetailsRec) ([]byte, error) {
|
||||
Layout = readTicketLayout()
|
||||
|
||||
var buf bytes.Buffer
|
||||
|
||||
// shortcuts
|
||||
@@ -141,6 +166,11 @@ func BuildRoomTicket(details RoomDetailsRec) ([]byte, error) {
|
||||
write([]byte{ESC, 'a', CENTER})
|
||||
writeStr(Layout.HotelSpecificDetails + "\n\n")
|
||||
|
||||
if details.Voucher != "" {
|
||||
s := strings.Repeat("*", 44)
|
||||
writeStr(fmt.Sprintf("%s\n\n%s\n\n%s\n\n", s, details.Voucher, s))
|
||||
}
|
||||
|
||||
// 8) Room map image
|
||||
mapPath := filepath.Join(Layout.RoomMapFolderPath, details.Map)
|
||||
mapBytes, err := printMap(mapPath)
|
||||
@@ -179,6 +209,23 @@ func PrintReceipt(receipt string) {
|
||||
}
|
||||
}
|
||||
|
||||
func PrintSaleReceipt(receipt string) {
|
||||
if len(receipt) == 0 {
|
||||
log.Warn("Empty sale receipt, skipping print")
|
||||
return
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
buf.WriteString(receipt)
|
||||
buf.WriteByte('\n')
|
||||
buf.Write([]byte{ESC, 'd', 7})
|
||||
buf.Write([]byte{GS, 'V', 1})
|
||||
|
||||
|
||||
if err := SendToPrinter(buf.Bytes()); err != nil {
|
||||
log.Errorf("SendToPrinter error: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func printCardholderReceipt(cardholderReceipt string) error {
|
||||
receiptEntries, err := ParseCardholderReceipt([]byte(cardholderReceipt))
|
||||
if err != nil {
|
||||
@@ -198,95 +245,174 @@ func printCardholderReceipt(cardholderReceipt string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// receiptColumns follows the existing 44-column normal-size text convention.
|
||||
const receiptColumns = 44
|
||||
|
||||
func BuildCardholderReceipt(entries []ReceiptEntryXML) ([]byte, error) {
|
||||
var buf bytes.Buffer
|
||||
rendered := make([]bool, len(entries))
|
||||
take := func(id string) string {
|
||||
for i, entry := range entries {
|
||||
if !rendered[i] && entry.ReceiptEntryId == id && entry.Value != "" {
|
||||
rendered[i] = true
|
||||
return receiptEntryText(entry)
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
write := func(b []byte) { buf.Write(b) }
|
||||
// writeStr := func(s string) { buf.WriteString(s) }
|
||||
writeln := func(s string) {
|
||||
buf.WriteString(s)
|
||||
// Set and restore only text state; leave printer setup and transport alone.
|
||||
normal := func() { buf.Write([]byte{ESC, 'a', 0, ESC, 'E', BOLD_OFF, GS, '!', NORMAL_FONT}) }
|
||||
normal()
|
||||
hasRows, newSection := false, false
|
||||
beginLine := func(center bool) {
|
||||
if hasRows && newSection {
|
||||
buf.WriteString(strings.Repeat("-", receiptColumns) + "\n")
|
||||
}
|
||||
hasRows, newSection = true, false
|
||||
if center {
|
||||
buf.Write([]byte{ESC, 'a', CENTER})
|
||||
}
|
||||
}
|
||||
text := func(value string, bold bool) {
|
||||
if bold {
|
||||
buf.Write([]byte{ESC, 'E', BOLD_ON})
|
||||
}
|
||||
buf.WriteString(value)
|
||||
if bold {
|
||||
buf.Write([]byte{ESC, 'E', BOLD_OFF})
|
||||
}
|
||||
}
|
||||
line := func(value string, bold, center bool) {
|
||||
if value == "" {
|
||||
return
|
||||
}
|
||||
beginLine(center)
|
||||
text(value, bold)
|
||||
buf.WriteByte('\n')
|
||||
normal()
|
||||
}
|
||||
pair := func(left, right string, boldRight bool) {
|
||||
if gap, fits := receiptPairGap(left, right); fits {
|
||||
beginLine(false)
|
||||
text(left+gap, false)
|
||||
text(right, boldRight)
|
||||
buf.WriteByte('\n')
|
||||
normal()
|
||||
return
|
||||
}
|
||||
line(left, false, false)
|
||||
line(right, boldRight, false)
|
||||
}
|
||||
|
||||
// Build a lookup map by ReceiptEntryId
|
||||
m := make(map[string]ReceiptEntryXML, len(entries))
|
||||
for _, e := range entries {
|
||||
m[e.ReceiptEntryId] = e
|
||||
line(take("Recipient"), true, true)
|
||||
line(take("MerchantName"), false, true)
|
||||
newSection = true
|
||||
line(take("CardScheme"), false, false)
|
||||
line(take("PanMasked"), false, false)
|
||||
pair(take("Aid"), take("PanSequence"), false)
|
||||
pair(take("TransactionSource"), take("TransactionType"), false)
|
||||
newSection = true
|
||||
// Align the provider amount without parsing or modifying its value.
|
||||
for i, entry := range entries {
|
||||
if entry.ReceiptEntryId == "TotalAmount" && entry.Value != "" {
|
||||
rendered[i] = true
|
||||
label := entry.Label
|
||||
if label == "" {
|
||||
label = "TOTAL"
|
||||
}
|
||||
label = strings.TrimSuffix(label, ":") + ":"
|
||||
if gap, fits := receiptPairGap(label, entry.Value); fits {
|
||||
line(label+gap+entry.Value, true, false)
|
||||
} else {
|
||||
line(receiptEntryText(entry), true, false)
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Utility to center text
|
||||
// center := func(s string) {
|
||||
// write([]byte{ESC, 'a', CENTER})
|
||||
// writeln(s)
|
||||
// write([]byte{ESC, 'a', 0})
|
||||
// }
|
||||
|
||||
// Utility for bold lines
|
||||
// boldOn := func() { write([]byte{GS, '!', WIDER_FONT}) }
|
||||
// boldOff := func() { write([]byte{GS, '!', NORMAL_FONT}) }
|
||||
|
||||
// boldOn()
|
||||
|
||||
// 1) Header: CARDHOLDER COPY
|
||||
writeln(m["Recipient"].Value)
|
||||
// writeStr("\n\n")
|
||||
// 2) Merchant name
|
||||
writeln(m["MerchantName"].Value)
|
||||
// writeStr("\n\n")
|
||||
// 3) AID
|
||||
writeln("AID: " + m["Aid"].Value)
|
||||
|
||||
// 4) Card scheme & pan
|
||||
writeln(fmt.Sprintf("%s Card: %s", m["CardScheme"].Value, m["PanMasked"].Value))
|
||||
|
||||
// 5) PAN Seq No
|
||||
writeln("PAN Seq No: " + m["PanSequence"].Value)
|
||||
|
||||
// 6) Transaction source
|
||||
writeln(m["TransactionSource"].Value)
|
||||
|
||||
// 7) Transaction type (Sale/Account Verification)
|
||||
writeln(m["TransactionType"].Value)
|
||||
|
||||
// 8) Total
|
||||
// assuming value like "GBP1.50" — insert space after currency
|
||||
total := m["TotalAmount"].Value
|
||||
if !strings.HasPrefix(total, "GBP") && len(total) > 3 {
|
||||
total = total[:3] + " " + total[3:]
|
||||
pair(take("CardholderVerification"), take("TransactionResult"), true)
|
||||
newSection = true
|
||||
line(take("AuthCode"), false, false)
|
||||
line(take("AuthReference"), false, false)
|
||||
line(take("TransactionSeqNumber"), false, false)
|
||||
pair(take("MerchantIdMasked"), take("TerminalIdMasked"), false)
|
||||
line(take("AuthDateTime"), false, false)
|
||||
footer := take("RetentionMessage")
|
||||
// Preserve every remaining occurrence, including unknown IDs, in provider order.
|
||||
for i, entry := range entries {
|
||||
if !rendered[i] && entry.Value != "" {
|
||||
line(receiptEntryText(entry), false, false)
|
||||
}
|
||||
}
|
||||
writeln("TOTAL: " + total)
|
||||
|
||||
// 9) Cardholder verification
|
||||
writeln(m["CardholderVerification"].Value)
|
||||
|
||||
// 10) Approved/Declined
|
||||
writeln(m["TransactionResult"].Value)
|
||||
|
||||
// 11) Auth code
|
||||
writeln("Auth Code: " + m["AuthCode"].Value)
|
||||
|
||||
// 12) Reference
|
||||
writeln("Ref: " + m["AuthReference"].Value)
|
||||
|
||||
// 13) Merchant & terminal IDs
|
||||
writeln("MID: " + m["MerchantIdMasked"].Value)
|
||||
writeln("TID: " + m["TerminalIdMasked"].Value)
|
||||
|
||||
// 14) Date/time
|
||||
writeln(m["AuthDateTime"].Value)
|
||||
|
||||
// 15) Retention message
|
||||
writeln(m["RetentionMessage"].Value)
|
||||
|
||||
// boldOff()
|
||||
|
||||
// finally feed & cut
|
||||
write([]byte{ESC, 'd', 7}) // Feed 5 lines
|
||||
write([]byte{GS, 'V', 1})
|
||||
|
||||
newSection = true
|
||||
line(footer, false, true)
|
||||
normal()
|
||||
buf.Write([]byte{ESC, 'd', 7})
|
||||
buf.Write([]byte{GS, 'V', 1})
|
||||
return buf.Bytes(), nil
|
||||
}
|
||||
|
||||
func receiptEntryText(entry ReceiptEntryXML) string {
|
||||
label := entry.Label
|
||||
if label == "" {
|
||||
switch entry.ReceiptEntryId {
|
||||
case "Recipient", "MerchantName", "CardScheme", "TransactionSource", "TransactionType",
|
||||
"CardholderVerification", "TransactionResult", "AuthDateTime", "RetentionMessage":
|
||||
return entry.Value
|
||||
case "PanMasked":
|
||||
label = "Card"
|
||||
case "Aid":
|
||||
label = "AID"
|
||||
case "PanSequence":
|
||||
label = "PAN Seq No"
|
||||
case "TotalAmount":
|
||||
label = "TOTAL"
|
||||
case "AuthCode":
|
||||
label = "Auth Code"
|
||||
case "AuthReference":
|
||||
label = "Ref"
|
||||
case "TransactionSeqNumber":
|
||||
label = "Transaction Seq. No"
|
||||
case "MerchantIdMasked":
|
||||
label = "MID"
|
||||
case "TerminalIdMasked":
|
||||
label = "TID"
|
||||
default:
|
||||
var readable strings.Builder
|
||||
runes := []rune(entry.ReceiptEntryId)
|
||||
for i, r := range runes {
|
||||
if i > 0 && r >= 'A' && r <= 'Z' &&
|
||||
((runes[i-1] >= 'a' && runes[i-1] <= 'z') ||
|
||||
(i+1 < len(runes) && runes[i+1] >= 'a' && runes[i+1] <= 'z')) {
|
||||
readable.WriteByte(' ')
|
||||
}
|
||||
if r == '_' || r == '-' {
|
||||
r = ' '
|
||||
}
|
||||
readable.WriteRune(r)
|
||||
}
|
||||
label = strings.TrimSpace(readable.String())
|
||||
}
|
||||
}
|
||||
if label == "" {
|
||||
return entry.Value
|
||||
}
|
||||
return strings.TrimSuffix(label, ":") + ": " + entry.Value
|
||||
}
|
||||
|
||||
func receiptPairGap(left, right string) (string, bool) {
|
||||
if left == "" || right == "" || len(left)+2+len(right) > receiptColumns {
|
||||
return "", false
|
||||
}
|
||||
// Only printable ASCII has a predictable single-column width here.
|
||||
for _, r := range left + right {
|
||||
if r < ' ' || r > '~' {
|
||||
return "", false
|
||||
}
|
||||
}
|
||||
return strings.Repeat(" ", receiptColumns-len(left)-len(right)), true
|
||||
}
|
||||
|
||||
func printLogo(path string) ([]byte, error) {
|
||||
const maxLogoWidth = 384
|
||||
f, err := os.Open(path)
|
||||
@@ -0,0 +1,280 @@
|
||||
package printer
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type receiptTestChar struct {
|
||||
value byte
|
||||
center, bold bool
|
||||
}
|
||||
|
||||
type receiptTestOutput struct {
|
||||
lines []string
|
||||
chars []receiptTestChar
|
||||
feeds, cuts int
|
||||
}
|
||||
|
||||
// readReceiptText understands only the commands emitted by this receipt builder.
|
||||
func readReceiptText(t *testing.T, data []byte) receiptTestOutput {
|
||||
t.Helper()
|
||||
var out receiptTestOutput
|
||||
var line strings.Builder
|
||||
var center, bold bool
|
||||
for i := 0; i < len(data); {
|
||||
if data[i] == ESC || data[i] == GS {
|
||||
if i+2 >= len(data) {
|
||||
t.Fatalf("BuildCardholderReceipt control bytes = %v, want complete command", data[i:])
|
||||
}
|
||||
prefix, command, value := data[i], data[i+1], data[i+2]
|
||||
switch {
|
||||
case prefix == ESC && command == 'a':
|
||||
if value != 0 && value != CENTER {
|
||||
t.Errorf("receipt alignment = %d, want left or center", value)
|
||||
}
|
||||
center = value == CENTER
|
||||
case prefix == ESC && command == 'E':
|
||||
if value != BOLD_OFF && value != BOLD_ON {
|
||||
t.Errorf("receipt bold = %d, want on or off", value)
|
||||
}
|
||||
bold = value == BOLD_ON
|
||||
case prefix == GS && command == '!':
|
||||
if value != NORMAL_FONT {
|
||||
t.Errorf("receipt size = %d, want normal size", value)
|
||||
}
|
||||
case prefix == ESC && command == 'd':
|
||||
out.feeds++
|
||||
if value != 7 || center || bold || i != len(data)-6 {
|
||||
t.Errorf("receipt feed = %d, center=%t bold=%t offset=%d, want final seven-line feed in normal state", value, center, bold, i)
|
||||
}
|
||||
case prefix == GS && command == 'V':
|
||||
out.cuts++
|
||||
if value != 1 || i != len(data)-3 {
|
||||
t.Errorf("receipt cut = %d at %d, want final GS V 1", value, i)
|
||||
}
|
||||
default:
|
||||
t.Fatalf("BuildCardholderReceipt command = %v, want supported text command", data[i:i+3])
|
||||
}
|
||||
i += 3
|
||||
continue
|
||||
}
|
||||
if data[i] == '\n' {
|
||||
out.lines = append(out.lines, line.String())
|
||||
line.Reset()
|
||||
} else {
|
||||
line.WriteByte(data[i])
|
||||
out.chars = append(out.chars, receiptTestChar{value: data[i], center: center, bold: bold})
|
||||
}
|
||||
i++
|
||||
}
|
||||
if line.Len() != 0 || center || bold || out.feeds != 1 || out.cuts != 1 {
|
||||
t.Errorf("receipt termination: trailing=%q center=%t bold=%t feeds=%d cuts=%d, want normal state and one feed/cut", line.String(), center, bold, out.feeds, out.cuts)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func buildReceiptText(t *testing.T, entries []ReceiptEntryXML) receiptTestOutput {
|
||||
t.Helper()
|
||||
before := append([]ReceiptEntryXML(nil), entries...)
|
||||
data, err := BuildCardholderReceipt(entries)
|
||||
if err != nil {
|
||||
t.Fatalf("BuildCardholderReceipt(%v) error = %v, want nil", entries, err)
|
||||
}
|
||||
if !reflect.DeepEqual(entries, before) {
|
||||
t.Errorf("BuildCardholderReceipt input = %v, want unchanged %v", entries, before)
|
||||
}
|
||||
if !bytes.HasSuffix(data, []byte{ESC, 'd', 7, GS, 'V', 1}) {
|
||||
t.Errorf("BuildCardholderReceipt suffix = %v, want unchanged feed/cut", data)
|
||||
}
|
||||
return readReceiptText(t, data)
|
||||
}
|
||||
|
||||
func sampleReceipt(recipient string) []ReceiptEntryXML {
|
||||
return []ReceiptEntryXML{
|
||||
{ReceiptEntryId: "Recipient", Value: recipient},
|
||||
{ReceiptEntryId: "MerchantName", Value: "Standard Test Merchant"},
|
||||
{ReceiptEntryId: "Aid", Value: "A0000000031010", Label: "AID"},
|
||||
{ReceiptEntryId: "CardScheme", Value: "VISA DEBIT"},
|
||||
{ReceiptEntryId: "PanMasked", Value: "************1133", Label: "Card"},
|
||||
{ReceiptEntryId: "PanSequence", Value: "01", Label: "PAN Seq No"},
|
||||
{ReceiptEntryId: "TransactionSource", Value: "ICC"},
|
||||
{ReceiptEntryId: "TransactionType", Value: "SALE"},
|
||||
{ReceiptEntryId: "TotalAmount", Value: "GBP120.00", Label: "TOTAL"},
|
||||
{ReceiptEntryId: "CardholderVerification", Value: "PIN VERIFIED"},
|
||||
{ReceiptEntryId: "TransactionResult", Value: "APPROVED"},
|
||||
{ReceiptEntryId: "AuthCode", Value: "D0A35D", Label: "Auth Code"},
|
||||
{ReceiptEntryId: "AuthReference", Value: "ChipDNA-Sale-20260908144731", Label: "Ref"},
|
||||
{ReceiptEntryId: "MerchantIdMasked", Value: "******7897", Label: "MID"},
|
||||
{ReceiptEntryId: "TerminalIdMasked", Value: "****9508", Label: "TID"},
|
||||
{ReceiptEntryId: "TransactionSeqNumber", Value: "00001059", Label: "Transaction Seq. No"},
|
||||
{ReceiptEntryId: "AuthDateTime", Value: "08/09/2026 14:48:06"},
|
||||
{ReceiptEntryId: "RetentionMessage", Value: "Please retain for your records"},
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptCompleteLayout(t *testing.T) {
|
||||
for _, recipient := range []string{"CARDHOLDER COPY", "MERCHANT COPY"} {
|
||||
t.Run(recipient, func(t *testing.T) {
|
||||
entries := sampleReceipt(recipient)
|
||||
out := buildReceiptText(t, entries)
|
||||
// Ignore padding used for left/right placement, not semantic row order.
|
||||
var rows []string
|
||||
for _, line := range out.lines {
|
||||
rows = append(rows, strings.Join(strings.Fields(line), " "))
|
||||
}
|
||||
rule := strings.Repeat("-", 44)
|
||||
want := []string{recipient, "Standard Test Merchant", rule, "VISA DEBIT", "Card: ************1133",
|
||||
"AID: A0000000031010 PAN Seq No: 01", "ICC SALE", rule, "TOTAL: GBP120.00", "PIN VERIFIED APPROVED", rule,
|
||||
"Auth Code: D0A35D", "Ref: ChipDNA-Sale-20260908144731", "Transaction Seq. No: 00001059",
|
||||
"MID: ******7897 TID: ****9508", "08/09/2026 14:48:06", rule, "Please retain for your records"}
|
||||
if !reflect.DeepEqual(rows, want) {
|
||||
t.Errorf("BuildCardholderReceipt(%q) rows = %q, want %q", recipient, rows, want)
|
||||
}
|
||||
for _, entry := range entries {
|
||||
if !strings.Contains(strings.Join(out.lines, "\n"), entry.Value) {
|
||||
t.Errorf("BuildCardholderReceipt(%q) lost %s=%q", recipient, entry.ReceiptEntryId, entry.Value)
|
||||
}
|
||||
}
|
||||
for _, line := range out.lines {
|
||||
if line == "" || len(line) > 44 {
|
||||
t.Errorf("BuildCardholderReceipt(%q) row = %q, want compact nonempty row within 44 columns", recipient, line)
|
||||
}
|
||||
}
|
||||
if len(out.lines) > 19 {
|
||||
t.Errorf("BuildCardholderReceipt(%q) rows = %d, want representative receipt at most 19", recipient, len(out.lines))
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptFormattingState(t *testing.T) {
|
||||
out := buildReceiptText(t, sampleReceipt("CARDHOLDER COPY"))
|
||||
var plain strings.Builder
|
||||
for _, char := range out.chars {
|
||||
plain.WriteByte(char.value)
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
text string
|
||||
center, bold bool
|
||||
}{
|
||||
{"CARDHOLDER COPY", true, true}, {"Standard Test Merchant", true, false},
|
||||
{"VISA DEBIT", false, false}, {"TOTAL:", false, true}, {"GBP120.00", false, true},
|
||||
{"PIN VERIFIED", false, false}, {"APPROVED", false, true}, {"Auth Code:", false, false},
|
||||
{"Please retain for your records", true, false},
|
||||
} {
|
||||
start := strings.Index(plain.String(), tc.text)
|
||||
if start < 0 {
|
||||
t.Fatalf("receipt text lacks %q", tc.text)
|
||||
}
|
||||
for _, char := range out.chars[start : start+len(tc.text)] {
|
||||
if char.center != tc.center || char.bold != tc.bold {
|
||||
t.Errorf("receipt style for %q = center:%t bold:%t, want center:%t bold:%t", tc.text, char.center, char.bold, tc.center, tc.bold)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptMissingFields(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
entries []ReceiptEntryXML
|
||||
want []string
|
||||
}{
|
||||
{name: "empty"},
|
||||
{name: "empty values", entries: []ReceiptEntryXML{{ReceiptEntryId: "Aid", Label: "AID"}, {ReceiptEntryId: "Unknown", Label: "Unused"}}},
|
||||
{name: "one partner", entries: []ReceiptEntryXML{{ReceiptEntryId: "PanSequence", Value: "02"}}, want: []string{"PAN Seq No: 02"}},
|
||||
{name: "result only", entries: []ReceiptEntryXML{{ReceiptEntryId: "TransactionResult", Value: "DECLINED"}}, want: []string{"DECLINED"}},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
out := buildReceiptText(t, tc.entries)
|
||||
if !reflect.DeepEqual(out.lines, tc.want) {
|
||||
t.Errorf("BuildCardholderReceipt(%v) rows = %q, want %q", tc.entries, out.lines, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptPreservesRemainingEntries(t *testing.T) {
|
||||
entries := []ReceiptEntryXML{
|
||||
{ReceiptEntryId: "AuthCode", Value: ""},
|
||||
{ReceiptEntryId: "FooBar", Value: "first-extra", Priority: "9"},
|
||||
{ReceiptEntryId: "AuthCode", Value: "primary", Label: "Provider authorization"},
|
||||
{ReceiptEntryId: "AuthCode", Value: "duplicate", Label: "Second authorization"},
|
||||
{ReceiptEntryId: "FooBar", Value: "second-extra", Label: "Foo", Priority: "1"},
|
||||
{ReceiptEntryId: "RetentionMessage", Value: "Retain this"},
|
||||
{ReceiptEntryId: "RetentionMessage", Value: "Extra retention"},
|
||||
{ReceiptEntryId: "HTTPCode", Value: "provider-code"},
|
||||
{Value: "unlabelled-value"},
|
||||
}
|
||||
out := buildReceiptText(t, entries)
|
||||
want := []string{"Provider authorization: primary", "Foo Bar: first-extra", "Second authorization: duplicate",
|
||||
"Foo: second-extra", "Extra retention", "HTTP Code: provider-code", "unlabelled-value", strings.Repeat("-", 44), "Retain this"}
|
||||
if !reflect.DeepEqual(out.lines, want) {
|
||||
t.Errorf("BuildCardholderReceipt remaining rows = %q, want %q", out.lines, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptPairBoundaries(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, left, right string
|
||||
paired bool
|
||||
}{
|
||||
{"short", "ICC", "SALE", true},
|
||||
{"exact width", strings.Repeat("L", 20), strings.Repeat("R", 22), true},
|
||||
{"overflow", strings.Repeat("L", 21), strings.Repeat("R", 22), false},
|
||||
{"unicode", "TAP \u00c9", "SALE", false},
|
||||
{"multiline", "ICC\nFALLBACK", "SALE", false},
|
||||
{"left missing", "", "SALE", false},
|
||||
{"right missing", "ICC", "", false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
out := buildReceiptText(t, []ReceiptEntryXML{{ReceiptEntryId: "TransactionSource", Value: tc.left}, {ReceiptEntryId: "TransactionType", Value: tc.right}})
|
||||
var want []string
|
||||
if tc.paired {
|
||||
want = []string{tc.left + strings.Repeat(" ", 44-len(tc.left)-len(tc.right)) + tc.right}
|
||||
} else {
|
||||
if tc.left != "" {
|
||||
want = append(want, strings.Split(tc.left, "\n")...)
|
||||
}
|
||||
if tc.right != "" {
|
||||
want = append(want, tc.right)
|
||||
}
|
||||
}
|
||||
if !reflect.DeepEqual(out.lines, want) {
|
||||
t.Errorf("BuildCardholderReceipt pair(%q,%q) rows = %q, want %q", tc.left, tc.right, out.lines, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptLongValuesAndLabels(t *testing.T) {
|
||||
ref := strings.Repeat("long-reference-", 8)
|
||||
verify := "CONSUMER DEVICE VERIFICATION WITH ADDITIONAL PROVIDER TEXT"
|
||||
out := buildReceiptText(t, []ReceiptEntryXML{
|
||||
{ReceiptEntryId: "CardholderVerification", Value: verify},
|
||||
{ReceiptEntryId: "TransactionResult", Value: "DECLINED"},
|
||||
{ReceiptEntryId: "AuthReference", Label: "Provider reference:", Value: ref},
|
||||
{ReceiptEntryId: "MerchantIdMasked", Label: strings.Repeat("Merchant", 6), Value: "******7897"},
|
||||
{ReceiptEntryId: "TerminalIdMasked", Value: "****9508"},
|
||||
})
|
||||
want := []string{verify, "DECLINED", strings.Repeat("-", 44), "Provider reference: " + ref,
|
||||
strings.Repeat("Merchant", 6) + ": ******7897", "TID: ****9508"}
|
||||
if !reflect.DeepEqual(out.lines, want) {
|
||||
t.Errorf("BuildCardholderReceipt long fields rows = %q, want %q", out.lines, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildCardholderReceiptProviderAmounts(t *testing.T) {
|
||||
for _, amount := range []string{"GBP120.00", "EUR 42,50", "USD1.23", "amount supplied verbatim", strings.Repeat("9", 50)} {
|
||||
t.Run(amount, func(t *testing.T) {
|
||||
out := buildReceiptText(t, []ReceiptEntryXML{{ReceiptEntryId: "TotalAmount", Label: "Provider total", Value: amount}})
|
||||
if len(out.lines) != 1 || !strings.HasPrefix(out.lines[0], "Provider total:") || !strings.HasSuffix(out.lines[0], amount) {
|
||||
t.Errorf("BuildCardholderReceipt amount(%q) rows = %q, want provider label and unchanged amount", amount, out.lines)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ const (
|
||||
ServiceName = "hardlink"
|
||||
DateOnly = "2006-01-02"
|
||||
CustomLayout = "2006-01-02 15:04:05 -0700"
|
||||
LinkStartTransactionStream = "http://127.0.0.1:18181/start-transaction-stream/"
|
||||
LinkStartTransaction = "http://127.0.0.1:18181/start-transaction/"
|
||||
LinkConfirmTransaction = "http://127.0.0.1:18181/confirm-transaction/"
|
||||
LinkTransactionInformation = "http://127.0.0.1:18181/transaction-information/"
|
||||
@@ -23,6 +24,7 @@ const (
|
||||
ResultApproved = "approved"
|
||||
ResultDeclined = "declined"
|
||||
ResultCancelled = "cancelled"
|
||||
ResultCanceled = "canceled"
|
||||
ResultPending = "pending"
|
||||
ResultStateUncommitted = "uncommitted"
|
||||
ResultStateVoided = "voided"
|
||||
@@ -39,8 +41,9 @@ const (
|
||||
ReceiptDataMerchant = "RECEIPT_DATA_MERCHANT"
|
||||
ReceiptDataCardholder = "RECEIPT_DATA_CARDHOLDER"
|
||||
Reference = "REFERENCE"
|
||||
PAN_MASKED = "PAN_MASKED"
|
||||
EXPIRY_DATE = "EXPIRY_DATE"
|
||||
CardType = "CARD_SCHEME_ID"
|
||||
PanMasked = "PAN_MASKED"
|
||||
ExpiryDate = "EXPIRY_DATE"
|
||||
TransactionResult = "TRANSACTION_RESULT"
|
||||
TransactionType = "TRANSACTION_TYPE"
|
||||
TransactionState = "TRANSACTION_STATE"
|
||||
@@ -48,6 +51,25 @@ const (
|
||||
ConfirmErrors = "CONFIRM_ERRORS"
|
||||
TotalAmount = "TOTAL_AMOUNT"
|
||||
|
||||
// Dojo terminal session statuses
|
||||
ResultCaptured = "captured"
|
||||
ResultSignatureAccepted = "signatureverificationaccepted"
|
||||
ResultInitiateRequested = "initiaterequested"
|
||||
ResultInitiated = "initiated"
|
||||
ResultAuthorized = "authorized"
|
||||
ResultCancelRequested = "cancelrequested"
|
||||
ResultExpired = "expired"
|
||||
ResultSignatureRejected = "signatureverificationrejected"
|
||||
ResultSignatureRequired = "signatureverificationrequired"
|
||||
|
||||
//PayBridge message types
|
||||
MesTypePaymentRequest = "payment_request"
|
||||
MesTypePaymentResult = "payment_result"
|
||||
MesTypePaymentError = "payment_error"
|
||||
MesTypePaymentStatusUpdate = "payment_status_update"
|
||||
MesTypePaymentAccepted = "payment_accepted"
|
||||
MesTypeAuthSuccess = "auth_success"
|
||||
|
||||
// Log field keys
|
||||
LogFieldError = "error"
|
||||
LogFieldDescription = "description"
|
||||
@@ -1,241 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/signal"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/tarm/serial"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/handlers"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/logging"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/printer"
|
||||
)
|
||||
|
||||
const (
|
||||
buildVersion = "1.2.0"
|
||||
serviceName = "hardlink"
|
||||
pollingFrequency = 8 * time.Second
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Load config
|
||||
cfg := config.ReadHardlinkConfig()
|
||||
printer.Layout = readTicketLayout()
|
||||
printer.PrinterName = cfg.PrinterName
|
||||
lockserver.Cert = cfg.Cert
|
||||
lockserver.LockServerURL = cfg.LockserverUrl
|
||||
mail.SendErrorEmails = cfg.SendErrorEmails
|
||||
|
||||
// Root context for background goroutines
|
||||
// rootCtx, rootCancel := context.WithCancel(context.Background())
|
||||
// defer rootCancel()
|
||||
|
||||
var (
|
||||
dispPort *serial.Port
|
||||
disp *dispenser.Client
|
||||
cardWellStatus string
|
||||
)
|
||||
|
||||
// Setup logging and get file handle
|
||||
logFile, err := logging.SetupLogging(cfg.LogDir, serviceName, buildVersion)
|
||||
if err != nil {
|
||||
log.Printf("Failed to set up logging: %v\n", err)
|
||||
}
|
||||
if logFile != nil {
|
||||
defer logFile.Close()
|
||||
}
|
||||
|
||||
// Initialize dispenser
|
||||
if !cfg.TestMode {
|
||||
dispenser.SerialPort = cfg.DispenserPort
|
||||
dispenser.Address = []byte(cfg.DispenserAdrr)
|
||||
|
||||
dispPort, err = dispenser.InitializeDispenser()
|
||||
if err != nil {
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Dispenser Initialization Error", fmt.Sprintf("Failed to initialize dispenser: %v", err))
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
defer dispPort.Close()
|
||||
|
||||
disp = dispenser.NewClient(dispPort, 32)
|
||||
defer disp.Close()
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
|
||||
cardWellStatus, err = disp.DispenserPrepare(ctx)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("%s; wrong dispenser address: %s", err, cfg.DispenserAdrr)
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Dispenser Preparation Error", err.Error())
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
fmt.Println(cardWellStatus)
|
||||
}
|
||||
|
||||
// Test lock-server connection
|
||||
switch strings.ToLower(cfg.LockType) {
|
||||
case lockserver.TLJ:
|
||||
// TLJ uses HTTP - skip TCP probe here
|
||||
default:
|
||||
lockConn, err := lockserver.InitializeServerConnection(cfg.LockserverUrl)
|
||||
if err != nil {
|
||||
fmt.Println(err.Error())
|
||||
log.Errorf(err.Error())
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Lock Server Connection Error", err.Error())
|
||||
} else {
|
||||
fmt.Printf("Connected to the lock server successfuly at %s\n", cfg.LockserverUrl)
|
||||
log.Infof("Connected to the lock server successfuly at %s", cfg.LockserverUrl)
|
||||
lockConn.Close()
|
||||
}
|
||||
}
|
||||
|
||||
database, err := bootstrap.OpenDB(&cfg)
|
||||
if err != nil {
|
||||
log.Warnf("DB init failed: %v", err)
|
||||
}
|
||||
if database != nil {
|
||||
defer database.Close()
|
||||
}
|
||||
|
||||
if cfg.IsPayment {
|
||||
fmt.Println("Payment processing is enabled")
|
||||
log.Info("Payment processing is enabled")
|
||||
|
||||
startChipDnaClient()
|
||||
|
||||
// check ChipDNA and PDQ status and log any errors, but continue running even if it fails
|
||||
go func() {
|
||||
time.Sleep(30 * time.Second) // give ChipDNA client a moment to start
|
||||
pdqstatus, err := payment.ReadPdqStatus(cfg.Hotel, cfg.Kiosk)
|
||||
if err != nil {
|
||||
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "PDQ Status Read Error", err.Error())
|
||||
} else {
|
||||
fmt.Printf("PDQ availabile: %v\n", pdqstatus.IsAvailable)
|
||||
log.Infof("PDQ availabile: %v", pdqstatus.IsAvailable)
|
||||
}
|
||||
}()
|
||||
} else {
|
||||
fmt.Println("Payment processing is disabled")
|
||||
log.Info("Payment processing is disabled")
|
||||
}
|
||||
|
||||
// Create App and wire routes
|
||||
app := handlers.NewApp(disp, cfg.LockType, cfg.EncoderAddress, cardWellStatus, database, &cfg)
|
||||
|
||||
// Update cardWellStatus when dispenser status changes
|
||||
if !cfg.TestMode && disp != nil {
|
||||
// Set initial cardWellStatus
|
||||
app.SetCardWellStatus(cardWellStatus)
|
||||
|
||||
// Set up callback to update cardWellStatus when dispenser status changes
|
||||
disp.OnStockUpdate(func(stock string) {
|
||||
app.SetCardWellStatus(stock)
|
||||
})
|
||||
|
||||
// Start polling for dispenser status every 10 seconds
|
||||
disp.StartPolling(pollingFrequency)
|
||||
}
|
||||
|
||||
mux := http.NewServeMux()
|
||||
app.RegisterRoutes(mux)
|
||||
|
||||
addr := fmt.Sprintf(":%d", cfg.Port)
|
||||
log.Infof("Starting HTTP server on http://localhost%s", addr)
|
||||
fmt.Printf("Starting HTTP server on http://localhost%s", addr)
|
||||
|
||||
if err := http.ListenAndServe(addr, mux); err != nil {
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
}
|
||||
|
||||
func readTicketLayout() printer.LayoutOptions {
|
||||
const layoutName = "TicketLayout.xml"
|
||||
var layout printer.LayoutOptions
|
||||
|
||||
// 1) Read the file
|
||||
data, err := os.ReadFile(layoutName)
|
||||
if err != nil {
|
||||
errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
|
||||
}
|
||||
|
||||
// 2) Unmarshal into your struct
|
||||
if err := xml.Unmarshal(data, &layout); err != nil {
|
||||
errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
|
||||
}
|
||||
|
||||
return layout
|
||||
}
|
||||
|
||||
func startChipDnaClient() {
|
||||
startClient := func() (*exec.Cmd, error) {
|
||||
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
|
||||
err := cmd.Start()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to start ChipDnaClient: %v", err)
|
||||
}
|
||||
log.Infof("ChipDnaClient started with PID %d", cmd.Process.Pid)
|
||||
return cmd, nil
|
||||
}
|
||||
|
||||
cmd, err := startClient()
|
||||
if err != nil {
|
||||
errorhandlers.FatalError(err)
|
||||
}
|
||||
|
||||
// Restart loop
|
||||
go func() {
|
||||
for {
|
||||
err := cmd.Wait()
|
||||
if err != nil {
|
||||
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
|
||||
time.Sleep(2 * time.Second)
|
||||
cmd, err = startClient()
|
||||
if err != nil {
|
||||
log.Errorf("Restart failed: %v", err)
|
||||
return
|
||||
}
|
||||
log.Info("ChipDnaClient restarted successfully")
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
// Handle shutdown signals
|
||||
sigs := make(chan os.Signal, 1)
|
||||
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
||||
go func() {
|
||||
<-sigs
|
||||
log.Info("Shutting down...")
|
||||
if cmd.Process != nil {
|
||||
log.Info("Sending SIGTERM to ChipDnaClient...")
|
||||
_ = cmd.Process.Signal(syscall.SIGTERM)
|
||||
// wait up to 5s for graceful shutdown
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- cmd.Wait() }()
|
||||
select {
|
||||
case <-time.After(5 * time.Second):
|
||||
log.Warn("ChipDnaClient did not exit in time, killing...")
|
||||
_ = cmd.Process.Kill()
|
||||
case err := <-done:
|
||||
log.Infof("ChipDnaClient exited cleanly: %v", err)
|
||||
}
|
||||
}
|
||||
os.Exit(0)
|
||||
}()
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
// Package paymentstatus defines progress codes emitted by Hardlink's
|
||||
// POST /api/payment/sale stream. These codes are not authoritative final
|
||||
// transaction decisions: clients may continue check-in only after receiving a
|
||||
// final result frame whose response.data begins with /successful.
|
||||
package paymentstatus
|
||||
|
||||
const (
|
||||
Starting = "PAYMENT_STARTING"
|
||||
Started = "PAYMENT_STARTED"
|
||||
RequestSent = "PAYMENT_REQUEST_SENT"
|
||||
Accepted = "PAYMENT_ACCEPTED"
|
||||
PresentCard = "PAYMENT_PRESENT_CARD"
|
||||
InsertCard = "PAYMENT_INSERT_CARD"
|
||||
SwipeCard = "PAYMENT_SWIPE_CARD"
|
||||
EnterPIN = "PAYMENT_ENTER_PIN"
|
||||
EnterPINAgain = "PAYMENT_ENTER_PIN_AGAIN"
|
||||
PleaseWait = "PAYMENT_PLEASE_WAIT"
|
||||
DoNotRemoveCard = "PAYMENT_DO_NOT_REMOVE_CARD"
|
||||
RemoveCard = "PAYMENT_REMOVE_CARD"
|
||||
TryAnotherInterface = "PAYMENT_TRY_ANOTHER_INTERFACE"
|
||||
Processing = "PAYMENT_PROCESSING"
|
||||
Authorized = "PAYMENT_AUTHORIZED"
|
||||
Approved = "PAYMENT_APPROVED"
|
||||
Cancelling = "PAYMENT_CANCELLING"
|
||||
Cancelled = "PAYMENT_CANCELLED"
|
||||
Declined = "PAYMENT_DECLINED"
|
||||
Expired = "PAYMENT_EXPIRED"
|
||||
Timeout = "PAYMENT_TIMEOUT"
|
||||
SignatureRequired = "PAYMENT_SIGNATURE_REQUIRED"
|
||||
SignatureRejecting = "PAYMENT_SIGNATURE_REJECTING"
|
||||
SignatureRejected = "PAYMENT_SIGNATURE_REJECTED"
|
||||
Voided = "PAYMENT_VOIDED"
|
||||
DailyLimitExceeded = "PAYMENT_DAILY_LIMIT_EXCEEDED"
|
||||
VoidFailed = "PAYMENT_VOID_FAILED"
|
||||
LimitValidationError = "PAYMENT_LIMIT_VALIDATION_ERROR"
|
||||
Error = "PAYMENT_ERROR"
|
||||
TerminalUnavailable = "PAYMENT_TERMINAL_UNAVAILABLE"
|
||||
|
||||
DojoNotificationPrefix = "PAYMENT_DOJO_NOTIFICATION_"
|
||||
DojoStatusPrefix = "PAYMENT_DOJO_STATUS_"
|
||||
)
|
||||
@@ -0,0 +1,84 @@
|
||||
package paymentstatus_test
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
|
||||
)
|
||||
|
||||
func TestFixedStatusValues(t *testing.T) {
|
||||
statuses := []struct {
|
||||
name string
|
||||
value string
|
||||
want string
|
||||
}{
|
||||
{"Starting", paymentstatus.Starting, "PAYMENT_STARTING"},
|
||||
{"Started", paymentstatus.Started, "PAYMENT_STARTED"},
|
||||
{"RequestSent", paymentstatus.RequestSent, "PAYMENT_REQUEST_SENT"},
|
||||
{"Accepted", paymentstatus.Accepted, "PAYMENT_ACCEPTED"},
|
||||
{"PresentCard", paymentstatus.PresentCard, "PAYMENT_PRESENT_CARD"},
|
||||
{"InsertCard", paymentstatus.InsertCard, "PAYMENT_INSERT_CARD"},
|
||||
{"SwipeCard", paymentstatus.SwipeCard, "PAYMENT_SWIPE_CARD"},
|
||||
{"EnterPIN", paymentstatus.EnterPIN, "PAYMENT_ENTER_PIN"},
|
||||
{"EnterPINAgain", paymentstatus.EnterPINAgain, "PAYMENT_ENTER_PIN_AGAIN"},
|
||||
{"PleaseWait", paymentstatus.PleaseWait, "PAYMENT_PLEASE_WAIT"},
|
||||
{"DoNotRemoveCard", paymentstatus.DoNotRemoveCard, "PAYMENT_DO_NOT_REMOVE_CARD"},
|
||||
{"RemoveCard", paymentstatus.RemoveCard, "PAYMENT_REMOVE_CARD"},
|
||||
{"TryAnotherInterface", paymentstatus.TryAnotherInterface, "PAYMENT_TRY_ANOTHER_INTERFACE"},
|
||||
{"Processing", paymentstatus.Processing, "PAYMENT_PROCESSING"},
|
||||
{"Authorized", paymentstatus.Authorized, "PAYMENT_AUTHORIZED"},
|
||||
{"Approved", paymentstatus.Approved, "PAYMENT_APPROVED"},
|
||||
{"Cancelling", paymentstatus.Cancelling, "PAYMENT_CANCELLING"},
|
||||
{"Cancelled", paymentstatus.Cancelled, "PAYMENT_CANCELLED"},
|
||||
{"Declined", paymentstatus.Declined, "PAYMENT_DECLINED"},
|
||||
{"Expired", paymentstatus.Expired, "PAYMENT_EXPIRED"},
|
||||
{"Timeout", paymentstatus.Timeout, "PAYMENT_TIMEOUT"},
|
||||
{"SignatureRequired", paymentstatus.SignatureRequired, "PAYMENT_SIGNATURE_REQUIRED"},
|
||||
{"SignatureRejecting", paymentstatus.SignatureRejecting, "PAYMENT_SIGNATURE_REJECTING"},
|
||||
{"SignatureRejected", paymentstatus.SignatureRejected, "PAYMENT_SIGNATURE_REJECTED"},
|
||||
{"Voided", paymentstatus.Voided, "PAYMENT_VOIDED"},
|
||||
{"DailyLimitExceeded", paymentstatus.DailyLimitExceeded, "PAYMENT_DAILY_LIMIT_EXCEEDED"},
|
||||
{"VoidFailed", paymentstatus.VoidFailed, "PAYMENT_VOID_FAILED"},
|
||||
{"LimitValidationError", paymentstatus.LimitValidationError, "PAYMENT_LIMIT_VALIDATION_ERROR"},
|
||||
{"Error", paymentstatus.Error, "PAYMENT_ERROR"},
|
||||
{"TerminalUnavailable", paymentstatus.TerminalUnavailable, "PAYMENT_TERMINAL_UNAVAILABLE"},
|
||||
}
|
||||
|
||||
seen := make(map[string]string, len(statuses))
|
||||
for _, status := range statuses {
|
||||
t.Run(status.name, func(t *testing.T) {
|
||||
if status.value != status.want {
|
||||
t.Fatalf("got %q, want %q", status.value, status.want)
|
||||
}
|
||||
if !strings.HasPrefix(status.value, "PAYMENT_") {
|
||||
t.Fatalf("status %q does not have PAYMENT_ prefix", status.value)
|
||||
}
|
||||
})
|
||||
|
||||
if previous, exists := seen[status.value]; exists {
|
||||
t.Errorf("%s and %s have duplicate value %q", previous, status.name, status.value)
|
||||
}
|
||||
seen[status.value] = status.name
|
||||
}
|
||||
}
|
||||
|
||||
func TestDojoPrefixes(t *testing.T) {
|
||||
if paymentstatus.DojoNotificationPrefix != "PAYMENT_DOJO_NOTIFICATION_" {
|
||||
t.Fatalf(
|
||||
"DojoNotificationPrefix = %q, want %q",
|
||||
paymentstatus.DojoNotificationPrefix,
|
||||
"PAYMENT_DOJO_NOTIFICATION_",
|
||||
)
|
||||
}
|
||||
if paymentstatus.DojoStatusPrefix != "PAYMENT_DOJO_STATUS_" {
|
||||
t.Fatalf(
|
||||
"DojoStatusPrefix = %q, want %q",
|
||||
paymentstatus.DojoStatusPrefix,
|
||||
"PAYMENT_DOJO_STATUS_",
|
||||
)
|
||||
}
|
||||
if paymentstatus.DojoNotificationPrefix == paymentstatus.DojoStatusPrefix {
|
||||
t.Fatal("Dojo prefixes must differ")
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,67 @@
|
||||
|
||||
builtVersion is a const in main.go
|
||||
|
||||
#### v2.0.1 - 10 September 2026
|
||||
feat: add CreditCall preauth streaming
|
||||
|
||||
#### v2.0.0 - 08 September 2026
|
||||
feat: stream CreditCall payment progress and results
|
||||
|
||||
#### v1.3.6 - 28 August 2026
|
||||
Refactor PDQ lookup for payment providers
|
||||
|
||||
#### v1.3.5 - 23 July 2026
|
||||
fixed dispenser delivery confirmation
|
||||
|
||||
#### v1.3.4 - 23 July 2026
|
||||
added support for Dojo terminal-unavailable responses
|
||||
|
||||
#### v1.3.3 - 21 July 2026
|
||||
added PDQ status streaming to the payment flow to allow the front end to display the status of the PDQ terminal
|
||||
|
||||
#### 1.3.2 - 20 July 2026
|
||||
make dojo decline payment in case of signature required
|
||||
|
||||
#### 1.3.1 - 17 July 2026
|
||||
added receipt printing functionality to the Dojo and Paybridge payment flow
|
||||
|
||||
#### 1.3.0 - 03 July 2026
|
||||
added pluggable PayBridge and Dojo payment flow with CMS credentials
|
||||
|
||||
#### 1.2.11 - 26 June 2026
|
||||
added PayBridge integration for payment processing functionality
|
||||
|
||||
#### 1.2.10 - 26 June 2026
|
||||
added voucher field to the guest receipt
|
||||
|
||||
#### 1.2.9 - 02 June 2026
|
||||
added Dormakaba lock server integration
|
||||
|
||||
#### 1.2.8 - 14 May 2026
|
||||
Updated hardlink source layout to use cmd/hardlink for the main application entry point and internal/ for application packages. Runtime files and preauth-release layout remain unchanged. No functional changes.
|
||||
|
||||
#### 1.2.7 - 13 May 2026
|
||||
retrieve CardType from the ChepDNA response
|
||||
|
||||
#### 1.2.6 - 20 April 2026
|
||||
added the second attempt to send the card to the encoder after 6 seconds
|
||||
|
||||
#### 1.2.5 - 20 March 2026
|
||||
removed early return on error when checking dispenser status in the start and final loops.
|
||||
|
||||
#### 1.2.4 - 18 March 2026
|
||||
added check if keycard at the encoder position before trying to encode key
|
||||
|
||||
#### 1.2.3 - 17 March 2026
|
||||
added check if keycard at the encoder position before trying to encode key
|
||||
|
||||
#### 1.2.2 - 11 February 2026
|
||||
increased waiting time befor sending email on PDQ unavailability to 30 seconds day time and 10 minutes night time
|
||||
to give it a chance to become available again
|
||||
|
||||
#### 1.2.1 - 09 February 2026
|
||||
increased waiting time befor sending email on PDQ unavailability to 60 seconds
|
||||
|
||||
#### 1.2.0 - 09 February 2026
|
||||
added testissuedoorcard endpoint for testing the full workflow of encoding a door card without moving the card out
|
||||
added ping-pdq endpoint to check the status of the pdq terminal
|
||||
|
||||
Reference in New Issue
Block a user