campingmontagut/pkg/booking/admin.go

/*
 * SPDX-FileCopyrightText: 2023 jordi fita mas <jfita@peritasoft.com>
 * SPDX-License-Identifier: AGPL-3.0-only
 */

package booking

import (
	"context"
	"net/http"
	"strings"
	"time"

	"golang.org/x/text/language"

	"dev.tandem.ws/tandem/camper/pkg/auth"
	"dev.tandem.ws/tandem/camper/pkg/database"
	httplib "dev.tandem.ws/tandem/camper/pkg/http"
	"dev.tandem.ws/tandem/camper/pkg/locale"
	"dev.tandem.ws/tandem/camper/pkg/template"
)

type AdminHandler struct {
}

func NewAdminHandler() *AdminHandler {
	return &AdminHandler{}
}

func (h *AdminHandler) Handler(user *auth.User, company *auth.Company, conn *database.Conn) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var head string
		head, r.URL.Path = httplib.ShiftPath(r.URL.Path)

		switch head {
		case "":
			switch r.Method {
			case http.MethodGet:
				serveBookingIndex(w, r, user, company, conn)
			default:
				httplib.MethodNotAllowed(w, r, http.MethodGet)
			}
		case "new":
			switch r.Method {
			case http.MethodGet:
				f, err := newAdminBookingForm(r, conn, company, user.Locale)
				if err != nil {
					panic(err)
				}
				f.MustRender(w, r, user, company)
			default:
				httplib.MethodNotAllowed(w, r, http.MethodGet)
			}
		default:
			http.NotFound(w, r)
		}
	})
}

func serveBookingIndex(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
	bookings, err := collectBookingEntries(r.Context(), conn, user.Locale.Language)
	if err != nil {
		panic(err)
	}
	page := bookingIndex(bookings)
	page.MustRender(w, r, user, company)
}

func collectBookingEntries(ctx context.Context, conn *database.Conn, lang language.Tag) ([]*bookingEntry, error) {
	rows, err := conn.Query(ctx, `
		select left(slug::text, 10)
		     , '/admin/bookings/' || slug
		     , lower(stay)
		     , upper(stay)
		     , holder_name
		, booking.booking_status
		, coalesce(i18n.name, status.name)
		from booking
		    join booking_status as status using (booking_status)
			left join booking_status_i18n as i18n on status.booking_status = i18n.booking_status and i18n.lang_tag = $1
		order by stay desc
	`, lang)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var entries []*bookingEntry
	for rows.Next() {
		entry := &bookingEntry{}
		if err = rows.Scan(&entry.Reference, &entry.URL, &entry.ArrivalDate, &entry.DepartureDate, &entry.HolderName, &entry.Status, &entry.StatusLabel); err != nil {
			return nil, err
		}
		entries = append(entries, entry)
	}

	return entries, nil
}

type bookingEntry struct {
	Reference     string
	URL           string
	ArrivalDate   time.Time
	DepartureDate time.Time
	HolderName    string
	Status        string
	StatusLabel   string
}

type bookingIndex []*bookingEntry

func (page bookingIndex) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
	switch r.URL.Query().Get("format") {
	case "ods":
		columns := []string{
			"Reference",
			"Arrival Date",
			"Departure Date",
			"Holder Name",
			"Status",
		}
		ods, err := writeTableOds(page, columns, user.Locale, func(sb *strings.Builder, entry *bookingEntry) error {
			if err := writeCellString(sb, entry.Reference); err != nil {
				return err
			}
			writeCellDate(sb, entry.ArrivalDate)
			writeCellDate(sb, entry.DepartureDate)
			if err := writeCellString(sb, entry.HolderName); err != nil {
				return err
			}
			if err := writeCellString(sb, entry.StatusLabel); err != nil {
				return err
			}
			return nil
		})
		if err != nil {
			panic(err)
		}
		mustWriteOdsResponse(w, ods, user.Locale.Pgettext("bookings.ods", "filename"))
	default:
		template.MustRenderAdmin(w, r, user, company, "booking/index.gohtml", page)
	}
}

type adminBookingForm struct {
	*bookingForm
	ID        int
	Campsites []*CampsiteEntry
	Months    []*Month
}

func newAdminBookingForm(r *http.Request, conn *database.Conn, company *auth.Company, l *locale.Locale) (*adminBookingForm, error) {
	form, err := newBookingForm(r, company, conn, l)
	if err != nil {
		return nil, err
	}
	if form.Options != nil {
		for _, option := range form.Options.Options {
			option.Subtotal = findSubtotal(option.ID, form.Cart)
		}
	}
	f := &adminBookingForm{
		bookingForm: form,
	}
	// Dates and Campsite are valid
	if form.Guests != nil {
		arrivalDate, _ := time.Parse(database.ISODateFormat, form.Dates.ArrivalDate.Val)
		from := arrivalDate.AddDate(0, 0, -1)
		departureDate, _ := time.Parse(database.ISODateFormat, form.Dates.DepartureDate.Val)
		to := departureDate.AddDate(0, 0, 2)
		f.Months = CollectMonths(from, to)
		f.Campsites, err = CollectCampsiteEntries(r.Context(), company, conn, from, to, form.CampsiteType.String())
		if err != nil {
			return nil, err
		}
	}
	return f, nil
}

func findSubtotal(ID int, cart *bookingCart) string {
	none := "0.0"
	if cart == nil || cart.Draft == nil {
		return none
	}
	for _, option := range cart.Draft.Options {
		if option.ID == ID {
			return option.Subtotal
		}
	}
	return none
}

func (f *adminBookingForm) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
	if httplib.IsHTMxRequest(r) {
		template.MustRenderAdminNoLayoutFiles(w, r, user, company, f, "booking/fields.gohtml", "booking/grid.gohtml")
	} else {
		template.MustRenderAdminFiles(w, r, user, company, f, "booking/form.gohtml", "booking/fields.gohtml", "booking/grid.gohtml")
	}
}