handlers/exports/agenda.go

@@ -3,6 +3,9 @@ package exports
 import (
 	"context"
 	"fmt"
+	"net/http"
+	"sort"
+
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
@@ -10,129 +13,69 @@ import (
 	groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	accountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
-	"github.com/gorilla/mux"
 	"github.com/xuri/excelize/v2"
-	"net/http"
-	"sort"
 )
 
-func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *http.Request) {
+func (h *ExportsHandler) Agenda(w http.ResponseWriter, r *http.Request) {
-	switch filter {
+	resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
-	case "allEvents":
+		Namespaces: []string{"parcoursmob_dispositifs"},
-		return func(w http.ResponseWriter, r *http.Request) {
+	})
-			resp, 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
-			}
 
-			events := []agendastorage.Event{}
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
 
-			groupids := []string{}
+	events := []agendastorage.Event{}
-			beneficiaries_ids := []string{}
-			for _, e := range resp.Events {
-				groupids = append(groupids, e.Owners...)
-				events = append(events, e.ToStorageType())
 
-				for _, subscriptions := range e.Subscriptions {
+	groupids := []string{}
-					beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
+	beneficiaries_ids := []string{}
-				}
+	for _, e := range resp.Events {
-			}
+		groupids = append(groupids, e.Owners...)
-
+		events = append(events, e.ToStorageType())
-			sort.Sort(sorting.EventsByStartdate(events))
-
-			groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
-				Groupids: groupids,
-			})
-			groups := map[string]groupsstorage.Group{}
-
-			if err == nil {
-				for _, g := range groupsresp.Groups {
-					groups[g.Id] = g.ToStorageType()
-				}
-			}
-
-			beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
-				Accountids: beneficiaries_ids,
-			})
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusInternalServerError)
-				return
-			}
-
-			beneficiaries_map := map[string]accountsstorage.Account{}
-			for _, ben := range beneficiaries.Accounts {
-				beneficiaries_map[ben.Id] = ben.ToStorageType()
-			}
-
-			f := h.generateExcel(events, groups, beneficiaries_map)
-
-			h.writeFileResponse(f, w)
-		}
-
-	case "oneEvent":
-		return func(w http.ResponseWriter, r *http.Request) {
-			vars := mux.Vars(r)
-			eventId := vars["eventid"]
-			resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), &agenda.GetEventRequest{
-				Id: eventId,
-			})
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusInternalServerError)
-				return
-			}
-			groupids := []string{}
-			beneficiaries_ids := []string{}
-			groupids = append(groupids, resp.Event.Owners...)
-			for _, subscriptions := range resp.Event.Subscriptions {
-				beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
-			}
-			groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
-				Groupids: groupids,
-			})
-			groups := map[string]groupsstorage.Group{}
-
-			if err == nil {
-				for _, g := range groupsresp.Groups {
-					groups[g.Id] = g.ToStorageType()
-				}
-			}
-
-			beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
-				Accountids: beneficiaries_ids,
-			})
-			if err != nil {
-				fmt.Println(err)
-				w.WriteHeader(http.StatusInternalServerError)
-				return
-			}
-
-			beneficiaries_map := map[string]accountsstorage.Account{}
-			for _, ben := range beneficiaries.Accounts {
-				beneficiaries_map[ben.Id] = ben.ToStorageType()
-			}
-
-			f := h.generateExcel([]agendastorage.Event{resp.Event.ToStorageType()}, groups, beneficiaries_map)
-			h.writeFileResponse(f, w)
 
+		for _, subscriptions := range e.Subscriptions {
+			beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber)
 		}
 	}
-	return nil
-}
 
-func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[string]groupsstorage.Group,
+	sort.Sort(sorting.EventsByStartdate(events))
-	beneficiaries_map map[string]accountsstorage.Account) *excelize.File {
+
+	groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+		Groupids: groupids,
+	})
+	groups := map[string]groupsstorage.Group{}
+
+	if err == nil {
+		for _, g := range groupsresp.Groups {
+			groups[g.Id] = g.ToStorageType()
+		}
+	}
+
+	beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
+		Accountids: beneficiaries_ids,
+	})
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	beneficiaries_map := map[string]accountsstorage.Account{}
+	for _, ben := range beneficiaries.Accounts {
+		beneficiaries_map[ben.Id] = ben.ToStorageType()
+	}
+
+	/////////////// Generate file
+
 	f := excelize.NewFile()
 	defer func() {
 		if err := f.Close(); err != nil {
 			fmt.Println(err)
 		}
 	}()
+
 	f.SetCellValue("Sheet1", "A1", "Evénement")
 	f.SetCellValue("Sheet1", "B1", "Date de début")
 	f.SetCellValue("Sheet1", "C1", "Date de fin")
@@ -142,6 +85,8 @@ func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[
 	f.SetCellValue("Sheet1", "G1", "Prescipteur")
 	f.SetCellValue("Sheet1", "H1", "Prescipteur Nom")
 	f.SetCellValue("Sheet1", "I1", "Gestionnaire événement")
+	// f.SetCellValue("Sheet1", "I1", "Prescripteur téléphone")
+
 	i := 2
 	for _, e := range events {
 		if len(e.Owners) == 0 {
@@ -183,14 +128,10 @@ func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[
 		}
 
 	}
-	return f
 
-}
-
-func (h *ExportsHandler) writeFileResponse(file *excelize.File, w http.ResponseWriter) {
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition", "attachment; filename="+"Workbook.xlsx")
 	w.Header().Set("Content-Transfer-Encoding", "binary")
 	w.Header().Set("Expires", "0")
-	file.Write(w)
+	f.Write(w)
 }

handlers/exports/fleets.go

@@ -5,7 +5,6 @@ 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"
@@ -19,6 +18,7 @@ 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,7 +45,6 @@ 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{
@@ -107,31 +106,14 @@ 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["user"].(map[string]any); ok {
+			if v2, ok := v["group"].(map[string]any); ok {
-				if v3, ok := v2["display_name"].(string); ok {
+				if v3, ok := v2["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

@@ -166,9 +166,7 @@ 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)
-	export.HandleFunc("/agenda/subscriptions", exportsHandler.Agenda("allEvents"))
-	export.HandleFunc("/agenda/{eventid}", exportsHandler.Agenda("oneEvent"))
 	export.Use(idp.Middleware)
 	export.Use(idp.GroupsMiddleware)