Compare commits

...
12 Commits
50 changed files with 4631 additions and 460 deletions
+1 -1
View File
@@ -42,6 +42,6 @@ _cgo_export.*
_testmain.go
*.exe
*.exe*
*.test
*.prof
+328
View File
@@ -0,0 +1,328 @@
package main
import (
"context"
"fmt"
"net/http"
"os"
"os/exec"
"os/signal"
"strings"
"syscall"
"time"
"github.com/tarm/serial"
log "github.com/sirupsen/logrus"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/cms"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dojo"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/handlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/logging"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paybridge"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
)
const (
buildVersion = "v1.3.6"
serviceName = "hardlink"
pollingFrequency = 8 * time.Second
)
func main() {
// Load config
cfg := config.ReadHardlinkConfig()
printer.PrinterName = cfg.PrinterName
lockserver.Cert = cfg.Cert
lockserver.LockServerURL = cfg.LockserverURL
mail.SendErrorEmails = cfg.SendErrorEmails
// Root context for background goroutines
// rootCtx, rootCancel := context.WithCancel(context.Background())
// defer rootCancel()
var (
dispPort *serial.Port
disp *dispenser.Client
cardWellStatus string
)
// Setup logging and get file handle
logFile, err := logging.SetupLogging(cfg.LogDir, serviceName, buildVersion)
if err != nil {
log.Printf("Failed to set up logging: %v\n", err)
}
if logFile != nil {
defer logFile.Close()
}
// Initialize dispenser
if !cfg.TestMode {
dispenser.SerialPort = cfg.DispenserPort
dispenser.Address = []byte(cfg.DispenserAdrr)
dispPort, err = dispenser.InitializeDispenser()
if err != nil {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dispenser Initialization Error", fmt.Errorf("failed to initialize dispenser: %v", err))
}
defer dispPort.Close()
disp = dispenser.NewClient(dispPort, 32)
defer disp.Close()
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
cardWellStatus, err = disp.DispenserPrepare(ctx)
if err != nil {
err = fmt.Errorf("%s; wrong dispenser address: %s", err, cfg.DispenserAdrr)
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dispenser Preparation Error", err)
}
fmt.Println(cardWellStatus)
}
// Test lock-server connection
switch strings.ToLower(cfg.LockType) {
case lockserver.TLJ:
// TLJ uses HTTP - skip TCP probe here
default:
lockConn, err := lockserver.InitializeServerConnection(cfg.LockserverURL)
if err != nil {
fmt.Println(err.Error())
log.Errorf(err.Error())
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Lock Server Connection Error", err.Error())
} else {
fmt.Printf("Connected to the lock server successfuly at %s\n", cfg.LockserverURL)
log.Infof("Connected to the lock server successfuly at %s", cfg.LockserverURL)
lockConn.Close()
}
}
database, err := bootstrap.OpenDB(&cfg)
if err != nil {
log.Warnf("DB init failed: %v", err)
}
if database != nil {
defer database.Close()
}
// Create App and wire routes
app := handlers.NewApp(disp, cfg.LockType, cfg.EncoderAddress, cardWellStatus, database, &cfg)
if cfg.IsPayment {
fmt.Println("Payment processing is enabled")
log.Info("Payment processing is enabled")
var provider paymentsvc.Provider
reservationSystem, err := cms.ReadHotel(cfg.Hotel, cfg.CMSBaseURL)
if err != nil {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to read hotel from CMS", fmt.Errorf("failed to read hotel from CMS: %v", err))
}
paymentProvider := reservationSystem.PaymentSystem
if paymentProvider == 0 {
paymentProvider = cms.PaymentSystemIndex(cfg.PaymentProvider)
}
switch paymentProvider {
case cmstypes.PaySystemCreditCall:
// CreditCall keeps using the existing /takepayment and /takepreauth endpoints.
startChipDnaClient()
go func() {
time.Sleep(30 * time.Second)
pdqStatus, err := creditcall.ReadPdqStatus(cfg.Hotel, cfg.Kiosk)
if err != nil {
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "PDQ Status Read Error", err.Error())
return
}
fmt.Printf("\nPDQ available: %v\n", pdqStatus.IsAvailable)
log.Infof("PDQ available: %v", pdqStatus.IsAvailable)
}()
log.Info("CreditCall payment provider enabled")
fmt.Println("CreditCall payment provider enabled")
case cmstypes.PaySystemPayBridge:
websocketURL := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
if websocketURL == "" {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "PayBridge websocket URL not found", fmt.Errorf("payment provider paybridge requires paybridge.websocket_url"))
}
if reservationSystem.PaymentGatewayAPIKeyWeb == "" {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway API Key not found", fmt.Errorf("payment provider paybridge requires paybridge.api_key"))
}
provider = paybridge.NewClient(
websocketURL,
reservationSystem.PaymentGatewayAPIKeyWeb,
cfg.TimeoutSeconds,
)
case cmstypes.PaySystemDojo:
TerminalID := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
if TerminalID == "" {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Dojo Terminal ID not found", fmt.Errorf("payment provider dojo requires a terminal ID for kiosk %q in the CMS", cfg.Kiosk))
}
if reservationSystem.PaymentGatewayURL == "" {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway URL not found", fmt.Errorf("payment provider dojo requires dojo.websocket_url"))
}
dojoClient, err := dojo.NewClient(dojo.Config{
BaseURL: reservationSystem.PaymentGatewayURL,
APIKey: reservationSystem.PaymentGatewayAPIKeyWeb,
SoftwareHouseID: reservationSystem.PaymentGatewaySiteIDEPOS,
Version: reservationSystem.PaymentGatewayPasswordEPOS,
TerminalID: TerminalID,
})
if err != nil {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to create Dojo client", err)
}
provider = dojoClient
case cmstypes.PaySystemNone:
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "No payment provider selected", fmt.Errorf("payment processing is enabled, but no payment provider selected; expected creditcall, paybridge or dojo"))
default:
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Unsupported Payment Provider", fmt.Errorf(
"unsupported payment provider %q; expected creditcall, paybridge or dojo",
cfg.PaymentProvider,
))
}
// Only PayBridge and Dojo use POST /api/payment/sale.
if provider != nil {
app.SetPaymentService(paymentsvc.NewService(provider))
log.Infof("Payment provider enabled for POST /api/payment/sale: %s", cmstypes.PaySystemNames[paymentProvider])
fmt.Printf("Payment provider enabled for POST /api/payment/sale: %s\n", cmstypes.PaySystemNames[paymentProvider])
}
} else {
fmt.Println("Payment processing is disabled")
log.Info("Payment processing is disabled")
}
// Update cardWellStatus when dispenser status changes
if !cfg.TestMode && disp != nil {
// Set initial cardWellStatus
app.SetCardWellStatus(cardWellStatus)
// Set up callback to update cardWellStatus when dispenser status changes
disp.OnStockUpdate(func(stock string) {
app.SetCardWellStatus(stock)
})
// Start polling for dispenser status every 10 seconds
disp.StartPolling(pollingFrequency)
}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
addr := fmt.Sprintf(":%d", cfg.Port)
log.Infof("Starting HTTP server on http://localhost%s", addr)
fmt.Printf("Starting HTTP server on http://localhost%s", addr)
if err := http.ListenAndServe(addr, mux); err != nil {
errorhandlers.FatalError(err)
}
}
// func readTicketLayout() printer.LayoutOptions {
// const layoutName = "TicketLayout.xml"
// var layout printer.LayoutOptions
// // 1) Read the file
// data, err := os.ReadFile(layoutName)
// if err != nil {
// errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
// }
// // 2) Unmarshal into your struct
// if err := xml.Unmarshal(data, &layout); err != nil {
// errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
// }
// return layout
// }
func startChipDnaClient() {
startClient := func() (*exec.Cmd, error) {
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
err := cmd.Start()
if err != nil {
return nil, fmt.Errorf("failed to start ChipDnaClient: %v", err)
}
log.Infof("ChipDnaClient started with PID %d", cmd.Process.Pid)
return cmd, nil
}
cmd, err := startClient()
if err != nil {
errorhandlers.FatalError(err)
}
// Restart loop
go func() {
for {
err := cmd.Wait()
if err != nil {
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
fmt.Printf("ChipDnaClient exited unexpectedly: %v", err)
time.Sleep(2 * time.Second)
cmd, err = startClient()
if err != nil {
log.Errorf("Restart failed: %v", err)
return
}
log.Info("ChipDnaClient restarted successfully")
fmt.Printf("ChipDnaClient restarted successfully")
}
}
}()
// Handle shutdown signals
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigs
log.Info("Shutting down...")
if cmd.Process != nil {
log.Info("Sending SIGTERM to ChipDnaClient...")
_ = cmd.Process.Signal(syscall.SIGTERM)
// wait up to 5s for graceful shutdown
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
select {
case <-time.After(5 * time.Second):
log.Warn("ChipDnaClient did not exit in time, killing...")
_ = cmd.Process.Kill()
case err := <-done:
log.Infof("ChipDnaClient exited cleanly: %v", err)
}
}
os.Exit(0)
}()
}
func pdqSerialForKiosk(pdqs []cmstypes.PDQRec, kiosk int) string {
for _, item := range pdqs {
if item.Kiosk == kiosk {
return item.Serial
}
}
return ""
}
+120
View File
@@ -0,0 +1,120 @@
// Package cms provides functions to read hotel records from the CMS and retrieve their reservation system configuration.
package cms
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
)
// ReadHotel gets the hotel record from CMS and returns its reservation system
// configuration if the record has been updated since the last read.
func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, error) {
var reservationSystem cmstypes.ReservationSystemRec
if hotelCode == "" {
return reservationSystem, errors.New("hotel code is empty")
}
if CMSBaseURL == "" {
return reservationSystem, errors.New("CMS base URL is empty")
}
var request cmstypes.RequestRec
request.Auth.ID = hotelCode
request.Auth.APIKey = cmstypes.APIKey
request.Auth.Hotel = hotelCode
request.Data = hotelCode
requestData, err := json.Marshal(request)
if err != nil {
return reservationSystem, fmt.Errorf(
"marshal CMS hotel request: %w",
err,
)
}
requestURL := CMSBaseURL + cmstypes.APIHotelDetails
req, err := http.NewRequest(http.MethodPost, requestURL, bytes.NewReader(requestData))
if err != nil {
return reservationSystem, fmt.Errorf(
"create CMS hotel request: %w",
err,
)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/json")
client := &http.Client{
Timeout: 15 * time.Second,
}
resp, err := client.Do(req)
if err != nil {
return reservationSystem, fmt.Errorf(
"perform CMS hotel request: %w",
err,
)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return reservationSystem, fmt.Errorf(
"read CMS hotel response: %w",
err,
)
}
if resp.StatusCode < http.StatusOK ||
resp.StatusCode >= http.StatusMultipleChoices {
return reservationSystem, fmt.Errorf(
"CMS hotel request returned HTTP %s: %s",
resp.Status,
string(body),
)
}
var hotelResponse cmstypes.HotelResponseRec
if err := json.Unmarshal(body, &hotelResponse); err != nil {
return reservationSystem, fmt.Errorf(
"unmarshal CMS hotel response: %w",
err,
)
}
if hotelResponse.Status.Code != cmstypes.StatusSuccessCode {
return reservationSystem, fmt.Errorf(
"CMS hotel request failed: %s",
hotelResponse.Status.Message,
)
}
if hotelResponse.TheHotel.Updated <= -1 {
return reservationSystem, errors.New(
"hotel record not updated since last read",
)
}
return hotelResponse.TheHotel.ReservationSystem, nil
}
func PaymentSystemIndex(name string) int {
for i, paySystemName := range cmstypes.PaySystemNames {
if strings.EqualFold(paySystemName, name) {
return i
}
}
return -1
}
+233
View File
@@ -0,0 +1,233 @@
package cms
import (
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/cmstypes"
)
func TestReadHotelSuccess(t *testing.T) {
const hotelCode = "gb-test-hotel"
expected := cmstypes.ReservationSystemRec{}
server := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
t.Errorf(
"expected method %s, got %s",
http.MethodPost,
r.Method,
)
}
if r.URL.Path != cmstypes.APIHotelDetails {
t.Errorf(
"expected path %q, got %q",
cmstypes.APIHotelDetails,
r.URL.Path,
)
}
if contentType := r.Header.Get("Content-Type"); contentType != "application/json" {
t.Errorf(
"expected Content-Type application/json, got %q",
contentType,
)
}
if accept := r.Header.Get("Accept"); accept != "application/json" {
t.Errorf(
"expected Accept application/json, got %q",
accept,
)
}
var request cmstypes.RequestRec
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
t.Errorf("decode request: %v", err)
http.Error(w, "invalid request", http.StatusBadRequest)
return
}
if request.Auth.ID != hotelCode {
t.Errorf(
"expected auth ID %q, got %q",
hotelCode,
request.Auth.ID,
)
}
if request.Auth.Hotel != hotelCode {
t.Errorf(
"expected auth hotel %q, got %q",
hotelCode,
request.Auth.Hotel,
)
}
if request.Auth.APIKey != cmstypes.APIKey {
t.Errorf(
"expected API key %q, got %q",
cmstypes.APIKey,
request.Auth.APIKey,
)
}
if request.Data != hotelCode {
t.Errorf(
"expected request data %q, got %q",
hotelCode,
request.Data,
)
}
response := cmstypes.HotelResponseRec{}
response.Status.Code = cmstypes.StatusSuccessCode
response.TheHotel.Updated = 1
response.TheHotel.ReservationSystem = expected
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(response); err != nil {
t.Errorf("encode response: %v", err)
}
},
))
defer server.Close()
got, err := ReadHotel(hotelCode, server.URL)
if err != nil {
t.Fatalf("ReadHotel returned an unexpected error: %v", err)
}
if !reflect.DeepEqual(got, expected) {
t.Errorf(
"unexpected reservation system:\ngot: %+v\nwant: %+v",
got,
expected,
)
}
}
func TestReadHotelValidation(t *testing.T) {
tests := []struct {
name string
hotelCode string
cmsBaseURL string
wantMessage string
}{
{
name: "empty hotel code",
hotelCode: "",
cmsBaseURL: "http://example.com",
wantMessage: "hotel code is empty",
},
{
name: "empty CMS base URL",
hotelCode: "gb-test-hotel",
cmsBaseURL: "",
wantMessage: "CMS base URL is empty",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
_, err := ReadHotel(test.hotelCode, test.cmsBaseURL)
if err == nil {
t.Fatal("expected an error, got nil")
}
if err.Error() != test.wantMessage {
t.Errorf(
"expected error %q, got %q",
test.wantMessage,
err.Error(),
)
}
})
}
}
func TestReadHotelNotUpdated(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
response := cmstypes.HotelResponseRec{}
response.Status.Code = cmstypes.StatusSuccessCode
response.TheHotel.Updated = -1
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(response); err != nil {
t.Errorf("encode response: %v", err)
}
},
))
defer server.Close()
_, err := ReadHotel("gb-test-hotel", server.URL)
if err == nil {
t.Fatal("expected an error, got nil")
}
const expected = "hotel record not updated since last read"
if err.Error() != expected {
t.Errorf("expected error %q, got %q", expected, err.Error())
}
}
func TestReadHotelHTTPError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
if _, err := io.WriteString(w, "CMS unavailable"); err != nil {
t.Errorf("write response: %v", err)
}
},
))
defer server.Close()
_, err := ReadHotel("gb-test-hotel", server.URL)
if err == nil {
t.Fatal("expected an error, got nil")
}
if !strings.Contains(err.Error(), "HTTP 500 Internal Server Error") {
t.Errorf("unexpected error: %v", err)
}
if !strings.Contains(err.Error(), "CMS unavailable") {
t.Errorf("expected response body in error, got: %v", err)
}
}
func TestReadHotelInvalidJSON(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "application/json")
if _, err := io.WriteString(w, `{invalid JSON`); err != nil {
t.Errorf("write response: %v", err)
}
},
))
defer server.Close()
_, err := ReadHotel("gb-test-hotel", server.URL)
if err == nil {
t.Fatal("expected an error, got nil")
}
if !strings.Contains(err.Error(), "unmarshal CMS hotel response") {
t.Errorf("unexpected error: %v", err)
}
}
+22 -15
View File
@@ -1,3 +1,4 @@
// Package config handles reading and parsing configuration from config.yml.
package config
import (
@@ -5,15 +6,15 @@ import (
"os"
"strings"
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
log "github.com/sirupsen/logrus"
yaml "gopkg.in/yaml.v3"
)
// configRec holds values from config.yml.
// ConfigRec holds values from config.yml.
type ConfigRec struct {
Port int `yaml:"port"`
LockserverUrl string `yaml:"lockservUrl"`
LockserverURL string `yaml:"lockservUrl"`
LockType string `yaml:"lockType"`
EncoderAddress string `yaml:"encoderAddr"`
Cert string `yaml:"cert"`
@@ -21,22 +22,25 @@ type ConfigRec struct {
DispenserAdrr string `yaml:"dispensAddr"`
PrinterName string `yaml:"printerName"`
LogDir string `yaml:"logdir"`
Dbport int `yaml:"dbport"` // Port for the database connection
Dbname string `yaml:"dbname"` // Database name for the connection
Dbuser string `yaml:"dbuser"` // User for the database connection
Dbpassword string `yaml:"dbpassword"` // Password for the database connection
Dbport int `yaml:"dbport"`
Dbname string `yaml:"dbname"`
Dbuser string `yaml:"dbuser"`
Dbpassword string `yaml:"dbpassword"`
CMSBaseURL string `yaml:"cmsurl"`
IsPayment bool `yaml:"isPayment"`
TestMode bool `yaml:"testMode"`
Hotel string `yaml:"hotel"`
Kiosk int `yaml:"kiosk"`
SendErrorEmails []string `yaml:"senderroremails"`
PaymentProvider string `yaml:"paymentProvider"`
TimeoutSeconds int `yaml:"timeoutSeconds"`
}
// ReadConfig reads config.yml and applies defaults.
// ReadHardlinkConfig reads config.yml and applies defaults.
func ReadHardlinkConfig() ConfigRec {
var cfg ConfigRec
const configName = "config.yml"
defaultPort := 9091
const defaultPort = 9091
sep := string(os.PathSeparator)
data, err := os.ReadFile(configName)
@@ -51,8 +55,7 @@ func ReadHardlinkConfig() ConfigRec {
}
if cfg.LockType == "" {
err = fmt.Errorf("LockType is required in %s", configName)
errorhandlers.FatalError(err)
errorhandlers.FatalError(fmt.Errorf("LockType is required in %s", configName))
}
cfg.LockType = strings.ToLower(cfg.LockType)
@@ -63,8 +66,13 @@ func ReadHardlinkConfig() ConfigRec {
}
if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" {
err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
log.Warnf(err.Error())
log.Warnf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
}
cfg.PaymentProvider = strings.ToLower(strings.TrimSpace(cfg.PaymentProvider))
if cfg.TimeoutSeconds <= 0 {
cfg.TimeoutSeconds = 300
}
return cfg
@@ -83,8 +91,7 @@ func ReadPreauthReleaserConfig() ConfigRec {
}
if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" {
err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
errorhandlers.FatalError(err)
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "PreauthReleaser Database Configuration Error", fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName))
}
if cfg.LogDir == "" {
+3 -1
View File
@@ -3,10 +3,12 @@ module gitea.futuresens.co.uk/futuresens/hardlink
go 1.23.2
require (
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200
gitea.futuresens.co.uk/futuresens/logging v1.0.9
github.com/alexbrainman/printer v0.0.0-20200912035444-f40f26f0bdeb
github.com/denisenkom/go-mssqldb v0.12.3
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394
github.com/sirupsen/logrus v1.9.3
github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07
+6 -2
View File
@@ -1,5 +1,5 @@
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190 h1:OxP911wT8HQqBJ20KIZcBxi898rsYHhhCkne2u45p1A=
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.190/go.mod h1:ABMUkdm+3VGrkuoCJsXMfPPud9GHDOwBb1NiifFqxes=
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200 h1:CRGAuhwecpOwY1CAuC038NFyw6EFulVG554HbUqfezI=
gitea.futuresens.co.uk/futuresens/cmstypes v1.0.200/go.mod h1:ABMUkdm+3VGrkuoCJsXMfPPud9GHDOwBb1NiifFqxes=
gitea.futuresens.co.uk/futuresens/fscrypto v0.0.0-20221125125050-9acaffd21362 h1:MnhYo7XtsECCU+5yVMo3tZZOOSOKGkl7NpOvTAieBTo=
gitea.futuresens.co.uk/futuresens/fscrypto v0.0.0-20221125125050-9acaffd21362/go.mod h1:p95ouVfK4qyC20D3/k9QLsWSxD2pdweWiY6vcYi9hpM=
gitea.futuresens.co.uk/futuresens/logging v1.0.9 h1:uvCQq/plecB0z/bUWOhFhwyYUWGPkTBZHsYNL+3RFvI=
@@ -19,6 +19,10 @@ github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZ
github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394 h1:+6kiV40vfmh17TDlZG15C2uGje1/XBGT32j6xKmUkqM=
github.com/mailjet/mailjet-apiv3-go v0.0.0-20201009050126-c24bc15a9394/go.mod h1:ogN8Sxy3n5VKLhQxbtSBM3ICG/VgjXS/akQJIoDSrgA=
github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8=
+4 -4
View File
@@ -6,10 +6,10 @@ import (
"os"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/logging"
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/logging"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
log "github.com/sirupsen/logrus"
)
@@ -32,7 +32,7 @@ func main() {
}
defer database.Close()
if err := payment.ReleasePreauthorizations(database); err != nil {
if err := creditcall.ReleasePreauthorizations(database); err != nil {
log.Error(err)
fmt.Println(err)
} else {
@@ -5,7 +5,7 @@ import (
"database/sql"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/db"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
)
func OpenDB(cfg *config.ConfigRec) (*sql.DB, error) {
@@ -1,4 +1,4 @@
package payment
package creditcall
import (
"bytes"
@@ -11,7 +11,7 @@ import (
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
)
@@ -1,4 +1,4 @@
package payment
package creditcall
import (
"encoding/hex"
@@ -9,7 +9,7 @@ import (
"strings"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
_ "github.com/denisenkom/go-mssqldb"
log "github.com/sirupsen/logrus"
)
@@ -82,7 +82,6 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML)
for _, e := range trResult.Entries {
switch e.Key {
case types.ReceiptData, types.ReceiptDataMerchant:
// intentionally ignored
@@ -100,7 +99,7 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML)
}
}
// BuildRedirectURL builds the redirect URL to send the guest to after payment.
// BuildPaymentRedirectURL builds the redirect URL to send the guest to after payment.
func BuildPaymentRedirectURL(result map[string]string) string {
res := result[types.TransactionResult]
@@ -155,8 +154,9 @@ func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
func BuildSuccessURL(result map[string]string) string {
q := url.Values{}
q.Set("CardNumber", hex.EncodeToString([]byte(result[types.PAN_MASKED])))
q.Set("ExpiryDate", hex.EncodeToString([]byte(result[types.EXPIRY_DATE])))
q.Set("CardNumber", hex.EncodeToString([]byte(result[types.PanMasked])))
q.Set("CardType", hex.EncodeToString([]byte(result[types.CardType])))
q.Set("ExpiryDate", hex.EncodeToString([]byte(result[types.ExpiryDate])))
q.Set("TxnReference", result[types.Reference])
q.Set("CardHash", hex.EncodeToString([]byte(result[types.CardHash])))
q.Set("CardReference", hex.EncodeToString([]byte(result[types.CardReference])))
@@ -1,4 +1,4 @@
package payment
package creditcall
import (
"bytes"
@@ -11,8 +11,8 @@ import (
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/db"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
log "github.com/sirupsen/logrus"
)
+1 -1
View File
@@ -12,7 +12,7 @@ import (
mssqldb "github.com/denisenkom/go-mssqldb" // for error inspection
log "github.com/sirupsen/logrus"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
)
// InitMSSQL opens and pings the SQL Server instance (keeps your original behaviour)
@@ -1,6 +1,7 @@
package dispenser
import (
"errors"
"fmt"
"strings"
"time"
@@ -22,9 +23,13 @@ const (
// cache freshness for "continuous status" reads (tune as you wish)
defaultStatusTTL = 1500 * time.Millisecond
CardWellEmptyMessage = "Card well is empty"
)
var (
ErrCardWellEmpty = errors.New(CardWellEmptyMessage)
SerialPort string
Address []byte
@@ -67,10 +72,9 @@ var (
// Status helpers
// --------------------
func logStatus(statusBytes []byte) {
func statusDescription(statusBytes []byte) string {
if len(statusBytes) < 4 {
log.Infof("Dispenser status: <invalid len=%d>", len(statusBytes))
return
return fmt.Sprintf("<invalid len=%d>", len(statusBytes))
}
posStatus := []struct {
@@ -94,13 +98,58 @@ func logStatus(statusBytes []byte) {
result.WriteString(statusMsg + "; ")
}
}
log.Infof("Dispenser status: %s", result.String())
return result.String()
}
func logStatus(statusBytes []byte) {
log.Infof("Dispenser status: %s", statusDescription(statusBytes))
}
func isAtEncoderPosition(statusBytes []byte) bool {
return len(statusBytes) >= 4 && statusBytes[3] == 0x33
}
func validateDispenserStatusData(statusBytes []byte) error {
if len(statusBytes) != 4 {
return fmt.Errorf("malformed dispenser status: got %d bytes, want 4", len(statusBytes))
}
statusMaps := []map[byte]string{statusPos0, statusPos1, statusPos2, statusPos3}
for position, mapper := range statusMaps {
if _, ok := mapper[statusBytes[position]]; !ok {
return fmt.Errorf("unknown dispenser status 0x%X at position %d", statusBytes[position], position+1)
}
}
return nil
}
func dispenserStatusError(statusBytes []byte) error {
switch statusBytes[0] {
case 0x34, 0x32, 0x36:
return fmt.Errorf("dispenser error: %s", statusPos0[statusBytes[0]])
}
switch statusBytes[1] {
case 0x32, 0x31:
return fmt.Errorf("dispenser error: %s", statusPos1[statusBytes[1]])
}
switch statusBytes[2] {
case 0x34, 0x32:
return fmt.Errorf("dispenser error: %s", statusPos2[statusBytes[2]])
}
return nil
}
func isPreparationMoving(statusBytes []byte) bool {
return len(statusBytes) == 4 &&
(statusBytes[0] == 0x31 || statusBytes[1] == 0x38)
}
func hasPreparationDiagnostics(statusBytes []byte) bool {
return len(statusBytes) == 4 &&
(statusBytes[0] != 0x30 || statusBytes[1] != 0x30 || statusBytes[2] != 0x30)
}
func stockTake(statusBytes []byte) string {
if len(statusBytes) < 4 {
return ""
@@ -1,6 +1,4 @@
// --------------------
// Queue-based client (single owner of port)
// --------------------
// Package dispenser provides a queue-based client (single owner of port).
package dispenser
import (
@@ -32,12 +30,25 @@ type cmdResp struct {
err error
}
type sequenceTiming struct {
now func() time.Time
wait func(context.Context, time.Duration) error
}
const (
sequencePollInterval = time.Second
sequenceRetryAfter = 6 * time.Second
sequenceTimeout = 12 * time.Second
)
type Client struct {
port *serial.Port
reqCh chan cmdReq
done chan struct{}
sequenceTiming sequenceTiming
// status cache
mu sync.RWMutex
lastStatus []byte
@@ -56,15 +67,31 @@ func NewClient(port *serial.Port, queueSize int) *Client {
queueSize = 16
}
c := &Client{
port: port,
reqCh: make(chan cmdReq, queueSize),
done: make(chan struct{}),
port: port,
reqCh: make(chan cmdReq, queueSize),
done: make(chan struct{}),
sequenceTiming: sequenceTiming{
now: time.Now,
wait: waitForSequence,
},
statusTTL: defaultStatusTTL,
}
go c.loop()
return c
}
func waitForSequence(ctx context.Context, duration time.Duration) error {
timer := time.NewTimer(duration)
defer timer.Stop()
select {
case <-timer.C:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (c *Client) Close() {
select {
case <-c.done:
@@ -74,7 +101,7 @@ func (c *Client) Close() {
}
}
// Optional: tune cache TTL (how "fresh" cached status must be)
// SetStatusTTL sets the duration for which cached status is considered fresh.
func (c *Client) SetStatusTTL(d time.Duration) {
c.mu.Lock()
c.statusTTL = d
@@ -233,7 +260,7 @@ func (c *Client) OutOfMouth(ctx context.Context) error {
// Public sequences updated to use Client (queue)
// --------------------
// DispenserPrepare: check status; if empty => ok; else ensure at encoder.
// DispenserPrepare checks status; if empty => ok; else ensure at encoder.
func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
const funcName = "DispenserPrepare"
stockStatus := ""
@@ -270,101 +297,152 @@ func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
return stockStatus, nil
}
func (c *Client) DispenserStart(ctx context.Context) (string, error) {
const funcName = "DispenserStart"
stockStatus := ""
status, err := c.CheckStatus(ctx)
func (c *Client) readSequenceStatus(ctx context.Context, operation string) ([]byte, string, error) {
status, err := c.do(ctx, cmdStatus)
if err != nil {
return stockStatus, fmt.Errorf("[%s] check status: %w", funcName, err)
if ctxErr := ctx.Err(); ctxErr != nil {
return nil, "", fmt.Errorf("[%s] read status: %w", operation, ctxErr)
}
return nil, "", fmt.Errorf("[%s] read status: %w", operation, err)
}
defer func() {
stockStatus := ""
if len(status) == 4 {
stockStatus = stockTake(status)
c.setStock(status)
logStatus(status)
}()
stockStatus = stockTake(status)
c.setStock(status)
}
return status, stockStatus, nil
}
if isCardWellEmpty(status) {
return stockStatus, fmt.Errorf(stockStatus)
func preparationStatus(operation string, status []byte) (bool, error) {
if len(status) != 4 {
return false, fmt.Errorf("[%s] %w", operation, validateDispenserStatusData(status))
}
if isAtEncoderPosition(status) {
if hasPreparationDiagnostics(status) {
log.Warnf(
"[%s] card confirmed at encoder with dispenser diagnostics: %s raw status: % X",
operation,
statusDescription(status),
status,
)
}
return true, nil
}
if err := validateDispenserStatusData(status); err != nil {
return false, fmt.Errorf("[%s] %w", operation, err)
}
if isCardWellEmpty(status) {
return false, fmt.Errorf("[%s] %w", operation, ErrCardWellEmpty)
}
if isPreparationMoving(status) {
return false, nil
}
if err := dispenserStatusError(status); err != nil {
return false, fmt.Errorf("[%s] %w", operation, err)
}
return false, nil
}
func (c *Client) pollForEncoderPosition(
ctx context.Context,
operation string,
retryCommand func(context.Context) error,
) (string, error) {
started := c.sequenceTiming.now()
halfway := started.Add(sequenceRetryAfter)
deadline := started.Add(sequenceTimeout)
retried := false
stockStatus := ""
for {
if err := ctx.Err(); err != nil {
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
}
now := c.sequenceTiming.now()
if !now.Before(deadline) {
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
}
status, currentStockStatus, err := c.readSequenceStatus(ctx, operation)
stockStatus = currentStockStatus
if err != nil {
return stockStatus, err
}
ready, err := preparationStatus(operation, status)
if err != nil {
return stockStatus, err
}
if ready {
return stockStatus, nil
}
now = c.sequenceTiming.now()
if !now.Before(deadline) {
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
}
if retryCommand != nil && !retried && !now.Before(halfway) {
if err := retryCommand(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] retry command: %w", operation, err)
}
retried = true
}
wait := sequencePollInterval
if remaining := deadline.Sub(now); remaining < wait {
wait = remaining
}
if err := c.sequenceTiming.wait(ctx, wait); err != nil {
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
}
}
}
func (c *Client) prepareCardAtEncoder(ctx context.Context, operation string) (string, error) {
status, stockStatus, err := c.readSequenceStatus(ctx, operation)
if err != nil {
return stockStatus, err
}
ready, err := preparationStatus(operation, status)
if err != nil {
return stockStatus, err
}
if ready {
return stockStatus, nil
}
if err := c.ToEncoder(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] to encoder: %w", funcName, err)
}
deadline := time.Now().Add(6 * time.Second)
for {
time.Sleep(delay * 2)
if time.Now().After(deadline) {
return stockStatus, nil
}
status, _ = c.do(ctx, cmdStatus)
stockStatus = stockTake(status)
c.setStock(status)
logStatus(status)
// error states first
if isCardWellEmpty(status) {
return stockStatus, fmt.Errorf(stockStatus)
}
if isAtEncoderPosition(status) {
return stockStatus, nil
}
return stockStatus, fmt.Errorf("[%s] to encoder: %w", operation, err)
}
return c.pollForEncoderPosition(ctx, operation, c.ToEncoder)
}
func (c *Client) DispenserFinal(ctx context.Context) (string, error) {
const funcName = "DispenserFinal"
stockStatus := ""
var status []byte
// PrepareCurrentCard authoritatively places the card to be encoded at the encoder.
func (c *Client) PrepareCurrentCard(ctx context.Context) (string, error) {
return c.prepareCardAtEncoder(ctx, "PrepareCurrentCard")
}
// DeliverCurrentCard presents the encoded card and confirms command acceptance.
func (c *Client) DeliverCurrentCard(ctx context.Context) (string, error) {
const operation = "DeliverCurrentCard"
if err := c.OutOfMouth(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] out of mouth: %w", funcName, err)
}
time.Sleep(delay)
status, err := c.do(ctx, cmdStatus)
if err == nil && len(status) >= 4 {
c.setStock(status)
}
time.Sleep(delay)
if err := c.ToEncoder(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] to encoder: %w", funcName, err)
}
defer func() {
logStatus(status)
}()
deadline := time.Now().Add(6 * time.Second)
for {
time.Sleep(delay * 2)
if time.Now().After(deadline) {
return stockStatus, nil
}
status, _ = c.do(ctx, cmdStatus)
stockStatus = stockTake(status)
c.setStock(status)
logStatus(status)
if isCardWellEmpty(status) {
return stockStatus, nil
}
if isAtEncoderPosition(status) {
return stockStatus, nil
}
return "", fmt.Errorf("[%s] out of mouth: %w", operation, err)
}
return "", nil
}
// BeginPrepareNextCard starts moving the next card to the encoder without waiting for readiness.
func (c *Client) BeginPrepareNextCard(ctx context.Context) error {
if err := c.ToEncoder(ctx); err != nil {
return fmt.Errorf("[BeginPrepareNextCard] to encoder: %w", err)
}
return nil
}
// PrepareNextCard places a new card at the encoder for a later issuance attempt.
func (c *Client) PrepareNextCard(ctx context.Context) (string, error) {
return c.prepareCardAtEncoder(ctx, "PrepareNextCard")
}
+404
View File
@@ -0,0 +1,404 @@
package dispenser
import (
"bytes"
"context"
"errors"
"strings"
"testing"
"time"
log "github.com/sirupsen/logrus"
)
type fakeSequenceDevice struct {
statusResponses []cmdResp
commandErrors map[cmdType][]error
commands []cmdType
}
func newSequenceTestClient(t *testing.T, statusResponses ...cmdResp) (*Client, *fakeSequenceDevice) {
t.Helper()
device := &fakeSequenceDevice{
statusResponses: append([]cmdResp(nil), statusResponses...),
commandErrors: make(map[cmdType][]error),
}
now := time.Date(2026, time.July, 23, 12, 0, 0, 0, time.UTC)
client := &Client{
reqCh: make(chan cmdReq),
done: make(chan struct{}),
sequenceTiming: sequenceTiming{
now: func() time.Time {
return now
},
wait: func(ctx context.Context, duration time.Duration) error {
select {
case <-ctx.Done():
return ctx.Err()
default:
now = now.Add(duration)
return nil
}
},
},
}
go func() {
for {
select {
case <-client.done:
return
case request := <-client.reqCh:
device.commands = append(device.commands, request.typ)
if request.typ == cmdStatus {
if len(device.statusResponses) == 0 {
request.respCh <- cmdResp{err: errors.New("unexpected status read")}
continue
}
response := device.statusResponses[0]
device.statusResponses = device.statusResponses[1:]
request.respCh <- response
continue
}
var err error
if queued := device.commandErrors[request.typ]; len(queued) > 0 {
err = queued[0]
device.commandErrors[request.typ] = queued[1:]
}
request.respCh <- cmdResp{err: err}
}
}
}()
t.Cleanup(client.Close)
return client, device
}
func status(position byte) []byte {
return []byte{0x30, 0x30, 0x30, position}
}
func commandCount(commands []cmdType, target cmdType) int {
count := 0
for _, command := range commands {
if command == target {
count++
}
}
return count
}
func TestPrepareCurrentCardAcceptsEncoderPositionWithStaleDiagnostics(t *testing.T) {
tests := []struct {
name string
status []byte
wantStock string
}{
{
name: "dispense error and jam",
status: []byte{0x30, 0x32, 0x32, 0x33},
wantStock: "Card jammed",
},
{
name: "supply diagnostics",
status: []byte{0x32, 0x30, 0x31, 0x33},
wantStock: "Card pre-empty",
},
{
name: "combined stale jam and supply diagnostics",
status: []byte{0x30, 0x32, 0x33, 0x33},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var logOutput bytes.Buffer
standardLogger := log.StandardLogger()
previousOutput := standardLogger.Out
standardLogger.SetOutput(&logOutput)
t.Cleanup(func() {
standardLogger.SetOutput(previousOutput)
})
client, device := newSequenceTestClient(t, cmdResp{status: test.status})
stock, err := client.PrepareCurrentCard(context.Background())
if err != nil {
t.Fatal(err)
}
if stock != test.wantStock {
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
}
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
t.Fatalf("to-encoder commands = %d, want 0", got)
}
if got := commandCount(device.commands, cmdStatus); got != 1 {
t.Fatalf("status reads = %d, want 1", got)
}
logged := logOutput.String()
if !strings.Contains(logged, "card confirmed at encoder") ||
!strings.Contains(logged, statusDescription(test.status)) ||
!strings.Contains(logged, "raw status") {
t.Fatalf("encoder diagnostic log = %q", logged)
}
})
}
}
func TestPrepareCurrentCardPollingAllowsTransientMovementWithStaleErrors(t *testing.T) {
client, device := newSequenceTestClient(t,
cmdResp{status: status(0x34)},
cmdResp{status: []byte{0x31, 0x38, 0x32, 0x30}},
cmdResp{status: []byte{0x30, 0x32, 0x32, 0x33}},
)
stock, err := client.PrepareCurrentCard(context.Background())
if err != nil {
t.Fatal(err)
}
if stock != "Card jammed" {
t.Fatalf("stock status = %q, want Card jammed", stock)
}
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
t.Fatalf("to-encoder commands = %d, want 1", got)
}
if got := commandCount(device.commands, cmdStatus); got != 3 {
t.Fatalf("status reads = %d, want 3", got)
}
}
func TestPrepareCurrentCardRejectsFailureWithoutEncoderOrMovement(t *testing.T) {
tests := []struct {
name string
response cmdResp
wantError string
wantStock string
}{
{
name: "status read error",
response: cmdResp{err: errors.New("serial read failed")},
wantError: "serial read failed",
},
{
name: "malformed status",
response: cmdResp{status: []byte{0x30, 0x30, 0x31}},
wantError: "malformed dispenser status",
},
{
name: "unknown status",
response: cmdResp{status: []byte{0x30, 0x30, 0x30, 0x39}},
wantError: "unknown dispenser status",
},
{
name: "jammed preparation",
response: cmdResp{status: []byte{0x30, 0x30, 0x32, 0x34}},
wantError: "Card jammed",
wantStock: "Card jammed",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client, _ := newSequenceTestClient(t, test.response)
stock, err := client.PrepareCurrentCard(context.Background())
if err == nil || !strings.Contains(err.Error(), test.wantError) {
t.Fatalf("error = %v, want containing %q", err, test.wantError)
}
if stock != test.wantStock {
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
}
})
}
}
func TestPrepareCurrentCardReturnsAuthoritativeEmptyWellError(t *testing.T) {
client, device := newSequenceTestClient(t, cmdResp{status: status(0x38)})
stock, err := client.PrepareCurrentCard(context.Background())
if !errors.Is(err, ErrCardWellEmpty) {
t.Fatalf("error = %v, want ErrCardWellEmpty", err)
}
if stock != "Card empty" {
t.Fatalf("stock status = %q, want Card empty", stock)
}
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
t.Fatalf("to-encoder commands = %d, want 0", got)
}
}
func TestDeliverCurrentCardSucceedsAfterCommandAcceptanceWithoutStatusPolling(t *testing.T) {
staleStatus := []byte{0x30, 0x32, 0x32, 0x33}
client, device := newSequenceTestClient(t, cmdResp{status: staleStatus})
stock, err := client.DeliverCurrentCard(context.Background())
if err != nil {
t.Fatal(err)
}
if stock != "" {
t.Fatalf("stock status = %q, want empty", stock)
}
if got := commandCount(device.commands, cmdOutOfMouth); got != 1 {
t.Fatalf("out-of-mouth commands = %d, want 1", got)
}
if got := commandCount(device.commands, cmdStatus); got != 0 {
t.Fatalf("status reads = %d, want 0", got)
}
if len(device.statusResponses) != 1 {
t.Fatalf("queued status responses = %d, want stale status unread", len(device.statusResponses))
}
}
func TestDeliverCurrentCardRejectsCommandFailures(t *testing.T) {
tests := []struct {
name string
err error
}{
{name: "serial dispatch failure", err: errors.New("serial write failed")},
{name: "invalid acknowledgement", err: errors.New("unexpected response status")},
{name: "missing acknowledgement", err: errors.New("no response from dispenser")},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client, device := newSequenceTestClient(t)
device.commandErrors[cmdOutOfMouth] = []error{test.err}
_, err := client.DeliverCurrentCard(context.Background())
if err == nil || !strings.Contains(err.Error(), test.err.Error()) {
t.Fatalf("error = %v, want containing %q", err, test.err)
}
if got := commandCount(device.commands, cmdOutOfMouth); got != 1 {
t.Fatalf("out-of-mouth commands = %d, want 1", got)
}
if got := commandCount(device.commands, cmdStatus); got != 0 {
t.Fatalf("status reads = %d, want 0", got)
}
})
}
}
func TestDeliverCurrentCardPreservesContextCancellation(t *testing.T) {
client, _ := newSequenceTestClient(t)
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := client.DeliverCurrentCard(ctx)
if !errors.Is(err, context.Canceled) {
t.Fatalf("error = %v, want context.Canceled", err)
}
}
func TestPrepareCurrentCardRetriesOnceThenTimesOut(t *testing.T) {
responses := make([]cmdResp, 13)
for index := range responses {
responses[index] = cmdResp{status: status(0x34)}
}
client, device := newSequenceTestClient(t, responses...)
_, err := client.PrepareCurrentCard(context.Background())
if err == nil || !strings.Contains(err.Error(), "timed out") {
t.Fatalf("error = %v, want preparation timeout", err)
}
if got := commandCount(device.commands, cmdToEncoder); got != 2 {
t.Fatalf("to-encoder commands = %d, want initial command plus one halfway retry", got)
}
if got := commandCount(device.commands, cmdStatus); got != 13 {
t.Fatalf("status reads = %d, want 13", got)
}
}
func TestPrepareCurrentCardPropagatesContextCancellation(t *testing.T) {
client, _ := newSequenceTestClient(t,
cmdResp{status: status(0x34)},
cmdResp{status: status(0x34)},
)
ctx, cancel := context.WithCancel(context.Background())
client.sequenceTiming.wait = func(context.Context, time.Duration) error {
cancel()
return ctx.Err()
}
_, err := client.PrepareCurrentCard(ctx)
if !errors.Is(err, context.Canceled) {
t.Fatalf("error = %v, want context.Canceled", err)
}
}
func TestBeginPrepareNextCardDispatchesWithoutReadinessPolling(t *testing.T) {
client, device := newSequenceTestClient(t)
if err := client.BeginPrepareNextCard(context.Background()); err != nil {
t.Fatal(err)
}
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
t.Fatalf("to-encoder commands = %d, want 1", got)
}
if got := commandCount(device.commands, cmdStatus); got != 0 {
t.Fatalf("status reads = %d, want 0", got)
}
}
func TestBeginPrepareNextCardReturnsDispatchFailureWithoutPolling(t *testing.T) {
client, device := newSequenceTestClient(t)
device.commandErrors[cmdToEncoder] = []error{errors.New("dispatch failed")}
err := client.BeginPrepareNextCard(context.Background())
if err == nil || !strings.Contains(err.Error(), "dispatch failed") {
t.Fatalf("error = %v, want dispatch failure", err)
}
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
t.Fatalf("to-encoder commands = %d, want 1", got)
}
if got := commandCount(device.commands, cmdStatus); got != 0 {
t.Fatalf("status reads = %d, want 0", got)
}
}
func TestPrepareCardAtEncoderRequiresConfirmedEncoderState(t *testing.T) {
tests := []struct {
name string
responses []cmdResp
wantError string
wantToEncoder int
}{
{
name: "already at encoder",
responses: []cmdResp{{status: status(0x33)}},
wantToEncoder: 0,
},
{
name: "moves ready card to encoder",
responses: []cmdResp{
{status: status(0x34)},
{status: status(0x33)},
},
wantToEncoder: 1,
},
{
name: "empty card well",
responses: []cmdResp{{status: status(0x38)}},
wantError: CardWellEmptyMessage,
wantToEncoder: 0,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client, device := newSequenceTestClient(t, test.responses...)
_, err := client.PrepareNextCard(context.Background())
if test.wantError == "" && err != nil {
t.Fatal(err)
}
if test.wantError != "" && (err == nil || !strings.Contains(err.Error(), test.wantError)) {
t.Fatalf("error = %v, want containing %q", err, test.wantError)
}
if got := commandCount(device.commands, cmdToEncoder); got != test.wantToEncoder {
t.Fatalf("to-encoder commands = %d, want %d", got, test.wantToEncoder)
}
})
}
}
+674
View File
@@ -0,0 +1,674 @@
package dojo
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"sort"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
log "github.com/sirupsen/logrus"
)
type Config struct {
BaseURL string
APIKey string
SoftwareHouseID string
Version string
TerminalID string
}
type Client struct {
baseURL string
apiKey string
version string
softwareHouseID string
terminalID string
httpClient *http.Client
}
const (
dojoTerminalUnavailableStatus = "TERMINAL_UNAVAILABLE"
dojoTerminalUnavailableMessage = "Payment terminal is unavailable"
)
type httpResponseError struct {
StatusCode int
Body string
}
func (e *httpResponseError) Error() string {
return fmt.Sprintf("Dojo returned HTTP %d: %s", e.StatusCode, e.Body)
}
type terminalSessionWithUpdates struct {
terminalSessionResponse
NotificationEvents []terminalNotificationEvent `json:"notificationEvents"`
StatusEvents []terminalStatusEvent `json:"statusEvents"`
}
type terminalNotificationEvent struct {
CreatedAt time.Time `json:"createdAt"`
NotificationType string `json:"notificationType"`
}
type terminalStatusEvent struct {
CreatedAt time.Time `json:"createdAt"`
Status string `json:"status"`
}
type terminalDisplayEvent struct {
createdAt time.Time
code string
sessionStatus string
}
func NewClient(cfg Config) (*Client, error) {
if cfg.BaseURL == "" {
return nil, fmt.Errorf("dojo base_url is required")
}
if cfg.APIKey == "" {
return nil, fmt.Errorf("dojo api_key is required")
}
if cfg.Version == "" {
cfg.Version = "2026-02-27"
}
if cfg.SoftwareHouseID == "" {
return nil, fmt.Errorf("dojo software_house_id is required")
}
if cfg.TerminalID == "" {
return nil, fmt.Errorf("dojo terminal_id is required")
}
return &Client{
baseURL: strings.TrimRight(cfg.BaseURL, "/"),
apiKey: cfg.APIKey,
version: cfg.Version,
softwareHouseID: cfg.SoftwareHouseID,
terminalID: cfg.TerminalID,
httpClient: &http.Client{Timeout: 30 * time.Second},
}, nil
}
func (c *Client) Sale(
ctx context.Context,
req paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
if req.Currency == "" {
req.Currency = "GBP"
}
sendPaymentStatus(onStatus, paymentstatus.Starting)
intent, err := c.createPaymentIntent(ctx, req)
if err != nil {
return nil, err
}
session, err := c.createTerminalSession(ctx, intent.ID)
if err != nil {
var responseErr *httpResponseError
if errors.As(err, &responseErr) && responseErr.StatusCode == http.StatusConflict {
log.WithFields(log.Fields{
"provider": "Dojo",
"operation": "createTerminalSession",
"status": responseErr.StatusCode,
"terminal_unavailable": true,
}).Warn(dojoTerminalUnavailableMessage)
sendPaymentStatus(onStatus, paymentstatus.TerminalUnavailable)
result := c.baseResult(req, nil)
result.Status = dojoTerminalUnavailableStatus
result.ErrorMessage = dojoTerminalUnavailableMessage
return result, nil
}
return nil, err
}
session, err = c.waitForTerminalSession(ctx, session.ID, onStatus)
if err != nil {
return nil, err
}
switch strings.ToLower(session.Status) {
case types.ResultCaptured, types.ResultSignatureAccepted:
intent, err = c.getPaymentIntent(ctx, intent.ID)
if err != nil {
return nil, err
}
if strings.ToLower(intent.Status) != types.ResultCaptured {
return nil, fmt.Errorf("Dojo terminal session is %s but payment intent is %s", session.Status, intent.Status)
}
result := c.mapCapturedResult(req, intent)
result.CustomerReceipt = receiptToText(session.Receipt)
return result, nil
case types.ResultCancelled, types.ResultCanceled, types.ResultDeclined, types.ResultExpired, types.ResultSignatureRejected:
return c.mapTerminalFailure(req, session), nil
case types.ResultSignatureRequired:
result := c.baseResult(req, session.PaymentDetails)
result.Status = "SIGNATURE_VERIFICATION_REQUIRED"
result.ErrorMessage = "Dojo signature verification is required but is not supported"
return result, nil
default:
return nil, fmt.Errorf("unexpected final Dojo terminal session status %q", session.Status)
}
}
func (c *Client) createPaymentIntent(ctx context.Context, req paymentsvc.SaleRequest) (*paymentIntentResponse, error) {
payload := createPaymentIntentRequest{
Amount: money{
Value: req.Amount,
CurrencyCode: req.Currency,
},
Reference: dojoReference(req),
CaptureMode: "Auto",
}
var response paymentIntentResponse
if err := c.doJSON(ctx, http.MethodPost, "/payment-intents", payload, false, &response); err != nil {
return nil, fmt.Errorf("create Dojo payment intent: %w", err)
}
if response.ID == "" {
return nil, fmt.Errorf("create Dojo payment intent: response did not contain id")
}
return &response, nil
}
func (c *Client) createTerminalSession(ctx context.Context, paymentIntentID string) (*terminalSessionResponse, error) {
payload := createTerminalSessionRequest{
TerminalID: c.terminalID,
Details: terminalSessionDetails{
SessionType: "Sale",
Sale: terminalSessionSale{
PaymentIntentID: paymentIntentID,
},
},
}
var response terminalSessionResponse
if err := c.doJSON(ctx, http.MethodPost, "/terminal-sessions", payload, true, &response); err != nil {
return nil, fmt.Errorf("create Dojo terminal session: %w", err)
}
if response.ID == "" {
return nil, fmt.Errorf("create Dojo terminal session: response did not contain id")
}
return &response, nil
}
func (c *Client) waitForTerminalSession(
ctx context.Context,
terminalSessionID string,
onStatus paymentsvc.StatusHandler,
) (*terminalSessionResponse, error) {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
notificationCount := 0
statusCount := 0
lastSessionStatus := ""
signatureRejected := false
for {
session, err := c.getTerminalSession(ctx, terminalSessionID)
if err != nil {
return nil, err
}
log.Println("session status:", session.Status)
emitNewTerminalSessionEvents(
session,
&notificationCount,
&statusCount,
&lastSessionStatus,
onStatus,
)
currentStatus := strings.ToLower(session.Status)
if currentStatus != lastSessionStatus {
lastSessionStatus = currentStatus
sendPaymentStatus(
onStatus,
mapDojoSessionStatus(session.Status),
)
}
switch currentStatus {
case types.ResultInitiateRequested,
types.ResultInitiated,
types.ResultAuthorized,
types.ResultCancelRequested:
case types.ResultSignatureRequired:
if !signatureRejected {
sendPaymentStatus(
onStatus,
paymentstatus.SignatureRejecting,
)
rejectedSession, err := c.rejectSignature(
ctx,
terminalSessionID,
)
if err != nil {
return nil, err
}
signatureRejected = true
if rejectedSession != nil {
rejectedStatus := strings.ToLower(
rejectedSession.Status,
)
if rejectedStatus != lastSessionStatus {
lastSessionStatus = rejectedStatus
sendPaymentStatus(
onStatus,
mapDojoSessionStatus(
rejectedSession.Status,
),
)
}
switch rejectedStatus {
case types.ResultCaptured,
types.ResultCancelled,
types.ResultCanceled,
types.ResultDeclined,
types.ResultExpired,
types.ResultSignatureAccepted,
types.ResultSignatureRejected:
return rejectedSession, nil
}
}
}
case types.ResultCaptured,
types.ResultCancelled,
types.ResultCanceled,
types.ResultDeclined,
types.ResultExpired,
types.ResultSignatureAccepted,
types.ResultSignatureRejected:
return &session.terminalSessionResponse, nil
default:
return nil, fmt.Errorf(
"unexpected Dojo terminal session status %q",
session.Status,
)
}
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-ticker.C:
}
}
}
func emitNewTerminalSessionEvents(
session *terminalSessionWithUpdates,
notificationCount *int,
statusCount *int,
lastSessionStatus *string,
onStatus paymentsvc.StatusHandler,
) {
if *notificationCount > len(session.NotificationEvents) {
*notificationCount = len(session.NotificationEvents)
}
if *statusCount > len(session.StatusEvents) {
*statusCount = len(session.StatusEvents)
}
newEventCount := len(session.NotificationEvents) - *notificationCount +
len(session.StatusEvents) - *statusCount
events := make([]terminalDisplayEvent, 0, newEventCount)
// Add status events first so a notification wins when timestamps are equal.
for *statusCount < len(session.StatusEvents) {
event := session.StatusEvents[*statusCount]
*statusCount = *statusCount + 1
events = append(events, terminalDisplayEvent{
createdAt: event.CreatedAt,
code: mapDojoSessionStatus(event.Status),
sessionStatus: event.Status,
})
}
for *notificationCount < len(session.NotificationEvents) {
event := session.NotificationEvents[*notificationCount]
*notificationCount = *notificationCount + 1
events = append(events, terminalDisplayEvent{
createdAt: event.CreatedAt,
code: mapDojoNotification(event.NotificationType),
})
}
sort.SliceStable(events, func(i, j int) bool {
return events[i].createdAt.Before(events[j].createdAt)
})
for _, event := range events {
if event.sessionStatus != "" {
*lastSessionStatus = strings.ToLower(event.sessionStatus)
}
sendPaymentStatus(onStatus, event.code)
}
}
func sendPaymentStatus(
handler paymentsvc.StatusHandler,
code string,
) {
if handler == nil || code == "" {
return
}
handler(paymentsvc.StatusUpdate{
Code: code,
})
}
func mapDojoNotification(notification string) string {
switch notification {
case "PresentCard":
return paymentstatus.PresentCard
case "InsertCard":
return paymentstatus.InsertCard
case "SwipeCard":
return paymentstatus.SwipeCard
case "EnterPin":
return paymentstatus.EnterPIN
case "RemoveCard":
return paymentstatus.RemoveCard
case "PleaseWait":
return paymentstatus.PleaseWait
default:
return dojoFallbackStatusCode(
paymentstatus.DojoNotificationPrefix,
notification,
)
}
}
func mapDojoSessionStatus(status string) string {
switch strings.ToLower(status) {
case types.ResultInitiateRequested:
return paymentstatus.Starting
case types.ResultInitiated:
return paymentstatus.Started
case types.ResultAuthorized:
return paymentstatus.Authorized
case types.ResultCancelRequested:
return paymentstatus.Cancelling
case types.ResultSignatureRequired:
return paymentstatus.SignatureRequired
case types.ResultCaptured, types.ResultSignatureAccepted:
return paymentstatus.Approved
case types.ResultCancelled, types.ResultCanceled:
return paymentstatus.Cancelled
case types.ResultDeclined:
return paymentstatus.Declined
case types.ResultExpired:
return paymentstatus.Expired
case types.ResultSignatureRejected:
return paymentstatus.SignatureRejected
default:
return dojoFallbackStatusCode(
paymentstatus.DojoStatusPrefix,
status,
)
}
}
func dojoFallbackStatusCode(prefix, value string) string {
value = strings.TrimSpace(value)
if value == "" {
return ""
}
replacer := strings.NewReplacer(
" ", "_",
"-", "_",
)
return prefix + strings.ToUpper(replacer.Replace(value))
}
func (c *Client) rejectSignature(ctx context.Context, terminalSessionID string) (*terminalSessionResponse, error) {
payload := signatureVerificationRequest{
Accepted: false,
}
var response terminalSessionResponse
path := "/terminal-sessions/" + url.PathEscape(terminalSessionID) + "/signature"
if err := c.doJSON(ctx, http.MethodPut, path, payload, true, &response); err != nil {
return nil, fmt.Errorf("reject Dojo signature verification: %w", err)
}
return &response, nil
}
func (c *Client) getTerminalSession(
ctx context.Context,
terminalSessionID string,
) (*terminalSessionWithUpdates, error) {
var response terminalSessionWithUpdates
path := "/terminal-sessions/" + url.PathEscape(terminalSessionID)
if err := c.doJSON(ctx, http.MethodGet, path, nil, true, &response); err != nil {
return nil, fmt.Errorf("get Dojo terminal session: %w", err)
}
return &response, nil
}
func (c *Client) getPaymentIntent(ctx context.Context, paymentIntentID string) (*paymentIntentResponse, error) {
var response paymentIntentResponse
path := "/payment-intents/" + url.PathEscape(paymentIntentID) + "?returnCanceled=true"
if err := c.doJSON(ctx, http.MethodGet, path, nil, false, &response); err != nil {
return nil, fmt.Errorf("get Dojo payment intent: %w", err)
}
return &response, nil
}
func (c *Client) mapCapturedResult(req paymentsvc.SaleRequest, intent *paymentIntentResponse) *paymentsvc.Result {
result := c.baseResult(req, intent.PaymentDetails)
result.Success = true
result.Status = "APPROVED"
if intent.Amount.Value != 0 {
result.Amount = intent.Amount.Value
}
if intent.Amount.CurrencyCode != "" {
result.Currency = intent.Amount.CurrencyCode
}
if result.Message == "" {
result.Message = "Payment approved"
}
return result
}
func (c *Client) mapTerminalFailure(req paymentsvc.SaleRequest, session *terminalSessionResponse) *paymentsvc.Result {
result := c.baseResult(req, session.PaymentDetails)
result.Status = strings.ToUpper(session.Status)
result.ErrorMessage = "Dojo terminal session ended with status " + session.Status
result.CustomerReceipt = receiptToText(session.Receipt)
return result
}
func (c *Client) baseResult(req paymentsvc.SaleRequest, details *paymentDetails) *paymentsvc.Result {
result := &paymentsvc.Result{
RequestID: req.RequestID,
Operation: "SALE",
Amount: req.Amount,
Currency: req.Currency,
DeviceUsed: c.terminalID,
DeviceType: "Dojo Terminal",
}
if details == nil {
return result
}
result.TransactionID = details.TransactionID
result.ReferenceNumber = req.RequestID
result.AuthCode = details.AuthCode
result.Message = details.Message
result.CardNumber = details.Card.CardNumber
result.CardType = details.Card.CardType
result.ExpiryDate = details.Card.ExpiryDate
result.LastFourDigits = details.Card.Last4PAN
if result.LastFourDigits == "" {
result.LastFourDigits = lastFour(details.Card.CardNumber)
}
return result
}
func (c *Client) doJSON(ctx context.Context, method, path string, payload any, terminalRequest bool, target any) error {
var body io.Reader
if payload != nil {
encoded, err := json.Marshal(payload)
if err != nil {
return fmt.Errorf("encode request: %w", err)
}
body = bytes.NewReader(encoded)
}
req, err := http.NewRequestWithContext(ctx, method, c.baseURL+path, body)
if err != nil {
return fmt.Errorf("create request: %w", err)
}
req.Header.Set("Authorization", "Basic "+c.apiKey)
req.Header.Set("Version", c.version)
req.Header.Set("Accept", "application/json")
if payload != nil {
req.Header.Set("Content-Type", "application/json")
}
if terminalRequest {
req.Header.Set("software-house-id", c.softwareHouseID)
}
resp, err := c.httpClient.Do(req)
if err != nil {
return fmt.Errorf("send request: %w", err)
}
defer resp.Body.Close()
responseBody, err := io.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("read response: %w", err)
}
// log.Println("Dojo payment result raw:", string(responseBody))
if resp.StatusCode < http.StatusOK ||
resp.StatusCode >= http.StatusMultipleChoices {
return &httpResponseError{
StatusCode: resp.StatusCode,
Body: strings.TrimSpace(string(responseBody)),
}
}
if target == nil || len(responseBody) == 0 {
return nil
}
if err := json.Unmarshal(responseBody, target); err != nil {
return fmt.Errorf("decode response: %w", err)
}
return nil
}
func dojoReference(req paymentsvc.SaleRequest) string {
reference := req.RequestID
if reference == "" {
reference = req.Reference
}
runes := []rune(reference)
if len(runes) > 60 {
runes = runes[:60]
}
return string(runes)
}
func receiptToText(receipt *receipt) string {
if receipt == nil {
return ""
}
var builder strings.Builder
for _, line := range receipt.Lines {
if line.LineType != "Text" || line.Text == nil {
continue
}
builder.WriteString(normalizeReceiptText(line.Text.Value))
builder.WriteByte('\n')
}
return builder.String()
}
func lastFour(cardNumber string) string {
digits := make([]byte, 0, len(cardNumber))
for i := 0; i < len(cardNumber); i++ {
if cardNumber[i] >= '0' && cardNumber[i] <= '9' {
digits = append(digits, cardNumber[i])
}
}
if len(digits) <= 4 {
return string(digits)
}
return string(digits[len(digits)-4:])
}
func normalizeReceiptText(value string) string {
replacer := strings.NewReplacer(
"£", "GBP ",
"€", "EUR ",
"$", "USD ",
)
return replacer.Replace(value)
}
+199
View File
@@ -0,0 +1,199 @@
package dojo
import (
"context"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync/atomic"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
const terminalUnavailableBody = `{"detail":"the terminal is either offline or currently in use","errors":{},"status":409,"title":"terminal unavailable","traceId":"trace-secret","type":"https://docs.dojo.tech/problems/terminal-unavailable"}`
func TestDoJSONReturnsStructuredHTTPResponseError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusConflict)
_, _ = w.Write([]byte(" " + terminalUnavailableBody + " "))
}))
defer server.Close()
client := newDojoTestClient(t, server)
err := client.doJSON(context.Background(), http.MethodPost, "/payment-intents", nil, false, nil)
var responseErr *httpResponseError
if !errors.As(err, &responseErr) {
t.Fatalf("error = %T %v, want *httpResponseError", err, err)
}
if responseErr.StatusCode != http.StatusConflict {
t.Fatalf("StatusCode = %d, want %d", responseErr.StatusCode, http.StatusConflict)
}
if responseErr.Body != terminalUnavailableBody {
t.Fatalf("Body = %q, want retained trimmed response", responseErr.Body)
}
}
func TestSaleMapsCreateTerminalSessionConflictToTerminalUnavailable(t *testing.T) {
var paymentIntentRequests atomic.Int32
var terminalSessionRequests atomic.Int32
var unexpectedRequests atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case r.Method == http.MethodPost && r.URL.Path == "/payment-intents":
paymentIntentRequests.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = fmt.Fprintln(w, `{"id":"intent-123"}`)
case r.Method == http.MethodPost && r.URL.Path == "/terminal-sessions":
terminalSessionRequests.Add(1)
w.Header().Set("Content-Type", "application/problem+json")
w.WriteHeader(http.StatusConflict)
_, _ = fmt.Fprintln(w, terminalUnavailableBody)
default:
unexpectedRequests.Add(1)
http.Error(w, "unexpected request", http.StatusInternalServerError)
}
}))
defer server.Close()
client := newDojoTestClient(t, server)
request := paymentsvc.SaleRequest{
RequestID: "REQ-123",
Reference: "BOOKING-123",
Amount: 10852,
Currency: "GBP",
}
var statuses []string
result, err := client.Sale(context.Background(), request, func(update paymentsvc.StatusUpdate) {
statuses = append(statuses, update.Code)
})
if err != nil {
t.Fatal(err)
}
if result == nil {
t.Fatal("Sale returned nil result")
}
if result.Success || result.Status == "APPROVED" {
t.Fatalf("result was accidentally successful: %+v", result)
}
if result.Status != dojoTerminalUnavailableStatus || result.ErrorMessage != dojoTerminalUnavailableMessage {
t.Fatalf("terminal-unavailable result = %+v", result)
}
if result.RequestID != request.RequestID ||
result.Operation != "SALE" ||
result.Amount != request.Amount ||
result.Currency != request.Currency ||
result.DeviceUsed != "terminal-1" ||
result.DeviceType != "Dojo Terminal" {
t.Fatalf("base result fields were not retained: %+v", result)
}
if result.TransactionID != "" || result.CustomerReceipt != "" || result.MerchantReceipt != "" {
t.Fatalf("terminal-unavailable result invented transaction data: %+v", result)
}
if !reflect.DeepEqual(statuses, []string{paymentstatus.Starting, paymentstatus.TerminalUnavailable}) {
t.Fatalf("statuses = %#v", statuses)
}
if paymentIntentRequests.Load() != 1 || terminalSessionRequests.Load() != 1 || unexpectedRequests.Load() != 0 {
t.Fatalf(
"requests: intent=%d terminal=%d unexpected=%d",
paymentIntentRequests.Load(),
terminalSessionRequests.Load(),
unexpectedRequests.Load(),
)
}
resultText := fmt.Sprintf("%+v", result)
for _, forbidden := range []string{"offline or currently in use", "trace-secret", "docs.dojo.tech", terminalUnavailableBody} {
if strings.Contains(resultText, forbidden) {
t.Fatalf("result exposed %q: %s", forbidden, resultText)
}
}
}
func TestSaleDoesNotClassifyPaymentIntentConflictAsTerminalUnavailable(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/payment-intents" {
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
}
w.WriteHeader(http.StatusConflict)
_, _ = fmt.Fprintln(w, terminalUnavailableBody)
}))
defer server.Close()
client := newDojoTestClient(t, server)
var statuses []string
result, err := client.Sale(context.Background(), paymentsvc.SaleRequest{
RequestID: "REQ-123",
Amount: 10852,
Currency: "GBP",
}, func(update paymentsvc.StatusUpdate) {
statuses = append(statuses, update.Code)
})
if result != nil || err == nil {
t.Fatalf("Sale result/error = %+v/%v, want nil generic error", result, err)
}
var responseErr *httpResponseError
if !errors.As(err, &responseErr) || responseErr.StatusCode != http.StatusConflict {
t.Fatalf("error = %T %v, want wrapped HTTP 409", err, err)
}
if !reflect.DeepEqual(statuses, []string{paymentstatus.Starting}) {
t.Fatalf("statuses = %#v, want only PAYMENT_STARTING", statuses)
}
}
func TestSaleRetainsGenericCreateTerminalSessionErrors(t *testing.T) {
for _, statusCode := range []int{http.StatusBadRequest, http.StatusBadGateway} {
t.Run(http.StatusText(statusCode), func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/payment-intents":
_, _ = fmt.Fprintln(w, `{"id":"intent-123"}`)
case "/terminal-sessions":
w.WriteHeader(statusCode)
_, _ = fmt.Fprintln(w, `{"detail":"provider failure"}`)
default:
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
}
}))
defer server.Close()
client := newDojoTestClient(t, server)
result, err := client.Sale(context.Background(), paymentsvc.SaleRequest{
RequestID: "REQ-123",
Amount: 10852,
Currency: "GBP",
}, nil)
if result != nil || err == nil {
t.Fatalf("Sale result/error = %+v/%v, want nil generic error", result, err)
}
var responseErr *httpResponseError
if !errors.As(err, &responseErr) || responseErr.StatusCode != statusCode {
t.Fatalf("error = %T %v, want wrapped HTTP %d", err, err, statusCode)
}
})
}
}
func newDojoTestClient(t *testing.T, server *httptest.Server) *Client {
t.Helper()
client, err := NewClient(Config{
BaseURL: server.URL,
APIKey: "test-api-key",
SoftwareHouseID: "software-house-1",
TerminalID: "terminal-1",
})
if err != nil {
t.Fatal(err)
}
client.httpClient = server.Client()
return client
}
+81
View File
@@ -0,0 +1,81 @@
package dojo
type money struct {
Value int64 `json:"value"`
CurrencyCode string `json:"currencyCode"`
}
type createPaymentIntentRequest struct {
Amount money `json:"amount"`
Reference string `json:"reference"`
CaptureMode string `json:"captureMode"`
}
type createTerminalSessionRequest struct {
TerminalID string `json:"terminalId"`
Details terminalSessionDetails `json:"details"`
}
type terminalSessionDetails struct {
SessionType string `json:"sessionType"`
Sale terminalSessionSale `json:"sale"`
}
type terminalSessionSale struct {
PaymentIntentID string `json:"paymentIntentId"`
}
type signatureVerificationRequest struct {
Accepted bool `json:"accepted"`
}
type terminalSessionResponse struct {
ID string `json:"id"`
Status string `json:"status"`
TerminalID string `json:"terminalId"`
PaymentDetails *paymentDetails `json:"paymentDetails"`
Receipt *receipt `json:"receipt,omitempty"`
}
type receipt struct {
Lines []receiptLine `json:"lines"`
}
type receiptLine struct {
LineType string `json:"lineType"`
Text *receiptText `json:"text,omitempty"`
}
type receiptText struct {
Align string `json:"align"`
EmphasisBold bool `json:"emphasisBold"`
Size string `json:"size"`
Value string `json:"value"`
}
type paymentIntentResponse struct {
ID string `json:"id"`
Status string `json:"status"`
Reference string `json:"reference"`
Amount money `json:"amount"`
PaymentDetails *paymentDetails `json:"paymentDetails"`
}
type paymentDetails struct {
TransactionID string `json:"transactionId"`
TransactionDateTime string `json:"transactionDateTime"`
Message string `json:"message"`
AuthCode string `json:"authCode"`
Card dojoCard `json:"card"`
}
type dojoCard struct {
CardNumber string `json:"cardNumber"`
CardName string `json:"cardName"`
ExpiryDate string `json:"expiryDate"`
CardType string `json:"cardType"`
CardFundingType string `json:"cardFundingType"`
Last4PAN string `json:"last4PAN"`
EntryMode string `json:"entryMode"`
VerificationMethod string `json:"verificationMethod"`
}
@@ -7,6 +7,7 @@ import (
"os"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
log "github.com/sirupsen/logrus"
)
@@ -28,3 +29,8 @@ func FatalError(err error) {
fmt.Scanln()
os.Exit(1)
}
func FatalErrorWithMail(hotel string, kiosk int, title string, err error) {
mail.SendEmailOnError(hotel, kiosk, title, err.Error())
FatalError(err)
}
@@ -10,7 +10,7 @@ import (
"path/filepath"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/db"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
log "github.com/sirupsen/logrus"
)
+313
View File
@@ -0,0 +1,313 @@
package handlers
import (
"bytes"
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
log "github.com/sirupsen/logrus"
)
type dispenserCallResult struct {
status string
err error
}
type fakeDoorCardDispenser struct {
prepareCurrent dispenserCallResult
deliverCurrent dispenserCallResult
beginNextErr error
beginNext func() error
prepareNext dispenserCallResult
calls []string
}
func (d *fakeDoorCardDispenser) PrepareCurrentCard(context.Context) (string, error) {
d.calls = append(d.calls, "prepare current")
return d.prepareCurrent.status, d.prepareCurrent.err
}
func (d *fakeDoorCardDispenser) DeliverCurrentCard(context.Context) (string, error) {
d.calls = append(d.calls, "deliver current")
return d.deliverCurrent.status, d.deliverCurrent.err
}
func (d *fakeDoorCardDispenser) BeginPrepareNextCard(context.Context) error {
d.calls = append(d.calls, "begin prepare next")
if d.beginNext != nil {
return d.beginNext()
}
return d.beginNextErr
}
func (d *fakeDoorCardDispenser) PrepareNextCard(context.Context) (string, error) {
d.calls = append(d.calls, "prepare next")
return d.prepareNext.status, d.prepareNext.err
}
type fakeDoorCardLockServer struct {
sequenceErr error
buildCalls int
sequenceCalls int
}
func (l *fakeDoorCardLockServer) BuildCommand(lockserver.DoorCardRequest, time.Time, time.Time) error {
l.buildCalls++
return nil
}
func (l *fakeDoorCardLockServer) LockSequence() error {
l.sequenceCalls++
return l.sequenceErr
}
func performIssueDoorCardRequest(
t *testing.T,
dispenser *fakeDoorCardDispenser,
lock *fakeDoorCardLockServer,
) (*httptest.ResponseRecorder, cmstypes.StatusRec, *App) {
t.Helper()
payload := lockserver.DoorCardRequest{
RoomField: "101",
CheckinTime: "2026-07-23 15:00:00 +0100",
CheckoutTime: "2026-07-24 11:00:00 +0100",
FollowStr: "0",
}
body, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
app := &App{
disp: dispenser,
lockserver: lock,
cfg: &config.ConfigRec{},
}
request := httptest.NewRequest(http.MethodPost, "/issuedoorcard", bytes.NewReader(body))
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
app.issueDoorCard(recorder, request)
var response cmstypes.StatusRec
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode response %q: %v", recorder.Body.String(), err)
}
return recorder, response, app
}
func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
encodingErr := errors.New("key encoding failed")
tests := []struct {
name string
dispenser fakeDoorCardDispenser
lockErr error
wantHTTP int
wantMessage string
wantCalls []string
wantLockSequence int
wantCardWell string
}{
{
name: "initial dispenser preparation failure is unavailable",
dispenser: fakeDoorCardDispenser{
prepareCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("card jammed")},
},
wantHTTP: http.StatusServiceUnavailable,
wantMessage: "Dispense error: card jammed",
wantCalls: []string{"prepare current"},
wantCardWell: "Card jammed",
},
{
name: "initial empty card well has stable message",
dispenser: fakeDoorCardDispenser{
prepareCurrent: dispenserCallResult{status: "Card empty", err: dispenser.ErrCardWellEmpty},
},
wantHTTP: http.StatusServiceUnavailable,
wantMessage: dispenser.CardWellEmptyMessage,
wantCalls: []string{"prepare current"},
wantCardWell: "Card empty",
},
{
name: "encoding and accepted delivery command succeed",
wantHTTP: http.StatusOK,
wantMessage: "Card issued successfully",
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
wantLockSequence: 1,
},
{
name: "successful encoding with delivery command failure is unavailable",
dispenser: fakeDoorCardDispenser{
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
},
wantHTTP: http.StatusServiceUnavailable,
wantMessage: "Card delivery could not be confirmed",
wantCalls: []string{"prepare current", "deliver current"},
wantLockSequence: 1,
wantCardWell: "Card jammed",
},
{
name: "failed next-card dispatch does not undo delivered card",
dispenser: fakeDoorCardDispenser{
beginNextErr: errors.New("dispatch failed"),
},
wantHTTP: http.StatusOK,
wantMessage: "Card issued successfully",
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
wantLockSequence: 1,
},
{
name: "encoding failure with safe recovery remains retryable",
lockErr: encodingErr,
wantHTTP: http.StatusBadGateway,
wantMessage: encodingErr.Error(),
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
wantLockSequence: 1,
},
{
name: "encoding failure with failed-card delivery failure is unavailable",
dispenser: fakeDoorCardDispenser{
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
},
lockErr: encodingErr,
wantHTTP: http.StatusServiceUnavailable,
wantMessage: "Dispenser recovery failed; another encoding attempt is not safe",
wantCalls: []string{"prepare current", "deliver current"},
wantLockSequence: 1,
wantCardWell: "Card jammed",
},
{
name: "encoding failure with empty card well has stable message",
dispenser: fakeDoorCardDispenser{
prepareNext: dispenserCallResult{status: "Card empty", err: dispenser.ErrCardWellEmpty},
},
lockErr: encodingErr,
wantHTTP: http.StatusServiceUnavailable,
wantMessage: dispenser.CardWellEmptyMessage,
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
wantLockSequence: 1,
wantCardWell: "Card empty",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
dispenser := test.dispenser
lock := &fakeDoorCardLockServer{sequenceErr: test.lockErr}
recorder, response, app := performIssueDoorCardRequest(t, &dispenser, lock)
if recorder.Code != test.wantHTTP {
t.Fatalf("HTTP status = %d, want %d", recorder.Code, test.wantHTTP)
}
if response.Code != test.wantHTTP {
t.Fatalf("response code = %d, want %d", response.Code, test.wantHTTP)
}
if response.Message != test.wantMessage {
t.Fatalf("response message = %q, want %q", response.Message, test.wantMessage)
}
if !reflect.DeepEqual(dispenser.calls, test.wantCalls) {
t.Fatalf("dispenser calls = %#v, want %#v", dispenser.calls, test.wantCalls)
}
if lock.sequenceCalls != test.wantLockSequence {
t.Fatalf("lock sequence calls = %d, want %d", lock.sequenceCalls, test.wantLockSequence)
}
if test.wantLockSequence > 0 && lock.buildCalls != 1 {
t.Fatalf("build command calls = %d, want 1", lock.buildCalls)
}
if test.wantLockSequence == 0 && lock.buildCalls != 0 {
t.Fatalf("build command calls = %d, want 0", lock.buildCalls)
}
if got := app.CardWellStatus(); got != test.wantCardWell {
t.Fatalf("card-well status = %q, want %q", got, test.wantCardWell)
}
})
}
}
type responseTrackingRecorder struct {
*httptest.ResponseRecorder
wroteResponse bool
}
func (r *responseTrackingRecorder) WriteHeader(statusCode int) {
r.wroteResponse = true
r.ResponseRecorder.WriteHeader(statusCode)
}
func (r *responseTrackingRecorder) Write(body []byte) (int, error) {
r.wroteResponse = true
return r.ResponseRecorder.Write(body)
}
func TestIssueDoorCardDispatchesNextCardBeforeHTTP200(t *testing.T) {
var recorder *responseTrackingRecorder
dispatchCalled := false
dispenser := &fakeDoorCardDispenser{
beginNext: func() error {
dispatchCalled = true
if recorder.wroteResponse {
t.Error("HTTP response started before next-card preparation was dispatched")
}
return nil
},
}
lock := &fakeDoorCardLockServer{}
payload := lockserver.DoorCardRequest{
RoomField: "101",
CheckinTime: "2026-07-23 15:00:00 +0100",
CheckoutTime: "2026-07-24 11:00:00 +0100",
}
body, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
app := &App{disp: dispenser, lockserver: lock, cfg: &config.ConfigRec{}}
request := httptest.NewRequest(http.MethodPost, "/issuedoorcard", bytes.NewReader(body))
request.Header.Set("Content-Type", "application/json")
recorder = &responseTrackingRecorder{ResponseRecorder: httptest.NewRecorder()}
app.issueDoorCard(recorder, request)
if !dispatchCalled {
t.Fatal("next-card preparation was not dispatched")
}
if recorder.Code != http.StatusOK {
t.Fatalf("HTTP status = %d, want %d", recorder.Code, http.StatusOK)
}
}
func TestIssueDoorCardLogsNextCardDispatchFailureAndStillSucceeds(t *testing.T) {
var logOutput bytes.Buffer
standardLogger := log.StandardLogger()
previousOutput := standardLogger.Out
standardLogger.SetOutput(&logOutput)
t.Cleanup(func() {
standardLogger.SetOutput(previousOutput)
})
dispenser := &fakeDoorCardDispenser{beginNextErr: errors.New("dispatch failed")}
lock := &fakeDoorCardLockServer{}
recorder, _, _ := performIssueDoorCardRequest(t, dispenser, lock)
if recorder.Code != http.StatusOK {
t.Fatalf("HTTP status = %d, want %d", recorder.Code, http.StatusOK)
}
logged := logOutput.String()
if !strings.Contains(logged, "dispatch failed") ||
!strings.Contains(logged, "Next card preparation dispatch") {
t.Fatalf("dispatch failure log = %q", logged)
}
}
@@ -5,6 +5,8 @@ import (
"database/sql"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"io"
"net/http"
"strings"
@@ -13,20 +15,29 @@ import (
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser"
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
)
type doorCardDispenser interface {
PrepareCurrentCard(context.Context) (string, error)
DeliverCurrentCard(context.Context) (string, error)
BeginPrepareNextCard(context.Context) error
PrepareNextCard(context.Context) (string, error)
}
type App struct {
disp *dispenser.Client
disp doorCardDispenser
lockserver lockserver.LockServer
paymentService *paymentsvc.Service
isPayment bool
db *sql.DB
cfg *config.ConfigRec
@@ -50,6 +61,10 @@ func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus str
return app
}
func (app *App) SetPaymentService(service *paymentsvc.Service) {
app.paymentService = service
}
func (app *App) RegisterRoutes(mux *http.ServeMux) {
mux.HandleFunc("/issuedoorcard", app.issueDoorCard)
mux.HandleFunc("/printroomticket", app.printRoomTicket)
@@ -59,6 +74,7 @@ func (app *App) RegisterRoutes(mux *http.ServeMux) {
mux.HandleFunc("/testissuedoorcard", app.testIssueDoorCard)
mux.HandleFunc("/ping-pdq", app.fetchChipDNAStatus)
mux.HandleFunc("/logerror", app.onChipDNAError)
mux.HandleFunc("/api/payment/sale", app.salePayment)
}
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
@@ -67,8 +83,8 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
var (
theResponse cmstypes.ResponseRec
theRequest cmstypes.TransactionRec
trResult payment.TransactionResultXML
result payment.PaymentResult
trResult creditcall.TransactionResultXML
result creditcall.PaymentResult
save bool
)
@@ -83,7 +99,7 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
if !app.isPayment {
if !app.cfg.TestMode {
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted preauthorization while payment processing is disabled")
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Payment processing is disabled")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
return
}
@@ -96,13 +112,13 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
log.Println("takePreauthorization called")
if r.Method != http.MethodPost {
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
return
}
if r.Header.Get("Content-Type") != "text/xml" {
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
return
}
@@ -112,14 +128,14 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
body, err := io.ReadAll(r.Body)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Failed to read request body")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
writeTransactionResult(w, http.StatusBadRequest, theResponse)
return
}
if err := xml.Unmarshal(body, &theRequest); err != nil {
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Invalid XML payload")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
writeTransactionResult(w, http.StatusBadRequest, theResponse)
return
}
@@ -138,7 +154,7 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Preauth processing error", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "No response from payment processor")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "No response from payment processor")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
@@ -156,7 +172,7 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
// ---- REDIRECT ----
theResponse.Status = result.Status
theResponse.Data, save = payment.BuildPreauthRedirectURL(result.Fields)
theResponse.Data, save = creditcall.BuildPreauthRedirectURL(result.Fields)
if save {
go app.persistPreauth(context.Background(), result.Fields, theRequest.CheckoutDate)
@@ -171,8 +187,8 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
var (
theResponse cmstypes.ResponseRec
theRequest cmstypes.TransactionRec
trResult payment.TransactionResultXML
result payment.PaymentResult
trResult creditcall.TransactionResultXML
result creditcall.PaymentResult
)
theResponse.Status.Code = http.StatusInternalServerError
@@ -187,11 +203,11 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
if !app.cfg.TestMode {
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted payment while payment processing is disabled")
theResponse.Status.Code = http.StatusServiceUnavailable
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Payment processing is disabled")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
return
}
}
if r.Method == http.MethodOptions {
@@ -201,13 +217,13 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
log.Println("takePayment called")
if r.Method != http.MethodPost {
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
return
}
if r.Header.Get("Content-Type") != "text/xml" {
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
return
}
@@ -217,14 +233,14 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
body, err := io.ReadAll(r.Body)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Failed to read request body")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
writeTransactionResult(w, http.StatusBadRequest, theResponse)
return
}
if err := xml.Unmarshal(body, &theRequest); err != nil {
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "Invalid XML payload")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
writeTransactionResult(w, http.StatusBadRequest, theResponse)
return
}
@@ -242,7 +258,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Start transaction error", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(types.ResultError, "No response from payment processor")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "No response from payment processor")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
@@ -263,7 +279,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
}
logging.Error(types.ServiceName, "Preauthorization failed", "Result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
theResponse.Status = result.Status
theResponse.Data = payment.BuildFailureURL(res, result.Fields[types.Errors])
theResponse.Data = creditcall.BuildFailureURL(res, result.Fields[types.Errors])
writeTransactionResult(w, http.StatusOK, theResponse)
return
@@ -273,7 +289,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
ref := result.Fields[types.Reference]
log.Printf("Preauth approved, reference: %s. Sending confirm...", ref)
confirmReq := payment.ConfirmTransactionRequest{
confirmReq := creditcall.ConfirmTransactionRequest{
Amount: theRequest.AmountMinorUnits,
Reference: ref,
}
@@ -282,7 +298,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Confirm transaction error", string(op), "", "", 0)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Error: "+err.Error())
theResponse.Data = payment.BuildFailureURL(types.ResultError, "ConfirmTransactionError")
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "ConfirmTransactionError")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
@@ -304,7 +320,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
logging.Error(types.ServiceName, "Transaction not approved after confirm", "Confirm result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
theResponse.Status = result.Status
theResponse.Data = payment.BuildFailureURL(res, result.Fields[types.Errors])
theResponse.Data = creditcall.BuildFailureURL(res, result.Fields[types.Errors])
writeTransactionResult(w, http.StatusOK, theResponse)
return
@@ -315,7 +331,7 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
printer.PrintReceipt(result.CardholderReceipt)
log.Printf("Transaction approved and confirmed, reference: %s", ref)
theResponse.Status = result.Status
theResponse.Data = payment.BuildSuccessURL(result.Fields)
theResponse.Data = creditcall.BuildSuccessURL(result.Fields)
writeTransactionResult(w, http.StatusOK, theResponse)
}
@@ -369,46 +385,69 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
return
}
// Ensure dispenser ready (card at encoder) BEFORE we attempt encoding.
// With queued dispenser ops, this will not clash with polling.
status, err := app.disp.DispenserStart(r.Context())
status, err := app.disp.PrepareCurrentCard(r.Context())
app.SetCardWellStatus(status)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
if errors.Is(err, dispenser.ErrCardWellEmpty) {
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
return
}
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
return
}
// Always attempt to finalize after we have moved a card / started an issuance flow.
// This guarantees we eject and prepare the next card even on lock failures.
finalize := func() {
if app.disp == nil {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
status, ferr := app.disp.DispenserFinal(ctx)
if ferr != nil {
logging.Error(types.ServiceName, ferr.Error(), "Dispenser final error", string(op), "", "", 0)
return
}
app.SetCardWellStatus(status)
}
// doorReq.RoomField = "104"
// build lock server command
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
// lock server sequence
if err := app.lockserver.LockSequence(); err != nil {
logging.Error(types.ServiceName, err.Error(), "Key encoding", string(op), "", "", 0)
finalize()
errorhandlers.WriteError(w, http.StatusBadGateway, err.Error())
encodingErr := app.lockserver.LockSequence()
if encodingErr != nil {
logging.Error(types.ServiceName, encodingErr.Error(), "Key encoding", string(op), "", "", 0)
}
// Once encoding has started, finish the physical dispenser sequence even if
// the HTTP client disconnects. Finalization remains bounded by one shared timeout.
finalizeCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
status, deliveryErr := app.disp.DeliverCurrentCard(finalizeCtx)
app.SetCardWellStatus(status)
if deliveryErr != nil {
if encodingErr != nil {
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, deliveryErr)
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
return
}
logging.Error(types.ServiceName, deliveryErr.Error(), "Card delivery", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Card delivery could not be confirmed")
return
}
// final dispenser steps
finalize()
if encodingErr != nil {
status, preparationErr := app.disp.PrepareNextCard(finalizeCtx)
app.SetCardWellStatus(status)
if preparationErr != nil {
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, preparationErr)
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
if errors.Is(preparationErr, dispenser.ErrCardWellEmpty) {
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
return
}
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
return
}
errorhandlers.WriteError(w, http.StatusBadGateway, encodingErr.Error())
return
}
if preparationErr := app.disp.BeginPrepareNextCard(finalizeCtx); preparationErr != nil {
logging.Error(types.ServiceName, preparationErr.Error(), "Next card preparation dispatch", string(op), "", "", 0)
}
theResponse.Code = http.StatusOK
theResponse.Message = "Card issued successfully"
@@ -9,8 +9,8 @@ import (
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
)
@@ -34,7 +34,7 @@ func callChipDNA(client *http.Client, url string, payload []byte) ([]byte, error
return io.ReadAll(resp.Body)
}
func confirmWithRetry(client *http.Client, req payment.ConfirmTransactionRequest, attempts int) ([]byte, error) {
func confirmWithRetry(client *http.Client, req creditcall.ConfirmTransactionRequest, attempts int) ([]byte, error) {
payload, err := xml.Marshal(req)
if err != nil {
@@ -69,3 +69,14 @@ func confirmWithRetry(client *http.Client, req payment.ConfirmTransactionRequest
return nil, lastErr
}
func writeJSON(w http.ResponseWriter, status int, payload any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
if payload == nil {
return
}
_ = json.NewEncoder(w).Encode(payload)
}
+334
View File
@@ -0,0 +1,334 @@
package handlers
import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"strings"
"sync"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
"github.com/google/uuid"
log "github.com/sirupsen/logrus"
)
type SalePaymentRequest struct {
Reference string `json:"reference,omitempty"`
ConfirmNo string `json:"confirmNo,omitempty"`
Amount int64 `json:"amount"`
Currency string `json:"currency,omitempty"`
}
type paymentStreamMessage struct {
Type string `json:"type"`
Code string `json:"code,omitempty"`
Response *cmstypes.ResponseRec `json:"response,omitempty"`
}
func (app *App) salePayment(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("salePayment")
response := cmstypes.ResponseRec{
Status: cmstypes.StatusRec{
Code: http.StatusInternalServerError,
Message: http.StatusText(http.StatusInternalServerError),
},
}
setPaymentCORS(w)
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
if r.Method != http.MethodPost {
response.Data = buildPaymentFailureURL(types.ResultError, "Method not allowed; use POST")
writeTransactionResult(w, http.StatusMethodNotAllowed, response)
return
}
if app.paymentService == nil {
mail.SendEmailOnError(
app.cfg.Hotel,
app.cfg.Kiosk,
"Payment Service Not Configured",
"Payment service is not configured; cannot process payment requests",
)
response.Data = buildPaymentFailureURL(types.ResultError, "Payment service is not configured")
writeTransactionResult(w, http.StatusInternalServerError, response)
return
}
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
response.Data = buildPaymentFailureURL(types.ResultError, "Content-Type must be application/json")
writeTransactionResult(w, http.StatusUnsupportedMediaType, response)
return
}
defer r.Body.Close()
var req SalePaymentRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
logging.Error(
types.ServiceName,
err.Error(),
"ReadJSON",
string(op),
"",
app.cfg.Hotel,
app.cfg.Kiosk,
)
response.Data = buildPaymentFailureURL(types.ResultError, "invalid JSON payload: "+err.Error())
writeTransactionResult(w, http.StatusBadRequest, response)
return
}
if req.Amount <= 0 {
response.Data = buildPaymentFailureURL(types.ResultError, "Amount must be greater than zero")
writeTransactionResult(w, http.StatusBadRequest, response)
return
}
if req.Currency == "" {
req.Currency = "GBP"
}
if req.Reference == "" {
req.Reference = req.ConfirmNo
}
if req.Reference == "" {
req.Reference = uuid.NewString()
}
requestID := buildPaymentRequestID(req.Reference)
timeoutSeconds := app.cfg.TimeoutSeconds
if timeoutSeconds <= 0 {
timeoutSeconds = 300
}
ctx, cancel := context.WithTimeout(
r.Context(),
time.Duration(timeoutSeconds)*time.Second,
)
defer cancel()
flusher, ok := w.(http.Flusher)
if !ok {
response.Data = buildPaymentFailureURL(
types.ResultError,
"Streaming payment updates are not supported",
)
writeTransactionResult(w, http.StatusInternalServerError, response)
return
}
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("X-Content-Type-Options", "nosniff")
encoder := json.NewEncoder(w)
var streamMu sync.Mutex
streamStarted := false
streamFailed := false
sendStreamMessage := func(message paymentStreamMessage) {
streamMu.Lock()
defer streamMu.Unlock()
if streamFailed {
return
}
if err := encoder.Encode(message); err != nil {
streamFailed = true
return
}
streamStarted = true
flusher.Flush()
}
onStatus := func(update paymentsvc.StatusUpdate) {
if update.Code == "" {
return
}
sendStreamMessage(paymentStreamMessage{
Type: "status",
Code: update.Code,
})
}
result, err := app.paymentService.Sale(
ctx,
paymentsvc.SaleRequest{
RequestID: requestID,
Reference: req.Reference,
Amount: req.Amount,
Currency: req.Currency,
},
onStatus,
)
if err != nil {
status := http.StatusBadGateway
if errors.Is(err, paymentsvc.ErrPaymentInProgress) {
status = http.StatusConflict
}
logging.Error(
types.ServiceName,
err.Error(),
"Payment provider error",
string(op),
req.Reference,
app.cfg.Hotel,
app.cfg.Kiosk,
)
response.Status.Code = status
response.Status.Message = http.StatusText(status)
response.Data = buildPaymentFailureURL(types.ResultError, err.Error())
if !streamStarted {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
writeTransactionResult(w, status, response)
return
}
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
return
}
if result == nil {
response.Status.Code = http.StatusBadGateway
response.Status.Message = "Empty payment result"
response.Data = buildPaymentFailureURL(
types.ResultError,
"Payment provider returned an empty result",
)
if !streamStarted {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
writeTransactionResult(w, http.StatusBadGateway, response)
return
}
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
return
}
response.Status.Code = http.StatusOK
if result.Success && strings.EqualFold(result.Status, "APPROVED") {
printer.PrintSaleReceipt(result.CustomerReceipt)
response.Status.Message = result.Message
response.Data = buildPaymentSuccessURL(result)
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
return
}
description := result.ErrorMessage
if description == "" {
description = result.Message
}
if description == "" {
description = result.Status
}
log.Printf("Transaction failed: %s", description)
printer.PrintSaleReceipt(result.CustomerReceipt)
response.Status.Message = "Payment unsuccessful"
response.Data = buildPaymentFailureURL(types.ResultError, description)
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
}
func buildPaymentRequestID(reference string) string {
const prefix = "REQ_"
const maxLength = 60
suffix := fmt.Sprintf("_%d", time.Now().UnixMilli())
maxReferenceLength := maxLength - len(prefix) - len(suffix)
runes := []rune(reference)
if len(runes) > maxReferenceLength {
runes = runes[:maxReferenceLength]
}
return prefix + string(runes) + suffix
}
func setPaymentCORS(w http.ResponseWriter) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json")
}
func buildPaymentSuccessURL(result *paymentsvc.Result) string {
// txnReference := result.ReferenceNumber
// if txnReference == "" {
// txnReference = result.TransactionID
// }
q := url.Values{}
q.Set("CardNumber", hex.EncodeToString([]byte(result.CardNumber)))
q.Set("CardType", hex.EncodeToString([]byte(result.CardType)))
q.Set("ExpiryDate", hex.EncodeToString([]byte(result.ExpiryDate)))
q.Set("TxnReference", result.RequestID)
q.Set("CardHash", hex.EncodeToString([]byte(result.CardHash)))
q.Set("CardReference", hex.EncodeToString([]byte(result.CardReference)))
return (&url.URL{
Path: types.CheckinSuccessfulEndpoint,
RawQuery: q.Encode(),
}).String()
}
func buildPaymentFailureURL(msgType, description string) string {
log.WithFields(log.Fields{
types.LogFieldError: msgType,
types.LogFieldDescription: description,
}).Error("Transaction failed")
q := url.Values{}
q.Set("MsgType", msgType)
q.Set("Description", description)
return (&url.URL{
Path: types.CheckinUnsuccessfulEndpoint,
RawQuery: q.Encode(),
}).String()
}
+162
View File
@@ -0,0 +1,162 @@
package handlers
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
type paymentProviderFunc func(
context.Context,
paymentsvc.SaleRequest,
paymentsvc.StatusHandler,
) (*paymentsvc.Result, error)
func (f paymentProviderFunc) Sale(
ctx context.Context,
request paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
return f(ctx, request, onStatus)
}
func TestSalePaymentStreamsTerminalUnavailableAsAuthoritativeUnsuccessfulResult(t *testing.T) {
provider := paymentProviderFunc(func(
_ context.Context,
request paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.TerminalUnavailable})
return &paymentsvc.Result{
RequestID: request.RequestID,
Operation: "SALE",
Status: "TERMINAL_UNAVAILABLE",
ErrorMessage: "Payment terminal is unavailable",
Amount: request.Amount,
Currency: request.Currency,
DeviceUsed: "terminal-1",
DeviceType: "Dojo Terminal",
}, nil
})
recorder := performSalePaymentRequest(t, provider)
if recorder.Code != http.StatusOK {
t.Fatalf("outer status = %d, want %d", recorder.Code, http.StatusOK)
}
messages := decodePaymentStream(t, recorder.Body)
if len(messages) != 3 {
t.Fatalf("stream messages = %#v, want two statuses and one result", messages)
}
if messages[0].Type != "status" || messages[0].Code != paymentstatus.Starting ||
messages[1].Type != "status" || messages[1].Code != paymentstatus.TerminalUnavailable {
t.Fatalf("status frames = %#v", messages[:2])
}
final := messages[2]
if final.Type != "result" || final.Response == nil {
t.Fatalf("final frame = %#v", final)
}
if final.Response.Status.Code != http.StatusOK {
t.Fatalf("nested status = %d, want %d", final.Response.Status.Code, http.StatusOK)
}
resultURL, err := url.Parse(final.Response.Data)
if err != nil {
t.Fatal(err)
}
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
}
if got := resultURL.Query().Get("Description"); got != "Payment terminal is unavailable" {
t.Fatalf("Description = %q", got)
}
body := recorder.Body.String()
for _, forbidden := range []string{
"Dojo returned HTTP 409",
"offline or currently in use",
"traceId",
"docs.dojo.tech",
} {
if strings.Contains(body, forbidden) {
t.Fatalf("stream exposed %q: %s", forbidden, body)
}
}
}
func TestSalePaymentRetainsNestedBadGatewayForProviderErrorsAfterStreamingStarts(t *testing.T) {
provider := paymentProviderFunc(func(
_ context.Context,
_ paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
return nil, errors.New("provider failed")
})
recorder := performSalePaymentRequest(t, provider)
if recorder.Code != http.StatusOK {
t.Fatalf("outer status = %d, want streaming status %d", recorder.Code, http.StatusOK)
}
messages := decodePaymentStream(t, recorder.Body)
if len(messages) != 2 || messages[1].Type != "result" || messages[1].Response == nil {
t.Fatalf("stream messages = %#v", messages)
}
if messages[1].Response.Status.Code != http.StatusBadGateway {
t.Fatalf("nested status = %d, want %d", messages[1].Response.Status.Code, http.StatusBadGateway)
}
resultURL, err := url.Parse(messages[1].Response.Data)
if err != nil {
t.Fatal(err)
}
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
}
}
func performSalePaymentRequest(t *testing.T, provider paymentsvc.Provider) *httptest.ResponseRecorder {
t.Helper()
app := &App{
paymentService: paymentsvc.NewService(provider),
cfg: &config.ConfigRec{
Hotel: "HOTEL",
Kiosk: 7,
TimeoutSeconds: 5,
},
}
request := httptest.NewRequest(
http.MethodPost,
"/api/payment/sale",
strings.NewReader(`{"reference":"BOOKING-123","amount":10852,"currency":"GBP"}`),
)
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
app.salePayment(recorder, request)
return recorder
}
func decodePaymentStream(t *testing.T, body io.Reader) []paymentStreamMessage {
t.Helper()
decoder := json.NewDecoder(body)
var messages []paymentStreamMessage
for {
var message paymentStreamMessage
if err := decoder.Decode(&message); err != nil {
if errors.Is(err, io.EOF) {
return messages
}
t.Fatal(err)
}
messages = append(messages, message)
}
}
@@ -9,11 +9,11 @@ import (
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/types"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
)
@@ -59,7 +59,7 @@ func (app *App) testIssueDoorCard(w http.ResponseWriter, r *http.Request) {
// Ensure dispenser ready (card at encoder) BEFORE we attempt encoding.
// With queued dispenser ops, this will not clash with polling.
status, err := app.disp.DispenserStart(r.Context())
status, err := app.disp.PrepareCurrentCard(r.Context())
app.SetCardWellStatus(status)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
@@ -91,7 +91,7 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json")
status, err := payment.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk)
status, err := creditcall.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "fetchChipDNAStatus", string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, err.Error())
@@ -111,7 +111,7 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) {
func (app *App) onChipDNAError(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("onChipDNAError")
var tr payment.TransactionResultXML
var tr creditcall.TransactionResultXML
title := "ChipDNA Error"
message := ""
@@ -168,10 +168,10 @@ func (app *App) onChipDNAError(w http.ResponseWriter, r *http.Request) {
switch e.Key {
case payment.KeyErrors:
case creditcall.KeyErrors:
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, title, e.Value)
case payment.KeyIsAvailable:
case creditcall.KeyIsAvailable:
isAvailable := strings.EqualFold(e.Value, "true")
app.handleAvailabilityDebounced(isAvailable)
}
@@ -1,15 +1,16 @@
// Package lockserver provides functionality for interacting with Assa Abloy lock servers.
package lockserver
import (
"fmt"
"net"
"time"
"strings"
"time"
log "github.com/sirupsen/logrus"
)
// Build key encoding request command for the Assa Abloy lock server.
// BuildCommand builds a key encoding request command for the Assa Abloy lock server.
func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
ci := checkIn.Format("200601021504")
co := checkOut.Format("200601021504")
@@ -18,7 +19,7 @@ func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
return nil
}
// Checks heart beat of the Assa Abloy lock server and perform key encoding
// LockSequence checks heartbeat of the Assa Abloy lock server and performs key encoding
func (lock *AssaLockServer) LockSequence() error {
const funcName = "AssaLockServer.LockSequence"
@@ -71,4 +72,3 @@ func parseAssaResponse(raw string) (string, error) {
}
return "Success: " + clean, nil
}
+291
View File
@@ -0,0 +1,291 @@
package lockserver
import (
"bufio"
"fmt"
"net"
"net/url"
"strings"
"time"
log "github.com/sirupsen/logrus"
)
const (
kabaSTX = 0x02
kabaETX = 0x03
kabaACK = 0x06
kabaNAK = 0x15
)
// BuildCommand builds a key encoding request command for the dormakaba/Kaba lock server.
// KR|KTD|WS192.168.135.20|KC2|RN41|KO000000|GA241213|TI16:56|GD241214|DT11:00|G#75|
func (lock *KabaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
const funcName = "DormakabaLockServer.BuildCommand"
room := strings.TrimSpace(doorReq.RoomField)
if room == "" {
return fmt.Errorf("[%s] roomField is required", funcName)
}
if checkIn.IsZero() {
return fmt.Errorf("[%s] checkin time is required", funcName)
}
if checkOut.IsZero() {
return fmt.Errorf("[%s] checkout time is required", funcName)
}
ws := dormakabaWorkstationID()
ga := checkIn.Format("060102") // yyMMdd, example: 241213
gd := checkOut.Format("060102") // yyMMdd, example: 241214
ti := checkIn.Format("15:04") // HH:mm, example: 16:56
dt := checkOut.Format("15:04") // HH:mm, example: 11:00
payload := fmt.Sprintf(
"KR|KTD|WS%s|KC%s|RN%s|KO000000|GA%s|TI%s|GD%s|DT%s|G#75|",
ws,
lock.encoderAddr,
room,
ga,
ti,
gd,
dt,
)
lock.command = wrapKabaFrame(payload)
return nil
}
// LockSequence starts the link and performs key encoding.
func (lock *KabaLockServer) LockSequence() error {
const funcName = "KabaLockServer.LockSequence"
conn, err := InitializeServerConnection(LockServerURL)
if err != nil {
return err
}
defer conn.Close()
reader := bufio.NewReader(conn)
regs, err := lock.linkStart(conn, reader)
if err != nil {
return fmt.Errorf("[%s] linkStart failed: %v", funcName, err)
}
for _, reg := range regs {
log.Printf("Received: %q", reg)
}
raw, err := lock.requestEncoding(conn, reader)
if err != nil {
return fmt.Errorf("[%s] request encoding failed: %v", funcName, err)
}
log.Infof("Encoding response: %s", raw)
return nil
}
// linkStart sends the dormakaba/Kaba LS command.
// LS|DA241213|TI165607|WS192.168.135.20|PW1234|
func (lock *KabaLockServer) linkStart(conn net.Conn, reader *bufio.Reader) ([]string, error) {
ws := dormakabaWorkstationID()
pw := dormakabaPassword()
payload := fmt.Sprintf(
"LS|DA%s|TI%s|WS%s|PW%s|",
time.Now().Format("060102"), // yyMMdd
time.Now().Format("150405"), // HHmmss
ws,
pw,
)
command := wrapKabaFrame(payload)
log.Printf("Sending Link Start command: %q", command)
if _, err := conn.Write(command); err != nil {
return nil, fmt.Errorf("failed to send Link Start command: %v", err)
}
var registers []string
timeout := 10 * time.Second
for {
conn.SetReadDeadline(time.Now().Add(timeout))
b, err := reader.ReadByte()
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
if len(registers) > 0 {
return registers, nil
}
}
return nil, fmt.Errorf("error reading Link Start response: %v", err)
}
switch b {
case kabaACK:
registers = append(registers, "ACK")
continue
case kabaNAK:
return registers, fmt.Errorf("received NAK after Link Start")
case kabaSTX:
frame, err := readKabaFrame(conn, reader, b, timeout)
if err != nil {
return registers, fmt.Errorf("failed to read Link Start frame: %v", err)
}
frameText := string(frame)
registers = append(registers, frameText)
clean := cleanKabaFrame(frameText)
if strings.HasPrefix(clean, "LA|") {
return registers, nil
}
default:
log.Warnf("Ignoring unexpected byte during Link Start: 0x%X", b)
}
}
}
func (lock *KabaLockServer) requestEncoding(conn net.Conn, reader *bufio.Reader) (string, error) {
log.Printf("Sending Encoding command: %q", lock.command)
if _, err := conn.Write(lock.command); err != nil {
return "", fmt.Errorf("failed to send Encoding command: %v", err)
}
deadline := time.Now().Add(60 * time.Second)
for {
remaining := time.Until(deadline)
if remaining <= 0 {
return "", fmt.Errorf("timeout waiting for dormakaba encoding response")
}
conn.SetReadDeadline(time.Now().Add(remaining))
b, err := reader.ReadByte()
if err != nil {
return "", fmt.Errorf("error reading encoding response: %v", err)
}
switch b {
case kabaACK:
log.Debug("Received ACK after Encoding command")
continue
case kabaNAK:
return "", fmt.Errorf("received NAK after Encoding command")
case kabaSTX:
frame, err := readKabaFrame(conn, reader, b, 60*time.Second)
if err != nil {
return "", fmt.Errorf("failed to read encoding response frame: %v", err)
}
raw := string(frame)
clean := cleanKabaFrame(raw)
log.Printf("Received Encoding frame: %q", clean)
if strings.HasPrefix(clean, "KA|") {
return parseDormakabaEncodingResponse(clean)
}
log.Warnf("Ignoring non-KA frame while waiting for encoding result: %q", clean)
default:
log.Warnf("Ignoring unexpected byte while waiting for encoding response: 0x%X", b)
}
}
}
func parseDormakabaEncodingResponse(clean string) (string, error) {
if strings.Contains(clean, "|ASOK|") {
return "Success: " + clean, nil
}
if strings.Contains(clean, "|AS") {
return "", fmt.Errorf("negative dormakaba response: %s", clean)
}
return "", fmt.Errorf("unexpected dormakaba response: %s", clean)
}
func readKabaFrame(conn net.Conn, reader *bufio.Reader, firstByte byte, timeout time.Duration) ([]byte, error) {
frame := []byte{firstByte}
for {
conn.SetReadDeadline(time.Now().Add(timeout))
b, err := reader.ReadByte()
if err != nil {
return frame, fmt.Errorf("error reading frame body: %w", err)
}
frame = append(frame, b)
if b == kabaETX {
return frame, nil
}
}
}
func wrapKabaFrame(payload string) []byte {
command := make([]byte, 0, len(payload)+2)
command = append(command, kabaSTX)
command = append(command, []byte(payload)...)
command = append(command, kabaETX)
return command
}
func cleanKabaFrame(raw string) string {
return strings.Trim(raw, string([]byte{kabaSTX, kabaETX}))
}
func dormakabaPassword() string {
if strings.TrimSpace(Cert) != "" {
return strings.TrimSpace(Cert)
}
return "1234"
}
func dormakabaWorkstationID() string {
parsed, err := url.Parse(LockServerURL)
if err == nil && parsed.Host != "" {
host := parsed.Host
if h, _, splitErr := net.SplitHostPort(host); splitErr == nil {
return h
}
return strings.Trim(host, "/")
}
raw := strings.TrimSpace(LockServerURL)
raw = strings.TrimPrefix(raw, "http://")
raw = strings.TrimPrefix(raw, "https://")
raw = strings.Trim(raw, "/")
if h, _, splitErr := net.SplitHostPort(raw); splitErr == nil {
return h
}
if idx := strings.Index(raw, ":"); idx >= 0 {
return raw[:idx]
}
return raw
}
@@ -25,10 +25,11 @@ const (
Omnitec = "omnitec"
Salto = "salto"
TLJ = "tlj"
Dormakaba = "kaba"
)
var (
Cert string
Cert string
LockServerURL string
)
@@ -38,6 +39,11 @@ type (
LockSequence() error
}
KabaLockServer struct {
encoderAddr string
command []byte
}
AssaLockServer struct {
encoderAddr string
command string
@@ -69,22 +75,24 @@ func NewLockServer(lockType, encoderAddr string, fatalError func(error)) LockSer
return &SaltoLockServer{encoderAddr: encoderAddr}
case TLJ:
return &TLJLockServer{encoderAddr: encoderAddr}
case Dormakaba:
return &KabaLockServer{encoderAddr: encoderAddr}
default:
fatalError(fmt.Errorf("unsupported LockType: %s; must be 'assaabloy' or 'omnitec'", lockType))
return nil // This line will never be reached, but is needed to satisfy the compiler
}
}
func InitializeServerConnection(LockserverUrl string) (net.Conn, error) {
func InitializeServerConnection(LockserverURL string) (net.Conn, error) {
const funcName = "InitializeServerConnection"
// Parse the URL to extract host and port
parsedUrl, err := url.Parse(LockserverUrl)
parsedURL, err := url.Parse(LockserverURL)
if err != nil {
return nil, fmt.Errorf("[%s] failed to parse LockserverUrl: %v", funcName, err)
return nil, fmt.Errorf("[%s] failed to parse LockserverURL: %v", funcName, err)
}
// Remove any leading/trailing slashes just in case
address := strings.Trim(parsedUrl.Host, "/")
address := strings.Trim(parsedURL.Host, "/")
// Establish a TCP connection to the Visionline server
conn, err := net.Dial("tcp", address)
@@ -7,12 +7,12 @@ import (
"os"
"strconv"
"strings"
"time"
"time"
log "github.com/sirupsen/logrus"
)
// Build key encoding request command for the Omnitec lock server.
// BuildCommand builds key encoding request command for the Omnitec lock server.
func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error {
const funcName = "OmniLockServer.BuildCommand"
hostname, err := os.Hostname()
@@ -25,7 +25,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
if err != nil {
return fmt.Errorf("[%s] failed to convert lockId to integer: %v", funcName, err)
}
formattedLockId := fmt.Sprintf("%04d", idInt)
formattedLockID := fmt.Sprintf("%04d", idInt)
// Format date/time parts
dt := checkOut.Format("15:04") // DT = HH:mm
@@ -37,7 +37,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
payload := fmt.Sprintf(
"KR|KC%s|KTD|RN%s|%s|DT%s|G#75|GA%s|GD%s|KO0000|DA%s|TI%s|",
lock.encoderAddr,
formattedLockId,
formattedLockID,
hostname,
dt,
ga,
@@ -52,7 +52,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
return nil
}
// Starts link to the Omnitec lock server and perform key encoding
// LockSequence starts link to the Omnitec lock server and perform key encoding
func (lock *OmniLockServer) LockSequence() error {
const funcName = "OmniLockServer.LockSequence"
@@ -136,4 +136,4 @@ func parseOmniResponse(raw string) (string, error) {
return "", fmt.Errorf("negative response code: %s", clean)
}
return "Success: " + clean, nil
}
}
+449
View File
@@ -0,0 +1,449 @@
package paybridge
import (
"context"
"encoding/json"
"fmt"
"net/url"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
"github.com/gorilla/websocket"
log "github.com/sirupsen/logrus"
)
type Client struct {
URL string
APIKey string
TimeoutSeconds int
}
func NewClient(url, apiKey string, timeoutSeconds int) *Client {
if timeoutSeconds <= 0 {
timeoutSeconds = 300
}
return &Client{
URL: url,
APIKey: apiKey,
TimeoutSeconds: timeoutSeconds,
}
}
func (c *Client) Sale(ctx context.Context, req paymentsvc.SaleRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
if req.Currency == "" {
req.Currency = "GBP"
}
payBridgeReq := PaymentRequest{
RequestID: req.RequestID,
Amount: req.Amount,
Currency: req.Currency,
Operation: "SALE",
TimeoutSeconds: c.TimeoutSeconds,
}
return c.doPayment(ctx, payBridgeReq, onStatus)
}
func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
emitStatus(onStatus, paymentstatus.Starting)
connectURL, err := c.connectURL()
if err != nil {
return nil, err
}
ws, _, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
if err != nil {
return nil, fmt.Errorf("%w: %v", ErrConnectionFailed, err)
}
defer ws.Close()
done := make(chan struct{})
defer close(done)
go func() {
select {
case <-ctx.Done():
_ = ws.Close()
case <-done:
}
}()
jwt, err := c.readAuthSuccess(ws)
if err != nil {
return nil, err
}
log.Info("PayBridge authentication successful")
emitStatus(onStatus, paymentstatus.Started)
if err := ws.WriteJSON(Envelope{
Type: types.MesTypePaymentRequest,
JWT: jwt,
Data: req,
Timestamp: time.Now().UnixMilli(),
}); err != nil {
return nil, fmt.Errorf("send PayBridge payment_request: %w", err)
}
log.WithFields(log.Fields{
"requestId": req.RequestID,
"operation": req.Operation,
"amount": req.Amount,
"currency": req.Currency,
}).Info("PayBridge payment request sent")
emitStatus(onStatus, paymentstatus.RequestSent)
for {
_, raw, err := ws.ReadMessage()
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("read PayBridge message: %w", err)
}
var head struct {
Type string `json:"type"`
}
if err := json.Unmarshal(raw, &head); err != nil {
return nil, fmt.Errorf("decode PayBridge message header: %w", err)
}
messageType := strings.ToLower(head.Type)
switch messageType {
case types.MesTypePaymentStatusUpdate:
var update StatusUpdateEnvelope
if err := json.Unmarshal(raw, &update); err != nil {
return nil, fmt.Errorf("decode payment_status_update: %w", err)
}
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Info("PayBridge status update")
statusCode, known := mapPayBridgeStatus(
update.Data.Status,
update.Data.Code,
)
if !known {
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Warn("Unknown PayBridge status update")
}
emitStatus(onStatus, statusCode)
case types.MesTypePaymentAccepted:
log.Info("PayBridge payment request accepted")
emitStatus(onStatus, paymentstatus.Accepted)
case types.MesTypePaymentResult:
var result PaymentResultEnvelope
// log.Println("PayBridge payment result raw:", string(raw))
if err := json.Unmarshal(raw, &result); err != nil {
return nil, fmt.Errorf("decode payment_result: %w", err)
}
mapped := mapPaymentResult(result)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"success": mapped.Success,
}).Info("PayBridge payment result received")
emitStatus(
onStatus,
mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
)
return mapped, nil
case types.MesTypePaymentError:
var paymentErr PaymentErrorEnvelope
if err := json.Unmarshal(raw, &paymentErr); err != nil {
return nil, fmt.Errorf("decode payment_error: %w", err)
}
mapped := mapPaymentError(req, paymentErr)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"error": mapped.ErrorMessage,
}).Warn("PayBridge payment error received")
emitStatus(
onStatus,
mapPayBridgeFinalStatus(mapped.Status, false),
)
return mapped, nil
case types.ResultError:
var genericErr struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(raw, &genericErr); err != nil {
return nil, fmt.Errorf(
"%w: %s",
ErrUnexpectedMessage,
string(raw),
)
}
log.WithFields(log.Fields{
"code": genericErr.Error.Code,
"message": genericErr.Error.Message,
}).Error("PayBridge error message received")
emitStatus(onStatus, paymentstatus.Error)
if genericErr.Error.Message != "" {
return nil, fmt.Errorf(
"%w: %s: %s",
ErrUnexpectedMessage,
genericErr.Error.Code,
genericErr.Error.Message,
)
}
return nil, fmt.Errorf(
"%w: %s",
ErrUnexpectedMessage,
string(raw),
)
case types.MesTypeAuthSuccess:
log.Info("Additional PayBridge auth_success message received")
default:
log.WithField(
"messageType",
head.Type,
).Warn("Unknown PayBridge intermediate message type")
emitStatus(onStatus, paymentstatus.Processing)
}
}
}
func (c *Client) connectURL() (string, error) {
u, err := url.Parse(c.URL)
if err != nil {
return "", fmt.Errorf(
"parse PayBridge WebSocket URL: %w",
err,
)
}
q := u.Query()
q.Set("api_key", c.APIKey)
u.RawQuery = q.Encode()
return u.String(), nil
}
func (c *Client) readAuthSuccess(ws *websocket.Conn) (string, error) {
if err := ws.SetReadDeadline(
time.Now().Add(10 * time.Second),
); err != nil {
return "", fmt.Errorf(
"%w: set auth read deadline: %v",
ErrAuthFailed,
err,
)
}
defer ws.SetReadDeadline(time.Time{})
_, raw, err := ws.ReadMessage()
if err != nil {
return "", fmt.Errorf(
"%w: read auth_success: %v",
ErrAuthFailed,
err,
)
}
var auth struct {
Type string `json:"type"`
JWT string `json:"jwt"`
}
if err := json.Unmarshal(raw, &auth); err != nil {
return "", fmt.Errorf(
"%w: decode auth_success: %v",
ErrAuthFailed,
err,
)
}
if !strings.EqualFold(
auth.Type,
types.MesTypeAuthSuccess,
) {
return "", fmt.Errorf(
"%w: expected auth_success, got %s: %s",
ErrAuthFailed,
auth.Type,
string(raw),
)
}
if auth.JWT == "" {
return "", fmt.Errorf(
"%w: auth_success did not contain jwt",
ErrAuthFailed,
)
}
return auth.JWT, nil
}
func emitStatus(
onStatus paymentsvc.StatusHandler,
code string,
) {
if onStatus == nil || code == "" {
return
}
onStatus(paymentsvc.StatusUpdate{
Code: code,
})
}
func mapPayBridgeStatus(
status string,
code string,
) (string, bool) {
normalizedStatus := strings.ToLower(
strings.TrimSpace(status),
)
switch normalizedStatus {
case payBridgeMessageInsertOrSwipeCard,
payBridgeMessageInsertSwipeOrPresentCard:
return paymentstatus.PresentCard, true
case payBridgeMessageInsertCard:
return paymentstatus.InsertCard, true
case payBridgeMessagePleaseWait:
return paymentstatus.PleaseWait, true
case payBridgeMessageDoNotRemoveCard:
return paymentstatus.DoNotRemoveCard, true
case payBridgeMessageTryAnotherInterface:
return paymentstatus.TryAnotherInterface, true
case payBridgeMessagePIN:
return paymentstatus.EnterPIN, true
case payBridgeMessagePINAgain:
return paymentstatus.EnterPINAgain, true
case payBridgeMessageTransactionCancelled:
return paymentstatus.Cancelled, true
case payBridgeMessageProcessing:
return paymentstatus.Processing, true
case payBridgeMessageApproved:
// Это ещё промежуточный статус.
// Финальный успех определяется только по payment_result.
return paymentstatus.Authorized, true
case payBridgeMessageDeclined:
return paymentstatus.Declined, true
}
// Fallback по фактически обнаруженным кодам терминала.
switch strings.TrimSpace(code) {
case payBridgeCodeInsertCard:
return paymentstatus.InsertCard, true
case payBridgeCodeEnterPIN:
return paymentstatus.EnterPIN, true
case payBridgeCodeCancelled:
return paymentstatus.Cancelled, true
case payBridgeCodePleaseWait:
return paymentstatus.PleaseWait, true
case payBridgeCodePresentCard, payBridgeCodePresentCardAlternate:
return paymentstatus.PresentCard, true
case payBridgeCodeEnterPINAgain:
return paymentstatus.EnterPINAgain, true
case payBridgeCodeTryAnotherInterface:
return paymentstatus.TryAnotherInterface, true
case payBridgeCodeDoNotRemoveCard:
return paymentstatus.DoNotRemoveCard, true
}
// Пока назначение кодов 200, 201, 205 и 210 неизвестно.
// Они останутся в логах, но на экране будет общий статус.
return paymentstatus.Processing, false
}
func mapPayBridgeFinalStatus(
status string,
success bool,
) string {
if success && strings.EqualFold(status, payBridgeFinalStatusApproved) {
return paymentstatus.Approved
}
switch strings.ToUpper(status) {
case payBridgeFinalStatusDeclined:
return paymentstatus.Declined
case payBridgeFinalStatusCancelled:
return paymentstatus.Cancelled
case payBridgeFinalStatusTimeout:
return paymentstatus.Timeout
case payBridgeFinalStatusVoided:
return paymentstatus.Voided
case payBridgeFinalStatusVoidedDailyLimitExceeded:
return paymentstatus.DailyLimitExceeded
case payBridgeFinalStatusDailyLimitVoidFailed:
return paymentstatus.VoidFailed
case payBridgeFinalStatusDailyLimitValidationError:
return paymentstatus.LimitValidationError
case payBridgeFinalStatusError, payBridgeFinalStatusFailed:
return paymentstatus.Error
default:
return paymentstatus.Error
}
}
+9
View File
@@ -0,0 +1,9 @@
package paybridge
import "errors"
var (
ErrConnectionFailed = errors.New("paybridge connection failed")
ErrAuthFailed = errors.New("paybridge authentication failed")
ErrUnexpectedMessage = errors.New("paybridge unexpected message")
)
+47
View File
@@ -0,0 +1,47 @@
package paybridge
import "gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
func mapPaymentResult(res PaymentResultEnvelope) *paymentsvc.Result {
var merchantReceipt string
if res.Data.ReceiptData.Merchant != nil {
merchantReceipt = *res.Data.ReceiptData.Merchant
}
return &paymentsvc.Result{
Success: res.Data.Success,
TransactionID: res.Data.TransactionID,
RequestID: res.Data.RequestID,
Operation: res.Data.Operation,
Status: res.Data.Status,
Message: res.Data.Message,
ErrorMessage: res.Data.ErrorMessage,
Amount: res.Data.Amount,
Currency: res.Data.Currency,
AuthCode: res.Data.AuthCode,
DeviceUsed: res.Data.DeviceUsed,
DeviceType: res.Data.DeviceType,
ReferenceNumber: res.Data.ReferenceNumber,
LastFourDigits: res.Data.LastFourDigits,
CardType: res.Data.CardType,
CardNumber: res.Data.CardNumber,
ExpiryDate: res.Data.ExpiryDate,
CardHash: res.Data.CardHash,
CardReference: res.Data.CardReference,
CustomerReceipt: res.Data.ReceiptData.Customer,
MerchantReceipt: merchantReceipt,
}
}
func mapPaymentError(req PaymentRequest, res PaymentErrorEnvelope) *paymentsvc.Result {
return &paymentsvc.Result{
Success: false,
TransactionID: res.Data.TransactionID,
RequestID: req.RequestID,
Operation: req.Operation,
Status: res.Data.Status,
ErrorMessage: res.Data.Error,
Amount: req.Amount,
Currency: req.Currency,
}
}
+41
View File
@@ -0,0 +1,41 @@
package paybridge
const (
payBridgeFinalStatusApproved = "APPROVED"
payBridgeFinalStatusDeclined = "DECLINED"
payBridgeFinalStatusCancelled = "CANCELLED"
payBridgeFinalStatusTimeout = "TIMEOUT"
payBridgeFinalStatusVoided = "VOIDED"
payBridgeFinalStatusVoidedDailyLimitExceeded = "VOIDED_DAILY_LIMIT_EXCEEDED"
payBridgeFinalStatusDailyLimitVoidFailed = "DAILY_LIMIT_EXCEEDED_VOID_FAILED"
payBridgeFinalStatusDailyLimitValidationError = "DAILY_LIMIT_VALIDATION_ERROR"
payBridgeFinalStatusError = "ERROR"
payBridgeFinalStatusFailed = "FAILED"
)
const (
payBridgeMessageInsertOrSwipeCard = "insert or swipe card"
payBridgeMessageInsertSwipeOrPresentCard = "insert, swipe or present card"
payBridgeMessageInsertCard = "insert card"
payBridgeMessagePleaseWait = "please wait"
payBridgeMessageDoNotRemoveCard = "please wait. do not remove card"
payBridgeMessageTryAnotherInterface = "please try another interface"
payBridgeMessagePIN = "pin"
payBridgeMessagePINAgain = "pin again"
payBridgeMessageTransactionCancelled = "transaction cancelled"
payBridgeMessageProcessing = "processing"
payBridgeMessageApproved = "approved"
payBridgeMessageDeclined = "declined"
)
const (
payBridgeCodeInsertCard = "101"
payBridgeCodeEnterPIN = "106"
payBridgeCodeCancelled = "124"
payBridgeCodePleaseWait = "1017"
payBridgeCodePresentCard = "1109"
payBridgeCodePresentCardAlternate = "1113"
payBridgeCodeEnterPINAgain = "1129"
payBridgeCodeTryAnotherInterface = "1274"
payBridgeCodeDoNotRemoveCard = "1312"
)
+125
View File
@@ -0,0 +1,125 @@
package paybridge
import (
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
func TestMapPayBridgeFinalStatus(t *testing.T) {
tests := []struct {
name string
status string
success bool
want string
}{
{"approved success", "APPROVED", true, paymentstatus.Approved},
{"approved without success", "APPROVED", false, paymentstatus.Error},
{"declined", "DECLINED", false, paymentstatus.Declined},
{"cancelled", "CANCELLED", false, paymentstatus.Cancelled},
{"timeout", "TIMEOUT", false, paymentstatus.Timeout},
{"voided", "VOIDED", false, paymentstatus.Voided},
{"voided daily limit exceeded", "VOIDED_DAILY_LIMIT_EXCEEDED", false, paymentstatus.DailyLimitExceeded},
{"daily limit void failed", "DAILY_LIMIT_EXCEEDED_VOID_FAILED", false, paymentstatus.VoidFailed},
{"daily limit validation error", "DAILY_LIMIT_VALIDATION_ERROR", false, paymentstatus.LimitValidationError},
{"error", "ERROR", false, paymentstatus.Error},
{"failed", "FAILED", false, paymentstatus.Error},
{"unknown", "UNKNOWN", false, paymentstatus.Error},
{"approved case insensitive", "approved", true, paymentstatus.Approved},
{"declined case insensitive", "declined", false, paymentstatus.Declined},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
got := mapPayBridgeFinalStatus(test.status, test.success)
if got != test.want {
t.Fatalf("got %q, want %q", got, test.want)
}
})
}
}
func TestMapPayBridgeStatusMessages(t *testing.T) {
tests := []struct {
name string
status string
want string
}{
{"insert or swipe card", "insert or swipe card", paymentstatus.PresentCard},
{"insert swipe or present card", "insert, swipe or present card", paymentstatus.PresentCard},
{"insert card", "insert card", paymentstatus.InsertCard},
{"please wait", "please wait", paymentstatus.PleaseWait},
{"do not remove card", "please wait. do not remove card", paymentstatus.DoNotRemoveCard},
{"try another interface", "please try another interface", paymentstatus.TryAnotherInterface},
{"pin", "pin", paymentstatus.EnterPIN},
{"pin again", "pin again", paymentstatus.EnterPINAgain},
{"transaction cancelled", "transaction cancelled", paymentstatus.Cancelled},
{"processing", "processing", paymentstatus.Processing},
{"approved", "approved", paymentstatus.Authorized},
{"declined", "declined", paymentstatus.Declined},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
got, matched := mapPayBridgeStatus(test.status, "")
if !matched {
t.Fatal("expected status to match")
}
if got != test.want {
t.Fatalf("got %q, want %q", got, test.want)
}
})
}
}
func TestMapPayBridgeStatusCodes(t *testing.T) {
tests := []struct {
name string
code string
want string
}{
{"insert card", "101", paymentstatus.InsertCard},
{"enter pin", "106", paymentstatus.EnterPIN},
{"cancelled", "124", paymentstatus.Cancelled},
{"please wait", "1017", paymentstatus.PleaseWait},
{"present card", "1109", paymentstatus.PresentCard},
{"present card alternate", "1113", paymentstatus.PresentCard},
{"enter pin again", "1129", paymentstatus.EnterPINAgain},
{"try another interface", "1274", paymentstatus.TryAnotherInterface},
{"do not remove card", "1312", paymentstatus.DoNotRemoveCard},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
got, matched := mapPayBridgeStatus("", test.code)
if !matched {
t.Fatal("expected code to match")
}
if got != test.want {
t.Fatalf("got %q, want %q", got, test.want)
}
})
}
}
func TestMapPayBridgeStatusNormalization(t *testing.T) {
got, matched := mapPayBridgeStatus(" PiN AgAiN ", "")
if !matched || got != paymentstatus.EnterPINAgain {
t.Fatalf("normalized message got (%q, %t), want (%q, true)", got, matched, paymentstatus.EnterPINAgain)
}
got, matched = mapPayBridgeStatus("", " 101 ")
if !matched || got != paymentstatus.InsertCard {
t.Fatalf("trimmed code got (%q, %t), want (%q, true)", got, matched, paymentstatus.InsertCard)
}
}
func TestMapPayBridgeStatusUnknown(t *testing.T) {
got, matched := mapPayBridgeStatus("unknown message", "999")
if matched {
t.Fatal("unknown status and code must not match")
}
if got != paymentstatus.Processing {
t.Fatalf("got %q, want %q", got, paymentstatus.Processing)
}
}
+65
View File
@@ -0,0 +1,65 @@
package paybridge
type Envelope struct {
Type string `json:"type"`
Data any `json:"data,omitempty"`
Timestamp int64 `json:"timestamp,omitempty"`
JWT string `json:"jwt,omitempty"`
}
type PaymentRequest struct {
RequestID string `json:"requestId"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
Operation string `json:"operation"`
TimeoutSeconds int `json:"timeoutSeconds,omitempty"`
}
type PaymentResultEnvelope struct {
Type string `json:"type"`
Data struct {
Success bool `json:"success"`
TransactionID string `json:"transactionId"`
RequestID string `json:"requestId"`
Operation string `json:"operation"`
Status string `json:"status"`
Message string `json:"message"`
ErrorMessage string `json:"errorMessage"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
AuthCode string `json:"authCode"`
DeviceUsed string `json:"deviceUsed"`
DeviceType string `json:"deviceType"`
ReferenceNumber string `json:"referenceNumber"`
LastFourDigits string `json:"lastFourDigits"`
CardType string `json:"cardType"`
CardNumber string `json:"cardNumber"`
ExpiryDate string `json:"expiryDate"`
CardHash string `json:"cardHash"`
CardReference string `json:"cardReference"`
ReceiptData struct {
Merchant *string `json:"merchant"`
Customer string `json:"customer"`
} `json:"receiptData"`
} `json:"data"`
}
type PaymentErrorEnvelope struct {
Type string `json:"type"`
Data struct {
TransactionID string `json:"transactionId"`
Error string `json:"error"`
Status string `json:"status"`
} `json:"data"`
}
type StatusUpdateEnvelope struct {
Type string `json:"type"`
Data struct {
Status string `json:"status"`
Code string `json:"code"`
Timestamp int64 `json:"timestamp"`
} `json:"data"`
}
+65
View File
@@ -0,0 +1,65 @@
package paymentsvc
import (
"context"
"errors"
"sync"
)
var (
ErrPaymentInProgress = errors.New("payment is already in progress")
ErrProviderNotConfigured = errors.New("payment provider is not configured")
)
type StatusUpdate struct {
Code string `json:"code"`
}
type StatusHandler func(StatusUpdate)
type Provider interface {
Sale(
ctx context.Context,
req SaleRequest,
onStatus StatusHandler,
) (*Result, error)
}
type Service struct {
provider Provider
mu sync.Mutex
busy bool
}
func NewService(provider Provider) *Service {
return &Service{
provider: provider,
}
}
func (s *Service) Sale(
ctx context.Context,
req SaleRequest,
onStatus StatusHandler,
) (*Result, error) {
if s == nil || s.provider == nil {
return nil, ErrProviderNotConfigured
}
s.mu.Lock()
if s.busy {
s.mu.Unlock()
return nil, ErrPaymentInProgress
}
s.busy = true
s.mu.Unlock()
defer func() {
s.mu.Lock()
s.busy = false
s.mu.Unlock()
}()
return s.provider.Sale(ctx, req, onStatus)
}
+37
View File
@@ -0,0 +1,37 @@
package paymentsvc
type SaleRequest struct {
RequestID string `json:"requestId"`
Reference string `json:"reference"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
}
type Result struct {
Success bool `json:"success"`
RequestID string `json:"requestId,omitempty"`
Operation string `json:"operation,omitempty"`
Status string `json:"status"`
Message string `json:"message,omitempty"`
ErrorMessage string `json:"errorMessage,omitempty"`
TransactionID string `json:"transactionId,omitempty"`
ReferenceNumber string `json:"referenceNumber,omitempty"`
AuthCode string `json:"authCode,omitempty"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
DeviceUsed string `json:"deviceUsed,omitempty"`
DeviceType string `json:"deviceType,omitempty"`
CardNumber string `json:"cardNumber,omitempty"`
LastFourDigits string `json:"lastFourDigits,omitempty"`
CardType string `json:"cardType,omitempty"`
ExpiryDate string `json:"expiryDate,omitempty"`
CardHash string `json:"cardHash,omitempty"`
CardReference string `json:"cardReference,omitempty"`
CustomerReceipt string `json:"customerReceipt,omitempty"`
MerchantReceipt string `json:"merchantReceipt,omitempty"`
}
@@ -13,6 +13,7 @@ import (
"path/filepath"
"strings"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
"github.com/alexbrainman/printer"
log "github.com/sirupsen/logrus"
imagedraw "golang.org/x/image/draw"
@@ -39,6 +40,7 @@ type (
Name string `xml:"customername"`
Checkout string `xml:"checkoutdatetime"`
RoomID string `xml:"roomno"`
Voucher string `xml:"voucher"`
Map string `xml:"roommap"`
Directions string `xml:"roomdirections"`
}
@@ -93,7 +95,30 @@ func ParseCardholderReceipt(data []byte) ([]ReceiptEntryXML, error) {
return tr.ReceiptEntries.ReceiptEntry, nil
}
func readTicketLayout() LayoutOptions {
var layout LayoutOptions
executablePath, err := os.Executable()
if err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to locate application executable: %v", err))
}
layoutName := filepath.Join(filepath.Dir(executablePath), "TicketLayout.xml")
data, err := os.ReadFile(layoutName)
if err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
}
if err := xml.Unmarshal(data, &layout); err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
}
return layout
}
func BuildRoomTicket(details RoomDetailsRec) ([]byte, error) {
Layout = readTicketLayout()
var buf bytes.Buffer
// shortcuts
@@ -141,6 +166,11 @@ func BuildRoomTicket(details RoomDetailsRec) ([]byte, error) {
write([]byte{ESC, 'a', CENTER})
writeStr(Layout.HotelSpecificDetails + "\n\n")
if details.Voucher != "" {
s := strings.Repeat("*", 44)
writeStr(fmt.Sprintf("%s\n\n%s\n\n%s\n\n", s, details.Voucher, s))
}
// 8) Room map image
mapPath := filepath.Join(Layout.RoomMapFolderPath, details.Map)
mapBytes, err := printMap(mapPath)
@@ -179,6 +209,23 @@ func PrintReceipt(receipt string) {
}
}
func PrintSaleReceipt(receipt string) {
if len(receipt) == 0 {
log.Warn("Empty sale receipt, skipping print")
return
}
var buf bytes.Buffer
buf.WriteString(receipt)
buf.WriteByte('\n')
buf.Write([]byte{ESC, 'd', 7})
buf.Write([]byte{GS, 'V', 1})
if err := SendToPrinter(buf.Bytes()); err != nil {
log.Errorf("SendToPrinter error: %v", err)
}
}
func printCardholderReceipt(cardholderReceipt string) error {
receiptEntries, err := ParseCardholderReceipt([]byte(cardholderReceipt))
if err != nil {
+23 -2
View File
@@ -23,6 +23,7 @@ const (
ResultApproved = "approved"
ResultDeclined = "declined"
ResultCancelled = "cancelled"
ResultCanceled = "canceled"
ResultPending = "pending"
ResultStateUncommitted = "uncommitted"
ResultStateVoided = "voided"
@@ -39,8 +40,9 @@ const (
ReceiptDataMerchant = "RECEIPT_DATA_MERCHANT"
ReceiptDataCardholder = "RECEIPT_DATA_CARDHOLDER"
Reference = "REFERENCE"
PAN_MASKED = "PAN_MASKED"
EXPIRY_DATE = "EXPIRY_DATE"
CardType = "CARD_SCHEME_ID"
PanMasked = "PAN_MASKED"
ExpiryDate = "EXPIRY_DATE"
TransactionResult = "TRANSACTION_RESULT"
TransactionType = "TRANSACTION_TYPE"
TransactionState = "TRANSACTION_STATE"
@@ -48,6 +50,25 @@ const (
ConfirmErrors = "CONFIRM_ERRORS"
TotalAmount = "TOTAL_AMOUNT"
// Dojo terminal session statuses
ResultCaptured = "captured"
ResultSignatureAccepted = "signatureverificationaccepted"
ResultInitiateRequested = "initiaterequested"
ResultInitiated = "initiated"
ResultAuthorized = "authorized"
ResultCancelRequested = "cancelrequested"
ResultExpired = "expired"
ResultSignatureRejected = "signatureverificationrejected"
ResultSignatureRequired = "signatureverificationrequired"
//PayBridge message types
MesTypePaymentRequest = "payment_request"
MesTypePaymentResult = "payment_result"
MesTypePaymentError = "payment_error"
MesTypePaymentStatusUpdate = "payment_status_update"
MesTypePaymentAccepted = "payment_accepted"
MesTypeAuthSuccess = "auth_success"
// Log field keys
LogFieldError = "error"
LogFieldDescription = "description"
-243
View File
@@ -1,243 +0,0 @@
package main
import (
"context"
"encoding/xml"
"fmt"
"net/http"
"os"
"os/exec"
"os/signal"
"strings"
"syscall"
"time"
"github.com/tarm/serial"
log "github.com/sirupsen/logrus"
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser"
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers"
"gitea.futuresens.co.uk/futuresens/hardlink/handlers"
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/logging"
"gitea.futuresens.co.uk/futuresens/hardlink/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/printer"
)
const (
buildVersion = "1.2.5"
serviceName = "hardlink"
pollingFrequency = 8 * time.Second
)
func main() {
// Load config
cfg := config.ReadHardlinkConfig()
printer.Layout = readTicketLayout()
printer.PrinterName = cfg.PrinterName
lockserver.Cert = cfg.Cert
lockserver.LockServerURL = cfg.LockserverUrl
mail.SendErrorEmails = cfg.SendErrorEmails
// Root context for background goroutines
// rootCtx, rootCancel := context.WithCancel(context.Background())
// defer rootCancel()
var (
dispPort *serial.Port
disp *dispenser.Client
cardWellStatus string
)
// Setup logging and get file handle
logFile, err := logging.SetupLogging(cfg.LogDir, serviceName, buildVersion)
if err != nil {
log.Printf("Failed to set up logging: %v\n", err)
}
if logFile != nil {
defer logFile.Close()
}
// Initialize dispenser
if !cfg.TestMode {
dispenser.SerialPort = cfg.DispenserPort
dispenser.Address = []byte(cfg.DispenserAdrr)
dispPort, err = dispenser.InitializeDispenser()
if err != nil {
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Dispenser Initialization Error", fmt.Sprintf("Failed to initialize dispenser: %v", err))
errorhandlers.FatalError(err)
}
defer dispPort.Close()
disp = dispenser.NewClient(dispPort, 32)
defer disp.Close()
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
cardWellStatus, err = disp.DispenserPrepare(ctx)
if err != nil {
err = fmt.Errorf("%s; wrong dispenser address: %s", err, cfg.DispenserAdrr)
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Dispenser Preparation Error", err.Error())
errorhandlers.FatalError(err)
}
fmt.Println(cardWellStatus)
}
// Test lock-server connection
switch strings.ToLower(cfg.LockType) {
case lockserver.TLJ:
// TLJ uses HTTP - skip TCP probe here
default:
lockConn, err := lockserver.InitializeServerConnection(cfg.LockserverUrl)
if err != nil {
fmt.Println(err.Error())
log.Errorf(err.Error())
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "Lock Server Connection Error", err.Error())
} else {
fmt.Printf("Connected to the lock server successfuly at %s\n", cfg.LockserverUrl)
log.Infof("Connected to the lock server successfuly at %s", cfg.LockserverUrl)
lockConn.Close()
}
}
database, err := bootstrap.OpenDB(&cfg)
if err != nil {
log.Warnf("DB init failed: %v", err)
}
if database != nil {
defer database.Close()
}
if cfg.IsPayment {
fmt.Println("Payment processing is enabled")
log.Info("Payment processing is enabled")
startChipDnaClient()
// check ChipDNA and PDQ status and log any errors, but continue running even if it fails
go func() {
time.Sleep(30 * time.Second) // give ChipDNA client a moment to start
pdqstatus, err := payment.ReadPdqStatus(cfg.Hotel, cfg.Kiosk)
if err != nil {
mail.SendEmailOnError(cfg.Hotel, cfg.Kiosk, "PDQ Status Read Error", err.Error())
} else {
fmt.Printf("\nPDQ availabile: %v\n", pdqstatus.IsAvailable)
log.Infof("PDQ availabile: %v", pdqstatus.IsAvailable)
}
}()
} else {
fmt.Println("Payment processing is disabled")
log.Info("Payment processing is disabled")
}
// Create App and wire routes
app := handlers.NewApp(disp, cfg.LockType, cfg.EncoderAddress, cardWellStatus, database, &cfg)
// Update cardWellStatus when dispenser status changes
if !cfg.TestMode && disp != nil {
// Set initial cardWellStatus
app.SetCardWellStatus(cardWellStatus)
// Set up callback to update cardWellStatus when dispenser status changes
disp.OnStockUpdate(func(stock string) {
app.SetCardWellStatus(stock)
})
// Start polling for dispenser status every 10 seconds
disp.StartPolling(pollingFrequency)
}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
addr := fmt.Sprintf(":%d", cfg.Port)
log.Infof("Starting HTTP server on http://localhost%s", addr)
fmt.Printf("Starting HTTP server on http://localhost%s", addr)
if err := http.ListenAndServe(addr, mux); err != nil {
errorhandlers.FatalError(err)
}
}
func readTicketLayout() printer.LayoutOptions {
const layoutName = "TicketLayout.xml"
var layout printer.LayoutOptions
// 1) Read the file
data, err := os.ReadFile(layoutName)
if err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
}
// 2) Unmarshal into your struct
if err := xml.Unmarshal(data, &layout); err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
}
return layout
}
func startChipDnaClient() {
startClient := func() (*exec.Cmd, error) {
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
err := cmd.Start()
if err != nil {
return nil, fmt.Errorf("failed to start ChipDnaClient: %v", err)
}
log.Infof("ChipDnaClient started with PID %d", cmd.Process.Pid)
return cmd, nil
}
cmd, err := startClient()
if err != nil {
errorhandlers.FatalError(err)
}
// Restart loop
go func() {
for {
err := cmd.Wait()
if err != nil {
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
fmt.Printf("ChipDnaClient exited unexpectedly: %v", err)
time.Sleep(2 * time.Second)
cmd, err = startClient()
if err != nil {
log.Errorf("Restart failed: %v", err)
return
}
log.Info("ChipDnaClient restarted successfully")
fmt.Printf("ChipDnaClient restarted successfully")
}
}
}()
// Handle shutdown signals
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigs
log.Info("Shutting down...")
if cmd.Process != nil {
log.Info("Sending SIGTERM to ChipDnaClient...")
_ = cmd.Process.Signal(syscall.SIGTERM)
// wait up to 5s for graceful shutdown
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
select {
case <-time.After(5 * time.Second):
log.Warn("ChipDnaClient did not exit in time, killing...")
_ = cmd.Process.Kill()
case err := <-done:
log.Infof("ChipDnaClient exited cleanly: %v", err)
}
}
os.Exit(0)
}()
}
+41
View File
@@ -0,0 +1,41 @@
// Package paymentstatus defines progress codes emitted by Hardlink's
// POST /api/payment/sale stream. These codes are not authoritative final
// transaction decisions: clients may continue check-in only after receiving a
// final result frame whose response.data begins with /successful.
package paymentstatus
const (
Starting = "PAYMENT_STARTING"
Started = "PAYMENT_STARTED"
RequestSent = "PAYMENT_REQUEST_SENT"
Accepted = "PAYMENT_ACCEPTED"
PresentCard = "PAYMENT_PRESENT_CARD"
InsertCard = "PAYMENT_INSERT_CARD"
SwipeCard = "PAYMENT_SWIPE_CARD"
EnterPIN = "PAYMENT_ENTER_PIN"
EnterPINAgain = "PAYMENT_ENTER_PIN_AGAIN"
PleaseWait = "PAYMENT_PLEASE_WAIT"
DoNotRemoveCard = "PAYMENT_DO_NOT_REMOVE_CARD"
RemoveCard = "PAYMENT_REMOVE_CARD"
TryAnotherInterface = "PAYMENT_TRY_ANOTHER_INTERFACE"
Processing = "PAYMENT_PROCESSING"
Authorized = "PAYMENT_AUTHORIZED"
Approved = "PAYMENT_APPROVED"
Cancelling = "PAYMENT_CANCELLING"
Cancelled = "PAYMENT_CANCELLED"
Declined = "PAYMENT_DECLINED"
Expired = "PAYMENT_EXPIRED"
Timeout = "PAYMENT_TIMEOUT"
SignatureRequired = "PAYMENT_SIGNATURE_REQUIRED"
SignatureRejecting = "PAYMENT_SIGNATURE_REJECTING"
SignatureRejected = "PAYMENT_SIGNATURE_REJECTED"
Voided = "PAYMENT_VOIDED"
DailyLimitExceeded = "PAYMENT_DAILY_LIMIT_EXCEEDED"
VoidFailed = "PAYMENT_VOID_FAILED"
LimitValidationError = "PAYMENT_LIMIT_VALIDATION_ERROR"
Error = "PAYMENT_ERROR"
TerminalUnavailable = "PAYMENT_TERMINAL_UNAVAILABLE"
DojoNotificationPrefix = "PAYMENT_DOJO_NOTIFICATION_"
DojoStatusPrefix = "PAYMENT_DOJO_STATUS_"
)
+84
View File
@@ -0,0 +1,84 @@
package paymentstatus_test
import (
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
func TestFixedStatusValues(t *testing.T) {
statuses := []struct {
name string
value string
want string
}{
{"Starting", paymentstatus.Starting, "PAYMENT_STARTING"},
{"Started", paymentstatus.Started, "PAYMENT_STARTED"},
{"RequestSent", paymentstatus.RequestSent, "PAYMENT_REQUEST_SENT"},
{"Accepted", paymentstatus.Accepted, "PAYMENT_ACCEPTED"},
{"PresentCard", paymentstatus.PresentCard, "PAYMENT_PRESENT_CARD"},
{"InsertCard", paymentstatus.InsertCard, "PAYMENT_INSERT_CARD"},
{"SwipeCard", paymentstatus.SwipeCard, "PAYMENT_SWIPE_CARD"},
{"EnterPIN", paymentstatus.EnterPIN, "PAYMENT_ENTER_PIN"},
{"EnterPINAgain", paymentstatus.EnterPINAgain, "PAYMENT_ENTER_PIN_AGAIN"},
{"PleaseWait", paymentstatus.PleaseWait, "PAYMENT_PLEASE_WAIT"},
{"DoNotRemoveCard", paymentstatus.DoNotRemoveCard, "PAYMENT_DO_NOT_REMOVE_CARD"},
{"RemoveCard", paymentstatus.RemoveCard, "PAYMENT_REMOVE_CARD"},
{"TryAnotherInterface", paymentstatus.TryAnotherInterface, "PAYMENT_TRY_ANOTHER_INTERFACE"},
{"Processing", paymentstatus.Processing, "PAYMENT_PROCESSING"},
{"Authorized", paymentstatus.Authorized, "PAYMENT_AUTHORIZED"},
{"Approved", paymentstatus.Approved, "PAYMENT_APPROVED"},
{"Cancelling", paymentstatus.Cancelling, "PAYMENT_CANCELLING"},
{"Cancelled", paymentstatus.Cancelled, "PAYMENT_CANCELLED"},
{"Declined", paymentstatus.Declined, "PAYMENT_DECLINED"},
{"Expired", paymentstatus.Expired, "PAYMENT_EXPIRED"},
{"Timeout", paymentstatus.Timeout, "PAYMENT_TIMEOUT"},
{"SignatureRequired", paymentstatus.SignatureRequired, "PAYMENT_SIGNATURE_REQUIRED"},
{"SignatureRejecting", paymentstatus.SignatureRejecting, "PAYMENT_SIGNATURE_REJECTING"},
{"SignatureRejected", paymentstatus.SignatureRejected, "PAYMENT_SIGNATURE_REJECTED"},
{"Voided", paymentstatus.Voided, "PAYMENT_VOIDED"},
{"DailyLimitExceeded", paymentstatus.DailyLimitExceeded, "PAYMENT_DAILY_LIMIT_EXCEEDED"},
{"VoidFailed", paymentstatus.VoidFailed, "PAYMENT_VOID_FAILED"},
{"LimitValidationError", paymentstatus.LimitValidationError, "PAYMENT_LIMIT_VALIDATION_ERROR"},
{"Error", paymentstatus.Error, "PAYMENT_ERROR"},
{"TerminalUnavailable", paymentstatus.TerminalUnavailable, "PAYMENT_TERMINAL_UNAVAILABLE"},
}
seen := make(map[string]string, len(statuses))
for _, status := range statuses {
t.Run(status.name, func(t *testing.T) {
if status.value != status.want {
t.Fatalf("got %q, want %q", status.value, status.want)
}
if !strings.HasPrefix(status.value, "PAYMENT_") {
t.Fatalf("status %q does not have PAYMENT_ prefix", status.value)
}
})
if previous, exists := seen[status.value]; exists {
t.Errorf("%s and %s have duplicate value %q", previous, status.name, status.value)
}
seen[status.value] = status.name
}
}
func TestDojoPrefixes(t *testing.T) {
if paymentstatus.DojoNotificationPrefix != "PAYMENT_DOJO_NOTIFICATION_" {
t.Fatalf(
"DojoNotificationPrefix = %q, want %q",
paymentstatus.DojoNotificationPrefix,
"PAYMENT_DOJO_NOTIFICATION_",
)
}
if paymentstatus.DojoStatusPrefix != "PAYMENT_DOJO_STATUS_" {
t.Fatalf(
"DojoStatusPrefix = %q, want %q",
paymentstatus.DojoStatusPrefix,
"PAYMENT_DOJO_STATUS_",
)
}
if paymentstatus.DojoNotificationPrefix == paymentstatus.DojoStatusPrefix {
t.Fatal("Dojo prefixes must differ")
}
}
+40
View File
@@ -2,6 +2,46 @@
builtVersion is a const in main.go
#### 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.