Update package git.coopgo.io

- Added events and vehicles inside it
- Included dates, characteristics, and names of events/vehicles
- Introduced color-coded badges to indicate the status of events/vehicles (ongoing or not)

.gitea/workflows/build.yml

@@ -0,0 +1,81 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    tags:
+      - '*'
+    branches:
+      - main
+      - dev
+
+jobs:
+  build_and_push:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install Docker
+      run: |
+        apt-get update
+        apt-get install -y docker.io
+
+    - name: Checkout Repository
+      uses: actions/checkout@v4
+
+    - name: Set Kubernetes Context
+      uses: azure/k8s-set-context@v4
+      with:
+        method: kubeconfig
+        kubeconfig: ${{secrets.buildx_kubeconfig}}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        driver: kubernetes
+        driver-opts: |
+          namespace=gitea
+
+    - name: Login to Docker Registry
+      uses: docker/login-action@v3
+      with:
+        registry: git.coopgo.io
+        username: ${{ secrets.REGISTRY_USER }}
+        password: ${{ secrets.REGISTRY_TOKEN }}
+
+    - name: Extract metadata (tags, labels) for Docker image
+      id: metadata
+      uses: docker/metadata-action@v3
+      with:
+        images: git.coopgo.io/${{gitea.repository}}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=tag
+          type=ref,event=pr
+        flavor: |
+          latest=auto
+
+    - name: Build and push
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        push: true
+        tags: |
+          ${{ steps.metadata.outputs.tags }}
+        build-args: |		
+          ACCESS_TOKEN_USR=${{gitea.actor}}
+          ACCESS_TOKEN_PWD=${{gitea.token}}
+
+    # BUILD WITH KANIKO
+    # - name: Kaniko build and push
+    #   uses: aevea/action-kaniko@master
+    #   with:
+    #     build_file: Dockerfile
+    #     registry: git.coopgo.io
+    #     username: ${{secrets.registry_user}}
+    #     password: ${{secrets.registry_token}}
+    #     image: ${{gitea.repository}}
+    #     tag: ${{gitea.ref_name}}
+    #     cache: true
+    #     cache_registry: git.coopgo.io/${{gitea.repository}}/cache
+    #     extra-args: |
+    #       ACCESS_TOKEN_USR=${{gitea.actor}}
+    #       ACCESS_TOKEN_PWD=${{gitea.token}}

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/parcoursmob.iml" filepath="$PROJECT_DIR$/.idea/parcoursmob.iml" />
+    </modules>
+  </component>
+</project>

.idea/parcoursmob.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/themes" vcs="Git" />
+  </component>
+</project>

README.md

@@ -9,4 +9,6 @@ This new version of PARCOURSMOB brings :
 - A delegation on authentication and identification to an external OpenID Connect Provider like [COOPGO Mobility Accounts](https://git.coopgo.io/coopgo-platform/mobility-accounts)
 - 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
+- A distributed cache system through [etcd](https://etcd.io/) to handle distributed state management like pagination in a cloud native way
+
+

go.mod

@@ -4,11 +4,11 @@ go 1.18
 
 // replace git.coopgo.io/coopgo-platform/mobility-accounts => ../../coopgo-platform/mobility-accounts/
 
-replace git.coopgo.io/coopgo-platform/groups-management => ../../coopgo-platform/groups-management/
+// 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/agenda => ../../coopgo-platform/agenda/
+// replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/
 
 // replace git.coopgo.io/coopgo-platform/emailing => ../../coopgo-platform/emailing/
 
@@ -20,79 +20,110 @@ require (
 	github.com/gorilla/mux v1.8.0
 	github.com/gorilla/sessions v1.2.1
 	github.com/paulmach/go.geojson v1.4.0
-	github.com/spf13/viper v1.13.0
+	github.com/spf13/viper v1.15.0
 	gitlab.scity.coop/maas/navitia-golang v0.0.0-20220429110621-5c22d6efdd0c
-	go.etcd.io/etcd/client/v3 v3.5.4
+	go.etcd.io/etcd/client/v3 v3.5.6
-	golang.org/x/image v0.0.0-20220722155232-062f8c9fd539
+	golang.org/x/image v0.5.0
-	golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5
+	golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783
-	google.golang.org/grpc v1.48.0
+	google.golang.org/grpc v1.52.0
-	google.golang.org/protobuf v1.28.1
+	google.golang.org/protobuf v1.31.0
 )
 
 require (
-	git.coopgo.io/coopgo-platform/agenda v0.0.0-20221205162112-5feb1b720ef9
+	git.coopgo.io/coopgo-platform/agenda v1.0.0
 	git.coopgo.io/coopgo-platform/emailing v0.0.0-20221017030337-c71888d90c15
-	git.coopgo.io/coopgo-platform/fleets v0.0.0-20221205181518-91991789db9b
+	git.coopgo.io/coopgo-platform/fleets v1.0.0
-	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20221205161801-9705c8d898f0
+	git.coopgo.io/coopgo-platform/groups-management v1.0.0
-	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20220906130339-b9a32e41bffe
+	git.coopgo.io/coopgo-platform/mobility-accounts v1.0.5
 	github.com/gorilla/securecookie v1.1.1
 	github.com/minio/minio-go/v7 v7.0.43
+	github.com/xuri/excelize/v2 v2.7.1
 )
 
 require (
+	ariga.io/atlas v0.13.1 // indirect
+	github.com/agext/levenshtein v1.2.1 // indirect
+	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
+	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
+	github.com/dgraph-io/ristretto v0.0.3 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/fsnotify/fsnotify v1.5.4 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/go-openapi/inflect v0.19.0 // indirect
 	github.com/go-playground/locales v0.14.0 // indirect
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/golang/snappy v0.0.1 // indirect
+	github.com/google/go-cmp v0.5.9 // 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/hashicorp/hcl/v2 v2.16.2 // 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/lib/pq v1.10.9 // indirect
+	github.com/magiconair/properties v1.8.7 // 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
+	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	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/viper v1.7.5 // 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/pelletier/go-toml/v2 v2.0.6 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pquerna/cachecontrol v0.1.0 // indirect
+	github.com/richardlehane/mscfb v1.0.4 // indirect
+	github.com/richardlehane/msoleps v1.0.3 // indirect
 	github.com/rs/xid v1.4.0 // indirect
 	github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect
 	github.com/sirupsen/logrus v1.9.0 // indirect
-	github.com/spf13/afero v1.8.2 // indirect
+	github.com/spf13/afero v1.9.3 // 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
+	github.com/subosito/gotenv v1.4.2 // indirect
+	github.com/tidwall/pretty v1.1.0 // indirect
 	github.com/twpayne/go-geom v1.3.6 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.1 // indirect
 	github.com/xdg-go/stringprep v1.0.3 // indirect
+	github.com/xuri/efp v0.0.0-20220603152613-6918739fd470 // indirect
+	github.com/xuri/nfp v0.0.0-20220409054826-5e722a1d9e22 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
-	go.etcd.io/etcd/api/v3 v3.5.4 // indirect
+	github.com/zclconf/go-cty v1.12.1 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.4 // indirect
+	go.etcd.io/etcd/api/v3 v3.5.6 // indirect
-	go.mongodb.org/mongo-driver v1.10.1 // indirect
+	go.etcd.io/etcd/client/pkg/v3 v3.5.6 // indirect
-	go.uber.org/atomic v1.7.0 // indirect
+	go.mongodb.org/mongo-driver v1.11.4 // indirect
-	go.uber.org/multierr v1.6.0 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
-	go.uber.org/zap v1.17.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
-	golang.org/x/crypto v0.0.0-20221012134737-56aed061732a // indirect
+	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/net v0.0.0-20221014081412-f15817d10f9b // indirect
+	golang.org/x/crypto v0.8.0 // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/net v0.9.0 // indirect
-	golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 // indirect
+	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/text v0.3.7 // 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
+	google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef // indirect
 	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/mail.v2 v2.3.1 // indirect

handlers/api/cache.go

@@ -12,40 +12,58 @@ import (
 func (h APIHandler) GetCache(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	cacheid := vars["cacheid"]
-
+	// Use a channel to synchronize the goroutines
-	d, err := h.cache.Get(cacheid)
+	ch := make(chan []byte)
-	if err != nil {
+	// Fetch data from cache asynchronously
-		fmt.Println(err)
+	go func() {
-		w.WriteHeader(http.StatusNotFound)
+		d, err := h.cache.Get(cacheid)
-		return
+		if err != nil {
-	}
+			fmt.Println(err)
-
+			w.WriteHeader(http.StatusNotFound)
-	result := d
+			ch <- nil
-
+			return
-	if data, ok := d.([]any); ok {
-		if limitsmin, ok := r.URL.Query()["limits.min"]; ok {
-			min, _ := strconv.Atoi(limitsmin[0])
-			if limitsmax, ok := r.URL.Query()["limits.max"]; ok {
-				max, _ := strconv.Atoi(limitsmax[0])
-				if max > len(data) {
-					result = data[min:]
-				} else {
-					result = data[min:max]
-				}
-			} else {
-				result = data[min:]
-			}
 		}
+		var data []any
+		if val, ok := d.([]any); ok {
+			data = val
+		} else {
+			data = []any{d}
+		}
+		j := toJSON(data, w, r)
+		ch <- j // Signal that the data has been fetched successfully
+		close(ch)
+	}()
+	// wait for the JSON marshaling goroutine to finish
+	j := <-ch
+	if j == nil {
+		return // Stop processing if an error occurred
 	}
-
+	// Send the JSON response to the client
-	j, err := json.Marshal(result)
-	if err != nil {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-
 	w.WriteHeader(http.StatusOK)
 	w.Header().Set("Content-Type", "application/json")
 	w.Write(j)
 
+	<-ch
+}
+func toJSON(data []any, w http.ResponseWriter, r *http.Request) []byte {
+	result := data
+	if limitsmin, ok := r.URL.Query()["limits.min"]; ok {
+		min, _ := strconv.Atoi(limitsmin[0])
+		if limitsmax, ok := r.URL.Query()["limits.max"]; ok {
+			max, _ := strconv.Atoi(limitsmax[0])
+			if max > len(data) {
+				result = data[min:]
+			} else {
+				result = data[min:max]
+			}
+		} else {
+			result = data[min:]
+		}
+	}
+	j, err := json.Marshal(result)
+	if err != nil {
+		w.WriteHeader(http.StatusNotFound)
+		return nil
+	}
+	return j
 }

handlers/application/administration.go

@@ -8,12 +8,17 @@ import (
 	"io"
 	"net/http"
 	"sort"
+	"sync"
 	"time"
 
+	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
+	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
+	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
-	"git.coopgo.io/coopgo-platform/fleets/storage"
+	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"
 	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
@@ -23,49 +28,84 @@ import (
 )
 
 func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) {
-
+	var (
-	accounts, err := h.services.GetAccounts()
+		wg                                                                                               sync.WaitGroup
-	if err != nil {
+		accounts, beneficiaries                                                                          []mobilityaccountsstorage.Account
-		fmt.Println(err)
+		bookings                                                                                         []fleetsstorage.Booking
+		accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr error
+		groups                                                                                           = []groupstorage.Group{}
+		responses                                                                                        = []agendastorage.Event{}
+		groupsResponse                                                                                   *groupsmanagement.GetGroupsResponse
+		eventsResponse                                                                                   *agenda.GetEventsResponse
+		groupids                                                                                         = []string{}
+		groupsBatchResponse                                                                              *groupsmanagement.GetGroupsBatchResponse
+	)
+	// Retrieve accounts in a goroutine
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		accounts, accountsErr = h.services.GetAccounts()
+	}()
+	// Retrieve beneficiaries in a goroutine
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		beneficiaries, beneficiariesErr = h.services.GetBeneficiaries()
+	}()
+	// Retrieve bookings in a goroutine
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		bookings, bookingsErr = h.services.GetBookings()
+	}()
+	// Retrieve groupsRequest in a goroutine
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		request := &groupsmanagement.GetGroupsRequest{
+			Namespaces: []string{"parcoursmob_organizations"},
+		}
+		groupsResponse, groupsResponseErr = h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
+		for _, group := range groupsResponse.Groups {
+			g := group.ToStorageType()
+			groups = append(groups, g)
+		}
+		sort.Sort(sorting.GroupsByName(groups))
+	}()
+	// Retrieve Events in a goroutine
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		eventsResponse, eventsResponseErr = h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
+			Namespaces: []string{"parcoursmob_dispositifs"},
+		})
+		for _, e := range eventsResponse.Events {
+			groupids = append(groupids, e.Owners...)
+			responses = append(responses, e.ToStorageType())
+		}
+		sort.Sort(sorting.EventsByStartdate(responses))
+	}()
+	wg.Add(1)
+	// Retrieve groupsBatch in a goroutine
+	go func() {
+		defer wg.Done()
+		groupsBatchResponse, groupsBatchErr = h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+			Groupids: groupids,
+		})
+		groupps := map[string]any{}
+		if groupsBatchErr == nil {
+			for _, g := range groupsBatchResponse.Groups {
+				groupps[g.Id] = g.ToStorageType()
+			}
+		}
+	}()
+	wg.Wait()
+	if accountsErr != nil || beneficiariesErr != nil || bookingsErr != nil || groupsResponseErr != nil || eventsResponseErr != nil {
+		fmt.Println(accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-
+	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings, responses)
-	beneficiaries, err := h.services.GetBeneficiaries()
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	bookings, err := h.services.GetBookings()
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	request := &groupsmanagement.GetGroupsRequest{
-		Namespaces: []string{"parcoursmob_organizations"},
-	}
-
-	resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	var groups = []groupstorage.Group{}
-
-	for _, group := range resp.Groups {
-		g := group.ToStorageType()
-		groups = append(groups, g)
-	}
-
-	sort.Sort(sorting.GroupsByName(groups))
-
-	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings)
 }
 
 func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r *http.Request) {
@@ -120,22 +160,23 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r
 				Namespace: "parcoursmob_roles",
 			},
 		}
-
+		go func() {
-		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
+			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
-		if err != nil {
+			if err != nil {
-			fmt.Println(err)
+				fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
+				w.WriteHeader(http.StatusInternalServerError)
-			return
+				return
-		}
+			}
-
+		}()
 		// Create the admin role for the organization
-		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
+		go func() {
-		if err != nil {
+			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
-			fmt.Println(err)
+			if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
+				fmt.Println(err)
-			return
+				w.WriteHeader(http.StatusInternalServerError)
-		}
+				return
-
+			}
+		}()
 		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
 		return
 	}
@@ -170,192 +211,311 @@ func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r
 func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	groupid := vars["groupid"]
+	var (
+		groupresp   *groupsmanagement.GetGroupResponse
+		accountresp *accounts.GetAccountUsernameResponse
+		err         error
+	)
+	go func() {
+		groupresp, err = h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+			Id:        groupid,
+			Namespace: "parcoursmob_organizations",
+		})
 
-	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+		if err != nil {
-		Id:        groupid,
+			fmt.Println(err)
-		Namespace: "parcoursmob_organizations",
+			w.WriteHeader(http.StatusInternalServerError)
-	})
+			return
-
+		}
-	if err != nil {
+	}()
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
 	r.ParseForm()
 
-	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
+	go func() {
-		Username:  r.FormValue("username"),
+		accountresp, err = h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
-		Namespace: "parcoursmob",
+			Username:  r.FormValue("username"),
-	})
+			Namespace: "parcoursmob",
+		})
+		if err == nil {
+			// Account already exists : adding the existing account to admin list
+			account := accountresp.Account.ToStorageType()
+			account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid)
+			account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid+":admin")
 
-	if err == nil {
+			as, _ := accounts.AccountFromStorageType(&account)
-		// Account already exists : adding the existing account to admin list
-		account := accountresp.Account.ToStorageType()
-		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid)
-		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid+":admin")
 
-		as, _ := accounts.AccountFromStorageType(&account)
+			_, err = h.services.GRPC.MobilityAccounts.UpdateData(
+				context.TODO(),
+				&accounts.UpdateDataRequest{
+					Account: as,
+				},
+			)
 
-		_, err = h.services.GRPC.MobilityAccounts.UpdateData(
-			context.TODO(),
-			&accounts.UpdateDataRequest{
-				Account: as,
-			},
-		)
-
-		fmt.Println(err)
-
-		data := map[string]any{
-			"group": groupresp.Group.ToStorageType().Data["name"],
-		}
-
-		if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil {
 			fmt.Println(err)
+
+			data := map[string]any{
+				"group": groupresp.Group.ToStorageType().Data["name"],
+			}
+
+			if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil {
+				fmt.Println(err)
+			}
+
+			http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
+			return
+		} else {
+			// Onboard now administrator
+			onboarding := map[string]any{
+				"username": r.FormValue("username"),
+				"group":    groupid,
+				"admin":    true,
+			}
+
+			b := make([]byte, 16)
+			if _, err := io.ReadFull(rand.Reader, b); err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+			key := base64.RawURLEncoding.EncodeToString(b)
+
+			h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL
+
+			data := map[string]any{
+				"group": groupresp.Group.ToStorageType().Data["name"],
+				"key":   key,
+			}
+
+			if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
 		}
 
 		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
 		return
-	} else {
+	}()
-		// Onboard now administrator
-		onboarding := map[string]any{
-			"username": r.FormValue("username"),
-			"group":    groupid,
-			"admin":    true,
-		}
-
-		b := make([]byte, 16)
-		if _, err := io.ReadFull(rand.Reader, b); err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		key := base64.RawURLEncoding.EncodeToString(b)
-
-		h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL
-
-		data := map[string]any{
-			"group": groupresp.Group.ToStorageType().Data["name"],
-			"key":   key,
-		}
-
-		if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
-	return
 }
-
 func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	groupid := vars["groupid"]
+	var (
+		group storage.Group
+	)
+	groupCh := make(chan storage.Group)
+	go func() {
+		groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+			Id:        groupid,
+			Namespace: "parcoursmob_organizations",
+		})
 
-	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+		if err != nil {
-		Id:        groupid,
+			fmt.Println(err)
-		Namespace: "parcoursmob_organizations",
+			w.WriteHeader(http.StatusInternalServerError)
-	})
+			return
+		}
+		group := groupresp.Group.ToStorageType()
+		groupCh <- group
+	}()
+	r.ParseForm()
+	go func() {
+		group = <-groupCh
+		accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
+			Username:  r.FormValue("username"),
+			Namespace: "parcoursmob",
+		})
+		if err == nil {
+			account := accountresp.Account.ToStorageType()
+			account.Data["groups"] = append(account.Data["groups"].([]any), group.ID)
 
+			as, _ := accounts.AccountFromStorageType(&account)
+
+			_, err = h.services.GRPC.MobilityAccounts.UpdateData(
+				context.TODO(),
+				&accounts.UpdateDataRequest{
+					Account: as,
+				},
+			)
+			data := map[string]any{
+				"group": group.Data["name"],
+			}
+
+			if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil {
+			}
+
+			http.Redirect(w, r, "/app/group/settings", http.StatusFound)
+			return
+		} else {
+			// Onboard now administrator
+			onboarding := map[string]any{
+				"username": r.FormValue("username"),
+				"group":    group.ID,
+				"admin":    false,
+			}
+
+			b := make([]byte, 16)
+			if _, err := io.ReadFull(rand.Reader, b); err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+			key := base64.RawURLEncoding.EncodeToString(b)
+
+			h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL
+			data := map[string]any{
+				"group": group.Data["name"],
+				"key":   key,
+			}
+
+			if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+		}
+	}()
+	http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound)
+	return
+}
+
+func filteVehicle(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) AdminStatVehicles(w http.ResponseWriter, r *http.Request) {
+
+	bookings := []fleetsstorage.Booking{}
+	administrators := []string{}
+	reequest := &fleets.GetVehiclesRequest{
+		Namespaces: []string{"parcoursmob"},
+	}
+	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+	}
+
+	vehicles := []fleetsstorage.Vehicle{}
+	for _, vehiicle := range reesp.Vehicles {
+
+		v := vehiicle.ToStorageType()
+		adminfound := false
+		for _, a := range administrators {
+			if a == v.Administrators[0] {
+				adminfound = true
+				break
+			}
+		}
+		if !adminfound {
+			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)
+
+	}
+	groups := map[string]any{}
+
+	if len(administrators) > 0 {
+		admingroups, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+			Groupids: administrators,
+		})
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		for _, g := range admingroups.Groups {
+			groups[g.Id] = g.ToStorageType()
+		}
+
+	}
+	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
+	sort.Sort(sorting.BookingsByStartdate(bookings))
+	h.Renderer.AdminStatVehicles(w, r, vehicles, bookings, groups)
+}
+
+func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Request) {
+
+	vehicles := map[string]fleetsstorage.Vehicle{}
+	bookings := []fleetsstorage.Booking{}
+
+	reequest := &fleets.GetVehiclesRequest{
+		Namespaces: []string{"parcoursmob"},
+	}
+	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
 	if err != nil {
 		fmt.Println(err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	group := groupresp.Group.ToStorageType()
+	beneficiaries_ids := []string{}
 
-	r.ParseForm()
+	for _, vehicle := range reesp.Vehicles {
 
-	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
+		v := vehicle.ToStorageType()
-		Username:  r.FormValue("username"),
-		Namespace: "parcoursmob",
-	})
 
-	if err == nil {
+		for _, b := range v.Bookings {
-		account := accountresp.Account.ToStorageType()
+			bookings = append(bookings, b)
-		account.Data["groups"] = append(account.Data["groups"].([]any), group.ID)
+			beneficiaries_ids = append(beneficiaries_ids, b.Driver)
-
-		as, _ := accounts.AccountFromStorageType(&account)
-
-		_, err = h.services.GRPC.MobilityAccounts.UpdateData(
-			context.TODO(),
-			&accounts.UpdateDataRequest{
-				Account: as,
-			},
-		)
-
-		fmt.Println(err)
-
-		data := map[string]any{
-			"group": group.Data["name"],
 		}
 
-		if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil {
+		vehicles[v.ID] = v
-			fmt.Println(err)
-		}
 
-		http.Redirect(w, r, "/app/group/settings", http.StatusFound)
-		return
-	} else {
-		// Onboard now administrator
-		onboarding := map[string]any{
-			"username": r.FormValue("username"),
-			"group":    group.ID,
-			"admin":    false,
-		}
-
-		b := make([]byte, 16)
-		if _, err := io.ReadFull(rand.Reader, b); err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		key := base64.RawURLEncoding.EncodeToString(b)
-
-		h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL
-
-		data := map[string]any{
-			"group": group.Data["name"],
-			"key":   key,
-		}
-
-		if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
 	}
 
-	http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound)
+	groups := map[string]any{}
-	return
-}
 
-func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Request) {
+	admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{
-
+		Namespaces: []string{"parcoursmob_organizations"},
-	request := &fleets.GetBookingsRequest{}
+	})
-	resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request)
 	if err != nil {
 		fmt.Println(err)
-		w.WriteHeader(http.StatusNotFound)
+		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	bookings := []storage.Booking{}
+	for _, g := range admingroups.Groups {
+		groups[g.Id] = g.ToStorageType()
+	}
 
-	for _, b := range resp.Bookings {
+	beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
-		booking := b.ToStorageType()
+		Accountids: beneficiaries_ids,
-		bookings = append(bookings, booking)
+	})
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	beneficiaries_map := map[string]any{}
+	for _, ben := range beneficiaries.Accounts {
+		beneficiaries_map[ben.Id] = ben.ToStorageType()
 	}
 
 	sort.Sort(sorting.BookingsByStartdate(bookings))
-
+	h.Renderer.AdminStatBookings(w, r, vehicles, bookings, groups, beneficiaries_map)
-	vehicles, _ := h.services.GetVehiclesMap()
-	groups, _ := h.services.GetGroupsMap()
-
-	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
 }
 
 func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
@@ -395,3 +555,49 @@ func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobili
 
 	return groupmembers, admins, err
 }
+
+func (h ApplicationHandler) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request) {
+	beneficiaries, err := h.services.GetBeneficiaries()
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	cacheid := uuid.NewString()
+	h.cache.PutWithTTL(cacheid, beneficiaries, 1*time.Hour)
+	h.Renderer.AdminStatBeneficaires(w, r, beneficiaries, cacheid)
+}
+
+func (h ApplicationHandler) AdminStatEvents(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
+	}
+
+	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.AdminStatEvents(w, r, responses, groups)
+}

handlers/application/agenda.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"sort"
 	"strconv"
@@ -13,11 +14,13 @@ import (
 	formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators"
 	"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"
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/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"
@@ -68,10 +71,44 @@ func (h *ApplicationHandler) AgendaHome(w http.ResponseWriter, r *http.Request)
 			groups[g.Id] = g.ToStorageType()
 		}
 	}
-
 	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
@@ -113,17 +150,52 @@ func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Re
 		}
 
 		resp, err := h.services.GRPC.Agenda.CreateEvent(context.TODO(), request)
-
 		if err != nil {
 			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 
+		contentType := r.Header.Get("Content-Type")
+		if strings.HasPrefix(contentType, "multipart/form-data") {
+			err = r.ParseMultipartForm(100 * 1024 * 1024) // 100 MB limit
+			if err != nil {
+				fmt.Println("Error parsing multipart form:", err)
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+
+			file, header, err := r.FormFile("file-upload")
+			if err == nil {
+				defer file.Close()
+
+				document_type := r.FormValue("file_type")
+				document_name := r.FormValue("file_name")
+				
+				fileid := uuid.NewString()
+
+				metadata := map[string]string{
+					"file_type": document_type,
+					"file_name": document_name,
+				}
+
+				if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", resp.Event.Id, fileid, header.Filename), header.Size, metadata); err != nil {
+					fmt.Println("Error uploading file:", err)
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+			} else if err != http.ErrMissingFile {
+				fmt.Println("Error retrieving file:", err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+		}
+
 		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", resp.Event.Id), http.StatusFound)
 		return
 	}
-	h.Renderer.AgendaCreateEvent(w, r)
+
+	h.Renderer.AgendaCreateEvent(w, r, h.config.GetStringSlice("modules.agenda.documents_types"), h.config.GetStringMapString("storage.files.file_types"), nil)
 }
 
 func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.Request) {
@@ -203,7 +275,13 @@ func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.R
 		}
 	}
 
-	h.Renderer.AgendaDisplayEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), subscribers, accounts)
+
+	documents := h.filestorage.List(filestorage.PREFIX_AGENDA + "/" + eventid)
+
+	events_file_types := h.config.GetStringSlice("modules.agenda.documents_types")
+	file_types_map := h.config.GetStringMapString("storage.files.file_types")
+
+	h.Renderer.AgendaDisplayEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), events_file_types, file_types_map, documents, subscribers, accounts)
 }
 
 func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http.Request) {
@@ -541,10 +619,10 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r
 		}
 
 		data := map[string]any{
-			"motif":  r.FormValue("motif"),
+			"motif":      r.FormValue("motif"),
-			"user": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+			"user":       current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
 			"subscriber": fmt.Sprintf("http://localhost:9000/app/beneficiaries/%s", subscribeid),
-			"link": fmt.Sprintf("http://localhost:9000/app/agenda/%s", eventId),
+			"link":       fmt.Sprintf("http://localhost:9000/app/agenda/%s", eventId),
 		}
 
 		// récupérer l'adresse mail de l'utilisateur qui a créé l'événement
@@ -651,3 +729,61 @@ func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.R
 
 	h.Renderer.AgendaHistoryEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), subscribers, accounts)
 }
+////// ADD DOCUMENTS //////
+func (h *ApplicationHandler) EventDocuments(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	eventID := vars["eventid"]
+
+	//r.ParseForm()
+	r.ParseMultipartForm(100 * 1024 * 1024)
+
+	document_type := r.FormValue("type")
+	document_name := r.FormValue("name")
+
+	file, header, err := r.FormFile("file-upload")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	defer file.Close()
+
+	fileid := uuid.NewString()
+
+	metadata := map[string]string{
+		"type": document_type,
+		"name": document_name,
+	}
+
+	if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", eventID, fileid, header.Filename), header.Size, metadata); err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound)
+
+}
+
+
+func (h *ApplicationHandler) EventDocumentDownload(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	eventID := vars["eventid"]
+	document := vars["document"]
+
+	file, info, err := h.filestorage.Get(filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s", eventID, document))
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", info.ContentType)
+	if _, err = io.Copy(w, file); err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound)
+
+}

handlers/application/beneficiaries.go

@@ -20,7 +20,10 @@ import (
 	profilepictures "git.coopgo.io/coopgo-apps/parcoursmob/utils/profile-pictures"
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
+	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
+	agendastorage "git.coopgo.io/coopgo-platform/agenda/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"
@@ -41,6 +44,67 @@ type BeneficiariesForm struct {
 	Gender      string     `json:"gender"`
 }
 
+type Event_Beneficiary interface {
+	Name() string
+	Date() time.Time
+	DateEnd() time.Time
+	Type() string
+	Db() string
+	ID() string
+	Icons() string
+	Status() int
+}
+
+type Event struct {
+	IDVal      string
+	NameVal    string
+	DateVal    time.Time
+	DateEndVal time.Time
+	TypeVal    string
+	DbVal      string
+	Deleted    bool
+	IconSet    string
+	StatusVal  int
+}
+
+func (e Event) Name() string {
+	return e.NameVal
+}
+
+func (e Event) Date() time.Time {
+	return e.DateVal
+}
+
+func (e Event) DateEnd() time.Time {
+	return e.DateEndVal
+}
+
+func (e Event) Type() string {
+	return e.TypeVal
+}
+
+func (e Event) ID() string {
+	return e.IDVal
+}
+
+func (e Event) Db() string {
+	return e.DbVal
+}
+
+func (e Event) Icons() string {
+	return e.IconSet
+}
+
+func (e Event) Status() int {
+	return e.StatusVal
+}
+
+func sortByDate(events []Event_Beneficiary) {
+	sort.Slice(events, func(i, j int) bool {
+		return events[i].Date().After(events[j].Date())
+	})
+}
+
 func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Request) {
 
 	accounts, err := h.beneficiaries(r)
@@ -54,7 +118,6 @@ func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Re
 
 	cacheid := uuid.NewString()
 	h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
-
 	h.Renderer.BeneficiariesList(w, r, accounts, cacheid)
 }
 
@@ -136,6 +199,35 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R
 		return
 	}
 
+	subscriptionrequest := &agenda.GetSubscriptionByUserRequest{
+		Subscriber: beneficiaryID,
+	}
+
+	subcriptionresp, err := h.services.GRPC.Agenda.GetSubscriptionByUser(context.TODO(), subscriptionrequest)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	events := []agendastorage.Event{}
+	currentTime := time.Now().Truncate(24 * time.Hour)
+
+	for _, e := range subcriptionresp.Subscription {
+		eventresquest := &agenda.GetEventRequest{
+			Id: e.Eventid,
+		}
+		eventresp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), eventresquest)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		events = append(events, eventresp.Event.ToStorageType())
+	}
+
+	sort.Sort(sorting.EventsByStartdate(events))
+
 	bookingsrequest := &fleets.GetDriverBookingsRequest{
 		Driver: beneficiaryID,
 	}
@@ -146,12 +238,78 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R
 		return
 	}
 
-	bookings := []any{}
+	bookings := []fleetsstorage.Booking{}
 
 	for _, b := range bookingsresp.Bookings {
 		bookings = append(bookings, b.ToStorageType())
 	}
 
+	var events_list []Event_Beneficiary
+	var status_event int
+
+	for _, e := range events {
+
+		if e.Startdate.After(currentTime) {
+			status_event = 1
+		} else if e.Startdate.Before(currentTime) && e.Enddate.After(currentTime) || e.Enddate.Equal(currentTime) {
+			status_event = 2
+		} else {
+			status_event = 3
+		}
+
+		event := Event{
+			NameVal:    e.Name,
+			DateVal:    e.Startdate,
+			DateEndVal: e.Enddate,
+			TypeVal:    e.Type,
+			IDVal:      e.ID,
+			DbVal:      "/app/agenda/",
+			IconSet:    "calendar",
+			StatusVal:  status_event,
+		}
+
+		events_list = append(events_list, event)
+	}
+
+	var status_booking int
+	for _, b := range bookings {
+
+		if b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) {
+			GetVehiculeRequest := &fleets.GetVehicleRequest{
+				Vehicleid: b.Vehicleid,
+			}
+
+			GetVehiculeResp, err := h.services.GRPC.Fleets.GetVehicle(context.Background(), GetVehiculeRequest)
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			if b.Startdate.After(currentTime) {
+				status_booking = 1
+			} else if b.Startdate.Before(currentTime) && b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) {
+				status_booking = 2
+			} else {
+				status_booking = 3
+			}
+
+			event := Event{
+				NameVal:    GetVehiculeResp.Vehicle.ToStorageType().Data["name"].(string),
+				DateVal:    b.Startdate,
+				DateEndVal: b.Enddate,
+				TypeVal:    "Réservation de véhicule",
+				IDVal:      b.ID,
+				DbVal:      "/app/vehicles-management/bookings/",
+				IconSet:    "vehicle",
+				StatusVal:  status_booking,
+			}
+
+			events_list = append(events_list, event)
+		}
+	}
+	sortByDate(events_list)
+
 	groupsrequest := &groupsmanagement.GetGroupsRequest{
 		Namespaces: []string{"parcoursmob_organizations"},
 		Member:     beneficiaryID,
@@ -170,7 +328,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R
 	beneficiaries_file_types := h.config.GetStringSlice("modules.beneficiaries.documents_types")
 	file_types_map := h.config.GetStringMapString("storage.files.file_types")
 
-	h.Renderer.BeneficiaryDisplay(w, r, resp.Account.ToStorageType(), bookings, organizations, beneficiaries_file_types, file_types_map, documents)
+	h.Renderer.BeneficiaryDisplay(w, r, resp.Account.ToStorageType(), bookings, organizations, beneficiaries_file_types, file_types_map, documents, events_list)
 }
 
 func (h *ApplicationHandler) BeneficiaryUpdate(w http.ResponseWriter, r *http.Request) {
@@ -269,7 +427,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")
@@ -288,6 +446,8 @@ func (h *ApplicationHandler) BeneficiaryDocuments(w http.ResponseWriter, r *http
 		"name": document_name,
 	}
 
+	fmt.Println("metadata", metadata)
+
 	if err := h.filestorage.Put(file, filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s_%s", beneficiaryID, fileid, header.Filename), header.Size, metadata); err != nil {
 		fmt.Println(err)
 		w.WriteHeader(http.StatusInternalServerError)
@@ -334,6 +494,8 @@ func filterAccount(r *http.Request, a *mobilityaccounts.Account) bool {
 	return true
 }
 
+// func BeneficiariesEventList()
+
 func (h *ApplicationHandler) beneficiaries(r *http.Request) ([]mobilityaccountsstorage.Account, error) {
 	var accounts = []mobilityaccountsstorage.Account{}
 	g := r.Context().Value(identification.GroupKey)

handlers/application/dashboard.go

@@ -13,6 +13,8 @@ import (
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	"google.golang.org/protobuf/types/known/timestamppb"
+	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
+	fleetstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 )
 
 func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
@@ -68,12 +70,26 @@ func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
 		Mindate:    timestamppb.Now(),
 	})
 
-	for _, e := range eventsresp.Events {
+	if err == nil {
-		events = append(events, e.ToStorageType())
+		for _, e := range eventsresp.Events {
+			events = append(events, e.ToStorageType())
+		}
 	}
 
 	sort.Sort(sorting.EventsByStartdate(events))
 
-	h.Renderer.Dashboard(w, r, accounts, count, count_members, events)
+	bookings := []fleetstorage.Booking{}
+
+	bookingsresp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), &fleets.GetBookingsRequest{
+		Namespaces: []string{"parcoursmob_dispositifs"},
+	})
+
+	if err == nil {
+		for _, b := range bookingsresp.Bookings {
+			bookings = append(bookings, b.ToStorageType())
+		}
+	}
+
+	h.Renderer.Dashboard(w, r, accounts, count, count_members, events, bookings)
 
 }

handlers/application/journeys.go

@@ -27,7 +27,14 @@ var Arrive any
 
 func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
-
+	var (
+		journeys_results *navitia.JourneyResults
+		carpool_results  any
+		vehicle_results  []any
+	)
+	vehiclech := make(chan []any, 1)
+	navitiaCh := make(chan *navitia.JourneyResults, 1)
+	carpoolCh := make(chan any, 1)
 	locTime, errTime := time.LoadLocation("Europe/Paris")
 	if errTime != nil {
 		fmt.Println("Loading timezone location Europe/Paris error : ")
@@ -70,91 +77,101 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+		journeysRequest := func() {
+			//TODO make it a library
+			session, _ := navitia.NewCustom(
+				h.config.GetString("services.navitia.api_key"),
+				"https://api.navitia.io/v1",
+				&http.Client{})
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusBadRequest)
+				navitiaCh <- nil
+				return
+			}
+
+			request := navitia.JourneyRequest{
+				From:          types.ID(fmt.Sprintf("%f", departuregeo.Geometry.Point[0]) + ";" + fmt.Sprintf("%f", departuregeo.Geometry.Point[1])),
+				To:            types.ID(fmt.Sprintf("%f", destinationgeo.Geometry.Point[0]) + ";" + fmt.Sprintf("%f", destinationgeo.Geometry.Point[1])),
+				Date:          departuredatetime.Add(-2 * time.Hour),
+				DateIsArrival: false, //TODO
+			}
+
+			journeys, err = session.Journeys(context.Background(), request)
+			if err != nil {
+				fmt.Println(err)
+				// w.WriteHeader(http.StatusBadRequest)
+				// return
+			}
+			navitiaCh <- journeys
 
-		//TODO make it a library
-		session, _ := navitia.NewCustom(
-			h.config.GetString("services.navitia.api_key"),
-			"https://api.navitia.io/v1",
-			&http.Client{})
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusBadRequest)
-			return
 		}
-
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-		request := navitia.JourneyRequest{
-			From:          types.ID(fmt.Sprintf("%f", departuregeo.Geometry.Point[0]) + ";" + fmt.Sprintf("%f", departuregeo.Geometry.Point[1])),
-			To:            types.ID(fmt.Sprintf("%f", destinationgeo.Geometry.Point[0]) + ";" + fmt.Sprintf("%f", destinationgeo.Geometry.Point[1])),
-			Date:          departuredatetime.Add(-2 * time.Hour),
-			DateIsArrival: false, //TODO
-		}
-
-		journeys, err = session.Journeys(context.Background(), request)
-		if err != nil {
-			fmt.Println(err)
-			// w.WriteHeader(http.StatusBadRequest)
-			// return
-		}
-
 		//CARPOOL
-		// carpoolrequest := fmt.Sprintf(
+		carpoolRequest := func() {
-		// 	"https://api.rdex.ridygo.fr/journeys.json?p[driver][state]=1&frequency=punctual&p[passenger][state]=0&p[from][latitude]=%f&p[from][longitude]=%f&p[to][latitude]=%f&p[to][longitude]=%f&p[outward][mindate]=%s&p[outward][maxdate]=%s",
+			carpoolrequest := "https://api.rdex.ridygo.fr/journeys.json"
-		// 	departuregeo.Geometry.Point[1], departuregeo.Geometry.Point[0],
-		// 	destinationgeo.Geometry.Point[1], destinationgeo.Geometry.Point[0],
-		// 	departuredatetime.Format("2006-01-02"), departuredatetime.Add(24*time.Hour).Format("2006-01-02"))
-		carpoolrequest := "https://api.rdex.ridygo.fr/journeys.json"
 
-		client := &http.Client{}
+			client := &http.Client{}
-		req, err := http.NewRequest("GET", carpoolrequest, nil)
+			req, err := http.NewRequest("GET", carpoolrequest, nil)
-		if err != nil {
-			fmt.Println(err)
-		}
-
-		req.URL.RawQuery = fmt.Sprintf(
-			"p[driver][state]=1&frequency=punctual&p[passenger][state]=0&p[from][latitude]=%f&p[from][longitude]=%f&p[to][latitude]=%f&p[to][longitude]=%f&p[outward][mindate]=%s&p[outward][maxdate]=%s",
-			departuregeo.Geometry.Point[1], departuregeo.Geometry.Point[0],
-			destinationgeo.Geometry.Point[1], destinationgeo.Geometry.Point[0],
-			departuredatetime.Format("2006-01-02"), departuredatetime.Format("2006-01-02"))
-
-		req.Header.Set("X-API-KEY", "123456")
-		resp, err := client.Do(req)
-		if err != nil {
-			fmt.Println(err)
-		}
-
-		if err == nil && resp.StatusCode == http.StatusOK {
-			err = json.NewDecoder(resp.Body).Decode(&carpoolresults)
 			if err != nil {
 				fmt.Println(err)
 			}
 
-			if carpoolresults == nil {
+			req.URL.RawQuery = fmt.Sprintf(
+				"p[driver][state]=1&frequency=punctual&p[passenger][state]=0&p[from][latitude]=%f&p[from][longitude]=%f&p[to][latitude]=%f&p[to][longitude]=%f&p[outward][mindate]=%s&p[outward][maxdate]=%s",
+				departuregeo.Geometry.Point[1], departuregeo.Geometry.Point[0],
+				destinationgeo.Geometry.Point[1], destinationgeo.Geometry.Point[0],
+				departuredatetime.Format("2006-01-02"), departuredatetime.Format("2006-01-02"))
+
+			req.Header.Set("X-API-KEY", "123456")
+			resp, err := client.Do(req)
+			if err != nil {
+				fmt.Println(err)
+			}
+
+			if err == nil && resp.StatusCode == http.StatusOK {
+				err = json.NewDecoder(resp.Body).Decode(&carpoolresults)
+				if err != nil {
+					fmt.Println(err)
+				}
+
+				if carpoolresults == nil {
+					carpoolresults = []any{}
+				}
+			} else {
 				carpoolresults = []any{}
 			}
-		} else {
+			carpoolCh <- carpoolresults
-			carpoolresults = []any{}
 		}
-
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		// Vehicles
-
+		vehicleRequest := func() {
-		vehiclerequest := &fleets.GetVehiclesRequest{
+			vehiclerequest := &fleets.GetVehiclesRequest{
-			Namespaces: []string{"parcoursmob"},
+				Namespaces: []string{"parcoursmob"},
-		}
-		vehicleresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), vehiclerequest)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-		}
-
-		for _, vehicle := range vehicleresp.Vehicles {
-			v := vehicle.ToStorageType()
-			if v.Free(departuredatetime.Add(-24*time.Hour), departuredatetime.Add(168*time.Hour)) {
-				vehicles = append(vehicles, v)
 			}
+			vehicleresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), vehiclerequest)
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+			}
+			for _, vehicle := range vehicleresp.Vehicles {
+				v := vehicle.ToStorageType()
+				if v.Free(departuredatetime.Add(-24*time.Hour), departuredatetime.Add(168*time.Hour)) {
+					vehicles = append(vehicles, v)
+				}
+			}
+			vehiclech <- vehicles
 		}
+		go journeysRequest()
+		go carpoolRequest()
+		go vehicleRequest()
+		carpool_results = <-carpoolCh
+		journeys_results = <-navitiaCh
+		vehicle_results = <-vehiclech
 	}
 
-	h.Renderer.JourneysSearch(w, r, carpoolresults, journeys, vehicles, searched, departuregeo, destinationgeo, departuredate, departuretime)
+	h.Renderer.JourneysSearch(w, r, carpool_results, journeys_results, vehicle_results, searched, departuregeo, destinationgeo, departuredate, departuretime)
 }
 
 type GroupsModule []groupstorage.Group

handlers/application/members.go

@@ -6,9 +6,12 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
+	"time"
 
 	formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators"
+	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
+	"github.com/google/uuid"
 	"google.golang.org/protobuf/types/known/structpb"
 )
 
@@ -36,8 +39,34 @@ func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Reques
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
+	//////////////////////////////////add organisations/////////////////////////////////////////////////
 
-	h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType())
+	var allIds []string
+	for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) {
+		s := fmt.Sprintf("%v", v)
+		if !(strings.Contains(s, "admin")) {
+			allIds = append(allIds, s)
+		}
+	}
+	reques := &groupsmanagement.GetGroupsBatchRequest{
+		Groupids: allIds,
+	}
+
+	res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	var groupsName []string
+
+	for _, group := range res.Groups {
+		g := fmt.Sprintf("%v", group.ToStorageType().Data["name"])
+		groupsName = append(groupsName, g)
+	}
+
+	h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType(), groupsName)
 }
 
 func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request) {
@@ -126,3 +155,59 @@ func parseUserForm(r *http.Request) (map[string]any, error) {
 
 	return dataMap, nil
 }
+
+func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request) {
+
+	accounts, err := h.services.GetAccounts()
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	var groupsName []string
+
+	for _, v := range accounts {
+		adminid := v.ID
+		request := &mobilityaccounts.GetAccountRequest{
+			Id: adminid,
+		}
+
+		resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		//////////////////////////////////add organisations/////////////////////////////////////////////////
+
+		var allIds []string
+		for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) {
+			s := fmt.Sprintf("%v", v)
+			if !(strings.Contains(s, "admin")) {
+				allIds = append(allIds, s)
+			}
+
+		}
+
+		reques := &groupsmanagement.GetGroupsBatchRequest{
+			Groupids: allIds,
+		}
+
+		res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		g := ""
+		for _, group := range res.Groups {
+			g += fmt.Sprintf("%v", group.ToStorageType().Data["name"]) + " "
+		}
+		groupsName = append(groupsName, g)
+
+	}
+	cacheid := uuid.NewString()
+	h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
+
+	h.Renderer.MembersList(w, r, accounts, cacheid, groupsName)
+}

handlers/application/vehicles-management.go

@@ -42,20 +42,26 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 	for _, vehicle := range resp.Vehicles {
 		if filterVehicle(r, vehicle) {
 			v := vehicle.ToStorageType()
-			vehicles = append(vehicles, v)
+			vehicleBookings := []fleetsstorage.Booking{}
-			vehicles_map[v.ID] = v
 			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)
 				}
 			}
+			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)
 }
 
@@ -134,6 +140,9 @@ func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Req
 			fmt.Println(v)
 			dataMap["automatic"] = (v == "on")
 		}
+		if v := r.FormValue("kilometers"); v != "" {
+			dataMap["kilometers"] = v
+		}
 
 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
@@ -188,29 +197,6 @@ func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http
 	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 {
@@ -320,6 +306,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)),
 	}
@@ -457,3 +445,214 @@ 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) 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("kilometers"); v != "" {
+			dataMap["kilometers"] = 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/application/vehicles.go

@@ -26,7 +26,7 @@ import (
 
 func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
-
+	fmt.Println("invoked")
 	var beneficiary mobilityaccountsstorage.Account
 
 	beneficiarydocuments := []filestorage.FileInfo{}
@@ -349,6 +349,9 @@ func (h ApplicationHandler) VehiclesBookingsList(w http.ResponseWriter, r *http.
 	vehicles, _ := h.services.GetVehiclesMap()
 	groups, _ := h.services.GetGroupsMap()
 
+	// fmt.Println("bookings : ", bookings)
+	// fmt.Println("vehicles : ", vehicles)
+	// fmt.Println("groups : ", groups)
 	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
 }
 

handlers/exports/agenda.go

@@ -0,0 +1,196 @@
+package exports
+
+import (
+	"context"
+	"fmt"
+	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
+	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
+	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
+	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
+	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(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
+			}
+
+			events := []agendastorage.Event{}
+
+			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)
+
+		}
+	}
+	return nil
+}
+
+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")
+	f.SetCellValue("Sheet1", "D1", "Nom bénéficiaire")
+	f.SetCellValue("Sheet1", "E1", "Prenom bénéficiaire")
+	f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi")
+	f.SetCellValue("Sheet1", "G1", "Prescipteur")
+	f.SetCellValue("Sheet1", "H1", "Prescipteur Nom")
+	f.SetCellValue("Sheet1", "I1", "Gestionnaire événement")
+	i := 2
+	for _, e := range events {
+		if len(e.Owners) == 0 {
+			continue
+		}
+		admin := groups[e.Owners[0]]
+
+		subscribedbygroup := ""
+		subscribedbyuser := ""
+		if v, ok := e.Data["subscribed_by"].(map[string]any); ok {
+			if v2, ok := v["group"].(map[string]any); ok {
+				if v3, ok := v2["id"].(string); ok {
+					subscribedbygroup = v3
+				}
+
+			}
+			if v4, ok := v["user"].(map[string]any); ok {
+				if v5, ok := v4["display_name"].(string); ok {
+					subscribedbyuser = v5
+				}
+
+			}
+		}
+
+		for _, s := range e.Subscriptions {
+
+			beneficiary := beneficiaries_map[s.Subscriber]
+
+			f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), e.Name)
+			f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), e.Startdate.Format("2006-01-02"))
+			f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), e.Enddate.Format("2006-01-02"))
+			f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), beneficiary.Data["last_name"])
+			f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), beneficiary.Data["first_name"])
+			f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"])
+			f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), groups[subscribedbygroup].Data["name"])
+			f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), subscribedbyuser)
+			f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), admin.Data["name"])
+			i = i + 1
+		}
+
+	}
+	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")
+	file.Write(w)
+}

handlers/exports/exports.go

@@ -0,0 +1,21 @@
+package exports
+
+import (
+	"git.coopgo.io/coopgo-apps/parcoursmob/services"
+	"git.coopgo.io/coopgo-platform/emailing"
+	"github.com/spf13/viper"
+)
+
+type ExportsHandler struct {
+	config   *viper.Viper
+	services *services.ServicesHandler
+	emailing *emailing.Mailer
+}
+
+func NewExportsHandler(cfg *viper.Viper, svc *services.ServicesHandler, emailing *emailing.Mailer) (*ExportsHandler, error) {
+	return &ExportsHandler{
+		config:   cfg,
+		services: svc,
+		emailing: emailing,
+	}, nil
+}

handlers/exports/fleets.go

@@ -0,0 +1,163 @@
+package exports
+
+import (
+	"context"
+	"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"
+	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/xuri/excelize/v2"
+)
+
+func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
+
+	vehicles := map[string]fleetsstorage.Vehicle{}
+	bookings := []fleetsstorage.Booking{}
+	reequest := &fleets.GetVehiclesRequest{
+		Namespaces: []string{"parcoursmob"},
+	}
+	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	beneficiaries_ids := []string{}
+
+	for _, vehicle := range reesp.Vehicles {
+
+		v := vehicle.ToStorageType()
+		fmt.Println(v)
+
+		for _, b := range v.Bookings {
+			bookings = append(bookings, b)
+			beneficiaries_ids = append(beneficiaries_ids, b.Driver)
+		}
+
+		vehicles[vehicle.Id] = v
+
+	}
+
+
+	groups := map[string]groupsstorage.Group{}
+
+	admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{
+		Namespaces: []string{"parcoursmob_organizations"},
+	})
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	for _, g := range admingroups.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
+
+	f := excelize.NewFile()
+	defer func() {
+		if err := f.Close(); err != nil {
+			fmt.Println(err)
+		}
+	}()
+
+	f.SetCellValue("Sheet1", "A1", "Numéro")
+	f.SetCellValue("Sheet1", "B1", "Type")
+	f.SetCellValue("Sheet1", "C1", "Gestionnaire")
+	f.SetCellValue("Sheet1", "D1", "Prescripteur")
+	f.SetCellValue("Sheet1", "E1", "Bénéficiaire")
+	f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi")
+	f.SetCellValue("Sheet1", "G1", "Début de Mise à disposition")
+	f.SetCellValue("Sheet1", "H1", "Fin de mise à disposition")
+	f.SetCellValue("Sheet1", "I1", "Début indisponibilité")
+	f.SetCellValue("Sheet1", "J1", "Fin indisponibilité")
+	f.SetCellValue("Sheet1", "K1", "Retrait par le gestionnaire")
+	f.SetCellValue("Sheet1", "L1", "Commentaire")
+
+	i := 2
+	for _, b := range bookings {
+		vehicle := vehicles[b.Vehicleid]
+		if len(vehicle.Administrators) == 0 {
+			continue
+		}
+		admin := groups[vehicle.Administrators[0]]
+
+		bookedby := ""
+		if v, ok := b.Data["booked_by"].(map[string]any); 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
+
+		if av, ok := b.Data["administrator_unavailability"].(bool); ok && av {
+			adminunavailability = true
+		}
+
+		f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), vehicle.Data["licence_plate"])
+		f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), vehicle.Type)
+		f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), admin.Data["name"])
+		f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), bookedby)
+		f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), fmt.Sprintf("%v %v", beneficiary.Data["first_name"], beneficiary.Data["last_name"]))
+		f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"])
+		f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), b.Startdate.Format("2006-01-02"))
+		f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), b.Enddate.Format("2006-01-02"))
+		f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), b.Unavailablefrom.Format("2006-01-02"))
+		f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), b.Unavailableto.Format("2006-01-02"))
+		f.SetCellValue("Sheet1", fmt.Sprintf("K%d", i), adminunavailability)
+		f.SetCellValue("Sheet1", fmt.Sprintf("L%d", i), b.Data["comment"])
+		i = i + 1
+	}
+
+	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)
+
+}

main.go

@@ -9,6 +9,7 @@ import (
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/api"
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/application"
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/auth"
+	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/exports"
 	"git.coopgo.io/coopgo-apps/parcoursmob/renderer"
 	"git.coopgo.io/coopgo-apps/parcoursmob/services"
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
@@ -18,26 +19,26 @@ import (
 
 func main() {
 	cfg, err := ReadConfig()
+
 	if err != nil {
 		panic(err)
 	}
 
 	var (
-		address              = cfg.GetString("server.listen")
+		//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)
 	if err != nil {
 		panic(err)
 	}
-
+	fmt.Println(cfg)
 	kv, err := cache.NewKVHandler(cfg)
 	if err != nil {
 		panic(err)
 	}
-
 	filestorage, err := cache.NewFileStorage(cfg)
 
 	idp, err := identification.NewIdentificationProvider(cfg, svc, kv)
@@ -52,9 +53,13 @@ func main() {
 
 	apiHandler, _ := api.NewAPIHandler(cfg, idp, svc, kv)
 	applicationHandler, _ := application.NewApplicationHandler(cfg, svc, kv, filestorage, emailing)
+	exportsHandler, _ := exports.NewExportsHandler(cfg, svc, emailing)
 	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()
 
@@ -87,6 +92,7 @@ func main() {
 	application.HandleFunc("/members/{beneficiaryid}/picture", applicationHandler.BeneficiaryPicture)
 	application.HandleFunc("/members/{adminid}", applicationHandler.MemberDisplay)
 	application.HandleFunc("/members/{adminid}/update", applicationHandler.MemberUpdate)
+	application.HandleFunc("/members/", applicationHandler.MembersList)
 	application.HandleFunc("/journeys/", applicationHandler.JourneysSearch)
 	application.HandleFunc("/vehicles/", applicationHandler.VehiclesSearch)
 	application.HandleFunc("/vehicles/bookings/", applicationHandler.VehiclesBookingsList)
@@ -100,8 +106,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///////////////////////
@@ -141,17 +152,31 @@ func main() {
 	appAdmin.HandleFunc("/groups/{groupid}", applicationHandler.AdministrationGroupDisplay)
 	appAdmin.HandleFunc("/groups/{groupid}/invite-admin", applicationHandler.AdministrationGroupInviteAdmin)
 	appAdmin.HandleFunc("/groups/{groupid}/invite-member", applicationHandler.AdministrationGroupInviteMember)
+	//add statistiques
 	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
+	appAdmin.HandleFunc("/stats/bookings", applicationHandler.AdminStatBookings)
+	appAdmin.HandleFunc("/stats/beneficaires", applicationHandler.AdminStatBeneficaires)
+	appAdmin.HandleFunc("/stats/events", applicationHandler.AdminStatEvents)
 
 	/////////////////////////////////////Delete subscriber///////////////////////////////////////////////
 	application.HandleFunc("/agenda/{eventid}/{subscribeid}/delete", applicationHandler.AgendaDeleteSubscribeEvent)
 	application.HandleFunc("/agenda/{eventid}/history", applicationHandler.AgendaHistoryEvent)
 	/////////////////////////////////////////////////////////////////////////////////////////////////////
-	fmt.Println("-> HTTP server listening on", address)
+	//////////////////Add documents in event////////////////////////
+	application.HandleFunc("/agenda/{eventid}/documents", applicationHandler.EventDocuments)
+	application.HandleFunc("/agenda/{eventid}/documents/{document}", applicationHandler.EventDocumentDownload)
+
+	export := r.PathPrefix("/exports").Subrouter()
+	export.HandleFunc("/fleets/bookings", exportsHandler.Bookings)
+	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)
 
 	srv := &http.Server{
 		Handler:      r,
-		Addr:         address,
+		Addr:         "0.0.0.0:9000",
 		WriteTimeout: 15 * time.Second,
 		ReadTimeout:  15 * time.Second,
 	}

renderer/administration.go

@@ -1,14 +1,18 @@
 package renderer
 
 import (
+	"encoding/json"
+	"html/template"
 	"net/http"
 
+	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
+	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
 const administrationMenu = "administration"
 
-func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request, accounts any, beneficiaries any, groups any, bookings any) {
+func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request, accounts any, beneficiaries any, groups any, bookings any, events []agendastorage.Event) {
 	files := renderer.ThemeConfig.GetStringSlice("views.administration.home.files")
 	state := NewState(r, renderer.ThemeConfig, administrationMenu)
 	state.ViewState = map[string]any{
@@ -16,6 +20,7 @@ func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request,
 		"beneficiaries": beneficiaries,
 		"bookings":      bookings,
 		"groups":        groups,
+		"events":        events,
 	}
 
 	renderer.Render("administration", w, r, files, state)
@@ -39,3 +44,71 @@ func (renderer *Renderer) AdministrationGroupDisplay(w http.ResponseWriter, r *h
 
 	renderer.Render("administration", w, r, files, state)
 }
+
+type BeneficiariesState struct {
+	Count         int                               `json:"count"`
+	CacheId       string                            `json:"cache_id"`
+	Beneficiaries []mobilityaccountsstorage.Account `json:"beneficiaries"`
+}
+
+func (s BeneficiariesState) JSON() template.JS {
+	result, _ := json.Marshal(s)
+	return template.JS(result)
+}
+
+func (s BeneficiariesState) JSONWithLimits(a int, b int) template.JS {
+	if b < len(s.Beneficiaries) {
+		s.Beneficiaries = s.Beneficiaries[a:b]
+	}
+	return s.JSON()
+}
+
+func (renderer *Renderer) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request, Beneficiaries []mobilityaccountsstorage.Account, cacheid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.beneficaires_list.files")
+
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = BeneficiariesState{
+		Count:         len(Beneficiaries),
+		CacheId:       cacheid,
+		Beneficiaries: Beneficiaries,
+	}
+
+	renderer.Render("beneficiaries_State", w, r, files, state)
+}
+
+func (renderer *Renderer) AdminStatEvents(w http.ResponseWriter, r *http.Request, events []agendastorage.Event, groups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.events_list.files")
+
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = map[string]any{
+		"events": events,
+		"groups": groups,
+	}
+
+	renderer.Render("beneficiaries_State", w, r, files, state)
+}
+
+func (renderer *Renderer) AdminStatVehicles(w http.ResponseWriter, r *http.Request, vehicles []fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, admingroups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.vehicles_list.files")
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = map[string]any{
+		"vehicles":    vehicles,
+		"bookings":    bookings,
+		"admingroups": admingroups,
+	}
+
+	renderer.Render("vehicles_state", w, r, files, state)
+}
+
+func (renderer *Renderer) AdminStatBookings(w http.ResponseWriter, r *http.Request, vehicles map[string]fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, admingroups map[string]any, beneficiaries map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.bookings_list.files")
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = map[string]any{
+		"vehicles_map":      vehicles,
+		"bookings":          bookings,
+		"admingroups":       admingroups,
+		"beneficiaries_map": beneficiaries,
+	}
+
+	renderer.Render("bookings_stats", w, r, files, state)
+}

renderer/agenda.go

@@ -19,22 +19,42 @@ func (renderer *Renderer) AgendaHome(w http.ResponseWriter, r *http.Request, eve
 	renderer.Render("agenda home", w, r, files, state)
 }
 
-func (renderer *Renderer) AgendaCreateEvent(w http.ResponseWriter, r *http.Request) {
+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, events_file_types []string, file_types_map map[string]string, documents any) {
 	files := renderer.ThemeConfig.GetStringSlice("views.agenda.create_event.files")
 	state := NewState(r, renderer.ThemeConfig, agendaMenu)
 
+	state.ViewState = map[string]any{
+		"events_file_types": events_file_types,
+		"file_types_map":    file_types_map,
+		"documents":         documents,
+	}
+
 	renderer.Render("agenda create event", w, r, files, state)
 }
 
-func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Request, event any, group any, subscribers map[string]any, beneficiaries any) {
+func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Request, event any, group any, events_file_types []string, file_types_map map[string]string, documents any, subscribers map[string]any, beneficiaries any) {
 	files := renderer.ThemeConfig.GetStringSlice("views.agenda.display_event.files")
 	state := NewState(r, renderer.ThemeConfig, agendaMenu)
 
 	state.ViewState = map[string]any{
-		"event":         event,
+		"event":         	 event,
-		"group":         group,
+		"group":         	 group,
-		"subscribers":   subscribers,
+		"events_file_types": events_file_types,
-		"beneficiaries": beneficiaries,
+		"file_types_map":	 file_types_map,
+		"documents":     	 documents,
+		"subscribers":   	 subscribers,
+		"beneficiaries": 	 beneficiaries,
 	}
 
 	renderer.Render("agenda create event", w, r, files, state)
@@ -89,3 +109,18 @@ func (renderer *Renderer) AgendaDeleteEvent(w http.ResponseWriter, r *http.Reque
 
 	renderer.Render("event_deleteEvent", w, r, files, state)
 }
+
+////////Event documents////////////////////////
+// func (renderer *Renderer) EventDocuments(w http.ResponseWriter, r *http.Request, event any, documents []any) {
+// 	files := renderer.ThemeConfig.GetStringSlice("views.agenda.event_files.files")
+// 	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+
+// 	state.ViewState = map[string]any{
+// 		"event":      event,
+// 		"documents":  documents,
+// 		"eventid":    event.(map[string]any)["id"],
+// 		"eventtitle": event.(map[string]any)["title"],
+// 	}
+
+// 	renderer.Render("event_files", w, r, files, state)
+// }

renderer/beneficiaries.go

@@ -5,6 +5,7 @@ import (
 	"html/template"
 	"net/http"
 
+	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
@@ -52,7 +53,7 @@ type BeneficiariesDisplayState struct {
 	Beneficiary any
 }
 
-func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Request, beneficiary any, bookings []any, organizations []any, beneficiaries_file_types []string, file_types_map map[string]string, documents any) {
+func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Request, beneficiary any, bookings []fleetsstorage.Booking, organizations []any, beneficiaries_file_types []string, file_types_map map[string]string, documents any, event interface{}) {
 	files := renderer.ThemeConfig.GetStringSlice("views.beneficiaries.display.files")
 	state := NewState(r, renderer.ThemeConfig, beneficiariesMenu)
 	state.ViewState = map[string]any{
@@ -62,8 +63,8 @@ func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Requ
 		"file_types_map":           file_types_map,
 		"documents":                documents,
 		"organizations":            organizations,
+		"event":                    event,
 	}
-
 	renderer.Render("beneficiaries_display", w, r, files, state)
 }
 

renderer/dashboard.go

@@ -4,11 +4,12 @@ import (
 	"net/http"
 
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
+	fleetstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 )
 
 const dashboardMenu = "dashboard"
 
-func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, accounts []any, nbaccounts int, count_members int, events []agendastorage.Event) {
+func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, accounts []any, nbaccounts int, count_members int, events []agendastorage.Event, fleets []fleetstorage.Booking) {
 	files := renderer.ThemeConfig.GetStringSlice("views.dashboard.files")
 	state := NewState(r, renderer.ThemeConfig, dashboardMenu)
 	state.ViewState = map[string]any{
@@ -18,6 +19,7 @@ func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, acco
 		},
 		"count_members": count_members,
 		"events":        events,
+		"fleets":         fleets,
 	}
 
 	renderer.Render("dashboard", w, r, files, state)

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/members.go

@@ -1,17 +1,22 @@
 package renderer
 
 import (
+	"encoding/json"
+	"html/template"
 	"net/http"
+
+	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
 const membersMenu = "members"
 
-func (renderer *Renderer) MemberDisplay(w http.ResponseWriter, r *http.Request, admins any) {
+func (renderer *Renderer) MemberDisplay(w http.ResponseWriter, r *http.Request, admins any, groups []string) {
 	files := renderer.ThemeConfig.GetStringSlice("views.members.display.files")
 
 	state := NewState(r, renderer.ThemeConfig, membersMenu)
 	state.ViewState = map[string]any{
 		"admins": admins,
+		"groups": groups,
 	}
 	renderer.Render("members_list", w, r, files, state)
 }
@@ -22,3 +27,41 @@ func (renderer *Renderer) MemberUpdate(w http.ResponseWriter, r *http.Request, u
 	state.ViewState = user
 	renderer.Render("members_update", w, r, files, state)
 }
+
+type MembersListState struct {
+	Count   int                               `json:"count"`
+	CacheId string                            `json:"cache_id"`
+	Members []mobilityaccountsstorage.Account `json:"members"`
+	Groups  []string                          `json:"groups"`
+}
+
+func (s MembersListState) JSON() template.JS {
+	result, _ := json.Marshal(s)
+	return template.JS(result)
+}
+
+func (s MembersListState) JSONWithLimits(a int, b int) template.JS {
+	if b < len(s.Members) {
+		s.Members = s.Members[a:b]
+	}
+	return s.JSON()
+}
+
+func (renderer *Renderer) MembersList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account, cacheid string, groups []string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.members.list.files")
+
+	state := NewState(r, renderer.ThemeConfig, membersMenu)
+
+	state.ViewState = map[string]any{
+
+		"list": MembersListState{
+			Count:   len(accounts),
+			CacheId: cacheid,
+			Members: accounts,
+			Groups:  groups,
+		},
+		"groups": groups,
+	}
+
+	renderer.Render("members_list", w, r, files, state)
+}

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,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)
+
+}

renderer/vehicles.go

@@ -78,3 +78,15 @@ func (renderer *Renderer) VehicleBookingsList(w http.ResponseWriter, r *http.Req
 
 	renderer.Render("vehicles search", w, r, files, state)
 }
+
+// func (renderer *Renderer) VehicleUnbookingsList(w http.ResponseWriter, r *http.Request, bookings []storage.Booking, vehiclesMap any, groupsMap any) {
+// 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles.bookings_list.files")
+// 	state := NewState(r, renderer.ThemeConfig, vehiclesMenu)
+// 	state.ViewState = map[string]any{
+// 		"bookings":     bookings,
+// 		"vehicles_map": vehiclesMap,
+// 		"groups_map":   groupsMap,
+// 	}
+
+// 	renderer.Render("vehicles search", w, r, files, state)
+// }

services/fleets.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"context"
+	"fmt"
 	"sort"
 
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
@@ -56,13 +57,17 @@ func (s *ServicesHandler) GetBookings() (bookings []storage.Booking, err error)
 func (s *ServicesHandler) GetVehiclesMap() (vehicles map[string]storage.Vehicle, err error) {
 	vehicles = map[string]storage.Vehicle{}
 
-	request := &fleets.GetVehiclesRequest{}
+	request := &fleets.GetVehiclesRequest{
+		Namespaces: []string{"parcoursmob"},
+	}
 	resp, err := s.GRPC.Fleets.GetVehicles(context.TODO(), request)
-	if err == nil {
+	if err != nil {
+		fmt.Println(err)
+	} else {
 		for _, vehicle := range resp.Vehicles {
 			vehicles[vehicle.Id] = vehicle.ToStorageType()
 		}
 	}
 
-	return
+	return vehicles, err
 }

utils/storage/badger.go

@@ -0,0 +1 @@
+package storage

utils/storage/etcd.go

@@ -74,6 +74,7 @@ func NewEtcdHandler(cfg *viper.Viper) (*EtcdHandler, error) {
 		Password:    password,
 		DialTimeout: 5 * time.Second,
 	})
+	fmt.Println(endpoints,prefix,username,password)
 	if err != nil {
 		fmt.Println(err)
 		return nil, err

utils/storage/files.go

@@ -10,6 +10,7 @@ import (
 const (
 	PREFIX_BENEFICIARIES = "beneficiaries"
 	PREFIX_BOOKINGS      = "fleets_bookings"
+	PREFIX_AGENDA		 = "event_files"
 )
 
 type FileInfo struct {

utils/storage/kv.go

@@ -15,4 +15,6 @@ type KVHandler interface {
 
 func NewKVHandler(cfg *viper.Viper) (KVHandler, error) {
 	return NewEtcdHandler(cfg)
+	return nil, nil
+
 }