sending mail to the prescripteur when beneficiary is delete

go.mod

@@ -8,7 +8,7 @@ replace git.coopgo.io/coopgo-platform/groups-management => ../../coopgo-platform
 
 // 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/
 

handlers/application/administration.go

@@ -11,6 +11,8 @@ import (
 	"time"
 
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
+	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
+	"git.coopgo.io/coopgo-platform/fleets/storage"
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
 	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
@@ -331,6 +333,31 @@ func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWrit
 	return
 }
 
+func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Request) {
+
+	request := &fleets.GetBookingsRequest{}
+	resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	bookings := []storage.Booking{}
+
+	for _, b := range resp.Bookings {
+		booking := b.ToStorageType()
+		bookings = append(bookings, booking)
+	}
+
+	sort.Sort(sorting.BookingsByStartdate(bookings))
+
+	vehicles, _ := h.services.GetVehiclesMap()
+	groups, _ := h.services.GetGroupsMap()
+
+	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
+}
+
 func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
 	resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), &accounts.GetAccountsRequest{
 		Namespaces: []string{"parcoursmob"},

handlers/application/agenda.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"sort"
 	"strconv"
+	"strings"
 	"time"
 
 	formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators"
@@ -107,6 +108,7 @@ func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Re
 				Allday:         eventForm.Allday,
 				MaxSubscribers: int64(eventForm.MaxSubscribers),
 				Data:           data,
+				Deleted:        false,
 			},
 		}
 
@@ -119,7 +121,7 @@ func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Re
 		}
 
 		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", resp.Event.Id), http.StatusFound)
-
+		return
 	}
 	h.Renderer.AgendaCreateEvent(w, r)
 }
@@ -225,13 +227,13 @@ func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
-
 	subscriber := r.FormValue("subscriber")
 	data := map[string]any{
 		"subscribed_by": map[string]any{
 			"user": map[string]any{
 				"id":           current_user_token.Subject,
-				"display_name": current_user_claims["display_name"],
+				"display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+				"email":        current_user_claims["email"].(string),
 			},
 			"group": map[string]any{
 				"id":   current_group.ID,
@@ -330,11 +332,322 @@ func contains(s []*agenda.Subscription, e string) bool {
 	return false
 }
 
-// func contains[V string](s []V, e V) bool {
-// 	for _, a := range s {
-// 		if a == e {
-// 			return true
-// 		}
-// 	}
-// 	return false
-// }
+///////////////////////////////Update Event/////////////////////////////////////////
+func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Request) {
+	adm := strings.Split(r.URL.Path, "/")
+	eventID := adm[3]
+	request := &agenda.GetEventRequest{
+		Id: eventID,
+	}
+
+	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	if r.Method == "POST" {
+		g := r.Context().Value(identification.GroupKey)
+		if g == nil {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+
+		group := g.(storage.Group)
+
+		eventForm, err := parseEventsForm(r)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+
+		data, _ := structpb.NewStruct(map[string]any{
+			"address": eventForm.Address,
+		})
+
+		request := &agenda.UpdateEventRequest{
+			Event: &agenda.Event{
+				Namespace:      "parcoursmob_dispositifs",
+				Id:             eventID,
+				Owners:         []string{group.ID},
+				Type:           eventForm.Type,
+				Name:           eventForm.Name,
+				Description:    eventForm.Description,
+				Startdate:      timestamppb.New(*eventForm.Startdate),
+				Enddate:        timestamppb.New(*eventForm.Enddate),
+				Starttime:      eventForm.Starttime,
+				Endtime:        eventForm.Endtime,
+				Allday:         eventForm.Allday,
+				MaxSubscribers: int64(eventForm.MaxSubscribers),
+				Data:           data,
+				Subscriptions:  resp.Event.Subscriptions,
+			},
+		}
+
+		resp, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", resp.Event.Id), http.StatusFound)
+		return
+	}
+	h.Renderer.AgendaUpdateEvent(w, r, resp.Event.ToStorageType())
+}
+
+func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Request) {
+
+	vars := mux.Vars(r)
+	eventID := vars["eventid"]
+	request := &agenda.GetEventRequest{
+		Id: eventID,
+	}
+
+	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	if r.Method == "POST" {
+
+		request := &agenda.UpdateEventRequest{
+			Event: &agenda.Event{
+				Namespace:      resp.Event.Namespace,
+				Id:             resp.Event.Id,
+				Owners:         resp.Event.Owners,
+				Type:           resp.Event.Type,
+				Name:           resp.Event.Name,
+				Description:    resp.Event.Description,
+				Startdate:      resp.Event.Startdate,
+				Enddate:        resp.Event.Enddate,
+				Starttime:      resp.Event.Starttime,
+				Endtime:        resp.Event.Endtime,
+				Allday:         resp.Event.Allday,
+				MaxSubscribers: int64(resp.Event.MaxSubscribers),
+				Data:           resp.Event.Data,
+				Subscriptions:  resp.Event.Subscriptions,
+				Deleted:        true,
+			},
+		}
+
+		_, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, "/app/agenda/", http.StatusFound)
+		return
+	}
+	h.Renderer.AgendaDeleteEvent(w, r, resp.Event.ToStorageType())
+}
+
+///////////////////////////Delete subscriber///////////////////////////////
+func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	eventId := vars["eventid"]
+	subscribeid := vars["subscribeid"]
+	s_b_id := ""
+	s_b_name := ""
+	s_b_email := ""
+	s_b_group_id := ""
+	s_b_group_name := ""
+	request := &agenda.GetEventRequest{
+		Id: eventId,
+	}
+
+	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	for i := range resp.Event.Subscriptions {
+		if resp.Event.Subscriptions[i].Subscriber == subscribeid {
+			subscribed_by_id := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue()
+			subscribed_by_name := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue()
+			subscribed_by_email := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue()
+			subscribed_by_group_id := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue()
+			subscribed_by_group_name := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue()
+			s_b_id = subscribed_by_id
+			s_b_name = subscribed_by_name
+			s_b_email = subscribed_by_email
+			s_b_group_id = subscribed_by_group_id
+			s_b_group_name = subscribed_by_group_name
+		}
+	}
+
+	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
+	}
+
+	data := map[string]any{
+		"subscribed_by": map[string]any{
+			"user": map[string]any{
+				"id":           s_b_id,
+				"display_name": s_b_name,
+				"email":        s_b_email,
+			},
+			"group": map[string]any{
+				"id":   s_b_group_id,
+				"name": s_b_group_name,
+			},
+		},
+		"unsubscribed_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"],
+			},
+		},
+		"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 := &agenda.DeleteSubscriptionRequest{
+			Subscriber: subscribeid,
+			Eventid:    eventId,
+			Data:       datapb,
+		}
+
+		data := map[string]any{
+			"motif":  r.FormValue("motif"),
+			"user": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+			"subscriber": fmt.Sprintf("http://localhost:9000/app/beneficiaries/%s", subscribeid),
+			"link": fmt.Sprintf("http://localhost:9000/app/agenda/%s", eventId),
+		}
+
+		// récupérer l'adresse mail de l'utilisateur qui a créé l'événement
+		mail := s_b_email
+		fmt.Println(mail)
+
+		_, err := h.services.GRPC.Agenda.DeleteSubscription(context.TODO(), request)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		if err := h.emailing.Send("delete_subscriber.request", mail, data); err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventId), http.StatusFound)
+		return
+	}
+	h.Renderer.AgendaDeleteSubscribeEvent(w, r, eventId)
+}
+
+////////////////////////////////////////////////////////
+// /////////////////////History Event////////////////////////
+func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	eventId := vars["eventid"]
+	request := &agenda.GetEventRequest{
+		Id: eventId,
+	}
+
+	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	grouprequest := &groupsmanagement.GetGroupRequest{
+		Id: resp.Event.Owners[0],
+	}
+
+	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	subscribers := map[string]any{}
+
+	accids := []string{}
+	for _, v := range resp.Event.DeletedSubscription {
+		accids = append(accids, v.Subscriber)
+	}
+
+	subscriberresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(
+		context.TODO(),
+		&mobilityaccounts.GetAccountsBatchRequest{
+			Accountids: accids,
+		},
+	)
+
+	if err == nil {
+		for _, sub := range subscriberresp.Accounts {
+			subscribers[sub.Id] = sub.ToStorageType()
+		}
+	}
+
+	g := r.Context().Value(identification.GroupKey)
+	if g == nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	group := g.(storage.Group)
+
+	accountids := []string{}
+	for _, m := range group.Members {
+		if !contains(resp.Event.DeletedSubscription, m) {
+			accountids = append(accountids, m)
+		}
+	}
+
+	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(
+		context.TODO(),
+		&mobilityaccounts.GetAccountsBatchRequest{
+			Accountids: accountids,
+		},
+	)
+
+	accounts := []any{}
+
+	if err == nil {
+		for _, acc := range accountresp.Accounts {
+			accounts = append(accounts, acc)
+		}
+	}
+
+	h.Renderer.AgendaHistoryEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), subscribers, accounts)
+}

handlers/application/beneficiaries.go

@@ -61,6 +61,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")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}

handlers/application/journeys.go

@@ -5,14 +5,26 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"sort"
+	"strconv"
+	"strings"
 	"time"
 
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
+	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"
+	"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/structpb"
 )
 
+var Depart any
+var Arrive any
+
 func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
 
@@ -144,3 +156,413 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
 
 	h.Renderer.JourneysSearch(w, r, carpoolresults, journeys, vehicles, searched, departuregeo, destinationgeo, departuredate, departuretime)
 }
+
+type GroupsModule []groupstorage.Group
+
+func (a GroupsModule) Len() int { return len(a) }
+func (a GroupsModule) Less(i, j int) bool {
+	return strings.Compare(a[i].Data["name"].(string), a[j].Data["name"].(string)) < 0
+}
+func (a GroupsModule) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+func (h *ApplicationHandler) GroupsGestion(w http.ResponseWriter, r *http.Request) {
+
+	request := &groupsmanagement.GetGroupsRequest{
+		Namespaces: []string{"parcoursmob_groups_covoiturage"},
+	}
+
+	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)
+	}
+
+	cacheid := uuid.NewString()
+
+	sort.Sort(GroupsModule(groups))
+	h.cache.PutWithTTL(cacheid, groups, 1*time.Hour)
+
+	h.Renderer.GroupsGestion(w, r, groups, cacheid)
+}
+func filterAcc(r *http.Request, a *mobilityaccounts.Account) bool {
+	searchFilter, ok := r.URL.Query()["search"]
+
+	if ok && len(searchFilter[0]) > 0 {
+		name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string)
+		if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter[0])) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request) {
+
+	var beneficiary any
+	var (
+		departurgeo   *geojson.Feature
+		dstinationgeo *geojson.Feature
+	)
+	searched := false
+
+	if r.FormValue("beneficiaryid") != "" {
+
+		searched = true
+
+		requestbeneficiary := &mobilityaccounts.GetAccountRequest{
+			Id: r.FormValue("beneficiaryid"),
+		}
+
+		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		beneficiary = respbeneficiary.Account.ToStorageType()
+
+		if r.Method == "POST" {
+			departure := r.FormValue("departure")
+			destination := r.FormValue("destination")
+
+			if departure != "" && destination != "" {
+
+				var err error
+
+				departurgeo, err = geojson.UnmarshalFeature([]byte(departure))
+				if err != nil {
+					fmt.Println(err)
+					w.WriteHeader(http.StatusBadRequest)
+					return
+				}
+
+				dstinationgeo, err = geojson.UnmarshalFeature([]byte(destination))
+				if err != nil {
+					fmt.Println(err)
+					w.WriteHeader(http.StatusBadRequest)
+					return
+				}
+			}
+			if r.FormValue("departure") != "" {
+				var a any
+				json.Unmarshal([]byte(r.FormValue("departure")), &a)
+
+				Depart = a
+			}
+			if r.FormValue("destination") != "" {
+				var a any
+				json.Unmarshal([]byte(r.FormValue("destination")), &a)
+
+				Arrive = a
+			}
+			r.ParseForm()
+
+			if r.FormValue("name") == "" {
+
+				fmt.Println("invalid name")
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+
+			if r.FormValue("number") == "" {
+
+				fmt.Println("invalid number of personne")
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+
+			planDays := map[string]any{
+				"lundi":    r.FormValue("lundi") == "on",
+				"mardi":    r.FormValue("mardi") == "on",
+				"mercredi": r.FormValue("mercredi") == "on",
+				"jeudi":    r.FormValue("jeudi") == "on",
+				"vendredi": r.FormValue("vendredi") == "on",
+				"samedi":   r.FormValue("samedi") == "on",
+				"dimanche": r.FormValue("dimanche") == "on",
+			}
+
+			groupidd := uuid.NewString()
+
+			dataMap := map[string]any{
+				"name":              r.FormValue("name"),
+				"number":            r.FormValue("number"),
+				"driver_first_name": respbeneficiary.Account.ToStorageType().Data["first_name"],
+				"driver_last_name":  respbeneficiary.Account.ToStorageType().Data["last_name"],
+				"depart":            Depart,
+				"arrive":            Arrive,
+				"departdate":        r.FormValue("departdate"),
+				"date":              r.FormValue("date"),
+				"enddate":           r.FormValue("enddate"),
+				"departtime":        r.FormValue("departtime"),
+				"time":              r.FormValue("time"),
+
+				"planDays":  planDays,
+				"recurrent": r.FormValue("recurrent"),
+				"pontuelle": r.FormValue("ponctuelle"),
+			}
+
+			data, err := structpb.NewValue(dataMap)
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			request_organization := &groupsmanagement.AddGroupRequest{
+				Group: &groupsmanagement.Group{
+					Id:        groupidd,
+					Namespace: "parcoursmob_groups_covoiturage",
+					Data:      data.GetStructValue(),
+				},
+			}
+
+			_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
+			if err != nil {
+				fmt.Println(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", request_organization.Group.ToStorageType().ID), http.StatusFound)
+
+			return
+		}
+	}
+	accountsBeneficaire, err := h.beneficiaries(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	h.Renderer.CreateGroup(w, r, Depart, Arrive, searched, beneficiary, accountsBeneficaire, departurgeo, dstinationgeo)
+
+}
+
+func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	groupid := vars["groupid"]
+
+	request := &groupsmanagement.GetGroupRequest{
+		Id: groupid,
+	}
+
+	resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	var accounts = []any{}
+
+	requesst := &mobilityaccounts.GetAccountsBatchRequest{
+		Accountids: resp.Group.Members,
+	}
+
+	ressp, _ := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), requesst)
+
+	for _, account := range ressp.Accounts {
+		if filterAcc(r, account) {
+			a := account.ToStorageType()
+			accounts = append(accounts, a)
+		}
+	}
+
+	cacheid := uuid.NewString()
+	h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
+	r.ParseForm()
+
+	var beneficiary any
+	searched := false
+
+	if r.FormValue("beneficiaryid") != "" {
+
+		searched = true
+
+		requestbeneficiary := &mobilityaccounts.GetAccountRequest{
+			Id: r.FormValue("beneficiaryid"),
+		}
+
+		respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		beneficiary = respbeneficiary.Account.ToStorageType()
+
+		subscribe := &groupsmanagement.SubscribeRequest{
+			Groupid:  resp.Group.ToStorageType().ID,
+			Memberid: respbeneficiary.Account.Id,
+		}
+
+		_, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe)
+
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		/*******************Code to store more information about mermbers groupscovoiturage**************/
+		if r.FormValue("departure") != "" {
+			var a any
+			json.Unmarshal([]byte(r.FormValue("departure")), &a)
+
+			Depart = a
+		}
+		if r.FormValue("destination") != "" {
+			var a any
+			json.Unmarshal([]byte(r.FormValue("destination")), &a)
+
+			Arrive = a
+		}
+		r.ParseForm()
+		dataMap := map[string]any{
+
+			"depart": Depart,
+			"arrive": Arrive,
+		}
+		id := uuid.NewString()
+		data, err := structpb.NewValue(dataMap)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		request_organizatio := &groupsmanagement.AddGroupMemberRequest{
+			Group: &groupsmanagement.GroupMember{
+				Id:       id,
+				Memberid: respbeneficiary.Account.Id,
+				Groupid:  resp.Group.ToStorageType().ID,
+				Data:     data.GetStructValue(),
+			},
+		}
+
+		_, err = h.services.GRPC.GroupsManagement.AddGroupMember(context.TODO(), request_organizatio)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", resp.Group.ToStorageType().ID), http.StatusFound)
+		return
+	}
+	//////////find all groups to store the adresse passenger///////
+	// grp := &groupsmanagement.GetGroupsBatchMemberRequest{
+
+	// 	Groupids: []string{resp.Group.ToStorageType().ID},
+	// }
+	// s, err := h.services.GRPC.GroupsManagement.GetGroupsBatchMember(context.TODO(), grp)
+	// if err != nil {
+	// 	fmt.Println(err)
+	// 	w.WriteHeader(http.StatusInternalServerError)
+	// 	return
+	// }
+	// groups := map[string]any{}
+
+	// if err == nil {
+	// 	for _, g := range s.Groups {
+	// 		groups[g.Memberid] = g.ToStorageType()
+	// 	}
+	// }
+	//////////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)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	h.Renderer.DisplayGroupCovoiturage(w, r, number, resp.Group.ToStorageType().ID, Depart, Arrive, accounts, cacheid, searched, beneficiary, resp.Group.ToStorageType(), accountsBeneficaire, groups)
+}
+
+func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+	groupid := vars["groupid"]
+	memberid := vars["memberid"]
+
+	if r.Method == "POST" {
+
+		//////////get groupid covoiturage//////////
+		request := &groupsmanagement.GetGroupRequest{
+			Id: groupid,
+		}
+
+		resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		//////////////////////////get group member////////////////////////////////
+
+		reequest := &groupsmanagement.GetGroupMemberRequest{
+			Id: id,
+		}
+
+		ressp, err := h.services.GRPC.GroupsManagement.GetGroupMember(context.TODO(), reequest)
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		req := &groupsmanagement.UnsubscribeMemberRequest{
+			Id: ressp.Group.Id,
+		}
+
+		_, errr := h.services.GRPC.GroupsManagement.UnsubscribeMember(context.TODO(), req)
+		if errr != nil {
+			fmt.Println(errr)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		members := resp.Group.Members
+		for i := 0; i < len(members); i++ {
+			if members[i] == memberid {
+				members = append(members[:i], members[(i+1):]...)
+				resp.Group.Members = members
+				reequest := &groupsmanagement.UnsubscribeRequest{
+					Groupid:  resp.Group.ToStorageType().ID,
+					Memberid: memberid,
+				}
+
+				_, err := h.services.GRPC.GroupsManagement.Unsubscribe(context.TODO(), reequest)
+				if err != nil {
+					fmt.Println(err)
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+			}
+
+		}
+		http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", groupid), http.StatusFound)
+		/*
+		 I must add "return" to resolve the err
+		 http: superfluous response.WriteHeader call from git.coopgo.io/coopgo-apps/parcoursmob/renderer.(*Renderer).Render (renderer.go:50)
+		*/
+		return
+	}
+	h.Renderer.UpdateGroupCovoiturage(w, r, groupid, memberid)
+}

handlers/application/members.go

@@ -16,12 +16,12 @@ type UserForm struct {
 	FirstName   string `json:"first_name" validate:"required"`
 	LastName    string `json:"last_name" validate:"required"`
 	Email       string `json:"email" validate:"required,email"`
-	PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"`
+	PhoneNumber string `json:"phone_number" `
 	Address     any    `json:"address,omitempty"`
 	Gender      string `json:"gender"`
 }
 
-func (h *ApplicationHandler) ConseillerDisplay(w http.ResponseWriter, r *http.Request) {
+func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Request) {
 
 	adm := strings.Split(r.URL.Path, "/")
 	adminid := adm[3]
@@ -37,10 +37,10 @@ func (h *ApplicationHandler) ConseillerDisplay(w http.ResponseWriter, r *http.Re
 		return
 	}
 
-	h.Renderer.ConseillerDisplay(w, r, resp.Account.ToStorageType())
+	h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType())
 }
 
-func (h *ApplicationHandler) ConseillerUpdate(w http.ResponseWriter, r *http.Request) {
+func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request) {
 	adm := strings.Split(r.URL.Path, "/")
 	userID := adm[3]
 
@@ -76,7 +76,7 @@ func (h *ApplicationHandler) ConseillerUpdate(w http.ResponseWriter, r *http.Req
 			return
 		}
 
-		http.Redirect(w, r, fmt.Sprintf("/app/profile/%s", resp.Account.Id), http.StatusFound)
+		http.Redirect(w, r, fmt.Sprintf("/app/members/%s", resp.Account.Id), http.StatusFound)
 
 		return
 	}
@@ -92,7 +92,7 @@ func (h *ApplicationHandler) ConseillerUpdate(w http.ResponseWriter, r *http.Req
 		return
 	}
 
-	h.Renderer.ConseillerUpdate(w, r, resp.Account.ToStorageType())
+	h.Renderer.MemberUpdate(w, r, resp.Account.ToStorageType())
 }
 
 func parseUserForm(r *http.Request) (map[string]any, error) {

handlers/application/vehicles.go

@@ -136,14 +136,7 @@ func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Reques
 }
 
 func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
-	// Get Group
-	// g := r.Context().Value(identification.GroupKey)
-	// if g == nil {
-	// 	fmt.Println("no current group")
-	// 	w.WriteHeader(http.StatusInternalServerError)
-	// 	return
-	// }
-	// current_group := g.(storage.Group)
+	fmt.Println("Book")
 	current_group, err := h.currentGroup(r)
 	if err != nil {
 		fmt.Println(err)
@@ -151,24 +144,6 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Get current user ID
-	// u := r.Context().Value(identification.IdtokenKey)
-	// if u == nil {
-	// 	fmt.Println("no current user")
-	// 	w.WriteHeader(http.StatusInternalServerError)
-	// 	return
-	// }
-	// current_user_token := u.(*oidc.IDToken)
-
-	// // Get current user claims
-	// c := r.Context().Value(identification.ClaimsKey)
-	// if c == nil {
-	// 	fmt.Println("no current user claims")
-	// 	w.WriteHeader(http.StatusInternalServerError)
-	// 	return
-	// }
-	// current_user_claims := c.(map[string]any)
-
 	current_user_token, current_user_claims, err := h.currentUser(r)
 	if err != nil {
 		fmt.Println(err)
@@ -191,7 +166,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	r.ParseMultipartForm(10 * 1024 * 1024)
+	r.ParseMultipartForm(100 * 1024 * 1024)
 
 	start := r.FormValue("startdate")
 	end := r.FormValue("enddate")
@@ -203,7 +178,7 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		"booked_by": map[string]any{
 			"user": map[string]any{
 				"id":           current_user_token.Subject,
-				"display_name": current_user_claims["display_name"],
+				"display_name": fmt.Sprintf("%s %s", current_user_claims["first_name"], current_user_claims["last_name"]),
 			},
 			"group": map[string]any{
 				"id":   current_group.ID,
@@ -233,7 +208,6 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		Booking: booking,
 	}
 
-	fmt.Println(r.FormFile("doc-identity_proof"))
 	for _, v := range h.config.GetStringSlice("modules.fleets.booking_documents.mandatory") {
 		existing_file := r.FormValue("type-" + v)
 		if existing_file == "" {
@@ -282,9 +256,11 @@ func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) {
 		fmt.Println(err)
 	} else {
 		for _, m := range members {
-			h.emailing.Send("fleets.bookings.creation_admin_alert", m.Data["email"].(string), map[string]string{
-				"bookingid": booking.Id,
-			})
+			if email, ok := m.Data["email"].(string); ok {
+				h.emailing.Send("fleets.bookings.creation_admin_alert", email, map[string]string{
+					"bookingid": booking.Id,
+				})
+			}
 		}
 	}
 
@@ -314,9 +290,9 @@ func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http
 
 	beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), beneficiaryrequest)
 	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
+		beneficiaryresp = &mobilityaccounts.GetAccountResponse{
+			Account: &mobilityaccounts.Account{},
+		}
 	}
 
 	grouprequest := &groupsmanagement.GetGroupRequest{
@@ -370,7 +346,10 @@ func (h ApplicationHandler) VehiclesBookingsList(w http.ResponseWriter, r *http.
 
 	sort.Sort(sorting.BookingsByStartdate(bookings))
 
-	h.Renderer.VehicleBookingsList(w, r, bookings)
+	vehicles, _ := h.services.GetVehiclesMap()
+	groups, _ := h.services.GetGroupsMap()
+
+	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
 }
 
 func (h *ApplicationHandler) BookingDocumentDownload(w http.ResponseWriter, r *http.Request) {

handlers/auth/disconnect.go

@@ -0,0 +1,13 @@
+package auth
+
+import "net/http"
+
+func (h *AuthHandler) Disconnect(w http.ResponseWriter, r *http.Request) {
+	session, err := h.idp.SessionsStore.Get(r, "parcoursmob_session")
+	if err == nil {
+		session.Options.MaxAge = -1
+		session.Save(r, w)
+	}
+
+	http.Redirect(w, r, "/", http.StatusOK)
+}

handlers/auth/onboarding.go

@@ -37,7 +37,7 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
 		if onboardingmap["admin"].(bool) {
 			groups = append(groups, onboardingmap["group"].(string)+":admin")
 		}
-
+		display_name := fmt.Sprint(r.FormValue("first_name")) + " " + fmt.Sprint(r.FormValue("last_name"))
 		account := &ma.Account{
 			Authentication: ma.AccountAuth{
 				Local: ma.LocalAuth{
@@ -46,11 +46,13 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
 				},
 			},
 			Namespace: "parcoursmob",
+
 			Data: map[string]any{
-				"first_name": r.FormValue("first_name"),
-				"last_name":  r.FormValue("last_name"),
-				"email":      onboardingmap["username"],
-				"groups":     groups,
+				"display_name": display_name,
+				"first_name":   r.FormValue("first_name"),
+				"last_name":    r.FormValue("last_name"),
+				"email":        onboardingmap["username"],
+				"groups":       groups,
 			},
 		}
 

main.go

@@ -61,6 +61,7 @@ func main() {
 	r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir(templates_public_dir))))
 
 	r.HandleFunc("/auth/onboarding", authHandler.Onboarding)
+	r.HandleFunc("/auth/disconnect", authHandler.Disconnect)
 	r.HandleFunc("/auth/lost-password", authHandler.LostPasswordInit)
 	r.HandleFunc("/auth/lost-password/recover", authHandler.LostPasswordRecover)
 	r.HandleFunc("/auth/groups/", authHandler.Groups)
@@ -84,6 +85,8 @@ func main() {
 	application.HandleFunc("/beneficiaries/{beneficiaryid}/documents/{document}", applicationHandler.BeneficiaryDocumentDownload)
 	application.HandleFunc("/beneficiaries/{beneficiaryid}/picture", applicationHandler.BeneficiaryPicture)
 	application.HandleFunc("/members/{beneficiaryid}/picture", applicationHandler.BeneficiaryPicture)
+	application.HandleFunc("/members/{adminid}", applicationHandler.MemberDisplay)
+	application.HandleFunc("/members/{adminid}/update", applicationHandler.MemberUpdate)
 	application.HandleFunc("/journeys/", applicationHandler.JourneysSearch)
 	application.HandleFunc("/vehicles/", applicationHandler.VehiclesSearch)
 	application.HandleFunc("/vehicles/bookings/", applicationHandler.VehiclesBookingsList)
@@ -101,6 +104,11 @@ func main() {
 	application.HandleFunc("/agenda/", applicationHandler.AgendaHome)
 	application.HandleFunc("/agenda/create-event", applicationHandler.AgendaCreateEvent)
 	application.HandleFunc("/agenda/{eventid}", applicationHandler.AgendaDisplayEvent)
+	///////////////////////////////Code to modify event///////////////////////
+	application.HandleFunc("/agenda/{eventid}/update", applicationHandler.AgendaUpdateEvent)
+	application.HandleFunc("/agenda/{eventid}/delete", applicationHandler.AgendaDeleteEvent)
+
+	/////////////////////////////////////////////////////
 	application.HandleFunc("/agenda/{eventid}/subscribe", applicationHandler.AgendaSubscribeEvent)
 	application.HandleFunc("/directory/", applicationHandler.DirectoryHome)
 
@@ -108,9 +116,10 @@ func main() {
 	application.HandleFunc("/group/settings/invite-member", applicationHandler.GroupSettingsInviteMember)
 
 	/****************************Groupe Déplacement ************************************/
-	// application.HandleFunc("/journeys/groups_covoiturage", applicationHandler.GroupsGestion)
-	// application.HandleFunc("/journeys/groups_covoiturage/create", applicationHandler.CreateGroup)
-	// application.HandleFunc("/journeys/groups_covoiturage/create/{groupid}", applicationHandler.DisplayGroupCovoiturage)
+	application.HandleFunc("/journeys/groups_covoiturage", applicationHandler.GroupsGestion)
+	application.HandleFunc("/journeys/groups_covoiturage/create", applicationHandler.CreateGroup)
+	application.HandleFunc("/journeys/groups_covoiturage/create/{groupid}", applicationHandler.DisplayGroupCovoiturage)
+	application.HandleFunc("/journeys/groups_covoiturage/create/{id}/{groupid}/{memberid}", applicationHandler.UpdateGroupCovoiturage)
 	/****************************************************************/
 
 	/********************Code Supprt Emailing************************/
@@ -132,12 +141,12 @@ func main() {
 	appAdmin.HandleFunc("/groups/{groupid}", applicationHandler.AdministrationGroupDisplay)
 	appAdmin.HandleFunc("/groups/{groupid}/invite-admin", applicationHandler.AdministrationGroupInviteAdmin)
 	appAdmin.HandleFunc("/groups/{groupid}/invite-member", applicationHandler.AdministrationGroupInviteMember)
+	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
 
-	///////////////////////////code page profile of admin ///////////////////////////
-	application.HandleFunc("/profile/{adminid}", applicationHandler.ConseillerDisplay)
-	application.HandleFunc("/profile/{adminid}/update", applicationHandler.ConseillerUpdate)
-	//TODO Secure with Middleware checking for modules
-
+	/////////////////////////////////////Delete subscriber///////////////////////////////////////////////
+	application.HandleFunc("/agenda/{eventid}/{subscribeid}/delete", applicationHandler.AgendaDeleteSubscribeEvent)
+	application.HandleFunc("/agenda/{eventid}/history", applicationHandler.AgendaHistoryEvent)
+	/////////////////////////////////////////////////////////////////////////////////////////////////////
 	fmt.Println("-> HTTP server listening on", address)
 
 	srv := &http.Server{

renderer/agenda.go

@@ -29,6 +29,7 @@ func (renderer *Renderer) AgendaCreateEvent(w http.ResponseWriter, r *http.Reque
 func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Request, event any, group 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,
@@ -38,3 +39,53 @@ func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Requ
 
 	renderer.Render("agenda create event", w, r, files, state)
 }
+
+//////////////////////////DElete subscriber//////////////////////////////////
+func (renderer *Renderer) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request, eventid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.delete_subscriber.files")
+	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+	state.ViewState = map[string]any{
+		"eventid": eventid,
+	}
+
+	renderer.Render("agenda delete subscriber", w, r, files, state)
+}
+
+//////////////////////////////////////////////////////////
+
+//////////////////////////History Event//////////////////////////////////
+func (renderer *Renderer) AgendaHistoryEvent(w http.ResponseWriter, r *http.Request, event any, group any, subscribers map[string]any, beneficiaries any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.history_event.files")
+	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+	state.ViewState = map[string]any{
+		"event":         event,
+		"group":         group,
+		"subscribers":   subscribers,
+		"beneficiaries": beneficiaries,
+	}
+
+	renderer.Render("agenda history event", w, r, files, state)
+}
+
+////////////////////////////////////////////////////////////////////////
+func (renderer *Renderer) AgendaUpdateEvent(w http.ResponseWriter, r *http.Request, event any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.update.files")
+	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+
+	state.ViewState = map[string]any{
+		"event": event,
+	}
+
+	renderer.Render("event_update", w, r, files, state)
+}
+
+func (renderer *Renderer) AgendaDeleteEvent(w http.ResponseWriter, r *http.Request, event any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.delete.files")
+	state := NewState(r, renderer.ThemeConfig, agendaMenu)
+
+	state.ViewState = map[string]any{
+		"event": event,
+	}
+
+	renderer.Render("event_deleteEvent", w, r, files, state)
+}

renderer/conseillers.go

@@ -1,24 +0,0 @@
-package renderer
-
-import (
-	"net/http"
-)
-
-const conseillersMenu = "conseillers"
-
-func (renderer *Renderer) ConseillerDisplay(w http.ResponseWriter, r *http.Request, admins any) {
-	files := renderer.ThemeConfig.GetStringSlice("views.conseillers.display.files")
-
-	state := NewState(r, renderer.ThemeConfig, conseillersMenu)
-	state.ViewState = map[string]any{
-		"admins": admins,
-	}
-	renderer.Render("conseillers_list", w, r, files, state)
-}
-
-func (renderer *Renderer) ConseillerUpdate(w http.ResponseWriter, r *http.Request, user any) {
-	files := renderer.ThemeConfig.GetStringSlice("views.conseillers.update.files")
-	state := NewState(r, renderer.ThemeConfig, conseillersMenu)
-	state.ViewState = user
-	renderer.Render("conseillers_update", w, r, files, state)
-}

renderer/journeys.go

@@ -1,9 +1,40 @@
 package renderer
 
-import "net/http"
+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"
+)
 
 const journeysMenu = "journeys"
 
+type BeneficiariesCovoiturage struct {
+	Group         string `json:"group"`
+	Count         int    `json:"count"`
+	CacheId       string `json:"cache_id"`
+	Beneficiaries []any  `json:"beneficiaries"`
+}
+type BeneficiariesCovoiturageA struct {
+	Count         int    `json:"count"`
+	CacheId       string `json:"cache_id"`
+	Beneficiaries []any  `json:"beneficiaries"`
+}
+
+func (s BeneficiariesCovoiturage) JSON() template.JS {
+	result, _ := json.Marshal(s)
+	return template.JS(result)
+}
+
+func (s BeneficiariesCovoiturage) JSONWithLimits(a int, b int) template.JS {
+	if b < len(s.Beneficiaries) {
+		s.Beneficiaries = s.Beneficiaries[a:b]
+	}
+	return s.JSON()
+}
+
 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)
@@ -20,3 +51,100 @@ func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request,
 
 	renderer.Render("journeys", w, r, files, state)
 }
+
+type BeneficiariesListstate struct {
+	Count         int                  `json:"count"`
+	CacheId       string               `json:"cache_id"`
+	Beneficiaries []groupstorage.Group `json:"beneficiaries"`
+}
+
+func (s BeneficiariesListstate) JSON() template.JS {
+	result, _ := json.Marshal(s)
+	return template.JS(result)
+}
+
+func (s BeneficiariesListstate) JSONWithLimits(a int, b int) template.JS {
+	if b < len(s.Beneficiaries) {
+		s.Beneficiaries = s.Beneficiaries[a:b]
+	}
+	return s.JSON()
+}
+func (renderer *Renderer) GroupsGestion(w http.ResponseWriter, r *http.Request, groups []groupstorage.Group, cacheid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.journeys.list.files")
+	state := NewState(r, renderer.ThemeConfig, journeysMenu)
+
+	state.ViewState = BeneficiariesListstate{
+		Count:         len(groups),
+		CacheId:       cacheid,
+		Beneficiaries: groups,
+	}
+
+	renderer.Render("journeys", w, r, files, state)
+}
+
+func (renderer *Renderer) CreateGroup(w http.ResponseWriter, r *http.Request, depart any, arrive any, searched bool, beneficiary any, beneficiaries []mobilityaccountsstorage.Account, departure any, destination any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.journeys.create.files")
+	state := NewState(r, renderer.ThemeConfig, journeysMenu)
+	viewstate := map[string]any{
+		"deeparture":    depart,
+		"deestination":  arrive,
+		"beneficiaries": beneficiaries,
+		"searched":      searched,
+		"departure":     departure,
+		"destination":   destination,
+	}
+
+	if searched {
+		viewstate["search"] = map[string]any{
+			"beneficiary": beneficiary,
+		}
+
+	}
+
+	state.ViewState = viewstate
+	renderer.Render("journeys", w, r, files, state)
+}
+
+func (renderer *Renderer) DisplayGroupCovoiturage(w http.ResponseWriter, r *http.Request, number string, groupid string, depart any, arrive any, accounts []any, cacheid string, searched bool, beneficiary any, group any, beneficiaries []mobilityaccountsstorage.Account, groups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.journeys.display.files")
+	state := NewState(r, renderer.ThemeConfig, journeysMenu)
+
+	viewstate := map[string]any{
+		"beneficiaries": beneficiaries,
+		"searched":      searched,
+		"group":         group,
+		"deeparture":    depart,
+		"deestination":  arrive,
+		"groups":        groups,
+		"ben":           accounts,
+		"number":        number,
+		"list": BeneficiariesCovoiturage{
+			Group:         groupid,
+			Count:         len(accounts),
+			CacheId:       cacheid,
+			Beneficiaries: accounts,
+		},
+	}
+
+	if searched {
+		viewstate["search"] = map[string]any{
+			"beneficiary": beneficiary,
+		}
+
+	}
+	state.ViewState = viewstate
+
+	renderer.Render("journeys", w, r, files, state)
+}
+
+func (renderer *Renderer) UpdateGroupCovoiturage(w http.ResponseWriter, r *http.Request, groupid string, memberid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.journeys.update.files")
+	state := NewState(r, renderer.ThemeConfig, journeysMenu)
+
+	state.ViewState = map[string]any{
+		"groupid":  groupid,
+		"memberid": memberid,
+	}
+	renderer.Render("journeys", w, r, files, state)
+
+}

renderer/members.go

@@ -0,0 +1,24 @@
+package renderer
+
+import (
+	"net/http"
+)
+
+const membersMenu = "members"
+
+func (renderer *Renderer) MemberDisplay(w http.ResponseWriter, r *http.Request, admins any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.members.display.files")
+
+	state := NewState(r, renderer.ThemeConfig, membersMenu)
+	state.ViewState = map[string]any{
+		"admins": admins,
+	}
+	renderer.Render("members_list", w, r, files, state)
+}
+
+func (renderer *Renderer) MemberUpdate(w http.ResponseWriter, r *http.Request, user any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.members.update.files")
+	state := NewState(r, renderer.ThemeConfig, membersMenu)
+	state.ViewState = user
+	renderer.Render("members_update", w, r, files, state)
+}

renderer/renderer.go

@@ -244,7 +244,7 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende
 		ls.MenuItems = append(ls.MenuItems, MenuItem{
 			Title:  "Conseillers",
 			Link:   "/app/conseillers/",
-			Active: menuState == conseillersMenu,
+			Active: menuState == membersMenu,
 			Icon:   "hero:outline/user-group",
 		})
 	}

renderer/vehicles.go

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

services/fleets.go

@@ -52,3 +52,17 @@ func (s *ServicesHandler) GetBookings() (bookings []storage.Booking, err error)
 
 	return
 }
+
+func (s *ServicesHandler) GetVehiclesMap() (vehicles map[string]storage.Vehicle, err error) {
+	vehicles = map[string]storage.Vehicle{}
+
+	request := &fleets.GetVehiclesRequest{}
+	resp, err := s.GRPC.Fleets.GetVehicles(context.TODO(), request)
+	if err == nil {
+		for _, vehicle := range resp.Vehicles {
+			vehicles[vehicle.Id] = vehicle.ToStorageType()
+		}
+	}
+
+	return
+}

services/groupsmanagement.go

@@ -1,7 +1,10 @@
 package services
 
 import (
+	"context"
+
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
+	"git.coopgo.io/coopgo-platform/groups-management/storage"
 	"google.golang.org/grpc"
 )
 
@@ -21,3 +24,35 @@ func NewGroupsManagementService(groupsManagementDial string) (*GroupsManagementS
 		GroupsManagementClient: client,
 	}, nil
 }
+
+func (s *ServicesHandler) GetGroupsMap() (groups map[string]storage.Group, err error) {
+	groups = map[string]storage.Group{}
+
+	request := &groupsmanagement.GetGroupsRequest{
+		Namespaces: []string{"parcoursmob_organizations"},
+	}
+	resp, err := s.GRPC.GroupsManagement.GetGroups(context.TODO(), request)
+	if err == nil {
+		for _, group := range resp.Groups {
+			groups[group.Id] = group.ToStorageType()
+		}
+	}
+
+	return
+}
+
+////////////////////////////////optimize the code//////////////////////////////////////
+func (s *ServicesHandler) GetGroupsMemberMap(id string) (groups map[string]any, err error) {
+	groups = map[string]any{}
+
+	request := &groupsmanagement.GetGroupsBatchMemberRequest{
+		Groupids: []string{id},
+	}
+	resp, err := s.GRPC.GroupsManagement.GetGroupsBatchMember(context.TODO(), request)
+	if err == nil {
+		for _, group := range resp.Groups {
+			groups[group.Memberid] = group.ToStorageType()
+		}
+	}
+	return
+}