parcoursmob/handlers/application/vehicles-management.go

package application

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"sort"
	"time"

	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
	filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
	"git.coopgo.io/coopgo-platform/groups-management/storage"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"github.com/google/uuid"
	"github.com/gorilla/mux"
	"google.golang.org/protobuf/types/known/structpb"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r *http.Request) {
	//Get Vehicles
	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)
	}

	vehicles := []fleetsstorage.Vehicle{}
	bookings := []fleetsstorage.Booking{}
	vehicles_map := map[string]fleetsstorage.Vehicle{}

	for _, vehicle := range resp.Vehicles {
		if filterVehicle(r, vehicle) {
			v := vehicle.ToStorageType()
			vehicles = append(vehicles, v)
			vehicles_map[v.ID] = v
			for _, b := range v.Bookings {
				if b.Status() != fleetsstorage.StatusOld {
					bookings = append(bookings, b)
				}
			}

		}
	}

	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
	sort.Sort(sorting.BookingsByStartdate(bookings))

	h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, bookings)
}

func (h *ApplicationHandler) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request) {
	//Get Vehicles
	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)
	}

	bookings := []fleetsstorage.Booking{}
	vehicles_map := map[string]fleetsstorage.Vehicle{}

	for _, vehicle := range resp.Vehicles {
		if filterVehicle(r, vehicle) {
			v := vehicle.ToStorageType()
			vehicles_map[v.ID] = v
			bookings = append(bookings, v.Bookings...)
		}
	}

	sort.Sort(sorting.BookingsByStartdate(bookings))

	cacheid := uuid.NewString()
	h.cache.PutWithTTL(cacheid, bookings, 1*time.Hour)

	h.Renderer.VehiclesManagementBookingsList(w, r, vehicles_map, bookings, cacheid)
}

func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Request) {
	if r.Method == "POST" {
		g := r.Context().Value(identification.GroupKey)
		if g == nil {
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		group := g.(storage.Group)

		if err := r.ParseForm(); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		dataMap := map[string]any{}
		if v := r.FormValue("name"); v != "" {
			dataMap["name"] = v
		}
		if v := r.FormValue("address"); v != "" {
			var address map[string]any
			err := json.Unmarshal([]byte(v), &address)
			if err != nil {
				fmt.Println(err)
				w.WriteHeader(http.StatusInternalServerError)
				return
			}
			dataMap["address"] = address
		}
		if v := r.FormValue("informations"); v != "" {
			dataMap["informations"] = v
		}
		if v := r.FormValue("licence_plate"); v != "" {
			dataMap["licence_plate"] = v
		}

		data, err := structpb.NewValue(dataMap)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		vehicle := &fleets.Vehicle{
			Id:             uuid.NewString(),
			Namespace:      "parcoursmob",
			Type:           r.FormValue("type"),
			Administrators: []string{group.ID},
			Data:           data.GetStructValue(),
		}

		request := &fleets.AddVehicleRequest{
			Vehicle: vehicle,
		}

		_, err = h.services.GRPC.Fleets.AddVehicle(context.TODO(), request)

		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicle.Id), http.StatusFound)
		return
	}
	h.Renderer.VehiclesFleetAdd(w, r)
}

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

	request := &fleets.GetVehicleRequest{
		Vehicleid: vehicleid,
	}

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

	h.Renderer.VehiclesFleetDisplay(w, r, resp.Vehicle.ToStorageType())
}

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

	if r.Method == "POST" {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	request := &fleets.GetVehicleRequest{
		Vehicleid: vehicleid,
	}

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

	h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType())
}

func filterVehicle(r *http.Request, v *fleets.Vehicle) bool {
	g := r.Context().Value(identification.GroupKey)
	if g == nil {
		return false
	}

	group := g.(storage.Group)

	for _, n := range v.Administrators {
		if n == group.ID {
			return true
		}
	}

	return false
}

func (h ApplicationHandler) VehicleManagementBookingDisplay(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()

	if r.Method == "POST" {
		r.ParseForm()

		newbooking := resp.Booking

		startdate := r.FormValue("startdate")
		if startdate != "" {
			newstartdate, _ := time.Parse("2006-01-02", startdate)
			newbooking.Startdate = timestamppb.New(newstartdate)

			if newstartdate.Before(newbooking.Unavailablefrom.AsTime()) {
				newbooking.Unavailablefrom = timestamppb.New(newstartdate)
			}
		}

		enddate := r.FormValue("enddate")
		if enddate != "" {
			newenddate, _ := time.Parse("2006-01-02", enddate)
			newbooking.Enddate = timestamppb.New(newenddate)

			if newenddate.After(newbooking.Unavailableto.AsTime()) || newenddate.Equal(newbooking.Unavailableto.AsTime()) {
				newbooking.Unavailableto = timestamppb.New(newenddate.Add(24 * time.Hour))
			}
		}

		unavailablefrom := r.FormValue("unavailablefrom")
		if unavailablefrom != "" {
			newunavailablefrom, _ := time.Parse("2006-01-02", unavailablefrom)
			newbooking.Unavailablefrom = timestamppb.New(newunavailablefrom)
		}

		unavailableto := r.FormValue("unavailableto")
		if unavailableto != "" {
			newunavailableto, _ := time.Parse("2006-01-02", unavailableto)
			newbooking.Unavailableto = timestamppb.New(newunavailableto)
		}

		request := &fleets.UpdateBookingRequest{
			Booking: newbooking,
		}

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

		booking = newbooking.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
	}

	documents := h.filestorage.List(filestorage.PREFIX_BOOKINGS + "/" + bookingid)
	file_types_map := h.config.GetStringMapString("storage.files.file_types")

	h.Renderer.VehicleManagementBookingDisplay(w, r, booking, booking.Vehicle, beneficiaryresp.Account.ToStorageType(), groupresp.Group.ToStorageType(), documents, file_types_map)
}