fix issues in groups members management

Add ICS calendars (global and organizations)
Add beneficiaries informations to bookings list
2024-11-21 23:11:59 +01:00 · 2024-11-21 00:54:52 +01:00 · 2024-11-19 15:53:40 +01:00 · 2024-11-19 15:21:31 +01:00 · 2024-11-11 20:07:00 +01:00 · 2024-11-11 19:50:17 +01:00
50 changed files with 1655 additions and 1436 deletions
--- a/.gitea/workflows/build.yml
+++ b/.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}}
--- a/go.mod
+++ b/go.mod
@@ -1,50 +1,41 @@
 module git.coopgo.io/coopgo-apps/parcoursmob

-go 1.22
+go 1.21

-toolchain go1.23.2
+// replace git.coopgo.io/coopgo-platform/mobility-accounts => ../../coopgo-platform/mobility-accounts/

-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/fleets => ../../coopgo-platform/fleets/
-
-replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/
-
-replace git.coopgo.io/sbouaram/solidarity-service => ../../coopgo-platform/solidarity-service/
-
-replace git.coopgo.io/coopgo-apps/silvermobi => ../../coopgo-apps/silvermobi/
-
-replace git.coopgo.io/coopgo-platform/routing-service => ../../coopgo-platform/routing-service/
+// replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/

 // replace git.coopgo.io/coopgo-platform/emailing => ../../coopgo-platform/emailing/

 require (
-	github.com/coreos/go-oidc v2.2.1+incompatible
 	github.com/fogleman/gg v1.3.0
-	github.com/go-playground/validator/v10 v10.12.0
+	github.com/go-playground/validator/v10 v10.11.0
 	github.com/google/uuid v1.6.0
-	github.com/gorilla/mux v1.8.1
+	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.18.2
+	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.10
+	go.etcd.io/etcd/client/v3 v3.5.6
 	golang.org/x/image v0.5.0
-	golang.org/x/oauth2 v0.23.0
-	google.golang.org/grpc v1.68.1
-	google.golang.org/protobuf v1.34.2
+	golang.org/x/oauth2 v0.21.0
+	google.golang.org/grpc v1.62.1
+	google.golang.org/protobuf v1.33.0
 )

 require (
-	git.coopgo.io/coopgo-platform/agenda v0.0.0-20230310121901-ef3add576f86
-	git.coopgo.io/coopgo-platform/emailing v0.0.0-20221017030337-c71888d90c15
+	git.coopgo.io/coopgo-platform/agenda v1.0.0
+	git.coopgo.io/coopgo-platform/emailing v0.0.0-20241119141913-9836b30191c1
 	git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e
 	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c
-	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230430115320-f5bb2e7c2c26
-	git.coopgo.io/coopgo-platform/routing-service v0.0.0-20230403183358-4d30329f06be
-	git.coopgo.io/sbouaram/solidarity-service v0.0.0-00010101000000-000000000000
+	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386
+	github.com/arran4/golang-ical v0.3.1
+	github.com/coreos/go-oidc/v3 v3.11.0
 	github.com/gorilla/securecookie v1.1.1
 	github.com/minio/minio-go/v7 v7.0.43
 	github.com/rs/zerolog v1.33.0
@@ -52,27 +43,28 @@ require (
 )

 require (
-	ariga.io/atlas v0.13.1 // indirect
+	ariga.io/atlas v0.12.0 // indirect
 	github.com/agext/levenshtein v1.2.1 // indirect
 	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/dustin/go-humanize v1.0.0 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/go-jose/go-jose/v4 v4.0.2 // indirect
 	github.com/go-openapi/inflect v0.19.0 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // 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.4 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/golang/snappy v0.0.1 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/hashicorp/hcl/v2 v2.16.2 // indirect
+	github.com/hashicorp/hcl/v2 v2.10.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.17.7 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/leodido/go-urn v1.2.2 // indirect
+	github.com/klauspost/cpuid/v2 v2.1.0 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/lib/pq v1.10.9 // indirect
 	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
@@ -86,49 +78,44 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
-	github.com/paulmach/orb v0.11.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // 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.5.0 // indirect
-	github.com/sagikazarmark/locafero v0.4.0 // indirect
-	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
-	github.com/sourcegraph/conc v0.3.0 // indirect
-	github.com/spf13/afero v1.11.0 // indirect
-	github.com/spf13/cast v1.6.0 // indirect
+	github.com/sergi/go-diff v1.1.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/spf13/afero v1.9.3 // indirect
+	github.com/spf13/cast v1.5.0 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/twpayne/go-geom v1.3.6 // indirect
-	github.com/twpayne/go-polyline v1.1.1 // indirect
+	github.com/subosito/gotenv v1.4.2 // indirect
+	github.com/tidwall/pretty v1.1.0 // indirect
+	github.com/twpayne/go-geom v1.5.7 // indirect
+	github.com/wneessen/go-mail v0.5.2 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
-	github.com/xdg-go/scram v1.1.2 // indirect
-	github.com/xdg-go/stringprep v1.0.4 // 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
-	github.com/zclconf/go-cty v1.12.1 // indirect
-	go.etcd.io/etcd/api/v3 v3.5.10 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.10 // indirect
-	go.mongodb.org/mongo-driver v1.15.0 // indirect
-	go.uber.org/atomic v1.11.0 // indirect
-	go.uber.org/multierr v1.11.0 // indirect
+	github.com/zclconf/go-cty v1.8.0 // indirect
+	go.etcd.io/etcd/api/v3 v3.5.6 // indirect
+	go.etcd.io/etcd/client/pkg/v3 v3.5.6 // indirect
+	go.mongodb.org/mongo-driver v1.11.4 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/crypto v0.27.0 // indirect
-	golang.org/x/exp v0.0.0-20240416160154-fe59bbe5cc7f // indirect
-	golang.org/x/net v0.29.0 // indirect
+	golang.org/x/crypto v0.28.0 // indirect
+	golang.org/x/net v0.27.0 // indirect
 	golang.org/x/sync v0.8.0 // indirect
-	golang.org/x/sys v0.28.0 // indirect
-	golang.org/x/text v0.18.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect
-	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
+	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	google.golang.org/genproto v0.0.0-20240123012728-ef4313101c80 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240123012728-ef4313101c80 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240311173647-c811ad7063a7 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
-	gopkg.in/mail.v2 v2.3.1 // indirect
 	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 // indirect
-	gopkg.in/square/go-jose.v2 v2.5.2-0.20210529014059-a5c7eec3c614 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
--- a/go.sum
+++ b/go.sum
--- a/handlers/api/cache.go
+++ b/handlers/api/cache.go
@@ -2,10 +2,11 @@ package api

 import (
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"strconv"

+	"github.com/rs/zerolog/log"
+
 	"github.com/gorilla/mux"
 )

@@ -18,7 +19,7 @@ func (h APIHandler) GetCache(w http.ResponseWriter, r *http.Request) {
 	go func() {
 		d, err := h.cache.Get(cacheid)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusNotFound)
 			ch <- nil
 			return
--- a/handlers/api/calendars.go
+++ b/handlers/api/calendars.go
@@ -0,0 +1,120 @@
+package api
+
+import (
+	"net/http"
+	"time"
+
+	"git.coopgo.io/coopgo-apps/parcoursmob/services"
+	ics "github.com/arran4/golang-ical"
+	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
+)
+
+func (h *APIHandler) icsCalendar(events []services.AgendaEvent) (*ics.Calendar, error) {
+	calendar := ics.NewCalendarFor(h.config.GetString("service_name"))
+
+	for _, e := range events {
+		vevent := ics.NewEvent(e.ID)
+		vevent.SetSummary(e.Name)
+		vevent.SetDescription(e.Description)
+		if e.Allday {
+			vevent.SetAllDayStartAt(e.Startdate)
+			if e.Enddate.After(e.Startdate) {
+				vevent.SetAllDayEndAt(e.Enddate.Add(24 * time.Hour))
+			}
+		} else {
+			timeloc, err := time.LoadLocation("Europe/Paris")
+			if err != nil {
+				log.Error().Err(err).Msg("Tried to load timezone location Europe/Paris. Error. Missing zones in container ?")
+				return nil, err
+			}
+
+			starttime, err := time.ParseInLocation("15:04", e.Starttime, timeloc)
+			if err != nil {
+				return nil, err
+			}
+			startdatetime := time.Date(e.Startdate.Year(), e.Startdate.Month(), e.Startdate.Day(), starttime.Hour(), starttime.Minute(), 0, 0, timeloc)
+
+			endtime, err := time.Parse("15:04", e.Endtime)
+			if err != nil {
+				return nil, err
+			}
+			enddatetime := time.Date(e.Enddate.Year(), e.Enddate.Month(), e.Enddate.Day(), endtime.Hour(), endtime.Minute(), 0, 0, timeloc)
+
+			vevent.SetStartAt(startdatetime)
+			vevent.SetEndAt(enddatetime)
+		}
+		calendar.AddVEvent(vevent)
+	}
+	return calendar, nil
+}
+
+func (h *APIHandler) CalendarGlobal(w http.ResponseWriter, r *http.Request) {
+	enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.global.enabled")
+	if !enabled {
+		log.Error().Msg("global calendar not activated in configuration")
+		w.WriteHeader(http.StatusForbidden)
+		return
+	}
+
+	events, err := h.services.GetAgendaEvents()
+	if err != nil {
+		log.Error().Err(err).Msg("error retrieving agenda events")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	calendar, err := h.icsCalendar(events)
+	if err != nil {
+		log.Error().Err(err).Msg("error while creating ics calendar")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Type", "text/calendar")
+	w.Write([]byte(calendar.Serialize()))
+}
+
+func (h *APIHandler) CalendarOrganizations(w http.ResponseWriter, r *http.Request) {
+	enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.organizations.enabled")
+	if !enabled {
+		log.Error().Msg("organizations calendar not activated in configuration")
+		w.WriteHeader(http.StatusForbidden)
+		return
+	}
+
+	// TODO set additional calendar rights in group configuration to prevent default behavior ?
+
+	vars := mux.Vars(r)
+	groupid := vars["groupid"]
+
+	events, err := h.services.GetAgendaEvents()
+	if err != nil {
+		log.Error().Err(err).Msg("error retrieving agenda events")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	filteredEvents := []services.AgendaEvent{}
+
+	for _, e := range events {
+		for _, g := range e.Owners {
+			if g == groupid {
+				filteredEvents = append(filteredEvents, e)
+				continue
+			}
+		}
+	}
+
+	calendar, err := h.icsCalendar(filteredEvents)
+	if err != nil {
+		log.Error().Err(err).Msg("error while creating ics calendar")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Type", "text/calendar")
+	w.Write([]byte(calendar.Serialize()))
+}
--- a/handlers/api/export.go
+++ b/handlers/api/export.go
@@ -8,6 +8,7 @@ import (
 	"strconv"

 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 )

 type FlatMaps []map[string]any
@@ -48,7 +49,7 @@ func (h APIHandler) CacheExport(w http.ResponseWriter, r *http.Request) {

 	d, err := h.cache.Get(cacheid)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Error getting cache")
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}
@@ -56,7 +57,6 @@ func (h APIHandler) CacheExport(w http.ResponseWriter, r *http.Request) {
 	if data, ok := d.([]any); ok {

 		flatmaps := FlatMaps{}
-		//fmt.Println(data)

 		for _, v := range data {
 			fm := map[string]any{}
@@ -90,7 +90,7 @@ func flatten(prefix string, src map[string]any, dest map[string]any) {
 				dest[prefix+k+"."+strconv.Itoa(i)] = child[i]
 			}
 		default:
-			fmt.Println(prefix+k, " : ", v)
+			// log.Trace().Str("key", prefix+k).Any("value", v).Msg("")
 			dest[prefix+k] = v
 		}
 	}
--- a/handlers/api/geo.go
+++ b/handlers/api/geo.go
@@ -3,13 +3,12 @@ package api
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 )

 func (h *APIHandler) GeoAutocomplete(w http.ResponseWriter, r *http.Request) {
-
 	pelias := h.config.GetString("geo.pelias.url")

 	t, ok := r.URL.Query()["text"]
@@ -29,8 +28,7 @@ func (h *APIHandler) GeoAutocomplete(w http.ResponseWriter, r *http.Request) {

 	defer resp.Body.Close()

-	body, err := ioutil.ReadAll(resp.Body)
-
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}
--- a/handlers/api/oidc.go
+++ b/handlers/api/oidc.go
@@ -2,15 +2,15 @@ package api

 import (
 	"context"
-	"fmt"
 	"net/http"
+
+	"github.com/rs/zerolog/log"
 )

 func (h APIHandler) OAuth2Callback(w http.ResponseWriter, r *http.Request) {
 	oauth2Token, err := h.idp.OAuth2Config.Exchange(context.Background(), r.URL.Query().Get("code"))
 	if err != nil {
-		fmt.Println("Exchange error")
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Exchange error")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -18,15 +18,14 @@ func (h APIHandler) OAuth2Callback(w http.ResponseWriter, r *http.Request) {
 	// Extract the ID Token from OAuth2 token.
 	rawIDToken, ok := oauth2Token.Extra("id_token").(string)
 	if !ok {
-		fmt.Println("issue retrieving token")
+		log.Error().Msg("Cannot retrieve ID token")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	_, err = h.idp.TokenVerifier.Verify(context.Background(), rawIDToken)
 	if err != nil {
-		fmt.Println("not able to verify token")
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Not able to verify token")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
@@ -42,7 +41,7 @@ func (h APIHandler) OAuth2Callback(w http.ResponseWriter, r *http.Request) {
 	}

 	if err = session.Save(r, w); err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Cannot save session")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
--- a/handlers/application/administration.go
+++ b/handlers/application/administration.go
@@ -24,6 +24,7 @@ import (
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 )

@@ -101,7 +102,14 @@ func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Reque
 	}()
 	wg.Wait()
 	if accountsErr != nil || beneficiariesErr != nil || bookingsErr != nil || groupsResponseErr != nil || eventsResponseErr != nil {
-		fmt.Println(accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr)
+		log.Error().
+			Any("accounts error", accountsErr).
+			Any("beneficiaries error", beneficiariesErr).
+			Any("bookings error", bookingsErr).
+			Any("groups response error", groupsResponseErr).
+			Any("events response error", eventsResponseErr).
+			Any("groups batch error", groupsBatchErr).
+			Msg("Error in retrieving administration data")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -114,7 +122,7 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r

 		if r.FormValue("name") == "" {

-			fmt.Println("invalid name")
+			log.Error().Str("name", r.FormValue("name")).Msg("Invalid name")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
@@ -141,7 +149,7 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("Cannot create PB struct from data map")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -163,7 +171,7 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r
 		go func() {
 			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("Issue in Groups management service - AddGroup")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -172,7 +180,7 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r
 		go func() {
 			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("Issue in Groups management service - AddGroup")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -193,14 +201,14 @@ func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r

 	resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Groups management service - GetGroup")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	groupmembers, admins, err := h.groupmembers(groupid)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("inssue retrieving group members")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -216,164 +224,141 @@ func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWrite
 		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{
+		Id:        groupid,
+		Namespace: "parcoursmob_organizations",
+	})
+	if err != nil {
+		log.Error().Err(err).Msg("Issue in Groups management service - GetGroup")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	r.ParseForm()

-		if err != nil {
-			fmt.Println(err)
+	accountresp, err = h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
+		Username:  r.FormValue("username"),
+		Namespace: "parcoursmob",
+	})
+	if err == nil {
+		log.Print("account exists")
+		// 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)
+
+		if _, err = h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), &accounts.UpdateDataRequest{Account: as}); err != nil {
+			log.Error().Err(err).Msg("could not set groups to user account")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
-	}()
-	r.ParseForm()

-	go func() {
-		accountresp, err = h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
-			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")
-
-			as, _ := accounts.AccountFromStorageType(&account)
-
-			_, 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)
-			}
-
-			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
-			}
+		data := map[string]any{
+			"group": groupresp.Group.ToStorageType().Data["name"],
 		}

-		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
-		return
-	}()
+		if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil {
+			log.Error().Err(err).Msg("Cannot send email")
+		}
+
+	} 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 {
+			log.Error().Err(err).Msg("Issue creating random bytes")
+			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 {
+			log.Error().Err(err).Msg("Cannot send email")
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	}
+
+	http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
 }
+
 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",
-		})
+	group, err := h.services.GetGroup(groupid)
+	if err != nil {
+		log.Error().Err(err).Msg("Issue in Groups management service - GetGroup")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	r.ParseForm()
+	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)

-		if err != nil {
-			fmt.Println(err)
+		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 {
+			log.Error().Err(err).Msg("error sending email onboarding.existing_member")
+		}
+
+		// http.Redirect(w, r, "/app/group/settings", http.StatusFound)
+		// return
+	} else {
+		// Onboard new 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
 		}
-		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)
+		key := base64.RawURLEncoding.EncodeToString(b)

-			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
-			}
+		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 {
+			log.Error().Err(err).Msg("error sending email onboarding.new_member")
+			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 {
@@ -394,7 +379,6 @@ func filteVehicle(r *http.Request, v *fleets.Vehicle) bool {
 }

 func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Request) {
-
 	bookings := []fleetsstorage.Booking{}
 	administrators := []string{}
 	reequest := &fleets.GetVehiclesRequest{
@@ -402,7 +386,7 @@ func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Req
 	}
 	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Fleets service - GetVehicles")
 		w.WriteHeader(http.StatusInternalServerError)
 	}

@@ -440,7 +424,7 @@ func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Req
 			Groupids: administrators,
 		})
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("Issue in Groups management service - GetGroupsBatch")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -456,7 +440,6 @@ func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Req
 }

 func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Request) {
-
 	vehicles := map[string]fleetsstorage.Vehicle{}
 	bookings := []fleetsstorage.Booking{}

@@ -465,7 +448,7 @@ func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Req
 	}
 	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Fleets service - GetVehicles")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -491,7 +474,7 @@ func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Req
 		Namespaces: []string{"parcoursmob_organizations"},
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Groups management service - GetGroups")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -504,7 +487,7 @@ func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Req
 		Accountids: beneficiaries_ids,
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Mobility accounts service - GetAccountsBatch")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -533,7 +516,7 @@ func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobili
 	members, err := h.members()
 	if err != nil {
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("Cannot get members")
 			return nil, nil, err
 		}
 	}
@@ -559,7 +542,7 @@ func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobili
 func (h ApplicationHandler) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request) {
 	beneficiaries, err := h.services.GetBeneficiaries()
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Cannot get beneficiaries")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -572,9 +555,8 @@ func (h ApplicationHandler) AdminStatEvents(w http.ResponseWriter, r *http.Reque
 	resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
 		Namespaces: []string{"parcoursmob_dispositifs"},
 	})
-
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("Issue in Agenda service - GetEvents")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
--- a/handlers/application/agenda.go
+++ b/handlers/application/agenda.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"sort"
 	"strconv"
@@ -13,12 +14,15 @@ 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"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -43,7 +47,7 @@ func (h *ApplicationHandler) AgendaHome(w http.ResponseWriter, r *http.Request)
 	})

 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -78,7 +82,7 @@ func (h *ApplicationHandler) AgendaHistory(w http.ResponseWriter, r *http.Reques
 	})

 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -119,10 +123,12 @@ func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Re

 		eventForm, err := parseEventsForm(r)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
+		
+		log.Debug().Any("eventFrom", eventForm).Msg("Form data submitted to create event")

 		data, _ := structpb.NewStruct(map[string]any{
 			"address": eventForm.Address,
@@ -147,17 +153,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)
+			log.Error().Err(err).Msg("")
 			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 {
+				log.Error().Err(err).Msg("Error parsing multipart form")
+				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 {
+					log.Error().Err(err).Msg("Error uploading file")
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+			} else if err != http.ErrMissingFile {
+				log.Error().Err(err).Msg("Error retrieving file")
+				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) {
@@ -170,7 +211,7 @@ func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.R

 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -181,7 +222,7 @@ func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.R

 	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -208,7 +249,7 @@ func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.R

 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -237,19 +278,24 @@ 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) {
 	current_group, err := h.currentGroup(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 	current_user_token, current_user_claims, err := h.currentUser(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -257,7 +303,7 @@ func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http
 	eventid := vars["eventid"]

 	if err := r.ParseForm(); err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -277,7 +323,7 @@ func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http
 	}
 	datapb, err := structpb.NewStruct(data)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -290,7 +336,7 @@ func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http

 	_, err = h.services.GRPC.Agenda.SubscribeEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -366,7 +412,7 @@ func contains(s []*agenda.Subscription, e string) bool {
 	return false
 }

-///////////////////////////////Update Event/////////////////////////////////////////
+// /////////////////////////////Update Event/////////////////////////////////////////
 func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Request) {
 	adm := strings.Split(r.URL.Path, "/")
 	eventID := adm[3]
@@ -376,7 +422,7 @@ func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Re

 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -391,7 +437,7 @@ func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Re

 		eventForm, err := parseEventsForm(r)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
@@ -422,7 +468,7 @@ func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Re
 		resp, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -443,7 +489,7 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re

 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -473,7 +519,7 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re
 		_, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -484,7 +530,7 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re
 	h.Renderer.AgendaDeleteEvent(w, r, resp.Event.ToStorageType())
 }

-///////////////////////////Delete subscriber///////////////////////////////
+// /////////////////////////Delete subscriber///////////////////////////////
 func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	eventId := vars["eventid"]
@@ -500,7 +546,7 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r

 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -522,14 +568,14 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r

 	current_group, err := h.currentGroup(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	current_user_token, current_user_claims, err := h.currentUser(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -562,7 +608,7 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r

 	datapb, err := structpb.NewStruct(data)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -583,18 +629,18 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r

 		// récupérer l'adresse mail de l'utilisateur qui a créé l'événement
 		mail := s_b_email
-		fmt.Println(mail)
+		log.Debug().Str("mail", mail).Msg("Email content")

 		_, err := h.services.GRPC.Agenda.DeleteSubscription(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}

 		if err := h.emailing.Send("delete_subscriber.request", mail, data); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -605,7 +651,7 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r
 	h.Renderer.AgendaDeleteSubscribeEvent(w, r, eventId)
 }

-////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////
 // /////////////////////History Event////////////////////////
 func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
@@ -616,7 +662,7 @@ func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.R

 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -627,7 +673,7 @@ func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.R

 	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -654,7 +700,6 @@ func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.R

 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
-		fmt.Println(err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -685,3 +730,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 {
+		log.Error().Err(err).Msg("")
+		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 {
+		log.Error().Err(err).Msg("")
+		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 {
+		log.Error().Err(err).Msg("")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", info.ContentType)
+	if _, err = io.Copy(w, file); err != nil {
+		log.Error().Err(err).Msg("")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound)
+
+}
--- a/handlers/application/application.go
+++ b/handlers/application/application.go
@@ -10,7 +10,7 @@ import (
 	cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
 	"git.coopgo.io/coopgo-platform/emailing"
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
-	"github.com/coreos/go-oidc"
+	"github.com/coreos/go-oidc/v3/oidc"
 	"github.com/spf13/viper"
 )

--- a/handlers/application/beneficiaries.go
+++ b/handlers/application/beneficiaries.go
@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"image/png"
 	"io"
-	"log"
 	"net/http"
 	"sort"
 	"strconv"
@@ -28,11 +27,9 @@ import (
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	solidarity_service "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-
-
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 )

@@ -112,7 +109,7 @@ func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Re

 	accounts, err := h.beneficiaries(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -127,7 +124,7 @@ func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Re
 func (h *ApplicationHandler) BeneficiaryCreate(w http.ResponseWriter, r *http.Request) {
 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
-		fmt.Println("Create beneficiary : could not find group")
+		log.Error().Msg("Create beneficiary : could not find group")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -138,14 +135,14 @@ func (h *ApplicationHandler) BeneficiaryCreate(w http.ResponseWriter, r *http.Re

 		dataMap, err := parseBeneficiariesForm(r)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -160,7 +157,7 @@ func (h *ApplicationHandler) BeneficiaryCreate(w http.ResponseWriter, r *http.Re
 		resp, err := h.services.GRPC.MobilityAccounts.Register(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -173,7 +170,7 @@ func (h *ApplicationHandler) BeneficiaryCreate(w http.ResponseWriter, r *http.Re
 		_, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -197,7 +194,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -208,7 +205,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R

 	subcriptionresp, err := h.services.GRPC.Agenda.GetSubscriptionByUser(context.TODO(), subscriptionrequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -222,7 +219,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R
 		}
 		eventresp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), eventresquest)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -236,7 +233,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R
 	}
 	bookingsresp, err := h.services.GRPC.Fleets.GetDriverBookings(context.TODO(), bookingsrequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -284,7 +281,7 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R

 			GetVehiculeResp, err := h.services.GRPC.Fleets.GetVehicle(context.Background(), GetVehiculeRequest)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -320,95 +317,18 @@ func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.R

 	groupsresp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), groupsrequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	}

 	organizations := []any{}
 	for _, o := range groupsresp.Groups {
 		organizations = append(organizations, o.ToStorageType())
 	}
-	
+
 	beneficiaries_file_types := h.config.GetStringSlice("modules.beneficiaries.documents_types")
 	file_types_map := h.config.GetStringMapString("storage.files.file_types")

-	if r.Method == "POST" {
-
-		request := &mobilityaccounts.GetAccountRequest{
-			Id: beneficiaryID,
-		}
-	
-		resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		fields := resp.Account.Data.Fields
-
-		firstName, ok := fields["first_name"]
-		if !ok {
-			fmt.Println("first_name not found in the data")
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		lastName, ok := fields["last_name"]
-		if !ok {
-			fmt.Println("last_name not found in the data")
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		passenger := solidarity_service.PassengerTripRequest {
-			Passenger : &solidarity_service.User {
-				Id: resp.Account.Id,
-				FirstName: firstName.Kind.(*structpb.Value_StringValue).StringValue,
-				LastName: lastName.Kind.(*structpb.Value_StringValue).StringValue,
-				Alias: " ",
-				Grade: 0,
-				Picture: " ",
-				Gender: " ",
-				VerifiedIdentity: true,
-
-			},
-		}
-
-		silvermobiPassenger, err := h.services.GRPC.SolidarityService.SetPassengerTrip(context.TODO(), &passenger)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		t := silvermobiPassenger
-		t = t		
-	}
-
-	solidarity_booking := &solidarity_service.GetBookingsByStatusRequest{
-		Status : 0,   /// 0 : pending
-		UserId : beneficiaryID,
-		Type: 1,      /// 1 : passenger
-	}
-
-	solidarity_bookings_object, err := h.services.GRPC.SolidarityService.GetBookingsByStatus(context.TODO(), solidarity_booking)
-
-
-	if err != nil {
-		fmt.Println(err)	
-		w.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	var solidarity_bookings_list []any
-
-	for _, o := range solidarity_bookings_object.Booking {
-		if(o.PassengerPickupDate != nil){
-			solidarity_bookings_list = append(solidarity_bookings_list, o)
-		}
-	}
-	
-	h.Renderer.BeneficiaryDisplay(w, r, resp.Account.ToStorageType(), bookings, organizations, beneficiaries_file_types, file_types_map, documents, events_list, solidarity_bookings_list)
+	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) {
@@ -419,14 +339,14 @@ func (h *ApplicationHandler) BeneficiaryUpdate(w http.ResponseWriter, r *http.Re

 		dataMap, err := parseBeneficiariesForm(r)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -442,7 +362,7 @@ func (h *ApplicationHandler) BeneficiaryUpdate(w http.ResponseWriter, r *http.Re
 		resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -458,7 +378,7 @@ func (h *ApplicationHandler) BeneficiaryUpdate(w http.ResponseWriter, r *http.Re

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -479,7 +399,7 @@ func (h *ApplicationHandler) BeneficiaryPicture(w http.ResponseWriter, r *http.R

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -492,13 +412,13 @@ func (h *ApplicationHandler) BeneficiaryPicture(w http.ResponseWriter, r *http.R

 	buffer := new(bytes.Buffer)
 	if err := png.Encode(buffer, picture); err != nil {
-		log.Println("unable to encode image.")
+		log.Error().Err(err).Msg("unable to encode image.")
 	}

 	w.Header().Set("Content-Type", "image/png")
 	w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes())))
 	if _, err := w.Write(buffer.Bytes()); err != nil {
-		log.Println("unable to write image.")
+		log.Error().Err(err).Msg("unable to write image.")
 	}
 }

@@ -514,7 +434,7 @@ func (h *ApplicationHandler) BeneficiaryDocuments(w http.ResponseWriter, r *http

 	file, header, err := r.FormFile("file-upload")
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return
 	}
 	defer file.Close()
@@ -526,8 +446,10 @@ func (h *ApplicationHandler) BeneficiaryDocuments(w http.ResponseWriter, r *http
 		"name": document_name,
 	}

+	log.Debug().Any("metadata", metadata).Msg("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)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -543,14 +465,14 @@ func (h *ApplicationHandler) BeneficiaryDocumentDownload(w http.ResponseWriter,

 	file, info, err := h.filestorage.Get(filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s", beneficiaryID, document))
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	w.Header().Set("Content-Type", info.ContentType)
 	if _, err = io.Copy(w, file); err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -614,7 +536,7 @@ func parseBeneficiariesForm(r *http.Request) (map[string]any, error) {
 		if err != nil {
 			return nil, err
 		}
-		date = &d 
+		date = &d
 	}

 	formData := BeneficiariesForm{
@@ -623,7 +545,7 @@ func parseBeneficiariesForm(r *http.Request) (map[string]any, error) {
 		Email:       r.PostFormValue("email"),
 		Birthdate:   date,
 		PhoneNumber: r.PostFormValue("phone_number"),
-		FileNumber:  r.PostFormValue("file_number"), 
+		FileNumber:  r.PostFormValue("file_number"),
 		Gender:      r.PostFormValue("gender"),
 	}

--- a/handlers/application/dashboard.go
+++ b/handlers/application/dashboard.go
@@ -2,7 +2,6 @@ package application

 import (
 	"context"
-	"fmt"
 	"net/http"
 	"sort"

@@ -10,8 +9,11 @@ import (
 	"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"
+	fleetstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )

@@ -31,7 +33,7 @@ func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -54,7 +56,7 @@ func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {

 	members, _, err := h.groupmembers(group.ID)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -76,6 +78,18 @@ func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {

 	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)

 }
--- a/handlers/application/group.go
+++ b/handlers/application/group.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/base64"
-	"fmt"
 	"io"
 	"net/http"
 	"time"
@@ -12,6 +11,7 @@ import (
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
+	"github.com/rs/zerolog/log"
 )

 func (h *ApplicationHandler) GroupSettingsDisplay(w http.ResponseWriter, r *http.Request) {
@@ -26,7 +26,7 @@ func (h *ApplicationHandler) GroupSettingsDisplay(w http.ResponseWriter, r *http
 	members, err := h.members()
 	if err != nil {
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -81,14 +81,16 @@ func (h *ApplicationHandler) GroupSettingsInviteMember(w http.ResponseWriter, r
 			},
 		)

-		fmt.Println(err)
+		if err != nil {
+			log.Error().Err(err).Msg("")
+		}

 		data := map[string]any{
 			"group": group.Data["name"],
 		}

 		if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}

 		http.Redirect(w, r, "/app/group/settings", http.StatusFound)
@@ -103,7 +105,7 @@ func (h *ApplicationHandler) GroupSettingsInviteMember(w http.ResponseWriter, r

 		b := make([]byte, 16)
 		if _, err := io.ReadFull(rand.Reader, b); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -117,7 +119,7 @@ func (h *ApplicationHandler) GroupSettingsInviteMember(w http.ResponseWriter, r
 		}

 		if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
--- a/handlers/application/group_module.go
+++ b/handlers/application/group_module.go
@@ -14,6 +14,7 @@ import (
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 )

@@ -44,8 +45,8 @@ func (h *ApplicationHandler) Groups(w http.ResponseWriter, r *http.Request) {
 	}

 	resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
-	if err != nil {   
-		fmt.Println(err)
+	if err != nil {
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -73,14 +74,12 @@ func (h *ApplicationHandler) CreateGroupModule(w http.ResponseWriter, r *http.Re
 		r.ParseForm()

 		if r.FormValue("name") == "" {
-
-			fmt.Println("invalid name")
+			log.Error().Msg("Invalid name")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 		if r.FormValue("type") == "" {
-
-			fmt.Println("invalid type")
+			log.Error().Msg("Invalid type")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
@@ -96,7 +95,7 @@ func (h *ApplicationHandler) CreateGroupModule(w http.ResponseWriter, r *http.Re

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -111,7 +110,7 @@ func (h *ApplicationHandler) CreateGroupModule(w http.ResponseWriter, r *http.Re

 		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -145,7 +144,7 @@ func (h *ApplicationHandler) DisplayGroupModule(w http.ResponseWriter, r *http.R

 	resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -186,7 +185,7 @@ func (h *ApplicationHandler) DisplayGroupModule(w http.ResponseWriter, r *http.R

 		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -201,7 +200,7 @@ func (h *ApplicationHandler) DisplayGroupModule(w http.ResponseWriter, r *http.R
 		_, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -212,7 +211,7 @@ func (h *ApplicationHandler) DisplayGroupModule(w http.ResponseWriter, r *http.R

 	accountsBeneficaire, err := h.beneficiaries(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
--- a/handlers/application/journeys.go
+++ b/handlers/application/journeys.go
@@ -14,45 +14,31 @@ import (
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
 	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
-	solidarity_service "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-	models "git.coopgo.io/coopgo-apps/parcoursmob/utils/models"
-
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	geojson "github.com/paulmach/go.geojson"
-
-	//"gitlab.scity.coop/maas/navitia-golang"
-	//"gitlab.scity.coop/maas/navitia-golang/types"
-	"google.golang.org/protobuf/types/known/emptypb"
+	"github.com/rs/zerolog/log"
+	"gitlab.scity.coop/maas/navitia-golang"
+	"gitlab.scity.coop/maas/navitia-golang/types"
 	"google.golang.org/protobuf/types/known/structpb"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )

 var Depart any
 var Arrive any

-
-var SolidarityData models.SolidarityTransport
-
-
 func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
 	var (
-		//journeys_results *navitia.JourneyResults
+		journeys_results *navitia.JourneyResults
 		carpool_results  any
 		vehicle_results  []any
-		solidarity_results  models.SolidarityTransport
 	)
 	vehiclech := make(chan []any, 1)
-	//navitiaCh := make(chan *navitia.JourneyResults, 1)
+	navitiaCh := make(chan *navitia.JourneyResults, 1)
 	carpoolCh := make(chan any, 1)
-	solidarityCh := make(chan models.SolidarityTransport, 1)
-
 	locTime, errTime := time.LoadLocation("Europe/Paris")
 	if errTime != nil {
-		fmt.Println("Loading timezone location Europe/Paris error : ")
-		fmt.Println("Missing zones in container ? ")
-		panic(errTime)
+		log.Panic().Err(errTime).Msg("Tried to load timezone location Europe/Paris. Error. Missing zones in container ?")
 	}

 	departuredate := r.FormValue("departuredate")
@@ -67,11 +53,9 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 	var (
 		departuregeo   *geojson.Feature
 		destinationgeo *geojson.Feature
-		//journeys       *navitia.JourneyResults
+		journeys       *navitia.JourneyResults
 		carpoolresults any
 		vehicles       = []any{}
-		drivers        []any
-		accounts 	   []any
 	)

 	if departuredate != "" && departuretime != "" && departure != "" && destination != "" {
@@ -81,47 +65,47 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque

 		departuregeo, err = geojson.UnmarshalFeature([]byte(departure))
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}

 		destinationgeo, err = geojson.UnmarshalFeature([]byte(destination))
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			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
-		// 	}
+		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 {
+				log.Error().Err(err).Msg("")
+				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
-		// 	}
+			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
+			journeys, err = session.Journeys(context.Background(), request)
+			if err != nil {
+				log.Error().Err(err).Msg("")
+				// w.WriteHeader(http.StatusBadRequest)
+				// return
+			}
+			navitiaCh <- journeys

-		// }
+		}
 		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		//CARPOOL
 		carpoolRequest := func() {
@@ -130,7 +114,7 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			client := &http.Client{}
 			req, err := http.NewRequest("GET", carpoolrequest, nil)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 			}

 			req.URL.RawQuery = fmt.Sprintf(
@@ -142,13 +126,13 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			req.Header.Set("X-API-KEY", "123456")
 			resp, err := client.Do(req)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 			}

 			if err == nil && resp.StatusCode == http.StatusOK {
 				err = json.NewDecoder(resp.Body).Decode(&carpoolresults)
 				if err != nil {
-					fmt.Println(err)
+					log.Error().Err(err).Msg("")
 				}

 				if carpoolresults == nil {
@@ -167,7 +151,7 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			}
 			vehicleresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), vehiclerequest)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 			}
 			for _, vehicle := range vehicleresp.Vehicles {
@@ -178,117 +162,15 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			}
 			vehiclech <- vehicles
 		}
-
-		///////////////////////////////////////////////////////////////////////////////////////////////////:::
-		//solidarity-service
-		solidarityRequest := func() {
-		timestamp := timestamppb.New(departuredatetime)
-		PassengerId := r.FormValue("passenger_id")
-		driverId := r.FormValue("driver_id")
-		id := uuid.New().String()
-
-		type Booking struct {
-			bookingData  solidarity_service.CreateBookingSolidarityRequest 
-		} 
-		var BookingData Booking
-		
-		accountsRequest, err := h.services.GRPC.SolidarityService.GetAllPassengers(context.TODO(), &emptypb.Empty{})
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusBadRequest)
-		}
-
-		for _, o := range accountsRequest.Passenger {
-				accounts = append(accounts, o)
-		}
-
-		cacheid := uuid.NewString()
-		h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
-
-
-		request := solidarity_service.DriverJourneysRequest{
-			DepartureDate: timestamp,
-			Departure: &solidarity_service.Feature{
-				Lat:     departuregeo.Geometry.Point[0],
-				Long:    departuregeo.Geometry.Point[1],
-				Address: departure,
-			},
-		}
-
-		driversRequest, err := h.services.GRPC.SolidarityService.DriverJourneys(context.TODO(), &request)
-
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		for _, o := range driversRequest.DriverJourneys {
-				drivers = append(drivers, o)
-		}
-
-		if r.Method == "POST" {
-
-			BookingData.bookingData = solidarity_service.CreateBookingSolidarityRequest {
-				Booking : &solidarity_service.BookingSolidarityRequest {
-					Id: id,
-					DriverId: driverId,
-					PassengerId: PassengerId,
-					DepartureAddress: &solidarity_service.Feature{
-						Lat:     departuregeo.Geometry.Point[0],
-						Long:    departuregeo.Geometry.Point[1],
-						Address: departure,
-					},
-					DestinationAddress: &solidarity_service.Feature{
-						Lat:     destinationgeo.Geometry.Point[0],
-						Long:    destinationgeo.Geometry.Point[1],
-						Address: departure,
-					},
-					PickupDate : timestamp,
-					
-				},
-			}
-			
-			BookingData.bookingData.Booking.DriverId = driverId
-			BookingData.bookingData.Booking.Id = id
-
-			booking, err := h.services.GRPC.SolidarityService.CreateBookingSolidarity(context.TODO(), &BookingData.bookingData)
-
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusInternalServerError)
-				return
-			}
-
-			booking = booking
-
-			SolidarityData = models.SolidarityTransport{
-				Drivers: drivers,
-				Beneficiaries: accounts,
-			}
-
-		}
-		SolidarityData = models.SolidarityTransport{
-			Drivers: drivers,
-			Beneficiaries: accounts,
-		}
-
-		solidarityCh <- SolidarityData
-
-		}
-		//go journeysRequest()
+		go journeysRequest()
 		go carpoolRequest()
 		go vehicleRequest()
-		go solidarityRequest()
 		carpool_results = <-carpoolCh
-		//journeys_results = <-navitiaCh
+		journeys_results = <-navitiaCh
 		vehicle_results = <-vehiclech
-		solidarity_results = <-solidarityCh
-
 	}
-	

-	h.Renderer.JourneysSearch(w, r, carpool_results, vehicle_results, searched, departuregeo, destinationgeo, departuredate, departuretime, solidarity_results) //journeys_results,
+	h.Renderer.JourneysSearch(w, r, carpool_results, journeys_results, vehicle_results, searched, departuregeo, destinationgeo, departuredate, departuretime)
 }

 type GroupsModule []groupstorage.Group
@@ -307,7 +189,7 @@ func (h *ApplicationHandler) GroupsGestion(w http.ResponseWriter, r *http.Reques

 	resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -358,7 +240,7 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)

 		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -375,14 +257,14 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)

 				departurgeo, err = geojson.UnmarshalFeature([]byte(departure))
 				if err != nil {
-					fmt.Println(err)
+					log.Error().Err(err).Msg("")
 					w.WriteHeader(http.StatusBadRequest)
 					return
 				}

 				dstinationgeo, err = geojson.UnmarshalFeature([]byte(destination))
 				if err != nil {
-					fmt.Println(err)
+					log.Error().Err(err).Msg("")
 					w.WriteHeader(http.StatusBadRequest)
 					return
 				}
@@ -403,14 +285,14 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)

 			if r.FormValue("name") == "" {

-				fmt.Println("invalid name")
+				log.Error().Msg("invalid name")
 				w.WriteHeader(http.StatusBadRequest)
 				return
 			}

 			if r.FormValue("number") == "" {

-				fmt.Println("invalid number of personne")
+				log.Error().Msg("invalid number of personne")
 				w.WriteHeader(http.StatusBadRequest)
 				return
 			}
@@ -447,7 +329,7 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)

 			data, err := structpb.NewValue(dataMap)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -462,7 +344,7 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)

 			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -474,7 +356,7 @@ func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request)
 	}
 	accountsBeneficaire, err := h.beneficiaries(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -493,7 +375,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h

 	resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -530,7 +412,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h

 		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -545,7 +427,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h
 		_, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -571,7 +453,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h
 		id := uuid.NewString()
 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -587,7 +469,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h

 		_, err = h.services.GRPC.GroupsManagement.AddGroupMember(context.TODO(), request_organizatio)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -602,7 +484,7 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h
 	// }
 	// s, err := h.services.GRPC.GroupsManagement.GetGroupsBatchMember(context.TODO(), grp)
 	// if err != nil {
-	// 	fmt.Println(err)
+	// 	log.Error().Err(err).Msg("")
 	// 	w.WriteHeader(http.StatusInternalServerError)
 	// 	return
 	// }
@@ -616,12 +498,10 @@ func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *h
 	//////////find all groups to store the adresse passenger///////
 	///////////try to optimise the code ////////////////////////////
 	groups, _ := h.services.GetGroupsMemberMap(resp.Group.ToStorageType().ID)
-	//fmt.Println(groups)
 	var number string = strconv.Itoa(len(resp.Group.Members))
-	/////////////////////
 	accountsBeneficaire, err := h.beneficiaries(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -644,7 +524,7 @@ func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *ht

 		resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -657,7 +537,7 @@ func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *ht

 		ressp, err := h.services.GRPC.GroupsManagement.GetGroupMember(context.TODO(), reequest)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -667,7 +547,7 @@ func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *ht

 		_, errr := h.services.GRPC.GroupsManagement.UnsubscribeMember(context.TODO(), req)
 		if errr != nil {
-			fmt.Println(errr)
+			log.Error().Err(errr).Msg("Issue in groups management service - InsubscribeMember")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -684,7 +564,7 @@ func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *ht

 				_, err := h.services.GRPC.GroupsManagement.Unsubscribe(context.TODO(), reequest)
 				if err != nil {
-					fmt.Println(err)
+					log.Error().Err(err).Msg("")
 					w.WriteHeader(http.StatusInternalServerError)
 					return
 				}
--- a/handlers/application/members.go
+++ b/handlers/application/members.go
@@ -12,6 +12,7 @@ import (
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 )

@@ -35,7 +36,7 @@ func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Reques

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -54,7 +55,7 @@ func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Reques

 	res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -77,14 +78,14 @@ func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request

 		dataMap, err := parseUserForm(r)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -100,7 +101,7 @@ func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request
 		resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -116,7 +117,7 @@ func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request

 	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -160,7 +161,7 @@ func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request)

 	accounts, err := h.services.GetAccounts()
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -174,7 +175,7 @@ func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request)

 		resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -195,7 +196,7 @@ func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request)

 		res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
--- a/handlers/application/solidarity_service.go
+++ b/handlers/application/solidarity_service.go
@@ -1,260 +0,0 @@
-package application
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-
-	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
-	solidarity_service "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-
-	"github.com/google/uuid"
-	"github.com/gorilla/mux"
-	geojson "github.com/paulmach/go.geojson"
-	"google.golang.org/protobuf/types/known/emptypb"
-	"google.golang.org/protobuf/types/known/structpb"
-	"google.golang.org/protobuf/types/known/timestamppb"
-)
-
-var BookingData Booking
-
-type Booking struct {
-	bookingData  solidarity_service.CreateBookingSolidarityRequest 
-} 
-
-//List les conducteurs disponibles + Créer une réservation
-func (h *ApplicationHandler) DriversJourney(w http.ResponseWriter, r *http.Request) {
-
-	if r.Method == "GET" && r.FormValue("date") != ""{
-				
-		DepartureAddress := r.FormValue("departure");
-		DestinationAddress := r.FormValue("destination");
-		PickupDate := r.FormValue("date");
-		
-		layout := "2006-01-02T15:04"
-
-		dateParsed, err := time.Parse(layout, PickupDate)
-
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		var (
-			departuregeo   *geojson.Feature
-			destinationgeo *geojson.Feature
-		)
-
-		timestamp := timestamppb.New(dateParsed)
-
-		if PickupDate != "" && DepartureAddress != "" && DestinationAddress != "" {
-			// searched = true
-	
-			var err error
-	
-			departuregeo, err = geojson.UnmarshalFeature([]byte(DepartureAddress))
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-	
-			destinationgeo, err = geojson.UnmarshalFeature([]byte(DestinationAddress))
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusBadRequest)
-				return
-			}
-		}
-
-		request := solidarity_service.DriverJourneysRequest{
-			DepartureDate: timestamp,
-			Departure: &solidarity_service.Feature{
-				Lat:     departuregeo.Geometry.Point[0],
-				Long:    departuregeo.Geometry.Point[1],
-				Address: DepartureAddress,
-			},
-		}
-
-		drivers, err := h.services.GRPC.SolidarityService.DriverJourneys(context.TODO(), &request)
-
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		BookingData.bookingData = solidarity_service.CreateBookingSolidarityRequest {
-			Booking : &solidarity_service.BookingSolidarityRequest {
-			
-			DepartureAddress: &solidarity_service.Feature{
-				Lat:     departuregeo.Geometry.Point[0],
-				Long:    departuregeo.Geometry.Point[1],
-				Address: DepartureAddress,
-			},
-			DestinationAddress: &solidarity_service.Feature{
-				Lat:     destinationgeo.Geometry.Point[0],
-				Long:    destinationgeo.Geometry.Point[1],
-				Address: DepartureAddress,
-			},
-			PickupDate : timestamp,
-		},
-		}
-
-		h.Renderer.SolidarityServiceListAvailableDrivers(w, r, drivers, &BookingData.bookingData)
-
-	} else if r.Method == "POST" {
-
-		vars := mux.Vars(r)
-		beneficiaryID := vars["id"]
-
-		driverId := r.FormValue("driver_id")
-		id := uuid.New().String()
-
-		BookingData.bookingData.Booking.DriverId = driverId
-		BookingData.bookingData.Booking.PassengerId= beneficiaryID
-		BookingData.bookingData.Booking.Id = id
-
-		booking, err := h.services.GRPC.SolidarityService.CreateBookingSolidarity(context.TODO(), &BookingData.bookingData)
-
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		h.Renderer.SolidarityServiceBooking(w, r, booking)
-
-	}else {
-
-
-		h.Renderer.CreateBookingHome(w, r)
-	}
-
-}
-
-func (h *ApplicationHandler) SolidarityService(w http.ResponseWriter, r *http.Request) {
-
-	accounts, err := h.services.GRPC.SolidarityService.GetAllPassengers(context.TODO(), &emptypb.Empty{})
-	drivers, err := h.services.GRPC.SolidarityService.GetAllDrivers(context.TODO(), &emptypb.Empty{})
-	bookings, err := h.services.GRPC.SolidarityService.GetAllBookingsSolidarity(context.TODO(), &emptypb.Empty{})
-
-	parcourmobAccounts, err := h.beneficiaries(r)
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusBadRequest)
-	}
-	cacheid := uuid.NewString()
-	h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
-	
-	h.Renderer.SolidarityService(w, r, accounts, drivers, parcourmobAccounts, bookings ,cacheid)
-}
-
-func (h *ApplicationHandler) CreateDriver(w http.ResponseWriter, r *http.Request) {
-
-	if r.Method== "POST" {
-
-		dataMap, err := parseBeneficiariesForm(r)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusBadRequest)
-			return
-		}
-
-		data, err := structpb.NewValue(dataMap)
-		if err != nil {
-			fmt.Println(err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		userRequest := &mobilityaccounts.RegisterRequest{
-			Account: &mobilityaccounts.Account{
-				Namespace: "silvermobi",
-				Data:      data.GetStructValue(),
-			},
-		}
-
-		resp, err := h.services.GRPC.MobilityAccounts.Register(context.TODO(), userRequest)
-
-		address := resp.Account.Data.GetFields()["address"].GetStructValue();
-		geometry := address.GetFields()["geometry"].GetStructValue();
-		coordinates:= geometry.GetFields()["coordinates"].GetListValue();
-		if len(coordinates.GetValues()) < 2{
-			fmt.Printf("Erreur lors de la récupération des coordonées : %v", err)
-			return
-		}
-		radiusStr := r.PostFormValue("radius")
-		radius, err := strconv.Atoi(radiusStr)
-		if err != nil {
-			fmt.Printf("Erreur lors de la conversion de radius : %v", err)
-			radius = 0
-		}
-
-		availabilitiesJSON := r.PostFormValue("availabilities")
-
-		var availabilities []solidarity_service.RegularAvailabilitySlot
-
-		jsonerr:= json.Unmarshal([]byte(availabilitiesJSON), &availabilities)
-		if jsonerr != nil {
-			fmt.Printf("Erreur lors de la conversion de availabilitiesJSON  : %v", err)
-		}
-
-		driverRequest := solidarity_service.DriverRegularAvailabilities {
-			DriverRequest : &solidarity_service.DriverRequest {
-				DriverAddress: &solidarity_service.Feature{
-					Lat: coordinates.GetValues()[0].GetNumberValue(),
-					Long: coordinates.GetValues()[1].GetNumberValue(),
-					Address: "********",
-				},
-				DriverRadius: int32(radius),
-				Driver: &solidarity_service.User{
-					Id: resp.Account.Id,
-					Alias: r.PostFormValue("alias"),
-					FirstName: r.PostFormValue("first_name"),
-					LastName: r.PostFormValue("last_name"),
-					Grade: 1,
-					Picture: "h.png",
-					Gender: r.PostFormValue("gender"),
-					VerifiedIdentity: true,      ///////// a Modifier !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-				},
-				Preferences: &solidarity_service.Preferences{
-					Smoking: false,
-					Animals: false,
-					Music: false,
-					IsTalker: false,
-					LuggageSize: 100,
-				},
-				Car: &solidarity_service.Car{
-					Model: r.PostFormValue("model"),
-					Brand: r.PostFormValue("brand"),
-				},
-			},
-			DriverAvailabilities: []*solidarity_service.RegularAvailabilitySlot{},
-		}
-
-		for _, slot := range availabilities{
-			driverRequest.DriverAvailabilities = append( driverRequest.DriverAvailabilities, &solidarity_service.RegularAvailabilitySlot{
-				DayOfWeek: slot.DayOfWeek,
-				StartTime: slot.StartTime,
-				EndTime: slot.EndTime,
-			})
-		}
-
-		driverResponse, err := h.services.GRPC.SolidarityService.SetDriverRegularAvailabilities(context.TODO(), &driverRequest)
-		if err != nil {
-			fmt.Printf("erreur lors de la création du conducteur: ", err)
-			radius = 0 
-		}
-		fmt.Println("driver: ", driverResponse)
-
-
-	}
-	
-	h.Renderer.CreateDriver(w, r)
-	
-}
--- a/handlers/application/support.go
+++ b/handlers/application/support.go
@@ -1,10 +1,11 @@
 package application

 import (
-	"fmt"
 	"net/http"

 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
+	"git.coopgo.io/coopgo-platform/emailing"
+	"github.com/rs/zerolog/log"
 )

 type Message struct {
@@ -15,23 +16,29 @@ func (h *ApplicationHandler) SupportSend(w http.ResponseWriter, r *http.Request)

 	c := r.Context().Value(identification.ClaimsKey)
 	if c == nil {
-		fmt.Println("no current user claims")
+		log.Error().Msg("no current user claims")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 	current_user_claims := c.(map[string]any)

 	comment := r.PostFormValue(("comment"))
+		

 	if r.Method == "POST" {
+		user_email := current_user_claims["email"].(string)
+		
 		data := map[string]any{
 			"key":  comment,
-			"user": current_user_claims["email"],
+			"user": user_email,
 		}

-		if err := h.emailing.Send("support.request", "support@parcoursmob.fr", data); err != nil {
-			fmt.Println(err)
+		log.Debug().Str("user_email", user_email).Msg("Sending message")
+
+		if err := h.emailing.Send("support.request", "support@parcoursmob.fr", data, emailing.WithReplyTo(user_email), emailing.WithTLSOpportunistic()); err != nil {
+			log.Error().Err(err).Msg("error sending email")
 			w.WriteHeader(http.StatusInternalServerError)
+			return 
 		}
 		http.Redirect(w, r, "/app/", http.StatusFound)
 		return
--- a/handlers/application/vehicles-management.go
+++ b/handlers/application/vehicles-management.go
@@ -17,9 +17,10 @@ import (
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	"github.com/coreos/go-oidc"
+	"github.com/coreos/go-oidc/v3/oidc"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -31,7 +32,7 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 	}
 	resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 	}

@@ -60,9 +61,11 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 		}
 	}

+	driversMap, _ := h.services.GetBeneficiariesMap() 
+
 	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
 	sort.Sort(sorting.BookingsByStartdate(bookings))
-	h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, bookings)
+	h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, driversMap, bookings)
 }

 func (h *ApplicationHandler) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request) {
@@ -72,7 +75,7 @@ func (h *ApplicationHandler) VehiclesManagementBookingsList(w http.ResponseWrite
 	}
 	resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 	}

@@ -97,7 +100,9 @@ func (h *ApplicationHandler) VehiclesManagementBookingsList(w http.ResponseWrite
 	cacheid := uuid.NewString()
 	h.cache.PutWithTTL(cacheid, bookings, 1*time.Hour)

-	h.Renderer.VehiclesManagementBookingsList(w, r, vehicles_map, bookings, cacheid)
+	driversMap, _ := h.services.GetBeneficiariesMap() 
+
+	h.Renderer.VehiclesManagementBookingsList(w, r, vehicles_map, driversMap, bookings, cacheid)
 }

 func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Request) {
@@ -111,7 +116,7 @@ func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Req
 		group := g.(storage.Group)

 		if err := r.ParseForm(); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
@@ -124,7 +129,7 @@ func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Req
 			var address map[string]any
 			err := json.Unmarshal([]byte(v), &address)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -137,13 +142,15 @@ func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Req
 			dataMap["licence_plate"] = v
 		}
 		if v := r.FormValue("automatic"); v != "" {
-			fmt.Println(v)
 			dataMap["automatic"] = (v == "on")
 		}
+		if v := r.FormValue("kilometers"); v != "" {
+			dataMap["kilometers"] = v
+		}

 		data, err := structpb.NewValue(dataMap)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -163,7 +170,7 @@ func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Req
 		_, err = h.services.GRPC.Fleets.AddVehicle(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -186,7 +193,7 @@ func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http

 	resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -217,7 +224,7 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite

 	booking, err := h.services.GetBooking(bookingid)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -265,7 +272,7 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite

 		_, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -282,7 +289,7 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite

 		beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), beneficiaryrequest)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -296,7 +303,7 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite

 	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -311,7 +318,7 @@ func (h ApplicationHandler) VehicleManagementBookingDisplay(w http.ResponseWrite

 	alternativeresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), alternativerequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	}

 	alternatives := []any{}
@@ -336,7 +343,7 @@ func (h ApplicationHandler) VehicleManagementBookingChangeVehicle(w http.Respons

 	booking, err := h.services.GetBooking(bookingid)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -351,7 +358,7 @@ func (h ApplicationHandler) VehicleManagementBookingChangeVehicle(w http.Respons

 	_, err = h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -363,7 +370,7 @@ func (h ApplicationHandler) VehicleManagementBookingChangeVehicle(w http.Respons
 func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter, r *http.Request) { // Get Group
 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
-		fmt.Println("no current group")
+		log.Error().Msg("no current group")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -372,7 +379,7 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 	// Get current user ID
 	u := r.Context().Value(identification.IdtokenKey)
 	if u == nil {
-		fmt.Println("no current user")
+		log.Error().Msg("no current user")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -381,7 +388,7 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 	// Get current user claims
 	c := r.Context().Value(identification.ClaimsKey)
 	if c == nil {
-		fmt.Println("no current user claims")
+		log.Error().Msg("no current user claims")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -416,7 +423,7 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,

 	datapb, err := structpb.NewStruct(data)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -435,7 +442,7 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,

 	_, err = h.services.GRPC.Fleets.CreateBooking(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -443,30 +450,6 @@ 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"]
@@ -477,7 +460,7 @@ func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Req

 	resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -487,14 +470,14 @@ func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Req

 	current_group, err := h.currentGroup(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	current_user_token, current_user_claims, err := h.currentUser(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -534,7 +517,7 @@ func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Req

 	datapb, err := structpb.NewStruct(data)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -557,7 +540,7 @@ func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Req
 		_, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -579,7 +562,7 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.

 	resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -590,7 +573,7 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.
 	if r.Method == "POST" {
 		fmt.Print(r.FormValue("vehicle_type"))
 		if err := r.ParseForm(); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
@@ -602,7 +585,7 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.
 			var address map[string]any
 			err := json.Unmarshal([]byte(v), &address)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -614,14 +597,16 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.
 		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)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -639,7 +624,7 @@ func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.
 		resp, err := h.services.GRPC.Fleets.UpdateVehicle(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
--- a/handlers/application/vehicles.go
+++ b/handlers/application/vehicles.go
@@ -20,13 +20,13 @@ import (
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/types/known/structpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )

 func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
-	fmt.Println("invoked")
 	var beneficiary mobilityaccountsstorage.Account

 	beneficiarydocuments := []filestorage.FileInfo{}
@@ -42,7 +42,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques

 	administrators := []string{}

-	if r.FormValue("beneficiaryid") != "" {
+	if r.FormValue("beneficiaryid") != "" && startdate.After(time.Now()) && enddate.After(startdate) {
 		// Handler form
 		searched = true

@@ -52,7 +52,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques

 		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -71,7 +71,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques

 		resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 		}

@@ -79,9 +79,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques
 			v := vehicle.ToStorageType()

 			if r.FormValue("type") == "Voiture" && automatic {
-				fmt.Println(v.Data["automatic"])
 				if auto, ok := v.Data["automatic"].(bool); !ok || !auto {
-					fmt.Println(v.Data["automatic"])
 					continue
 				}
 			}
@@ -105,7 +103,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques

 	accounts, err := h.beneficiaries(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -116,7 +114,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques
 			Groupids: administrators,
 		})
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -136,17 +134,16 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques
 }

 func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
-	fmt.Println("Book")
 	current_group, err := h.currentGroup(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	current_user_token, current_user_claims, err := h.currentUser(r)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -159,7 +156,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		Vehicleid: vehicleid,
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte("Vehicle not found"))
 		w.Write([]byte(err.Error()))
@@ -188,7 +185,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 	}
 	datapb, err := structpb.NewStruct(data)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -213,7 +210,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		if existing_file == "" {
 			file, header, err := r.FormFile("doc-" + v)
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusBadRequest)
 				w.Write([]byte("Document manquant : " + v))
 				return
@@ -228,7 +225,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 			}

 			if err := h.filestorage.Put(file, filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s_%s", booking.Id, fileid, header.Filename), header.Size, metadata); err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -236,7 +233,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 			path := strings.Split(existing_file, "/")

 			if err := h.filestorage.Copy(existing_file, fmt.Sprintf("%s/%s/%s", filestorage.PREFIX_BOOKINGS, booking.Id, path[len(path)-1])); err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -245,15 +242,15 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {

 	_, err = h.services.GRPC.Fleets.CreateBooking(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}

-	//NOTIFY GROUP MEMBERS
+	// NOTIFY GROUP MEMBERS
 	members, _, err := h.groupmembers(vehicle.Vehicle.Administrators[0])
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	} else {
 		for _, m := range members {
 			if email, ok := m.Data["email"].(string); ok {
@@ -265,7 +262,6 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 	}

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

 func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http.Request) {
@@ -277,7 +273,7 @@ func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http
 	}
 	resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -301,7 +297,7 @@ func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http

 	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -313,7 +309,6 @@ func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http
 }

 func (h ApplicationHandler) VehiclesBookingsList(w http.ResponseWriter, r *http.Request) {
-
 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
 		w.WriteHeader(http.StatusBadRequest)
@@ -325,7 +320,7 @@ func (h ApplicationHandler) VehiclesBookingsList(w http.ResponseWriter, r *http.
 	request := &fleets.GetBookingsRequest{}
 	resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}
@@ -349,9 +344,6 @@ 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)
 }

@@ -360,22 +352,21 @@ func (h *ApplicationHandler) BookingDocumentDownload(w http.ResponseWriter, r *h
 	bookingid := vars["bookingid"]
 	document := vars["document"]

-	fmt.Println(fmt.Sprintf("%s/%s", bookingid, document))
+	log.Debug().Str("booking id", bookingid).Str("document", document).Msg("Document and booking ID")

 	file, info, err := h.filestorage.Get(filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s", bookingid, document))
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	w.Header().Set("Content-Type", info.ContentType)
 	if _, err = io.Copy(w, file); err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	http.Redirect(w, r, fmt.Sprintf("/app/vehicles/bookings/%s", bookingid), http.StatusFound)
-
 }
--- a/handlers/auth/groups.go
+++ b/handlers/auth/groups.go
@@ -2,10 +2,10 @@ package auth

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

 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
+	"github.com/rs/zerolog/log"
 )

 func (h *AuthHandler) Groups(w http.ResponseWriter, r *http.Request) {
@@ -42,7 +42,7 @@ func (h *AuthHandler) Groups(w http.ResponseWriter, r *http.Request) {

 	err = idtoken.Claims(&claims)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	}

 	g := claims["groups"]
@@ -65,7 +65,7 @@ func (h *AuthHandler) Groups(w http.ResponseWriter, r *http.Request) {

 	resp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
--- a/handlers/auth/lost_password.go
+++ b/handlers/auth/lost_password.go
@@ -4,12 +4,12 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/base64"
-	"fmt"
 	"io"
 	"net/http"
 	"time"

 	"git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
+	"github.com/rs/zerolog/log"
 )

 func (h *AuthHandler) LostPasswordInit(w http.ResponseWriter, r *http.Request) {
@@ -22,14 +22,14 @@ func (h *AuthHandler) LostPasswordInit(w http.ResponseWriter, r *http.Request) {
 				Namespace: "parcoursmob",
 			})
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				http.Redirect(w, r, "/app/", http.StatusFound)
 				return
 			}

 			b := make([]byte, 16)
 			if _, err := io.ReadFull(rand.Reader, b); err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -44,7 +44,7 @@ func (h *AuthHandler) LostPasswordInit(w http.ResponseWriter, r *http.Request) {
 			h.cache.PutWithTTL("retrieve-password/"+key, passwordretrieval, 72*time.Hour)

 			if err := h.emailing.Send("auth.retrieve_password", email, passwordretrieval); err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -62,7 +62,7 @@ func (h *AuthHandler) LostPasswordRecover(w http.ResponseWriter, r *http.Request
 	key := r.FormValue("key")
 	recover, err := h.cache.Get("retrieve-password/" + key)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		h.Renderer.LostPasswordRecoverKO(w, r, key)
 		return
 	}
@@ -81,13 +81,13 @@ func (h *AuthHandler) LostPasswordRecover(w http.ResponseWriter, r *http.Request
 		})

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 		}

 		err = h.cache.Delete("retrieve-password/" + key)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}

 		http.Redirect(w, r, "/app/", http.StatusFound)
--- a/handlers/auth/onboarding.go
+++ b/handlers/auth/onboarding.go
@@ -7,6 +7,7 @@ import (

 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	ma "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
+	"github.com/rs/zerolog/log"
 )

 func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
@@ -15,7 +16,7 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
 	key := r.FormValue("key")
 	onboarding, err := h.cache.Get("onboarding/" + key)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		h.Renderer.AuthOnboardingKO(w, r, key)
 		return
 	}
@@ -24,7 +25,7 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {

 	if r.Method == "POST" {
 		if r.FormValue("password") == "" {
-			fmt.Println("password is empty !")
+			log.Error().Msg("Password is empty")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -58,7 +59,7 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {

 		acc, err := mobilityaccounts.AccountFromStorageType(account)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
@@ -70,14 +71,14 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
 		_, err = h.services.GRPC.MobilityAccounts.Register(context.TODO(), request)

 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}

 		err = h.cache.Delete("onboarding/" + key)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}

 		http.Redirect(w, r, "/app/", http.StatusFound)
--- a/handlers/exports/agenda.go
+++ b/handlers/exports/agenda.go
@@ -3,6 +3,9 @@ package exports
 import (
 	"context"
 	"fmt"
+	"net/http"
+	"sort"
+
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
@@ -11,9 +14,8 @@ import (
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	accountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 	"github.com/gorilla/mux"
+	"github.com/rs/zerolog/log"
 	"github.com/xuri/excelize/v2"
-	"net/http"
-	"sort"
 )

 func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *http.Request) {
@@ -24,7 +26,7 @@ func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *ht
 				Namespaces: []string{"parcoursmob_dispositifs"},
 			})
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -59,7 +61,7 @@ func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *ht
 				Accountids: beneficiaries_ids,
 			})
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -82,7 +84,7 @@ func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *ht
 				Id: eventId,
 			})
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -107,7 +109,7 @@ func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *ht
 				Accountids: beneficiaries_ids,
 			})
 			if err != nil {
-				fmt.Println(err)
+				log.Error().Err(err).Msg("")
 				w.WriteHeader(http.StatusInternalServerError)
 				return
 			}
@@ -130,7 +132,7 @@ func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[
 	f := excelize.NewFile()
 	defer func() {
 		if err := f.Close(); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}
 	}()
 	f.SetCellValue("Sheet1", "A1", "Evénement")
--- a/handlers/exports/fleets.go
+++ b/handlers/exports/fleets.go
@@ -12,6 +12,7 @@ import (
 	groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	accountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
+	"github.com/rs/zerolog/log"
 	"github.com/xuri/excelize/v2"
 )

@@ -24,7 +25,7 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 	}
 	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -34,7 +35,6 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 	for _, vehicle := range reesp.Vehicles {

 		v := vehicle.ToStorageType()
-		fmt.Println(v)

 		for _, b := range v.Bookings {
 			bookings = append(bookings, b)
@@ -45,14 +45,13 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {

 	}

-
 	groups := map[string]groupsstorage.Group{}

 	admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{
 		Namespaces: []string{"parcoursmob_organizations"},
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -65,7 +64,7 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 		Accountids: beneficiaries_ids,
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -80,7 +79,7 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 	f := excelize.NewFile()
 	defer func() {
 		if err := f.Close(); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}
 	}()

@@ -127,7 +126,7 @@ func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) {
 		// filter by group
 		g := r.Context().Value(identification.GroupKey)
 		group := g.(groupsstorage.Group)
-		
+
 		if bookedbygroup != group.ID {
 			continue
 		}
--- a/main.go
+++ b/main.go
@@ -1,11 +1,13 @@
 package main

 import (
-	"fmt"
-	"log"
 	"net/http"
+	"os"
 	"time"

+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/api"
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/application"
 	"git.coopgo.io/coopgo-apps/parcoursmob/handlers/auth"
@@ -18,37 +20,44 @@ import (
 )

 func main() {
-	cfg, err := ReadConfig()
+	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix

+	cfg, err := ReadConfig()
 	if err != nil {
-		panic(err)
+		log.Fatal().Err(err).Msg("cannot read config")
+		return
 	}

 	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")
 	)
+
+	if dev_env {
+		log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
+	}
+
 	svc, err := services.NewServicesHandler(cfg)
 	if err != nil {
-		panic(err)
+		log.Panic().Err(err).Msg("Error creating services handler")
 	}
-	fmt.Println(cfg)
+
 	kv, err := cache.NewKVHandler(cfg)
 	if err != nil {
-		panic(err)
+		log.Panic().Err(err).Msg("Error creating KV handler")
 	}
-	filestorage, err := cache.NewFileStorage(cfg)
+	filestorage, _ := cache.NewFileStorage(cfg)

 	idp, err := identification.NewIdentificationProvider(cfg, svc, kv)
 	if err != nil {
-		panic(err)
+		log.Panic().Err(err).Msg("Error creating identification provider")
 	}

 	emailing, err := renderer.NewEmailingHandler(cfg)
 	if err != nil {
-		panic(err)
+		log.Panic().Err(err).Msg("Error creating emailing handler")
 	}

 	apiHandler, _ := api.NewAPIHandler(cfg, idp, svc, kv)
@@ -56,11 +65,6 @@ func main() {
 	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()

 	r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir(templates_public_dir))))
@@ -73,6 +77,14 @@ func main() {
 	r.HandleFunc("/auth/groups/switch", authHandler.GroupSwitch)
 	r.HandleFunc("/", redirectApp)

+	if dev_env {
+		r.Use(trackPage)
+	}
+
+	calendars_router := r.PathPrefix("/api/calendars").Subrouter()
+	calendars_router.HandleFunc("/global.ics", apiHandler.CalendarGlobal)
+	calendars_router.HandleFunc("/organizations/{groupid}.ics", apiHandler.CalendarOrganizations)
+
 	api_router := r.PathPrefix("/api").Subrouter()
 	api_router.HandleFunc("/", apiHandler.NotFound)
 	api_router.HandleFunc("/geo/autocomplete", apiHandler.GeoAutocomplete)
@@ -137,18 +149,12 @@ func main() {
 	application.HandleFunc("/support/", applicationHandler.SupportSend)
 	/*********************** CODE GROUP **************************/

-	//=================================silvermobi====================================
-	application.HandleFunc("/solidarity_service/", applicationHandler.SolidarityService) 
-	application.HandleFunc("/solidarity_service/create/{id}", applicationHandler.DriversJourney) 
-	application.HandleFunc("/solidarity_service/driver/create", applicationHandler.CreateDriver) 
-
-
 	appGroup := application.PathPrefix("/group_module").Subrouter()
 	appGroup.HandleFunc("/", applicationHandler.Groups)
 	appGroup.HandleFunc("/groups", applicationHandler.CreateGroupModule)
 	appGroup.HandleFunc("/groups/{groupid}", applicationHandler.DisplayGroupModule)

-	//TODO Subrouters with middlewares checking security for each module ?
+	// TODO Subrouters with middlewares checking security for each module ?
 	application.Use(idp.Middleware)
 	application.Use(idp.GroupsMiddleware)

@@ -158,7 +164,7 @@ 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
+	// add statistiques
 	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
 	appAdmin.HandleFunc("/stats/bookings", applicationHandler.AdminStatBookings)
 	appAdmin.HandleFunc("/stats/beneficaires", applicationHandler.AdminStatBeneficaires)
@@ -168,6 +174,9 @@ func main() {
 	application.HandleFunc("/agenda/{eventid}/{subscribeid}/delete", applicationHandler.AgendaDeleteSubscribeEvent)
 	application.HandleFunc("/agenda/{eventid}/history", applicationHandler.AgendaHistoryEvent)
 	/////////////////////////////////////////////////////////////////////////////////////////////////////
+	//////////////////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)
@@ -179,15 +188,23 @@ func main() {

 	srv := &http.Server{
 		Handler:      r,
-		Addr:         "0.0.0.0:9000",
+		Addr:         address,
 		WriteTimeout: 15 * time.Second,
 		ReadTimeout:  15 * time.Second,
 	}

-	log.Fatal(srv.ListenAndServe())
+	log.Info().Str("service_name", service_name).Str("address", address).Msg("Running HTTP server")

+	log.Fatal().Err(srv.ListenAndServe())
 }

 func redirectApp(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, "/app/", http.StatusFound)
 }
+
+func trackPage(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Trace().Str("requested_uri", r.RequestURI).Msg("New request")
+		next.ServeHTTP(w, r.WithContext(r.Context()))
+	})
+}
--- a/BIN
+++ b/BIN
--- a/renderer/agenda.go
+++ b/renderer/agenda.go
@@ -30,22 +30,31 @@ func (renderer *Renderer) AgendaHistory(w http.ResponseWriter, r *http.Request,
 	renderer.Render("agenda history", w, r, files, state)
 }

-func (renderer *Renderer) AgendaCreateEvent(w http.ResponseWriter, r *http.Request) {
+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,
-		"group":         group,
-		"subscribers":   subscribers,
-		"beneficiaries": beneficiaries,
+		"event":         	 event,
+		"group":         	 group,
+		"events_file_types": events_file_types,
+		"file_types_map":	 file_types_map,
+		"documents":     	 documents,
+		"subscribers":   	 subscribers,
+		"beneficiaries": 	 beneficiaries,
 	}

 	renderer.Render("agenda create event", w, r, files, state)
@@ -100,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)
+// }
--- a/renderer/beneficiaries.go
+++ b/renderer/beneficiaries.go
@@ -7,7 +7,6 @@ import (

 	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	solidarity_service "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
 )

 const beneficiariesMenu = "beneficiaries"
@@ -16,16 +15,6 @@ type BeneficiariesListState struct {
 	Count         int                               `json:"count"`
 	CacheId       string                            `json:"cache_id"`
 	Beneficiaries []mobilityaccountsstorage.Account `json:"beneficiaries"`
-	BeneficiariesSolidarity *solidarity_service.GetAllPassengersResponse `json:"beneficiariessolidarity"`
-}
-
-type BeneficiarySolidarityState struct {
-	Count         int                               `json:"count"`
-	CacheId       string                            `json:"cache_id"`
-	Beneficiaries []mobilityaccountsstorage.Account `json:"beneficiaries"`
-	BeneficiarySolidarity *solidarity_service.GetPassengerResponse `json:"beneficiarysolidarity"`
-	BookingSolidarity *solidarity_service.GetBookingsByStatusResponse `json:"bookingsolidarity"`
-
 }

 func (s BeneficiariesListState) JSON() template.JS {
@@ -34,30 +23,18 @@ func (s BeneficiariesListState) JSON() template.JS {
 }

 func (s BeneficiariesListState) JSONWithLimits(a int, b int) template.JS {
-	if b < len(s.Beneficiaries) { 
+	if b < len(s.Beneficiaries) {
 		s.Beneficiaries = s.Beneficiaries[a:b]
 	}
 	return s.JSON()
 }

-func (s BeneficiarySolidarityState) JSON() template.JS {
-	result, _ := json.Marshal(s)
-	return template.JS(result)
-}
-
-func (s BeneficiarySolidarityState) JSONWithLimits(a int, b int) template.JS {
-	if b < 5 { 
-		s.Beneficiaries = s.Beneficiaries[a:b]
-	}
-	return s.JSON()
-}
-
-func (renderer *Renderer) BeneficiariesList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account,cacheid string) {
+func (renderer *Renderer) BeneficiariesList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account, cacheid string) {
 	files := renderer.ThemeConfig.GetStringSlice("views.beneficiaries.list.files")

 	state := NewState(r, renderer.ThemeConfig, beneficiariesMenu)
 	state.ViewState = BeneficiariesListState{
-		Count:         len(accounts), 
+		Count:         len(accounts),
 		CacheId:       cacheid,
 		Beneficiaries: accounts,
 	}
@@ -76,7 +53,7 @@ type BeneficiariesDisplayState struct {
 	Beneficiary 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{}, solidarity_bookings_list []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{
@@ -86,8 +63,7 @@ func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Requ
 		"file_types_map":           file_types_map,
 		"documents":                documents,
 		"organizations":            organizations,
-		"event":                    event, 
-		"bookingSolidarity" : solidarity_bookings_list,
+		"event":                    event,
 	}
 	renderer.Render("beneficiaries_display", w, r, files, state)
 }
--- a/renderer/dashboard.go
+++ b/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)
--- a/renderer/func-maps.go
+++ b/renderer/func-maps.go
@@ -25,20 +25,6 @@ func TimeFrom(d any) *time.Time {
 	return nil
 }

-func TimestampFrom(d any) *time.Time {
-
-	if date, ok := d.(time.Time); ok {
-		return &date
-	} else if date, ok := d.(string); ok {
-		datetime, err := time.Parse("2006-01-02T15:04:05Z", date)
-		if err != nil {
-			panic(err)
-		}
-		return &datetime
-	}
-	return nil
-}
-
 func TimeFormat(d any, f string) string {
 	date := TimeFrom(d)
 	if date == nil {
--- a/renderer/journeys.go
+++ b/renderer/journeys.go
@@ -4,10 +4,9 @@ import (
 	"encoding/json"
 	"html/template"
 	"net/http"
+
 	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	models "git.coopgo.io/coopgo-apps/parcoursmob/utils/models"
-
 )

 const journeysMenu = "journeys"
@@ -24,7 +23,6 @@ type BeneficiariesCovoiturageA struct {
 	Beneficiaries []any  `json:"beneficiaries"`
 }

-
 func (s BeneficiariesCovoiturage) JSON() template.JS {
 	result, _ := json.Marshal(s)
 	return template.JS(result)
@@ -37,7 +35,7 @@ func (s BeneficiariesCovoiturage) JSONWithLimits(a int, b int) template.JS {
 	return s.JSON()
 }

-func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, carpools any, vehicles []any, searched bool, departure any, destination any, departuredate string, departuretime string, solidarity_results models.SolidarityTransport ) { //transitjourneys any,
+func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, carpools any, transitjourneys any, vehicles []any, searched bool, departure any, destination any, departuredate string, departuretime string) {
 	files := renderer.ThemeConfig.GetStringSlice("views.journeys.search.files")
 	state := NewState(r, renderer.ThemeConfig, journeysMenu)
 	state.ViewState = map[string]any{
@@ -46,11 +44,11 @@ func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request,
 		"departuretime": departuretime,
 		"departure":     departure,
 		"destination":   destination,
-		//"journeys":      transitjourneys,
+		"journeys":      transitjourneys,
 		"carpools":      carpools,
 		"vehicles":      vehicles,
-		"solidarity_results": solidarity_results,
 	}
+
 	renderer.Render("journeys", w, r, files, state)
 }

--- a/renderer/renderer.go
+++ b/renderer/renderer.go
@@ -9,7 +9,8 @@ import (
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
 	"git.coopgo.io/coopgo-platform/emailing"
 	"git.coopgo.io/coopgo-platform/groups-management/storage"
-	"github.com/coreos/go-oidc"
+	"github.com/coreos/go-oidc/v3/oidc"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
 )

@@ -66,7 +67,7 @@ func (renderer *Renderer) Render(name string, w http.ResponseWriter, r *http.Req

 	err := t.ExecuteTemplate(w, "main", state)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	}
 }

@@ -95,7 +96,7 @@ func (renderer *Renderer) RenderNoLayout(name string, w http.ResponseWriter, r *
 	t = template.Must(t.ParseFiles(prefixed_files...))
 	err := t.ExecuteTemplate(w, "main", state)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	}
 }

@@ -251,14 +252,6 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende
 			Icon:   "hero:outline/user-group",
 		})
 	}
-	if modules["solidarity_service"] != nil && modules["solidarity_service"].(bool) {
-		ls.MenuItems = append(ls.MenuItems, MenuItem{
-			Title:  "Transport solidaire",
-			Link:   "/app/solidarity_service/",
-			Active: menuState == solidarityserviceMenu,
-			Icon:   "hero:outline/map",
-		})
-	}
 	return RenderState{
 		IconSet:     icons.NewIconSet(iconset),
 		Group:       group,
--- a/renderer/solidarity_service.go
+++ b/renderer/solidarity_service.go
@@ -1,127 +0,0 @@
-package renderer
-
-import (
-	"encoding/json"
-	"html/template"
-	"net/http"
-
-	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	solidarity_service "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-)
-
-const solidarityserviceMenu = "solidarity_service"
-
-
-type SolidarityListState struct {
-	Count                     int                               `json:"count"`
-  	CacheId                   string                            `json:"cache_id"`
-	BeneficiariesSolidarity   *solidarity_service.GetAllPassengersResponse `json:"beneficiariessolidarity"`
-	Drivers                   *solidarity_service.DriverJourneysResponse `json:"drivers"`
-	Bookings                  *solidarity_service.GetAllBookingsSolidarityResponse `json:"bookings"`
-	Beneficiaries              []mobilityaccountsstorage.Account   `json:"beneficiaries"`
-
-}
-
-type BeneficiariesSolidarityListState struct {
-	Count                      int                               `json:"count"`
-  	CacheId                    string                            `json:"cache_id"`
-	BeneficiariesSolidarity    *solidarity_service.GetAllPassengersResponse `json:"beneficiariessolidarity"`
-	Drivers                    *solidarity_service.GetAllDriversResponse `json:"drivers"`
-	Bookings                    *solidarity_service.GetAllBookingsSolidarityResponse `json:"bookings"`
-	Beneficiaries              []mobilityaccountsstorage.Account   `json:"beneficiaries"`
-
-
-}
-
-type SolidarityBookingsState struct {
-	Bookings *solidarity_service.CreateBookingSolidarityResponse `json:"bookings"`
-	Beneficiaries []mobilityaccountsstorage.Account   `json:"beneficiaries"`
-	BeneficiariesSolidarity          *solidarity_service.GetAllPassengersResponse `json:"beneficiariessolidarity"`
-
-}
-
-func (s BeneficiariesSolidarityListState) JSON() template.JS {
-	result, _ := json.Marshal(s)
-	return template.JS(result)
-}
-
-func (s BeneficiariesSolidarityListState) JSONWithLimits(a int, b int) template.JS {
-	if b < 5 { 
-		s.Beneficiaries = s.Beneficiaries[a:b]
-	}
-	return s.JSON()
-}
-
-func (s SolidarityListState) JSON() template.JS {
-	result, _ := json.Marshal(s)
-	return template.JS(result)
-}
-
-func (s SolidarityListState) JSONWithLimits(a int, b int) template.JS {
-	if b < 5 { 
-		s.Beneficiaries = s.Beneficiaries[a:b]
-	}
-	return s.JSON()
-}
-
-func (s SolidarityBookingsState) JSON() template.JS {
-	result, _ := json.Marshal(s)
-	return template.JS(result)
-}
-
-func (s SolidarityBookingsState) JSONWithLimits(a int, b int) template.JS {
-	if b < 5 { 
-		s.Beneficiaries = s.Beneficiaries[a:b]
-	}
-	return s.JSON()
-}
-
-func (renderer *Renderer) SolidarityService(w http.ResponseWriter, r *http.Request, accounts *solidarity_service.GetAllPassengersResponse, drivers *solidarity_service.GetAllDriversResponse, parcourmobAccounts []mobilityaccountsstorage.Account, bookings *solidarity_service.GetAllBookingsSolidarityResponse, cacheid string) {
-	files := renderer.ThemeConfig.GetStringSlice("views.solidarity_service.list.files")
-	state := NewState(r, renderer.ThemeConfig, solidarityserviceMenu)
-	state.ViewState = BeneficiariesSolidarityListState{
-		Count:         len(parcourmobAccounts), 
-		CacheId:       cacheid,
-		Beneficiaries: parcourmobAccounts,
-		BeneficiariesSolidarity: accounts,
-		Drivers: drivers,
-		Bookings: bookings,
-
-	}
-
-	renderer.Render("solidarity_service", w, r, files, state)
-}
-
-func (renderer *Renderer) CreateBookingHome(w http.ResponseWriter, r *http.Request ) {
-	files := renderer.ThemeConfig.GetStringSlice("views.solidarity_service.create.files")
-	state := NewState(r, renderer.ThemeConfig, solidarityserviceMenu)
-
-	renderer.Render("solidarity_service", w, r, files, state)
-}
-
-func (renderer *Renderer) SolidarityServiceBooking(w http.ResponseWriter, r *http.Request, bookings *solidarity_service.CreateBookingSolidarityResponse) {
-	files := renderer.ThemeConfig.GetStringSlice("views.solidarity_service.create.files")
-	state := NewState(r, renderer.ThemeConfig, solidarityserviceMenu)
-	state.ViewState = SolidarityBookingsState{
-		Bookings: bookings,
-	}
-
-	renderer.Render("solidarity_service", w, r, files, state)
-}
-
-func (renderer *Renderer) SolidarityServiceListAvailableDrivers(w http.ResponseWriter, r *http.Request, drivers *solidarity_service.DriverJourneysResponse, booking *solidarity_service.CreateBookingSolidarityRequest) {
-	files := renderer.ThemeConfig.GetStringSlice("views.solidarity_service.create.files")
-	state := NewState(r, renderer.ThemeConfig, solidarityserviceMenu)
-	state.ViewState = SolidarityListState{
-		Drivers: drivers,
-	}
-
-	renderer.Render("solidarity_service", w, r, files, state)
-}
-
-func (renderer *Renderer) CreateDriver(w http.ResponseWriter, r *http.Request) {
-	files := renderer.ThemeConfig.GetStringSlice("views.solidarity_service.create_driver.files")
-	state := NewState(r, renderer.ThemeConfig, solidarityserviceMenu)
-
-	renderer.Render("solidarity_service", w, r, files, state)
-}
--- a/renderer/vehicle-management.go
+++ b/renderer/vehicle-management.go
@@ -5,28 +5,31 @@ import (

 	filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
 	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
+	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )

 const vehiclesmanagementMenu = "vehicles_management"

-func (renderer *Renderer) VehiclesManagementOverview(w http.ResponseWriter, r *http.Request, vehicles []fleetsstorage.Vehicle, vehicles_map map[string]fleetsstorage.Vehicle, bookings []fleetsstorage.Booking) {
+func (renderer *Renderer) VehiclesManagementOverview(w http.ResponseWriter, r *http.Request, vehicles []fleetsstorage.Vehicle, vehicles_map map[string]fleetsstorage.Vehicle, driversMap map[string]mobilityaccountsstorage.Account, bookings []fleetsstorage.Booking) {
 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.overview.files")
 	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
 	state.ViewState = map[string]any{
 		"vehicles":     vehicles,
 		"bookings":     bookings,
 		"vehicles_map": vehicles_map,
+		"drivers_map": driversMap,
 	}

 	renderer.Render("fleet overview", w, r, files, state)
 }

-func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request, vehicles_map map[string]fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, cacheid string) {
+func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request, vehiclesMap map[string]fleetsstorage.Vehicle, driversMap map[string]mobilityaccountsstorage.Account, bookings []fleetsstorage.Booking, cacheid string) {
 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.bookings_list.files")
 	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
 	state.ViewState = map[string]any{
 		"bookings":     bookings,
-		"vehicles_map": vehicles_map,
+		"vehicles_map": vehiclesMap,
+		"drivers_map": driversMap,
 		"cacheid":      cacheid,
 	}

@@ -89,4 +92,4 @@ func (renderer *Renderer) UnbookingVehicle(w http.ResponseWriter, r *http.Reques

 	renderer.Render("vehicule unbooking", w, r, files, state)

-}
+}
--- a/services/agenda.go
+++ b/services/agenda.go
@@ -1,8 +1,14 @@
 package services

 import (
+	"context"
+	"fmt"
+	"time"
+
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
+	"git.coopgo.io/coopgo-platform/agenda/storage"
 	"google.golang.org/grpc"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )

 type AgendaService struct {
@@ -21,3 +27,39 @@ func NewAgendaService(dial string) (*AgendaService, error) {
 		AgendaClient: client,
 	}, nil
 }
+
+func (s *ServicesHandler) GetAgendaEvents() ([]AgendaEvent, error) {
+	resp, err := s.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
+		Namespaces: []string{"parcoursmob_dispositifs"},
+		Mindate:    timestamppb.New(time.Now().Add(-24 * time.Hour)),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	groups, err := s.GetGroupsMap()
+	if err != nil {
+		return nil, fmt.Errorf("error in groups request : %w", err)
+	}
+
+	events := []AgendaEvent{}
+
+	for _, e := range resp.Events {
+		newEvent := AgendaEvent{
+			Event: e.ToStorageType(),
+		}
+		for _, o := range e.Owners {
+			newEvent.OwnersGroups = append(newEvent.OwnersGroups, GroupsManagementGroup{Group: groups[o]})
+		}
+		events = append(events, newEvent)
+	}
+
+	return events, nil
+}
+
+// Enriched types
+
+type AgendaEvent struct {
+	OwnersGroups []GroupsManagementGroup
+	storage.Event
+}
--- a/services/fleets.go
+++ b/services/fleets.go
@@ -2,12 +2,12 @@ package services

 import (
 	"context"
-	"fmt"
 	"sort"

 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
 	"git.coopgo.io/coopgo-platform/fleets/storage"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/grpc"
 )

@@ -62,7 +62,7 @@ func (s *ServicesHandler) GetVehiclesMap() (vehicles map[string]storage.Vehicle,
 	}
 	resp, err := s.GRPC.Fleets.GetVehicles(context.TODO(), request)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 	} else {
 		for _, vehicle := range resp.Vehicles {
 			vehicles[vehicle.Id] = vehicle.ToStorageType()
--- a/services/groupsmanagement.go
+++ b/services/groupsmanagement.go
@@ -41,7 +41,7 @@ func (s *ServicesHandler) GetGroupsMap() (groups map[string]storage.Group, err e
 	return
 }

-////////////////////////////////optimize the code//////////////////////////////////////
+// //////////////////////////////optimize the code//////////////////////////////////////
 func (s *ServicesHandler) GetGroupsMemberMap(id string) (groups map[string]any, err error) {
 	groups = map[string]any{}

@@ -56,3 +56,23 @@ func (s *ServicesHandler) GetGroupsMemberMap(id string) (groups map[string]any,
 	}
 	return
 }
+
+func (s *ServicesHandler) GetGroup(groupid string) (*storage.Group, error) {
+	groupresp, err := s.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+		Id:        groupid,
+		Namespace: "parcoursmob_organizations",
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	group := groupresp.Group.ToStorageType()
+
+	return &group, nil
+}
+
+// Enriched types
+
+type GroupsManagementGroup struct {
+	storage.Group
+}
--- a/services/mobilityaccounts.go
+++ b/services/mobilityaccounts.go
@@ -42,6 +42,22 @@ func (s *ServicesHandler) GetBeneficiaries() (accounts []storage.Account, err er
 	return
 }

+func (s *ServicesHandler) GetBeneficiariesMap() (accounts map[string]storage.Account, err error) {
+	accounts = map[string]storage.Account{}
+	request := &mobilityaccounts.GetAccountsRequest{
+		Namespaces: []string{"parcoursmob_beneficiaries"},
+	}
+	resp, err := s.GRPC.MobilityAccounts.GetAccounts(context.TODO(), request)
+
+	if err == nil {
+		for _, v := range resp.Accounts {
+			accounts[v.Id] = v.ToStorageType()
+		}
+	}
+
+	return
+}
+
 func (s *ServicesHandler) GetAccounts() (accounts []storage.Account, err error) {
 	accounts = []storage.Account{}
 	request := &mobilityaccounts.GetAccountsRequest{
--- a/services/services.go
+++ b/services/services.go
@@ -5,11 +5,7 @@ import (
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
 	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
-	routing "git.coopgo.io/coopgo-platform/routing-service"
-	solidarityservice "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-
 	"github.com/spf13/viper"
-	"github.com/rs/zerolog/log"
 )

 type ServicesHandler struct {
@@ -17,13 +13,10 @@ type ServicesHandler struct {
 }

 type GRPCServices struct {
-	MobilityAccounts  mobilityaccounts.MobilityAccountsClient
-	GroupsManagement  groupsmanagement.GroupsManagementClient
-	Fleets            fleets.FleetsClient
-	Agenda            agenda.AgendaClient
-	SolidarityService solidarityservice.SolidarityServiceClient
-
-	Routing          routing.RoutingService
+	MobilityAccounts mobilityaccounts.MobilityAccountsClient
+	GroupsManagement groupsmanagement.GroupsManagementClient
+	Fleets           fleets.FleetsClient
+	Agenda           agenda.AgendaClient
 }

 func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) {
@@ -32,9 +25,6 @@ func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) {
 		groupsManagementDial = cfg.GetString("services.grpc.groupsmanagement.dial")
 		fleetsDial           = cfg.GetString("services.grpc.fleets.dial")
 		agendaDial           = cfg.GetString("services.grpc.agenda.dial")
-		solidarityDial   = cfg.GetString("services.grpc.solidarityservice.dial")
-		routing_service_type = cfg.GetString("routing.type")
-		valhalla_base_url    = cfg.GetString("routing.valhalla.base_url")
 	)
 	mobilityAccounts, err := NewMobilityAccountService(mobilityAccountsDial)
 	if err != nil {
@@ -56,27 +46,12 @@ func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) {
 		return nil, err
 	}

-	solidarityService, err := NewSolidarityService(solidarityDial)
-	if err != nil {
-		return nil , err
-	}
-
-	
-
-	routing, err := routing.NewRoutingService(routing_service_type, valhalla_base_url)
-	if err != nil {
-		log.Fatal().Err(err).Msg("Could not initiate the routing service")
-		return nil, err
-	}
-
 	return &ServicesHandler{
 		GRPC: GRPCServices{
 			MobilityAccounts: mobilityAccounts,
 			GroupsManagement: groupsManagement,
 			Fleets:           fleetsSvc,
 			Agenda:           agendaSvc,
-			SolidarityService: solidarityService,
-			Routing: routing,
 		},
 	}, nil
 }
--- a/services/solidarity_service.go
+++ b/services/solidarity_service.go
@@ -1,23 +0,0 @@
-package services
-
-import (
-	solidarityservice "git.coopgo.io/sbouaram/solidarity-service/servers/grpc/proto"
-	"google.golang.org/grpc"
-)
-
-type SolidarityService struct {
-	solidarityservice.SolidarityServiceClient
-}
-
-func NewSolidarityService(silvermobiDial string) (*SolidarityService, error) {
-	conn, err := grpc.Dial(silvermobiDial, grpc.WithInsecure())
-	
-	client := solidarityservice.NewSolidarityServiceClient(conn)
-	if err != nil {
-		return nil, err
-	}
-
-	return &SolidarityService{
-		SolidarityServiceClient: client,
-	}, nil
-}
--- a/utils/identification/groups.go
+++ b/utils/identification/groups.go
@@ -6,6 +6,7 @@ import (
 	"net/http"

 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
+	"github.com/rs/zerolog/log"
 )

 const GroupKey ContextKey = "group"
@@ -19,7 +20,6 @@ func (p *IdentificationProvider) GroupsMiddleware(next http.Handler) http.Handle

 		o, ok := session.Values["organization"]
 		if !ok || o == nil {
-			fmt.Println("no organization")
 			http.Redirect(w, r, "/auth/groups/", http.StatusFound)
 			return
 		}
@@ -29,7 +29,7 @@ func (p *IdentificationProvider) GroupsMiddleware(next http.Handler) http.Handle
 		claimgroups, ok := claims["groups"].([]any)

 		if !ok {
-			fmt.Println("cast issue")
+			log.Error().Msg("cast issue")
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
--- a/utils/identification/oidc.go
+++ b/utils/identification/oidc.go
@@ -4,14 +4,14 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/base64"
-	"fmt"
 	"io"
 	"net/http"

 	"git.coopgo.io/coopgo-apps/parcoursmob/services"
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
-	"github.com/coreos/go-oidc"
+	"github.com/coreos/go-oidc/v3/oidc"
 	"github.com/gorilla/sessions"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
 	"golang.org/x/oauth2"
 )
@@ -40,7 +40,27 @@ func NewIdentificationProvider(cfg *viper.Viper, services *services.ServicesHand

 	provider, err := oidc.NewProvider(context.Background(), providerURL)
 	if err != nil {
-		return nil, err
+		var (
+			issuerUrl   = cfg.GetString("identification.oidc.provider_config.issuer_url")
+			authUrl     = cfg.GetString("identification.oidc.provider_config.auth_url")
+			tokenUrl    = cfg.GetString("identification.oidc.provider_config.token_url")
+			userInfoUrl = cfg.GetString("identification.oidc.provider_config.user_info_url")
+			jwksUrl     = cfg.GetString("identification.oidc.provider_config.jwks_url")
+			algorithms  = []string{"RS256"}
+		)
+		if issuerUrl == "" || authUrl == "" || tokenUrl == "" || jwksUrl == "" {
+			return nil, err
+		}
+		providerConfig := oidc.ProviderConfig{
+			IssuerURL:   issuerUrl,
+			AuthURL:     authUrl,
+			TokenURL:    tokenUrl,
+			UserInfoURL: userInfoUrl,
+			JWKSURL:     jwksUrl,
+			Algorithms:  algorithms,
+		}
+
+		provider = providerConfig.NewProvider(context.Background())
 	}

 	oauth2Config := oauth2.Config{
@@ -71,18 +91,18 @@ func (p *IdentificationProvider) Middleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		session, err := p.SessionsStore.Get(r, "parcoursmob_session")
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}

 		if session.Values["idtoken"] == nil || session.Values["idtoken"] == "" {
-
 			state, err := newState()
 			if err != nil {
 				panic(err)
 			}
 			session.Values["state"] = state
 			session.Save(r, w)
-			http.Redirect(w, r, p.OAuth2Config.AuthCodeURL(state), http.StatusFound)
+			url := p.OAuth2Config.AuthCodeURL(state)
+			http.Redirect(w, r, url, http.StatusFound)
 			return
 		}

@@ -102,7 +122,7 @@ func (p *IdentificationProvider) Middleware(next http.Handler) http.Handler {

 		err = idtoken.Claims(&claims)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 		}

 		ctx := context.WithValue(r.Context(), IdtokenKey, idtoken)
--- a/utils/models/models.go
+++ b/utils/models/models.go
@@ -1,7 +0,0 @@
-package internal
-
-
-type SolidarityTransport struct {
-	Drivers []any
-	Beneficiaries []any
-}
--- a/utils/profile-pictures/profile-pictures.go
+++ b/utils/profile-pictures/profile-pictures.go
@@ -1,12 +1,12 @@
 package profilepictures

 import (
-	"fmt"
 	"image"
 	"image/color"
 	"image/draw"

 	"github.com/fogleman/gg"
+	"github.com/rs/zerolog/log"
 	"golang.org/x/image/font"
 	"golang.org/x/image/math/fixed"
 )
@@ -21,7 +21,7 @@ func DefaultProfilePicture(initials string) *image.RGBA {

 	ff, err := gg.LoadFontFace("themes/default/web/fonts/bitter.ttf", 150.0)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return img
 	}

--- a/utils/storage/etcd.go
+++ b/utils/storage/etcd.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"time"

+	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
 	clientv3 "go.etcd.io/etcd/client/v3"
 	"go.etcd.io/etcd/client/v3/namespace"
@@ -74,9 +75,8 @@ 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)
+		log.Error().Err(err).Msg("")
 		return nil, err
 	}

@@ -93,7 +93,7 @@ func NewEtcdHandler(cfg *viper.Viper) (*EtcdHandler, error) {
 func (s *EtcdHandler) Put(k string, v any) error {
 	data, err := s.serializer.Serialize(v)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	// _, err = s.Client.KV.Put(context.TODO(), k, data.String())
@@ -101,7 +101,7 @@ func (s *EtcdHandler) Put(k string, v any) error {
 	_, err = s.Client.KV.Put(ctx, k, string(data))
 	cancel()
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	return nil
@@ -110,13 +110,13 @@ func (s *EtcdHandler) Put(k string, v any) error {
 func (s *EtcdHandler) PutWithTTL(k string, v any, duration time.Duration) error {
 	lease, err := s.Client.Lease.Grant(context.TODO(), int64(duration.Seconds()))
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}

 	data, err := s.serializer.Serialize(v)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	// _, err = s.Client.KV.Put(context.TODO(), k, data.String(), clientv3.WithLease(lease.ID))
@@ -125,7 +125,7 @@ func (s *EtcdHandler) PutWithTTL(k string, v any, duration time.Duration) error
 	cancel()

 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	return nil
@@ -136,14 +136,14 @@ func (s *EtcdHandler) Get(k string) (any, error) {
 	resp, err := s.Client.KV.Get(ctx, k)
 	cancel()
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, err
 	}
 	for _, v := range resp.Kvs {
 		var data any
 		err := s.serializer.Deserialize([]byte(v.Value), &data)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return nil, err
 		}
 		// We return directly as we want to last revision of value
@@ -157,7 +157,7 @@ func (s *EtcdHandler) Delete(k string) error {
 	_, err := s.Client.KV.Delete(ctx, k)
 	cancel()
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	return nil
--- a/utils/storage/files.go
+++ b/utils/storage/files.go
@@ -10,6 +10,7 @@ import (
 const (
 	PREFIX_BENEFICIARIES = "beneficiaries"
 	PREFIX_BOOKINGS      = "fleets_bookings"
+	PREFIX_AGENDA		 = "event_files"
 )

 type FileInfo struct {
--- a/utils/storage/minio.go
+++ b/utils/storage/minio.go
@@ -2,12 +2,12 @@ package storage

 import (
 	"context"
-	"fmt"
 	"io"
 	"strings"

 	"github.com/minio/minio-go/v7"
 	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
 )

@@ -23,7 +23,7 @@ func NewMinioStorageHandler(cfg *viper.Viper) (*MinioStorageHandler, error) {
 		Secure: cfg.GetBool("storage.files.minio.use_ssl"),
 	})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, err
 	}

@@ -53,13 +53,13 @@ func (s *MinioStorageHandler) List(prefix string) []FileInfo {

 	for object := range objectCh {
 		if object.Err != nil {
-			fmt.Println("Error : ", object.Err)
+			log.Error().Str("prefix", prefix).Err(object.Err).Msg("Error listing files for prefix")
 			continue
 		}

 		objinfo, err := s.Client.StatObject(context.Background(), s.BucketName, object.Key, minio.StatObjectOptions{})
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			continue
 		}

@@ -82,12 +82,12 @@ func (s *MinioStorageHandler) List(prefix string) []FileInfo {
 func (s *MinioStorageHandler) Get(prefix string, file string) (io.Reader, *FileInfo, error) {
 	object, err := s.Client.GetObject(context.Background(), s.BucketName, prefix+"/"+file, minio.GetObjectOptions{})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, nil, err
 	}
 	objinfo, err := s.Client.StatObject(context.Background(), s.BucketName, prefix+"/"+file, minio.StatObjectOptions{})
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, nil, err
 	}

@@ -117,7 +117,7 @@ func (s *MinioStorageHandler) Copy(src string, dst string) error {

 	_, err := s.Client.CopyObject(context.Background(), dstOpts, srcOpts)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return err
 	}
 	return nil
--- a/utils/storage/sessions.go
+++ b/utils/storage/sessions.go
@@ -11,6 +11,7 @@ import (

 	"github.com/gorilla/securecookie"
 	"github.com/gorilla/sessions"
+	"github.com/rs/zerolog/log"
 )

 // Amount of time for cookies/kv keys to expire.
@@ -76,7 +77,7 @@ func (s *SessionStore) Save(r *http.Request, w http.ResponseWriter, session *ses
 	// Marked for deletion.
 	if session.Options.MaxAge <= 0 {
 		if err := s.delete(r.Context(), session); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return err
 		}
 		http.SetCookie(w, sessions.NewCookie(session.Name(), "", session.Options))
@@ -87,13 +88,13 @@ func (s *SessionStore) Save(r *http.Request, w http.ResponseWriter, session *ses
 		}

 		if err := s.save(r.Context(), session); err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return err
 		}

 		encoded, err := securecookie.EncodeMulti(session.Name(), session.ID, s.Codecs...)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return err
 		}
 		http.SetCookie(w, sessions.NewCookie(session.Name(), encoded, session.Options))
@@ -104,13 +105,11 @@ func (s *SessionStore) Save(r *http.Request, w http.ResponseWriter, session *ses
 // save stores the session in kv.
 func (s *SessionStore) save(ctx context.Context, session *sessions.Session) error {
 	m := make(map[string]interface{}, len(session.Values))
-	fmt.Println(m)
 	for k, v := range session.Values {
-		fmt.Println(v)
 		ks, ok := k.(string)
 		if !ok {
 			err := fmt.Errorf("non-string key value, cannot serialize session: %v", k)
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return err
 		}
 		m[ks] = v
Author	SHA1	Message	Date
Arnaud Delcasse	d46f62d92a	fix issues in groups members management Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m26s Details	2024-11-21 23:11:59 +01:00
Arnaud Delcasse	dd30d7959b	Add ICS calendars (global and organizations) Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m24s Details	2024-11-21 00:54:52 +01:00
Arnaud Delcasse	5f12bed2d4	Add beneficiaries informations to bookings list Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m25s Details	2024-11-19 15:53:40 +01:00
Arnaud Delcasse	2f760733af	Add ReplyTo header when sending email tu support Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m41s Details	2024-11-19 15:21:31 +01:00
Arnaud Delcasse	1df56a4f83	Remove all fmr.Println and add zerolog logging Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m42s Details	2024-11-11 20:07:00 +01:00
Arnaud Delcasse	a8acc9950a	Remove all fmr.Println and add zerolog logging Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m52s Details	2024-11-11 19:50:17 +01:00
Arnaud Delcasse	a51f077358	resolve conflict Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m46s Details	2024-11-04 17:29:19 +01:00
Arnaud Delcasse	4fc08a35de	Allow insecure HTTP for OIDC only in local in development mode	2024-11-04 17:24:02 +01:00
Nicolas CARON	eaf866154e	Update package git.coopgo.io Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m41s Details	2024-11-04 10:58:30 +01:00
Nicolas CARON	06f42947b9	run 'go mod tidy' Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 1m1s Details	2024-11-04 10:45:59 +01:00
Nicolas CARON	acb5232b94	run 'go mod tidy' Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 55s Details	2024-11-04 10:43:24 +01:00
Nicolas CARON	8de170a009	add bookings on dashboard & kilometers on vehicles management Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 59s Details	2024-10-29 12:08:24 +01:00
Nicolas CARON	a0557b0971	edit go.mod - comments all replace Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 58s Details	2024-10-28 10:05:31 +01:00
Nicolas CARON	b4c59c7408	edit agenda handlers - delete logs Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 2m8s Details	2024-10-23 10:39:11 +02:00
Nicolas CARON	334351a0cf	renderer agenda.go & handler agendo.go	2024-10-22 12:09:46 +02:00
Nicolas CARON	7184f4735c	edit agenda handlers	2024-10-15 10:51:15 +02:00
Nicolas CARON	434be30074	add logical to add docs in event	2024-10-09 18:21:45 +02:00
Arnaud Delcasse	498b12de18	fix dependencies in go.mod Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 54s Details	2024-05-20 17:25:31 +02:00
Nicolas Caron	b77403c674	test actions Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 53s Details	2024-04-10 09:18:24 +02:00
Nicolas Caron	f7cb9f1116	test actions Some checks failed Build and Push Docker Image / build_and_push (push) Failing after 26s Details	2024-04-05 12:22:22 +02:00
Nicolas Caron	2aec61e520	Merge branch 'dev' of https://git.coopgo.io/coopgo-apps/parcoursmob into dev	2024-04-04 12:24:59 +02:00
Nicolas Caron	73586aa61a	add .gitea/worflows/build.yml	2024-04-04 12:24:21 +02:00