Compare commits

..
8 Commits
8 changed files with 272 additions and 174 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]
+1 -1
View File
@@ -22,7 +22,7 @@ func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
func (lock *AssaLockServer) LockSequence() error { func (lock *AssaLockServer) LockSequence() error {
const funcName = "AssaLockServer.LockSequence" const funcName = "AssaLockServer.LockSequence"
conn, err := InitializeServerConnection(lock.encoderAddr) conn, err := InitializeServerConnection(LockServerURL)
if err != nil { if err != nil {
return err return err
} }
+1 -1
View File
@@ -56,7 +56,7 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
func (lock *OmniLockServer) LockSequence() error { func (lock *OmniLockServer) LockSequence() error {
const funcName = "OmniLockServer.LockSequence" const funcName = "OmniLockServer.LockSequence"
conn, err := net.Dial("tcp", lock.encoderAddr) conn, err := InitializeServerConnection(LockServerURL)
if err != nil { if err != nil {
return err return err
} }
+10 -10
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)
@@ -140,19 +140,19 @@ 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() error { func (lock *SaltoLockServer) LockSequence() error {
const timeout = 10 * time.Second const timeout = 20 * time.Second
var ( var (
resp []byte resp []byte
drained = 0 // count of stale frames consumed across waits drained = 0 // count of stale frames consumed across waits
) )
conn, err := InitializeServerConnection(lock.encoderAddr) conn, err := InitializeServerConnection(LockServerURL)
if err != nil { if err != nil {
return err return err
} }
defer conn.Close() defer conn.Close()
reader := bufio.NewReader(conn) reader := bufio.NewReader(conn)
// 1. Send ENQ // 1. Send ENQ
log.Infof("Sending ENQ") log.Infof("Sending ENQ")
@@ -178,7 +178,7 @@ func (lock *SaltoLockServer) LockSequence() 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)
@@ -210,11 +210,11 @@ func (lock *SaltoLockServer) LockSequence() 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))
+1 -1
View File
@@ -37,7 +37,7 @@ func (lock *TLJLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkO
func (lock *TLJLockServer) LockSequence() 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)
+137 -97
View File
@@ -1,7 +1,7 @@
package main package main
import ( import (
// "database/sql" "bytes"
"encoding/json" "encoding/json"
"encoding/xml" "encoding/xml"
"fmt" "fmt"
@@ -29,7 +29,7 @@ import (
) )
const ( const (
buildVersion = "1.0.13" 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/"
@@ -47,16 +47,19 @@ type configRec struct {
PrinterName string `yaml:"printerName"` PrinterName string `yaml:"printerName"`
LogDir string `yaml:"logdir"` LogDir string `yaml:"logdir"`
IsPayment bool `yaml:"isPayment"` IsPayment bool `yaml:"isPayment"`
TestMode bool `yaml:"testMode"`
} }
// App holds shared resources. // App holds shared resources.
type App struct { type App struct {
configRec configRec
dispPort *serial.Port dispPort *serial.Port
lockserver lockserver.LockServer lockserver lockserver.LockServer
} }
func newApp(dispPort *serial.Port, config configRec) *App { func newApp(dispPort *serial.Port, config configRec) *App {
return &App{ return &App{
configRec: config,
dispPort: dispPort, dispPort: dispPort,
lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError), lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError),
} }
@@ -69,6 +72,7 @@ func main() {
printer.PrinterName = config.PrinterName printer.PrinterName = config.PrinterName
lockserver.Cert = config.Cert lockserver.Cert = config.Cert
lockserver.LockServerURL = config.LockserverUrl lockserver.LockServerURL = config.LockserverUrl
dispHandle := &serial.Port{}
// Setup logging and get file handle // Setup logging and get file handle
logFile, err := setupLogging(config.LogDir) logFile, err := setupLogging(config.LogDir)
@@ -78,25 +82,27 @@ func main() {
defer logFile.Close() defer logFile.Close()
// Initialize dispenser // Initialize dispenser
dispenser.SerialPort = config.DispenserPort if !config.TestMode {
dispenser.Address = []byte(config.DispenserAdrr) dispenser.SerialPort = config.DispenserPort
dispHandle, err := dispenser.InitializeDispenser() dispenser.Address = []byte(config.DispenserAdrr)
if err != nil { dispHandle, err = dispenser.InitializeDispenser()
fatalError(err) if err != nil {
}
defer dispHandle.Close()
status, err := dispenser.CheckDispenserStatus(dispHandle)
if err != nil {
if len(status) == 0 {
err = fmt.Errorf("%s; wrong dispenser address: %s", err, config.DispenserAdrr)
fatalError(err) fatalError(err)
} else {
fmt.Println(status)
fmt.Println(err.Error())
} }
defer dispHandle.Close()
status, err := dispenser.CheckDispenserStatus(dispHandle)
if err != nil {
if len(status) == 0 {
err = fmt.Errorf("%s; wrong dispenser address: %s", err, config.DispenserAdrr)
fatalError(err)
} else {
fmt.Println(status)
fmt.Println(err.Error())
}
}
log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status)
} }
log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status)
// Test lock-server connection // Test lock-server connection
switch strings.ToLower(config.LockType) { switch strings.ToLower(config.LockType) {
@@ -105,71 +111,25 @@ func main() {
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()
} }
log.Infof("Connectting to lock server at %s", config.LockserverUrl)
lockConn.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
app := newApp(dispHandle, config) app := newApp(dispHandle, config)
mux := http.NewServeMux() mux := http.NewServeMux()
@@ -230,18 +190,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
@@ -249,29 +227,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
} }
@@ -281,10 +273,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
@@ -297,18 +290,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) {
@@ -504,3 +487,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()
} }
+33 -12
View File
@@ -2,44 +2,65 @@
builtVersion is a const in main.go builtVersion is a const in main.go
#### 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 #### 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. 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 2024 #### 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.