clean code

handlers/application/administration.go

@@ -10,19 +10,20 @@ import (
 	"sort"
 	"time"
 
+	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
 	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
-	"git.coopgo.io/coopgo-platform/fleets/storage"
+	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"
 	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
 	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"google.golang.org/protobuf/types/known/structpb"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) {
@@ -70,7 +71,6 @@ func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Reque
 	////////////////////////////////////add event////////////////////////////////////////////
 	rresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
 		Namespaces: []string{"parcoursmob_dispositifs"},
-		Mindate:    timestamppb.New(time.Now().Add(-24 * time.Hour)),
 	})
 
 	if err != nil {
@@ -99,7 +99,7 @@ func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Reque
 			groupps[g.Id] = g.ToStorageType()
 		}
 	}
-	/////////////////////////////////////////////////////////////////////////////////////////
+
 	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings, responses)
 }
 
@@ -368,30 +368,74 @@ func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWrit
 	return
 }
 
+func filteVehicle(r *http.Request, v *fleets.Vehicle) bool {
+	g := r.Context().Value(identification.GroupKey)
+	if g == nil {
+		return false
+	}
+
+	group := g.(storage.Group)
+
+	for _, n := range v.Administrators {
+		if n == group.ID {
+			return true
+		}
+	}
+
+	return false
+}
+
 func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Request) {
 
-	request := &fleets.GetBookingsRequest{}
+	bookings := []fleetsstorage.Booking{}
-	resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request)
+	administrators := []string{}
+	reequest := &fleets.GetVehiclesRequest{
+		Namespaces: []string{"parcoursmob"},
+	}
+	reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest)
 	if err != nil {
 		fmt.Println(err)
-		w.WriteHeader(http.StatusNotFound)
+		w.WriteHeader(http.StatusInternalServerError)
-		return
 	}
 
-	bookings := []storage.Booking{}
+	vehicles := []fleetsstorage.Vehicle{}
+	for _, vehiicle := range reesp.Vehicles {
+
+		v := vehiicle.ToStorageType()
+		adminfound := false
+		for _, a := range administrators {
+			if a == v.Administrators[0] {
+				adminfound = true
+				break
+			}
+		}
+		if !adminfound {
+			administrators = append(administrators, v.Administrators[0])
+		}
+
+		vehicles = append(vehicles, v)
 
-	for _, b := range resp.Bookings {
-		booking := b.ToStorageType()
-		bookings = append(bookings, booking)
 	}
+	groups := map[string]any{}
 
+	if len(administrators) > 0 {
+		admingroups, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
+			Groupids: administrators,
+		})
+		if err != nil {
+			fmt.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		for _, g := range admingroups.Groups {
+			groups[g.Id] = g.ToStorageType()
+		}
+
+	}
+	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
 	sort.Sort(sorting.BookingsByStartdate(bookings))
-
+	h.Renderer.AdminStatVehicles(w, r, vehicles, bookings, groups)
-	vehicles, _ := h.services.GetVehiclesMap()
-	groups, _ := h.services.GetGroupsMap()
-	// fmt.Println(vehicles)
-	// fmt.Println("////////////////////////////////////////:")
-	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
 }
 
 func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
@@ -431,3 +475,49 @@ func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobili
 
 	return groupmembers, admins, err
 }
+
+func (h ApplicationHandler) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request) {
+	beneficiaries, err := h.services.GetBeneficiaries()
+	if err != nil {
+		fmt.Println(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	cacheid := uuid.NewString()
+	h.cache.PutWithTTL(cacheid, beneficiaries, 1*time.Hour)
+	h.Renderer.AdminStatBeneficaires(w, r, beneficiaries, cacheid)
+}
+
+func (h ApplicationHandler) AdminStatEvents(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
+	}
+
+	responses := []agendastorage.Event{}
+
+	groupids := []string{}
+	for _, e := range resp.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,
+	})
+	groups := map[string]any{}
+
+	if err == nil {
+		for _, g := range groupsresp.Groups {
+			groups[g.Id] = g.ToStorageType()
+		}
+	}
+	h.Renderer.AdminStatEvents(w, r, responses, groups)
+}

handlers/application/beneficiaries.go

@@ -54,7 +54,6 @@ func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Re
 
 	cacheid := uuid.NewString()
 	h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour)
-
 	h.Renderer.BeneficiariesList(w, r, accounts, cacheid)
 }
 

main.go

@@ -136,9 +136,8 @@ 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)
 	//add statistiques
-	appAdmin.HandleFunc("/stats/vehicles/available", applicationHandler.AdminStatAvailableVehicles)
+	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
 	appAdmin.HandleFunc("/stats/beneficaires", applicationHandler.AdminStatBeneficaires)
 	appAdmin.HandleFunc("/stats/events", applicationHandler.AdminStatEvents)
 

renderer/administration.go

@@ -1,9 +1,12 @@
 package renderer
 
 import (
+	"encoding/json"
+	"html/template"
 	"net/http"
 
 	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
+	fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
@@ -41,3 +44,58 @@ func (renderer *Renderer) AdministrationGroupDisplay(w http.ResponseWriter, r *h
 
 	renderer.Render("administration", w, r, files, state)
 }
+
+type BeneficiariesState struct {
+	Count         int                               `json:"count"`
+	CacheId       string                            `json:"cache_id"`
+	Beneficiaries []mobilityaccountsstorage.Account `json:"beneficiaries"`
+}
+
+func (s BeneficiariesState) JSON() template.JS {
+	result, _ := json.Marshal(s)
+	return template.JS(result)
+}
+
+func (s BeneficiariesState) JSONWithLimits(a int, b int) template.JS {
+	if b < len(s.Beneficiaries) {
+		s.Beneficiaries = s.Beneficiaries[a:b]
+	}
+	return s.JSON()
+}
+
+func (renderer *Renderer) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request, Beneficiaries []mobilityaccountsstorage.Account, cacheid string) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.beneficaires_list.files")
+
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = BeneficiariesState{
+		Count:         len(Beneficiaries),
+		CacheId:       cacheid,
+		Beneficiaries: Beneficiaries,
+	}
+
+	renderer.Render("beneficiaries_State", w, r, files, state)
+}
+
+func (renderer *Renderer) AdminStatEvents(w http.ResponseWriter, r *http.Request, events []agendastorage.Event, groups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.events_list.files")
+
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = map[string]any{
+		"events": events,
+		"groups": groups,
+	}
+
+	renderer.Render("beneficiaries_State", w, r, files, state)
+}
+
+func (renderer *Renderer) AdminStatVehicles(w http.ResponseWriter, r *http.Request, vehicles []fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, admingroups map[string]any) {
+	files := renderer.ThemeConfig.GetStringSlice("views.administration.vehicles_list.files")
+	state := NewState(r, renderer.ThemeConfig, administrationMenu)
+	state.ViewState = map[string]any{
+		"vehicles":    vehicles,
+		"bookings":    bookings,
+		"admingroups": admingroups,
+	}
+
+	renderer.Render("vehicles_state", w, r, files, state)
+}

renderer/vehicle-management.go

@@ -78,13 +78,3 @@ func (renderer *Renderer) VehicleManagementBookingDisplay(w http.ResponseWriter,
 
 	renderer.Render("vehicles search", w, r, files, state)
 }
-
-// func (renderer *Renderer) UnbookingVehicles(w http.ResponseWriter, r *http.Request, vehicles []fleetsstorage.Vehicle) {
-// 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.unbooking_display.files")
-// 	state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu)
-// 	state.ViewState = map[string]any{
-// 		"vehicles": vehicles,
-// 	}
-
-// 	renderer.Render("fleet display 	Unbooking vehicle", w, r, files, state)
-// }