391 lines
13 KiB
Go
391 lines
13 KiB
Go
package handlers
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/tarm/serial"
|
|
|
|
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/dispenser"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/lockserver"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/payment"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/printer"
|
|
"gitea.futuresens.co.uk/futuresens/logging"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
const (
|
|
customLayout = "2006-01-02 15:04:05 -0700"
|
|
takePreauthorizationUrl = "http://127.0.0.1:18181/start-transaction/"
|
|
takePaymentUrl = "http://127.0.0.1:18181/start-and-confirm-transaction/"
|
|
)
|
|
|
|
type App struct {
|
|
dispPort *serial.Port
|
|
lockserver lockserver.LockServer
|
|
isPayment bool
|
|
}
|
|
|
|
func NewApp(dispPort *serial.Port, lockType, encoderAddress string, isPayment bool) *App {
|
|
return &App{
|
|
isPayment: isPayment,
|
|
dispPort: dispPort,
|
|
lockserver: lockserver.NewLockServer(lockType, encoderAddress, FatalError),
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("takePreauthorization")
|
|
var (
|
|
theResponse cmstypes.ResponseRec
|
|
cardholderReceipt string
|
|
theRequest cmstypes.TransactionRec
|
|
trResult payment.TransactionResultXML
|
|
)
|
|
|
|
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 {
|
|
theResponse.Data = payment.BuildFailureURL(payment.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 = payment.BuildFailureURL(payment.ResultError, "Method not allowed; use POST")
|
|
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
if ct := r.Header.Get("Content-Type"); ct != "text/xml" {
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Content-Type must be text/xml")
|
|
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
|
return
|
|
}
|
|
|
|
body, _ := io.ReadAll(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("Transaction payload: Amount=%s, Type=%s", theRequest.AmountMinorUnits, theRequest.TransactionType)
|
|
|
|
client := &http.Client{Timeout: 300 * time.Second}
|
|
response, err := client.Post(takePreauthorizationUrl, "text/xml", bytes.NewBuffer(body))
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Payment processing error", string(op), "", "", 0)
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "No response from payment processor")
|
|
writeTransactionResult(w, http.StatusBadGateway, theResponse)
|
|
return
|
|
}
|
|
defer response.Body.Close()
|
|
|
|
body, err = io.ReadAll(response.Body)
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Read response body error", string(op), "", "", 0)
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Failed to read response body")
|
|
writeTransactionResult(w, http.StatusInternalServerError, theResponse)
|
|
return
|
|
}
|
|
|
|
if err := trResult.ParseTransactionResult(body); err != nil {
|
|
logging.Error(serviceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
|
}
|
|
|
|
// Compose JSON from responseEntries
|
|
result := make(map[string]string)
|
|
for _, e := range trResult.Entries {
|
|
switch e.Key {
|
|
case payment.ReceiptData, payment.ReceiptDataMerchant:
|
|
// ignore these
|
|
case payment.ReceiptDataCardholder:
|
|
cardholderReceipt = e.Value
|
|
case payment.TransactionResult:
|
|
theResponse.Status.Message = e.Value
|
|
theResponse.Status.Code = http.StatusOK
|
|
result[e.Key] = e.Value
|
|
default:
|
|
result[e.Key] = e.Value
|
|
}
|
|
}
|
|
|
|
if err := printer.PrintCardholderReceipt(cardholderReceipt); err != nil {
|
|
log.Errorf("PrintCardholderReceipt error: %v", err)
|
|
}
|
|
|
|
theResponse.Data = payment.BuildPreauthRedirectURL(result)
|
|
writeTransactionResult(w, http.StatusOK, theResponse)
|
|
}
|
|
|
|
func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
|
|
const op = logging.Op("takePayment")
|
|
var (
|
|
theResponse cmstypes.ResponseRec
|
|
cardholderReceipt string
|
|
theRequest cmstypes.TransactionRec
|
|
trResult payment.TransactionResultXML
|
|
)
|
|
|
|
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 {
|
|
theResponse.Data = payment.BuildFailureURL(payment.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 = payment.BuildFailureURL(payment.ResultError, "Method not allowed; use POST")
|
|
writeTransactionResult(w, http.StatusMethodNotAllowed, theResponse)
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
if ct := r.Header.Get("Content-Type"); ct != "text/xml" {
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Content-Type must be text/xml")
|
|
writeTransactionResult(w, http.StatusUnsupportedMediaType, theResponse)
|
|
return
|
|
}
|
|
|
|
body, _ := io.ReadAll(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("Transaction payload: Amount=%s, Type=%s", theRequest.AmountMinorUnits, theRequest.TransactionType)
|
|
|
|
client := &http.Client{Timeout: 300 * time.Second}
|
|
response, err := client.Post(takePaymentUrl, "text/xml", bytes.NewBuffer(body))
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Payment processing error", string(op), "", "", 0)
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "No response from payment processor")
|
|
writeTransactionResult(w, http.StatusBadGateway, theResponse)
|
|
return
|
|
}
|
|
defer response.Body.Close()
|
|
|
|
body, err = io.ReadAll(response.Body)
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Read response body error", string(op), "", "", 0)
|
|
theResponse.Data = payment.BuildFailureURL(payment.ResultError, "Failed to read response body")
|
|
writeTransactionResult(w, http.StatusInternalServerError, theResponse)
|
|
return
|
|
}
|
|
|
|
if err := trResult.ParseTransactionResult(body); err != nil {
|
|
logging.Error(serviceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
|
|
}
|
|
|
|
// Compose JSON from responseEntries
|
|
result := make(map[string]string)
|
|
for _, e := range trResult.Entries {
|
|
switch e.Key {
|
|
case payment.ReceiptData, payment.ReceiptDataMerchant:
|
|
// ignore these
|
|
case payment.ReceiptDataCardholder:
|
|
cardholderReceipt = e.Value
|
|
case payment.TransactionResult:
|
|
theResponse.Status.Message = e.Value
|
|
theResponse.Status.Code = http.StatusOK
|
|
result[e.Key] = e.Value
|
|
default:
|
|
result[e.Key] = e.Value
|
|
}
|
|
}
|
|
|
|
if err := printer.PrintCardholderReceipt(cardholderReceipt); err != nil {
|
|
log.Errorf("PrintCardholderReceipt error: %v", err)
|
|
}
|
|
|
|
theResponse.Data = payment.BuildPaymentRedirectURL(result)
|
|
writeTransactionResult(w, http.StatusOK, theResponse)
|
|
}
|
|
|
|
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 {
|
|
writeError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
if ct := r.Header.Get("Content-Type"); ct != "application/json" {
|
|
writeError(w, http.StatusUnsupportedMediaType, "Content-Type must be application/json")
|
|
return
|
|
}
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&doorReq); err != nil {
|
|
logging.Error(serviceName, err.Error(), "ReadJSON", string(op), "", "", 0)
|
|
writeError(w, http.StatusBadRequest, "Invalid JSON payload: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// parse times
|
|
checkIn, err := time.Parse(customLayout, doorReq.CheckinTime)
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Invalid checkinTime format", string(op), "", "", 0)
|
|
writeError(w, http.StatusBadRequest, "Invalid checkinTime format: "+err.Error())
|
|
return
|
|
}
|
|
checkOut, err := time.Parse(customLayout, doorReq.CheckoutTime)
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Invalid checkoutTime format", string(op), "", "", 0)
|
|
writeError(w, http.StatusBadRequest, "Invalid checkoutTime format: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// dispenser sequence
|
|
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)
|
|
}
|
|
|
|
// build lock server command
|
|
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
|
|
|
|
// lock server sequence
|
|
err = app.lockserver.LockSequence()
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "Key encoding", string(op), "", "", 0)
|
|
writeError(w, http.StatusBadGateway, err.Error())
|
|
dispenser.CardOutOfMouth(app.dispPort)
|
|
return
|
|
}
|
|
|
|
// final dispenser steps
|
|
if status, err := dispenser.CardOutOfMouth(app.dispPort); err != nil {
|
|
logging.Error(serviceName, err.Error(), "Dispenser eject error", string(op), "", "", 0)
|
|
writeError(w, http.StatusServiceUnavailable, "Dispenser eject error: "+err.Error())
|
|
return
|
|
} else {
|
|
log.Info(status)
|
|
}
|
|
|
|
theResponse.Code = http.StatusOK
|
|
theResponse.Message = "Card issued successfully"
|
|
// success! return 200 and any data you like
|
|
w.Header().Set("Content-Type", "application/json")
|
|
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 {
|
|
writeError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
|
|
return
|
|
}
|
|
if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "xml") {
|
|
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(serviceName, err.Error(), "ReadXML", string(op), "", "", 0)
|
|
writeError(w, http.StatusBadRequest, "Invalid XML payload: "+err.Error())
|
|
return
|
|
}
|
|
|
|
data, err := printer.BuildRoomTicket(roomDetails)
|
|
if err != nil {
|
|
logging.Error(serviceName, err.Error(), "BuildRoomTicket", string(op), "", "", 0)
|
|
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(serviceName, err.Error(), "printRoomTicket", "printRoomTicket", "", "", 0)
|
|
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",
|
|
})
|
|
}
|