Compare commits

...
8 Commits
9 changed files with 282 additions and 175 deletions
+1
View File
@@ -28,6 +28,7 @@ Checkin.code-workspace
_obj _obj
_test _test
.vscode/ .vscode/
ChipDNAClient/
# Architecture specific extensions/prefixes # Architecture specific extensions/prefixes
*.[568vq] *.[568vq]
+8 -1
View File
@@ -19,8 +19,15 @@ func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
} }
// Checks heart beat of the Assa Abloy lock server and perform key encoding // Checks heart beat of the Assa Abloy lock server and perform key encoding
func (lock *AssaLockServer) LockSequence(conn net.Conn) error { func (lock *AssaLockServer) LockSequence() error {
const funcName = "AssaLockServer.LockSequence" const funcName = "AssaLockServer.LockSequence"
conn, err := InitializeServerConnection(LockServerURL)
if err != nil {
return err
}
defer conn.Close()
resp, err := sendHeartbeatToServer(conn) resp, err := sendHeartbeatToServer(conn)
if err != nil { if err != nil {
return fmt.Errorf("[%s] heartbeat failed: %v", funcName, err) return fmt.Errorf("[%s] heartbeat failed: %v", funcName, err)
+1 -1
View File
@@ -35,7 +35,7 @@ var (
type ( type (
LockServer interface { LockServer interface {
BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error
LockSequence(conn net.Conn) error LockSequence() error
} }
AssaLockServer struct { AssaLockServer struct {
+8 -1
View File
@@ -53,8 +53,15 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
} }
// Starts link to the Omnitec lock server and perform key encoding // Starts link to the Omnitec lock server and perform key encoding
func (lock *OmniLockServer) LockSequence(conn net.Conn) error { func (lock *OmniLockServer) LockSequence() error {
const funcName = "OmniLockServer.LockSequence" const funcName = "OmniLockServer.LockSequence"
conn, err := InitializeServerConnection(LockServerURL)
if err != nil {
return err
}
defer conn.Close()
// Start the link with the lock server // Start the link with the lock server
regs, err := lock.linkStart(conn) regs, err := lock.linkStart(conn)
if err != nil { if err != nil {
+16 -9
View File
@@ -31,8 +31,8 @@ func calculateLRC(data []byte) byte {
func (lock *SaltoLockServer) BuildCommand(req DoorCardRequest, checkIn, checkOut time.Time) error { func (lock *SaltoLockServer) BuildCommand(req DoorCardRequest, checkIn, checkOut time.Time) error {
// helper: hh[mm]DDMMYY // helper: hh[mm]DDMMYY
fmtStamp := func(t time.Time) string { fmtStamp := func(t time.Time) string {
return fmt.Sprintf("%02d%02d%02d%02d%02d", return fmt.Sprintf("%02d%02d%02d%02d",
t.Hour(), t.Minute(), t.Day(), int(t.Month()), t.Year()%100) t.Hour(), t.Day(), int(t.Month()), t.Year()%100)
} }
start := fmtStamp(checkIn) start := fmtStamp(checkIn)
expiry := fmtStamp(checkOut) expiry := fmtStamp(checkOut)
@@ -139,14 +139,21 @@ func (lock *SaltoLockServer) waitForAck(conn net.Conn, reader *bufio.Reader, tim
} }
// LockSequence performs the full ENQ/ACK handshake and command exchange // LockSequence performs the full ENQ/ACK handshake and command exchange
func (lock *SaltoLockServer) LockSequence(conn net.Conn) error { func (lock *SaltoLockServer) LockSequence() error {
const timeout = 10 * time.Second const timeout = 20 * time.Second
var ( var (
resp []byte resp []byte
reader = bufio.NewReader(conn)
drained = 0 // count of stale frames consumed across waits drained = 0 // count of stale frames consumed across waits
) )
conn, err := InitializeServerConnection(LockServerURL)
if err != nil {
return err
}
defer conn.Close()
reader := bufio.NewReader(conn)
// 1. Send ENQ // 1. Send ENQ
log.Infof("Sending ENQ") log.Infof("Sending ENQ")
if _, e := conn.Write([]byte{ENQ}); e != nil { if _, e := conn.Write([]byte{ENQ}); e != nil {
@@ -171,7 +178,7 @@ func (lock *SaltoLockServer) LockSequence(conn net.Conn) error {
// 5. Now read the *next* STX frame which should be the response to our command. // 5. Now read the *next* STX frame which should be the response to our command.
for { for {
conn.SetReadDeadline(time.Now().Add(20 * time.Second)) conn.SetReadDeadline(time.Now().Add(40 * time.Second))
b, e := reader.ReadByte() b, e := reader.ReadByte()
if e != nil { if e != nil {
return fmt.Errorf("error reading response start: %w", e) return fmt.Errorf("error reading response start: %w", e)
@@ -203,11 +210,11 @@ func (lock *SaltoLockServer) LockSequence(conn net.Conn) error {
case b1 == 'C' && b2 == 'C': case b1 == 'C' && b2 == 'C':
log.Infof("LockSequence: command response is CC (follow-up)") log.Infof("LockSequence: command response is CC (follow-up)")
case b1 == 'T' && b2 == 'D': case b1 == 'T' && b2 == 'D':
log.Warnf("LockSequence: command response is TD (room does not exist)") log.Warnf("LockSequence: command response is TD (room does not exist): %q", string(resp))
return fmt.Errorf("lock response indicates room does not exist") return fmt.Errorf("lock response indicates room does not exist: %q", string(resp))
default: default:
log.Warnf("LockSequence: unexpected command response %q", string(resp)) log.Warnf("LockSequence: unexpected command response %q", string(resp))
return fmt.Errorf("error encoding keycard, unexpected response") return fmt.Errorf("error encoding keycard, unexpected response: %q", string(resp))
} }
} else { } else {
log.Warnf("LockSequence: response too short: %q", string(resp)) log.Warnf("LockSequence: response too short: %q", string(resp))
+2 -3
View File
@@ -4,7 +4,6 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"net"
"net/http" "net/http"
"net/url" "net/url"
"time" "time"
@@ -36,9 +35,9 @@ func (lock *TLJLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkO
return nil return nil
} }
func (lock *TLJLockServer) LockSequence(conn net.Conn) error { func (lock *TLJLockServer) LockSequence() error {
log.Infof("Sending command: %q", lock.command) log.Infof("Sending command: %q", lock.command)
client := &http.Client{Timeout: 10 * time.Second} client := &http.Client{Timeout: 30 * time.Second}
resp, err := client.Get(lock.command) resp, err := client.Get(lock.command)
if err != nil { if err != nil {
return fmt.Errorf("HTTP request failed: %v", err) return fmt.Errorf("HTTP request failed: %v", err)
+122 -96
View File
@@ -1,12 +1,11 @@
package main package main
import ( import (
// "database/sql" "bytes"
"encoding/json" "encoding/json"
"encoding/xml" "encoding/xml"
"fmt" "fmt"
"io" "io"
"net"
"net/http" "net/http"
"os" "os"
"os/exec" "os/exec"
@@ -30,7 +29,7 @@ import (
) )
const ( const (
buildVersion = "1.0.12" buildVersion = "1.0.21"
serviceName = "hardlink" serviceName = "hardlink"
customLayout = "2006-01-02 15:04:05 -0700" customLayout = "2006-01-02 15:04:05 -0700"
transactionUrl = "http://127.0.0.1:18181/start-transaction/" transactionUrl = "http://127.0.0.1:18181/start-transaction/"
@@ -52,15 +51,15 @@ type configRec struct {
// App holds shared resources. // App holds shared resources.
type App struct { type App struct {
configRec configRec
dispPort *serial.Port dispPort *serial.Port
lockConn net.Conn
lockserver lockserver.LockServer lockserver lockserver.LockServer
} }
func newApp(dispPort *serial.Port, lockConn net.Conn, config configRec) *App { func newApp(dispPort *serial.Port, config configRec) *App {
return &App{ return &App{
configRec: config,
dispPort: dispPort, dispPort: dispPort,
lockConn: lockConn,
lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError), lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError),
} }
} }
@@ -70,8 +69,6 @@ func main() {
config := readConfig() config := readConfig()
printer.Layout = readTicketLayout() printer.Layout = readTicketLayout()
printer.PrinterName = config.PrinterName printer.PrinterName = config.PrinterName
var lockConn net.Conn
lockserver.Cert = config.Cert lockserver.Cert = config.Cert
lockserver.LockServerURL = config.LockserverUrl lockserver.LockServerURL = config.LockserverUrl
@@ -103,85 +100,34 @@ func main() {
} }
log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status) log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status)
// Initialize lock-server connection once // Test lock-server connection
switch strings.ToLower(config.LockType) { switch strings.ToLower(config.LockType) {
case lockserver.TLJ: case lockserver.TLJ:
default: default:
lockConn, err = lockserver.InitializeServerConnection(config.LockserverUrl) lockConn, err := lockserver.InitializeServerConnection(config.LockserverUrl)
if err != nil { if err != nil {
fatalError(err) fmt.Println(err.Error())
log.Errorf(err.Error())
} else {
fmt.Printf("Connected to the lock server successfuly at %s\n", config.LockserverUrl)
log.Infof("Connected to the lock server successfuly at %s", config.LockserverUrl)
lockConn.Close()
} }
defer lockConn.Close()
log.Infof("Connected to lock server at %s", config.LockserverUrl)
} }
// db, err := payment.InitMSSQL(config.dbport, config.dbname, config.dbuser, config.dbpassword)
// if err != nil {
// fatalError(fmt.Errorf("DB init failed: %v", err))
// }
// defer db.Close()
if config.IsPayment { if config.IsPayment {
startClient := func() (*exec.Cmd, error) { fmt.Println("Payment processing is enabled")
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe") log.Info("Payment processing is enabled")
err := cmd.Start() startChipDnaClient()
if err != nil { } else {
return nil, fmt.Errorf("failed to start ChipDnaClient: %v", err) fmt.Println("Payment processing is disabled")
} log.Info("Payment processing is disabled")
log.Infof("ChipDnaClient started with PID %d", cmd.Process.Pid)
return cmd, nil
}
cmd, err := startClient()
if err != nil {
fatalError(err)
}
// Restart loop
go func() {
for {
err := cmd.Wait()
if err != nil {
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
time.Sleep(2 * time.Second)
cmd, err = startClient()
if err != nil {
log.Errorf("Restart failed: %v", err)
return
}
log.Info("ChipDnaClient restarted successfully")
}
}
}()
// Handle shutdown signals
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigs
log.Info("Shutting down...")
if cmd.Process != nil {
log.Info("Sending SIGTERM to ChipDnaClient...")
_ = cmd.Process.Signal(syscall.SIGTERM)
// wait up to 5s for graceful shutdown
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
select {
case <-time.After(5 * time.Second):
log.Warn("ChipDnaClient did not exit in time, killing...")
_ = cmd.Process.Kill()
case err := <-done:
log.Infof("ChipDnaClient exited cleanly: %v", err)
}
}
os.Exit(0)
}()
} }
// Create App and wire routes // Create App and wire routes
// dispHandle := &serial.Port{} // Placeholder, replace with actual dispenser handle // dispHandle := &serial.Port{} // Placeholder, replace with actual dispenser handle
app := newApp(dispHandle, lockConn, config) app := newApp(dispHandle, config)
mux := http.NewServeMux() mux := http.NewServeMux()
setUpRoutes(app, mux) setUpRoutes(app, mux)
@@ -241,18 +187,36 @@ func writeError(w http.ResponseWriter, status int, msg string) {
json.NewEncoder(w).Encode(theResponse) json.NewEncoder(w).Encode(theResponse)
} }
func writeTransactionResult(w http.ResponseWriter, status int, theResponse cmstypes.ResponseRec) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
if err := json.NewEncoder(w).Encode(theResponse); err != nil {
logging.Error(serviceName, err.Error(), "JSON encode error", "startTransaction", "", "", 0)
}
}
func (app *App) startTransaction(w http.ResponseWriter, r *http.Request) { func (app *App) startTransaction(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("startTransaction") const op = logging.Op("startTransaction")
var ( var (
theResponse cmstypes.ResponseRec theResponse cmstypes.ResponseRec
cardholderReceipt string cardholderReceipt string
theRequest cmstypes.TransactionRec
) )
theResponse.Status.Code = http.StatusInternalServerError
theResponse.Status.Message = "500 Internal server error"
w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS") w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type") w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
if !app.configRec.IsPayment {
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Payment processing is disabled")
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
return
}
if r.Method == http.MethodOptions { if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent) w.WriteHeader(http.StatusNoContent)
return return
@@ -260,29 +224,43 @@ func (app *App) startTransaction(w http.ResponseWriter, r *http.Request) {
log.Println("startTransaction called") log.Println("startTransaction called")
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
writeError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST") theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Method not allowed; use POST")
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
return return
} }
defer r.Body.Close() defer r.Body.Close()
if ct := r.Header.Get("Content-Type"); ct != "text/xml" { if ct := r.Header.Get("Content-Type"); ct != "text/xml" {
writeError(w, http.StatusUnsupportedMediaType, "Content-Type must be text/xml") theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Content-Type must be text/xml")
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
return return
} }
client := &http.Client{Timeout: 90 * time.Second} body, _ := io.ReadAll(r.Body)
response, err := client.Post(transactionUrl, "text/xml", r.Body) err := xml.Unmarshal(body, &theRequest)
if err != nil {
logging.Error(serviceName, err.Error(), "ReadXML", string(op), "", "", 0)
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Invalid XML payload")
writeTransactionResult(w, http.StatusBadRequest, theResponse)
return
}
log.Printf("Start trnasaction payload: Amount=%s, Type=%s", theRequest.AmountMinorUnits, theRequest.TransactionType)
client := &http.Client{Timeout: 300 * time.Second}
response, err := client.Post(transactionUrl, "text/xml", bytes.NewBuffer(body))
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Payment processing error", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Payment processing error", string(op), "", "", 0)
writeError(w, http.StatusInternalServerError, "Payment processing failed: "+err.Error()) theResponse.Data = payment.BuildFailureURL(payment.ResultError, "No response from payment processor")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return return
} }
defer response.Body.Close() defer response.Body.Close()
body, err := io.ReadAll(response.Body) body, err = io.ReadAll(response.Body)
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Read response body error", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Read response body error", string(op), "", "", 0)
writeError(w, http.StatusInternalServerError, "Failed to read response body: "+err.Error()) theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Failed to read response body")
writeTransactionResult(w, http.StatusInternalServerError, theResponse)
return return
} }
@@ -292,10 +270,11 @@ func (app *App) startTransaction(w http.ResponseWriter, r *http.Request) {
result := make(map[string]string) result := make(map[string]string)
for _, e := range responseEntries { for _, e := range responseEntries {
switch e.Key { switch e.Key {
case "RECEIPT_DATA", "RECEIPT_DATA_MERCHANT": case payment.ReceiptData, payment.ReceiptDataMerchant:
case "RECEIPT_DATA_CARDHOLDER": // ignore these
case payment.ReceiptDataCardholder:
cardholderReceipt = e.Value cardholderReceipt = e.Value
case "TRANSACTION_RESULT": case payment.TransactionResult:
theResponse.Status.Message = e.Value theResponse.Status.Message = e.Value
theResponse.Status.Code = http.StatusOK theResponse.Status.Code = http.StatusOK
result[e.Key] = e.Value result[e.Key] = e.Value
@@ -308,18 +287,8 @@ func (app *App) startTransaction(w http.ResponseWriter, r *http.Request) {
log.Errorf("PrintCardholderReceipt error: %v", err) log.Errorf("PrintCardholderReceipt error: %v", err)
} }
// Insert into DB
// if err := payment.InsertTransactionRecord(r.Context(), app.db, result); err != nil {
// log.Errorf("DB insert error: %v", err)
// }
theResponse.Data = payment.BuildRedirectURL(result) theResponse.Data = payment.BuildRedirectURL(result)
writeTransactionResult(w, http.StatusOK, theResponse)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(theResponse); err != nil {
logging.Error(serviceName, err.Error(), "JSON encode error", string(op), "", "", 0)
}
} }
func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) { func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
@@ -389,7 +358,7 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
app.lockserver.BuildCommand(doorReq, checkIn, checkOut) app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
// lock server sequence // lock server sequence
err = app.lockserver.LockSequence(app.lockConn) err = app.lockserver.LockSequence()
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Key encoding", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Key encoding", string(op), "", "", 0)
writeError(w, http.StatusBadGateway, err.Error()) writeError(w, http.StatusBadGateway, err.Error())
@@ -515,3 +484,60 @@ func readTicketLayout() printer.LayoutOptions {
return layout 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 {
fatalError(err)
}
// Restart loop
go func() {
for {
err := cmd.Wait()
if err != nil {
log.Errorf("ChipDnaClient exited unexpectedly: %v", err)
time.Sleep(2 * time.Second)
cmd, err = startClient()
if err != nil {
log.Errorf("Restart failed: %v", err)
return
}
log.Info("ChipDnaClient restarted successfully")
}
}
}()
// Handle shutdown signals
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigs
log.Info("Shutting down...")
if cmd.Process != nil {
log.Info("Sending SIGTERM to ChipDnaClient...")
_ = cmd.Process.Signal(syscall.SIGTERM)
// wait up to 5s for graceful shutdown
done := make(chan error, 1)
go func() { done <- cmd.Wait() }()
select {
case <-time.After(5 * time.Second):
log.Warn("ChipDnaClient did not exit in time, killing...")
_ = cmd.Process.Kill()
case err := <-done:
log.Infof("ChipDnaClient exited cleanly: %v", err)
}
}
os.Exit(0)
}()
}
+88 -52
View File
@@ -16,6 +16,11 @@ import (
) )
const ( const (
// Transaction types
SaleTransactionType = "sale"
AccountVerificationType = "account verification"
// Transaction results
ResultApproved = "approved" ResultApproved = "approved"
ResultDeclined = "declined" ResultDeclined = "declined"
ResultCancelled = "cancelled" ResultCancelled = "cancelled"
@@ -23,6 +28,24 @@ const (
ResultError = "error" ResultError = "error"
CheckinSuccessfulEndpoint = "/successful" // Endpoint to send guest to after successful payment CheckinSuccessfulEndpoint = "/successful" // Endpoint to send guest to after successful payment
CheckinUnsuccessfulEndpoint = "/unsuccessful" CheckinUnsuccessfulEndpoint = "/unsuccessful"
// Response map keys
CardReference = "CARD_REFERENCE"
CardHash = "CARD_HASH"
Errors = "ERRORS"
ReceiptData = "RECEIPT_DATA"
ReceiptDataMerchant = "RECEIPT_DATA_MERCHANT"
ReceiptDataCardholder = "RECEIPT_DATA_CARDHOLDER"
Reference = "REFERENCE"
TransactionResult = "TRANSACTION_RESULT"
TransactionType = "TRANSACTION_TYPE"
ConfirmResult = "CONFIRM_RESULT"
ConfirmErrors = "CONFIRM_ERRORS"
// Log field keys
LogFieldError = "error"
LogFieldDescription = "description"
LogResult = "transactionResult"
) )
// XML parsing structs // XML parsing structs
@@ -42,6 +65,14 @@ type (
Key string `xml:"Key"` Key string `xml:"Key"`
Value string `xml:"Value"` Value string `xml:"Value"`
} }
TransactionConfirmation struct {
XMLName xml.Name `xml:"TransactionConfirmation"`
Result string `xml:"Result"`
Errors string `xml:"Errors"`
ErrorDescription string `xml:"ErrorDescription"`
ReceiptDataCardholder string `xml:"ReceiptDataCardholder"`
}
) )
// ParseTransactionResult parses the XML into entries. // ParseTransactionResult parses the XML into entries.
@@ -217,65 +248,70 @@ func nullableFloatArg(nf sql.NullFloat64) interface{} {
return nil return nil
} }
// BuildRedirectURL builds the redirect URL to send the guest to after payment.
func BuildRedirectURL(result map[string]string) string { func BuildRedirectURL(result map[string]string) string {
// 1) normalize the result code res := result[TransactionResult]
res := strings.ToLower(result["TRANSACTION_RESULT"]) tType := result[TransactionType]
// 2) pick base path and optional error params // Transaction approved?
var basePath string if strings.EqualFold(res, ResultApproved) {
var msgType, description string switch {
// Transaction type AccountVerification?
case strings.EqualFold(tType, AccountVerificationType):
log.WithField(LogResult, result[TransactionResult]).
Info("Account verification approved")
switch res { return buildSuccessURL(result)
case ResultApproved:
basePath = CheckinSuccessfulEndpoint
case ResultDeclined: // Transaction type Sale?
basePath = CheckinUnsuccessfulEndpoint case strings.EqualFold(tType, SaleTransactionType):
msgType = "declined" // Transaction confirmed?
description = "payment declined" if strings.EqualFold(result[ConfirmResult], ResultApproved) {
log.WithField(LogResult, result[ConfirmResult]).
Info("Transaction approved and confirmed")
case ResultCancelled: return buildSuccessURL(result)
basePath = CheckinUnsuccessfulEndpoint }
msgType = "cancelled"
description = "payment cancelled by customer"
case ResultPending: // Not confirmed
// you could choose to treat pending as unsuccessful or special-case it log.WithFields(log.Fields{LogFieldError: result[ConfirmResult], LogFieldDescription: result[ConfirmErrors]}).
basePath = CheckinUnsuccessfulEndpoint Error("Transaction approved but not confirmed")
msgType = "pending"
description = "payment pending"
case ResultError:
basePath = CheckinUnsuccessfulEndpoint
msgType = "error"
description = result["ERROR"]
default: return BuildFailureURL(result[ConfirmResult], result[ConfirmErrors])
basePath = CheckinUnsuccessfulEndpoint }
msgType = "error"
description = "unknown transaction result"
} }
if msgType != "" { // Not approved
log.Warnf("Transaction %s: %s - %s", res, msgType, description) return BuildFailureURL(res, result[Errors])
} }
// 3) build query params func buildSuccessURL(result map[string]string) string {
q := url.Values{} q := url.Values{}
q.Set("TxnReference", result["REFERENCE"]) q.Set("TxnReference", result[Reference])
q.Set("CardHash", hex.EncodeToString([]byte(result["CARD_HASH"]))) q.Set("CardHash", hex.EncodeToString([]byte(result[CardHash])))
q.Set("CardReference", hex.EncodeToString([]byte(result["CARD_REFERENCE"]))) q.Set("CardReference", hex.EncodeToString([]byte(result[CardReference])))
return (&url.URL{
// only append these when non-approved Path: CheckinSuccessfulEndpoint,
if msgType != "" { RawQuery: q.Encode(),
q.Set("MsgType", msgType) }).String()
q.Set("Description", description) }
}
func BuildFailureURL(msgType, description string) string {
// 4) assemble final URL q := url.Values{}
// note: url.URL automatically escapes values in RawQuery if msgType == "" {
u := url.URL{ msgType = ResultError
Path: basePath, }
RawQuery: q.Encode(), if description == "" {
} description = "Transaction failed"
return u.String() }
log.WithFields(log.Fields{LogFieldError: msgType, LogFieldDescription: description}).
Error("Transaction failed")
q.Set("MsgType", msgType)
q.Set("Description", description)
return (&url.URL{
Path: CheckinUnsuccessfulEndpoint,
RawQuery: q.Encode(),
}).String()
} }
+36 -12
View File
@@ -2,41 +2,65 @@
builtVersion is a const in main.go builtVersion is a const in main.go
#### 1.0.12 - 11 August 2024 #### 1.0.21 - 20 October 2025
increased timeout for Salto lock server connection to 40 seconds
#### 1.0.20 - 06 October 2025
removed minutes from the start and expiry time in Salto lock command
#### 1.0.19 - 10 September 2025
allowed to continue if the connection to the lock server fails at startup
#### 1.0.18 - 04 September 2025
increased timeout for TLJ lock server connection to 30 seconds
#### 1.0.17 - 30 August 2025
added functionality to commit transactions
#### 1.0.15 - 27 August 2025
fixed TCP/IP connection to the lock server
#### 1.0.14 - 21 August 2025
fixed issue in creditcall payment processing where error description was not properly set
#### 1.0.13 - 21 August 2025
TCP/IP connection to the lock server is now established before encoding the keycard and closedafter the encoding is done.
#### 1.0.12 - 11 August 2025
added delay before checking dispenser status added delay before checking dispenser status
#### 1.0.11 - 11 August 2024 #### 1.0.11 - 11 August 2025
updated Salto key encoding workflow updated Salto key encoding workflow
#### 1.0.10 - 08 August 2024 #### 1.0.10 - 08 August 2025
updated logging for TLJ locks updated logging for TLJ locks
#### 1.0.9 - 08 August 2024 #### 1.0.9 - 08 August 2025
added TLJ lock server and implemented workflow for TLJ locks added TLJ lock server and implemented workflow for TLJ locks
#### 1.0.8 - 01 August 2024 #### 1.0.8 - 01 August 2025
improved error handling and logging in Salto improved error handling and logging in Salto
#### 1.0.7 - 25 July 2024 #### 1.0.7 - 25 July 2025
added check if the room exists added check if the room exists
#### 1.0.6 - 25 July 2024 #### 1.0.6 - 25 July 2025
updated workflow for Salto locks updated workflow for Salto locks
#### 1.0.5 - 24 July 2024 #### 1.0.5 - 24 July 2025
added encoding keycard copy for Salto locks added encoding keycard copy for Salto locks
#### 1.0.4 - 22 July 2024 #### 1.0.4 - 22 July 2025
added salto lock server and implemented workflow for Salto added salto lock server and implemented workflow for Salto
#### 1.0.0 - 30 June 2024 #### 1.0.0 - 30 June 2025
added creditcall payment method added creditcall payment method
`/starttransaction` - API payment endpoint to start a transaction `/starttransaction` - API payment endpoint to start a transaction
#### 0.9.1 - 22 May 2024 #### 0.9.1 - 22 May 2025
added lockserver interface and implemented workflow for Omnitec added lockserver interface and implemented workflow for Omnitec
#### 0.9.0 - 22 May 2024 #### 0.9.0 - 22 May 2025
The new API has two new endpoints: The new API has two new endpoints:
- `/issuedoorcard` - encoding the door card for the room. - `/issuedoorcard` - encoding the door card for the room.
- `/printroomticket` - printing the room ticket. - `/printroomticket` - printing the room ticket.