add 'Motif' in DB

handlers/application/agenda.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"sort"
 	"strconv"
-	"strings"
 	"time"
 
 	formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators"
@@ -108,7 +107,6 @@ func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Re
 				Allday:         eventForm.Allday,
 				MaxSubscribers: int64(eventForm.MaxSubscribers),
 				Data:           data,
-				Deleted:        false,
 			},
 		}
 
@@ -121,7 +119,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)
 }
@@ -227,13 +225,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": dis,
+				"display_name": current_user_claims["display_name"],
 			},
 			"group": map[string]any{
 				"id":   current_group.ID,
@@ -332,82 +330,60 @@ func contains(s []*agenda.Subscription, e string) bool {
 	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) {
-
+// /////////////////////////Delete subscriber///////////////////////////////
+func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	eventID := vars["eventid"]
-	request := &agenda.GetEventRequest{
-		Id: eventID,
+	eventId := vars["eventid"]
+	subscribeid := vars["subscribeid"]
+
+	/////////////////////////Test ajout motif///////////////////////////////
+	// dd, _ := structpb.NewStruct(map[string]any{})
+	// 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 {
+	// 		d := resp.Event.Subscriptions[i].Data
+	// 		dd = d
+	// 	}
+	// }
+
+	current_group, err := h.currentGroup(r)
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
 	}
 
-	resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request)
+	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{
+		"unsubscribed_by": map[string]any{
+			"user": map[string]any{
+				"id":           current_user_token.Subject,
+				"display_name": current_user_claims["display_name"],
+			},
+			"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)
@@ -415,28 +391,15 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re
 	}
 
 	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,
-			},
+		request := &agenda.DeleteSubscriptionRequest{
+			Subscriber: subscribeid,
+			Eventid:    eventId,
+			Data:       datapb,
 		}
 
-		_, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request)
+
+		
+		_, err := h.services.GRPC.Agenda.DeleteSubscription(context.TODO(), request)
 
 		if err != nil {
 			fmt.Println(err)
@@ -444,12 +407,14 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re
 			return
 		}
 
-		http.Redirect(w, r, "/app/agenda/", http.StatusFound)
+		http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventId), http.StatusFound)
 		return
 	}
-	h.Renderer.AgendaDeleteEvent(w, r, resp.Event.ToStorageType())
+	h.Renderer.AgendaDeleteSubscribeEvent(w, r, eventId)
 }
 
+////////////////////////////////////////////////////////
+
 // func contains[V string](s []V, e V) bool {
 // 	for _, a := range s {
 // 		if a == e {
@@ -458,3 +423,5 @@ func (h *ApplicationHandler) AgendaDeleteEvent(w http.ResponseWriter, r *http.Re
 // 	}
 // 	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/members/%s", resp.Account.Id), http.StatusFound)
+		http.Redirect(w, r, fmt.Sprintf("/app/profile/%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,13 +46,11 @@ 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"],
-				"groups":       groups,
+				"first_name": r.FormValue("first_name"),
+				"last_name":  r.FormValue("last_name"),
+				"email":      onboardingmap["username"],
+				"groups":     groups,
 			},
 		}
 

main.go

@@ -104,11 +104,6 @@ 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)
 
@@ -142,6 +137,9 @@ 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)
+	/////////////////////////////////////////////////////////////////////////////////////////////////////
 	fmt.Println("-> HTTP server listening on", address)
 
 	srv := &http.Server{

renderer/agenda.go

@@ -29,7 +29,6 @@ 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,
@@ -40,24 +39,15 @@ func (renderer *Renderer) AgendaDisplayEvent(w http.ResponseWriter, r *http.Requ
 	renderer.Render("agenda create 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")
+//////////////////////////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{
-		"event": event,
+		"eventid": eventid,
 	}
 
-	renderer.Render("event_update", w, r, files, state)
+	renderer.Render("agenda delete subscriber", 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)
-}
+//////////////////////////////////////////////////////////