parcoursmob/handlers/application/vehicles.go

package application

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

	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"github.com/google/uuid"
	"github.com/gorilla/mux"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()

	var beneficiary any

	vehicles := []any{}
	searched := false
	start := r.FormValue("startdate")
	end := r.FormValue("enddate")

	startdate, _ := time.Parse("2006-01-02", start)
	enddate, _ := time.Parse("2006-01-02", end)

	if r.FormValue("beneficiaryid") != "" {
		// Handler form
		searched = true

		requestbeneficiary := &mobilityaccounts.GetAccountRequest{
			Id: r.FormValue("beneficiaryid"),
		}

		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		beneficiary = respbeneficiary.Account.ToStorageType()

		request := &fleets.GetVehiclesRequest{
			Namespaces: []string{"parcoursmob"},
		}
		resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
		}

		for _, vehicle := range resp.Vehicles {
			v := vehicle.ToStorageType()
			if v.Free(startdate, enddate) {
				vehicles = append(vehicles, v)
			}
		}
	}

	accounts, err := h.beneficiaries(r)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	h.Renderer.VehiclesSearch(w, r, accounts, searched, vehicles, beneficiary, r.FormValue("startdate"), r.FormValue("enddate"))
}

func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {

	vars := mux.Vars(r)
	vehicleid := vars["vehicleid"]
	beneficiaryid := vars["beneficiaryid"]

	r.ParseForm()

	start := r.FormValue("startdate")
	end := r.FormValue("enddate")

	startdate, _ := time.Parse("2006-01-02", start)
	enddate, _ := time.Parse("2006-01-02", end)

	booking := &fleets.Booking{
		Id:              uuid.NewString(),
		Vehicleid:       vehicleid,
		Driver:          beneficiaryid,
		Startdate:       timestamppb.New(startdate),
		Enddate:         timestamppb.New(enddate),
		Unavailablefrom: timestamppb.New(startdate),
		Unavailableto:   timestamppb.New(enddate.Add(72 * time.Hour)),
	}

	request := &fleets.CreateBookingRequest{
		Booking: booking,
	}

	_, err := h.services.GRPC.Fleets.CreateBooking(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	http.Redirect(w, r, fmt.Sprintf("/app/vehicles/bookings/%s", booking.Id), http.StatusFound)

}

func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	bookingid := vars["bookingid"]

	request := &fleets.GetBookingRequest{
		Bookingid: bookingid,
	}
	resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	booking := resp.Booking.ToStorageType()

	beneficiaryrequest := &mobilityaccounts.GetAccountRequest{
		Id: booking.Driver,
	}

	beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), beneficiaryrequest)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	// grouprequest := &groupsmanagement.GetGroupRequest{
	// 	Id: booking.Vehicle.Administrators[0],
	// }

	// groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
	// if err != nil {
	// 	fmt.Println(err)
	// 	w.WriteHeader(http.StatusInternalServerError)
	// 	return
	// }

	h.Renderer.VehicleBookingDisplay(w, r, booking, booking.Vehicle, beneficiaryresp.Account.ToStorageType(), "")
}