parcoursmob/handlers/application/dashboard.go

package application

import (
	"context"
	"net/http"
	"sort"

	"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"
	fleetstorage "git.coopgo.io/coopgo-platform/fleets/storage"
	"git.coopgo.io/coopgo-platform/groups-management/storage"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"github.com/rs/zerolog/log"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func (h *ApplicationHandler) Dashboard(w http.ResponseWriter, r *http.Request) {

	g := r.Context().Value(identification.GroupKey)
	if g == nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	group := g.(storage.Group)

	request := &mobilityaccounts.GetAccountsBatchRequest{
		Accountids: group.Members,
	}

	resp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), request)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	var accounts = []any{}

	// We only display the 10 last here
	count := len(resp.Accounts)
	min := count - 5
	if min < 0 {
		min = 0
	}

	for _, account := range resp.Accounts[min:] {
		if filterAccount(r, account) {
			a := account.ToStorageType()
			accounts = append([]any{a}, accounts...)
		}
	}

	members, _, err := h.groupmembers(group.ID)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	count_members := len(members)

	events := []agendastorage.Event{}

	eventsresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
		Namespaces: []string{"parcoursmob_dispositifs"},
		Mindate:    timestamppb.Now(),
	})

	if err == nil {
		for _, e := range eventsresp.Events {
			events = append(events, e.ToStorageType())
		}
	}

	sort.Sort(sorting.EventsByStartdate(events))

	bookings := []fleetstorage.Booking{}

	bookingsresp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), &fleets.GetBookingsRequest{
		Namespaces: []string{"parcoursmob_dispositifs"},
	})

	if err == nil {
		for _, b := range bookingsresp.Bookings {
			bookings = append(bookings, b.ToStorageType())
		}
	}

	h.Renderer.Dashboard(w, r, accounts, count, count_members, events, bookings)

}