mirror of
https://github.com/rjNemo/rentease.git
synced 2026-06-06 02:36:49 +00:00
Ruidy
23f3ceec21
Some checks are pending
CI / checks (push) Waiting to run
* feat(stripe): add Stripe payment sync and webhook support Introduce Stripe integration for automatic payment ingestion and refund tracking. Adds new fields to the payment model for Stripe IDs and status, Stripe client driver, sync service, cron job, manual API endpoint, and public webhook handler for real-time updates. Includes tests and documentation. Manual cash entry remains supported. * chore(stripe): upgrade to stripe-go v83 Upgrade Stripe SDK from v79 to v83 across the codebase. Update all imports to use github.com/stripe/stripe-go/v83 and refactor client usage to match the new API, including changes to PaymentIntents listing. Update documentation and plans to reference the new version. Remove references to the old version from go.mod and go.sum. * refactor(payment): extract payment logic to new service Moves all payment-related logic (manual payments, Stripe sync, webhook handling) from the booking service into a dedicated payment service (`internal/service/payment`). Updates server, cron, and handler wiring to inject and use the new payment service. Adjusts tests, routes, and documentation to reflect the new separation of concerns. This improves cohesion, clarifies responsibilities, and prepares for future payment features. No database schema changes are introduced. * chore(ci): add Go and templ setup to CI workflow This update enhances the CI workflow by adding steps to set up Go using the version specified in go.mod, add the Go bin directory to the PATH, and install the templ code generation tool. These additions ensure that Go-based tooling is available for subsequent CI steps.
560 lines
17 KiB
Go
560 lines
17 KiB
Go
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/a-h/templ"
|
|
"github.com/go-chi/chi/v5"
|
|
u "github.com/rjNemo/underscore"
|
|
|
|
"github.com/rjNemo/rentease/assets"
|
|
"github.com/rjNemo/rentease/internal/config"
|
|
"github.com/rjNemo/rentease/internal/constant"
|
|
"github.com/rjNemo/rentease/internal/service/booking"
|
|
"github.com/rjNemo/rentease/internal/service/payment"
|
|
"github.com/rjNemo/rentease/internal/view"
|
|
myTime "github.com/rjNemo/rentease/pkg/time"
|
|
)
|
|
|
|
func handleBookingListPage(bs *booking.Service, hc *config.Host) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
search := r.URL.Query().Get("search")
|
|
|
|
var bookings []*booking.Line
|
|
if search != "" {
|
|
bookings = bs.Search(search)
|
|
} else {
|
|
bookings = bs.All()
|
|
}
|
|
|
|
slog.Info("serving bookings", slog.Int("bookings_length", len(bookings)))
|
|
|
|
bvm := u.Map(bookings, func(b *booking.Line) *view.ListBookingsViewModel {
|
|
return &view.ListBookingsViewModel{
|
|
Id: b.InvoiceNumber(hc),
|
|
Url: templ.SafeURL(fmt.Sprintf("%s/%d", constant.RouteBooking, b.ID)),
|
|
From: b.From.Format(time.DateOnly),
|
|
To: b.To.Format(time.DateOnly),
|
|
Platform: b.Platform,
|
|
Name: b.CustomerName,
|
|
Total: strconv.FormatFloat(b.Total, 'f', 2, 64),
|
|
Canceled: b.Canceled,
|
|
}
|
|
})
|
|
|
|
var err error
|
|
switch {
|
|
case hxRequest(r) && !hxBoosted(r):
|
|
err = renderTempl(w, http.StatusOK, view.BookingLines(bvm))
|
|
default:
|
|
err = renderTempl(w, http.StatusOK, view.ListBookings(bvm))
|
|
}
|
|
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func paymentViewModelFromBookingPayment(p booking.Payment, stripeAccountID string) *view.PaymentViewModel {
|
|
stripeStatus := ""
|
|
if p.StripeStatus != nil {
|
|
stripeStatus = *p.StripeStatus
|
|
}
|
|
|
|
var stripeDashboardURL string
|
|
if string(p.PaymentMethod) == "Card" && stripeAccountID != "" && p.StripePaymentID != nil && *p.StripePaymentID != "" {
|
|
stripeDashboardURL = fmt.Sprintf("https://dashboard.stripe.com/%s/payments/%s", stripeAccountID, *p.StripePaymentID)
|
|
}
|
|
|
|
return &view.PaymentViewModel{
|
|
Amount: strconv.FormatFloat(p.Amount, 'f', 2, 64),
|
|
PaymentMethod: string(p.PaymentMethod),
|
|
PaymentUrl: fmt.Sprintf("%s/%d", constant.RoutePayment, p.ID),
|
|
StripeStatus: stripeStatus,
|
|
StripeDashboardURL: stripeDashboardURL,
|
|
}
|
|
}
|
|
|
|
func handleBookingList(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
search := r.URL.Query().Get("search")
|
|
|
|
var bookings []*booking.Line
|
|
if search != "" {
|
|
bookings = bs.Search(search)
|
|
} else {
|
|
bookings = bs.All()
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(bookings); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleBookingCreatePage(hc *config.Host) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if err := renderTempl(w, http.StatusOK, view.NewBooking(u.Map(hc.Platforms, func(p config.Platform) string {
|
|
return string(p)
|
|
}))); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleBookingCreate(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if err := r.ParseForm(); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
customerNumber, err := strconv.Atoi(r.FormValue("customer_number"))
|
|
if err != nil {
|
|
http.Error(w, "invalid customer number", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
platformFees := 0.0
|
|
if v := r.FormValue("platform_fees"); v != "" {
|
|
platformFees, err = strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
http.Error(w, "invalid platform fees", http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
externalID := r.FormValue("external_id")
|
|
var externalPtr *string
|
|
if externalID != "" {
|
|
externalPtr = &externalID
|
|
}
|
|
|
|
from, _ := myTime.ParseFromForm(r.FormValue("from"))
|
|
to, _ := myTime.ParseFromForm(r.FormValue("to"))
|
|
|
|
b := bs.Create(
|
|
from,
|
|
to,
|
|
r.FormValue("name"),
|
|
r.FormValue("phone_number"),
|
|
r.FormValue("email"),
|
|
r.FormValue("platform"),
|
|
customerNumber,
|
|
platformFees,
|
|
externalPtr,
|
|
)
|
|
|
|
http.Redirect(w, r, fmt.Sprintf("%s/%d", constant.RouteBooking, b.ID), http.StatusSeeOther)
|
|
}
|
|
}
|
|
|
|
func handleBookingPage(bs *booking.Service, hc *config.Host) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
idStr := chi.URLParam(r, "id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid booking id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
b, err := bs.One(id)
|
|
if err != nil {
|
|
renderHTTPErrorPage(w, http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
var eid string
|
|
if b.ExternalID == nil {
|
|
eid = ""
|
|
} else {
|
|
eid = *b.ExternalID
|
|
}
|
|
bvm := &view.BookingViewModel{
|
|
Id: b.InvoiceNumber(hc),
|
|
Name: b.Name,
|
|
PhoneNumber: b.PhoneNumber,
|
|
CustomerNumber: strconv.Itoa(b.CustomerNumber),
|
|
Email: b.Email,
|
|
From: b.From.Format(time.DateOnly),
|
|
To: b.To.Format(time.DateOnly),
|
|
Platform: string(b.Platform),
|
|
ExternalId: eid,
|
|
Canceled: b.Canceled,
|
|
PlatformFees: strconv.FormatFloat(b.PlatformFees, 'f', 2, 64),
|
|
Url: templ.EscapeString(fmt.Sprintf("%s/%d", constant.RouteBooking, b.ID)),
|
|
PdfUrl: templ.SafeURL(fmt.Sprintf("%s/pdf/%d", constant.RouteBooking, b.ID)),
|
|
CancelUrl: fmt.Sprintf("%s/%d/cancel", constant.RouteBooking, b.ID),
|
|
PaymentUrl: fmt.Sprintf("%s/%d", constant.RoutePayment, b.ID),
|
|
StripePaymentLinkUrl: fmt.Sprintf("%s/%d/stripe/payment-link", constant.RouteBooking, b.ID),
|
|
Items: view.ItemListViewModel{
|
|
Items: u.Map(b.Items, func(i booking.Item) view.ItemViewModel {
|
|
return view.ItemViewModel{
|
|
Id: strconv.Itoa(i.ID),
|
|
Item: i.Item,
|
|
Quantity: strconv.Itoa(i.Quantity),
|
|
Price: strconv.FormatFloat(i.Price, 'f', 2, 64),
|
|
SubTotal: strconv.FormatFloat(i.Price*float64(i.Quantity), 'f', 2, 64),
|
|
PaymentStatus: i.PaymentStatus,
|
|
ItemUrl: fmt.Sprintf("%s/%d", constant.RouteItem, i.ID),
|
|
}
|
|
}),
|
|
Payments: u.Map(b.Payments, func(p booking.Payment) view.PaymentViewModel {
|
|
return *paymentViewModelFromBookingPayment(p, hc.StripeAccountID)
|
|
}),
|
|
},
|
|
Total: strconv.FormatFloat(u.Reduce(b.Items, func(i booking.Item, sum float64) float64 {
|
|
return sum + i.Price*float64(i.Quantity)
|
|
}, 0.0), 'f', 2, 64),
|
|
Platforms: u.Map(hc.Platforms, func(p config.Platform) string { return string(p) }),
|
|
ItemList: u.OrderBy(func(items map[string]config.HostItem) (out []string) { // TODO: return the full item to prefill the form
|
|
for _, item := range items {
|
|
out = append(out, item.Name)
|
|
}
|
|
return out
|
|
}(hc.Items),
|
|
func(l, r string) bool { return l > r },
|
|
),
|
|
PaymentMethods: hc.PaymentMethods,
|
|
}
|
|
|
|
if err := renderTempl(w, http.StatusOK, view.BookingById(bvm)); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleBookingStripePaymentLink(ps *payment.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
idStr := chi.URLParam(r, "id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid booking id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
url, err := ps.CreateStripePaymentLink(r.Context(), id)
|
|
if err != nil {
|
|
switch {
|
|
case errors.Is(err, payment.ErrStripeClientNotConfigured):
|
|
http.Error(w, "stripe is not configured", http.StatusBadRequest)
|
|
case errors.Is(err, booking.ErrBookingNotFound):
|
|
http.Error(w, "booking not found", http.StatusNotFound)
|
|
case errors.Is(err, payment.ErrNoOutstandingBalance):
|
|
http.Error(w, "booking has no outstanding balance", http.StatusBadRequest)
|
|
default:
|
|
http.Error(w, fmt.Sprintf("failed to create payment link: %v", err), http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusCreated)
|
|
if err := json.NewEncoder(w).Encode(map[string]string{"url": url}); err != nil {
|
|
slog.Error("failed to write stripe payment link response", slog.Any("error", err))
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleBookingUpdate(bs *booking.Service, hc *config.Host) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if err := r.ParseForm(); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
id, err := strconv.Atoi(chi.URLParam(r, "id"))
|
|
if err != nil {
|
|
http.Error(w, "invalid booking id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
customerNumber, err := strconv.Atoi(r.FormValue("customer_number"))
|
|
if err != nil {
|
|
http.Error(w, "invalid customer number", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
platformFees := 0.0
|
|
if v := r.FormValue("platform_fees"); v != "" {
|
|
platformFees, err = strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
http.Error(w, "invalid platform fees", http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
externalID := r.FormValue("external_id")
|
|
var externalPtr *string
|
|
if externalID != "" {
|
|
externalPtr = &externalID
|
|
}
|
|
|
|
from, _ := myTime.ParseFromForm(r.FormValue("from"))
|
|
to, _ := myTime.ParseFromForm(r.FormValue("to"))
|
|
|
|
b := bs.Update(
|
|
id,
|
|
from,
|
|
to,
|
|
r.FormValue("name"),
|
|
r.FormValue("phone_number"),
|
|
r.FormValue("email"),
|
|
r.FormValue("platform"),
|
|
customerNumber,
|
|
platformFees,
|
|
externalPtr,
|
|
)
|
|
|
|
externalValue := ""
|
|
if b.ExternalID != nil {
|
|
externalValue = *b.ExternalID
|
|
}
|
|
|
|
form := view.BookingForm(view.BookingViewModel{
|
|
Id: b.InvoiceNumber(hc),
|
|
Name: b.Name,
|
|
PhoneNumber: b.PhoneNumber,
|
|
CustomerNumber: strconv.Itoa(b.CustomerNumber),
|
|
Email: b.Email,
|
|
From: b.From.Format(time.DateOnly),
|
|
To: b.To.Format(time.DateOnly),
|
|
Canceled: b.Canceled,
|
|
Platform: string(b.Platform),
|
|
ExternalId: externalValue,
|
|
Platforms: u.Map(hc.Platforms, func(p config.Platform) string { return string(p) }),
|
|
PlatformFees: strconv.FormatFloat(b.PlatformFees, 'f', 2, 64),
|
|
PaymentMethods: hc.PaymentMethods,
|
|
Url: templ.EscapeString(fmt.Sprintf("%s/%d", constant.RouteBooking, b.ID)),
|
|
PdfUrl: templ.SafeURL(fmt.Sprintf("%s/pdf/%d", constant.RouteBooking, b.ID)),
|
|
})
|
|
|
|
if err := renderTempl(w, http.StatusOK, form); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleLineItemForm(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
idStr := chi.URLParam(r, "id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid item id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
i := bs.OneItem(id)
|
|
form := view.LineItemForm(&view.ItemViewModel{
|
|
Id: strconv.Itoa(i.ID),
|
|
Item: i.Item,
|
|
Quantity: strconv.Itoa(i.Quantity),
|
|
Price: strconv.FormatFloat(i.Price, 'f', 2, 64),
|
|
PaymentStatus: i.PaymentStatus,
|
|
SubTotal: strconv.FormatFloat(i.Price*float64(i.Quantity), 'f', 2, 64),
|
|
ItemUrl: fmt.Sprintf("%s/%d", constant.RouteItem, i.ID),
|
|
})
|
|
|
|
if err := renderTempl(w, http.StatusOK, form); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleCreateItem(bs *booking.Service, hc *config.Host) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
bookingIdStr := chi.URLParam(r, "id")
|
|
bid, err := strconv.Atoi(bookingIdStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid booking id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := r.ParseForm(); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
b, err := bs.One(bid)
|
|
if bookingLookupFailed(w, err) {
|
|
return
|
|
}
|
|
|
|
itemName := r.FormValue("item")
|
|
itm, ok := hc.Items[itemName]
|
|
if !ok {
|
|
http.Error(w, fmt.Sprintf("invalid item name %q", itemName), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
quantity, err := strconv.Atoi(r.FormValue("quantity"))
|
|
if err != nil {
|
|
http.Error(w, "invalid quantity", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
price := 0.0
|
|
if v := r.FormValue("price"); v != "" {
|
|
price, err = strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
http.Error(w, "invalid price", http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
newItems := bs.CreateItem(b.ID, itm, quantity, price, r.FormValue("method"), b.CustomerNumber, string(b.Platform))
|
|
|
|
var buf bytes.Buffer
|
|
for _, i := range newItems {
|
|
component := view.LineItem(&view.ItemViewModel{
|
|
Id: strconv.Itoa(i.ID),
|
|
Item: i.Item,
|
|
Quantity: strconv.Itoa(i.Quantity),
|
|
Price: strconv.FormatFloat(i.Price, 'f', 2, 64),
|
|
PaymentStatus: i.PaymentStatus,
|
|
SubTotal: strconv.FormatFloat(i.Price*float64(i.Quantity), 'f', 2, 64),
|
|
ItemUrl: fmt.Sprintf("%s/%d", constant.RouteItem, i.ID),
|
|
})
|
|
if err := component.Render(context.Background(), &buf); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.WriteHeader(http.StatusCreated)
|
|
if _, err := buf.WriteTo(w); err != nil {
|
|
slog.Error("failed to write item response", slog.Any("error", err))
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleItemPay(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
itemIdStr := chi.URLParam(r, "id")
|
|
itemId, err := strconv.Atoi(itemIdStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid item id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
i := bs.PayItem(itemId)
|
|
if err := renderTempl(w, http.StatusOK, view.LineItem(&view.ItemViewModel{
|
|
Id: itemIdStr,
|
|
Item: i.Item,
|
|
Quantity: strconv.Itoa(i.Quantity),
|
|
Price: strconv.FormatFloat(i.Price, 'f', 2, 64),
|
|
PaymentStatus: i.PaymentStatus,
|
|
SubTotal: strconv.FormatFloat(i.Price*float64(i.Quantity), 'f', 2, 64),
|
|
ItemUrl: fmt.Sprintf("%s/%d", constant.RouteItem, i.ID),
|
|
})); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleItemUpdate(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if err := r.ParseForm(); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
id, err := strconv.Atoi(chi.URLParam(r, "id"))
|
|
if err != nil {
|
|
http.Error(w, "invalid item id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
quantity, err := strconv.Atoi(r.FormValue("quantity"))
|
|
if err != nil {
|
|
http.Error(w, "invalid quantity", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
price := 0.0
|
|
if v := r.FormValue("price"); v != "" {
|
|
price, err = strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
http.Error(w, "invalid price", http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
i := bs.UpdateItem(id, r.FormValue("item"), quantity, price, r.FormValue("paymentMethod"), r.FormValue("paymentStatus"))
|
|
|
|
if err := renderTempl(w, http.StatusCreated, view.LineItem(&view.ItemViewModel{
|
|
Id: strconv.Itoa(id),
|
|
Item: i.Item,
|
|
Quantity: strconv.Itoa(i.Quantity),
|
|
Price: strconv.FormatFloat(i.Price, 'f', 2, 64),
|
|
PaymentStatus: i.PaymentStatus,
|
|
SubTotal: strconv.FormatFloat(i.Price*float64(i.Quantity), 'f', 2, 64),
|
|
ItemUrl: fmt.Sprintf("%s/%d", constant.RouteItem, i.ID),
|
|
})); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleBookingCancel(bs *booking.Service) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
idStr := chi.URLParam(r, "id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid booking id", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
bs.Cancel(id)
|
|
|
|
component := templ.ComponentFunc(func(ctx context.Context, writer io.Writer) error {
|
|
_, err := io.WriteString(writer, " <span>Canceled</span>")
|
|
return err
|
|
})
|
|
|
|
if err := renderTempl(w, http.StatusOK, component); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
func bookingLookupFailed(w http.ResponseWriter, err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
|
|
if errors.Is(err, booking.ErrBookingNotFound) {
|
|
renderHTTPErrorPage(w, http.StatusNotFound)
|
|
return true
|
|
}
|
|
|
|
renderHTTPErrorPage(w, http.StatusInternalServerError)
|
|
return true
|
|
}
|
|
|
|
func renderHTTPErrorPage(w http.ResponseWriter, status int) {
|
|
pagePath := fmt.Sprintf("assets/html/HTTP%d.html", status)
|
|
page, err := assets.Static.ReadFile(pagePath)
|
|
if err != nil {
|
|
http.Error(w, http.StatusText(status), status)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.WriteHeader(status)
|
|
if _, err := w.Write(page); err != nil {
|
|
slog.Error("failed to write error page", slog.Any("path", pagePath), slog.Any("error", err))
|
|
}
|
|
}
|