replace

Dockerfile

@@ -19,7 +19,7 @@ COPY . .
 
 RUN go mod download && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /server
 
-RUN rm -r themes/*
+# RUN rm -r themes/*
 RUN git clone --depth 1 https://git.coopgo.io/coopgo-apps/parcoursmob-default-theme themes/default
 RUN git clone -b spie06 --depth 1 https://git.coopgo.io/coopgo-apps/parcoursmob-default-theme themes/spie06
 

go.mod

@@ -30,11 +30,11 @@ require (
 )
 
 require (
-	git.coopgo.io/coopgo-platform/agenda v0.0.0-20230310121901-ef3add576f86
+	git.coopgo.io/coopgo-platform/agenda v0.0.0-20230222135722-e55cf41e203b
 	git.coopgo.io/coopgo-platform/emailing v0.0.0-20221017030337-c71888d90c15
-	git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e
-	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c
-	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386
+	git.coopgo.io/coopgo-platform/fleets v0.0.0-20230519092636-41bf03682ca9
+	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230117140716-312200e21063
+	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20221107003506-e2ff98094b81
 	github.com/gorilla/securecookie v1.1.1
 	github.com/minio/minio-go/v7 v7.0.43
 	github.com/ory/viper v1.7.5
@@ -42,6 +42,7 @@ require (
 )
 
 require (
+	github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
@@ -54,12 +55,16 @@ require (
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.1 // indirect
+	github.com/gorilla/csrf v1.7.1 // indirect
+	github.com/gorilla/websocket v1.4.2 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.15.9 // indirect
 	github.com/klauspost/cpuid/v2 v2.1.0 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/magiconair/properties v1.8.6 // indirect
+	github.com/mattn/goveralls v0.0.6 // indirect
 	github.com/mb0/wkt v0.0.0-20170420051526-a30afd545ee1 // indirect
 	github.com/minio/md5-simd v1.1.2 // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
@@ -68,6 +73,11 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
+	github.com/ory/fosite v0.42.2 // indirect
+	github.com/ory/go-acc v0.2.6 // indirect
+	github.com/ory/go-convenience v0.1.0 // indirect
+	github.com/ory/x v0.0.214 // indirect
+	github.com/pborman/uuid v1.2.0 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
@@ -79,6 +89,7 @@ require (
 	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/spf13/afero v1.8.2 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
+	github.com/spf13/cobra v1.0.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.1 // indirect
@@ -101,6 +112,7 @@ require (
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.7.0 // indirect
 	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/tools v0.6.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd // indirect
 	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect

handlers/application/vehicles-management.go

@@ -45,7 +45,9 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 			vehicleBookings := []fleetsstorage.Booking{}
 			for _, b := range v.Bookings {
 				if b.Status() != fleetsstorage.StatusOld {
-					bookings = append(bookings, b)
+					if deleted, ok := b.Data["Deleted"].(bool); !ok && !deleted {
+						bookings = append(bookings, b)
+					}
 				}
 				if b.Unavailableto.After(time.Now()) {
 					vehicleBookings = append(vehicleBookings, b)
@@ -188,36 +190,10 @@ 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 {
@@ -467,27 +443,210 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 	http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleid), http.StatusFound)
 }
 
-// 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) 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)
+	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
+	}
+	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
+	}
+
+	if r.Method == "POST" {
+
+		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,
+			},
+		}
+
+		_, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, "/app/vehicles-management/", http.StatusFound)
+		return
+	}
+	h.Renderer.UnbookingVehicle(w, r, resp.Booking.ToStorageType())
+}
+
+////////////////////////UpdateVehicle///////////////////////
+
+func (h *ApplicationHandler) VehiclesFleetUpdate(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
+	}
+	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(),
+			},
+		}
+
+		resp, err := h.services.GRPC.Fleets.UpdateVehicle(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", resp.Vehicle.Id), http.StatusFound)
+		return
+	}
+	vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types")
+	h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType(), vehicles_types)
+}

handlers/exports/agenda.go

@@ -3,9 +3,6 @@ package exports
 import (
 	"context"
 	"fmt"
-	"net/http"
-	"sort"
-
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
@@ -13,69 +10,129 @@ import (
 	groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	accountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
+	"github.com/gorilla/mux"
 	"github.com/xuri/excelize/v2"
+	"net/http"
+	"sort"
 )
 
-func (h *ExportsHandler) Agenda(w http.ResponseWriter, r *http.Request) {
-	resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
-		Namespaces: []string{"parcoursmob_dispositifs"},
-	})
+func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *http.Request) {
+	switch filter {
+	case "allEvents":
+		return func(w http.ResponseWriter, r *http.Request) {
+			resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
+				Namespaces: []string{"parcoursmob_dispositifs"},
+			})
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
 
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
+			events := []agendastorage.Event{}
 
-	events := []agendastorage.Event{}
+			groupids := []string{}
+			beneficiaries_ids := []string{}
+			for _, e := range resp.Events {
+				groupids = append(groupids, e.Owners...)
+				events = append(events, e.ToStorageType())
 
-	groupids := []string{}
-	beneficiaries_ids := []string{}
-	for _, e := range resp.Events {
-		groupids = append(groupids, e.Owners...)
-		events = append(events, e.ToStorageType())
+				for _, subscriptions := range e.Subscriptions {
+					beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
+				}
+			}
+
+			sort.Sort(sorting.EventsByStartdate(events))
+
+			groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+				Groupids: groupids,
+			})
+			groups := map[string]groupsstorage.Group{}
+
+			if err == nil {
+				for _, g := range groupsresp.Groups {
+					groups[g.Id] = g.ToStorageType()
+				}
+			}
+
+			beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
+				Accountids: beneficiaries_ids,
+			})
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			beneficiaries_map := map[string]accountsstorage.Account{}
+			for _, ben := range beneficiaries.Accounts {
+				beneficiaries_map[ben.Id] = ben.ToStorageType()
+			}
+
+			f := h.generateExcel(events, groups, beneficiaries_map)
+
+			h.writeFileResponse(f, w)
+		}
+
+	case "oneEvent":
+		return func(w http.ResponseWriter, r *http.Request) {
+			vars := mux.Vars(r)
+			eventId := vars["eventid"]
+			resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), &agenda.GetEventRequest{
+				Id: eventId,
+			})
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+			groupids := []string{}
+			beneficiaries_ids := []string{}
+			groupids = append(groupids, resp.Event.Owners...)
+			for _, subscriptions := range resp.Event.Subscriptions {
+				beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
+			}
+			groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+				Groupids: groupids,
+			})
+			groups := map[string]groupsstorage.Group{}
+
+			if err == nil {
+				for _, g := range groupsresp.Groups {
+					groups[g.Id] = g.ToStorageType()
+				}
+			}
+
+			beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
+				Accountids: beneficiaries_ids,
+			})
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			beneficiaries_map := map[string]accountsstorage.Account{}
+			for _, ben := range beneficiaries.Accounts {
+				beneficiaries_map[ben.Id] = ben.ToStorageType()
+			}
+
+			f := h.generateExcel([]agendastorage.Event{resp.Event.ToStorageType()}, groups, beneficiaries_map)
+			h.writeFileResponse(f, w)
 
-		for _, subscriptions := range e.Subscriptions {
-			beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
 		}
 	}
+	return nil
+}
 
-	sort.Sort(sorting.EventsByStartdate(events))
-
-	groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
-		Groupids: groupids,
-	})
-	groups := map[string]groupsstorage.Group{}
-
-	if err == nil {
-		for _, g := range groupsresp.Groups {
-			groups[g.Id] = g.ToStorageType()
-		}
-	}
-
-	beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
-		Accountids: beneficiaries_ids,
-	})
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	beneficiaries_map := map[string]accountsstorage.Account{}
-	for _, ben := range beneficiaries.Accounts {
-		beneficiaries_map[ben.Id] = ben.ToStorageType()
-	}
-
-	/////////////// Generate file
-
+func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[string]groupsstorage.Group,
+	beneficiaries_map map[string]accountsstorage.Account) *excelize.File {
 	f := excelize.NewFile()
 	defer func() {
 		if err := f.Close(); err != nil {
 			fmt.Println(err)
 		}
 	}()
-
 	f.SetCellValue("Sheet1", "A1", "Evénement")
 	f.SetCellValue("Sheet1", "B1", "Date de début")
 	f.SetCellValue("Sheet1", "C1", "Date de fin")
@@ -85,8 +142,6 @@ func (h *ExportsHandler) Agenda(w http.ResponseWriter, r *http.Request) {
 	f.SetCellValue("Sheet1", "G1", "Prescipteur")
 	f.SetCellValue("Sheet1", "H1", "Prescipteur Nom")
 	f.SetCellValue("Sheet1", "I1", "Gestionnaire événement")
-	// f.SetCellValue("Sheet1", "I1", "Prescripteur téléphone")
-
 	i := 2
 	for _, e := range events {
 		if len(e.Owners) == 0 {
@@ -128,10 +183,14 @@ func (h *ExportsHandler) Agenda(w http.ResponseWriter, r *http.Request) {
 		}
 
 	}
+	return f
 
+}
+
+func (h *ExportsHandler) writeFileResponse(file *excelize.File, w http.ResponseWriter) {
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
 	w.Header().Set("Content-Transfer-Encoding", "binary")
 	w.Header().Set("Expires", "0")
-	f.Write(w)
+	file.Write(w)
 }

handlers/exports/fleets.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
 	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"
@@ -18,7 +19,6 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 
 	vehicles := map[string]fleetsstorage.Vehicle{}
 	bookings := []fleetsstorage.Booking{}
-
 	reequest := &fleets.GetVehiclesRequest{
 		Namespaces: []string{"parcoursmob"},
 	}
@@ -45,6 +45,7 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 
 	}
 
+
 	groups := map[string]groupsstorage.Group{}
 
 	admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{
@@ -106,14 +107,31 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 
 		bookedby := ""
 		if v, ok := b.Data["booked_by"].(map[string]any); ok {
-			if v2, ok := v["group"].(map[string]any); ok {
-				if v3, ok := v2["name"].(string); ok {
+			if v2, ok := v["user"].(map[string]any); ok {
+				if v3, ok := v2["display_name"].(string); ok {
 					bookedby = v3
 				}
 
 			}
 		}
 
+		bookedbygroup := ""
+		if v4, ok := b.Data["booked_by"].(map[string]any); ok {
+			if v5, ok := v4["group"].(map[string]any); ok {
+				if v6, ok := v5["id"].(string); ok {
+					bookedbygroup = v6
+				}
+			}
+		}
+
+		// filter by group
+		g := r.Context().Value(identification.GroupKey)
+		group := g.(groupsstorage.Group)
+		
+		if bookedbygroup != group.ID {
+			continue
+		}
+
 		beneficiary := beneficiaries_map[b.Driver]
 		adminunavailability := false
 

main.go

@@ -108,6 +108,9 @@ func main() {
 	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)
@@ -163,7 +166,9 @@ func main() {
 
 	export := r.PathPrefix("/exports").Subrouter()
 	export.HandleFunc("/fleets/bookings", exportsHandler.Bookings)
-	export.HandleFunc("/agenda/subscriptions", exportsHandler.Agenda)
+	export.HandleFunc("/fleets/bookings/{groupid}", exportsHandler.Bookings)
+	export.HandleFunc("/agenda/subscriptions", exportsHandler.Agenda("allEvents"))
+	export.HandleFunc("/agenda/{eventid}", exportsHandler.Agenda("oneEvent"))
 	export.Use(idp.Middleware)
 	export.Use(idp.GroupsMiddleware)
 

renderer/vehicle-management.go

@@ -53,11 +53,12 @@ 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) {
+func (renderer *Renderer) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request, vehicle any, vehicle_types []string) {
 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.fleet_update.files")
 	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
 	state.ViewState = map[string]any{
-		"vehicle": vehicle,
+		"vehicle":       vehicle,
+		"vehicle_types": vehicle_types,
 	}
 
 	renderer.Render("fleet display vehicle", w, r, files, state)
@@ -78,3 +79,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)
+
+}