diff --git a/CREDITCALL_STREAMING.md b/CREDITCALL_STREAMING.md deleted file mode 100644 index f326775..0000000 --- a/CREDITCALL_STREAMING.md +++ /dev/null @@ -1,124 +0,0 @@ -# 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. diff --git a/README.md b/README.md index 67d2f62..48ab138 100644 --- a/README.md +++ b/README.md @@ -3,267 +3,27 @@ Hardlink is the Windows hotel-kiosk service for K720 card dispensing, door-key encoding, room-ticket and payment-receipt printing, and terminal payments. It supports Assa Abloy, Omnitec, Salto, TLJ and dormakaba lock servers, and CreditCall -(ChipDNA), Dojo and PayBridge payment providers. +(ChipDNA), Dojo, PayBridge and Trust Payments providers. -## Build and run +## Documentation -Run from the repository root on Windows with Go 1.23.2 or newer and access to the -private Gitea modules. The entry point is `cmd/hardlink`, not the repository root. +- [Configuration](docs/configuration.md): local service/device settings, + room-ticket layout and CMS-only Trust configuration. +- [Operations](docs/operations.md): builds, deployment layout, hardware HTTP + endpoints, diagnostics, logs and offline verification. +- [Payment API](docs/payment-api.md): unified Sale/PREAUTH requests, NDJSON + results, transaction ownership, receipts and CreditCall streaming details. +- [K720 hardware contract](docs/hardware/k720.md): preparation, uncertain-handoff + recovery, delivery clearance and maintenance invariants. +- [Release history](docs/releases.md). +- [Historical archive](docs/archive/README.md): superseded Trust plans and + audits, retained as dated evidence rather than current operating instructions. -```powershell -go build -mod=readonly -o hardlink.exe ./cmd/hardlink -go build -mod=readonly -o hardlink-preauth-release/preauth-release.exe ./hardlink-preauth-release -./hardlink.exe -``` +Hardlink owns payment-provider selection and terminal processing. The native +Fyne applications use the common Sale/PREAUTH contract and own their financial +calculations, PMS descriptions, PMS posting and guest journeys. Trust settings +come from CMS; no local `trust:` YAML section or currency-evidence flag is needed. -`preauth-release.exe` is a separate task for releasing due CreditCall -preauthorizations; the HTTP service does not run it automatically. - -Start Hardlink with the deployment directory as its working directory: - -```text -hardlink/ - hardlink.exe - config.yml - TicketLayout.xml - ChipDNAClient/ # Required for CreditCall - ChipDnaClient.exe - ... SDK dependencies and terminal configuration - hardlink-preauth-release/ - preauth-release.exe - config.yml # Configuration for the separate release task - logs/ -``` - -`config.yml` and the ChipDNA executable path are relative to the working -directory. `TicketLayout.xml` is loaded beside the Hardlink executable. Configure -the release task's working directory to contain its own `config.yml`. - -The HTTP server binds to `:` on all interfaces; the default port is `9091`. - -## Configuration - -Example `config.yml` for card issuance and printing: - -```yaml -port: 9091 -lockType: "assaabloy" -lockservUrl: "http://192.168.4.109:4000" -encoderAddr: "1" -dispensPort: "COM9" -dispensAddr: "15" -printerName: "EPSON TM-T82II Receipt" -logdir: "./logs" -isPayment: false -``` - -- `lockType` is required: `assaabloy`, `omnitec`, `salto`, `tlj` or `kaba`. -- `cert` supplies the certificate value used by TLJ's GuestCard API. -- `dispensAddr` is the two-character serial device address. -- `printerName` must match an installed Windows printer. -- Payment setup additionally uses `isPayment`, `hotel`, `kiosk`, `cmsurl` and, - when CMS does not select a provider, `paymentProvider` (`creditcall`, `dojo` or - `paybridge`). Provider-specific terminal settings are read from CMS. -- SQL configuration uses `dbport`, `dbname`, `dbuser` and `dbpassword`; configure - these for monetary CreditCall PREAUTH persistence and the release task. -- `senderroremails` contains recipients for operational error emails. -- `timeoutSeconds` defaults to `300` for the generic payment handler. CreditCall - retains its independent 300-second start/confirmation call bounds. - -Example `TicketLayout.xml`: - -```xml - - C:/Logo/logo.png - Welcome to the hotel - Your room number is - - Hotel information - Check Out Time - C:/Logo/Roommaps - -``` - -## Door cards and K720 recovery - -`POST /issuedoorcard` accepts `Content-Type: application/json`: - -```json -{ - "roomField": "101", - "checkinTime": "2026-10-23 15:00:00 +0100", - "checkoutTime": "2026-10-24 11:00:00 +0100", - "followStr": "0" -} -``` - -Times use `2006-01-02 15:04:05 -0700`. A successful response is: - -```json -{"code":200,"message":"Card issued successfully"} -``` - -Errors use the same `code`/`message` JSON structure with an HTTP error status. -Exact physical empty (`0x38`) during preparation returns `503`; preparation -exhaustion and encoding errors return `502`. - -The serial worker exclusively owns AP, RS, FC7 and FC0 communication. Preparation -uses fresh AP observations, a 32-second preparation budget, one-second polling, -and at most three RS/shake recoveries. A valid encoder position permits encoding -immediately. Uncertain or unusable observations after FC7 share a four-second -window before an uncertain handoff may permit one encoding attempt. - -Only an uncertain handoff enables recovery concurrently with the single -`LockSequence`. It carries forward the shakes already used and runs the remaining -`RS -> 2-second settle -> AP -> FC7 -> AP` recovery sequence. Encoder confirmation -stops recovery, including before FC7 if the diagnostic AP confirms the card. -Unusable diagnostic AP is logged; it does not create a new fatal encoding error. -There is no second `LockSequence` or extra plain FC7 retry. - -When `LockSequence` returns, the handler cancels and joins recovery before one -FC0 delivery attempt. Caller cancellation stops recovery; already-started encoding -retains its original lock-server timeout and result. Recovery/FC0 errors do not -replace that result. Successful encoding keeps the existing best-effort next-card -prestage. Idle maintenance and passive status polling remain separate from the -foreground issuance operation. - -See the [K720 dispenser contract](internal/dispenser/K720_DISPENSER_CONTRACT.md) -for status classifications, clearance rules, recovery limits and cancellation. -Concurrent recovery still requires validation with the physical K720 and lock server. - -## Room tickets - -`POST /printroomticket` accepts `Content-Type: application/xml`: - -```xml - - John Doe - 24/10/2026 11:00 am - 103 - map.png - Follow the corridor... - -``` - -Success returns HTTP `200` with: - -```json -{"code":200,"message":"Print job sent successfully"} -``` - -The printer package loads the ticket layout, renders ESC/POS text and raster -images, and sends the output to the configured Windows printer. - -## Payments - -| Endpoint | Request | Purpose | -| --- | --- | --- | -| `POST /api/payment/sale` | JSON | SALE streaming for CreditCall, Dojo or PayBridge | -| `POST /api/payment/preauth` | JSON | CreditCall PREAUTH/account-verification streaming | -| `POST /takepayment` | `text/xml` | Legacy CreditCall SALE | -| `POST /takepreauth` | `text/xml` | Legacy CreditCall PREAUTH/account verification | - -The streaming endpoints return `application/x-ndjson`: progress frames followed -by a final result. CreditCall's structured final frame uses `result`; -Dojo/PayBridge use their existing `response` frame. Progress is observational and -never determines payment success or failure. - -SALE JSON example (integer minor units): - -```json -{"amount":1234,"confirmNo":"BOOKING-123","currency":"GBP"} -``` - -CreditCall monetary PREAUTH JSON example (string fields): - -```json -{"amount":"3100","transactionType":"Sale","checkoutDate":"2026-10-24 00:00:00 +0000"} -``` - -Zero-value account verification: - -```json -{"amount":"","transactionType":"AccountVerification","checkoutDate":""} -``` - -CreditCall SALE confirms approved starts; PREAUTH does not confirm. PREAUTH uses -the provider-returned `TRANSACTION_TYPE` and `TOTAL_AMOUNT`. Approved returned -`ACCOUNT VERIFICATION` needs no amount and is not persisted. Approved returned -`SALE` schedules persistence using the returned amount; it never substitutes the -request amount. SQL failures fall back to `preauth_spool.ndjson` in `logdir`. -The current SQL release date is checkout plus 96 hours, using the existing -local-midnight date conversion. - -After financial dispatch, a kiosk disconnect stops stream delivery without -cancelling CreditCall result processing, SALE confirmation, receipts or PREAUTH -persistence scheduling. Never restart a transaction or fall back to a legacy -endpoint because streaming delivery failed. - -Deploy a matching ChipDNAClient build: Hardlink starts -`./ChipDNAClient/ChipDnaClient.exe` and calls it on `127.0.0.1:18181`. That deployed -EXE must include `TRANSACTION_TYPE` and optional `TOTAL_AMOUNT` in its streaming -allowlist; an older build can support SALE while breaking PREAUTH classification. - -See [CreditCall streaming](CREDITCALL_STREAMING.md) for frame schemas, progress -ownership and timeout details. The current SQL implementation in -`internal/db/db.go` defines release scheduling. - -## Additional endpoints - -| Endpoint | Purpose | -| --- | --- | -| `/dispenserstatus` | Cached stock/status in a `code`/`message` JSON response | -| `POST /testissuedoorcard` | Diagnostic issuance path; not the normal delivery workflow | -| `/ping-pdq` | Read ChipDNA terminal status | -| `POST /logerror` | Receive ChipDNA error notifications | - -## Logging - -JSON logs are written to `/hardlink.log`. Weekly rotation uses local -Monday midnight and retains `hardlink.1.log` through `hardlink.13.log`. The separate -release task writes `preauth-release.log` with the same rotation policy. - -K720 logs include uncertain handoff, raw AP status/classification, RS/FC7 attempts, -remaining shake budget, recovery stop reason and encoding duration. PREAUTH logs -include processor result/type, transaction reference, approval/persistence -decision, missing fields, and SQL/spool outcomes without card or receipt payloads. - -## Verification - -Use repository-local build and temporary caches from PowerShell: - -```powershell -New-Item -ItemType Directory -Force .cache/go-build, .cache/tmp | Out-Null -$env:GOCACHE = Join-Path $PWD '.cache/go-build' -$env:GOTMPDIR = Join-Path $PWD '.cache/tmp' - -go test -mod=readonly -count=1 ./internal/dispenser ./internal/handlers -go test -mod=readonly -race -count=1 ./internal/dispenser ./internal/handlers -go test -mod=readonly -count=1 -skip '^Test_SendMail$' ./... -go vet -mod=readonly ./... -go build -mod=readonly ./... -git diff --check -``` - -`Test_SendMail` sends real email and is excluded from offline verification. -Automated tests do not replace physical dispenser, encoder, terminal or printer -validation. - -## Deployment - -Production deployment uses Salt. Build the intended revision and deploy the -versioned Windows package through the Salt repository and Hardlink pillar. - -Where installed, local release tooling is invoked as `bash ./winbuild.sh ` -from the `development` branch. It builds Hardlink and the release task, packages -the existing `ChipDNAClient/` directory into `hardlink_windows_.zip`, and -copies it to `salt/hardlink/files`. It also checks out/pulls the Salt and pillar -repositories and commits/pushes the package in Salt; it does not create a Git tag. -Ensure `ChipDNAClient/` contains the intended build before packaging. - -Update `pillar/hardlink/init.sls` to select the package version, then apply the -Hardlink state to the intended hosts: - -```bash -salt '' state.apply hardlink -``` +The deprecated XML payment routes remain solely for legacy compatibility. +`/testissuedoorcard` remains an operational diagnostic available on production +kiosks regardless of TestMode, and retains the encoded card inside the dispenser. diff --git a/cmd/hardlink/main.go b/cmd/hardlink/main.go index d1622cc..16f3389 100644 --- a/cmd/hardlink/main.go +++ b/cmd/hardlink/main.go @@ -33,7 +33,7 @@ import ( ) const ( - buildVersion = "v2.1.5" + buildVersion = "v2.2.0" serviceName = "hardlink" pollingFrequency = 8 * time.Second ) @@ -46,10 +46,6 @@ func main() { 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 @@ -123,17 +119,22 @@ func main() { log.Info("Payment processing is enabled") var provider paymentsvc.Provider - reservationSystem, err := cms.ReadHotel(cfg.Hotel, cfg.CMSBaseURL) + hotel, err := cms.ReadHotelDetails(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)) } + reservationSystem := hotel.ReservationSystem paymentProvider := reservationSystem.PaymentSystem if paymentProvider == 0 { paymentProvider = cms.PaymentSystemIndex(cfg.PaymentProvider) } switch paymentProvider { + case cmstypes.PaySystemTrustPayments: + if err := configureTrust(app, cfg, hotel); err != nil { + errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to initialize Trust Payments", err) + } case cmstypes.PaySystemCreditCall: // CreditCall streaming shares its proven legacy transaction core. app.EnableCreditCallStreaming() @@ -152,9 +153,6 @@ func main() { 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) @@ -165,11 +163,13 @@ func main() { errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway API Key not found", fmt.Errorf("payment provider paybridge requires paybridge.api_key")) } - provider = paybridge.NewClient( + payBridgeClient := paybridge.NewClient( websocketURL, reservationSystem.PaymentGatewayAPIKeyWeb, cfg.TimeoutSeconds, ) + payBridgeClient.PrintReceipt = printer.PrintSaleReceipt + provider = payBridgeClient case cmstypes.PaySystemDojo: TerminalID := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk) @@ -182,6 +182,7 @@ func main() { } dojoClient, err := dojo.NewClient(dojo.Config{ + PrintReceipt: printer.PrintSaleReceipt, BaseURL: reservationSystem.PaymentGatewayURL, APIKey: reservationSystem.PaymentGatewayAPIKeyWeb, SoftwareHouseID: reservationSystem.PaymentGatewaySiteIDEPOS, @@ -195,21 +196,22 @@ func main() { 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")) + errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "No payment provider selected", fmt.Errorf("payment processing is enabled, but no payment provider selected; expected creditcall, trustpayments, paybridge or dojo")) default: errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Unsupported Payment Provider", fmt.Errorf( - "unsupported payment provider %q; expected creditcall, paybridge or dojo", + "unsupported payment provider %q; expected creditcall, trustpayments, paybridge or dojo", cfg.PaymentProvider, )) } - // PayBridge and Dojo use the generic payment service. + // All modern endpoint providers use the same 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]) } + app.SetPaymentCurrency(hotel.Currency.Code) + 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") @@ -242,24 +244,6 @@ func main() { } } -// 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") diff --git a/cmd/hardlink/startup_diagnostics_test.go b/cmd/hardlink/startup_diagnostics_test.go new file mode 100644 index 0000000..f7509f5 --- /dev/null +++ b/cmd/hardlink/startup_diagnostics_test.go @@ -0,0 +1,236 @@ +package main + +import ( + "context" + "encoding/json" + "errors" + "go/ast" + "go/parser" + "go/token" + "io" + "net/http" + "os" + "os/exec" + "path/filepath" + "strconv" + "strings" + "testing" + "time" + + "gitea.futuresens.co.uk/futuresens/cmstypes" + log "github.com/sirupsen/logrus" +) + +type startupFixtureStop struct{} +type startupLogHook struct{} + +func (startupLogHook) Levels() []log.Level { return log.AllLevels } +func (startupLogHook) Fire(entry *log.Entry) error { + if strings.HasPrefix(entry.Message, "Payment provider enabled for POST /api/payment/sale:") { + if err := os.WriteFile("provider-started.txt", []byte(entry.Message), 0600); err != nil { + os.Exit(92) + } + // Stop before main binds HTTP or admits any financial/device operation. + panic(startupFixtureStop{}) + } + return nil +} + +// This child process executes the real startup/fatal-notification path. TestMode +// and TLJ bypass devices; missing DB configuration returns before opening SQL. +func TestPostAuditStartupFixture(t *testing.T) { + scenario := os.Getenv("HARDLINK_POST_AUDIT_STARTUP") + if scenario == "" { + t.Skip("isolated startup fixture") + } + hotel := syntheticTrustHotel() + switch scenario { + case "gateway": + hotel.ReservationSystem.PaymentGatewayURL = "" + case "password": + hotel.ReservationSystem.PaymentGatewayPasswordEPOS = "" + case "ped": + hotel.ReservationSystem.PDQs = nil + case "timezone": + hotel.ReservationSystem.TimeZone = "SYNTH/INVALID" + case "none": + hotel.ReservationSystem.PaymentSystem = cmstypes.PaySystemNone + case "unsupported": + hotel.ReservationSystem.PaymentSystem = 999 + case "ready": + default: + t.Fatal("unrecognized synthetic startup scenario") + } + transport := cmsTrustTransport(func(r *http.Request) (*http.Response, error) { + var body []byte + switch r.URL.Hostname() { + case "cms.invalid": + response := cmstypes.HotelResponseRec{TheHotel: hotel} + response.Status.Code = cmstypes.StatusSuccessCode + var err error + body, err = json.Marshal(response) + if err != nil { + return nil, err + } + case "api.mailjet.com": + var notification struct { + Messages []struct{ Subject, TextPart string } + } + if err := json.NewDecoder(r.Body).Decode(¬ification); err != nil { + return nil, err + } + // Retain only notification text, never headers or API authentication. + encoded, err := json.Marshal(notification) + if err != nil { + return nil, err + } + if err := os.WriteFile("notification.json", encoded, 0600); err != nil { + return nil, err + } + body = []byte(`{"Messages":[{"Status":"success"}]}`) + default: + if err := os.WriteFile("unexpected-network.txt", []byte("rejected non-mock request"), 0600); err != nil { + return nil, err + } + return nil, errors.New("offline startup fixture prohibits network") + } + return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(string(body)))}, nil + }) + http.DefaultTransport = transport + http.DefaultClient = &http.Client{Transport: transport} + log.AddHook(startupLogHook{}) + defer func() { + if stopped := recover(); stopped != nil { + if _, ok := stopped.(startupFixtureStop); !ok { + panic(stopped) + } + } + }() + main() + t.Fatal("startup fixture unexpectedly returned from main") +} + +func TestTrustStartupUsesExistingFatalNotification(t *testing.T) { + for _, tc := range []struct{ name, field string }{ + {"gateway", "PaymentGatewayURL"}, {"password", "PaymentGatewayPasswordEPOS"}, + {"ped", "PED"}, {"timezone", "TimeZone"}, + {"none", "expected creditcall, trustpayments, paybridge or dojo"}, + {"unsupported", "expected creditcall, trustpayments, paybridge or dojo"}, + {"ready", ""}, + } { + t.Run(tc.name, func(t *testing.T) { + dir := t.TempDir() + configuration := "hotel: SYNTH-HOTEL\nkiosk: 9\nlockType: tlj\ntestMode: true\nisPayment: true\ncmsurl: http://cms.invalid\nsenderroremails:\n - operator@example.test\nlogdir: ./logs\n" + if err := os.WriteFile(filepath.Join(dir, "config.yml"), []byte(configuration), 0600); err != nil { + t.Fatal(err) + } + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) + defer cancel() + process := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestPostAuditStartupFixture$") + process.Dir = dir + process.Env = append(os.Environ(), "HARDLINK_POST_AUDIT_STARTUP="+tc.name) + process.Stdin = strings.NewReader("\n") + output, err := process.CombinedOutput() + if ctx.Err() != nil { + t.Fatalf("Startup(%s) timed out: %v", tc.name, ctx.Err()) + } + if tc.name == "ready" { + if err != nil { + t.Fatalf("Startup(ready) error=%v output=%s, want successful synthetic initialization", err, output) + } + started, readErr := os.ReadFile(filepath.Join(dir, "provider-started.txt")) + if readErr != nil || !strings.HasSuffix(string(started), "trustpayments") { + t.Errorf("Startup(ready) log=%q error=%v, want common Trust provider-enabled log", started, readErr) + } + if _, statErr := os.Stat(filepath.Join(dir, "notification.json")); !os.IsNotExist(statErr) { + t.Errorf("Startup(ready) notification error=%v, want no failure notification", statErr) + } + } else { + var exitError *exec.ExitError + if !errors.As(err, &exitError) || exitError.ExitCode() != 1 { + t.Fatalf("Startup(%s) error=%v output=%s, want fatal exit1", tc.name, err, output) + } + notification, readErr := os.ReadFile(filepath.Join(dir, "notification.json")) + if readErr != nil { + t.Fatalf("Startup(%s) notification error=%v, want existing fatal mail attempted", tc.name, readErr) + } + text := string(notification) + for _, want := range []string{"SYNTH-HOTEL", "kiosk: 9", tc.field} { + if !strings.Contains(text, want) { + t.Errorf("Startup(%s) notification missing %q", tc.name, want) + } + } + if tc.name != "none" && tc.name != "unsupported" && !strings.Contains(text, "Failed to initialize Trust Payments") { + t.Errorf("Startup(%s) notification lacks Trust initialization title", tc.name) + } + logs, _ := os.ReadFile(filepath.Join(dir, "logs", "hardlink.log")) + for _, secret := range []string{"SYNTH-PASSWORD", "SYNTH-PED"} { + if strings.Contains(text+string(output)+string(logs), secret) { + t.Errorf("Startup(%s) diagnostic leaked synthetic secret %q", tc.name, secret) + } + } + } + if _, statErr := os.Stat(filepath.Join(dir, "unexpected-network.txt")); !os.IsNotExist(statErr) { + t.Errorf("Startup(%s) attempted a non-mock request", tc.name) + } + }) + } +} + +func TestProviderEnabledLoggingIsSharedByAllSelections(t *testing.T) { + file, err := parser.ParseFile(token.NewFileSet(), "main.go", nil, 0) + if err != nil { + t.Fatal(err) + } + var paymentBody *ast.BlockStmt + ast.Inspect(file, func(node ast.Node) bool { + if statement, ok := node.(*ast.IfStmt); ok { + if condition, ok := statement.Cond.(*ast.SelectorExpr); ok && condition.Sel.Name == "IsPayment" { + paymentBody = statement.Body + return false + } + } + return true + }) + if paymentBody == nil { + t.Fatal("main has no payment startup block") + } + sharedMessages := 0 + for _, statement := range paymentBody.List { + expression, ok := statement.(*ast.ExprStmt) + if !ok { + continue + } + call, ok := expression.X.(*ast.CallExpr) + if !ok || len(call.Args) != 2 { + continue + } + format, ok := call.Args[0].(*ast.BasicLit) + if !ok { + continue + } + text, err := strconv.Unquote(format.Value) + if err != nil || !strings.HasPrefix(text, "Payment provider enabled for POST /api/payment/sale:") { + continue + } + index, ok := call.Args[1].(*ast.IndexExpr) + if !ok { + t.Error("common startup message does not use selected provider name") + continue + } + name, ok := index.X.(*ast.SelectorExpr) + if !ok || name.Sel.Name != "PaySystemNames" { + t.Error("common startup message lost standard provider names") + continue + } + sharedMessages++ + } + if sharedMessages != 2 { + t.Errorf("main has %d unconditional common provider messages, want logging and console outside provider-specific branches", sharedMessages) + } + for _, provider := range []int{cmstypes.PaySystemCreditCall, cmstypes.PaySystemTrustPayments, cmstypes.PaySystemDojo, cmstypes.PaySystemPayBridge} { + if cmstypes.PaySystemNames[provider] == "" { + t.Errorf("common startup name for provider%d is empty", provider) + } + } +} diff --git a/cmd/hardlink/trust.go b/cmd/hardlink/trust.go new file mode 100644 index 0000000..63cc42c --- /dev/null +++ b/cmd/hardlink/trust.go @@ -0,0 +1,36 @@ +package main + +import ( + "errors" + "gitea.futuresens.co.uk/futuresens/cmstypes" + "gitea.futuresens.co.uk/futuresens/hardlink/config" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/handlers" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments" +) + +func configureTrust(app *handlers.App, cfg config.ConfigRec, hotel cmstypes.Hotel) error { + res := hotel.ReservationSystem + serial, count := "", 0 + for _, pdq := range res.PDQs { + if pdq.Kiosk == cfg.Kiosk { + serial = pdq.Serial + count++ + } + } + if count != 1 || serial == "" { + return errors.New("exactly one Trust PED serial required") + } + client, err := trustpayments.New( + trustpayments.Config{ + BaseURL: res.PaymentGatewayURL, + SiteID: res.PaymentGatewaySiteIDEPOS, + Password: res.PaymentGatewayPasswordEPOS, + Terminal: serial, + Currency: hotel.Currency.Code, + Timezone: res.TimeZone}) + if err != nil { + return err + } + app.SetTrustPayments(client) + return nil +} diff --git a/cmd/hardlink/trust_test.go b/cmd/hardlink/trust_test.go new file mode 100644 index 0000000..d2515e3 --- /dev/null +++ b/cmd/hardlink/trust_test.go @@ -0,0 +1,155 @@ +package main + +import ( + "context" + "encoding/json" + "errors" + "io" + "net" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "sync/atomic" + "testing" + "time" + + "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/handlers" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments" + yaml "gopkg.in/yaml.v3" +) + +type cmsTrustTransport func(*http.Request) (*http.Response, error) + +func (f cmsTrustTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +func syntheticTrustHotel() cmstypes.Hotel { + hotel := cmstypes.Hotel{Currency: cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2}} + hotel.Updated = 1 + hotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: cmstypes.PaySystemTrustPayments, PaymentGatewayURL: "https://sandbox.link.trustpayments.com/trustpayments/rest", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", TimeZone: "Europe/London", PDQs: []cmstypes.PDQRec{{Kiosk: 4, Serial: "OTHER-PED"}, {Kiosk: 9, Serial: "SYNTH-PED"}}} + return hotel +} + +func TestConfigureTrustUsesCMSWithoutLocalTrustYAML(t *testing.T) { + var cfg config.ConfigRec + if err := yaml.Unmarshal([]byte("hotel: SYNTH-HOTEL\nkiosk: 9\nlockType: assaabloy\nisPayment: true\n"), &cfg); err != nil { + t.Fatal(err) + } + if _, exists := reflect.TypeOf(cfg).FieldByName("Trust"); exists { + t.Fatal("ConfigRec still exposes local Trust configuration") + } + hotel := syntheticTrustHotel() + var cmsCalls, financialCalls atomic.Int32 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + cmsCalls.Add(1) + response := cmstypes.HotelResponseRec{TheHotel: hotel} + response.Status.Code = cmstypes.StatusSuccessCode + _ = json.NewEncoder(w).Encode(response) + })) + defer server.Close() + cfg.CMSBaseURL = server.URL + original := http.DefaultTransport + base := original.(*http.Transport).Clone() + base.Proxy = nil + dialer := &net.Dialer{} + base.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) { + if address != server.Listener.Addr().String() { + return nil, errors.New("offline test rejected non-mock dial") + } + return dialer.DialContext(ctx, network, address) + } + http.DefaultTransport = cmsTrustTransport(func(r *http.Request) (*http.Response, error) { + if r.URL.Host == server.Listener.Addr().String() { + return base.RoundTrip(r) + } + if r.URL.Host != "sandbox.link.trustpayments.com" || r.URL.Path != "/trustpayments/rest/sale" { + return nil, errors.New("offline test rejected unregistered request") + } + financialCalls.Add(1) + var payload map[string]string + if err := json.NewDecoder(r.Body).Decode(&payload); err != nil { + return nil, err + } + if payload["siteid"] != hotel.ReservationSystem.PaymentGatewaySiteIDEPOS || payload["terminalserialnumber"] != "SYNTH-PED" || payload["amount"] != "25.00" { + t.Errorf("provider request = %v, want CMS credentials/PED and exact amount", payload) + } + wantToken := trustpayments.Token(hotel.ReservationSystem.PaymentGatewaySiteIDEPOS, payload["txndate"], payload["refid"], hotel.ReservationSystem.PaymentGatewayPasswordEPOS) + if r.Header.Get("token") != wantToken { + t.Error("request was not signed with CMS credentials") + } + location, _ := time.LoadLocation(hotel.ReservationSystem.TimeZone) + signedAt, err := time.ParseInLocation("2006-01-02:15:04:05", payload["txndate"], location) + if err != nil || time.Since(signedAt) < -time.Second || time.Since(signedAt) > 5*time.Second { + t.Errorf("CMS signing timezone was not used: %q/%v", payload["txndate"], err) + } + // A definite refusal exercises dispatch without invoking any receipt printer. + body, _ := json.Marshal(map[string]string{"refid": payload["refid"], "siteid": payload["siteid"], "terminalserialnumber": payload["terminalserialnumber"], "type": "sale", "resultcode": "Declined"}) + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body)))}, nil + }) + t.Cleanup(func() { http.DefaultTransport = original; base.CloseIdleConnections() }) + loaded, err := cms.ReadHotelDetails(cfg.Hotel, cfg.CMSBaseURL) + if err != nil { + t.Fatal(err) + } + if loaded.Currency != hotel.Currency { + t.Fatal("full CMS hotel currency was discarded") + } + app := handlers.NewApp(nil, cfg.LockType, "synthetic", "", nil, &cfg) + if err := configureTrust(app, cfg, loaded); err != nil { + t.Fatal(err) + } + if cmsCalls.Load() != 1 || financialCalls.Load() != 0 { + t.Fatal("initialization made extra CMS or financial requests") + } + mux := http.NewServeMux() + app.RegisterRoutes(mux) + w := httptest.NewRecorder() + r := httptest.NewRequest("POST", "/api/payment/sale", strings.NewReader(`{"amount":2500,"currency":"DIFFERENT"}`)) + mux.ServeHTTP(w, r) + if w.Code != 200 || !strings.Contains(w.Body.String(), `"outcome":"declined"`) || financialCalls.Load() != 1 { + t.Fatalf("CMS-only terminal request = HTTP %d/%s calls=%d", w.Code, w.Body.String(), financialCalls.Load()) + } +} + +func TestConfigureTrustRejectsMissingEssentialCMSSettingsBeforeDispatch(t *testing.T) { + cases := []struct { + name, field string + change func(*cmstypes.Hotel) + }{ + {"gateway", "PaymentGatewayURL", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayURL = "" }}, + {"invalid gateway", "PaymentGatewayURL", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayURL = "http://synthetic.invalid" }}, + {"site", "PaymentGatewaySiteIDEPOS", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewaySiteIDEPOS = "" }}, + {"password", "PaymentGatewayPasswordEPOS", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayPasswordEPOS = "" }}, + {"missing PED", "PED", func(h *cmstypes.Hotel) { h.ReservationSystem.PDQs = nil }}, + {"empty PED", "PED", func(h *cmstypes.Hotel) { h.ReservationSystem.PDQs[1].Serial = "" }}, + {"duplicate PED", "PED", func(h *cmstypes.Hotel) { + h.ReservationSystem.PDQs = append(h.ReservationSystem.PDQs, h.ReservationSystem.PDQs[1]) + }}, + {"timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "" }}, + {"invalid timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "SYNTH/INVALID" }}, + {"machine timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "Local" }}, + } + var networkCalls atomic.Int32 + original := http.DefaultTransport + http.DefaultTransport = cmsTrustTransport(func(*http.Request) (*http.Response, error) { + networkCalls.Add(1) + return nil, errors.New("offline test rejects all network") + }) + t.Cleanup(func() { http.DefaultTransport = original }) + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + hotel := syntheticTrustHotel() + tc.change(&hotel) + err := configureTrust(&handlers.App{}, config.ConfigRec{Kiosk: 9}, hotel) + if err == nil || !strings.Contains(err.Error(), tc.field) || strings.Contains(err.Error(), "SYNTH-PASSWORD") { + t.Errorf("configureTrust(%s)=%v, want safe field-specific error", tc.name, err) + } + }) + } + if networkCalls.Load() != 0 { + t.Fatalf("invalid CMS settings triggered %d requests", networkCalls.Load()) + } +} diff --git a/cms/cms.go b/cms/cms.go index 8fe9074..2589357 100644 --- a/cms/cms.go +++ b/cms/cms.go @@ -17,14 +17,20 @@ import ( // 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 + hotel, err := ReadHotelDetails(hotelCode, CMSBaseURL) + return hotel.ReservationSystem, err +} + +// ReadHotelDetails retains the complete hotel response, including its currency. +func ReadHotelDetails(hotelCode, CMSBaseURL string) (cmstypes.Hotel, error) { + var hotel cmstypes.Hotel if hotelCode == "" { - return reservationSystem, errors.New("hotel code is empty") + return hotel, errors.New("hotel code is empty") } if CMSBaseURL == "" { - return reservationSystem, errors.New("CMS base URL is empty") + return hotel, errors.New("CMS base URL is empty") } var request cmstypes.RequestRec @@ -36,7 +42,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err requestData, err := json.Marshal(request) if err != nil { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "marshal CMS hotel request: %w", err, ) @@ -46,7 +52,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err req, err := http.NewRequest(http.MethodPost, requestURL, bytes.NewReader(requestData)) if err != nil { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "create CMS hotel request: %w", err, ) @@ -61,7 +67,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err resp, err := client.Do(req) if err != nil { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "perform CMS hotel request: %w", err, ) @@ -70,7 +76,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err body, err := io.ReadAll(resp.Body) if err != nil { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "read CMS hotel response: %w", err, ) @@ -78,7 +84,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "CMS hotel request returned HTTP %s: %s", resp.Status, string(body), @@ -88,26 +94,26 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err var hotelResponse cmstypes.HotelResponseRec if err := json.Unmarshal(body, &hotelResponse); err != nil { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "unmarshal CMS hotel response: %w", err, ) } if hotelResponse.Status.Code != cmstypes.StatusSuccessCode { - return reservationSystem, fmt.Errorf( + return hotel, fmt.Errorf( "CMS hotel request failed: %s", hotelResponse.Status.Message, ) } if hotelResponse.TheHotel.Updated <= -1 { - return reservationSystem, errors.New( + return hotel, errors.New( "hotel record not updated since last read", ) } - return hotelResponse.TheHotel.ReservationSystem, nil + return hotelResponse.TheHotel, nil } func PaymentSystemIndex(name string) int { diff --git a/cms/cms_test.go b/cms/cms_test.go index 17dfd26..d126582 100644 --- a/cms/cms_test.go +++ b/cms/cms_test.go @@ -4,7 +4,6 @@ import ( "encoding/json" "io" "net/http" - "net/http/httptest" "reflect" "strings" "testing" @@ -17,7 +16,7 @@ func TestReadHotelSuccess(t *testing.T) { expected := cmstypes.ReservationSystemRec{} - server := httptest.NewServer(http.HandlerFunc( + server := newCMSMockServer(http.HandlerFunc( func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost { t.Errorf( @@ -157,7 +156,7 @@ func TestReadHotelValidation(t *testing.T) { } func TestReadHotelNotUpdated(t *testing.T) { - server := httptest.NewServer(http.HandlerFunc( + server := newCMSMockServer(http.HandlerFunc( func(w http.ResponseWriter, _ *http.Request) { response := cmstypes.HotelResponseRec{} response.Status.Code = cmstypes.StatusSuccessCode @@ -185,7 +184,7 @@ func TestReadHotelNotUpdated(t *testing.T) { } func TestReadHotelHTTPError(t *testing.T) { - server := httptest.NewServer(http.HandlerFunc( + server := newCMSMockServer(http.HandlerFunc( func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusInternalServerError) @@ -211,7 +210,7 @@ func TestReadHotelHTTPError(t *testing.T) { } func TestReadHotelInvalidJSON(t *testing.T) { - server := httptest.NewServer(http.HandlerFunc( + server := newCMSMockServer(http.HandlerFunc( func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "application/json") @@ -230,4 +229,4 @@ func TestReadHotelInvalidJSON(t *testing.T) { if !strings.Contains(err.Error(), "unmarshal CMS hotel response") { t.Errorf("unexpected error: %v", err) } -} \ No newline at end of file +} diff --git a/cms/hotel_details_test.go b/cms/hotel_details_test.go new file mode 100644 index 0000000..866db44 --- /dev/null +++ b/cms/hotel_details_test.go @@ -0,0 +1,60 @@ +package cms + +import ( + "encoding/json" + "net/http" + "reflect" + "sync/atomic" + "testing" + + "gitea.futuresens.co.uk/futuresens/cmstypes" +) + +func TestReadHotelDetailsRetainsCMSPaymentConfiguration(t *testing.T) { + var calls atomic.Int32 + hotel := cmstypes.Hotel{Currency: cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2}} + hotel.Updated = 1 + hotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: cmstypes.PaySystemTrustPayments, PaymentGatewayURL: "https://sandbox.link.trustpayments.com/trustpayments/rest", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", TimeZone: "Europe/London", PDQs: []cmstypes.PDQRec{{Kiosk: 9, Serial: "SYNTH-PED"}}} + server := newCMSMockServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + calls.Add(1) + if r.Method != http.MethodPost || r.URL.Path != cmstypes.APIHotelDetails { + t.Errorf("CMS request = %s %s, want existing hotel-details POST", r.Method, r.URL.Path) + } + var request cmstypes.RequestRec + if err := json.NewDecoder(r.Body).Decode(&request); err != nil { + t.Error(err) + } + if request.Auth.Hotel != "SYNTH-HOTEL" || request.Data != "SYNTH-HOTEL" { + t.Error("CMS hotel identity changed") + } + response := cmstypes.HotelResponseRec{TheHotel: hotel} + response.Status.Code = cmstypes.StatusSuccessCode + if err := json.NewEncoder(w).Encode(response); err != nil { + t.Error(err) + } + })) + defer server.Close() + got, err := ReadHotelDetails("SYNTH-HOTEL", server.URL) + if err != nil || !reflect.DeepEqual(got, hotel) || calls.Load() != 1 { + t.Fatalf("ReadHotelDetails = %+v/%v requests=%d, want complete CMS hotel in one request", got, err, calls.Load()) + } +} + +func TestReadHotelProjectionPreservesOtherProviderSettings(t *testing.T) { + for _, provider := range []int{cmstypes.PaySystemCreditCall, cmstypes.PaySystemDojo, cmstypes.PaySystemPayBridge} { + t.Run(cmstypes.PaySystemNames[provider], func(t *testing.T) { + var calls atomic.Int32 + response := cmstypes.HotelResponseRec{} + response.Status.Code = cmstypes.StatusSuccessCode + response.TheHotel.Updated = 1 + response.TheHotel.Currency = cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2} + response.TheHotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: provider, PaymentGatewayURL: "https://synthetic.invalid", PaymentGatewayAPIKeyWeb: "SYNTH-API", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", PDQs: []cmstypes.PDQRec{{Kiosk: 9, Serial: "SYNTH-PED"}}} + server := newCMSMockServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls.Add(1); _ = json.NewEncoder(w).Encode(response) })) + defer server.Close() + got, err := ReadHotel("SYNTH-HOTEL", server.URL) + if err != nil || !reflect.DeepEqual(got, response.TheHotel.ReservationSystem) || calls.Load() != 1 { + t.Fatalf("ReadHotel projection = %+v/%v calls=%d, want unchanged provider settings and one request", got, err, calls.Load()) + } + }) + } +} diff --git a/cms/offline_network_test.go b/cms/offline_network_test.go new file mode 100644 index 0000000..2d790fc --- /dev/null +++ b/cms/offline_network_test.go @@ -0,0 +1,43 @@ +package cms + +import ( + "errors" + "net/http" + "net/http/httptest" + "os" + "sync" + "testing" +) + +var cmsMockHosts = struct { + sync.RWMutex + values map[string]bool +}{values: make(map[string]bool)} + +type cmsOfflineTransport struct{ base http.RoundTripper } + +func (t cmsOfflineTransport) RoundTrip(r *http.Request) (*http.Response, error) { + cmsMockHosts.RLock() + allowed := cmsMockHosts.values[r.URL.Host] + cmsMockHosts.RUnlock() + if !allowed { + return nil, errors.New("offline CMS tests reject unregistered endpoints") + } + return t.base.RoundTrip(r) +} + +func newCMSMockServer(handler http.Handler) *httptest.Server { + server := httptest.NewServer(handler) + cmsMockHosts.Lock() + cmsMockHosts.values[server.Listener.Addr().String()] = true + cmsMockHosts.Unlock() + return server +} + +func TestMain(m *testing.M) { + base := http.DefaultTransport.(*http.Transport).Clone() + base.Proxy = nil + http.DefaultTransport = cmsOfflineTransport{base: base} + http.DefaultClient = &http.Client{Transport: http.DefaultTransport} + os.Exit(m.Run()) +} diff --git a/internal/creditcall/chipdnastatus.go b/internal/creditcall/chipdnastatus.go index 5ed7229..12cf732 100644 --- a/internal/creditcall/chipdnastatus.go +++ b/internal/creditcall/chipdnastatus.go @@ -2,7 +2,6 @@ package creditcall import ( "bytes" - "context" "encoding/xml" "fmt" "html" @@ -243,36 +242,3 @@ func ReadPdqStatus(hotel string, kiosk int) (PaymentDeviceStatus, error) { return dev, nil } - -func StartPdqHourlyCheck(ctx context.Context, hotel string, kiosk int) { - // waitUntilNextHour(ctx) - - // First execution exactly at round hour - _, _ = ReadPdqStatus(hotel, kiosk) - - ticker := time.NewTicker(10 * time.Second) - defer ticker.Stop() - - for { - select { - case <-ctx.Done(): - return - case <-ticker.C: - _, _ = ReadPdqStatus(hotel, kiosk) - } - } -} - -func waitUntilNextHour(ctx context.Context) { - now := time.Now() - next := now.Truncate(time.Hour).Add(time.Hour) - d := time.Until(next) - - timer := time.NewTimer(d) - defer timer.Stop() - - select { - case <-ctx.Done(): - case <-timer.C: - } -} diff --git a/internal/creditcall/creditcall.go b/internal/creditcall/creditcall.go index 0bf31da..d5be656 100644 --- a/internal/creditcall/creditcall.go +++ b/internal/creditcall/creditcall.go @@ -16,12 +16,6 @@ import ( // XML parsing structs type ( - TransactionRec struct { - XMLName xml.Name `xml:"TransactionPayload"` - AmountMinorUnits string `xml:"amount"` - TransactionType string `xml:"transactionType"` - } - TransactionResultXML struct { XMLName xml.Name `xml:"TransactionResult"` Entries []EntryXML `xml:"Entry"` @@ -99,39 +93,6 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML) } } -// BuildPaymentRedirectURL builds the redirect URL to send the guest to after payment. -func BuildPaymentRedirectURL(result map[string]string) string { - res := result[types.TransactionResult] - - // Transaction approved? - if strings.EqualFold(res, types.ResultApproved) { - // Transaction confirmed? - if strings.EqualFold(result[types.ConfirmResult], types.ResultApproved) { - log.WithField(types.LogResult, result[types.ConfirmResult]). - Info("Transaction approved and confirmed") - - return BuildSuccessURL(result) - } - - // Not confirmed - log.WithFields(log.Fields{types.LogFieldError: result[types.ConfirmResult], types.LogFieldDescription: result[types.ConfirmErrors]}). - Error("Transaction approved but not confirmed") - - return BuildFailureURL(result[types.ConfirmResult], result[types.ConfirmErrors]) - } - - // Not approved - return BuildFailureURL(res, result[types.Errors]) -} - -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] diff --git a/internal/creditcall/preauth_test.go b/internal/creditcall/preauth_test.go index 57c07ff..f995225 100644 --- a/internal/creditcall/preauth_test.go +++ b/internal/creditcall/preauth_test.go @@ -1,7 +1,6 @@ package creditcall import ( - "strings" "testing" "gitea.futuresens.co.uk/futuresens/hardlink/internal/types" @@ -23,12 +22,12 @@ func TestPreauthLegacyDecision(t *testing.T) { } { 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) + approved, save := PreauthDecision(fields) + if approved != tc.approved || save != tc.save { + t.Errorf("PreauthDecision(%v) = %t,%t, want approved=%t save=%t", fields, approved, save, tc.approved, tc.save) } if _, ok := fields[types.TotalAmount]; ok { - t.Error("BuildPreauthRedirectURL fabricated TOTAL_AMOUNT") + t.Error("PreauthDecision fabricated TOTAL_AMOUNT") } }) } diff --git a/internal/db/db.go b/internal/db/db.go index addb8db..8e0d298 100644 --- a/internal/db/db.go +++ b/internal/db/db.go @@ -84,7 +84,7 @@ func InsertPreauth(ctx context.Context, db *sql.DB, m map[string]string, checkou txnTime := time.Now().UTC() - // parse departure / checkout date and compute release date (48h after departure) + // Parse departure / checkout date and compute release date (96h after departure). checkOutDate, err := parseDateOnly(checkoutDate) if err != nil { return fmt.Errorf("InsertPreauth: parsing checkoutDate %q: %w", checkoutDate, err) @@ -198,4 +198,3 @@ WHERE TxnReference = @TxnReference AND Released = 0; log.Infof("Marked preauth %s released at %s", txnReference, releasedAt.Format(time.RFC3339)) return nil } - diff --git a/internal/dispenser/K720_DISPENSER_CONTRACT.md b/internal/dispenser/K720_DISPENSER_CONTRACT.md deleted file mode 100644 index ac1f60c..0000000 --- a/internal/dispenser/K720_DISPENSER_CONTRACT.md +++ /dev/null @@ -1,335 +0,0 @@ -# K720 dispenser issuance contract - -Hardlink treats the K720 as an unreliable mechanical peripheral with a strict transport -protocol and imperfect status telemetry. The implementation must keep transport -validation strict while making mechanical decisions from fresh, bounded observations. -Diagnostic bytes are useful evidence, but they must not override a valid physical -position or turn an uncertain observation into a fatal guest-facing error. - -This document records the dispenser invariants agreed for the clean implementation. -It is intended to be a design contract: future changes should preserve these rules -unless production evidence justifies changing them explicitly. - -## Ownership and concurrency - -- The dispenser worker is the single owner of serial commands and `deliveryPending`. - New code must not access the serial port directly from handlers or background - goroutines. -- Commands that can move a card are serialized through the worker. There must never - be concurrent AP/FC7/FC0/RS traffic from separate flows. -- `deliveryPending` is worker-owned state. It must not be duplicated or mutated by - HTTP handlers. -- A real `/issuedoorcard` operation always has priority over maintenance/prestage - work. -- Cancellation of a real caller must stop caller-owned work. Internal bounded - observation timeouts must remain distinguishable from caller cancellation. -- Do not create overlapping maintenance goroutines or timers per request. Any - background maintenance must have one clear owner and lifecycle. - -## Status and observation model - -AP transport parsing is strict. A response is usable only when its framing and -contents are valid, including ACK/address/header/length/ETX/BCC/type checks. - -Malformed, truncated, timed-out or otherwise invalid AP responses are unusable -observations. They are logged and discarded. They are never converted into a -fabricated physical state such as `0x30` or `0x38`. - -Every fresh valid AP observation reclassifies the current mechanical state. No -physical position is latched across later observations. - -The fourth AP status byte is the physical position used by the preparation logic: - -- Encoder confirmed: - `0x32, 0x33, 0x36, 0x37, 0x3A, 0x3B, 0x3E, 0x3F`. - A card may be handed to `LockSequence` immediately. -- Valid but uncertain: - `0x31, 0x34, 0x35, 0x39, 0x3C, 0x3D`. - Continue bounded fresh observation; if no stronger state appears, one encoding - opportunity may still be granted after the uncertainty window. -- No card on sensors: - exact `0x30`. - This may trigger the bounded mechanical recovery sequence. -- Card well empty: - exact `0x38`. - This is the only physical state that becomes `ErrCardWellEmpty`. - -The first three diagnostic bytes are advisory. Values such as `Preparing card fails`, -`Dispense card error`, `Card jammed`, or `Command cannot execute` may coexist with a -usable physical position. They may be logged, but they must not automatically block -encoding when the fourth byte confirms a usable card position. - -## Preparing the current card - -A `/issuedoorcard` request receives at most one `LockSequence` opportunity. - -Preparation uses bounded fresh observation: - -- Poll interval: 1 second. -- After a successful FC7, allow 3 seconds of observation before shake recovery is - eligible for a persistent exact `0x30`. -- For uncertain or unusable observations after a successful FC7, use one shared - 4-second uncertainty window. Switching between uncertain and unusable observations - does not restart that window. -- A later usable observation always takes precedence: - encoder confirmed -> handoff; - exact `0x38` -> empty; - exact `0x30` -> resume the remaining shake budget and reset uncertainty timing. -- Total preparation budget: 32 seconds. - -For persistent exact `0x30`, the request may perform at most three shake recoveries: - -`RS -> 2 second settle -> FC7` - -There is no additional plain FC7 retry. Including the initial dispatch, the maximum -per request is four FC7 commands and three RS commands. - -If all three shakes are exhausted while the latest usable physical state remains -exact `0x30`, preparation fails. If the internal preparation deadline is reached -while the latest state is uncertain or unusable after a successful FC7, the request -may hand off one encoding opportunity. Exact `0x38` remains empty. - -FC7 or RS dispatch failures are real transport/command failures. They are not -converted into status uncertainty and are not retried merely because their dispatch -failed. - -## Encoding and delivery - -`LockSequence` runs exactly once for a prepared card in a single `/issuedoorcard` -request. The dispenser layer does not implement a second encoding attempt on the same -physical card. - -After `LockSequence`, FC0 is dispatched exactly once to move the current card toward -the guest: - -- `LockSequence` success -> FC0 once -> successful issuance remains successful. -- `LockSequence` failure -> FC0 once -> return the original encoding error. -- FC0 errors are logged only. They do not replace the original encoding result and - they do not become `ErrCardWellEmpty`. - -A failed `LockSequence` does not start next-card prestaging. - -The design intentionally does not add retained-card state, per-card failure counters, -provider-specific encoder retries, special bad-card recovery, CP/capture recovery, or -multiple encoding attempts per physical card without production evidence requiring -them. - -## Delivery clearance - -After FC0, the worker marks the previous delivery as pending. A later FC7 must not be -sent until the previous delivery has been considered clear. - -Delivery clearance uses fresh AP observations and is owned by the worker. - -Current bounds: - -- Minimum clearance wait: 2 seconds. -- Clearance timeout: 6 seconds. -- Poll interval: 1 second. - -A valid physical position of `0x30` or `0x34` may clear `deliveryPending` after the -minimum wait unless the same fresh observation explicitly indicates active -preparing/dispensing/capturing movement. - -Exact `0x38` reports physical empty and does not silently clear the state. - -If the internal clearance timeout is reached while the caller context is still -valid, the worker may make the bounded assumption that delivery has cleared unless -the latest fresh usable observation establishes exact physical empty (`0x38`) or -explicit active movement. This fallback may therefore occur while the latest -physical position is `0x33`; `0x33` itself is not positive clearance evidence. -The fallback is an internal timeout policy, not a reclassification of the observed -position. - -If the latest fresh usable observation still explicitly indicates movement, that is -not treated as unknown. `deliveryPending` remains set and the clearance attempt -times out. - -Caller cancellation or deadline always takes precedence over the internal clearance -fallback. If the caller context expires, return the caller error and do not admit a -subsequent FC7 from that caller-owned operation. - -A later unusable observation supersedes older movement evidence; stale movement -information must not be latched indefinitely. - -## Next-card prestage and guest UX - -Preparing the next card is an optimization for the next guest, not part of the -business success of the current guest's issuance. - -After a successful `LockSequence` and FC0, Hardlink may make a short best-effort -attempt to prestage the next card: - -- wait for worker-owned delivery clearance; -- if clearance is obtained within the bounded prestage context, send exactly one FC7; -- do not run readiness polling, RS/shake recovery, or the full current-card - preparation flow; -- prestage failure is log-only and must not change the successful `/issuedoorcard` - result. - -Do not extend the current guest's screen by 15-20 seconds merely to guarantee that -the next card reaches the encoder. The guest-facing flow must remain bounded even -when the dispenser is slow to become ready for prestage. - -If the short prestage window expires, skip that prestage attempt. A later request or -maintenance cycle may prepare the next card. - -## HTTP contract - -Physical empty and operational failure are deliberately different outcomes. - -- HTTP 503 is reserved for `ErrCardWellEmpty`, derived only from an exact valid - physical `0x38`. -- All other dispenser preparation, transport, command and encoding failures return - HTTP 502. -- Normal request/protocol validation keeps its existing 400/405/415 behavior. -- Diagnostic text such as `Preparing card fails` must never by itself produce 503. - -Operafyne treats: - -- 502 as retryable while attempts remain; -- 503 as terminal `dispenser_failed`; -- a maximum of three total issue attempts: the initial attempt plus up to two user - retries. - -The dispenser layer must preserve this distinction. - -## Passive status and alerts - -Ordinary status queries remain strict and passive. They must not reuse tolerant -issuance semantics to fabricate a status or hide malformed transport. - -Passive polling captures the current foreground activity generation when the poll is -queued. The worker skips a passive poll if foreground activity is active when it is -dispatched or if the captured generation has become obsolete. Passive polling does -not reset the idle-maintenance clock. - -Status/diagnostic observations may be useful for logs and support alerts, but alerts -must not alter physical state classification or issuance success. - -Idle maintenance observations are intentionally quiet: they do not invoke the normal -stock-update callback or generate repeated support email such as `Preparing card -fails`. Maintenance failures are local diagnostic events only. - -## Idle prestage maintenance - -Idle prestaging recovers from a short post-FC0 prestage timeout without keeping the -current guest waiting. - -The implementation uses the existing dispenser worker as the single maintenance -owner: - -- one resettable maintenance timer is owned by the serial-worker loop; there is no - maintenance goroutine and no timer created per request; -- `/issuedoorcard` and `/testissuedoorcard` register foreground activity before - using the dispenser/encoder and release it when the handler finishes; -- foreground activity is reference-counted so overlapping requests suppress - maintenance until the last active request finishes; -- each foreground registration increments an activity generation and invalidates the - previous idle deadline; -- when the last foreground request finishes, the next maintenance attempt is - scheduled one minute later; -- enabling maintenance at startup schedules the first check one minute later when - no foreground request is active; -- a stale timer or stale generation cannot perform maintenance; -- after a maintenance attempt, the next check is scheduled one minute from completion - only if the same generation is still authoritative. A later foreground completion - therefore cannot have its newer deadline overwritten by an older maintenance - attempt. - -Foreground registration and maintenance transaction admission use the same activity -guard. The guard is used only for admission/state bookkeeping and is never held -across serial I/O, queue waits, sleeps, callbacks, or `LockSequence`. - -A maintenance attempt is deliberately weaker than foreground preparation: - -1. create a bounded 5-second maintenance context; -2. recheck maintenance admission before AP; -3. obtain one fresh AP using the existing strict transport parser; -4. classify the fresh status using the common physical classifier; -5. do nothing for encoder-present, exact `0x38`, unusable, explicit-movement, or - otherwise ineligible observations; -6. when `deliveryPending` is set, require fresh qualifying clearance evidence and the - existing minimum clearance wait before clearing it; -7. never use the foreground six-second assumed-clearance fallback; -8. recheck foreground count, activity generation, maintenance enabled state, and - maintenance context immediately before FC7 admission; -9. dispatch at most one FC7 and return immediately. - -If foreground activity begins while an already-admitted maintenance AP is in -progress, that AP may finish, but the second admission check prevents maintenance -from sending FC7 afterward. An FC7 that was already admitted and dispatched before -foreground registration cannot be recalled. - -Maintenance never performs: - -- RS or shake recovery; -- `LockSequence`; -- `PrepareCurrentCard`; -- `PrepareNextCard` or `BeginPrepareNextCard`; -- readiness polling after FC7; -- the 32-second foreground preparation flow; -- repeated FC7 attempts; -- the foreground assumed-clearance fallback. - -The 5-second maintenance context bounds new admissions and context-aware waits. An -already-admitted serial read may still finish according to the existing serial read -timeout, but no subsequent maintenance transaction is admitted after cancellation or -expiry. - -`StartMaintenance` and `StopMaintenance` are idempotent lifecycle operations. -`Client.Close` disables maintenance and stops the timer. -Stopping maintenance cancels the current maintenance context and waits only for an -already-admitted maintenance transaction to finish under the existing bounded serial -behavior. - -## Automated verification - -Tests should preserve the behavioural contract rather than only exercise individual -functions. - -At minimum, cover: - -- strict AP framing and malformed/truncated/timeout responses; -- tolerant issuance observations never fabricating `0x30` or `0x38`; -- every physical position class and transitions between classes; -- exact `0x38` as the only `ErrCardWellEmpty` path; -- persistent `0x30` using at most three `RS -> settle -> FC7` recoveries; -- no extra FC7 after the shake budget; -- uncertain/unusable shared timing and later usable-state precedence; -- caller cancellation versus internal preparation timeout; -- exactly one `LockSequence` opportunity per request; -- FC0 exactly once after encoding success or failure; -- FC0 failure remaining log-only; -- failed encoding never starting prestage; -- worker-owned `deliveryPending` and guarded FC7 dispatch; -- bounded delivery-clearance fallback and explicit-movement timeout; -- successful issuance remaining successful when next-card prestage fails; -- HTTP 503 only for exact physical empty and 502 for other issuance failures; -- Operafyne retry semantics remaining three total attempts. - -Idle maintenance verification additionally covers: - -- first attempt occurs one minute after the latest issuance finishes; -- a new issuance resets that idle interval; -- overlapping foreground requests suppress maintenance until the last request - finishes; -- both `/issuedoorcard` and `/testissuedoorcard` participate in foreground activity - registration; -- stale timer events and stale activity generations cannot perform maintenance; -- foreground registration before maintenance AP prevents AP admission; -- foreground registration during an admitted AP prevents the later FC7; -- passive polls are skipped while foreground activity is active or when their - captured generation is stale; -- maintenance performs one AP and at most one FC7, with no RS/shake/encoding; -- encoder-present, exact-empty, movement and unusable observations are no-ops; -- pending delivery requires fresh normal clearance plus the minimum wait and never - uses the foreground assumed-clearance fallback; -- maintenance errors do not produce guest-facing failures, stock callbacks or - repeated alert email; -- repeated maintenance start/stop calls are safe and do not accumulate work; -- cancellation, `StopMaintenance` and `Client.Close` prevent subsequent maintenance - commands after shutdown admission is revoked. - -For Hardlink verification, continue excluding the existing test that sends real -email when running the full suite. diff --git a/internal/dispenser/maintenance_test.go b/internal/dispenser/maintenance_test.go index 0dd9155..dfb3393 100644 --- a/internal/dispenser/maintenance_test.go +++ b/internal/dispenser/maintenance_test.go @@ -303,12 +303,17 @@ func TestForegroundEncoderClearanceCallerDeadline(t *testing.T) { c.deliveryStarted = *now start := *now samples := 0 + remainingChunks := len(p.chunks) p.afterRead = func() { - if len(p.chunks)%2 == 0 { // Only complete frame reads advance the observation clock. - if len(p.chunks) == 4 || len(p.chunks) == 2 || len(p.chunks) == 0 { - samples++ - *now = now.Add(time.Second) - } + // ACK and frame headers can take several reads without consuming a chunk. + // Advance once per completed AP frame, not during a partial ACK read. + if len(p.chunks) == remainingChunks { + return + } + remainingChunks = len(p.chunks) + if remainingChunks%2 == 0 { + samples++ + *now = now.Add(time.Second) } } ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second) @@ -326,7 +331,10 @@ func TestForegroundEncoderClearanceCallerDeadline(t *testing.T) { t.Errorf("caller deadline err=%v pending=%t", r.err, c.deliveryPending) } if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "AP", "AP"}) { - t.Errorf("caller deadline commands=%v want AP only", got) + t.Errorf("caller deadline commands=%v, want three AP observations and no movement", got) + } + if samples != 3 { + t.Errorf("caller deadline completed AP frames=%d, want 3", samples) } if elapsed := now.Sub(start); elapsed != 5*time.Second { t.Errorf("last observation elapsed=%v want 5s", elapsed) diff --git a/internal/dojo/client.go b/internal/dojo/client.go index 81785a3..5e4c44e 100644 --- a/internal/dojo/client.go +++ b/internal/dojo/client.go @@ -13,13 +13,16 @@ import ( "strings" "time" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall" "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" "gitea.futuresens.co.uk/futuresens/hardlink/internal/types" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus" log "github.com/sirupsen/logrus" ) type Config struct { + PrintReceipt func(string) BaseURL string APIKey string SoftwareHouseID string @@ -28,6 +31,7 @@ type Config struct { } type Client struct { + printReceipt func(string) baseURL string apiKey string version string @@ -91,6 +95,7 @@ func NewClient(cfg Config) (*Client, error) { } return &Client{ + printReceipt: cfg.PrintReceipt, baseURL: strings.TrimRight(cfg.BaseURL, "/"), apiKey: cfg.APIKey, version: cfg.Version, @@ -104,7 +109,49 @@ func (c *Client) Sale( ctx context.Context, req paymentsvc.SaleRequest, onStatus paymentsvc.StatusHandler, -) (*paymentsvc.Result, error) { +) (returned *paymentsvc.Result, resultErr error) { + stage := "create_payment_intent" + var intentID, sessionID, transactionID string + observeSession := func(session *terminalSessionResponse) { + if session != nil { + if session.ID != "" { + sessionID = session.ID + } + if session.PaymentDetails != nil && session.PaymentDetails.TransactionID != "" { + transactionID = session.PaymentDetails.TransactionID + } + } + } + defer func() { + if returned != nil { + returned.Terminal = dojoTerminalResult(returned) + if c.printReceipt != nil { + c.printReceipt(returned.CustomerReceipt) + } + } + if resultErr != nil || (returned != nil && returned.Terminal.Outcome == "unknown") { + fields := log.Fields{ + "provider": "dojo", "operation": "sale", "stage": stage, + "request_id": req.RequestID, "transaction_reference": req.RequestID, + "error_category": paymentsvc.SafeErrorCategory(resultErr), + } + if intentID != "" { + fields["payment_intent_id"] = intentID + } + if sessionID != "" { + fields["terminal_session_id"] = sessionID + } + if transactionID != "" { + fields["provider_transaction_id"] = transactionID + } + var responseError *httpResponseError + if errors.As(resultErr, &responseError) { + fields["http_status"] = responseError.StatusCode + fields["error_category"] = "http_error" + } + log.WithFields(fields).Warn("Dojo payment requires reconciliation") + } + }() if req.Currency == "" { req.Currency = "GBP" } @@ -115,7 +162,12 @@ func (c *Client) Sale( if err != nil { return nil, err } + intentID = intent.ID + if intent.PaymentDetails != nil { + transactionID = intent.PaymentDetails.TransactionID + } + stage = "create_terminal_session" session, err := c.createTerminalSession(ctx, intent.ID) if err != nil { var responseErr *httpResponseError @@ -125,6 +177,8 @@ func (c *Client) Sale( "operation": "createTerminalSession", "status": responseErr.StatusCode, "terminal_unavailable": true, + "request_id": req.RequestID, "transaction_reference": req.RequestID, + "payment_intent_id": intentID, }).Warn(dojoTerminalUnavailableMessage) sendPaymentStatus(onStatus, paymentstatus.TerminalUnavailable) @@ -135,18 +189,24 @@ func (c *Client) Sale( } return nil, err } + observeSession(session) - session, err = c.waitForTerminalSession(ctx, session.ID, onStatus) + stage = "read_terminal_session" + session, err = c.waitForTerminalSession(ctx, session.ID, onStatus, observeSession) if err != nil { return nil, err } switch strings.ToLower(session.Status) { case types.ResultCaptured, types.ResultSignatureAccepted: + stage = "read_payment_intent" intent, err = c.getPaymentIntent(ctx, intent.ID) if err != nil { return nil, err } + if intent.PaymentDetails != nil && intent.PaymentDetails.TransactionID != "" { + transactionID = intent.PaymentDetails.TransactionID + } 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) } @@ -215,6 +275,7 @@ func (c *Client) waitForTerminalSession( ctx context.Context, terminalSessionID string, onStatus paymentsvc.StatusHandler, + observeSession func(*terminalSessionResponse), ) (*terminalSessionResponse, error) { ticker := time.NewTicker(time.Second) defer ticker.Stop() @@ -230,7 +291,9 @@ func (c *Client) waitForTerminalSession( return nil, err } - log.Println("session status:", session.Status) + observeSession(&session.terminalSessionResponse) + log.WithFields(log.Fields{"provider": "dojo", "terminal_session_id": terminalSessionID, + "status": mapDojoSessionStatus(session.Status)}).Info("Dojo terminal session observed") emitNewTerminalSessionEvents( session, @@ -273,6 +336,7 @@ func (c *Client) waitForTerminalSession( signatureRejected = true if rejectedSession != nil { + observeSession(rejectedSession) rejectedStatus := strings.ToLower( rejectedSession.Status, ) @@ -672,3 +736,29 @@ func normalizeReceiptText(value string) string { return replacer.Replace(value) } + +func (*Client) ValidatePreauth(paymentsvc.SaleRequest) error { return paymentsvc.ErrPreauthUnsupported } +func (*Client) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return nil, paymentsvc.ErrPreauthUnsupported +} + +func dojoTerminalResult(r *paymentsvc.Result) paymentapi.Result { + final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "dojo", AmountMinor: r.Amount, CurrencyCode: r.Currency, TransactionReference: r.RequestID, CardType: r.CardType, MaskedCardNumber: creditcall.MaskedCardNumber(r.CardNumber), ExpiryDate: r.ExpiryDate, CardHash: r.CardHash, CardReference: r.CardReference, AuthorizationCode: r.AuthCode, LastFour: r.LastFourDigits, Message: "Payment outcome uncertain; contact reception"} + if r.Success && strings.EqualFold(r.Status, "APPROVED") { + final.Outcome, final.Message = "approved", "Payment approved" + return final + } + switch strings.ToUpper(r.Status) { + case "DECLINED": + final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined" + case "CANCELLED", "CANCELED": + final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled" + case "SIGNATUREVERIFICATIONREJECTED", "SIGNATURE_VERIFICATION_REJECTED": + final.Outcome, final.Reason, final.Message = "declined", "signature_verification", "Signature verification declined" + final.Retryable = true + case dojoTerminalUnavailableStatus: + final.Outcome, final.Reason, final.Message = "error", "terminal_unavailable", dojoTerminalUnavailableMessage + final.Retryable = true + } + return final +} diff --git a/internal/dojo/client_test.go b/internal/dojo/client_test.go index b21ca2f..da735d4 100644 --- a/internal/dojo/client_test.go +++ b/internal/dojo/client_test.go @@ -86,6 +86,9 @@ func TestSaleMapsCreateTerminalSessionConflictToTerminalUnavailable(t *testing.T if result.Status != dojoTerminalUnavailableStatus || result.ErrorMessage != dojoTerminalUnavailableMessage { t.Fatalf("terminal-unavailable result = %+v", result) } + if !result.Terminal.Retryable || result.Terminal.Reason != "terminal_unavailable" || result.Terminal.Outcome != "error" { + t.Errorf("Sale(session conflict) terminal=%+v, want safely retryable pre-dispatch unavailability", result.Terminal) + } if result.RequestID != request.RequestID || result.Operation != "SALE" || result.Amount != request.Amount || diff --git a/internal/dojo/diagnostics_test.go b/internal/dojo/diagnostics_test.go new file mode 100644 index 0000000..369c915 --- /dev/null +++ b/internal/dojo/diagnostics_test.go @@ -0,0 +1,165 @@ +package dojo + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "strings" + "testing" + + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + log "github.com/sirupsen/logrus" + logtest "github.com/sirupsen/logrus/hooks/test" +) + +type diagnosticTransport func(*http.Request) (*http.Response, error) + +func (f diagnosticTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +func dojoDiagnosticLog(t *testing.T) *logtest.Hook { + t.Helper() + logger := log.StandardLogger() + oldOutput := logger.Out + oldHooks := logger.ReplaceHooks(make(log.LevelHooks)) + hook := logtest.NewGlobal() + log.SetOutput(io.Discard) + t.Cleanup(func() { log.SetOutput(oldOutput); logger.ReplaceHooks(oldHooks) }) + return hook +} + +func TestDojoFailureDiagnosticsKeepIdentityWithoutRawErrors(t *testing.T) { + for _, failure := range []string{"transport", "lost", "malformed", "http", "expired"} { + t.Run(failure, func(t *testing.T) { + hook := dojoDiagnosticLog(t) + financialPosts := 0 + client, err := NewClient(Config{BaseURL: "https://synthetic.invalid", APIKey: "SYNTH-CREDENTIAL", SoftwareHouseID: "SYNTH-HOUSE", TerminalID: "SYNTH-PED"}) + if err != nil { + t.Fatal(err) + } + client.httpClient = &http.Client{Transport: diagnosticTransport(func(r *http.Request) (*http.Response, error) { + body := "" + switch { + case r.Method == http.MethodPost && r.URL.Path == "/payment-intents": + financialPosts++ + if failure == "transport" { + return nil, errors.New("SYNTH-RAW-SECRET https://user:password@private.invalid") + } + body = `{"id":"SYNTH-INTENT"}` + case r.Method == http.MethodPost && r.URL.Path == "/terminal-sessions": + body = `{"id":"SYNTH-SESSION","paymentDetails":{"transactionId":"SYNTH-PROVIDER-TXN"}}` + case r.Method == http.MethodGet && r.URL.Path == "/terminal-sessions/SYNTH-SESSION": + switch failure { + case "lost": + return nil, io.ErrUnexpectedEOF + case "malformed": + body = `{"SYNTH-RAW-SECRET":nope}` + case "http": + return &http.Response{StatusCode: 502, Header: make(http.Header), Body: io.NopCloser(strings.NewReader("SYNTH-RAW-SECRET card 4111111111111111"))}, nil + case "expired": + body = `{"id":"SYNTH-SESSION","status":"Expired","paymentDetails":{"transactionId":"SYNTH-PROVIDER-TXN"}}` + default: + t.Errorf("unexpected poll for %s", failure) + } + default: + t.Errorf("Dojo Sale requested unexpected %s %s", r.Method, r.URL.Path) + } + return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))}, nil + })} + request := paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Reference: "SYNTH-BOOK", Amount: 2500, Currency: "GBP"} + result, err := client.Sale(context.Background(), request, nil) + if failure == "expired" { + if err != nil || result == nil || result.Terminal.Outcome != "unknown" || result.Terminal.Retryable { + t.Fatalf("Sale(expired)=%+v/%v, want unchanged nonretryable unknown", result, err) + } + } else if err == nil || result != nil { + t.Fatalf("Sale(%s)=%+v/%v, want original nil-result error", failure, result, err) + } + if failure == "http" && !strings.Contains(err.Error(), "SYNTH-RAW-SECRET") { + t.Error("Sale(http) changed the existing returned error") + } + if financialPosts != 1 { + t.Errorf("Sale(%s) financial posts=%d, want one", failure, financialPosts) + } + var diagnostic *log.Entry + for _, entry := range hook.AllEntries() { + data, _ := json.Marshal(entry.Data) + for _, secret := range []string{"SYNTH-CREDENTIAL", "SYNTH-RAW-SECRET", "4111111111111111", "user:password"} { + if strings.Contains(string(data)+entry.Message, secret) { + t.Errorf("Sale(%s) logged sensitive marker %q", failure, secret) + } + } + if entry.Message == "Dojo payment requires reconciliation" { + diagnostic = entry + } + } + if diagnostic == nil { + t.Fatal("Sale failure emitted no reconciliation diagnostic") + } + for key, want := range map[string]any{"provider": "dojo", "request_id": "SYNTH-REQUEST", "transaction_reference": "SYNTH-REQUEST"} { + if diagnostic.Data[key] != want { + t.Errorf("Sale(%s) diagnostic[%s]=%v, want %v", failure, key, diagnostic.Data[key], want) + } + } + wantStage, wantCategory := "read_terminal_session", "unresolved_result" + switch failure { + case "transport": + wantStage, wantCategory = "create_payment_intent", "connection_failure" + case "lost": + wantCategory = "response_lost" + case "malformed": + wantCategory = "invalid_response" + case "http": + wantCategory = "http_error" + } + if diagnostic.Data["stage"] != wantStage || diagnostic.Data["error_category"] != wantCategory { + t.Errorf("Sale(%s) diagnostic=%v, want stage=%s category=%s", failure, diagnostic.Data, wantStage, wantCategory) + } + if failure != "transport" { + for key, want := range map[string]string{"payment_intent_id": "SYNTH-INTENT", "terminal_session_id": "SYNTH-SESSION", "provider_transaction_id": "SYNTH-PROVIDER-TXN"} { + if diagnostic.Data[key] != want { + t.Errorf("Sale(%s) diagnostic[%s]=%v, want %s", failure, key, diagnostic.Data[key], want) + } + } + } + if failure == "http" && diagnostic.Data["http_status"] != 502 { + t.Errorf("Sale(http) status=%v, want 502", diagnostic.Data["http_status"]) + } + }) + } +} + +func TestDojoPollFailureRetainsLastObservedTransactionIdentity(t *testing.T) { + hook := dojoDiagnosticLog(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + client, err := NewClient(Config{BaseURL: "https://synthetic.invalid", APIKey: "SYNTH", SoftwareHouseID: "SYNTH", TerminalID: "SYNTH"}) + if err != nil { + t.Fatal(err) + } + client.httpClient = &http.Client{Transport: diagnosticTransport(func(r *http.Request) (*http.Response, error) { + body := `{"id":"SYNTH-INTENT"}` + if strings.HasPrefix(r.URL.Path, "/terminal-sessions") { + body = `{"id":"SYNTH-SESSION"}` + } + if r.Method == "GET" { + body = `{"id":"SYNTH-SESSION","status":"Initiated","paymentDetails":{"transactionId":"SYNTH-POLL-TXN"}}` + cancel() + } + return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))}, nil + })} + result, err := client.Sale(ctx, paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Amount: 2500}, nil) + if result != nil || !errors.Is(err, context.Canceled) { + t.Fatalf("Sale(cancel after poll)=%+v/%v, want unchanged cancellation", result, err) + } + for _, entry := range hook.AllEntries() { + if entry.Message == "Dojo payment requires reconciliation" { + if entry.Data["provider_transaction_id"] != "SYNTH-POLL-TXN" || entry.Data["error_category"] != "cancelled" { + t.Errorf("Sale(cancel after poll) diagnostic=%v, want last observed transaction and cancellation", entry.Data) + } + return + } + } + t.Fatalf("Sale(cancel after poll) emitted no diagnostic; entries=%d", len(hook.AllEntries())) +} diff --git a/internal/dojo/processor_test.go b/internal/dojo/processor_test.go new file mode 100644 index 0000000..b867f50 --- /dev/null +++ b/internal/dojo/processor_test.go @@ -0,0 +1,31 @@ +package dojo + +import ( + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "testing" +) + +func TestTerminalResultKeepsExistingIdentityAndOnlyRealMetadata(t *testing.T) { + raw := &paymentsvc.Result{Success: true, Status: "APPROVED", RequestID: "SYNTH-REQUEST", TransactionID: "SYNTH-PROVIDER-ID", Amount: 1234, Currency: "EUR", CardNumber: "************1133", CardType: "Visa", ExpiryDate: "1228", AuthCode: "SYNTH-AUTH"} + result := dojoTerminalResult(raw) + if result.Outcome != "approved" || result.TransactionReference != "SYNTH-REQUEST" || result.MaskedCardNumber != raw.CardNumber || result.ExpiryDate != "1228" || result.CardHash != "" || result.CardReference != "" { + t.Errorf("dojoTerminalResult(%+v)=%+v, want current request identity and only supplied card data", raw, result) + } + raw.CardNumber = "4111111111111111" + if got := dojoTerminalResult(raw).MaskedCardNumber; got != "" { + t.Errorf("dojoTerminalResult(unmasked PAN) masked=%q, want omitted", got) + } +} +func TestExpiredTerminalResultIsUncertain(t *testing.T) { + result := dojoTerminalResult(&paymentsvc.Result{Status: "EXPIRED"}) + if result.Outcome != "unknown" || result.Retryable { + t.Errorf("dojoTerminalResult(EXPIRED)=%+v, want nonretryable unknown", result) + } +} + +func TestConfirmedSignatureRejectionRemainsRetryable(t *testing.T) { + result := dojoTerminalResult(&paymentsvc.Result{Status: "SIGNATUREVERIFICATIONREJECTED"}) + if result.Outcome != "declined" || result.Reason != "signature_verification" || !result.Retryable { + t.Errorf("dojoTerminalResult(signature rejected)=%+v, want safely retryable confirmed rejection", result) + } +} diff --git a/internal/handlers/build_command_test.go b/internal/handlers/build_command_test.go new file mode 100644 index 0000000..d39cab5 --- /dev/null +++ b/internal/handlers/build_command_test.go @@ -0,0 +1,43 @@ +package handlers + +import ( + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "testing" + + "gitea.futuresens.co.uk/futuresens/cmstypes" + "gitea.futuresens.co.uk/futuresens/hardlink/config" +) + +func TestCardRoutesNeverExecuteStoredCommandAfterBuildFailure(t *testing.T) { + for _, path := range []string{"/issuedoorcard", "/testissuedoorcard"} { + t.Run(path, func(t *testing.T) { + d := &fakeDoorCardDispenser{} + lock := &fakeDoorCardLockServer{buildErr: errors.New("synthetic invalid lock command"), storedCommand: "PREVIOUS-ROOM"} + app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + r := httptest.NewRequest(http.MethodPost, path, strings.NewReader(`{"roomField":"CURRENT-ROOM","checkinTime":"2026-11-04 15:00:00 +0000","checkoutTime":"2026-11-05 11:00:00 +0000","followStr":"0"}`)) + r.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + var response cmstypes.StatusRec + if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil { + t.Fatal(err) + } + if w.Code != http.StatusBadGateway || response.Code != http.StatusBadGateway || !strings.Contains(response.Message, "Build key command failed") { + t.Errorf("POST %s = %d %+v, want existing 502 JSON error", path, w.Code, response) + } + if lock.buildCalls != 1 || lock.sequenceCalls != 0 || lock.storedCommand != "PREVIOUS-ROOM" { + t.Errorf("POST %s build=%d sequence=%d stored=%q, want one rejected build and no execution of previous command", path, lock.buildCalls, lock.sequenceCalls, lock.storedCommand) + } + if !reflect.DeepEqual(d.calls, []string{"prepare current"}) || d.activity != 0 || d.outsideActivity { + t.Errorf("POST %s dispenser=%v active=%d outside=%t, want preparation only and released foreground", path, d.calls, d.activity, d.outsideActivity) + } + }) + } +} diff --git a/internal/handlers/creditcall_amount_test.go b/internal/handlers/creditcall_amount_test.go new file mode 100644 index 0000000..2de9ffc --- /dev/null +++ b/internal/handlers/creditcall_amount_test.go @@ -0,0 +1,56 @@ +package handlers + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "gitea.futuresens.co.uk/futuresens/hardlink/internal/types" +) + +func TestCreditCallModernPreauthReportsActualReturnedAmount(t *testing.T) { + for _, total := range []string{"3100", "12000"} { + t.Run(total, func(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.TotalAmount: total, types.Reference: "SYNTH-HOLD"}}) + }) + database := preauthTestDatabase(t, app) + app.creditCallReceipt = func(string) {} + recorder := httptest.NewRecorder() + app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000")) + frames := decodePaymentStream(t, recorder.Body) + want := int64(12000) + if total == "3100" { + want = 3100 + } + if len(frames) != 1 || frames[0].Result == nil || frames[0].Result.Outcome != "approved" || frames[0].Result.AmountMinor != want { + t.Errorf("Preauth(request12000,total%s) frames=%+v, want approved actual%d", total, frames, want) + } + if got := waitPreauthInsert(t, database)["TotalMinorUnits"]; got != total { + t.Errorf("Preauth(total%s) SQLamount=%v, want unchanged provider amount", total, got) + } + }) + } +} + +func TestCreditCallModernPreauthMalformedAmountRequiresReception(t *testing.T) { + for _, total := range []string{"bad", "-1", "9223372036854775808"} { + t.Run(total, func(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: "ACCOUNT VERIFICATION", types.TotalAmount: total, types.Reference: "SYNTH-HOLD"}}) + }) + app.creditCallReceipt = func(string) {} + recorder := httptest.NewRecorder() + app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000")) + frames := decodePaymentStream(t, recorder.Body) + if len(frames) != 1 || frames[0].Result == nil { + t.Fatalf("Preauth(total%s) frames=%+v, want final uncertainty", total, frames) + } + final := frames[0].Result + if final.Outcome != "unknown" || final.Retryable || final.AmountMinor != 0 || final.Reason != "amount_unverified" { + t.Errorf("Preauth(total%s) final=%+v, want nonretryable unknown without fabricated amount", total, final) + } + }) + } +} diff --git a/internal/handlers/creditcall_preauth.go b/internal/handlers/creditcall_preauth.go index b67aedc..f87f85d 100644 --- a/internal/handlers/creditcall_preauth.go +++ b/internal/handlers/creditcall_preauth.go @@ -11,14 +11,8 @@ import ( log "github.com/sirupsen/logrus" ) -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) +func (app *App) preauthPayment(w http.ResponseWriter, r *http.Request) { + app.streamPayment(w, r, true) } // executeCreditCallPreauth finalizes the existing unconfirmed transaction. diff --git a/internal/handlers/creditcall_preauth_test.go b/internal/handlers/creditcall_preauth_test.go index 09f5af6..2148dc3 100644 --- a/internal/handlers/creditcall_preauth_test.go +++ b/internal/handlers/creditcall_preauth_test.go @@ -7,11 +7,13 @@ import ( "encoding/json" "encoding/xml" "errors" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" "io" "net/http" "net/http/httptest" "os" "reflect" + "strconv" "strings" "sync/atomic" "testing" @@ -143,8 +145,8 @@ func TestCreditCallPreauthLegacyCharacterization(t *testing.T) { 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) + if got["DepartureDate"] != departure || got["ReleaseDate"] != departure.Add(96*time.Hour) { + t.Errorf("persisted dates=%v, want existing local midnight plus 96 hours", got) } } else if c.count.Load() != 0 { t.Error("non-persisting result inserted SQL") @@ -154,7 +156,8 @@ func TestCreditCallPreauthLegacyCharacterization(t *testing.T) { } func preauthStreamRequest(amount, kind, checkout string) *http.Request { - body, _ := json.Marshal(creditCallPreauthRequest{Amount: amount, TransactionType: kind, CheckoutDate: checkout}) + value, _ := strconv.ParseInt(amount, 10, 64) + body, _ := json.Marshal(paymentapi.Request{Amount: value, CheckoutDate: checkout}) r := httptest.NewRequest(http.MethodPost, "/api/payment/preauth", strings.NewReader(string(body))) r.Header.Set("Content-Type", "application/json") return r @@ -214,7 +217,7 @@ func TestCreditCallPreauthStreamingParity(t *testing.T) { } recorder := httptest.NewRecorder() if stream { - app.streamCreditCallPreauth(recorder, preauthStreamRequest(amount, kind, date)) + app.preauthPayment(recorder, preauthStreamRequest(amount, kind, date)) frames := decodePaymentStream(t, recorder.Body) var statuses []string for _, frame := range frames { @@ -230,7 +233,7 @@ func TestCreditCallPreauthStreamingParity(t *testing.T) { if final == nil { t.Fatal("missing structured final") } - if (final.Outcome == "approved") != tc.approved || final.Status != legacy.Status || final.HTTPStatus != 200 { + if (final.Outcome == "approved") != tc.approved || 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") { @@ -296,9 +299,9 @@ func TestCreditCallInboundCancellationAfterDispatch(t *testing.T) { go func() { defer close(done) if preauth { - app.streamCreditCallPreauth(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx)) + app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx)) } else { - app.streamCreditCallSale(recorder, saleRequest(true).WithContext(ctx)) + app.salePayment(recorder, saleRequest(true).WithContext(ctx)) } }() select { @@ -342,9 +345,9 @@ func TestCreditCallPreauthMissingAmountNeverSynthesized(t *testing.T) { c := preauthTestDatabase(t, app) app.creditCallReceipt = func(string) {} recorder := httptest.NewRecorder() - app.streamCreditCallPreauth(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000")) + app.preauthPayment(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000")) frames := decodePaymentStream(t, recorder.Body) - if frames[0].Result.Outcome != "approved" { + if frames[0].Result.Outcome != "approved" || frames[0].Result.AmountMinor != 9999 { t.Fatalf("missing amount changed approval: %+v", frames[0].Result) } deadline := time.Now().Add(3 * time.Second) @@ -378,16 +381,22 @@ func TestCreditCallPreauthStreamFailureAndCancelledBeforeDispatch(t *testing.T) 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", "")) + app.preauthPayment(recorder, preauthStreamRequest("", "AccountVerification", "")) frames := decodePaymentStream(t, recorder.Body) - if calls != 1 || len(frames) != 1 || frames[0].Result.Outcome != "error" || frames[0].Result.HTTPStatus != 502 { + if calls != 1 || len(frames) != 1 || frames[0].Result.Outcome != "unknown" || 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)) + app.preauthPayment(httptest.NewRecorder(), preauthStreamRequest("", "AccountVerification", "").WithContext(ctx)) if calls != 1 { t.Error("already-cancelled request dispatched a transaction") } } } + +type creditCallPreauthRequest struct { + Amount string `json:"amount"` + TransactionType string `json:"transactionType"` + CheckoutDate string `json:"checkoutDate"` +} diff --git a/internal/handlers/creditcall_processor.go b/internal/handlers/creditcall_processor.go new file mode 100644 index 0000000..70802cb --- /dev/null +++ b/internal/handlers/creditcall_processor.go @@ -0,0 +1,91 @@ +package handlers + +import ( + "context" + "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/paymentsvc" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/types" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" +) + +// creditCallProcessor delegates to the unchanged legacy execution/finalization core. +type creditCallProcessor struct{ app *App } + +func (*creditCallProcessor) ValidatePreauth(req paymentsvc.SaleRequest) error { + if req.Amount < 0 { + return paymentsvc.ErrPreauthUnsupported + } + return nil +} +func (p *creditCallProcessor) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return p.run(ctx, req, status, false) +} +func (p *creditCallProcessor) Preauth(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return p.run(ctx, req, status, true) +} +func (p *creditCallProcessor) run(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler, preauth bool) (*paymentsvc.Result, error) { + transaction := cmstypes.TransactionRec{AmountMinorUnits: strconv.FormatInt(req.Amount, 10), TransactionType: "Sale", CheckoutDate: req.CheckoutDate} + if preauth && req.Amount == 0 { + transaction.AmountMinorUnits = "" + transaction.TransactionType = "AccountVerification" + } + start := func(client *http.Client) (creditcall.TransactionResultXML, error) { + return callChipDNATransactionStream(context.WithoutCancel(ctx), client, transaction, func(code string) { + if status != nil { + status(paymentsvc.StatusUpdate{Code: code}) + } + }) + } + var outcome creditCallSaleOutcome + if preauth { + // The existing asynchronous PREAUTH persistence must outlive response delivery. + outcome = p.app.executeCreditCallPreauth(context.WithoutCancel(ctx), transaction, start) + } else { + outcome = p.app.executeCreditCallSale(transaction, start) + } + final := outcome.streamResult() + final.AmountMinor, final.CurrencyCode = req.Amount, req.Currency + if outcome.Approved { + if raw := outcome.Payment.Fields[types.TotalAmount]; raw != "" { + amount, err := strconv.ParseInt(raw, 10, 64) + if err != nil || amount < 0 { + final.Outcome, final.Retryable = "unknown", false + final.AmountMinor = 0 + final.Reason = "amount_unverified" + final.Message = "Payment amount uncertain; contact reception" + } else { + final.AmountMinor = amount + } + } + } + return &paymentsvc.Result{Terminal: final}, nil +} + +func (outcome creditCallSaleOutcome) streamResult() paymentapi.Result { + final := paymentapi.Result{Outcome: "unknown", HTTPStatus: outcome.HTTPStatus, Provider: "creditcall", Message: "Payment outcome uncertain; contact reception"} + if final.HTTPStatus == 0 { + final.HTTPStatus = http.StatusOK + } + if outcome.Approved { + fields := outcome.Payment.Fields + final.Outcome, final.Message = "approved", "Payment approved" + final.TransactionReference = fields[types.Reference] + final.CardType = fields[types.CardType] + final.MaskedCardNumber = creditcall.MaskedCardNumber(fields[types.PanMasked]) + final.ExpiryDate = fields[types.ExpiryDate] + final.CardHash, final.CardReference = fields[types.CardHash], fields[types.CardReference] + } else { + switch strings.ToLower(outcome.FailureType) { + case "declined": + final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined" + case "cancelled", "canceled": + final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled" + } + } + return final +} diff --git a/internal/handlers/creditcall_sale_test.go b/internal/handlers/creditcall_sale_test.go index c792e74..01afbec 100644 --- a/internal/handlers/creditcall_sale_test.go +++ b/internal/handlers/creditcall_sale_test.go @@ -75,7 +75,7 @@ func TestCreditCallStreamFailureNeverRestartsOrConfirms(t *testing.T) { 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 { + if calls != 1 || len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "unknown" || frames[1].Result.HTTPStatus != 502 { t.Errorf("malformed stream calls=%d frames=%+v", calls, frames) } } @@ -185,13 +185,15 @@ func newCreditCallTestApp(t *testing.T, handler http.HandlerFunc) *App { if err != nil { t.Fatal(err) } - return &App{isPayment: true, creditCallStreamEnabled: true, cfg: &config.ConfigRec{TimeoutSeconds: 1}, + app := &App{isPayment: 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) }), } + app.EnableCreditCallStreaming() + return app } func saleRequest(stream bool) *http.Request { @@ -292,7 +294,7 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) { 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 { + if final.HTTPStatus != http.StatusOK || (final.Outcome == "approved") != test.approved { t.Errorf("structured final = %+v, legacy = %+v", final, legacy) } parsed, err := url.Parse(legacy.Data) @@ -303,12 +305,10 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) { 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") { + } else if final.Outcome == "approved" { 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") - } + } }) } @@ -318,7 +318,8 @@ 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 := &App{isPayment: true, cfg: &config.ConfigRec{}} + app.EnableCreditCallStreaming() 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 { @@ -349,7 +350,7 @@ func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) { } 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" { + if len(frames) != 1 || frames[0].Result.HTTPStatus != 502 || frames[0].Result.Outcome != "unknown" || frames[0].Result.Retryable { t.Fatalf("confirmation failure frames=%+v", frames) } } else if recorder.Code != 502 { diff --git a/internal/handlers/creditcall_stream.go b/internal/handlers/creditcall_stream.go index ff3f13f..7713713 100644 --- a/internal/handlers/creditcall_stream.go +++ b/internal/handlers/creditcall_stream.go @@ -10,184 +10,16 @@ import ( "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/paymentsvc" "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 - } - } +// EnableCreditCallStreaming selects the existing CreditCall execution core. +func (app *App) EnableCreditCallStreaming() { + app.paymentService = paymentsvc.NewService(&creditCallProcessor{app: app}) } func callChipDNAStream(client *http.Client, amount int64, onStatus func(string)) (creditcall.TransactionResultXML, error) { diff --git a/internal/handlers/doorcard_handlers_test.go b/internal/handlers/doorcard_handlers_test.go index 2670d66..f97db03 100644 --- a/internal/handlers/doorcard_handlers_test.go +++ b/internal/handlers/doorcard_handlers_test.go @@ -90,12 +90,18 @@ type fakeDoorCardLockServer struct { sequence func() error sequenceErr error + buildErr error + storedCommand string buildCalls int sequenceCalls int } -func (l *fakeDoorCardLockServer) BuildCommand(lockserver.DoorCardRequest, time.Time, time.Time) error { +func (l *fakeDoorCardLockServer) BuildCommand(request lockserver.DoorCardRequest, _ time.Time, _ time.Time) error { l.buildCalls++ + if l.buildErr != nil { + return l.buildErr + } + l.storedCommand = request.RoomField return nil } diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.go index e029170..c12f4fc 100644 --- a/internal/handlers/handlers.go +++ b/internal/handlers/handlers.go @@ -37,20 +37,20 @@ type doorCardDispenser interface { } type App struct { - 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 + trustSelected bool + disp doorCardDispenser + lockserver lockserver.LockServer + paymentService *paymentsvc.Service + 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 { @@ -66,6 +66,13 @@ func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus str return app } +// SetPaymentCurrency supplies the CMS currency to the selected modern processor. +func (app *App) SetPaymentCurrency(currency string) { + if app.paymentService != nil { + app.paymentService.SetCurrency(currency) + } +} + func (app *App) SetPaymentService(service *paymentsvc.Service) { app.paymentService = service } @@ -80,10 +87,14 @@ func (app *App) RegisterRoutes(mux *http.ServeMux) { 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) + mux.HandleFunc("/api/payment/preauth", app.preauthPayment) } func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) { + if app.trustSelected { + http.Error(w, "Trust uses /api/payment/preauth", http.StatusConflict) + return + } const op = logging.Op("takePreauthorization") var ( @@ -164,6 +175,10 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) { } func (app *App) takePayment(w http.ResponseWriter, r *http.Request) { + if app.trustSelected { + http.Error(w, "Trust uses /api/payment/sale", http.StatusConflict) + return + } const op = logging.Op("takePayment") var ( @@ -251,16 +266,8 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) { theResponse cmstypes.StatusRec ) - 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") - if r.Method == http.MethodOptions { - w.WriteHeader(http.StatusNoContent) - return - } - log.Println("issueDoorCard called") if r.Method != http.MethodPost { errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST") @@ -314,7 +321,11 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) { // doorReq.RoomField = "104" // build lock server command - app.lockserver.BuildCommand(doorReq, checkIn, checkOut) + if err := app.lockserver.BuildCommand(doorReq, checkIn, checkOut); err != nil { + logging.Error(types.ServiceName, err.Error(), "Build key command", string(op), "", "", 0) + errorhandlers.WriteError(w, http.StatusBadGateway, "Build key command failed: "+err.Error()) + return + } // Each request performs at most one encoder operation. encodingStarted := time.Now() @@ -374,15 +385,7 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) { func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) { const op = logging.Op("printRoomTicket") var roomDetails printer.RoomDetailsRec - // Allow CORS preflight if needed - 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") - if r.Method == http.MethodOptions { - w.WriteHeader(http.StatusNoContent) - return - } log.Println("printRoomTicket called") if r.Method != http.MethodPost { errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST") @@ -424,6 +427,12 @@ func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) { } func (app *App) reportDispenserStatus(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodGet { + w.Header().Set("Allow", http.MethodGet) + errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use GET") + return + } + w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) _ = json.NewEncoder(w).Encode(cmstypes.StatusRec{ diff --git a/internal/handlers/modern_routes_test.go b/internal/handlers/modern_routes_test.go new file mode 100644 index 0000000..f15224e --- /dev/null +++ b/internal/handlers/modern_routes_test.go @@ -0,0 +1,231 @@ +package handlers + +import ( + "context" + "encoding/json" + "encoding/xml" + "fmt" + "io" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "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/mail" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" +) + +func TestModernRoutesRejectNonPOSTWithoutDispatch(t *testing.T) { + var payments atomic.Int32 + d := &fakeDoorCardDispenser{} + lock := &fakeDoorCardLockServer{} + provider := paymentProviderFunc(func(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + payments.Add(1) + return nil, nil + }) + app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock, isPayment: true, paymentService: paymentsvc.NewService(provider)} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + for _, path := range []string{"/issuedoorcard", "/printroomticket", "/api/payment/sale", "/api/payment/preauth"} { + for _, method := range []string{http.MethodGet, http.MethodOptions, http.MethodPut} { + t.Run(method+path, func(t *testing.T) { + r := httptest.NewRequest(method, path, nil) + r.Header.Set("Origin", "http://retired-browser.invalid") + r.Header.Set("Access-Control-Request-Method", http.MethodPost) + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + if w.Code != http.StatusMethodNotAllowed { + t.Errorf("%s %s status = %d, want 405", method, path, w.Code) + } + for key := range w.Header() { + if strings.HasPrefix(key, "Access-Control-") { + t.Errorf("%s %s header %s = %q, want no browser CORS", method, path, key, w.Header().Get(key)) + } + } + if strings.HasPrefix(path, "/api/payment/") { + frames := decodePaymentStream(t, w.Body) + if len(frames) != 1 || frames[0].Result == nil || frames[0].Result.HTTPStatus != 405 || frames[0].Result.Reason != "invalid_request" { + t.Errorf("%s %s frames = %+v, want one structured method rejection", method, path, frames) + } + } + }) + } + } + if payments.Load() != 0 || len(d.calls) != 0 || lock.sequenceCalls != 0 { + t.Errorf("Rejected requests dispatched payments=%d dispenser=%v encoder=%d, want none", payments.Load(), d.calls, lock.sequenceCalls) + } +} + +func TestOperationalDiagnosticIssuanceRetainsEncodedCard(t *testing.T) { + d := &fakeDoorCardDispenser{} + lock := &fakeDoorCardLockServer{} + app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + r := httptest.NewRequest(http.MethodPost, "/testissuedoorcard", strings.NewReader(`{"roomField":"SYNTH-101"}`)) + r.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + if w.Code != http.StatusOK || lock.buildCalls != 1 || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current"}) { + t.Errorf("Diagnostic issuance status=%d build=%d encode=%d dispenser=%v, want 200, one build/encode and preparation only", w.Code, lock.buildCalls, lock.sequenceCalls, d.calls) + } + if d.activity != 0 || d.outsideActivity { + t.Errorf("Diagnostic issuance activity=%d outside=%t, want released foreground ownership", d.activity, d.outsideActivity) + } +} + +func TestModernPOSTValidationHasNoBrowserCORS(t *testing.T) { + var dispatched bool + provider := paymentProviderFunc(func(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + dispatched = true + return nil, nil + }) + app := &App{cfg: &config.ConfigRec{}, isPayment: true, paymentService: paymentsvc.NewService(provider)} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + for _, path := range []string{"/issuedoorcard", "/printroomticket", "/api/payment/sale", "/api/payment/preauth"} { + r := httptest.NewRequest(http.MethodPost, path, strings.NewReader("{")) + r.Header.Set("Origin", "http://retired-browser.invalid") + r.Header.Set("Content-Type", "application/json") + if path == "/printroomticket" { + r.Header.Set("Content-Type", "application/xml") + } + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + if w.Code != http.StatusBadRequest { + t.Errorf("POST %s with malformed payload = %d, want unchanged 400 validation", path, w.Code) + } + for key := range w.Header() { + if strings.HasPrefix(key, "Access-Control-") { + t.Errorf("POST %s header %s = %q, want no browser CORS", path, key, w.Header().Get(key)) + } + } + } + if dispatched { + t.Error("Malformed modern POST dispatched a payment, want validation before dispatch") + } +} + +func TestModernIssueDoorCardRouteStillDelivers(t *testing.T) { + d := &fakeDoorCardDispenser{} + lock := &fakeDoorCardLockServer{} + app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + r := httptest.NewRequest(http.MethodPost, "/issuedoorcard", strings.NewReader(`{"roomField":"SYNTH-101","checkinTime":"2026-11-04 15:00:00 +0000","checkoutTime":"2026-11-05 11:00:00 +0000","followStr":"0"}`)) + r.Header.Set("Content-Type", "application/json") + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + if w.Code != http.StatusOK || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current", "deliver current", "begin prepare next"}) { + t.Errorf("Normal issuance status=%d encode=%d dispenser=%v, want 200, one encoding, delivery and next preparation", w.Code, lock.sequenceCalls, d.calls) + } + if got := w.Header().Get("Access-Control-Allow-Origin"); got != "" { + t.Errorf("Normal issuance CORS = %q, want absent", got) + } +} + +func TestOperationalDiagnosticsUseGET(t *testing.T) { + previous := http.DefaultTransport + var sidecarCalls int + http.DefaultTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodPost || r.URL.Path != "/chipdna-status/" { + return nil, fmt.Errorf("unexpected synthetic sidecar request: %s %s", r.Method, r.URL.Path) + } + sidecarCalls++ + deviceXML := `SYNTH-PEDtrue` + body, err := xml.Marshal(creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: creditcall.KeyPaymentDeviceStatus, Value: deviceXML}}}) + if err != nil { + return nil, err + } + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body))), Header: make(http.Header)}, nil + }) + t.Cleanup(func() { http.DefaultTransport = previous }) + app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH", Kiosk: 9}, cardWellStatus: "Card present"} + mux := http.NewServeMux() + app.RegisterRoutes(mux) + for _, path := range []string{"/dispenserstatus", "/ping-pdq"} { + for _, method := range []string{http.MethodPost, http.MethodOptions, http.MethodDelete} { + w := httptest.NewRecorder() + mux.ServeHTTP(w, httptest.NewRequest(method, path, nil)) + if w.Code != 405 || w.Header().Get("Allow") != http.MethodGet { + t.Errorf("%s %s status=%d Allow=%q, want 405 and GET", method, path, w.Code, w.Header().Get("Allow")) + } + } + w := httptest.NewRecorder() + mux.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil)) + var status cmstypes.StatusRec + if err := json.Unmarshal(w.Body.Bytes(), &status); err != nil { + t.Fatal(err) + } + if w.Code != 200 || status.Code != 200 || (path == "/dispenserstatus" && status.Message != "Card present") || (path == "/ping-pdq" && !strings.Contains(status.Message, "SYNTH-PED")) { + t.Errorf("GET %s = %d %+v, want unchanged diagnostic response", path, w.Code, status) + } + } + if sidecarCalls != 1 { + t.Errorf("Diagnostic sidecar calls = %d, want one for GET only", sidecarCalls) + } +} + +func TestChipDNAErrorRoutePreservesXMLNotificationsAndDebounce(t *testing.T) { + previousTransport, previousClient, previousRecipients := http.DefaultTransport, http.DefaultClient, mail.SendErrorEmails + var notifications int + http.DefaultTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { + if r.URL.Host != "api.mailjet.com" || r.Method != http.MethodPost { + return nil, fmt.Errorf("unexpected synthetic notification transport") + } + notifications++ + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + if !strings.Contains(string(body), "SYNTH-DEVICE-ERROR") || !strings.Contains(string(body), "SYNTH-HOTEL") { + t.Error("ChipDNA notification lacks synthetic hotel/error context") + } + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"Messages":[{"Status":"success"}]}`)), Header: make(http.Header)}, nil + }) + http.DefaultClient = &http.Client{Transport: http.DefaultTransport} + mail.SendErrorEmails = []string{"operator@example.test"} + app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}, availabilityTimers: make(map[string]*time.Timer)} + t.Cleanup(func() { + app.availabilityMu.Lock() + for _, timer := range app.availabilityTimers { + timer.Stop() + } + app.availabilityMu.Unlock() + http.DefaultTransport, http.DefaultClient, mail.SendErrorEmails = previousTransport, previousClient, previousRecipients + }) + mux := http.NewServeMux() + app.RegisterRoutes(mux) + post := func(key, value string) { + t.Helper() + body, err := xml.Marshal(creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: key, Value: value}}}) + if err != nil { + t.Fatal(err) + } + r := httptest.NewRequest(http.MethodPost, "/logerror", strings.NewReader(string(body))) + r.Header.Set("Content-Type", "application/xml") + w := httptest.NewRecorder() + mux.ServeHTTP(w, r) + if w.Code != 200 || w.Body.String() != `{"status":"received"}` { + t.Errorf("POST /logerror(%s) = %d %s, want unchanged acknowledgement", key, w.Code, w.Body.String()) + } + } + post(creditcall.KeyErrors, "SYNTH-DEVICE-ERROR") + post(creditcall.KeyIsAvailable, "false") + key := app.availabilityKey() + first := app.availabilityTimers[key] + post(creditcall.KeyIsAvailable, "false") + if first == nil || len(app.availabilityTimers) != 1 || app.availabilityTimers[key] != first { + t.Errorf("Repeated unavailable notifications timers=%d, want same single debounce timer", len(app.availabilityTimers)) + } + post(creditcall.KeyIsAvailable, "true") + if len(app.availabilityTimers) != 0 || notifications != 1 { + t.Errorf("Restored availability timers=%d notifications=%d, want zero timers and one error notification", len(app.availabilityTimers), notifications) + } +} diff --git a/internal/handlers/offline_network_test.go b/internal/handlers/offline_network_test.go new file mode 100644 index 0000000..8411e28 --- /dev/null +++ b/internal/handlers/offline_network_test.go @@ -0,0 +1,22 @@ +package handlers + +import ( + "errors" + "net/http" + "os" + "testing" +) + +type offlineDefaultTransport struct{} + +func (offlineDefaultTransport) RoundTrip(*http.Request) (*http.Response, error) { + return nil, errors.New("offline handler tests prohibit default network access") +} + +func TestMain(m *testing.M) { + // Fixtures supply in-memory transports or httptest server-specific clients. + // In particular, error-notification code cannot reach a live email service. + http.DefaultTransport = offlineDefaultTransport{} + http.DefaultClient = &http.Client{Transport: http.DefaultTransport} + os.Exit(m.Run()) +} diff --git a/internal/handlers/payment_handlers.go b/internal/handlers/payment_handlers.go index 4e4be4a..522205a 100644 --- a/internal/handlers/payment_handlers.go +++ b/internal/handlers/payment_handlers.go @@ -2,339 +2,190 @@ 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" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" "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 - } + app.streamPayment(w, r, false) +} +func (app *App) streamPayment(w http.ResponseWriter, r *http.Request, preauth bool) { 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) - - var streamMu sync.Mutex - streamStarted := false - streamFailed := false - - sendStreamMessage := func(message paymentStreamMessage) { - streamMu.Lock() - defer streamMu.Unlock() - - if streamFailed { - return + deliveryFailed := false + deliveryFailure := "" + send := func(frame paymentapi.Frame) bool { + if deliveryFailed { + return false } - - if err := encoder.Encode(message); err != nil { - streamFailed = true - return + if r.Context().Err() != nil { + deliveryFailure = "client_disconnected" + return false } - - streamStarted = true - flusher.Flush() + if err := controller.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil && !errors.Is(err, http.ErrNotSupported) { + deliveryFailure = paymentsvc.SafeErrorCategory(err) + return false + } + if err := encoder.Encode(frame); err != nil { + deliveryFailed = true + deliveryFailure = paymentsvc.SafeErrorCategory(err) + return false + } + if err := controller.Flush(); err != nil { + deliveryFailed = true + deliveryFailure = paymentsvc.SafeErrorCategory(err) + return false + } + return true } - - onStatus := func(update paymentsvc.StatusUpdate) { - if update.Code == "" { - return - } - - sendStreamMessage(paymentStreamMessage{ - Type: "status", - Code: update.Code, - }) + reject := func(code int, reason, message string) { + w.WriteHeader(code) + result := paymentapi.Result{Outcome: "error", HTTPStatus: code, Reason: reason, Message: message} + send(paymentapi.Frame{Type: "result", Result: &result}) } - - 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, - }) + if r.Method != http.MethodPost { + reject(http.StatusMethodNotAllowed, "invalid_request", "Use POST") 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) + if !app.isPayment || app.paymentService == nil { + reject(http.StatusServiceUnavailable, "terminal_unavailable", "Payment service is unavailable") + return + } + if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") { + reject(http.StatusUnsupportedMediaType, "invalid_request", "Use application/json") + return + } + defer r.Body.Close() + var input paymentapi.Request + if json.NewDecoder(http.MaxBytesReader(w, r.Body, 64*1024)).Decode(&input) != nil { + reject(http.StatusBadRequest, "invalid_request", "Invalid JSON payload") + return + } + if input.Amount < 0 || (!preauth && input.Amount == 0) { + reject(http.StatusBadRequest, "invalid_request", "Invalid payment amount") + return + } + if input.RequiredPreauth != nil && input.RequiredPreauth.Amount < 0 { + reject(http.StatusBadRequest, "invalid_request", "Invalid required preauthorisation amount") + return + } + if _, ok := w.(http.Flusher); !ok { + reject(http.StatusInternalServerError, "stream_unavailable", "Streaming payment updates are unavailable") + return + } + if r.Context().Err() != nil { + return + } + if input.Reference == "" { + input.Reference = uuid.NewString() + } + req := paymentsvc.SaleRequest{RequestID: buildPaymentRequestID(input.Reference), Reference: input.Reference, Amount: input.Amount, Currency: input.Currency, CheckoutDate: input.CheckoutDate, RequiredPreauth: input.RequiredPreauth} + operation := paymentapi.Sale + if preauth { + operation = paymentapi.Preauth + } + reconciliationFields := func(final paymentapi.Result) log.Fields { + return log.Fields{ + "hotel": app.cfg.Hotel, "kiosk": app.cfg.Kiosk, "operation": operation, + "request_id": req.RequestID, "request_reference": req.Reference, + "provider": final.Provider, "transaction_reference": final.TransactionReference, + "outcome": final.Outcome, "reason": final.Reason, + } + } + progress := make(chan string, 128) + finished := make(chan paymentapi.Result, 1) + go func() { + // Financial dispatch owns its lifetime; HTTP disconnect only ends observation. + timeout := app.cfg.TimeoutSeconds + if timeout <= 0 { + timeout = 300 + } + timeout += 15 // Delivery/status margin; provider financial calls retain their own bounds. + ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), time.Duration(timeout)*time.Second) + defer cancel() + status := func(update paymentsvc.StatusUpdate) { + if update.Code != "" { + select { + case progress <- update.Code: + default: + } + } + } + var result *paymentsvc.Result + var err error + if preauth { + result, err = app.paymentService.Preauth(ctx, req, status) + } else { + result, err = app.paymentService.Sale(ctx, req, status) + } + final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Message: "Payment outcome uncertain; contact reception"} + if result != nil { + final = result.Terminal + } + if err != nil { + switch { + case errors.Is(err, paymentsvc.ErrPaymentInProgress): + final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusConflict, Reason: "payment_in_progress", Message: "Payment is already in progress"} + case errors.Is(err, paymentsvc.ErrPreauthUnsupported): + final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusUnprocessableEntity, Reason: "unsupported_operation", Message: "Preauthorisation is unavailable; contact reception"} + case errors.Is(err, paymentsvc.ErrProviderNotConfigured): + final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusServiceUnavailable, Reason: "terminal_unavailable", Message: "Payment service is unavailable"} + } + } + if final.Outcome == "" { + final = paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Message: "Payment outcome uncertain; contact reception"} + } + if final.Outcome == "unknown" { + log.WithFields(reconciliationFields(final)).WithField("transport_error", err != nil). + Warn("Payment outcome requires reception reconciliation") + } + close(progress) + finished <- final + }() + for { + select { + case code, ok := <-progress: + if !ok { + progress = nil + continue + } + send(paymentapi.Frame{Type: "status", Code: code}) + case final := <-finished: + if progress != nil { + for code := range progress { + send(paymentapi.Frame{Type: "status", Code: code}) + } + } + if !send(paymentapi.Frame{Type: "result", Result: &final}) { + log.WithFields(reconciliationFields(final)).WithField("error_category", deliveryFailure). + Warn("Payment final result delivery failed; reception reconciliation required") + } 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() -} diff --git a/internal/handlers/payment_handlers_test.go b/internal/handlers/payment_handlers_test.go index 3b9186e..686c240 100644 --- a/internal/handlers/payment_handlers_test.go +++ b/internal/handlers/payment_handlers_test.go @@ -7,156 +7,88 @@ import ( "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/paymentapi" "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus" ) -type paymentProviderFunc func( - context.Context, - paymentsvc.SaleRequest, - paymentsvc.StatusHandler, -) (*paymentsvc.Result, error) +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 (f paymentProviderFunc) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return f(ctx, req, status) +} +func (paymentProviderFunc) ValidatePreauth(paymentsvc.SaleRequest) error { + return paymentsvc.ErrPreauthUnsupported +} +func (paymentProviderFunc) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return nil, paymentsvc.ErrPreauthUnsupported } +type paymentStreamMessage = paymentapi.Frame + 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 + provider := paymentProviderFunc(func(_ context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + status(paymentsvc.StatusUpdate{Code: paymentstatus.Starting}) + status(paymentsvc.StatusUpdate{Code: paymentstatus.TerminalUnavailable}) + return &paymentsvc.Result{Terminal: paymentapi.Result{Outcome: "error", HTTPStatus: 200, Reason: "terminal_unavailable", Message: "Payment terminal is unavailable"}}, nil }) - recorder := performSalePaymentRequest(t, provider) - if recorder.Code != http.StatusOK { - t.Fatalf("outer status = %d, want %d", recorder.Code, http.StatusOK) + frames := decodePaymentStream(t, recorder.Body) + if recorder.Code != 200 || len(frames) != 3 || frames[0].Code != paymentstatus.Starting || frames[1].Code != paymentstatus.TerminalUnavailable || frames[2].Result == nil { + t.Fatalf("SalePayment() HTTP/frames=%d/%+v, want 200 and two statuses plus final", recorder.Code, frames) } - messages := decodePaymentStream(t, recorder.Body) - if len(messages) != 3 { - t.Fatalf("stream messages = %#v, want two statuses and one result", messages) + final := frames[2].Result + if final.Outcome != "error" || final.Reason != "terminal_unavailable" || final.Retryable { + t.Errorf("SalePayment() final=%+v, want definite nonretryable terminal unavailability", final) } - 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) + for _, forbidden := range []string{"Dojo returned HTTP 409", "offline or currently in use", "traceId", "docs.dojo.tech", "\"response\""} { + if strings.Contains(recorder.Body.String(), forbidden) { + t.Errorf("SalePayment() leaked %q", forbidden) } } } -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") +func TestSalePaymentRetainsUncertaintyForProviderErrorsAfterStreamingStarts(t *testing.T) { + provider := paymentProviderFunc(func(_ context.Context, _ paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + status(paymentsvc.StatusUpdate{Code: paymentstatus.Starting}) + return nil, errors.New("raw secret provider error") }) - recorder := performSalePaymentRequest(t, provider) - if recorder.Code != http.StatusOK { - t.Fatalf("outer status = %d, want streaming status %d", recorder.Code, http.StatusOK) + frames := decodePaymentStream(t, recorder.Body) + if len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "unknown" || frames[1].Result.Retryable { + t.Fatalf("SalePayment() frames=%+v, want progress then nonretryable uncertainty", frames) } - 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) + if strings.Contains(recorder.Body.String(), "secret") { + t.Error("SalePayment() exposed raw provider diagnostics") } } 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"}`), - ) + app := &App{isPayment: true, paymentService: paymentsvc.NewService(provider), cfg: &config.ConfigRec{TimeoutSeconds: 1}} + request := httptest.NewRequest(http.MethodPost, paymentapi.SalePath, strings.NewReader(`{"amount":1234,"currency":"GBP","reference":"SYNTH"}`)) 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 { +func decodePaymentStream(t *testing.T, body io.Reader) []paymentapi.Frame { t.Helper() + var frames []paymentapi.Frame 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) + var frame paymentapi.Frame + err := decoder.Decode(&frame) + if err == io.EOF { + return frames } - messages = append(messages, message) + if err != nil { + t.Fatalf("DecodePaymentStream() error=%v, want valid frames", err) + } + frames = append(frames, frame) } } diff --git a/internal/handlers/testhandlers.go b/internal/handlers/testhandlers.go index a03bb84..37fd52a 100644 --- a/internal/handlers/testhandlers.go +++ b/internal/handlers/testhandlers.go @@ -71,7 +71,11 @@ func (app *App) testIssueDoorCard(w http.ResponseWriter, r *http.Request) { } // build lock server command - app.lockserver.BuildCommand(doorReq, checkIn, checkOut) + if err := app.lockserver.BuildCommand(doorReq, checkIn, checkOut); err != nil { + logging.Error(types.ServiceName, err.Error(), "Build key command", string(op), "", "", 0) + errorhandlers.WriteError(w, http.StatusBadGateway, "Build key command failed: "+err.Error()) + return + } // lock server sequence if err := app.lockserver.LockSequence(); err != nil { @@ -90,8 +94,14 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) { const op = logging.Op("fetchChipDNAStatus") var theResponse cmstypes.StatusRec + if r.Method != http.MethodGet { + w.Header().Set("Allow", http.MethodGet) + errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use GET") + return + } + w.Header().Set("Access-Control-Allow-Origin", "*") - w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS") + w.Header().Set("Access-Control-Allow-Methods", "GET") w.Header().Set("Access-Control-Allow-Headers", "Content-Type") w.Header().Set("Content-Type", "application/json") status, err := creditcall.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk) diff --git a/internal/handlers/trust_diagnostics_test.go b/internal/handlers/trust_diagnostics_test.go new file mode 100644 index 0000000..8e6539d --- /dev/null +++ b/internal/handlers/trust_diagnostics_test.go @@ -0,0 +1,156 @@ +package handlers + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "gitea.futuresens.co.uk/futuresens/hardlink/config" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments" + log "github.com/sirupsen/logrus" +) + +type failedDiagnosticWriter struct{ header http.Header } + +func (w *failedDiagnosticWriter) Header() http.Header { return w.header } +func (*failedDiagnosticWriter) WriteHeader(int) {} +func (*failedDiagnosticWriter) Flush() {} +func (*failedDiagnosticWriter) Write([]byte) (int, error) { + return 0, errors.New("https://user:WRITE_PRIVATE_MARKER@gateway.invalid/4111111111111111") +} + +func TestTrustReconciliationLogsPreserveIdentityAndFinancialOutcome(t *testing.T) { + for _, preauth := range []bool{false, true} { + for _, mode := range []string{"unknown", "unknown-transport", "unknown-write-failure", "approved-client-closed", "approved-write-failure"} { + operation := "sale" + if preauth { + operation = "preauth" + } + t.Run(operation+"/"+mode, func(t *testing.T) { + var output bytes.Buffer + logger := log.StandardLogger() + oldOutput, oldFormatter := logger.Out, logger.Formatter + logger.SetOutput(&output) + logger.SetFormatter(&log.JSONFormatter{}) + t.Cleanup(func() { logger.SetOutput(oldOutput); logger.SetFormatter(oldFormatter) }) + unknown := strings.HasPrefix(mode, "unknown") + financial, lookups, prints := 0, 0, 0 + var ref string + var tokens []string + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + client, err := trustpayments.New(trustpayments.Config{ + BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "SYNTH-SITE", Password: "PASSWORD_PRIVATE_MARKER", Terminal: "SYNTH-PED", Currency: "GBP", Timezone: "Europe/London", + Transport: trustFixtureTransport(func(r *http.Request) (*http.Response, error) { + var input map[string]string + if err := json.NewDecoder(r.Body).Decode(&input); err != nil { + return nil, err + } + tokens = append(tokens, r.Header.Get("token")) + if strings.HasSuffix(r.URL.Path, "/status") { + lookups++ + if input["refid"] != ref { + t.Errorf("Status RefID=%q, want original %q", input["refid"], ref) + } + } else { + financial++ + ref = input["refid"] + if !strings.HasSuffix(r.URL.Path, "/"+operation) || input["type"] != operation { + t.Errorf("Financial request path/type=%s/%s, want %s", r.URL.Path, input["type"], operation) + } + if mode == "approved-client-closed" { + cancel() + } + } + if mode == "unknown-transport" { + return nil, errors.New("https://user:PASSWORD_PRIVATE_MARKER@gateway.invalid/4111111111111111/JWT_PRIVATE_MARKER") + } + body := map[string]any{"refid": ref, "siteid": "SYNTH-SITE", "terminalserialnumber": "SYNTH-PED", "type": operation, "amount": "25.00", "finalamount": "25.00", "resultcode": "Approved", "authcode": "AUTH_PRIVATE_MARKER", "cardtype": "Visa", "last4": "1133", "receipt": "PAN: 4111111111111111\nRAW_PRIVATE_MARKER"} + if unknown { + body["errorcode"], body["errormessage"] = 2003, "RAW_PRIVATE_MARKER JWT_PRIVATE_MARKER" + } + encoded, err := json.Marshal(body) + if err != nil { + return nil, err + } + return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(encoded)), Header: make(http.Header)}, nil + }), + }) + if err != nil { + t.Fatal(err) + } + app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}, isPayment: true} + app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(string) { prints++ }})) + request := httptest.NewRequest(http.MethodPost, "/api/payment/"+operation, strings.NewReader(`{"reference":"SYNTH-BOOK","amount":2500,"currency":"GBP"}`)).WithContext(ctx) + request.Header.Set("Content-Type", "application/json") + recorder := httptest.NewRecorder() + var writer http.ResponseWriter = recorder + if strings.Contains(mode, "write-failure") { + writer = &failedDiagnosticWriter{header: make(http.Header)} + } + app.streamPayment(writer, request, preauth) + wantLookups, wantPrints, wantOutcome := 0, 1, "approved" + if unknown { + wantLookups, wantPrints, wantOutcome = 1, 0, "unknown" + } + if financial != 1 || lookups != wantLookups || prints != wantPrints || len(ref) != 32 { + t.Fatalf("Trust(%s) financial/status/prints/ref=%d/%d/%d/%q, want 1/%d/%d and original RefID", mode, financial, lookups, prints, ref, wantLookups, wantPrints) + } + if unknown && !strings.Contains(mode, "write-failure") { + frames := decodePaymentStream(t, recorder.Body) + if len(frames) == 0 { + t.Fatal("Unknown payment stream is empty, want final result") + } + final := frames[len(frames)-1].Result + if final == nil || final.Outcome != wantOutcome || final.Retryable || final.TransactionReference != ref { + t.Errorf("Unknown terminal result=%+v, want unchanged nonretryable outcome and RefID %s", final, ref) + } + } + var requestID string + warnings := 0 + decoder := json.NewDecoder(strings.NewReader(output.String())) + for { + var entry map[string]any + if err := decoder.Decode(&entry); err == io.EOF { + break + } else if err != nil { + t.Fatal(err) + } + if entry["level"] != "warning" { + continue + } + warnings++ + id, _ := entry["request_id"].(string) + if requestID == "" { + requestID = id + } + if id == "" || id != requestID || entry["request_reference"] != "SYNTH-BOOK" || entry["transaction_reference"] != ref || entry["provider"] != "TrustPayments" || entry["operation"] != operation || entry["outcome"] != wantOutcome { + t.Errorf("Reconciliation warning=%v, want same request ID, Trust RefID, provider, operation and financial outcome", entry) + } + } + wantWarnings := 0 + if unknown { + wantWarnings = 2 + } + if strings.Contains(mode, "write-failure") || mode == "approved-client-closed" { + wantWarnings++ + } + if warnings != wantWarnings { + t.Errorf("Trust(%s) reconciliation warnings=%d, want %d", mode, warnings, wantWarnings) + } + for _, secret := range append(tokens, "PASSWORD_PRIVATE_MARKER", "AUTH_PRIVATE_MARKER", "RAW_PRIVATE_MARKER", "JWT_PRIVATE_MARKER", "WRITE_PRIVATE_MARKER", "4111111111111111") { + if secret != "" && strings.Contains(output.String(), secret) { + t.Errorf("Trust(%s) diagnostics contain private fixture data", mode) + } + } + }) + } + } +} diff --git a/internal/handlers/trust_payment_handlers.go b/internal/handlers/trust_payment_handlers.go new file mode 100644 index 0000000..18f7f9e --- /dev/null +++ b/internal/handlers/trust_payment_handlers.go @@ -0,0 +1,12 @@ +package handlers + +import ( + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments" +) + +// SetTrustPayments selects Trust while preserving the deprecated endpoint guard. +func (app *App) SetTrustPayments(client *trustpayments.Client) { + app.trustSelected = true + app.paymentService = paymentsvc.NewService(&trustpayments.Processor{Client: client}) +} diff --git a/internal/handlers/trust_payment_test.go b/internal/handlers/trust_payment_test.go new file mode 100644 index 0000000..f2dbd24 --- /dev/null +++ b/internal/handlers/trust_payment_test.go @@ -0,0 +1,314 @@ +package handlers + +import ( + "bytes" + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "sync/atomic" + "testing" + "time" + + "gitea.futuresens.co.uk/futuresens/hardlink/config" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments" +) + +type trustFixtureTransport func(*http.Request) (*http.Response, error) + +func (f trustFixtureTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +func fixtureTrustApp(t *testing.T, dir string) *trustFixtureApp { + t.Helper() + client, err := trustpayments.New(trustpayments.Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "fixture-site", Password: "synthetic", Terminal: "fixture-ped", Currency: "GBP", Timezone: "Europe/London", Transport: trustFixtureTransport(func(r *http.Request) (*http.Response, error) { + var input map[string]string + if err := json.NewDecoder(r.Body).Decode(&input); err != nil { + return nil, err + } + if strings.HasSuffix(r.URL.Path, "/status") { + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"errorcode":2003}`))}, nil + } + f, err := os.OpenFile(filepath.Join(dir, "starts"), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600) + if err != nil { + return nil, err + } + _, err = f.WriteString(input["refid"] + "\n") + closeErr := f.Close() + if err != nil { + return nil, err + } + if closeErr != nil { + return nil, closeErr + } + outcome, auth := "Approved", "123456" + if _, err := os.Stat(filepath.Join(dir, "decline-preauth")); err == nil && input["type"] == "preauth" { + outcome, auth = "Declined", "" + } + if _, err := os.Stat(filepath.Join(dir, "uncertain")); err == nil { + outcome, auth = "Pending", "" + } + body, _ := json.Marshal(map[string]string{"refid": input["refid"], "siteid": "fixture-site", "terminalserialnumber": "fixture-ped", "type": input["type"], "amount": input["amount"], "finalamount": input["amount"], "resultcode": outcome, "authcode": auth, "cardtype": "Visa", "last4": "1133", "receipt": "Receipt: 31\nSequence number: 42\nPAN: 4111111111111111"}) + return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(body))}, nil + })}) + if err != nil { + t.Fatal(err) + } + app := &trustFixtureApp{App: &App{isPayment: true, cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}}, trustReceipt: func(string) {}} + app.SetTrustPayments(client) + app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(s string) { app.trustReceipt(s) }})) + return app +} + +// This opt-in subprocess only uses an in-memory gateway and synthetic receipts. +func TestTrustFixtureProcess(t *testing.T) { + dir := os.Getenv("TRUST_FIXTURE_DIR") + if dir == "" { + t.Skip("offline subprocess helper") + } + app := fixtureTrustApp(t, dir) + mux := http.NewServeMux() + app.RegisterRoutes(mux) + server := httptest.NewServer(mux) + defer server.Close() + b, _ := json.Marshal(map[string]string{"url": server.URL}) + if err := os.WriteFile(filepath.Join(dir, "ready.json"), b, 0600); err != nil { + t.Fatal(err) + } + for { + if _, err := os.Stat(filepath.Join(dir, "stop")); err == nil { + return + } + time.Sleep(10 * time.Millisecond) + } +} + +func trustStreamRequest(preauth bool) *http.Request { + path, body := "/api/payment/sale", `{"reference":"SYNTH-BOOK","amount":2500,"currency":"GBP"}` + if preauth { + path, body = "/api/payment/preauth", `{"amount":2500,"currency":"GBP","transactionType":"Sale","checkoutDate":"synthetic"}` + } + r := httptest.NewRequest(http.MethodPost, path, strings.NewReader(body)) + r.Header.Set("Content-Type", "application/json") + return r +} + +func TestTrustExistingEndpointsAndSafeFrames(t *testing.T) { + for _, preauth := range []bool{false, true} { + t.Run(map[bool]string{false: "sale", true: "preauth"}[preauth], func(t *testing.T) { + dir := t.TempDir() + app := fixtureTrustApp(t, dir) + prints := 0 + app.trustReceipt = func(s string) { + prints++ + if strings.Contains(s, "4111111111111111") || !strings.Contains(s, "************1133") { + t.Error("unsafe or missing masked receipt") + } + } + mux := http.NewServeMux() + app.RegisterRoutes(mux) + w := httptest.NewRecorder() + mux.ServeHTTP(w, trustStreamRequest(preauth)) + decoder := json.NewDecoder(w.Body) + statuses, results := 0, 0 + for { + var frame paymentStreamMessage + if err := decoder.Decode(&frame); err == io.EOF { + break + } else if err != nil { + t.Fatal(err) + } + if frame.Type == "status" { + statuses++ + if strings.Contains(frame.Code, "PIN") || strings.Contains(frame.Code, "INSERT") { + t.Error("invented terminal prompt") + } + } + if frame.Result != nil { + results++ + if frame.Result.Outcome != "approved" || frame.Result.AmountMinor != 2500 || frame.Result.CurrencyCode != "GBP" || frame.Result.ReceiptNumber != "31" || frame.Result.SequenceNumber != "42" { + t.Errorf("approved result=%+v", frame.Result) + } + } + } + if w.Code != 200 || statuses != 3 || results != 1 || prints != 1 { + t.Errorf("HTTP/statuses/results/prints=%d/%d/%d/%d", w.Code, statuses, results, prints) + } + starts, _ := os.ReadFile(filepath.Join(dir, "starts")) + if strings.Count(string(starts), "\n") != 1 { + t.Errorf("financial starts=%q", starts) + } + if strings.Contains(w.Body.String(), "4111111111111111") || strings.Contains(w.Body.String(), "synthetic") { + t.Error("private provider data escaped") + } + }) + } +} + +func TestTrustUnknownNeverDeclinesOrReposts(t *testing.T) { + dir := t.TempDir() + if err := os.WriteFile(filepath.Join(dir, "uncertain"), nil, 0600); err != nil { + t.Fatal(err) + } + app := fixtureTrustApp(t, dir) + app.trustReceipt = func(string) { t.Error("uncertain payment printed approval") } + w := httptest.NewRecorder() + app.streamTrustPayment(w, trustStreamRequest(false), false) + if !strings.Contains(w.Body.String(), `"outcome":"unknown"`) || strings.Contains(w.Body.String(), `"outcome":"declined"`) { + t.Errorf("uncertain stream=%s", w.Body.String()) + } + starts, _ := os.ReadFile(filepath.Join(dir, "starts")) + if strings.Count(string(starts), "\n") != 1 { + t.Errorf("financial starts=%q", starts) + } +} + +func TestTrustInvalidRequestsAndNoOperationAPI(t *testing.T) { + app := fixtureTrustApp(t, t.TempDir()) + mux := http.NewServeMux() + app.RegisterRoutes(mux) + for _, body := range []string{`{"amount":0,"currency":"GBP"}`, `{`} { + w := httptest.NewRecorder() + r := httptest.NewRequest("POST", "/api/payment/sale", strings.NewReader(body)) + mux.ServeHTTP(w, r) + if w.Code != 400 { + t.Errorf("invalid input=%q status=%d", body, w.Code) + } + } + w := httptest.NewRecorder() + mux.ServeHTTP(w, httptest.NewRequest("GET", "/api/payment/trust/v1/capabilities", nil)) + if w.Code != 404 { + t.Errorf("removed operation API=%d", w.Code) + } + r := trustStreamRequest(false) + ctx, cancel := context.WithCancel(r.Context()) + cancel() + w = httptest.NewRecorder() + mux.ServeHTTP(w, r.WithContext(ctx)) + if w.Body.Len() != 0 { + t.Error("cancelled-before-dispatch request produced result") + } +} + +type trustBlockingWriter struct { + entered chan struct{} + release chan struct{} + once sync.Once +} + +func (w *trustBlockingWriter) Header() http.Header { return make(http.Header) } +func (w *trustBlockingWriter) WriteHeader(int) {} +func (w *trustBlockingWriter) Flush() {} +func (w *trustBlockingWriter) Write(p []byte) (int, error) { + w.once.Do(func() { close(w.entered) }) + <-w.release + return len(p), nil +} + +func TestTrustBackpressureAndDisconnectDoNotCancelFinancialWorker(t *testing.T) { + for _, disconnect := range []bool{false, true} { + t.Run(map[bool]string{false: "backpressure", true: "disconnect"}[disconnect], func(t *testing.T) { + app := fixtureTrustApp(t, t.TempDir()) + printed := make(chan struct{}) + var prints atomic.Int32 + app.trustReceipt = func(string) { prints.Add(1); close(printed) } + writer := &trustBlockingWriter{entered: make(chan struct{}), release: make(chan struct{})} + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + done := make(chan struct{}) + go func() { app.streamTrustPayment(writer, trustStreamRequest(false).WithContext(ctx), false); close(done) }() + var once sync.Once + t.Cleanup(func() { once.Do(func() { close(writer.release) }); <-done }) + select { + case <-writer.entered: + case <-time.After(3 * time.Second): + t.Fatal("handler did not reach blocked writer") + } + if disconnect { + cancel() + } + select { + case <-printed: + case <-time.After(3 * time.Second): + t.Fatal("delivery blocked provider finalization/printing") + } + once.Do(func() { close(writer.release) }) + select { + case <-done: + case <-time.After(3 * time.Second): + t.Fatal("handler did not finish after delivery released") + } + if prints.Load() != 1 { + t.Errorf("prints=%d, want 1", prints.Load()) + } + }) + } +} + +func TestTrustDisconnectDuringProviderCallAndConcurrentAdmission(t *testing.T) { + entered, release := make(chan struct{}), make(chan struct{}) + var calls atomic.Int32 + client, err := trustpayments.New(trustpayments.Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "fixture-site", Password: "synthetic", Terminal: "fixture-ped", Currency: "GBP", Timezone: "Europe/London", Transport: trustFixtureTransport(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + var input map[string]string + if err := json.NewDecoder(r.Body).Decode(&input); err != nil { + return nil, err + } + close(entered) + <-release + if r.Context().Err() != nil { + t.Error("incoming disconnect cancelled admitted provider request") + } + body, _ := json.Marshal(map[string]string{"refid": input["refid"], "siteid": "fixture-site", "terminalserialnumber": "fixture-ped", "type": input["type"], "amount": input["amount"], "resultcode": "Approved"}) + return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(body))}, nil + })}) + if err != nil { + t.Fatal(err) + } + app := &trustFixtureApp{App: &App{isPayment: true, cfg: &config.ConfigRec{}}, trustReceipt: func(string) {}} + app.SetTrustPayments(client) + app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(s string) { app.trustReceipt(s) }})) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + done := make(chan struct{}) + go func() { + app.streamTrustPayment(httptest.NewRecorder(), trustStreamRequest(false).WithContext(ctx), false) + close(done) + }() + var once sync.Once + t.Cleanup(func() { once.Do(func() { close(release) }); <-done }) + select { + case <-entered: + case <-time.After(3 * time.Second): + t.Fatal("provider request was not admitted") + } + second := httptest.NewRecorder() + app.streamTrustPayment(second, trustStreamRequest(false), false) + if !strings.Contains(second.Body.String(), `"httpStatus":409`) { + t.Errorf("concurrent admission status=%d, want 409", second.Code) + } + cancel() + once.Do(func() { close(release) }) + select { + case <-done: + case <-time.After(3 * time.Second): + t.Fatal("admitted provider did not finish after disconnect") + } + if calls.Load() != 1 { + t.Errorf("financial requests=%d, want 1", calls.Load()) + } +} + +type trustFixtureApp struct { + *App + trustReceipt func(string) +} + +func (a *trustFixtureApp) streamTrustPayment(w http.ResponseWriter, r *http.Request, preauth bool) { + a.streamPayment(w, r, preauth) +} diff --git a/internal/paybridge/client.go b/internal/paybridge/client.go index aacc523..95045b5 100644 --- a/internal/paybridge/client.go +++ b/internal/paybridge/client.go @@ -3,19 +3,24 @@ package paybridge import ( "context" "encoding/json" + "errors" "fmt" + "net/http" "net/url" "strings" "time" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall" "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" "gitea.futuresens.co.uk/futuresens/hardlink/internal/types" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus" "github.com/gorilla/websocket" log "github.com/sirupsen/logrus" ) type Client struct { + PrintReceipt func(string) URL string APIKey string TimeoutSeconds int @@ -46,10 +51,57 @@ func (c *Client) Sale(ctx context.Context, req paymentsvc.SaleRequest, onStatus TimeoutSeconds: c.TimeoutSeconds, } - return c.doPayment(ctx, payBridgeReq, onStatus) + result, err := c.doPayment(ctx, payBridgeReq, onStatus) + if result != nil { + result.Terminal = payBridgeTerminalResult(result) + if c.PrintReceipt != nil { + c.PrintReceipt(result.CustomerReceipt) + } + } + return result, err } -func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) { +func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (returned *paymentsvc.Result, resultErr error) { + stage := "configure_connection" + var httpStatus int + defer func() { + if resultErr != nil || (returned != nil && payBridgeTerminalResult(returned).Outcome == "unknown") { + fields := log.Fields{ + "provider": "paybridge", "operation": "sale", "stage": stage, + "request_id": req.RequestID, "transaction_reference": req.RequestID, + "error_category": paymentsvc.SafeErrorCategory(resultErr), + } + if returned != nil { + if returned.RequestID != "" { + fields["transaction_reference"] = returned.RequestID + } + if returned.TransactionID != "" { + fields["provider_transaction_id"] = returned.TransactionID + } + if returned.ReferenceNumber != "" { + fields["provider_reference"] = returned.ReferenceNumber + } + } + if ctx.Err() != nil { + fields["error_category"] = paymentsvc.SafeErrorCategory(ctx.Err()) + } else if errors.Is(resultErr, ErrConnectionFailed) { + fields["error_category"] = "connection_failure" + } else if errors.Is(resultErr, ErrAuthFailed) { + fields["error_category"] = "authentication_failed" + } else if errors.Is(resultErr, ErrUnexpectedMessage) { + fields["error_category"] = "invalid_response" + } + var closeError *websocket.CloseError + if errors.As(resultErr, &closeError) { + fields["error_category"] = "response_lost" + fields["websocket_close_code"] = closeError.Code + } + if httpStatus != 0 { + fields["http_status"] = httpStatus + } + log.WithFields(fields).Warn("PayBridge payment requires reconciliation") + } + }() emitStatus(onStatus, paymentstatus.Starting) connectURL, err := c.connectURL() @@ -57,8 +109,15 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay return nil, err } - ws, _, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil) + stage = "connect" + ws, response, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil) if err != nil { + if response != nil { + httpStatus = response.StatusCode + if response.Body != nil { + response.Body.Close() + } + } return nil, fmt.Errorf("%w: %v", ErrConnectionFailed, err) } defer ws.Close() @@ -74,6 +133,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay } }() + stage = "authenticate" jwt, err := c.readAuthSuccess(ws) if err != nil { return nil, err @@ -82,6 +142,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay log.Info("PayBridge authentication successful") emitStatus(onStatus, paymentstatus.Started) + stage = "send_payment" if err := ws.WriteJSON(Envelope{ Type: types.MesTypePaymentRequest, JWT: jwt, @@ -101,6 +162,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay emitStatus(onStatus, paymentstatus.RequestSent) for { + stage = "read_result" _, raw, err := ws.ReadMessage() if err != nil { if ctx.Err() != nil { @@ -122,26 +184,20 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay switch messageType { case types.MesTypePaymentStatusUpdate: + stage = "decode_status" var update StatusUpdateEnvelope if err := json.Unmarshal(raw, &update); err != nil { return nil, fmt.Errorf("decode payment_status_update: %w", err) } - log.WithFields(log.Fields{ - "status": update.Data.Status, - "code": update.Data.Code, - }).Info("PayBridge status update") - statusCode, known := mapPayBridgeStatus( update.Data.Status, update.Data.Code, ) + log.WithField("status", statusCode).Info("PayBridge status update") if !known { - log.WithFields(log.Fields{ - "status": update.Data.Status, - "code": update.Data.Code, - }).Warn("Unknown PayBridge status update") + log.Warn("Unknown PayBridge status update") } emitStatus(onStatus, statusCode) @@ -151,6 +207,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay emitStatus(onStatus, paymentstatus.Accepted) case types.MesTypePaymentResult: + stage = "decode_result" var result PaymentResultEnvelope // log.Println("PayBridge payment result raw:", string(raw)) if err := json.Unmarshal(raw, &result); err != nil { @@ -162,7 +219,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay log.WithFields(log.Fields{ "requestId": mapped.RequestID, "transactionId": mapped.TransactionID, - "status": mapped.Status, + "status": mapPayBridgeFinalStatus(mapped.Status, mapped.Success), "success": mapped.Success, }).Info("PayBridge payment result received") @@ -174,6 +231,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay return mapped, nil case types.MesTypePaymentError: + stage = "decode_payment_error" var paymentErr PaymentErrorEnvelope if err := json.Unmarshal(raw, &paymentErr); err != nil { return nil, fmt.Errorf("decode payment_error: %w", err) @@ -182,10 +240,10 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay mapped := mapPaymentError(req, paymentErr) log.WithFields(log.Fields{ - "requestId": mapped.RequestID, - "transactionId": mapped.TransactionID, - "status": mapped.Status, - "error": mapped.ErrorMessage, + "requestId": mapped.RequestID, + "transactionId": mapped.TransactionID, + "status": mapPayBridgeFinalStatus(mapped.Status, false), + "error_category": "provider_error", }).Warn("PayBridge payment error received") emitStatus( @@ -196,6 +254,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay return mapped, nil case types.ResultError: + stage = "provider_error" var genericErr struct { Error struct { Code string `json:"code"` @@ -211,10 +270,8 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay ) } - log.WithFields(log.Fields{ - "code": genericErr.Error.Code, - "message": genericErr.Error.Message, - }).Error("PayBridge error message received") + log.WithFields(log.Fields{"provider": "paybridge", "request_id": req.RequestID, + "error_category": "provider_error"}).Error("PayBridge error message received") emitStatus(onStatus, paymentstatus.Error) @@ -237,10 +294,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay log.Info("Additional PayBridge auth_success message received") default: - log.WithField( - "messageType", - head.Type, - ).Warn("Unknown PayBridge intermediate message type") + log.Warn("Unknown PayBridge intermediate message type") emitStatus(onStatus, paymentstatus.Processing) } @@ -447,3 +501,23 @@ func mapPayBridgeFinalStatus( return paymentstatus.Error } } + +func (*Client) ValidatePreauth(paymentsvc.SaleRequest) error { return paymentsvc.ErrPreauthUnsupported } +func (*Client) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return nil, paymentsvc.ErrPreauthUnsupported +} + +func payBridgeTerminalResult(r *paymentsvc.Result) paymentapi.Result { + final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "paybridge", AmountMinor: r.Amount, CurrencyCode: r.Currency, TransactionReference: r.RequestID, CardType: r.CardType, MaskedCardNumber: creditcall.MaskedCardNumber(r.CardNumber), ExpiryDate: r.ExpiryDate, CardHash: r.CardHash, CardReference: r.CardReference, AuthorizationCode: r.AuthCode, LastFour: r.LastFourDigits, Message: "Payment outcome uncertain; contact reception"} + if r.Success && strings.EqualFold(r.Status, payBridgeFinalStatusApproved) { + final.Outcome, final.Message = "approved", "Payment approved" + return final + } + switch strings.ToUpper(r.Status) { + case payBridgeFinalStatusDeclined: + final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined" + case payBridgeFinalStatusCancelled: + final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled" + } + return final +} diff --git a/internal/paybridge/diagnostics_test.go b/internal/paybridge/diagnostics_test.go new file mode 100644 index 0000000..5adbbdd --- /dev/null +++ b/internal/paybridge/diagnostics_test.go @@ -0,0 +1,162 @@ +package paybridge + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "github.com/gorilla/websocket" + log "github.com/sirupsen/logrus" + logtest "github.com/sirupsen/logrus/hooks/test" +) + +func paybridgeDiagnosticLog(t *testing.T) *logtest.Hook { + t.Helper() + logger := log.StandardLogger() + oldOutput := logger.Out + oldHooks := logger.ReplaceHooks(make(log.LevelHooks)) + hook := logtest.NewGlobal() + log.SetOutput(io.Discard) + t.Cleanup(func() { log.SetOutput(oldOutput); logger.ReplaceHooks(oldHooks) }) + return hook +} + +func TestPayBridgeFailureDiagnosticsKeepIdentityAndDoNotRetry(t *testing.T) { + for _, failure := range []string{"connect", "auth", "lost", "malformed", "uncertain", "provider_error", "payment_error", "cancelled"} { + t.Run(failure, func(t *testing.T) { + hook := paybridgeDiagnosticLog(t) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + var financialPosts atomic.Int32 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Query().Get("api_key") != "SYNTH-CREDENTIAL" { + t.Error("PayBridge connection omitted synthetic credential") + } + if failure == "connect" { + http.Error(w, "SYNTH-RAW-SECRET", 503) + return + } + connection, err := (&websocket.Upgrader{}).Upgrade(w, r, nil) + if err != nil { + t.Error(err) + return + } + defer connection.Close() + auth := `{"type":"auth_success","jwt":"SYNTH-JWT-PRIVATE"}` + if failure == "auth" { + auth = `{"type":"SYNTH-RAW-SECRET","jwt":"SYNTH-JWT-PRIVATE"}` + } + if err := connection.WriteMessage(websocket.TextMessage, []byte(auth)); err != nil { + t.Error(err) + return + } + if failure == "auth" { + return + } + var request struct { + Data PaymentRequest `json:"data"` + } + if err := connection.ReadJSON(&request); err != nil { + t.Error(err) + return + } + financialPosts.Add(1) + if request.Data.RequestID != "SYNTH-REQUEST" || request.Data.Amount != 2500 { + t.Errorf("PayBridge dispatched %+v, want original request identity/amount", request.Data) + } + body := "" + switch failure { + case "lost": + if err := connection.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.ClosePolicyViolation, "SYNTH-RAW-SECRET"), time.Now().Add(time.Second)); err != nil { + t.Error(err) + } + return + case "malformed": + body = `{"type":"payment_result","data":"SYNTH-RAW-SECRET"}` + case "uncertain": + body = `{"type":"payment_result","data":{"requestId":"SYNTH-REQUEST","transactionId":"SYNTH-PROVIDER-TXN","referenceNumber":"SYNTH-PROVIDER-REF","success":false,"status":"TIMEOUT","errorMessage":"SYNTH-RAW-SECRET card 4111111111111111","amount":2500}}` + case "provider_error": + body = `{"type":"error","error":{"code":"SYNTH-PRIVATE-CODE","message":"SYNTH-RAW-SECRET"}}` + case "payment_error": + body = `{"type":"payment_error","data":{"transactionId":"SYNTH-PROVIDER-TXN","status":"TIMEOUT","error":"SYNTH-RAW-SECRET"}}` + case "cancelled": + cancel() + return + } + if err := connection.WriteMessage(websocket.TextMessage, []byte(body)); err != nil { + t.Error(err) + } + })) + t.Cleanup(server.Close) + client := NewClient("ws"+strings.TrimPrefix(server.URL, "http"), "SYNTH-CREDENTIAL", 5) + result, err := client.Sale(ctx, paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Amount: 2500, Currency: "GBP"}, nil) + wantPosts := int32(1) + if failure == "connect" || failure == "auth" { + wantPosts = 0 + } + if financialPosts.Load() != wantPosts { + t.Errorf("Sale(%s) dispatches=%d, want %d without retry", failure, financialPosts.Load(), wantPosts) + } + if failure == "uncertain" || failure == "payment_error" { + if err != nil || result == nil || result.Terminal.Outcome != "unknown" || result.Terminal.Retryable { + t.Fatalf("Sale(%s)=%+v/%v, want unchanged nonretryable unknown", failure, result, err) + } + if !strings.Contains(result.ErrorMessage, "SYNTH-RAW-SECRET") { + t.Error("diagnostic changes mutated the existing provider result") + } + } else if result != nil || err == nil { + t.Fatalf("Sale(%s)=%+v/%v, want original nil-result failure", failure, result, err) + } + if failure == "connect" && !errors.Is(err, ErrConnectionFailed) { + t.Errorf("Sale(connect) error=%v, want ErrConnectionFailed", err) + } + if failure == "cancelled" && !errors.Is(err, context.Canceled) { + t.Errorf("Sale(cancelled) error=%v, want context.Canceled", err) + } + var diagnostic *log.Entry + for _, entry := range hook.AllEntries() { + data, _ := json.Marshal(entry.Data) + for _, secret := range []string{"SYNTH-CREDENTIAL", "SYNTH-JWT-PRIVATE", "SYNTH-RAW-SECRET", "SYNTH-PRIVATE-CODE", "4111111111111111"} { + if strings.Contains(string(data)+entry.Message, secret) { + t.Errorf("Sale(%s) logged sensitive marker %q", failure, secret) + } + } + if entry.Message == "PayBridge payment requires reconciliation" { + diagnostic = entry + } + } + if diagnostic == nil { + t.Fatal("Sale failure emitted no reconciliation diagnostic") + } + for key, want := range map[string]string{"provider": "paybridge", "request_id": "SYNTH-REQUEST", "transaction_reference": "SYNTH-REQUEST"} { + if diagnostic.Data[key] != want { + t.Errorf("Sale(%s) diagnostic[%s]=%v, want %s", failure, key, diagnostic.Data[key], want) + } + } + stages := map[string]string{"connect": "connect", "auth": "authenticate", "lost": "read_result", "malformed": "decode_result", "uncertain": "decode_result", "provider_error": "provider_error", "payment_error": "decode_payment_error", "cancelled": "read_result"} + categories := map[string]string{"connect": "connection_failure", "auth": "authentication_failed", "lost": "response_lost", "malformed": "invalid_response", "uncertain": "unresolved_result", "provider_error": "invalid_response", "payment_error": "unresolved_result", "cancelled": "cancelled"} + if diagnostic.Data["stage"] != stages[failure] || diagnostic.Data["error_category"] != categories[failure] { + t.Errorf("Sale(%s) diagnostic=%v, want stage=%s category=%s", failure, diagnostic.Data, stages[failure], categories[failure]) + } + if failure == "lost" && diagnostic.Data["websocket_close_code"] != websocket.ClosePolicyViolation { + t.Errorf("Sale(lost) close code=%v, want 1008", diagnostic.Data["websocket_close_code"]) + } + if failure == "connect" && diagnostic.Data["http_status"] != 503 { + t.Errorf("Sale(connect) HTTP status=%v, want 503", diagnostic.Data["http_status"]) + } + if failure == "uncertain" || failure == "payment_error" { + if diagnostic.Data["provider_transaction_id"] != "SYNTH-PROVIDER-TXN" { + t.Errorf("Sale(%s) provider transaction=%v, want retained identity", failure, diagnostic.Data["provider_transaction_id"]) + } + } + }) + } +} diff --git a/internal/paybridge/processor_test.go b/internal/paybridge/processor_test.go new file mode 100644 index 0000000..13d61fc --- /dev/null +++ b/internal/paybridge/processor_test.go @@ -0,0 +1,20 @@ +package paybridge + +import ( + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "testing" +) + +func TestTerminalResultKeepsExistingIdentityAndMetadata(t *testing.T) { + raw := &paymentsvc.Result{Success: true, Status: "APPROVED", RequestID: "SYNTH-REQUEST", TransactionID: "SYNTH-PROVIDER-ID", Amount: 1234, Currency: "EUR", CardNumber: "************1133", CardType: "Visa", ExpiryDate: "1228", CardHash: "SYNTH-HASH", CardReference: "SYNTH-CARD"} + result := payBridgeTerminalResult(raw) + if result.Outcome != "approved" || result.TransactionReference != "SYNTH-REQUEST" || result.MaskedCardNumber != raw.CardNumber || result.CardHash != raw.CardHash || result.CardReference != raw.CardReference { + t.Errorf("payBridgeTerminalResult(%+v)=%+v, want current request identity and unchanged metadata", raw, result) + } +} +func TestTimeoutTerminalResultIsUncertain(t *testing.T) { + result := payBridgeTerminalResult(&paymentsvc.Result{Status: "TIMEOUT"}) + if result.Outcome != "unknown" || result.Retryable { + t.Errorf("payBridgeTerminalResult(TIMEOUT)=%+v, want nonretryable unknown", result) + } +} diff --git a/internal/paymentsvc/diagnostics.go b/internal/paymentsvc/diagnostics.go new file mode 100644 index 0000000..beabe81 --- /dev/null +++ b/internal/paymentsvc/diagnostics.go @@ -0,0 +1,38 @@ +package paymentsvc + +import ( + "context" + "encoding/json" + "errors" + "io" + "net" +) + +// SafeErrorCategory describes a failure without exposing URLs, payloads or credentials. +// It is diagnostic only and must not determine financial outcomes or retry eligibility. +func SafeErrorCategory(err error) string { + if err == nil { + return "unresolved_result" + } + switch { + case errors.Is(err, context.DeadlineExceeded): + return "timeout" + case errors.Is(err, context.Canceled): + return "cancelled" + case errors.Is(err, io.EOF), errors.Is(err, io.ErrUnexpectedEOF): + return "response_lost" + } + var networkError net.Error + if errors.As(err, &networkError) { + if networkError.Timeout() { + return "timeout" + } + return "connection_failure" + } + var syntaxError *json.SyntaxError + var typeError *json.UnmarshalTypeError + if errors.As(err, &syntaxError) || errors.As(err, &typeError) { + return "invalid_response" + } + return "provider_error" +} diff --git a/internal/paymentsvc/diagnostics_test.go b/internal/paymentsvc/diagnostics_test.go new file mode 100644 index 0000000..a896d3d --- /dev/null +++ b/internal/paymentsvc/diagnostics_test.go @@ -0,0 +1,37 @@ +package paymentsvc + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net" + "net/url" + "testing" +) + +func TestSafeErrorCategory(t *testing.T) { + tests := []struct { + name string + err error + want string + }{ + {"missing result", nil, "unresolved_result"}, + {"timeout", fmt.Errorf("private URL: %w", context.DeadlineExceeded), "timeout"}, + {"cancel", fmt.Errorf("private token: %w", context.Canceled), "cancelled"}, + {"eof", fmt.Errorf("raw response: %w", io.EOF), "response_lost"}, + {"truncated", io.ErrUnexpectedEOF, "response_lost"}, + {"connection", &url.Error{Op: "Post", URL: "https://user:secret@synthetic.invalid", Err: &net.OpError{Op: "dial", Net: "tcp", Err: errors.New("private credential")}}, "connection_failure"}, + {"json syntax", &json.SyntaxError{Offset: 1}, "invalid_response"}, + {"json type", &json.UnmarshalTypeError{Value: "private card", Field: "secret"}, "invalid_response"}, + {"other", errors.New("raw provider response with sensitive content"), "provider_error"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := SafeErrorCategory(tc.err); got != tc.want { + t.Errorf("SafeErrorCategory(%s)=%q, want %q", tc.name, got, tc.want) + } + }) + } +} diff --git a/internal/paymentsvc/service.go b/internal/paymentsvc/service.go index c0fa9e5..f723a14 100644 --- a/internal/paymentsvc/service.go +++ b/internal/paymentsvc/service.go @@ -9,6 +9,7 @@ import ( var ( ErrPaymentInProgress = errors.New("payment is already in progress") ErrProviderNotConfigured = errors.New("payment provider is not configured") + ErrPreauthUnsupported = errors.New("configured payment provider does not support preauthorisation") ) type StatusUpdate struct { @@ -23,15 +24,21 @@ type Provider interface { req SaleRequest, onStatus StatusHandler, ) (*Result, error) + Preauth(context.Context, SaleRequest, StatusHandler) (*Result, error) + ValidatePreauth(SaleRequest) error } type Service struct { provider Provider + currency string mu sync.Mutex busy bool } +// SetCurrency supplies the currency from the existing CMS hotel response at startup. +func (s *Service) SetCurrency(currency string) { s.currency = currency } + func NewService(provider Provider) *Service { return &Service{ provider: provider, @@ -43,9 +50,32 @@ func (s *Service) Sale( req SaleRequest, onStatus StatusHandler, ) (*Result, error) { + return s.run(ctx, req, onStatus, false) +} + +// Preauth uses the same terminal ownership as Sale. +func (s *Service) Preauth(ctx context.Context, req SaleRequest, onStatus StatusHandler) (*Result, error) { + return s.run(ctx, req, onStatus, true) +} + +func (s *Service) run(ctx context.Context, req SaleRequest, onStatus StatusHandler, preauth bool) (*Result, error) { if s == nil || s.provider == nil { return nil, ErrProviderNotConfigured } + if s.currency != "" { + req.Currency = s.currency + } + if preauth { + if err := s.provider.ValidatePreauth(req); err != nil { + return nil, err + } + } else if req.RequiredPreauth != nil { + hold := req + hold.Amount, hold.CheckoutDate = req.RequiredPreauth.Amount, req.RequiredPreauth.CheckoutDate + if err := s.provider.ValidatePreauth(hold); err != nil { + return nil, err + } + } s.mu.Lock() if s.busy { @@ -61,5 +91,8 @@ func (s *Service) Sale( s.mu.Unlock() }() + if preauth { + return s.provider.Preauth(ctx, req, onStatus) + } return s.provider.Sale(ctx, req, onStatus) -} \ No newline at end of file +} diff --git a/internal/paymentsvc/service_test.go b/internal/paymentsvc/service_test.go new file mode 100644 index 0000000..581db3f --- /dev/null +++ b/internal/paymentsvc/service_test.go @@ -0,0 +1,85 @@ +package paymentsvc + +import ( + "context" + "errors" + "sync/atomic" + "testing" + + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" +) + +type testProcessor struct { + entered chan SaleRequest + release chan struct{} + saleCalls atomic.Int32 + preauthCalls atomic.Int32 + validation func(SaleRequest) error +} + +func (p *testProcessor) ValidatePreauth(req SaleRequest) error { + if p.validation != nil { + return p.validation(req) + } + return nil +} +func (p *testProcessor) Sale(_ context.Context, req SaleRequest, _ StatusHandler) (*Result, error) { + p.saleCalls.Add(1) + if p.entered != nil { + p.entered <- req + } + if p.release != nil { + <-p.release + } + return &Result{Terminal: paymentapi.Result{Outcome: "approved", HTTPStatus: 200}}, nil +} +func (p *testProcessor) Preauth(context.Context, SaleRequest, StatusHandler) (*Result, error) { + p.preauthCalls.Add(1) + return &Result{Terminal: paymentapi.Result{Outcome: "approved", HTTPStatus: 200}}, nil +} + +func TestSaleAndPreauthShareAdmission(t *testing.T) { + p := &testProcessor{entered: make(chan SaleRequest, 1), release: make(chan struct{})} + s := NewService(p) + done := make(chan error, 1) + go func() { _, err := s.Sale(context.Background(), SaleRequest{Amount: 100}, nil); done <- err }() + <-p.entered + if _, err := s.Preauth(context.Background(), SaleRequest{Amount: 50}, nil); !errors.Is(err, ErrPaymentInProgress) { + t.Errorf("Preauth(during Sale) error=%v, want ErrPaymentInProgress", err) + } + close(p.release) + if err := <-done; err != nil { + t.Fatalf("Sale() error=%v, want nil", err) + } + if _, err := s.Preauth(context.Background(), SaleRequest{Amount: 50}, nil); err != nil { + t.Errorf("Preauth(after Sale) error=%v, want nil", err) + } + if p.saleCalls.Load() != 1 || p.preauthCalls.Load() != 1 { + t.Errorf("Provider calls=%d/%d, want Sale=1/PREAUTH=1", p.saleCalls.Load(), p.preauthCalls.Load()) + } +} + +func TestRequiredPreauthValidatedBeforeSale(t *testing.T) { + p := &testProcessor{validation: func(req SaleRequest) error { + if req.Amount != 2500 || req.CheckoutDate != "SYNTH-DATE" { + t.Errorf("ValidatePreauth() request=%+v, want planned 2500 hold/date", req) + } + return ErrPreauthUnsupported + }} + _, err := NewService(p).Sale(context.Background(), SaleRequest{Amount: 10000, RequiredPreauth: &paymentapi.PreauthRequirement{Amount: 2500, CheckoutDate: "SYNTH-DATE"}}, nil) + if !errors.Is(err, ErrPreauthUnsupported) || p.saleCalls.Load() != 0 || p.preauthCalls.Load() != 0 { + t.Errorf("Sale(required unsupported hold) error/calls=%v/%d/%d, want unsupported/no dispatch", err, p.saleCalls.Load(), p.preauthCalls.Load()) + } +} + +func TestCMSCurrencyReachesProviderWithoutLocalDefault(t *testing.T) { + p := &testProcessor{entered: make(chan SaleRequest, 1)} + s := NewService(p) + s.SetCurrency("EUR") + if _, err := s.Sale(context.Background(), SaleRequest{Amount: 100, Currency: "GBP"}, nil); err != nil { + t.Fatal(err) + } + if got := (<-p.entered).Currency; got != "EUR" { + t.Errorf("Sale() provider currency=%q, want CMS EUR", got) + } +} diff --git a/internal/paymentsvc/types.go b/internal/paymentsvc/types.go index a496bcd..6807140 100644 --- a/internal/paymentsvc/types.go +++ b/internal/paymentsvc/types.go @@ -1,19 +1,25 @@ package paymentsvc +import "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" + type SaleRequest struct { - RequestID string `json:"requestId"` - Reference string `json:"reference"` - Amount int64 `json:"amount"` - Currency string `json:"currency"` + RequestID string `json:"requestId"` + Reference string `json:"reference"` + Amount int64 `json:"amount"` + Currency string `json:"currency"` + CheckoutDate string `json:"checkoutDate,omitempty"` + RequiredPreauth *paymentapi.PreauthRequirement `json:"requiredPreauth,omitempty"` } 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"` + // Terminal is the provider-independent result exposed by the modern endpoints. + Terminal paymentapi.Result `json:"-"` + 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"` diff --git a/internal/printer/printer.go b/internal/printer/printer.go index 332f2d9..3b99178 100644 --- a/internal/printer/printer.go +++ b/internal/printer/printer.go @@ -55,20 +55,6 @@ type ( CheckOutTimeText string `xml:"CheckOutTimeText"` RoomMapFolderPath string `xml:"RoomMapFolderPath"` } - - RoomTicket struct { - Logo string - TopMostText string - Name string - BeforeRoomNumberText string - RoomID string - BeforeDirectionsText string - Directions string - HotelSpecificDetails string - Map string - CheckOutTimeText string - Checkout string - } ) const ( @@ -220,7 +206,6 @@ func PrintSaleReceipt(receipt string) { 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) } diff --git a/internal/trustpayments/client.go b/internal/trustpayments/client.go new file mode 100644 index 0000000..6681b0d --- /dev/null +++ b/internal/trustpayments/client.go @@ -0,0 +1,276 @@ +// Package trustpayments implements bounded TRU Link calls without financial retries. +package trustpayments + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "github.com/google/uuid" +) + +type Config struct { + BaseURL string + SiteID string + Password string + Terminal string + Currency string + Timezone string + // Transport is an explicit fixture seam; production leaves it nil. + Transport http.RoundTripper +} + +type Client struct { + cfg Config + http *http.Client +} + +func New(cfg Config) (*Client, error) { + u, err := url.Parse(cfg.BaseURL) + if err != nil || u.Scheme != "https" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || + (u.Host != "link.trustpayments.com" && u.Host != "sandbox.link.trustpayments.com") || + strings.TrimRight(u.Path, "/") != "/trustpayments/rest" { + return nil, errors.New("invalid CMS ReservationSystem.PaymentGatewayURL for Trust") + } + for _, field := range []struct{ name, value string }{ + {"ReservationSystem.PaymentGatewaySiteIDEPOS", cfg.SiteID}, + {"ReservationSystem.PaymentGatewayPasswordEPOS", cfg.Password}, + {"ReservationSystem.PDQs.Serial", cfg.Terminal}, + } { + if strings.TrimSpace(field.value) == "" { + return nil, fmt.Errorf("CMS %s is required for Trust", field.name) + } + } + if _, err := time.LoadLocation(cfg.Timezone); err != nil || cfg.Timezone == "" || cfg.Timezone == "Local" { + return nil, errors.New("valid CMS ReservationSystem.TimeZone is required for Trust") + } + return &Client{cfg: cfg, http: &http.Client{Transport: cfg.Transport, Timeout: 300 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return errors.New("Trust redirects prohibited") }}}, nil +} +func (c *Client) ValidRequest(request Request) bool { + return (request.Kind == "sale" || request.Kind == "preauth") && request.Amount > 0 +} + +// Process makes one financial request and at most one observational status call. +// Its reference exists for this attempt only; no restart recovery is provided. +func (c *Client) Process(ctx context.Context, request Request) (Result, error) { + if !c.ValidRequest(request) { + return Result{State: Unknown}, errors.New("invalid or unavailable Trust request") + } + op := Operation{Request: request, RefID: strings.ReplaceAll(uuid.NewString(), "-", ""), TxnDate: c.Timestamp(time.Now())} + ctx, cancel := context.WithTimeout(ctx, 315*time.Second) + defer cancel() + result, err := c.Execute(ctx, op, false) + if (result.State == Unknown || result.State == Pending) && ctx.Err() == nil { + return c.Execute(ctx, op, true) + } + return result, err +} +func (c *Client) Timestamp(t time.Time) string { + loc, _ := time.LoadLocation(c.cfg.Timezone) + return t.In(loc).Format("2006-01-02:15:04:05") +} +func Token(site, date, ref, password string) string { + h := sha256.Sum256([]byte(site + ":" + date + ":" + ref + ":" + password)) + return hex.EncodeToString(h[:]) +} +func Decimal(n int64) string { return fmt.Sprintf("%d.%02d", n/100, n%100) } + +func ParseAmount(s string) (int64, error) { + if s == "" || strings.Trim(s, "0123456789.") != "" { + return 0, errors.New("invalid provider amount") + } + parts := strings.Split(s, ".") + if len(parts) != 2 || len(parts[0]) == 0 || len(parts[1]) != 2 { + return 0, errors.New("invalid provider amount scale") + } + n, err := strconv.ParseInt(parts[0]+parts[1], 10, 64) + if err != nil || n <= 0 { + return 0, errors.New("invalid provider amount range") + } + return n, nil +} + +type response struct { + RefID string `json:"refid"` + Site string `json:"siteid"` + Terminal string `json:"terminalserialnumber"` + Kind string `json:"type"` + Result string `json:"resultcode"` + Amount string `json:"amount"` + Final string `json:"finalamount"` + Error json.RawMessage `json:"error"` + ErrorMessage string `json:"errormessage"` + Code json.RawMessage `json:"errorcode"` + Auth string `json:"authcode"` + Card string `json:"cardtype"` + Last string `json:"last4"` + Receipt string `json:"receipt"` +} + +func safe(s string) string { + if len(s) > 80 || strings.Trim(s, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 -_./") != "" { + return "" + } + return s +} +func receiptFields(s string) (string, string) { + var receipt, sequence string + for _, line := range strings.Split(strings.ReplaceAll(s, "\r\n", "\n"), "\n") { + line = strings.TrimSpace(line) + if strings.HasPrefix(line, "Receipt:") { + receipt = safe(strings.TrimSpace(strings.TrimPrefix(line, "Receipt:"))) + } + if strings.HasPrefix(line, "Sequence number:") { + sequence = safe(strings.TrimSpace(strings.TrimPrefix(line, "Sequence number:"))) + } + } + return receipt, sequence +} +func (c *Client) Execute(ctx context.Context, op Operation, status bool) (Result, error) { + result := Result{State: Unknown, RefID: op.RefID} + if (op.Request.Kind != "sale" && op.Request.Kind != "preauth") || op.Request.Amount <= 0 || op.RefID == "" || op.TxnDate == "" { + return result, errors.New("invalid Trust operation context") + } + payload := map[string]string{"siteid": c.cfg.SiteID, "txndate": op.TxnDate, "refid": op.RefID} + endpoint := "status" + timeout := 15 * time.Second + if !status { + endpoint = op.Request.Kind + timeout = 300 * time.Second + payload["amount"] = Decimal(op.Request.Amount) + payload["type"] = op.Request.Kind + payload["terminalserialnumber"] = c.cfg.Terminal + payload["wait"] = "y" + } + ctx, cancel := context.WithTimeout(ctx, timeout) + defer cancel() + b, err := json.Marshal(payload) + if err != nil { + return result, err + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(c.cfg.BaseURL, "/")+"/"+endpoint, bytes.NewReader(b)) + if err != nil { + return result, errors.New("invalid Trust endpoint") + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("token", Token(c.cfg.SiteID, op.TxnDate, op.RefID, c.cfg.Password)) + resp, err := c.http.Do(req) + if err != nil { + return result, errors.New("Trust transport outcome unavailable") + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + return result, fmt.Errorf("Trust HTTP status %d; financial outcome unknown", resp.StatusCode) + } + data, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024+1)) + if err != nil || len(data) > 1024*1024 { + return result, errors.New("Trust result unreadable") + } + var r response + if err = json.Unmarshal(data, &r); err != nil { + return result, errors.New("Trust result invalid") + } + // Preserve bounded, parsed observations for operator reconciliation without + // representing mismatched values as admitted approval evidence. + if n, e := ParseAmount(r.Amount); e == nil { + result.ObservedAmount = n + result.ObservedAmountKnown = true + } + if n, e := ParseAmount(r.Final); e == nil { + result.ObservedFinalAmount = n + result.ObservedFinalKnown = true + } + code := strings.Trim(string(r.Code), `"`) + if code == "null" { + code = "" + } + if len(code) <= 6 && strings.Trim(code, "0123456789") == "" { + result.Code = code + } + // Duplicate identity, any error code and incomplete responses are never refusals. + if code != "" && code != "0" { + // This attempt never resubmits a financial POST. A duplicate on its first + // dispatch may belong to another owner; Status alone cannot prove that + // ownership when terminal/timestamp evidence is absent. + if code == "1008" || code == "1011" { + result.State = Review + } + return result, nil + } + if (len(r.Error) > 0 && string(r.Error) != "null" && string(r.Error) != "0" && string(r.Error) != "\"\"") || r.ErrorMessage != "" { + return result, nil + } + if r.RefID != op.RefID || r.Site != c.cfg.SiteID || (r.Terminal != "" && r.Terminal != c.cfg.Terminal) || + (status && !strings.EqualFold(r.Kind, op.Request.Kind)) || (!status && r.Terminal != c.cfg.Terminal) || + (r.Kind != "" && !strings.EqualFold(r.Kind, op.Request.Kind)) { + result.State = Review + return result, nil + } + switch strings.ToLower(r.Result) { + case "pending": + result.State = Pending + return result, nil + case "declined": + if r.Auth != "" { + result.State = Review + return result, nil + } + result.State = Declined + return result, nil + case "cancelled": + if r.Auth != "" { + result.State = Review + return result, nil + } + result.State = Cancelled + return result, nil + case "approved": + default: + return result, nil + } + amountText := r.Amount + if status { + amountText = r.Final + } + amount, err := ParseAmount(amountText) + if err != nil || amount != op.Request.Amount { + result.State = Review + return result, nil + } + if r.Final != "" { + final, e := ParseAmount(r.Final) + if e != nil || final != amount { + result.State = Review + return result, nil + } + } + result.State = Approved + result.Amount = amount + // Legacy TRU approval does not validate currency; this is CMS bookkeeping only. + result.Currency = c.cfg.Currency + receipt, sequence := receiptFields(r.Receipt) + result.Metadata = Metadata{Receipt: shortIdentifier(receipt), Sequence: shortIdentifier(sequence), AuthCode: shortIdentifier(r.Auth)} + if len(r.Card) <= 24 && strings.Trim(r.Card, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == "" { + result.Metadata.CardType = r.Card + } + if len(r.Last) == 4 && strings.Trim(r.Last, "0123456789") == "" { + result.Metadata.LastFour = r.Last + } + return result, nil +} +func shortIdentifier(s string) string { + if len(s) > 12 || strings.Trim(s, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_/") != "" { + return "" + } + return s +} diff --git a/internal/trustpayments/client_test.go b/internal/trustpayments/client_test.go new file mode 100644 index 0000000..4a120d5 --- /dev/null +++ b/internal/trustpayments/client_test.go @@ -0,0 +1,137 @@ +package trustpayments + +import ( + "context" + "encoding/json" + "io" + "net/http" + "strings" + "testing" +) + +type transportFunc func(*http.Request) (*http.Response, error) + +func (f transportFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } +func fixtureConfig() Config { + return Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "site", Password: "test-secret", Terminal: "terminal", Currency: "GBP", Timezone: "Europe/London"} +} +func TestTrustSigningMoneyAndConfiguration(t *testing.T) { + if got := Token("123456", "2020-03-01:10:20:05", "7876547", "tv%61w%5"); got != "990bc7bb7efee9e383a96f6f929fd00c90f4ec94f4344270c1552e4d5d4d80c5" { + t.Errorf("Token=%s", got) + } + for _, s := range []string{"", "0.00", "-1.00", "1.001", "1", "NaN", "92233720368547758.08", "1e2"} { + if _, e := ParseAmount(s); e == nil { + t.Errorf("ParseAmount(%q) accepted", s) + } + } + if n, e := ParseAmount("123456.78"); e != nil || Decimal(n) != "123456.78" { + t.Fatalf("money=%d/%v", n, e) + } + for _, url := range []string{"", "http://link.trustpayments.com/trustpayments/rest/", "https://other.invalid/trustpayments/rest/", "https://link.trustpayments.com:443/trustpayments/rest/", "https://link.trustpayments.com/trustpayments/rest/?x=1"} { + cfg := fixtureConfig() + cfg.BaseURL = url + if _, e := New(cfg); e == nil { + t.Errorf("New(%q) accepted", url) + } + } +} +func TestTrustFinancialEvidenceAndUncertainErrors(t *testing.T) { + for _, tc := range []struct { + name string + change func(map[string]any) + status bool + state string + }{ + {"sale", nil, false, Approved}, {"status", nil, true, Approved}, + {"adjusted", func(r map[string]any) { r["finalamount"] = "11.00" }, false, Review}, + {"wrongAmount", func(r map[string]any) { r["amount"] = "9.00" }, false, Review}, + {"providerCurrencyIgnored", func(r map[string]any) { r["currency"] = "EUR" }, false, Approved}, + {"wrongRef", func(r map[string]any) { r["refid"] = "other" }, false, Review}, + {"wrongSite", func(r map[string]any) { r["siteid"] = "other" }, true, Review}, + {"wrongType", func(r map[string]any) { r["type"] = "preauth" }, true, Review}, + {"noAmount", func(r map[string]any) { delete(r, "finalamount") }, true, Review}, + {"declined", func(r map[string]any) { r["resultcode"] = "Declined"; delete(r, "authcode") }, false, Declined}, + {"cancelled", func(r map[string]any) { r["resultcode"] = "Cancelled"; delete(r, "authcode") }, false, Cancelled}, + {"pending", func(r map[string]any) { r["resultcode"] = "Pending" }, false, Pending}, + {"2003", func(r map[string]any) { r["errorcode"] = 2003 }, false, Unknown}, + {"2005", func(r map[string]any) { r["errorcode"] = "2005" }, false, Unknown}, + {"2006", func(r map[string]any) { r["errorcode"] = 2006 }, false, Unknown}, + {"1011", func(r map[string]any) { r["errorcode"] = 1011 }, false, Review}, + {"1008", func(r map[string]any) { r["errorcode"] = 1008 }, false, Review}, + {"offline", func(r map[string]any) { r["resultcode"] = "Terminal Busy" }, false, Unknown}, + } { + t.Run(tc.name, func(t *testing.T) { + cfg := fixtureConfig() + calls := 0 + cfg.Transport = transportFunc(func(req *http.Request) (*http.Response, error) { + calls++ + var input map[string]string + if e := json.NewDecoder(req.Body).Decode(&input); e != nil { + t.Fatal(e) + } + if input["txndate"] != "2026-10-23:12:00:00" || req.Header.Get("token") != Token(cfg.SiteID, input["txndate"], "ref", cfg.Password) { + t.Error("signing context changed") + } + if !tc.status && (input["wait"] != "y" || input["amount"] != "10.00") { + t.Error("incorrect financial payload") + } + r := map[string]any{"refid": "ref", "siteid": "site", "terminalserialnumber": "terminal", "type": "sale", "amount": "10.00", "finalamount": "10.00", "resultcode": "Approved", "receipt": "Sequence number: 42\r\nReceipt: 31\r\nPAN: 4111111111111111", "authcode": "123456", "cardtype": "Visa", "last4": "1133"} + if tc.change != nil { + tc.change(r) + } + b, _ := json.Marshal(r) + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(b)))}, nil + }) + c, e := New(cfg) + if e != nil { + t.Fatal(e) + } + result, e := c.Execute(context.Background(), Operation{RefID: "ref", TxnDate: "2026-10-23:12:00:00", Request: Request{Kind: "sale", Amount: 1000, Currency: "GBP"}}, tc.status) + if e != nil || result.State != tc.state || calls != 1 { + t.Fatalf("Execute=%+v/%v, calls=%d, want %s/1", result, e, calls, tc.state) + } + if result.State == Approved && (result.Metadata.Receipt != "31" || result.Metadata.Sequence != "42" || result.Metadata.LastFour != "1133") { + t.Error("metadata lost") + } + if result.State == Approved && result.Currency != cfg.Currency { + t.Errorf("currency metadata=%q, want CMS currency %q", result.Currency, cfg.Currency) + } + if tc.name == "adjusted" && (!result.ObservedFinalKnown || result.ObservedFinalAmount != 1100 || result.Amount != 0) { + t.Fatal("financial mismatch evidence was lost or admitted") + } + b, _ := json.Marshal(result) + if strings.Contains(string(b), "4111111111111111") || strings.Contains(string(b), cfg.Password) { + t.Error("sensitive data escaped") + } + }) + } + cfg := fixtureConfig() + c, _ := New(cfg) + r, e := c.Execute(context.Background(), Operation{}, false) + if e == nil || r.State == Approved { + t.Fatal("invalid operation admitted") + } +} +func TestTrustTransportHTTPAndMalformedResultsRemainUnknown(t *testing.T) { + for _, tc := range []struct { + name, body string + status int + }{{"http500", `{"resultcode":"Approved"}`, 500}, {"http401", "", 401}, {"malformed", "{", 200}, {"empty", "{}", 200}, {"unexpectedError", `{"resultcode":"Approved","error":"private-token"}`, 200}} { + t.Run(tc.name, func(t *testing.T) { + cfg := fixtureConfig() + calls := 0 + cfg.Transport = transportFunc(func(*http.Request) (*http.Response, error) { + calls++ + return &http.Response{StatusCode: tc.status, Body: io.NopCloser(strings.NewReader(tc.body))}, nil + }) + c, e := New(cfg) + if e != nil { + t.Fatal(e) + } + r, _ := c.Execute(context.Background(), Operation{RefID: "ref", TxnDate: "2026-10-23:12:00:00", Request: Request{Kind: "sale", Amount: 1000, Currency: "GBP"}}, false) + if r.State == Approved || r.State == Declined || calls != 1 { + t.Fatalf("uncertain=%+v calls=%d", r, calls) + } + }) + } +} diff --git a/internal/trustpayments/cms_currency_test.go b/internal/trustpayments/cms_currency_test.go new file mode 100644 index 0000000..a8bf6c2 --- /dev/null +++ b/internal/trustpayments/cms_currency_test.go @@ -0,0 +1,54 @@ +package trustpayments + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + "testing" +) + +func TestLegacyTrustCurrencyDoesNotDetermineApproval(t *testing.T) { + for _, providerCurrency := range []any{nil, "", "GBP", "EUR", "NOT-AN-ISO-CODE", 123, map[string]any{"unexpected": "value"}} { + t.Run(fmt.Sprint("provider=", providerCurrency), func(t *testing.T) { + cfg := fixtureConfig() + cfg.Transport = transportFunc(func(r *http.Request) (*http.Response, error) { + var input map[string]string + if err := json.NewDecoder(r.Body).Decode(&input); err != nil { + return nil, err + } + if _, exists := input["currency"]; exists { + t.Error("TRU request gained a currency field") + } + body, _ := json.Marshal(map[string]any{"refid": "SYNTH-REF", "siteid": cfg.SiteID, "terminalserialnumber": cfg.Terminal, "type": "sale", "resultcode": "Approved", "amount": "25.00", "currency": providerCurrency}) + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body)))}, nil + }) + client, err := New(cfg) + if err != nil { + t.Fatal(err) + } + op := Operation{RefID: "SYNTH-REF", TxnDate: "2026-11-03:12:00:00", Request: Request{Kind: "sale", Amount: 2500, Currency: "REQUEST-CURRENCY-IS-NOT-A-GATE"}} + result, err := client.Execute(context.Background(), op, false) + if err != nil || result.State != Approved || result.Amount != 2500 || result.Currency != cfg.Currency { + t.Fatalf("Execute(provider currency %v)=%+v/%v, want approval and CMS bookkeeping only", providerCurrency, result, err) + } + }) + } +} + +func TestCMSCurrencyIsMetadataNotAClientValidationFlag(t *testing.T) { + for _, currency := range []string{"", "GBP", "NOT-AN-ISO-CODE"} { + cfg := fixtureConfig() + cfg.Currency = currency + client, err := New(cfg) + if err != nil { + t.Errorf("New(CMS currency %q)=%v, want no Trust currency gate", currency, err) + continue + } + if !client.ValidRequest(Request{Kind: "preauth", Amount: 2500, Currency: "different"}) { + t.Errorf("ValidRequest(CMS currency %q) imposed currency validation", currency) + } + } +} diff --git a/internal/trustpayments/process_test.go b/internal/trustpayments/process_test.go new file mode 100644 index 0000000..7751a4f --- /dev/null +++ b/internal/trustpayments/process_test.go @@ -0,0 +1,110 @@ +package trustpayments + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "strings" + "testing" + "time" +) + +func TestTrustProcessOneFinancialPostAndBoundedStatus(t *testing.T) { + for _, first := range []string{"Approved", "Declined", "Cancelled", "Pending", "2003", "2005", "2006", "transport", "1011", "mismatch"} { + t.Run(first, func(t *testing.T) { + cfg := fixtureConfig() + var ref, timestamp string + financial, status := 0, 0 + cfg.Transport = transportFunc(func(r *http.Request) (*http.Response, error) { + var input map[string]string + if err := json.NewDecoder(r.Body).Decode(&input); err != nil { + t.Fatal(err) + } + lookup := strings.HasSuffix(r.URL.Path, "/status") + deadline, ok := r.Context().Deadline() + remaining := time.Until(deadline) + if !lookup { + financial++ + ref, timestamp = input["refid"], input["txndate"] + if !ok || remaining > 300*time.Second || remaining < 299*time.Second || input["wait"] != "y" { + t.Errorf("financial deadline/payload=%s/%v", remaining, input) + } + } else { + status++ + if input["refid"] != ref || input["txndate"] != timestamp || !ok || remaining > 15*time.Second || remaining < 14*time.Second || input["amount"] != "" { + t.Errorf("status changed identity/budget/payload=%s/%v", remaining, input) + } + } + if !lookup && first == "transport" { + return nil, errors.New("synthetic disconnected provider") + } + body := map[string]any{"refid": ref, "siteid": "site", "terminalserialnumber": "terminal", "type": "sale", "amount": "10.00", "finalamount": "10.00", "resultcode": "Approved", "authcode": "123456"} + if !lookup { + switch first { + case "Declined", "Cancelled": + body["resultcode"], body["authcode"] = first, "" + case "Pending": + body["resultcode"] = first + case "2003", "2005", "2006", "1011": + body["errorcode"] = first + case "mismatch": + body["amount"] = "9.00" + } + } + encoded, _ := json.Marshal(body) + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(encoded)))}, nil + }) + client, err := New(cfg) + if err != nil { + t.Fatal(err) + } + result, err := client.Process(context.Background(), Request{Kind: "sale", Amount: 1000, Currency: "GBP"}) + wantStatus := 0 + if first == "Pending" || first == "transport" || first == "2003" || first == "2005" || first == "2006" { + wantStatus = 1 + } + want := Approved + if first == "Declined" { + want = Declined + } + if first == "Cancelled" { + want = Cancelled + } + if first == "1011" || first == "mismatch" { + want = Review + } + if err != nil || financial != 1 || status != wantStatus || result.State != want || len(ref) != 32 { + t.Fatalf("Process(%s) state/error/posts/status=%s/%v/%d/%d, want %s/nil/1/%d", first, result.State, err, financial, status, want, wantStatus) + } + }) + } +} + +func TestTrustProcessStatusStillUnknownAndPreauth(t *testing.T) { + for _, kind := range []string{"sale", "preauth"} { + t.Run(kind, func(t *testing.T) { + cfg := fixtureConfig() + calls := 0 + cfg.Transport = transportFunc(func(r *http.Request) (*http.Response, error) { + calls++ + if calls == 1 && !strings.HasSuffix(r.URL.Path, "/"+kind) { + t.Errorf("provider endpoint=%s", r.URL.Path) + } + if calls == 2 && !strings.HasSuffix(r.URL.Path, "/status") { + t.Errorf("second call=%s, want status", r.URL.Path) + } + return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"errorcode":2003}`))}, nil + }) + client, err := New(cfg) + if err != nil { + t.Fatal(err) + } + result, err := client.Process(context.Background(), Request{Kind: kind, Amount: 2500, Currency: "GBP"}) + if err != nil || result.State != Unknown || calls != 2 { + t.Fatalf("unresolved result=%+v/%v calls=%d", result, err, calls) + } + }) + } +} diff --git a/internal/trustpayments/processor.go b/internal/trustpayments/processor.go new file mode 100644 index 0000000..d613db4 --- /dev/null +++ b/internal/trustpayments/processor.go @@ -0,0 +1,77 @@ +package trustpayments + +import ( + "context" + "fmt" + "net/http" + + "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc" + "gitea.futuresens.co.uk/futuresens/hardlink/internal/printer" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi" + "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus" + log "github.com/sirupsen/logrus" +) + +// Processor owns Trust execution and terminal receipt printing. +type Processor struct { + Client *Client + PrintReceipt func(string) +} + +func (p *Processor) ValidatePreauth(req paymentsvc.SaleRequest) error { + if p.Client == nil || !p.Client.ValidRequest(Request{Kind: "preauth", Amount: req.Amount}) { + return paymentsvc.ErrPreauthUnsupported + } + return nil +} +func (p *Processor) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return p.run(ctx, req, status, "sale") +} +func (p *Processor) Preauth(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) { + return p.run(ctx, req, status, "preauth") +} +func (p *Processor) run(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler, kind string) (*paymentsvc.Result, error) { + for _, code := range []string{paymentstatus.Starting, paymentstatus.RequestSent, paymentstatus.Processing} { + if status != nil { + status(paymentsvc.StatusUpdate{Code: code}) + } + } + result, err := p.Client.Process(ctx, Request{Kind: kind, Amount: req.Amount, Currency: req.Currency}) + final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "TrustPayments", Message: "Payment outcome uncertain; contact reception", TransactionReference: result.RefID} + switch result.State { + case Approved: + final.Outcome, final.Message = "approved", "Payment approved" + final.AmountMinor, final.CurrencyCode = result.Amount, result.Currency + m := result.Metadata + final.ReceiptNumber, final.SequenceNumber, final.AuthorizationCode = m.Receipt, m.Sequence, m.AuthCode + final.CardType, final.LastFour = m.CardType, m.LastFour + receipt := fmt.Sprintf("Trust Payments\n%s %s\n%s\nCard ************%s", Decimal(result.Amount), result.Currency, m.Description(result.RefID), m.LastFour) + if p.PrintReceipt != nil { + p.PrintReceipt(receipt) + } else { + printer.PrintSaleReceipt(receipt) + } + case Declined: + final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined" + case Cancelled: + final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled" + } + if final.Outcome != "unknown" { + err = nil + } else { + fields := log.Fields{ + "provider": final.Provider, "operation": kind, "outcome": final.Outcome, + "request_id": req.RequestID, "request_reference": req.Reference, + "transaction_reference": result.RefID, "provider_state": result.State, + "provider_code": result.Code, "error_category": paymentsvc.SafeErrorCategory(err), + } + if result.ObservedAmountKnown { + fields["observed_amount_minor"] = result.ObservedAmount + } + if result.ObservedFinalKnown { + fields["observed_final_amount_minor"] = result.ObservedFinalAmount + } + log.WithFields(fields).Warn("Trust payment outcome requires reception reconciliation") + } + return &paymentsvc.Result{Terminal: final}, err +} diff --git a/internal/trustpayments/types.go b/internal/trustpayments/types.go new file mode 100644 index 0000000..19bbd5a --- /dev/null +++ b/internal/trustpayments/types.go @@ -0,0 +1,44 @@ +package trustpayments + +// These are provider-call values, not persistent operations or kiosk sessions. +const ( + Approved = "APPROVED_VALIDATED" + Declined = "DECLINED" + Cancelled = "CANCELLED" + Pending = "PENDING" + Unknown = "UNKNOWN" + Review = "REVIEW_REQUIRED" +) + +type Request struct { + Kind string + Amount int64 + Currency string +} + +type Operation struct { + Request Request + RefID, TxnDate string +} + +type Metadata struct { + Receipt, Sequence, AuthCode, CardType, LastFour string +} + +func (m Metadata) Description(ref string) string { + s := "Tx " + ref + for _, v := range [][2]string{{"Rec", m.Receipt}, {"Seq", m.Sequence}, {"Hash", m.AuthCode}, {"Ref", m.CardType + m.LastFour}} { + if v[1] != "" { + s += " " + v[0] + " " + v[1] + } + } + return s +} + +type Result struct { + State, RefID, Currency, Code string + Amount int64 + Metadata Metadata + ObservedAmount, ObservedFinalAmount int64 + ObservedAmountKnown, ObservedFinalKnown bool +} diff --git a/paymentapi/client.go b/paymentapi/client.go new file mode 100644 index 0000000..d057f7a --- /dev/null +++ b/paymentapi/client.go @@ -0,0 +1,116 @@ +package paymentapi + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "strings" +) + +// Execute sends exactly one request. Missing, malformed or interrupted results are +// uncertain; this client never retries a financial request. +func Execute(ctx context.Context, client *http.Client, baseURL, operation string, request Request, onStatus func(string)) (Result, error) { + var path string + switch operation { + case Sale: + path = SalePath + if request.Amount <= 0 { + return Result{}, errors.New("sale amount must be positive") + } + case Preauth: + path = PreauthPath + if request.Amount < 0 { + return Result{}, errors.New("preauth amount must not be negative") + } + default: + return Result{}, errors.New("invalid terminal operation") + } + if client == nil || strings.TrimSpace(baseURL) == "" { + return Result{}, errors.New("terminal client is not configured") + } + body, err := json.Marshal(request) + if err != nil { + return Result{}, fmt.Errorf("encode terminal request: %w", err) + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, `/\`)+path, bytes.NewReader(body)) + if err != nil { + return Result{}, errors.New("invalid terminal endpoint") + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/x-ndjson") + response, err := client.Do(req) + if err != nil { + if ctx.Err() != nil { + return Result{}, fmt.Errorf("terminal request interrupted: %w", ctx.Err()) + } + if errors.Is(err, context.DeadlineExceeded) { + return Result{}, fmt.Errorf("terminal request interrupted: %w", context.DeadlineExceeded) + } + if errors.Is(err, context.Canceled) { + return Result{}, fmt.Errorf("terminal request interrupted: %w", context.Canceled) + } + // Do not expose a transport error that may contain a URL or raw payload. + return Result{}, errors.New("terminal request failed; outcome is uncertain") + } + defer response.Body.Close() + if !strings.HasPrefix(response.Header.Get("Content-Type"), "application/x-ndjson") { + return Result{}, fmt.Errorf("terminal returned an invalid response contract (HTTP %d)", response.StatusCode) + } + decoder := json.NewDecoder(response.Body) + for { + var frame struct { + Frame + Legacy json.RawMessage `json:"response"` + } + if err := decoder.Decode(&frame); err != nil { + if ctx.Err() != nil { + return Result{}, fmt.Errorf("terminal stream interrupted: %w", ctx.Err()) + } + if errors.Is(err, io.EOF) { + return Result{}, errors.New("terminal stream ended before a final result") + } + return Result{}, errors.New("terminal stream is invalid; outcome is uncertain") + } + if len(frame.Legacy) != 0 { + return Result{}, errors.New("terminal returned a legacy result contract") + } + switch frame.Type { + case "status": + if frame.Code == "" || frame.Result != nil { + return Result{}, errors.New("invalid terminal status frame") + } + if onStatus != nil { + onStatus(frame.Code) + } + case "result": + if frame.Result == nil || frame.Code != "" { + return Result{}, errors.New("invalid terminal result frame") + } + result := *frame.Result + switch result.Outcome { + case "approved", "declined", "cancelled", "timeout", "error", "unknown": + default: + return Result{}, errors.New("invalid terminal outcome") + } + if result.HTTPStatus < 100 || result.HTTPStatus > 599 { + return Result{}, errors.New("invalid terminal operation status") + } + if result.Outcome == "approved" && (result.HTTPStatus < 200 || result.HTTPStatus >= 300 || response.StatusCode < 200 || response.StatusCode >= 300 || result.Retryable) { + return Result{}, errors.New("contradictory terminal approval") + } + if result.Outcome == "unknown" && result.Retryable { + return Result{}, errors.New("uncertain terminal result cannot permit retry") + } + if response.StatusCode < 200 || response.StatusCode >= 300 || result.HTTPStatus < 200 || result.HTTPStatus >= 300 { + return result, fmt.Errorf("terminal operation failed (HTTP %d, operation %d)", response.StatusCode, result.HTTPStatus) + } + return result, nil + default: + return Result{}, errors.New("invalid terminal frame type") + } + } +} diff --git a/paymentapi/client_test.go b/paymentapi/client_test.go new file mode 100644 index 0000000..282ee68 --- /dev/null +++ b/paymentapi/client_test.go @@ -0,0 +1,146 @@ +package paymentapi + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "testing" +) + +func TestExecuteUsesOneContractForSaleAndPreauth(t *testing.T) { + for _, operation := range []string{Sale, Preauth} { + t.Run(operation, func(t *testing.T) { + input := Request{Reference: "SYNTH-BOOK", Amount: 2500, Currency: "GBP", CheckoutDate: "12 Oct 2030"} + if operation == Sale { + input.RequiredPreauth = &PreauthRequirement{Amount: 5000, CheckoutDate: "12 Oct 2030"} + } + calls := 0 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + calls++ + if r.Method != http.MethodPost || r.URL.Path != "/api/payment/"+operation { + t.Errorf("Execute(%q) sent %s %s, want POST modern operation", operation, r.Method, r.URL.Path) + } + var got Request + if err := json.NewDecoder(r.Body).Decode(&got); err != nil { + t.Error(err) + return + } + if !reflect.DeepEqual(got, input) { + t.Errorf("Execute(%q) request=%+v, want %+v", operation, got, input) + } + if r.Header.Get("Accept") != "application/x-ndjson" || r.Header.Get("Content-Type") != "application/json" { + t.Errorf("Execute(%q) headers=%v, want JSON request/NDJSON response", operation, r.Header) + } + w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8") + encoder := json.NewEncoder(w) + for _, frame := range []Frame{{Type: "status", Code: "PAYMENT_PROCESSING"}, {Type: "status", Code: "FUTURE_OBSERVATIONAL_CODE"}, {Type: "result", Result: &Result{Outcome: "approved", HTTPStatus: 200, Provider: "FutureProcessor", AmountMinor: 2500, TransactionReference: "SYNTH-REFERENCE", CardType: "Visa"}}} { + if err := encoder.Encode(frame); err != nil { + t.Error(err) + return + } + } + })) + t.Cleanup(server.Close) + var progress []string + got, err := Execute(context.Background(), server.Client(), server.URL, operation, input, func(code string) { progress = append(progress, code) }) + if err != nil || got.Outcome != "approved" || got.TransactionReference != "SYNTH-REFERENCE" || calls != 1 { + t.Fatalf("Execute(%q)=%+v/%v calls=%d, want one approved request", operation, got, err, calls) + } + if !reflect.DeepEqual(progress, []string{"PAYMENT_PROCESSING", "FUTURE_OBSERVATIONAL_CODE"}) { + t.Errorf("Execute(%q) progress=%v, want observed codes in order", operation, progress) + } + }) + } +} + +type testTransport func(*http.Request) (*http.Response, error) + +func (f testTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +type trackedBody struct { + io.Reader + closed bool +} + +func (b *trackedBody) Close() error { b.closed = true; return nil } + +func TestExecuteRejectsIncompleteOrContradictoryResultsAndClosesBodies(t *testing.T) { + tests := []struct { + name, body string + status int + }{ + {"eof", `{"type":"status","code":"PAYMENT_APPROVED"}`, 200}, + {"malformed", `{"type":`, 200}, + {"legacy", `{"type":"result","response":{"status":{"code":200},"data":"/successful"}}`, 200}, + {"mixed", `{"type":"result","result":{"outcome":"approved","httpStatus":200},"response":{}}`, 200}, + {"empty_status", `{"type":"status","code":""}`, 200}, + {"status_result", `{"type":"status","code":"X","result":{"outcome":"approved","httpStatus":200}}`, 200}, + {"unknown_frame", `{"type":"other"}`, 200}, + {"unknown_outcome", `{"type":"result","result":{"outcome":"maybe","httpStatus":200}}`, 200}, + {"invalid_status", `{"type":"result","result":{"outcome":"approved","httpStatus":0}}`, 200}, + {"http_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":200}}`, 502}, + {"operation_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":502}}`, 200}, + {"retryable_approval", `{"type":"result","result":{"outcome":"approved","httpStatus":200,"retryable":true}}`, 200}, + {"retryable_unknown", `{"type":"result","result":{"outcome":"unknown","httpStatus":200,"retryable":true}}`, 200}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + body := &trackedBody{Reader: strings.NewReader(test.body)} + calls := 0 + client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { + calls++ + return &http.Response{StatusCode: test.status, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: body}, nil + })} + _, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) + if err == nil || !body.closed || calls != 1 { + t.Errorf("Execute(%s) error=%v closed=%t calls=%d, want error/closed/one request", test.name, err, body.closed, calls) + } + }) + } +} + +func TestExecuteProgressCannotApproveOrRetryUnknown(t *testing.T) { + client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { + return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: io.NopCloser(strings.NewReader("{\"type\":\"status\",\"code\":\"PAYMENT_APPROVED\"}\n{\"type\":\"result\",\"result\":{\"outcome\":\"unknown\",\"httpStatus\":200}}"))}, nil + })} + got, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) + if err != nil || got.Outcome != "unknown" || got.Retryable { + t.Errorf("Execute(progress approved then unknown)=%+v/%v, want nonretryable unknown", got, err) + } +} + +func TestExecutePreservesCancellationWithoutLeakingTransportDiagnostics(t *testing.T) { + for _, cause := range []error{context.Canceled, context.DeadlineExceeded} { + t.Run(cause.Error(), func(t *testing.T) { + calls := 0 + client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { + calls++ + return nil, fmt.Errorf("synthetic-private-payload: %w", cause) + })} + _, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) + if !errors.Is(err, cause) || strings.Contains(err.Error(), "synthetic-private-payload") || calls != 1 { + t.Errorf("Execute(transport %v)=%v calls=%d, want sanitized wrapped cause and one attempt", cause, err, calls) + } + }) + } +} + +func TestExecuteRejectsInvalidRequestsWithoutDispatch(t *testing.T) { + for _, test := range []struct { + operation string + amount int64 + }{{Sale, 0}, {Sale, -1}, {Preauth, -1}, {"refund", 1}} { + calls := 0 + client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { calls++; return nil, errors.New("must not dispatch") })} + _, err := Execute(context.Background(), client, "http://synthetic.invalid", test.operation, Request{Amount: test.amount}, nil) + if err == nil || calls != 0 { + t.Errorf("Execute(%q,%d) error=%v calls=%d, want validation error without dispatch", test.operation, test.amount, err, calls) + } + } +} diff --git a/paymentapi/types.go b/paymentapi/types.go new file mode 100644 index 0000000..b9bb4a7 --- /dev/null +++ b/paymentapi/types.go @@ -0,0 +1,55 @@ +// Package paymentapi defines the modern Hardlink terminal contract and its HTTP client. +// It contains no provider selection, PMS posting or guest-journey logic. +package paymentapi + +const ( + Sale = "sale" + Preauth = "preauth" + SalePath = "/api/payment/sale" + PreauthPath = "/api/payment/preauth" +) + +// PreauthRequirement describes a later required hold; validating it never executes it. +type PreauthRequirement struct { + Amount int64 `json:"amount"` + CheckoutDate string `json:"checkoutDate,omitempty"` +} + +// Request uses integer minor units and currency supplied by CMS. +type Request struct { + Reference string `json:"reference,omitempty"` + Amount int64 `json:"amount"` + Currency string `json:"currency,omitempty"` + CheckoutDate string `json:"checkoutDate,omitempty"` + RequiredPreauth *PreauthRequirement `json:"requiredPreauth,omitempty"` +} + +// Result is authoritative terminal outcome and metadata, never a PMS description. +// CurrencyCode is configured bookkeeping currency, not settlement-currency evidence. +type Result struct { + Outcome string `json:"outcome"` + HTTPStatus int `json:"httpStatus"` + Reason string `json:"reason,omitempty"` + Retryable bool `json:"retryable"` + Message string `json:"message,omitempty"` + Provider string `json:"provider,omitempty"` + AmountMinor int64 `json:"amountMinor"` + CurrencyCode string `json:"currencyCode,omitempty"` + 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"` + ReceiptNumber string `json:"receiptNumber,omitempty"` + SequenceNumber string `json:"sequenceNumber,omitempty"` + AuthorizationCode string `json:"authorizationCode,omitempty"` + LastFour string `json:"lastFour,omitempty"` +} + +// Frame carries observational progress or one final result. +type Frame struct { + Type string `json:"type"` + Code string `json:"code,omitempty"` + Result *Result `json:"result,omitempty"` +} diff --git a/paymentstatus/status.go b/paymentstatus/status.go index ba48c3e..e0362fc 100644 --- a/paymentstatus/status.go +++ b/paymentstatus/status.go @@ -1,7 +1,6 @@ // 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. +// modern Sale/PREAUTH streams. Progress codes are not final transaction decisions; +// clients must use the structured result frame and their PMS completion rules. package paymentstatus const ( diff --git a/release notes.md b/release notes.md deleted file mode 100644 index 329ef6f..0000000 --- a/release notes.md +++ /dev/null @@ -1,203 +0,0 @@ -## Release notes - -builtVersion is a const in main.go - -#### v2.1.5 - 22 October 2026 -feat(dispenser): recover K720 card position during uncertain encoding - -#### v2.1.4 - 19 October 2026 -added detailed logging for preauth payment processing and result streaming - -#### v2.1.3 - 30 September 2026 -feat(logging): add weekly log rotation and retention - -#### v2.1.2 - 30 September 2026 -fix(dispenser): scan ACK responses without assuming 3-byte reads - -#### v2.1.1 - 28 September 2026 -feat(dispenser): add worker-owned idle card prestaging - -#### v2.1.0 - 28 September 2026 -fix(dispenser): tolerate unusable AP observations during card preparation - -#### v2.0.3 - 24 September 2026 -fix(dispenser): recover stuck card preparation with reset - -#### v2.0.2 - 22 September 2026 -fix(dispenser): retry on transient prepare failure - -#### 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 -added sending the email on the pdq disconnect event to notify support about the issue -added sending the email on the dispenser error status to notify support about the issue - -#### 1.1.3 - 02 February 2026 -increased timeout for reading response from the Assa abloy lock server to 20 seconds - -#### 1.1.2 - 02 February 2026 -added logging for unknown dispenser status positions - -#### 1.1.1 - 02 February 2026 -added contionuous polling of the dispenser status every 8 seconds to update the card well status - -#### 1.1.0 - 26 January 2026 -divided `/starttransaction` endpoint into two separate endpoints: - `/takepreauth` to request preauthorization payment - `/takepayment` to request taking payment -added preauth releaser functionality to release preauthorization payments after a defined time period -added db connection check before adding a transaction to the database -and reconnection functionality if the connection to the database is lost -added `/dispenserstatus` endpoint -key card always stays at encoder position - -#### 1.0.30 - 09 January 2026 -improved logging for preauth releaser - -#### 1.0.29 - 08 January 2026 -added count down before exiting the preauth releaser 20 seconds - -#### 1.0.28 - 10 December 2025 -added preauth releaser - -#### 1.0.27 - 10 December 2025 -updated handling AmountTooSmall response from creditcall - -#### 1.0.26 - 10 December 2025 -added route for taking preauthorization payment - -#### 1.0.25 - 08 December 2025 -return masked card number and expiry date in the payment success URL - -#### 1.0.24 - 13 November 2025 -improved logging for creditcall payment processing - -#### 1.0.23 - 13 November 2025 -moved handlers from main.go to handlers/handlers.go - -#### 1.0.22 - 13 November 2025 -added test mode into config file to allow testing without connecting to the dispenser - -#### 1.0.21 - 20 October 2025 -increased timeout for Salto lock server connection to 40 seconds - -#### 1.0.20 - 06 October 2025 -removed minutes from the start and expiry time in Salto lock command - -#### 1.0.19 - 10 September 2025 -allowed to continue if the connection to the lock server fails at startup - -#### 1.0.18 - 04 September 2025 -increased timeout for TLJ lock server connection to 30 seconds - -#### 1.0.17 - 30 August 2025 -added functionality to commit transactions - -#### 1.0.15 - 27 August 2025 -fixed TCP/IP connection to the lock server - -#### 1.0.14 - 21 August 2025 -fixed issue in creditcall payment processing where error description was not properly set - -#### 1.0.13 - 21 August 2025 -TCP/IP connection to the lock server is now established before encoding the keycard and closedafter the encoding is done. - -#### 1.0.12 - 11 August 2025 -added delay before checking dispenser status - -#### 1.0.11 - 11 August 2025 -updated Salto key encoding workflow - -#### 1.0.10 - 08 August 2025 -updated logging for TLJ locks - -#### 1.0.9 - 08 August 2025 -added TLJ lock server and implemented workflow for TLJ locks - -#### 1.0.8 - 01 August 2025 -improved error handling and logging in Salto - -#### 1.0.7 - 25 July 2025 -added check if the room exists - -#### 1.0.6 - 25 July 2025 -updated workflow for Salto locks - -#### 1.0.5 - 24 July 2025 -added encoding keycard copy for Salto locks - -#### 1.0.4 - 22 July 2025 -added salto lock server and implemented workflow for Salto - -#### 1.0.0 - 30 June 2025 -added creditcall payment method - `/starttransaction` - API payment endpoint to start a transaction - -#### 0.9.1 - 22 May 2025 -added lockserver interface and implemented workflow for Omnitec - -#### 0.9.0 - 22 May 2025 -The new API has two new endpoints: -- `/issuedoorcard` - encoding the door card for the room. -- `/printroomticket` - printing the room ticket. \ No newline at end of file