Compare commits

..
1 Commits
Author SHA1 Message Date
Yurii 975707de4c start 2025-12-23 16:23:11 +00:00
12 changed files with 189 additions and 519 deletions
+3 -3
View File
@@ -5,7 +5,7 @@ import (
"os" "os"
"strings" "strings"
"gitea.futuresens.co.uk/futuresens/hardlink/errorhandlers" "gitea.futuresens.co.uk/futuresens/hardlink/handlers"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
yaml "gopkg.in/yaml.v3" yaml "gopkg.in/yaml.v3"
) )
@@ -49,7 +49,7 @@ func ReadHardlinkConfig() ConfigRec {
if cfg.LockType == "" { if cfg.LockType == "" {
err = fmt.Errorf("LockType is required in %s", configName) err = fmt.Errorf("LockType is required in %s", configName)
errorhandlers.FatalError(err) handlers.FatalError(err)
} }
cfg.LockType = strings.ToLower(cfg.LockType) cfg.LockType = strings.ToLower(cfg.LockType)
@@ -81,7 +81,7 @@ func ReadPreauthReleaserConfig() ConfigRec {
if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" { if cfg.Dbport <= 0 || cfg.Dbuser == "" || cfg.Dbname == "" || cfg.Dbpassword == "" {
err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName) err = fmt.Errorf("Database config (dbport, dbuser, dbname, dbpassword) are required in %s", configName)
errorhandlers.FatalError(err) handlers.FatalError(err)
} }
if cfg.LogDir == "" { if cfg.LogDir == "" {
-1
View File
@@ -198,4 +198,3 @@ WHERE TxnReference = @TxnReference AND Released = 0;
log.Infof("Marked preauth %s released at %s", txnReference, releasedAt.Format(time.RFC3339)) log.Infof("Marked preauth %s released at %s", txnReference, releasedAt.Format(time.RFC3339))
return nil return nil
} }
+84 -185
View File
@@ -3,8 +3,6 @@ package dispenser
import ( import (
// "encoding/hex" // "encoding/hex"
"fmt" "fmt"
"strings"
// "log" // "log"
"time" "time"
@@ -71,78 +69,44 @@ var (
} }
) )
func logStatus(statusBytes []byte) { func checkStatus(statusResp []byte) ([]string, error) {
// For each position, get the ASCII character, hex value, and mapped meaning. if len(statusResp) > 3 {
posStatus := []struct { statusBytes := statusResp[7:11] // Extract the relevant bytes from the response
pos int // For each position, get the ASCII character, hex value, and mapped meaning.
value byte posStatus := []struct {
mapper map[byte]string pos int
}{ value byte
{pos: 1, value: statusBytes[0], mapper: statusPos0}, mapper map[byte]string
{pos: 2, value: statusBytes[1], mapper: statusPos1}, }{
{pos: 3, value: statusBytes[2], mapper: statusPos2}, {pos: 1, value: statusBytes[0], mapper: statusPos0},
{pos: 4, value: statusBytes[3], mapper: statusPos3}, {pos: 2, value: statusBytes[1], mapper: statusPos1},
} {pos: 3, value: statusBytes[2], mapper: statusPos2},
{pos: 4, value: statusBytes[3], mapper: statusPos3},
var result strings.Builder
for _, p := range posStatus {
statusMsg, exists := p.mapper[p.value]
if !exists {
statusMsg = fmt.Sprintf("Unknown status 0x%X;", p.value)
} }
if p.value != 0x30 {
result.WriteString(statusMsg + "; ") result := make([]string, len(posStatus))
for _, p := range posStatus {
statusMsg, exists := p.mapper[p.value]
if !exists {
statusMsg = "Unknown status"
}
if p.value != 0x30 {
result = append(result, fmt.Sprintf("Status: %s; ", statusMsg))
}
if p.pos == 4 && p.value == 0x38 {
return nil, fmt.Errorf("Card well empty")
}
} }
} return result, nil
log.Infof("Dispenser status: %s", result.String())
}
func isAtEncoderPosition(statusBytes []byte) bool {
if statusBytes == nil {
return false
}
switch statusBytes[3] {
case 0x33: // Card at encoder position
return true
default:
return false // Not at encoder position
}
}
func stockTake(statusBytes []byte) string {
status := ""
if statusBytes == nil {
return status
}
if statusBytes[2] != 0x30 {
status = statusPos2[statusBytes[2]]
}
if statusBytes[3] == 0x38 { // Card well empty
status = statusPos3[statusBytes[3]]
}
return status
}
func isCardWellEmpty(statusBytes []byte) bool {
if statusBytes == nil {
return false
}
switch statusBytes[3] {
case 0x38: // Card well empty
return true
default:
return false
}
}
func checkACK(statusResp []byte) error {
if len(statusResp) == 3 && statusResp[0] == ACK && statusResp[1] == Address[0] && statusResp[2] == Address[1] {
return nil
} else if len(statusResp) > 0 && statusResp[0] == NAK {
return fmt.Errorf("negative response from dispenser")
} else { } else {
return fmt.Errorf("unexpected response status: % X", statusResp) if len(statusResp) == 3 && statusResp[0] == ACK && statusResp[1] == Address[0] && statusResp[2] == Address[1] {
return "active;", nil
} else if len(statusResp) > 0 && statusResp[0] == NAK {
return "", fmt.Errorf("negative response from dispenser")
} else {
return "", fmt.Errorf("unexpected response status: % X", statusResp)
}
} }
} }
@@ -207,130 +171,47 @@ func InitializeDispenser() (*serial.Port, error) {
return port, nil return port, nil
} }
func DispenserPrepare(port *serial.Port) (string, error) { func DispenserSequence(port *serial.Port) (string, error) {
const funcName = "dispenserSequence" const funcName = "dispenserSequence"
stockStatus := "" var result string
// Check dispenser status // Check dispenser status
status, err := CheckDispenserStatus(port) status, err := CheckDispenserStatus(port)
if err != nil { if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err) return status, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
if isCardWellEmpty(status) {
return stockStatus, nil
} }
result += status
if isAtEncoderPosition(status) {
return stockStatus, nil
}
// Send card to encoder position // Send card to encoder position
err = CardToEncoderPosition(port) status, err = CardToEncoderPosition(port)
if err != nil { if err != nil {
return stockStatus, fmt.Errorf("[%s] error sending card to encoder position: %v", funcName, err) return status, fmt.Errorf("[%s] error sending card to encoder position: %v", funcName, err)
} }
result += "; " + status
time.Sleep(delay) return result, nil
// Check dispenser status
status, err = CheckDispenserStatus(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
return stockStatus, nil
}
func DispenserStart(port *serial.Port) (string, error) {
const funcName = "dispenserSequence"
stockStatus := ""
// Check dispenser status
status, err := CheckDispenserStatus(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
if isCardWellEmpty(status) {
return stockStatus, fmt.Errorf(stockStatus)
}
if isAtEncoderPosition(status) {
return stockStatus, nil
}
// Send card to encoder position
err = CardToEncoderPosition(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error sending card to encoder position: %v", funcName, err)
}
time.Sleep(delay)
// Check dispenser status
status, err = CheckDispenserStatus(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
return stockStatus, nil
}
func DispenserFinal(port *serial.Port) (string, error) {
const funcName = "dispenserSequence"
stockStatus := ""
err := CardOutOfMouth(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error sending card to out mouth position: %v", funcName, err)
}
time.Sleep(delay)
// Check dispenser status
status, err := CheckDispenserStatus(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
time.Sleep(delay)
// Send card to encoder position
err = CardToEncoderPosition(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error sending card to encoder position: %v", funcName, err)
}
time.Sleep(delay)
// Check dispenser status
status, err = CheckDispenserStatus(port)
if err != nil {
return stockStatus, fmt.Errorf("[%s] error checking dispenser status: %v", funcName, err)
}
logStatus(status)
stockStatus = stockTake(status)
return stockStatus, nil
} }
// if dispenser is not responding, I should repeat the command // if dispenser is not responding, I should repeat the command
func CheckDispenserStatus(port *serial.Port) ([]byte, error) { func CheckDispenserStatus(port *serial.Port) (string, error) {
const funcName = "checkDispenserStatus" const funcName = "checkDispenserStatus"
var result string
checkCmd := buildCheckAP(Address) checkCmd := buildCheckAP(Address)
enq := append([]byte{ENQ}, Address...) enq := append([]byte{ENQ}, Address...)
// Send check command (AP) // Send check command (AP)
statusResp, err := sendAndReceive(port, checkCmd, delay) statusResp, err := sendAndReceive(port, checkCmd, delay)
if err != nil { if err != nil {
return nil, fmt.Errorf("error sending check command: %v", err) return "", fmt.Errorf("error sending check command: %v", err)
} }
if len(statusResp) == 0 { if len(statusResp) == 0 {
return nil, fmt.Errorf("no response from dispenser") return "", fmt.Errorf("no response from dispenser")
} }
err = checkACK(statusResp) status, err := checkStatus(statusResp)
if err != nil { if err != nil {
return nil, err return status, err
} }
result += "; " + status
// Send ENQ+ADDR to prompt device to execute the command. // Send ENQ+ADDR to prompt device to execute the command.
statusResp, err = sendAndReceive(port, enq, delay) statusResp, err = sendAndReceive(port, enq, delay)
@@ -338,15 +219,17 @@ func CheckDispenserStatus(port *serial.Port) ([]byte, error) {
log.Errorf("error sending ENQ: %v", err) log.Errorf("error sending ENQ: %v", err)
} }
if len(statusResp) == 0 { if len(statusResp) == 0 {
return nil, fmt.Errorf("no response from dispenser") return "", fmt.Errorf("no response from dispenser")
} }
if len(statusResp) < 13 { status, err = checkStatus(statusResp)
return nil, fmt.Errorf("incomplete status response from dispenser: % X", statusResp) if err != nil {
return status, err
} }
return statusResp[7:11], nil // Return status bytes result += status
return result, nil
} }
func CardToEncoderPosition(port *serial.Port) error { func CardToEncoderPosition(port *serial.Port) (string, error) {
const funcName = "cartToEncoderPosition" const funcName = "cartToEncoderPosition"
enq := append([]byte{ENQ}, Address...) enq := append([]byte{ENQ}, Address...)
@@ -355,22 +238,30 @@ func CardToEncoderPosition(port *serial.Port) error {
log.Println("Send card to encoder position") log.Println("Send card to encoder position")
statusResp, err := sendAndReceive(port, dispenseCmd, delay) statusResp, err := sendAndReceive(port, dispenseCmd, delay)
if err != nil { if err != nil {
return fmt.Errorf("error sending card to encoder position: %v", err) return "", fmt.Errorf("error sending card to encoder position: %v", err)
} }
err = checkACK(statusResp) _, err = checkStatus(statusResp)
if err != nil { if err != nil {
return err return "", err
} }
//Send ENQ to prompt device --- //Send ENQ to prompt device ---
_, err = port.Write(enq) _, err = port.Write(enq)
if err != nil { if err != nil {
return fmt.Errorf("error sending ENQ to prompt device: %v", err) return "", fmt.Errorf("error sending ENQ to prompt device: %v", err)
} }
return nil
time.Sleep(delay)
//Check card position status
status, err := CheckDispenserStatus(port)
if err != nil {
return "", err
}
return status, nil
} }
func CardOutOfMouth(port *serial.Port) error { func CardOutOfMouth(port *serial.Port) (string, error) {
const funcName = "CardOutOfMouth" const funcName = "CardOutOfMouth"
enq := append([]byte{ENQ}, Address...) enq := append([]byte{ENQ}, Address...)
@@ -379,17 +270,25 @@ func CardOutOfMouth(port *serial.Port) error {
log.Println("Send card to out mouth position") log.Println("Send card to out mouth position")
statusResp, err := sendAndReceive(port, dispenseCmd, delay) statusResp, err := sendAndReceive(port, dispenseCmd, delay)
if err != nil { if err != nil {
return fmt.Errorf("error sending out of mouth command: %v", err) return "", fmt.Errorf("error sending out of mouth command: %v", err)
} }
err = checkACK(statusResp) _, err = checkStatus(statusResp)
if err != nil { if err != nil {
return err return "", err
} }
//Send ENQ to prompt device --- //Send ENQ to prompt device ---
_, err = port.Write(enq) _, err = port.Write(enq)
if err != nil { if err != nil {
return fmt.Errorf("error sending ENQ to prompt device: %v", err) return "", fmt.Errorf("error sending ENQ to prompt device: %v", err)
} }
return nil
time.Sleep(delay)
//Check card position status
status, err := CheckDispenserStatus(port)
if err != nil {
return "", err
}
return status, nil
} }
-32
View File
@@ -1,32 +0,0 @@
package errorhandlers
import (
"encoding/json"
"fmt"
"net/http"
"os"
"gitea.futuresens.co.uk/futuresens/cmstypes"
log "github.com/sirupsen/logrus"
)
const serviceName = "hardlink"
// writeError is a helper to send a JSON error and HTTP status in one go.
func WriteError(w http.ResponseWriter, status int, msg string) {
theResponse := cmstypes.StatusRec{
Code: status,
Message: msg,
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(theResponse)
}
func FatalError(err error) {
fmt.Println(err.Error())
log.Errorf(err.Error())
fmt.Println(". Press Enter to exit...")
fmt.Scanln()
os.Exit(1)
}
-206
View File
@@ -1,206 +0,0 @@
package handlers
import (
"bufio"
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"path/filepath"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/db"
log "github.com/sirupsen/logrus"
)
type preauthSpoolRecord struct {
CreatedAt time.Time `json:"createdAt"`
CheckoutDate string `json:"checkoutDate"` // keep as received
Fields map[string]string `json:"fields"` // ChipDNA result.Fields
}
func (app *App) getDB(ctx context.Context) (*sql.DB, error) {
app.dbMu.Lock()
defer app.dbMu.Unlock()
// Fast path: db exists and is alive
if app.db != nil {
pingCtx, cancel := context.WithTimeout(ctx, 1*time.Second)
defer cancel()
if err := app.db.PingContext(pingCtx); err == nil {
return app.db, nil
}
// stale handle
_ = app.db.Close()
app.db = nil
}
// Reconnect once, bounded
dialCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
dbConn, err := db.InitMSSQL(
app.cfg.Dbport,
app.cfg.Dbuser,
app.cfg.Dbpassword,
app.cfg.Dbname,
)
if err != nil {
return nil, err
}
pingCtx, cancel2 := context.WithTimeout(dialCtx, 1*time.Second)
defer cancel2()
if err := dbConn.PingContext(pingCtx); err != nil {
_ = dbConn.Close()
return nil, err
}
app.db = dbConn
return app.db, nil
}
func (app *App) spoolPath() string {
// keep it near logs; adjust if you prefer a dedicated dir
// ensure LogDir ends with separator in your config loader
return filepath.Join(app.cfg.LogDir, "preauth_spool.ndjson")
}
// persistPreauth tries DB first; if DB is down or insert fails, it spools to file.
// It never returns an error to the caller (so your HTTP flow stays simple),
// but it logs failures.
func (app *App) persistPreauth(ctx context.Context, fields map[string]string, checkoutDate string) {
// First, try DB (with your reconnect logic inside getDB)
dbConn, err := app.getDB(ctx)
if err == nil && dbConn != nil {
if err := db.InsertPreauth(ctx, dbConn, fields, checkoutDate); err == nil {
// opportunistic drain once DB is alive
go app.drainPreauthSpool(context.Background())
return
} else {
log.WithError(err).Warn("DB insert failed; will spool preauth")
}
} else {
log.WithError(err).Warn("DB unavailable; will spool preauth")
}
// Fallback: spool to file
rec := preauthSpoolRecord{
CreatedAt: time.Now().UTC(),
CheckoutDate: checkoutDate,
Fields: fields,
}
if spErr := app.spoolPreauth(rec); spErr != nil {
log.WithError(spErr).Error("failed to spool preauth")
}
}
// append one line JSON (NDJSON)
func (app *App) spoolPreauth(rec preauthSpoolRecord) error {
p := app.spoolPath()
f, err := os.OpenFile(p, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
return fmt.Errorf("open spool file: %w", err)
}
defer f.Close()
b, err := json.Marshal(rec)
if err != nil {
return fmt.Errorf("marshal spool record: %w", err)
}
if _, err := f.Write(append(b, '\n')); err != nil {
return fmt.Errorf("write spool record: %w", err)
}
return f.Sync() // ensure it's on disk
}
// Drain spool into DB.
// Strategy: read all lines, insert each; keep failures in a temp file; then replace original.
func (app *App) drainPreauthSpool(ctx context.Context) {
dbConn, err := app.getDB(ctx)
if err != nil {
return // still down, nothing to do
}
spool := app.spoolPath()
in, err := os.Open(spool)
if err != nil {
// no spool is fine
return
}
defer in.Close()
tmp := spool + ".tmp"
out, err := os.OpenFile(tmp, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
if err != nil {
log.WithError(err).Warn("drain spool: open tmp failed")
return
}
defer out.Close()
sc := bufio.NewScanner(in)
// allow long lines if receipts ever sneak in (shouldn't, but safe)
buf := make([]byte, 0, 64*1024)
sc.Buffer(buf, 2*1024*1024)
var (
okCount int
failCount int
)
for sc.Scan() {
line := sc.Bytes()
if len(line) == 0 {
continue
}
var rec preauthSpoolRecord
if err := json.Unmarshal(line, &rec); err != nil {
// malformed line: keep it so we don't lose evidence
_, _ = out.Write(append(line, '\n'))
failCount++
continue
}
// attempt insert
if err := db.InsertPreauth(ctx, dbConn, rec.Fields, rec.CheckoutDate); err != nil {
// DB still flaky or data issue: keep it for later retry
_, _ = out.Write(append(line, '\n'))
failCount++
continue
}
okCount++
}
if err := sc.Err(); err != nil {
log.WithError(err).Warn("drain spool: scanner error")
// best effort; do not replace spool
return
}
_ = out.Sync()
// Replace original spool with temp (atomic on Windows is best-effort; still OK here)
_ = in.Close()
_ = out.Close()
if err := os.Rename(tmp, spool); err != nil {
log.WithError(err).Warn("drain spool: rename failed")
return
}
if okCount > 0 || failCount > 0 {
log.WithFields(log.Fields{
"inserted": okCount,
"remaining": failCount,
}).Info("preauth spool drained")
}
}
+52 -46
View File
@@ -2,22 +2,19 @@ package handlers
import ( import (
"bytes" "bytes"
"context"
"database/sql" "database/sql"
"encoding/json" "encoding/json"
"encoding/xml" "encoding/xml"
"io" "io"
"net/http" "net/http"
"strings" "strings"
"sync"
"time" "time"
"github.com/tarm/serial" "github.com/tarm/serial"
"gitea.futuresens.co.uk/futuresens/cmstypes" "gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config" "gitea.futuresens.co.uk/futuresens/hardlink/db"
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser" "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/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/payment" "gitea.futuresens.co.uk/futuresens/hardlink/payment"
"gitea.futuresens.co.uk/futuresens/hardlink/printer" "gitea.futuresens.co.uk/futuresens/hardlink/printer"
@@ -27,23 +24,18 @@ import (
) )
type App struct { type App struct {
dispPort *serial.Port dispPort *serial.Port
lockserver lockserver.LockServer lockserver lockserver.LockServer
isPayment bool isPayment bool
db *sql.DB db *sql.DB
cfg *config.ConfigRec
dbMu sync.Mutex
cardWellStatus string
} }
func NewApp(dispPort *serial.Port, lockType, encoderAddress, cardWellStatus string, db *sql.DB, cfg *config.ConfigRec) *App { func NewApp(dispPort *serial.Port, lockType, encoderAddress string, db *sql.DB, isPayment bool) *App {
return &App{ return &App{
isPayment: cfg.IsPayment, isPayment: isPayment,
dispPort: dispPort, dispPort: dispPort,
lockserver: lockserver.NewLockServer(lockType, encoderAddress, errorhandlers.FatalError), lockserver: lockserver.NewLockServer(lockType, encoderAddress, FatalError),
db: db, db: db,
cfg: cfg,
cardWellStatus: cardWellStatus,
} }
} }
@@ -52,7 +44,6 @@ func (app *App) RegisterRoutes(mux *http.ServeMux) {
mux.HandleFunc("/printroomticket", app.printRoomTicket) mux.HandleFunc("/printroomticket", app.printRoomTicket)
mux.HandleFunc("/takepreauth", app.takePreauthorization) mux.HandleFunc("/takepreauth", app.takePreauthorization)
mux.HandleFunc("/takepayment", app.takePayment) mux.HandleFunc("/takepayment", app.takePayment)
mux.HandleFunc("/dispenserstatus", app.reportDispenserStatus)
} }
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) { func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
@@ -140,9 +131,8 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
theResponse.Status = result.Status theResponse.Status = result.Status
theResponse.Data, save = payment.BuildPreauthRedirectURL(result.Fields) theResponse.Data, save = payment.BuildPreauthRedirectURL(result.Fields)
if save { if save {
go app.persistPreauth(context.Background(), result.Fields, theRequest.CheckoutDate) db.InsertPreauth(r.Context(), app.db, result.Fields, theRequest.CheckoutDate)
} }
writeTransactionResult(w, http.StatusOK, theResponse) writeTransactionResult(w, http.StatusOK, theResponse)
} }
@@ -251,19 +241,19 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
log.Println("issueDoorCard called") log.Println("issueDoorCard called")
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST") writeError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
return return
} }
defer r.Body.Close() defer r.Body.Close()
if ct := r.Header.Get("Content-Type"); ct != "application/json" { if ct := r.Header.Get("Content-Type"); ct != "application/json" {
errorhandlers.WriteError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/json") writeError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/json")
return return
} }
if err := json.NewDecoder(r.Body).Decode(&doorReq); err != nil { if err := json.NewDecoder(r.Body).Decode(&doorReq); err != nil {
logging.Error(serviceName, err.Error(), "ReadJSON", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "ReadJSON", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid JSON payload: "+err.Error()) writeError(w, http.StatusBadRequest, "Invalid JSON payload: "+err.Error())
return return
} }
@@ -271,20 +261,28 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
checkIn, err := time.Parse(types.CustomLayout, doorReq.CheckinTime) checkIn, err := time.Parse(types.CustomLayout, doorReq.CheckinTime)
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Invalid checkinTime format", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Invalid checkinTime format", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid checkinTime format: "+err.Error()) writeError(w, http.StatusBadRequest, "Invalid checkinTime format: "+err.Error())
return return
} }
checkOut, err := time.Parse(types.CustomLayout, doorReq.CheckoutTime) checkOut, err := time.Parse(types.CustomLayout, doorReq.CheckoutTime)
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Invalid checkoutTime format", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Invalid checkoutTime format", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid checkoutTime format: "+err.Error()) writeError(w, http.StatusBadRequest, "Invalid checkoutTime format: "+err.Error())
return return
} }
if app.cardWellStatus, err = dispenser.DispenserStart(app.dispPort); err != nil { // card to encoder position if not there already
logging.Error(serviceName, err.Error(), "Dispense error", string(op), "", "", 0) if status, err := dispenser.DispenserSequence(app.dispPort); err != nil {
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error()) if status != "" {
logging.Error(serviceName, status, "Dispense error", string(op), "", "", 0)
writeError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
} else {
logging.Error(serviceName, err.Error(), "Dispense error", string(op), "", "", 0)
writeError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error()+"; check card stock")
}
return return
} else {
log.Info(status)
} }
// build lock server command // build lock server command
@@ -294,16 +292,33 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
err = app.lockserver.LockSequence() 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)
dispenser.DispenserFinal(app.dispPort) writeError(w, http.StatusBadGateway, err.Error())
errorhandlers.WriteError(w, http.StatusBadGateway, err.Error()) dispenser.CardOutOfMouth(app.dispPort)
dispenser.DispenserSequence(app.dispPort)
return return
} }
// final dispenser steps // card out of mouth
if app.cardWellStatus, err = dispenser.DispenserFinal(app.dispPort); err != nil { if status, err := dispenser.CardOutOfMouth(app.dispPort); err != nil {
logging.Error(serviceName, err.Error(), "Dispenser eject error", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Dispenser eject error", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser eject error: "+err.Error()) writeError(w, http.StatusServiceUnavailable, "Dispenser eject error: "+err.Error())
return return
} else {
log.Info(status)
}
// card to encoder position
if status, err := dispenser.DispenserSequence(app.dispPort); err != nil {
if status != "" {
logging.Error(serviceName, status, "Dispense error", string(op), "", "", 0)
writeError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
} else {
logging.Error(serviceName, err.Error(), "Dispense error", string(op), "", "", 0)
writeError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error()+"; check card stock")
}
return
} else {
log.Info(status)
} }
theResponse.Code = http.StatusOK theResponse.Code = http.StatusOK
@@ -328,32 +343,32 @@ func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) {
} }
log.Println("printRoomTicket called") log.Println("printRoomTicket called")
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST") writeError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
return return
} }
if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "xml") { if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "xml") {
errorhandlers.WriteError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/xml") writeError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/xml")
return return
} }
defer r.Body.Close() defer r.Body.Close()
if err := xml.NewDecoder(r.Body).Decode(&roomDetails); err != nil { if err := xml.NewDecoder(r.Body).Decode(&roomDetails); err != nil {
logging.Error(serviceName, err.Error(), "ReadXML", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "ReadXML", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid XML payload: "+err.Error()) writeError(w, http.StatusBadRequest, "Invalid XML payload: "+err.Error())
return return
} }
data, err := printer.BuildRoomTicket(roomDetails) data, err := printer.BuildRoomTicket(roomDetails)
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "BuildRoomTicket", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "BuildRoomTicket", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusInternalServerError, "BuildRoomTicket failed: "+err.Error()) writeError(w, http.StatusInternalServerError, "BuildRoomTicket failed: "+err.Error())
return return
} }
// Send to the Windows Epson TM-T82II via the printer package // Send to the Windows Epson TM-T82II via the printer package
if err := printer.SendToPrinter(data); err != nil { if err := printer.SendToPrinter(data); err != nil {
logging.Error(serviceName, err.Error(), "printRoomTicket", "printRoomTicket", "", "", 0) logging.Error(serviceName, err.Error(), "printRoomTicket", "printRoomTicket", "", "", 0)
errorhandlers.WriteError(w, http.StatusInternalServerError, "Print failed: "+err.Error()) writeError(w, http.StatusInternalServerError, "Print failed: "+err.Error())
return return
} }
@@ -365,12 +380,3 @@ func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) {
Message: "Print job sent successfully", Message: "Print job sent successfully",
}) })
} }
func (app *App) reportDispenserStatus(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(cmstypes.StatusRec{
Code: http.StatusOK,
Message: app.cardWellStatus,
})
}
+21
View File
@@ -2,14 +2,28 @@ package handlers
import ( import (
"encoding/json" "encoding/json"
"fmt"
"net/http" "net/http"
"os"
"gitea.futuresens.co.uk/futuresens/cmstypes" "gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/logging" "gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
) )
const serviceName = "hardlink" const serviceName = "hardlink"
// writeError is a helper to send a JSON error and HTTP status in one go.
func writeError(w http.ResponseWriter, status int, msg string) {
theResponse := cmstypes.StatusRec{
Code: status,
Message: msg,
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(theResponse)
}
func writeTransactionResult(w http.ResponseWriter, status int, theResponse cmstypes.ResponseRec) { func writeTransactionResult(w http.ResponseWriter, status int, theResponse cmstypes.ResponseRec) {
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status) w.WriteHeader(status)
@@ -18,3 +32,10 @@ func writeTransactionResult(w http.ResponseWriter, status int, theResponse cmsty
} }
} }
func FatalError(err error) {
fmt.Println(err.Error())
log.Errorf(err.Error())
fmt.Println(". Press Enter to exit...")
fmt.Scanln()
os.Exit(1)
}
+5 -12
View File
@@ -4,7 +4,6 @@ package main
import ( import (
"fmt" "fmt"
"os" "os"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap" "gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/config" "gitea.futuresens.co.uk/futuresens/hardlink/config"
@@ -14,7 +13,7 @@ import (
) )
const ( const (
buildVersion = "1.0.2" buildVersion = "1.0.0"
serviceName = "preauth-release" serviceName = "preauth-release"
) )
@@ -33,17 +32,11 @@ func main() {
defer database.Close() defer database.Close()
if err := payment.ReleasePreauthorizations(database); err != nil { if err := payment.ReleasePreauthorizations(database); err != nil {
log.Error(err) log.WithError(err).Fatal("Preauth release failed")
fmt.Println(err)
} else {
log.Info("Task completed successfully")
fmt.Println("Task completed successfully")
} }
for i := 20; i > 0; i-- { log.Info("Task completed successfully")
fmt.Printf("\rExiting in %2d seconds... ", i) fmt.Println(". Press Enter to exit...")
time.Sleep(time.Second) fmt.Scanln()
}
fmt.Println("\rExiting now. ")
os.Exit(0) os.Exit(0)
} }
+2 -2
View File
@@ -155,7 +155,7 @@ func (lock *SaltoLockServer) LockSequence() error {
reader := bufio.NewReader(conn) reader := bufio.NewReader(conn)
// 1. Send ENQ // 1. Send ENQ
log.Infof("LockSequence: sending ENQ") log.Infof("Sending ENQ")
if _, e := conn.Write([]byte{ENQ}); e != nil { if _, e := conn.Write([]byte{ENQ}); e != nil {
return fmt.Errorf("failed to send ENQ: %w", e) return fmt.Errorf("failed to send ENQ: %w", e)
} }
@@ -166,7 +166,7 @@ func (lock *SaltoLockServer) LockSequence() error {
} }
// 3. Send command frame // 3. Send command frame
log.Infof("LockSequence: sending encoding command: %q", string(lock.command)) log.Infof("Sending encoding command: %q", string(lock.command))
if _, e := conn.Write(lock.command); e != nil { if _, e := conn.Write(lock.command); e != nil {
return fmt.Errorf("failed to send command frame: %w", e) return fmt.Errorf("failed to send command frame: %w", e)
} }
+19 -13
View File
@@ -18,7 +18,6 @@ import (
"gitea.futuresens.co.uk/futuresens/hardlink/bootstrap" "gitea.futuresens.co.uk/futuresens/hardlink/bootstrap"
"gitea.futuresens.co.uk/futuresens/hardlink/config" "gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser" "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/handlers"
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver" "gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
"gitea.futuresens.co.uk/futuresens/hardlink/logging" "gitea.futuresens.co.uk/futuresens/hardlink/logging"
@@ -26,7 +25,7 @@ import (
) )
const ( const (
buildVersion = "1.1.0" buildVersion = "1.0.28"
serviceName = "hardlink" serviceName = "hardlink"
) )
@@ -38,7 +37,6 @@ func main() {
lockserver.Cert = config.Cert lockserver.Cert = config.Cert
lockserver.LockServerURL = config.LockserverUrl lockserver.LockServerURL = config.LockserverUrl
dispHandle := &serial.Port{} dispHandle := &serial.Port{}
cardWellStatus := ""
// Setup logging and get file handle // Setup logging and get file handle
logFile, err := logging.SetupLogging(config.LogDir, serviceName, buildVersion) logFile, err := logging.SetupLogging(config.LogDir, serviceName, buildVersion)
@@ -53,16 +51,24 @@ func main() {
dispenser.Address = []byte(config.DispenserAdrr) dispenser.Address = []byte(config.DispenserAdrr)
dispHandle, err = dispenser.InitializeDispenser() dispHandle, err = dispenser.InitializeDispenser()
if err != nil { if err != nil {
errorhandlers.FatalError(err) handlers.FatalError(err)
} }
defer dispHandle.Close() defer dispHandle.Close()
cardWellStatus, err = dispenser.DispenserPrepare(dispHandle) status, err := dispenser.CheckDispenserStatus(dispHandle)
if err != nil { if err != nil {
err = fmt.Errorf("%s; wrong dispenser address: %s", err, config.DispenserAdrr) if len(status) == 0 {
errorhandlers.FatalError(err) err = fmt.Errorf("%s; wrong dispenser address: %s", err, config.DispenserAdrr)
handlers.FatalError(err)
} else {
fmt.Println(status)
fmt.Println(err.Error())
}
} }
fmt.Println(cardWellStatus) if status, err = dispenser.DispenserSequence(dispHandle); err != nil {
handlers.FatalError(err)
}
log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status)
} }
// Test lock-server connection // Test lock-server connection
@@ -97,7 +103,7 @@ func main() {
} }
// Create App and wire routes // Create App and wire routes
app := handlers.NewApp(dispHandle, config.LockType, config.EncoderAddress, cardWellStatus, database, &config) app := handlers.NewApp(dispHandle, config.LockType, config.EncoderAddress, database, config.IsPayment)
mux := http.NewServeMux() mux := http.NewServeMux()
app.RegisterRoutes(mux) app.RegisterRoutes(mux)
@@ -106,7 +112,7 @@ func main() {
log.Infof("Starting HTTP server on http://localhost%s", addr) log.Infof("Starting HTTP server on http://localhost%s", addr)
fmt.Printf("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 { if err := http.ListenAndServe(addr, mux); err != nil {
errorhandlers.FatalError(err) handlers.FatalError(err)
} }
} }
@@ -117,12 +123,12 @@ func readTicketLayout() printer.LayoutOptions {
// 1) Read the file // 1) Read the file
data, err := os.ReadFile(layoutName) data, err := os.ReadFile(layoutName)
if err != nil { if err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err)) handlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
} }
// 2) Unmarshal into your struct // 2) Unmarshal into your struct
if err := xml.Unmarshal(data, &layout); err != nil { if err := xml.Unmarshal(data, &layout); err != nil {
errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err)) handlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
} }
return layout return layout
@@ -141,7 +147,7 @@ func startChipDnaClient() {
cmd, err := startClient() cmd, err := startClient()
if err != nil { if err != nil {
errorhandlers.FatalError(err) handlers.FatalError(err)
} }
// Restart loop // Restart loop
+3 -3
View File
@@ -21,7 +21,7 @@ const (
) )
/* ============================== /* ==============================
Public Entry Point Public Entry Point (LEGACY)
============================== */ ============================== */
func ReleasePreauthorizations(database *sql.DB) error { func ReleasePreauthorizations(database *sql.DB) error {
@@ -78,7 +78,6 @@ func handlePreauthRelease(
if err != nil { if err != nil {
return err return err
} }
log.Infof("res=%s state=%s", info.transactionRes, info.transactionState)
// If already voided or declined → mark released // If already voided or declined → mark released
if isAlreadyReleased(info) { if isAlreadyReleased(info) {
@@ -87,7 +86,8 @@ func handlePreauthRelease(
// Only void approved + uncommitted // Only void approved + uncommitted
if !isVoidable(info) { if !isVoidable(info) {
log.Infof("Preauth %s not eligible for void (res=%s state=%s)", ref, info.transactionRes, info.transactionState) log.Infof("Preauth %s not eligible for void (res=%s state=%s)",
ref, info.transactionRes, info.transactionState)
return nil return nil
} }
-16
View File
@@ -2,22 +2,6 @@
builtVersion is a const in main.go builtVersion is a const in main.go
#### 1.1.0 - 26 January 2026
divided `/starttransaction` endpoint into two separate endpoints:
`/takepreauth` to request preauthorization payment
`/takepayment` to request taking payment
added preauth releaser functionality to release preauthorization payments after a defined time period
added db connection check before adding a transaction to the database
and reconnection functionality if the connection to the database is lost
added `/dispenserstatus` endpoint
key card always stays at encoder position
#### 1.0.30 - 09 January 2026
improved logging for preauth releaser
#### 1.0.29 - 08 January 2026
added count down before exiting the preauth releaser 20 seconds
#### 1.0.28 - 10 December 2025 #### 1.0.28 - 10 December 2025
added preauth releaser added preauth releaser