fix the update profile err

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,14 +227,13 @@ func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
-
+	dis := fmt.Sprint(current_user_claims["first_name"]) + " " + fmt.Sprint(current_user_claims["last_name"])
 	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["first_name"].(string) + " " + current_user_claims["last_name"].(string),
+				"display_name": dis,
-				"email":         current_user_claims["email"].(string),
 			},
 			"group": map[string]any{
 				"id":   current_group.ID,
@@ -331,19 +332,12 @@ func contains(s []*agenda.Subscription, e string) bool {
 	return false
 }
 
-///////////////////////////Delete subscriber///////////////////////////////
+///////////////////////////////Update Event/////////////////////////////////////////
-
+func (h *ApplicationHandler) AgendaUpdateEvent(w http.ResponseWriter, r *http.Request) {
-func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request) {
+	adm := strings.Split(r.URL.Path, "/")
-	vars := mux.Vars(r)
+	eventID := adm[3]
-	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,
+		Id: eventID,
 	}
 
 	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
@@ -352,63 +346,68 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-
+	if r.Method == "POST" {
-	for i := range resp.Event.Subscriptions {
+		g := r.Context().Value(identification.GroupKey)
-		if resp.Event.Subscriptions[i].Subscriber == subscribeid {
+		if g == nil {
-			subscribed_by_id := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue()
+			w.WriteHeader(http.StatusBadRequest)
-			subscribed_by_name := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue()
+			return
-			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)
+		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
 		}
 
-	current_user_token, current_user_claims, err := h.currentUser(r)
+		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", resp.Event.Id), http.StatusFound)
-	if err != nil {
-		fmt.Println(err)
-		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-
+	h.Renderer.AgendaUpdateEvent(w, r, resp.Event.ToStorageType())
-	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)
+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)
@@ -416,126 +415,41 @@ func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r
 	}
 
 	if r.Method == "POST" {
-		request := &agenda.DeleteSubscriptionRequest{
-			Subscriber: subscribeid,
-			Eventid:    eventId,
-			Data:       datapb,
-		}
 
-		data := map[string]any{
+		request := &agenda.UpdateEventRequest{
-			"key":  r.FormValue("motif"),
+			Event: &agenda.Event{
-			"user": current_user_claims["email"],
+				Namespace:      resp.Event.Namespace,
-		}
+				Id:             resp.Event.Id,
-
+				Owners:         resp.Event.Owners,
-		// récupérer l'adresse mail de l'utilisateur qui a créé l'événement
+				Type:           resp.Event.Type,
-		mail := s_b_email;
+				Name:           resp.Event.Name,
-		fmt.Println(mail)
+				Description:    resp.Event.Description,
-
+				Startdate:      resp.Event.Startdate,
-		_, err := h.services.GRPC.Agenda.DeleteSubscription(context.TODO(), request)
+				Enddate:        resp.Event.Enddate,
-
+				Starttime:      resp.Event.Starttime,
-		if err != nil {
+				Endtime:        resp.Event.Endtime,
-			fmt.Println(err)
+				Allday:         resp.Event.Allday,
-			w.WriteHeader(http.StatusInternalServerError)
+				MaxSubscribers: int64(resp.Event.MaxSubscribers),
-			return
+				Data:           resp.Event.Data,
-		}
+				Subscriptions:  resp.Event.Subscriptions,
-
+				Deleted:        true,
-		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)
+		_, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)
-	if g == nil {
+
+		if err != nil {
 			fmt.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 
-	group := g.(storage.Group)
+		http.Redirect(w, r, "/app/agenda/", http.StatusFound)
-
+		return
-	accountids := []string{}
-	for _, m := range group.Members {
-		if !contains(resp.Event.DeletedSubscription, m) {
-			accountids = append(accountids, m)
 	}
+	h.Renderer.AgendaDeleteEvent(w, r, resp.Event.ToStorageType())
 }
 
-	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)
-}
-
-/////////////////////////////////////////////////////////
-
 // func contains[V string](s []V, e V) bool {
 // 	for _, a := range s {
 // 		if a == e {
@@ -544,5 +458,3 @@ func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.R
 // 	}
 // 	return false
 // }
-
-//test

handlers/application/members.go

@@ -76,7 +76,7 @@ func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request
 			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
 	}

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,7 +46,9 @@ func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) {
 				},
 			},
 			Namespace: "parcoursmob",
+
 			Data: map[string]any{
+				"display_name": display_name,
 				"first_name":   r.FormValue("first_name"),
 				"last_name":    r.FormValue("last_name"),
 				"email":        onboardingmap["username"],

main.go

@@ -104,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)
 
@@ -137,10 +142,6 @@ func main() {
 	appAdmin.HandleFunc("/groups/{groupid}/invite-member", applicationHandler.AdministrationGroupInviteMember)
 	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
 
-	/////////////////////////////////////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,
@@ -39,30 +40,24 @@ func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Requ
 	renderer.Render("agenda create event", w, r, files, state)
 }
 
-//////////////////////////DElete subscriber//////////////////////////////////
+func (renderer *Renderer) AgendaUpdateEvent(w http.ResponseWriter, r *http.Request, event any) {
-func (renderer *Renderer) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request, eventid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.agenda.update.files")
-	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)
+	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)
 }
-////////////////////////////////////////////////////////////////////////