edit vehicles-management handler

README.md

@@ -10,3 +10,4 @@ This new version of PARCOURSMOB brings :
 - A configurable and themeable approach of rendering web pages : the default theme is located in the folder [themes/default/](themes/default/)
 - A modular architecture based on groups and access rights, using [COOPGO Groups Management](https://git.coopgo.io/coopgo-groups-management)
 - A distributed cache system through [etcd](https://etcd.io/) to handle distributed state management like pagination in a cloud native way
+

go.mod

@@ -6,7 +6,7 @@ go 1.18
 
 // replace git.coopgo.io/coopgo-platform/groups-management => ../../coopgo-platform/groups-management/
 
-// replace git.coopgo.io/coopgo-platform/fleets => ../../coopgo-platform/fleets/
+replace git.coopgo.io/coopgo-platform/fleets => ../../coopgo-platform/fleets/
 
 // replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/
 

handlers/application/administration.go

@@ -413,6 +413,15 @@ func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Req
 			administrators = append(administrators, v.Administrators[0])
 		}
 
+		vehicleBookings := []fleetsstorage.Booking{}
+		for _, b := range v.Bookings {
+			if b.Unavailableto.After(time.Now()) {
+				vehicleBookings = append(vehicleBookings, b)
+			}
+		}
+
+		v.Bookings = vehicleBookings
+
 		vehicles = append(vehicles, v)
 
 	}

handlers/application/agenda.go

@@ -71,6 +71,41 @@ func (h *ApplicationHandler) AgendaHome(w http.ResponseWriter, r *http.Request)
 	h.Renderer.AgendaHome(w, r, responses, groups)
 }
 
+func (h *ApplicationHandler) AgendaHistory(w http.ResponseWriter, r *http.Request) {
+	resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
+		Namespaces: []string{"parcoursmob_dispositifs"},
+		//Maxdate:    timestamppb.New(time.Now().Add(24 * time.Hour)),
+	})
+
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	responses := []agendastorage.Event{}
+
+	groupids := []string{}
+	for _, e := range resp.Events {
+		groupids = append(groupids, e.Owners...)
+		responses = append(responses, e.ToStorageType())
+	}
+
+	sort.Sort(sorting.EventsByStartdate(responses))
+
+	groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+		Groupids: groupids,
+	})
+	groups := map[string]any{}
+
+	if err == nil {
+		for _, g := range groupsresp.Groups {
+			groups[g.Id] = g.ToStorageType()
+		}
+	}
+	h.Renderer.AgendaHistory(w, r, responses, groups)
+}
+
 func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		// Get current group

handlers/application/beneficiaries.go

@@ -268,7 +268,7 @@ func (h *ApplicationHandler) BeneficiaryDocuments(w http.ResponseWriter, r *http
 	beneficiaryID := vars["beneficiaryid"]
 
 	//r.ParseForm()
-	r.ParseMultipartForm(10 * 1024 * 1024)
+	r.ParseMultipartForm(100 * 1024 * 1024)
 
 	document_type := r.FormValue("type")
 	document_name := r.FormValue("name")

handlers/application/vehicles-management.go

@@ -42,16 +42,24 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 	for _, vehicle := range resp.Vehicles {
 		if filterVehicle(r, vehicle) {
 			v := vehicle.ToStorageType()
-			vehicles = append(vehicles, v)
-			vehicles_map[v.ID] = v
+			vehicleBookings := []fleetsstorage.Booking{}
 			for _, b := range v.Bookings {
 				if b.Status() != fleetsstorage.StatusOld {
+					if deleted, ok := b.Data["Deleted"].(bool); !ok && !deleted {
 						bookings = append(bookings, b)
 					}
 				}
+				if b.Unavailableto.After(time.Now()) {
+					vehicleBookings = append(vehicleBookings, b)
+				}
+			}
+			v.Bookings = vehicleBookings
+			vehicles = append(vehicles, v)
+			vehicles_map[v.ID] = v
 
 		}
 	}
+
 	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
 	sort.Sort(sorting.BookingsByStartdate(bookings))
 	h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, bookings)
@@ -182,10 +190,36 @@ func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-
+	// if len(resp.Vehicle.ToStorageType().Bookings) == 0 {
+	// 	fmt.Println("lol")
+	// }
+	// fmt.Println(resp.Vehicle.ToStorageType().Bookings)
 	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 {
@@ -295,6 +329,8 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite
 
 	alternativerequest := &fleets.GetVehiclesRequest{
 		Namespaces:       []string{"parcoursmob"},
+		Types:            []string{booking.Vehicle.Type},
+		Administrators:   booking.Vehicle.Administrators,
 		AvailabilityFrom: timestamppb.New(booking.Startdate),
 		AvailabilityTo:   timestamppb.New(booking.Enddate.Add(24 * time.Hour)),
 	}
@@ -433,75 +469,118 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 	http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleid), http.StatusFound)
 }
 
-////////////////////////UpdateVehicle///////////////////////
-
-func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request) {
+//	func (h *ApplicationHandler) UnbookingVehicles(w http.ResponseWriter, r *http.Request) {
+//		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{}
+//		fmt.Println(resp.Vehicles[0].Bookings)
+//		for i, vehicle := range resp.Vehicles {
+//			if len(resp.Vehicles[i].Bookings) == 0 {
+//				v := vehicle.ToStorageType()
+//				vehicles = append(vehicles, v)
+//			}
+//		}
+//		// if len(resp.Vehicle.ToStorageType().Bookings) == 0 {
+//		// 	h.Renderer.UnbookingVehicles(w, r, resp.Vehicle.ToStorageType())
+//		// }
+//		// fmt.Println(resp.Vehicle.ToStorageType().Bookings)
+//		fmt.Println(vehicles)
+//		h.Renderer.UnbookingVehicles(w, r, vehicles)
+//	}
+func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	vehicleID := vars["vehicleid"]
-	request := &fleets.GetVehicleRequest{
-		Vehicleid: vehicleID,
+	bookingid := vars["bookingid"]
+
+	request := &fleets.GetBookingRequest{
+		Bookingid: bookingid,
 	}
 
-	resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request)
+	resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	now := time.Now()
+	date := now.Format("2006-01-02")
+	unavailableto, _ := time.Parse("2006-01-02", date)
+
+	current_group, err := h.currentGroup(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	current_user_token, current_user_claims, err := h.currentUser(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	booked_by_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue()
+	booked_by_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue()
+	booked_by_email := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue()
+	booked_by_group_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue()
+	booked_by_group_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue()
+
+	data := map[string]any{
+		"booked_by": map[string]any{
+			"user": map[string]any{
+				"id":           booked_by_id,
+				"display_name": booked_by_name,
+				"email":        booked_by_email,
+			},
+			"group": map[string]any{
+				"id":   booked_by_group_id,
+				"name": booked_by_group_name,
+			},
+		},
+		"unbooked_by": map[string]any{
+			"user": map[string]any{
+				"id":           current_user_token.Subject,
+				"display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+				"email":        current_user_claims["email"],
+			},
+			"group": map[string]any{
+				"id":   current_group.ID,
+				"name": current_group.Data["name"],
+			},
+		},
+		"Deleted": true,
+		"motif": r.FormValue("motif"),
+	}
+
+	datapb, err := structpb.NewStruct(data)
 	if err != nil {
 		fmt.Println(err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	namespaceV := resp.Vehicle.Namespace
-	//typeV := resp.Vehicle.Type
-	administratorsV := resp.Vehicle.Administrators
 
 	if r.Method == "POST" {
-		fmt.Print(r.FormValue("vehicle_type"))
-		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
-		}
-		if v := r.FormValue("automatic"); v != "" {
-			fmt.Println(v)
-			dataMap["automatic"] = (v == "on")
-		}
 
-		data, err := structpb.NewValue(dataMap)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		request := &fleets.UpdateVehicleRequest{
-			Vehicle: &fleets.Vehicle{
-				Id:             vehicleID,
-				Namespace:      namespaceV,
-				Type:           r.FormValue("type"),
-				Administrators: administratorsV,
-				Data:           data.GetStructValue(),
+		request := &fleets.UpdateBookingRequest{
+			Booking: &fleets.Booking{
+				Id:              resp.Booking.Id,
+				Vehicleid:       resp.Booking.Vehicleid,
+				Driver:          resp.Booking.Driver,
+				Startdate:       resp.Booking.Startdate,
+				Enddate:         resp.Booking.Enddate,
+				Unavailablefrom: resp.Booking.Unavailablefrom,
+				Unavailableto:   timestamppb.New(unavailableto),
+				Data:            datapb,
 			},
 		}
 
-		resp, err := h.services.GRPC.Fleets.UpdateVehicle(context.TODO(), request)
+		_, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)
 
 		if err != nil {
 			fmt.Println(err)
@@ -509,9 +588,8 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.
 			return
 		}
 
-		http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", resp.Vehicle.Id), http.StatusFound)
+		http.Redirect(w, r, "/app/vehicles-management/", http.StatusFound)
 		return
 	}
-	vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types")
-	h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType(), vehicles_types)
+	h.Renderer.UnbookingVehicle(w, r, resp.Booking.ToStorageType())
 }

main.go

@@ -26,6 +26,7 @@ func main() {
 		address              = cfg.GetString("server.listen")
 		service_name         = cfg.GetString("service_name")
 		templates_public_dir = cfg.GetString("templates.public_dir")
+		dev_env              = cfg.GetBool("dev_env")
 	)
 
 	svc, err := services.NewServicesHandler(cfg)
@@ -55,6 +56,9 @@ func main() {
 	authHandler, _ := auth.NewAuthHandler(cfg, idp, svc, kv, emailing)
 
 	fmt.Println("Running", service_name, ":")
+	if dev_env {
+		fmt.Printf("\033]0;%s\007", service_name)
+	}
 
 	r := mux.NewRouter()
 
@@ -101,8 +105,13 @@ func main() {
 	application.HandleFunc("/vehicles-management/fleet/{vehicleid}/update", applicationHandler.VehiclesFleetUpdate)
 	application.HandleFunc("/vehicles-management/bookings/", applicationHandler.VehiclesManagementBookingsList)
 	application.HandleFunc("/vehicles-management/bookings/{bookingid}", applicationHandler.VehicleManagementBookingDisplay)
+	application.HandleFunc("/vehicles-management/bookings/{bookingid}/change-vehicle", applicationHandler.VehicleManagementBookingChangeVehicle)
+	/////////////////////////////////////Remove booking vehicle/////////////////////////////////////////
+	application.HandleFunc("/vehicles-management/bookings/{bookingid}/delete", applicationHandler.UnbookingVehicle)
+	////////////////////////////////////////////////////////////////////////////////////////////////////
 	application.HandleFunc("/vehicles-management/bookings/{bookingid}/documents/{document}", applicationHandler.BookingDocumentDownload)
 	application.HandleFunc("/agenda/", applicationHandler.AgendaHome)
+	application.HandleFunc("/agenda/history", applicationHandler.AgendaHistory)
 	application.HandleFunc("/agenda/create-event", applicationHandler.AgendaCreateEvent)
 	application.HandleFunc("/agenda/{eventid}", applicationHandler.AgendaDisplayEvent)
 	///////////////////////////////Code to modify event///////////////////////
@@ -151,6 +160,8 @@ func main() {
 	application.HandleFunc("/agenda/{eventid}/{subscribeid}/delete", applicationHandler.AgendaDeleteSubscribeEvent)
 	application.HandleFunc("/agenda/{eventid}/history", applicationHandler.AgendaHistoryEvent)
 	/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
 	fmt.Println("-> HTTP server listening on", address)
 
 	srv := &http.Server{

renderer/agenda.go

@@ -19,6 +19,17 @@ func (renderer *Renderer) AgendaHome(w http.ResponseWriter, r *http.Request, eve
 	renderer.Render("agenda home", w, r, files, state)
 }
 
+func (renderer *Renderer) AgendaHistory(w http.ResponseWriter, r *http.Request, events []agendastorage.Event, groups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.history.files")
+	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+	state.ViewState = map[string]any{
+		"events": events,
+		"groups": groups,
+	}
+
+	renderer.Render("agenda history", w, r, files, state)
+}
+
 func (renderer *Renderer) AgendaCreateEvent(w http.ResponseWriter, r *http.Request) {
 	files := renderer.ThemeConfig.GetStringSlice("views.agenda.create_event.files")
 	state := NewState(r, renderer.ThemeConfig, agendaMenu)

renderer/func-maps.go

@@ -1,9 +1,11 @@
 package renderer
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"html/template"
+	"strings"
 	"time"
 
 	"gitlab.scity.coop/maas/navitia-golang/types"
@@ -67,6 +69,22 @@ func JSON(v any) template.JS {
 	return template.JS(result)
 }
 
+func RawJSON(v any) string {
+	buf := new(bytes.Buffer)
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(false)
+	err := enc.Encode(&v)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSuffix(buf.String(), "\n")
+
+}
+
+func UnescapeHTML(s string) template.HTML {
+	return template.HTML(s)
+}
+
 func Dict(v ...interface{}) map[string]interface{} {
 	dict := map[string]interface{}{}
 	lenv := len(v)

renderer/renderer.go

@@ -55,6 +55,8 @@ func (renderer *Renderer) Render(name string, w http.ResponseWriter, r *http.Req
 			"genderISO5218": GenderISO5218,
 			"dict":          Dict,
 			"json":          JSON,
+			"rawjson":       RawJSON,
+			"unescapeHTML":  UnescapeHTML,
 			"walkingLength": WalkingLength,
 			"divideFloat64": Divide[float64],
 			"divideInt":     Divide[int],
@@ -83,6 +85,8 @@ func (renderer *Renderer) RenderNoLayout(name string, w http.ResponseWriter, r *
 			"genderISO5218": GenderISO5218,
 			"dict":          Dict,
 			"json":          JSON,
+			"rawjson":       RawJSON,
+			"unsescapeHTML": UnescapeHTML,
 			"divideFloat64": Divide[float64],
 			"divideInt":     Divide[int],
 		},
@@ -156,7 +160,6 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende
 			Active:  menuState == administrationMenu,
 		},
 
-		//TODO from configuration for icons at least
 		MenuItems: []MenuItem{
 			{
 				Title:  "Tableau de bord",
@@ -212,16 +215,6 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende
 		})
 	}
 
-	if modules["support"] != nil && modules["support"].(bool) {
-		ls.MenuItems = append(ls.MenuItems, MenuItem{
-			Title:  "Support",
-			Link:   "/app/support/",
-			Active: menuState == commentMenu,
-			Icon:   "hero:outline/support",
-		})
-
-	}
-
 	if modules["group_module"] != nil && modules["group_module"].(bool) {
 		ls.MenuItems = append(ls.MenuItems, MenuItem{
 			Title:  "Groupes / Communautés",
@@ -232,6 +225,16 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende
 
 	}
 
+	if modules["support"] != nil && modules["support"].(bool) {
+		ls.MenuItems = append(ls.MenuItems, MenuItem{
+			Title:  "Support",
+			Link:   "/app/support/",
+			Active: menuState == commentMenu,
+			Icon:   "hero:outline/support",
+		})
+
+	}
+
 	if modules["directory"] != nil && modules["directory"].(bool) {
 		ls.MenuItems = append(ls.MenuItems, MenuItem{
 			Title:  "Répertoire solutions",

renderer/vehicle-management.go

@@ -53,12 +53,11 @@ func (renderer *Renderer) VehiclesFleetDisplay(w http.ResponseWriter, r *http.Re
 	renderer.Render("fleet display vehicle", w, r, files, state)
 }
 
-func (renderer *Renderer) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request, vehicle any, vehicle_types []string) {
+func (renderer *Renderer) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request, vehicle any) {
 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.fleet_update.files")
 	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
 	state.ViewState = map[string]any{
 		"vehicle": vehicle,
-		"vehicle_types": vehicle_types,
 	}
 
 	renderer.Render("fleet display vehicle", w, r, files, state)
@@ -79,3 +78,14 @@ func (renderer *Renderer) VehicleManagementBookingDisplay(w http.ResponseWriter,
 
 	renderer.Render("vehicles search", w, r, files, state)
 }
+
+func (renderer *Renderer) UnbookingVehicle(w http.ResponseWriter, r *http.Request, booking any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.delete_booking.files")
+	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
+	state.ViewState = map[string]any{
+		"booking":              booking,
+	}
+
+	renderer.Render("vehicule unbooking", w, r, files, state)
+
+}