441 lines
16 KiB
Go
441 lines
16 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/config"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/dispenser"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/errorhandlers"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/lockserver"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
|
|
"gitea.futuresens.co.uk/futuresens/logging"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type doorCardDispenser interface {
|
|
PrepareCurrentCard(context.Context) (string, error)
|
|
DeliverCurrentCard(context.Context) (string, error)
|
|
BeginPrepareNextCard(context.Context) error
|
|
PrepareNextCard(context.Context) (string, error)
|
|
}
|
|
|
|
type App struct {
|
|
disp doorCardDispenser
|
|
lockserver lockserver.LockServer
|
|
paymentService *paymentsvc.Service
|
|
creditCallStreamEnabled bool
|
|
creditCallTransport http.RoundTripper
|
|
creditCallReceipt func(string)
|
|
isPayment bool
|
|
db *sql.DB
|
|
cfg *config.ConfigRec
|
|
dbMu sync.Mutex
|
|
cardWellMu sync.RWMutex
|
|
cardWellStatus string
|
|
availabilityMu sync.Mutex
|
|
availabilityTimers map[string]*time.Timer
|
|
}
|
|
|
|
func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus string, db *sql.DB, cfg *config.ConfigRec) *App {
|
|
app := &App{
|
|
isPayment: cfg.IsPayment,
|
|
disp: disp,
|
|
lockserver: lockserver.NewLockServer(lockType, encoderAddress, errorhandlers.FatalError),
|
|
db: db,
|
|
cfg: cfg,
|
|
availabilityTimers: make(map[string]*time.Timer),
|
|
}
|
|
app.SetCardWellStatus(cardWellStatus)
|
|
return app
|
|
}
|
|
|
|
func (app *App) SetPaymentService(service *paymentsvc.Service) {
|
|
app.paymentService = service
|
|
}
|
|
|
|
func (app *App) RegisterRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("/issuedoorcard", app.issueDoorCard)
|
|
mux.HandleFunc("/printroomticket", app.printRoomTicket)
|
|
mux.HandleFunc("/takepreauth", app.takePreauthorization)
|
|
mux.HandleFunc("/takepayment", app.takePayment)
|
|
mux.HandleFunc("/dispenserstatus", app.reportDispenserStatus)
|
|
mux.HandleFunc("/testissuedoorcard", app.testIssueDoorCard)
|
|
mux.HandleFunc("/ping-pdq", app.fetchChipDNAStatus)
|
|
mux.HandleFunc("/logerror", app.onChipDNAError)
|
|
mux.HandleFunc("/api/payment/sale", app.salePayment)
|
|
mux.HandleFunc("/api/payment/preauth", app.streamCreditCallPreauth)
|
|
}
|
|
|
|
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("takePreauthorization")
|
|
|
|
var (
|
|
theResponse cmstypes.ResponseRec
|
|
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-Methods", "POST, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if !app.isPayment {
|
|
if !app.cfg.TestMode {
|
|
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted preauthorization while payment processing is disabled")
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
|
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
|
|
return
|
|
}
|
|
}
|
|
|
|
if r.Method == http.MethodOptions {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
log.Println("takePreauthorization called")
|
|
if r.Method != http.MethodPost {
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
|
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
|
return
|
|
}
|
|
|
|
if r.Header.Get("Content-Type") != "text/xml" {
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
|
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
|
return
|
|
}
|
|
|
|
defer r.Body.Close()
|
|
|
|
body, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
|
|
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
|
return
|
|
}
|
|
|
|
if err := xml.Unmarshal(body, &theRequest); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
|
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
|
return
|
|
}
|
|
|
|
log.Printf(
|
|
"Preauthorization payload: Amount=%s, Type=%s",
|
|
theRequest.AmountMinorUnits,
|
|
theRequest.TransactionType,
|
|
)
|
|
|
|
outcome := app.executeCreditCallPreauth(context.Background(), theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
|
|
var transaction creditcall.TransactionResultXML
|
|
response, err := callChipDNA(client, types.LinkStartTransaction, body)
|
|
if err != nil {
|
|
return transaction, err
|
|
}
|
|
if err := transaction.ParseTransactionResult(response); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
|
}
|
|
return transaction, nil
|
|
})
|
|
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
|
|
}
|
|
|
|
func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("takePayment")
|
|
|
|
var (
|
|
theResponse cmstypes.ResponseRec
|
|
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-Methods", "POST, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if !app.isPayment {
|
|
if !app.cfg.TestMode {
|
|
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted payment while payment processing is disabled")
|
|
theResponse.Status.Code = http.StatusServiceUnavailable
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Payment processing is disabled")
|
|
writeTransactionResult(w, http.StatusServiceUnavailable, theResponse)
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
if r.Method == http.MethodOptions {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
log.Println("takePayment called")
|
|
if r.Method != http.MethodPost {
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Method not allowed; use POST")
|
|
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
|
return
|
|
}
|
|
|
|
if r.Header.Get("Content-Type") != "text/xml" {
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Content-Type must be text/xml")
|
|
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
|
return
|
|
}
|
|
|
|
defer r.Body.Close()
|
|
|
|
body, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Read body error", string(op), "", "", 0)
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Failed to read request body")
|
|
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
|
return
|
|
}
|
|
|
|
if err := xml.Unmarshal(body, &theRequest); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
|
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "Invalid XML payload")
|
|
writeTransactionResult(w, http.StatusBadRequest, theResponse)
|
|
return
|
|
}
|
|
|
|
log.Printf("Transaction payload: Amount=%s, Type=%s",
|
|
theRequest.AmountMinorUnits,
|
|
theRequest.TransactionType,
|
|
)
|
|
|
|
outcome := app.executeCreditCallSale(theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
|
|
var trResult creditcall.TransactionResultXML
|
|
body, err := callChipDNA(client, types.LinkStartTransaction, body)
|
|
if err != nil {
|
|
return trResult, err
|
|
}
|
|
if err := trResult.ParseTransactionResult(body); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
|
}
|
|
return trResult, nil
|
|
})
|
|
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
|
|
}
|
|
|
|
func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("issueDoorCard")
|
|
var (
|
|
doorReq lockserver.DoorCardRequest
|
|
theResponse cmstypes.StatusRec
|
|
)
|
|
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if r.Method == http.MethodOptions {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
log.Println("issueDoorCard called")
|
|
if r.Method != http.MethodPost {
|
|
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
if ct := r.Header.Get("Content-Type"); ct != "application/json" {
|
|
errorhandlers.WriteError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/json")
|
|
return
|
|
}
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&doorReq); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "ReadJSON", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid JSON payload: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// parse times
|
|
checkIn, err := time.Parse(types.CustomLayout, doorReq.CheckinTime)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Invalid checkinTime format", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid checkinTime format: "+err.Error())
|
|
return
|
|
}
|
|
checkOut, err := time.Parse(types.CustomLayout, doorReq.CheckoutTime)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Invalid checkoutTime format", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid checkoutTime format: "+err.Error())
|
|
return
|
|
}
|
|
|
|
status, err := app.disp.PrepareCurrentCard(r.Context())
|
|
app.SetCardWellStatus(status)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
|
|
if errors.Is(err, dispenser.ErrCardWellEmpty) {
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
|
|
return
|
|
}
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// doorReq.RoomField = "104"
|
|
// build lock server command
|
|
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
|
|
|
|
// lock server sequence
|
|
encodingErr := app.lockserver.LockSequence()
|
|
if encodingErr != nil {
|
|
logging.Error(types.ServiceName, encodingErr.Error(), "Key encoding", string(op), "", "", 0)
|
|
}
|
|
|
|
// Once encoding has started, finish the physical dispenser sequence even if
|
|
// the HTTP client disconnects. Finalization remains bounded by one shared timeout.
|
|
finalizeCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
status, deliveryErr := app.disp.DeliverCurrentCard(finalizeCtx)
|
|
app.SetCardWellStatus(status)
|
|
if deliveryErr != nil {
|
|
if encodingErr != nil {
|
|
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, deliveryErr)
|
|
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
|
|
return
|
|
}
|
|
|
|
logging.Error(types.ServiceName, deliveryErr.Error(), "Card delivery", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Card delivery could not be confirmed")
|
|
return
|
|
}
|
|
|
|
if encodingErr != nil {
|
|
status, preparationErr := app.disp.PrepareNextCard(finalizeCtx)
|
|
app.SetCardWellStatus(status)
|
|
if preparationErr != nil {
|
|
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, preparationErr)
|
|
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
|
|
if errors.Is(preparationErr, dispenser.ErrCardWellEmpty) {
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
|
|
return
|
|
}
|
|
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
|
|
return
|
|
}
|
|
|
|
errorhandlers.WriteError(w, http.StatusBadGateway, encodingErr.Error())
|
|
return
|
|
}
|
|
|
|
if preparationErr := app.disp.BeginPrepareNextCard(finalizeCtx); preparationErr != nil {
|
|
logging.Error(types.ServiceName, preparationErr.Error(), "Next card preparation dispatch", string(op), "", "", 0)
|
|
}
|
|
|
|
theResponse.Code = http.StatusOK
|
|
theResponse.Message = "Card issued successfully"
|
|
w.WriteHeader(http.StatusOK)
|
|
_ = json.NewEncoder(w).Encode(theResponse)
|
|
}
|
|
|
|
func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("printRoomTicket")
|
|
var roomDetails printer.RoomDetailsRec
|
|
// Allow CORS preflight if needed
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
|
|
if r.Method == http.MethodOptions {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
log.Println("printRoomTicket called")
|
|
if r.Method != http.MethodPost {
|
|
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
|
|
return
|
|
}
|
|
if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "xml") {
|
|
errorhandlers.WriteError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/xml")
|
|
return
|
|
}
|
|
|
|
defer r.Body.Close()
|
|
if err := xml.NewDecoder(r.Body).Decode(&roomDetails); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusBadRequest, "Invalid XML payload: "+err.Error())
|
|
return
|
|
}
|
|
|
|
data, err := printer.BuildRoomTicket(roomDetails)
|
|
if err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "BuildRoomTicket", string(op), "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusInternalServerError, "BuildRoomTicket failed: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Send to the Windows Epson TM-T82II via the printer package
|
|
if err := printer.SendToPrinter(data); err != nil {
|
|
logging.Error(types.ServiceName, err.Error(), "printRoomTicket", "printRoomTicket", "", "", 0)
|
|
errorhandlers.WriteError(w, http.StatusInternalServerError, "Print failed: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Success
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(cmstypes.StatusRec{
|
|
Code: http.StatusOK,
|
|
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(),
|
|
})
|
|
}
|
|
|
|
func (app *App) SetCardWellStatus(s string) {
|
|
app.cardWellMu.Lock()
|
|
prev := app.cardWellStatus
|
|
app.cardWellStatus = s
|
|
app.cardWellMu.Unlock()
|
|
|
|
if s != "" && prev != s {
|
|
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Dispenser Error Status", "Status: "+s)
|
|
}
|
|
}
|
|
|
|
func (app *App) CardWellStatus() string {
|
|
app.cardWellMu.RLock()
|
|
defer app.cardWellMu.RUnlock()
|
|
return app.cardWellStatus
|
|
}
|