edit dockerfile

.idea/.gitignore

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

.idea/modules.xml

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

.idea/parcoursmob.iml

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

.idea/vcs.xml

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

Dockerfile

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

go.mod

@@ -8,7 +8,7 @@ go 1.18
 
 // replace git.coopgo.io/coopgo-platform/fleets => ../../coopgo-platform/fleets/
 
-replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/
+// replace git.coopgo.io/coopgo-platform/agenda => ../../coopgo-platform/agenda/
 
 // replace git.coopgo.io/coopgo-platform/emailing => ../../coopgo-platform/emailing/
 
@@ -26,53 +26,58 @@ require (
 	golang.org/x/image v0.5.0
 	golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5
 	google.golang.org/grpc v1.48.0
-	google.golang.org/protobuf v1.31.0
+	google.golang.org/protobuf v1.28.1
 )
 
 require (
-	git.coopgo.io/coopgo-platform/agenda v0.0.0-20230310121901-ef3add576f86
+	git.coopgo.io/coopgo-platform/agenda v0.0.0-20230222135722-e55cf41e203b
 	git.coopgo.io/coopgo-platform/emailing v0.0.0-20221017030337-c71888d90c15
-	git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e
-	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c
-	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386
+	git.coopgo.io/coopgo-platform/fleets v0.0.0-20230519092636-41bf03682ca9
+	git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230117140716-312200e21063
+	git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20221107003506-e2ff98094b81
 	github.com/gorilla/securecookie v1.1.1
 	github.com/minio/minio-go/v7 v7.0.43
+	github.com/ory/viper v1.7.5
 	github.com/xuri/excelize/v2 v2.7.1
 )
 
 require (
-	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/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect
+	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
+	github.com/dgraph-io/ristretto v0.0.3 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/fsnotify/fsnotify v1.5.4 // indirect
-	github.com/go-openapi/inflect v0.19.0 // indirect
 	github.com/go-playground/locales v0.14.0 // indirect
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.1 // indirect
-	github.com/google/go-cmp v0.5.8 // indirect
+	github.com/gorilla/csrf v1.7.1 // indirect
+	github.com/gorilla/websocket v1.4.2 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/hashicorp/hcl/v2 v2.10.0 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.15.9 // indirect
 	github.com/klauspost/cpuid/v2 v2.1.0 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/lib/pq v1.10.9 // indirect
 	github.com/magiconair/properties v1.8.6 // indirect
+	github.com/mattn/goveralls v0.0.6 // indirect
 	github.com/mb0/wkt v0.0.0-20170420051526-a30afd545ee1 // indirect
 	github.com/minio/md5-simd v1.1.2 // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
-	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
+	github.com/ory/fosite v0.42.2 // indirect
+	github.com/ory/go-acc v0.2.6 // indirect
+	github.com/ory/go-convenience v0.1.0 // indirect
+	github.com/ory/x v0.0.214 // indirect
+	github.com/pborman/uuid v1.2.0 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
@@ -84,6 +89,7 @@ require (
 	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/spf13/afero v1.8.2 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
+	github.com/spf13/cobra v1.0.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.1 // indirect
@@ -95,7 +101,6 @@ require (
 	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.8.0 // indirect
 	go.etcd.io/etcd/api/v3 v3.5.4 // indirect
 	go.etcd.io/etcd/client/pkg/v3 v3.5.4 // indirect
 	go.mongodb.org/mongo-driver v1.10.1 // indirect
@@ -107,6 +112,7 @@ require (
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.7.0 // indirect
 	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/tools v0.6.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd // indirect
 	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect

handlers/api/cache.go

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

handlers/application/administration.go

@@ -8,7 +8,6 @@ import (
 	"io"
 	"net/http"
 	"sort"
-	"sync"
 	"time"
 
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
@@ -28,83 +27,79 @@ import (
 )
 
 func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) {
-	var (
-		wg                                                                                               sync.WaitGroup
-		accounts, beneficiaries                                                                          []mobilityaccountsstorage.Account
-		bookings                                                                                         []fleetsstorage.Booking
-		accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr error
-		groups                                                                                           = []groupstorage.Group{}
-		responses                                                                                        = []agendastorage.Event{}
-		groupsResponse                                                                                   *groupsmanagement.GetGroupsResponse
-		eventsResponse                                                                                   *agenda.GetEventsResponse
-		groupids                                                                                         = []string{}
-		groupsBatchResponse                                                                              *groupsmanagement.GetGroupsBatchResponse
-	)
-	// Retrieve accounts in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		accounts, accountsErr = h.services.GetAccounts()
-	}()
-	// Retrieve beneficiaries in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		beneficiaries, beneficiariesErr = h.services.GetBeneficiaries()
-	}()
-	// Retrieve bookings in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		bookings, bookingsErr = h.services.GetBookings()
-	}()
-	// Retrieve groupsRequest in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		request := &groupsmanagement.GetGroupsRequest{
-			Namespaces: []string{"parcoursmob_organizations"},
-		}
-		groupsResponse, groupsResponseErr = h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
-		for _, group := range groupsResponse.Groups {
-			g := group.ToStorageType()
-			groups = append(groups, g)
-		}
-		sort.Sort(sorting.GroupsByName(groups))
-	}()
-	// Retrieve Events in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		eventsResponse, eventsResponseErr = h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
-			Namespaces: []string{"parcoursmob_dispositifs"},
-		})
-		for _, e := range eventsResponse.Events {
-			groupids = append(groupids, e.Owners...)
-			responses = append(responses, e.ToStorageType())
-		}
-		sort.Sort(sorting.EventsByStartdate(responses))
-	}()
-	wg.Add(1)
-	// Retrieve groupsBatch in a goroutine
-	go func() {
-		defer wg.Done()
-		groupsBatchResponse, groupsBatchErr = h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
-			Groupids: groupids,
-		})
-		groupps := map[string]any{}
-		if groupsBatchErr == nil {
-			for _, g := range groupsBatchResponse.Groups {
-				groupps[g.Id] = g.ToStorageType()
-			}
-		}
-	}()
-	wg.Wait()
-	if accountsErr != nil || beneficiariesErr != nil || bookingsErr != nil || groupsResponseErr != nil || eventsResponseErr != nil {
-		fmt.Println(accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr)
+
+	accounts, err := h.services.GetAccounts()
+	if err != nil {
+		fmt.Println(err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
+
+	beneficiaries, err := h.services.GetBeneficiaries()
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bookings, err := h.services.GetBookings()
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	request := &groupsmanagement.GetGroupsRequest{
+		Namespaces: []string{"parcoursmob_organizations"},
+	}
+
+	resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	var groups = []groupstorage.Group{}
+
+	for _, group := range resp.Groups {
+		g := group.ToStorageType()
+		groups = append(groups, g)
+	}
+
+	sort.Sort(sorting.GroupsByName(groups))
+	////////////////////////////////////add event////////////////////////////////////////////
+	rresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
+		Namespaces: []string{"parcoursmob_dispositifs"},
+	})
+
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	responses := []agendastorage.Event{}
+
+	groupids := []string{}
+	for _, e := range rresp.Events {
+		groupids = append(groupids, e.Owners...)
+		responses = append(responses, e.ToStorageType())
+	}
+
+	sort.Sort(sorting.EventsByStartdate(responses))
+
+	groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+		Groupids: groupids,
+	})
+	groupps := map[string]any{}
+
+	if err == nil {
+		for _, g := range groupsresp.Groups {
+			groupps[g.Id] = g.ToStorageType()
+		}
+	}
+
 	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings, responses)
 }
 
@@ -160,23 +155,22 @@ func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r
 				Namespace: "parcoursmob_roles",
 			},
 		}
-		go func() {
+
 		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
 		if err != nil {
 			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
-		}()
+
 		// Create the admin role for the organization
-		go func() {
 		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
 		if err != nil {
 			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
-		}()
+
 		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
 		return
 	}
@@ -211,13 +205,8 @@ func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r
 func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	groupid := vars["groupid"]
-	var (
-		groupresp   *groupsmanagement.GetGroupResponse
-		accountresp *accounts.GetAccountUsernameResponse
-		err         error
-	)
-	go func() {
-		groupresp, err = h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
+
+	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
 		Id:        groupid,
 		Namespace: "parcoursmob_organizations",
 	})
@@ -227,14 +216,14 @@ func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWrite
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	}()
+
 	r.ParseForm()
 
-	go func() {
-		accountresp, err = h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
+	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()
@@ -294,16 +283,12 @@ func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWrite
 
 	http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
 	return
-	}()
 }
+
 func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	groupid := vars["groupid"]
-	var (
-		group storage.Group
-	)
-	groupCh := make(chan storage.Group)
-	go func() {
+
 	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
 		Id:        groupid,
 		Namespace: "parcoursmob_organizations",
@@ -314,16 +299,16 @@ func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWrit
 		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)
@@ -336,11 +321,15 @@ func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWrit
 				Account: as,
 			},
 		)
+
+		fmt.Println(err)
+
 		data := map[string]any{
 			"group": group.Data["name"],
 		}
 
 		if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil {
+			fmt.Println(err)
 		}
 
 		http.Redirect(w, r, "/app/group/settings", http.StatusFound)
@@ -355,23 +344,26 @@ func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWrit
 
 		b := make([]byte, 16)
 		if _, err := io.ReadFull(rand.Reader, b); err != nil {
+			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 		key := base64.RawURLEncoding.EncodeToString(b)
 
 		h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL
+
 		data := map[string]any{
 			"group": group.Data["name"],
 			"key":   key,
 		}
 
 		if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil {
+			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 	}
-	}()
+
 	http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound)
 	return
 }

handlers/application/beneficiaries.go

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

handlers/application/dashboard.go

@@ -68,11 +68,9 @@ func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
 		Mindate:    timestamppb.Now(),
 	})
 
-	if err == nil {
 	for _, e := range eventsresp.Events {
 		events = append(events, e.ToStorageType())
 	}
-	}
 
 	sort.Sort(sorting.EventsByStartdate(events))
 

handlers/application/journeys.go

@@ -27,14 +27,7 @@ var Arrive any
 
 func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
-	var (
-		journeys_results *navitia.JourneyResults
-		carpool_results  any
-		vehicle_results  []any
-	)
-	vehiclech := make(chan []any, 1)
-	navitiaCh := make(chan *navitia.JourneyResults, 1)
-	carpoolCh := make(chan any, 1)
+
 	locTime, errTime := time.LoadLocation("Europe/Paris")
 	if errTime != nil {
 		fmt.Println("Loading timezone location Europe/Paris error : ")
@@ -77,8 +70,7 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
-		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-		journeysRequest := func() {
+
 		//TODO make it a library
 		session, _ := navitia.NewCustom(
 			h.config.GetString("services.navitia.api_key"),
@@ -87,7 +79,6 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 		if err != nil {
 			fmt.Println(err)
 			w.WriteHeader(http.StatusBadRequest)
-				navitiaCh <- nil
 			return
 		}
 
@@ -104,12 +95,13 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			// w.WriteHeader(http.StatusBadRequest)
 			// return
 		}
-			navitiaCh <- journeys
 
-		}
-		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		//CARPOOL
-		carpoolRequest := func() {
+		// carpoolrequest := fmt.Sprintf(
+		// 	"https://api.rdex.ridygo.fr/journeys.json?p[driver][state]=1&frequency=punctual&p[passenger][state]=0&p[from][latitude]=%f&p[from][longitude]=%f&p[to][latitude]=%f&p[to][longitude]=%f&p[outward][mindate]=%s&p[outward][maxdate]=%s",
+		// 	departuregeo.Geometry.Point[1], departuregeo.Geometry.Point[0],
+		// 	destinationgeo.Geometry.Point[1], destinationgeo.Geometry.Point[0],
+		// 	departuredatetime.Format("2006-01-02"), departuredatetime.Add(24*time.Hour).Format("2006-01-02"))
 		carpoolrequest := "https://api.rdex.ridygo.fr/journeys.json"
 
 		client := &http.Client{}
@@ -142,11 +134,9 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 		} else {
 			carpoolresults = []any{}
 		}
-			carpoolCh <- carpoolresults
-		}
-		////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 		// Vehicles
-		vehicleRequest := func() {
+
 		vehiclerequest := &fleets.GetVehiclesRequest{
 			Namespaces: []string{"parcoursmob"},
 		}
@@ -155,23 +145,16 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 		}
+
 		for _, vehicle := range vehicleresp.Vehicles {
 			v := vehicle.ToStorageType()
 			if v.Free(departuredatetime.Add(-24*time.Hour), departuredatetime.Add(168*time.Hour)) {
 				vehicles = append(vehicles, v)
 			}
 		}
-			vehiclech <- vehicles
-		}
-		go journeysRequest()
-		go carpoolRequest()
-		go vehicleRequest()
-		carpool_results = <-carpoolCh
-		journeys_results = <-navitiaCh
-		vehicle_results = <-vehiclech
 	}
 
-	h.Renderer.JourneysSearch(w, r, carpool_results, journeys_results, vehicle_results, searched, departuregeo, destinationgeo, departuredate, departuretime)
+	h.Renderer.JourneysSearch(w, r, carpoolresults, journeys, vehicles, searched, departuregeo, destinationgeo, departuredate, departuretime)
 }
 
 type GroupsModule []groupstorage.Group

handlers/application/vehicles-management.go

@@ -45,8 +45,10 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 			vehicleBookings := []fleetsstorage.Booking{}
 			for _, b := range v.Bookings {
 				if b.Status() != fleetsstorage.StatusOld {
+					if deleted, ok := b.Data["Deleted"].(bool); !ok && !deleted {
 						bookings = append(bookings, b)
 					}
+				}
 				if b.Unavailableto.After(time.Now()) {
 					vehicleBookings = append(vehicleBookings, b)
 				}
@@ -57,7 +59,6 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 
 		}
 	}
-	fmt.Println(vehicles_map)
 
 	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
 	sort.Sort(sorting.BookingsByStartdate(bookings))
@@ -189,36 +190,10 @@ func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	// if len(resp.Vehicle.ToStorageType().Bookings) == 0 {
-	// 	fmt.Println("lol")
-	// }
-	// fmt.Println(resp.Vehicle.ToStorageType().Bookings)
+
 	h.Renderer.VehiclesFleetDisplay(w, r, resp.Vehicle.ToStorageType())
 }
 
-func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	vehicleid := vars["vehicleid"]
-
-	if r.Method == "POST" {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	request := &fleets.GetVehicleRequest{
-		Vehicleid: vehicleid,
-	}
-
-	resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request)
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-
-	h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType())
-}
-
 func filterVehicle(r *http.Request, v *fleets.Vehicle) bool {
 	g := r.Context().Value(identification.GroupKey)
 	if g == nil {
@@ -492,3 +467,186 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 //		fmt.Println(vehicles)
 //		h.Renderer.UnbookingVehicles(w, r, vehicles)
 //	}
+func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	bookingid := vars["bookingid"]
+
+	request := &fleets.GetBookingRequest{
+		Bookingid: bookingid,
+	}
+
+	resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	now := time.Now()
+	date := now.Format("2006-01-02")
+	unavailableto, _ := time.Parse("2006-01-02", date)
+
+	current_group, err := h.currentGroup(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	current_user_token, current_user_claims, err := h.currentUser(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	booked_by_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue()
+	booked_by_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue()
+	booked_by_email := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue()
+	booked_by_group_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue()
+	booked_by_group_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue()
+
+	data := map[string]any{
+		"booked_by": map[string]any{
+			"user": map[string]any{
+				"id":           booked_by_id,
+				"display_name": booked_by_name,
+				"email":        booked_by_email,
+			},
+			"group": map[string]any{
+				"id":   booked_by_group_id,
+				"name": booked_by_group_name,
+			},
+		},
+		"unbooked_by": map[string]any{
+			"user": map[string]any{
+				"id":           current_user_token.Subject,
+				"display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+				"email":        current_user_claims["email"],
+			},
+			"group": map[string]any{
+				"id":   current_group.ID,
+				"name": current_group.Data["name"],
+			},
+		},
+		"Deleted": true,
+		"motif":   r.FormValue("motif"),
+	}
+
+	datapb, err := structpb.NewStruct(data)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	if r.Method == "POST" {
+
+		request := &fleets.UpdateBookingRequest{
+			Booking: &fleets.Booking{
+				Id:              resp.Booking.Id,
+				Vehicleid:       resp.Booking.Vehicleid,
+				Driver:          resp.Booking.Driver,
+				Startdate:       resp.Booking.Startdate,
+				Enddate:         resp.Booking.Enddate,
+				Unavailablefrom: resp.Booking.Unavailablefrom,
+				Unavailableto:   timestamppb.New(unavailableto),
+				Data:            datapb,
+			},
+		}
+
+		_, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, "/app/vehicles-management/", http.StatusFound)
+		return
+	}
+	h.Renderer.UnbookingVehicle(w, r, resp.Booking.ToStorageType())
+}
+
+////////////////////////UpdateVehicle///////////////////////
+
+func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	vehicleID := vars["vehicleid"]
+	request := &fleets.GetVehicleRequest{
+		Vehicleid: vehicleID,
+	}
+
+	resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	namespaceV := resp.Vehicle.Namespace
+	//typeV := resp.Vehicle.Type
+	administratorsV := resp.Vehicle.Administrators
+
+	if r.Method == "POST" {
+		fmt.Print(r.FormValue("vehicle_type"))
+		if err := r.ParseForm(); err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		dataMap := map[string]any{}
+		if v := r.FormValue("name"); v != "" {
+			dataMap["name"] = v
+		}
+		if v := r.FormValue("address"); v != "" {
+			var address map[string]any
+			err := json.Unmarshal([]byte(v), &address)
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+			dataMap["address"] = address
+		}
+		if v := r.FormValue("informations"); v != "" {
+			dataMap["informations"] = v
+		}
+		if v := r.FormValue("licence_plate"); v != "" {
+			dataMap["licence_plate"] = v
+		}
+		if v := r.FormValue("automatic"); v != "" {
+			fmt.Println(v)
+			dataMap["automatic"] = (v == "on")
+		}
+
+		data, err := structpb.NewValue(dataMap)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		request := &fleets.UpdateVehicleRequest{
+			Vehicle: &fleets.Vehicle{
+				Id:             vehicleID,
+				Namespace:      namespaceV,
+				Type:           r.FormValue("type"),
+				Administrators: administratorsV,
+				Data:           data.GetStructValue(),
+			},
+		}
+
+		resp, err := h.services.GRPC.Fleets.UpdateVehicle(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", resp.Vehicle.Id), http.StatusFound)
+		return
+	}
+	vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types")
+	h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType(), vehicles_types)
+}

handlers/application/vehicles.go

@@ -26,7 +26,7 @@ import (
 
 func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
-	fmt.Println("invoked")
+
 	var beneficiary mobilityaccountsstorage.Account
 
 	beneficiarydocuments := []filestorage.FileInfo{}

handlers/exports/fleets.go

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

main.go

@@ -19,26 +19,27 @@ import (
 
 func main() {
 	cfg, err := ReadConfig()
-
 	if err != nil {
 		panic(err)
 	}
 
 	var (
-		//address              = cfg.GetString("server.listen")
+		address              = cfg.GetString("server.listen")
 		service_name         = cfg.GetString("service_name")
 		templates_public_dir = cfg.GetString("templates.public_dir")
 		dev_env              = cfg.GetBool("dev_env")
 	)
+
 	svc, err := services.NewServicesHandler(cfg)
 	if err != nil {
 		panic(err)
 	}
-	fmt.Println(cfg)
+
 	kv, err := cache.NewKVHandler(cfg)
 	if err != nil {
 		panic(err)
 	}
+
 	filestorage, err := cache.NewFileStorage(cfg)
 
 	idp, err := identification.NewIdentificationProvider(cfg, svc, kv)
@@ -107,6 +108,9 @@ func main() {
 	application.HandleFunc("/vehicles-management/bookings/", applicationHandler.VehiclesManagementBookingsList)
 	application.HandleFunc("/vehicles-management/bookings/{bookingid}", applicationHandler.VehicleManagementBookingDisplay)
 	application.HandleFunc("/vehicles-management/bookings/{bookingid}/change-vehicle", applicationHandler.VehicleManagementBookingChangeVehicle)
+	/////////////////////////////////////Remove booking vehicle/////////////////////////////////////////
+	application.HandleFunc("/vehicles-management/bookings/{bookingid}/delete", applicationHandler.UnbookingVehicle)
+	////////////////////////////////////////////////////////////////////////////////////////////////////
 	application.HandleFunc("/vehicles-management/bookings/{bookingid}/documents/{document}", applicationHandler.BookingDocumentDownload)
 	application.HandleFunc("/agenda/", applicationHandler.AgendaHome)
 	application.HandleFunc("/agenda/history", applicationHandler.AgendaHistory)
@@ -162,14 +166,17 @@ func main() {
 
 	export := r.PathPrefix("/exports").Subrouter()
 	export.HandleFunc("/fleets/bookings", exportsHandler.Bookings)
+	export.HandleFunc("/fleets/bookings/{groupid}", exportsHandler.Bookings)
 	export.HandleFunc("/agenda/subscriptions", exportsHandler.Agenda("allEvents"))
 	export.HandleFunc("/agenda/{eventid}", exportsHandler.Agenda("oneEvent"))
 	export.Use(idp.Middleware)
 	export.Use(idp.GroupsMiddleware)
 
+	fmt.Println("-> HTTP server listening on", address)
+
 	srv := &http.Server{
 		Handler:      r,
-		Addr:         "0.0.0.0:8000",
+		Addr:         address,
 		WriteTimeout: 15 * time.Second,
 		ReadTimeout:  15 * time.Second,
 	}

renderer/beneficiaries.go

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

renderer/vehicle-management.go

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

utils/storage/badger.go

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

utils/storage/etcd.go

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

utils/storage/kv.go

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