lot of new functionalities
This commit is contained in:
Arnaud Delcasse
658
core/application/administration.go
Executable file
658
core/application/administration.go
Executable file
@@ -0,0 +1,658 @@
|
||||
package application
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"sort"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification"
|
||||
"git.coopgo.io/coopgo-apps/parcoursmob/core/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"
|
||||
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"
|
||||
mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
|
||||
mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
|
||||
"github.com/google/uuid"
|
||||
"github.com/rs/zerolog/log"
|
||||
"google.golang.org/protobuf/types/known/structpb"
|
||||
)
|
||||
|
||||
type AdministrationDataResult struct {
|
||||
Accounts []mobilityaccountsstorage.Account
|
||||
Beneficiaries []mobilityaccountsstorage.Account
|
||||
Groups []groupstorage.Group
|
||||
Bookings []fleetsstorage.Booking
|
||||
Events []agendastorage.Event
|
||||
}
|
||||
|
||||
type AdminVehiclesStatsResult struct {
|
||||
Vehicles []fleetsstorage.Vehicle
|
||||
Bookings []fleetsstorage.Booking
|
||||
Groups map[string]any
|
||||
}
|
||||
|
||||
type AdminBookingsStatsResult struct {
|
||||
Vehicles map[string]fleetsstorage.Vehicle
|
||||
Bookings []fleetsstorage.Booking
|
||||
Groups map[string]any
|
||||
BeneficiariesMap map[string]any
|
||||
}
|
||||
|
||||
type AdminBeneficiariesStatsResult struct {
|
||||
Beneficiaries []mobilityaccountsstorage.Account
|
||||
CacheID string
|
||||
}
|
||||
|
||||
type AdminEventsStatsResult struct {
|
||||
Events []agendastorage.Event
|
||||
Groups map[string]any
|
||||
}
|
||||
|
||||
// GetAdministrationData retrieves all data needed for the administration dashboard
|
||||
func (h *ApplicationHandler) GetAdministrationData(ctx context.Context) (*AdministrationDataResult, error) {
|
||||
var (
|
||||
wg sync.WaitGroup
|
||||
accounts, beneficiaries []mobilityaccountsstorage.Account
|
||||
bookings []fleetsstorage.Booking
|
||||
accountsErr, beneficiariesErr, bookingsErr, groupsResponseErr, eventsResponseErr, groupsBatchErr error
|
||||
groups = []groupstorage.Group{}
|
||||
responses = []agendastorage.Event{}
|
||||
groupsResponse *groupsmanagement.GetGroupsResponse
|
||||
eventsResponse *agenda.GetEventsResponse
|
||||
groupids = []string{}
|
||||
)
|
||||
|
||||
// Retrieve accounts in a goroutine
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
accounts, accountsErr = h.services.GetAccounts()
|
||||
}()
|
||||
|
||||
// Retrieve beneficiaries in a goroutine
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
beneficiaries, beneficiariesErr = h.services.GetBeneficiaries()
|
||||
}()
|
||||
|
||||
// Retrieve bookings in a goroutine
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
bookings, bookingsErr = h.services.GetBookings()
|
||||
}()
|
||||
|
||||
// Retrieve groups in a goroutine
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
request := &groupsmanagement.GetGroupsRequest{
|
||||
Namespaces: []string{"parcoursmob_organizations"},
|
||||
}
|
||||
groupsResponse, groupsResponseErr = h.services.GRPC.GroupsManagement.GetGroups(ctx, request)
|
||||
if groupsResponseErr == nil {
|
||||
for _, group := range groupsResponse.Groups {
|
||||
g := group.ToStorageType()
|
||||
groups = append(groups, g)
|
||||
}
|
||||
sort.Sort(sorting.GroupsByName(groups))
|
||||
}
|
||||
}()
|
||||
|
||||
// Retrieve Events in a goroutine
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
eventsResponse, eventsResponseErr = h.services.GRPC.Agenda.GetEvents(ctx, &agenda.GetEventsRequest{
|
||||
Namespaces: []string{"parcoursmob_dispositifs"},
|
||||
})
|
||||
if eventsResponseErr == nil {
|
||||
for _, e := range eventsResponse.Events {
|
||||
groupids = append(groupids, e.Owners...)
|
||||
responses = append(responses, e.ToStorageType())
|
||||
}
|
||||
sort.Sort(sorting.EventsByStartdate(responses))
|
||||
}
|
||||
}()
|
||||
|
||||
wg.Wait()
|
||||
|
||||
// Check for errors
|
||||
if accountsErr != nil || beneficiariesErr != nil || bookingsErr != nil || groupsResponseErr != nil || eventsResponseErr != nil {
|
||||
log.Error().
|
||||
Any("accounts error", accountsErr).
|
||||
Any("beneficiaries error", beneficiariesErr).
|
||||
Any("bookings error", bookingsErr).
|
||||
Any("groups response error", groupsResponseErr).
|
||||
Any("events response error", eventsResponseErr).
|
||||
Any("groups batch error", groupsBatchErr).
|
||||
Msg("Error in retrieving administration data")
|
||||
return nil, fmt.Errorf("error retrieving administration data")
|
||||
}
|
||||
|
||||
return &AdministrationDataResult{
|
||||
Accounts: accounts,
|
||||
Beneficiaries: beneficiaries,
|
||||
Groups: groups,
|
||||
Bookings: bookings,
|
||||
Events: responses,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// CreateAdministrationGroup creates a new administration group
|
||||
func (h *ApplicationHandler) CreateAdministrationGroup(ctx context.Context, name string, modules map[string]any) (string, error) {
|
||||
groupid := uuid.NewString()
|
||||
|
||||
dataMap := map[string]any{
|
||||
"name": name,
|
||||
"modules": modules,
|
||||
}
|
||||
|
||||
data, err := structpb.NewValue(dataMap)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("Cannot create PB struct from data map")
|
||||
return "", fmt.Errorf("failed to create group data: %w", err)
|
||||
}
|
||||
|
||||
request_organization := &groupsmanagement.AddGroupRequest{
|
||||
Group: &groupsmanagement.Group{
|
||||
Id: groupid,
|
||||
Namespace: "parcoursmob_organizations",
|
||||
Data: data.GetStructValue(),
|
||||
},
|
||||
}
|
||||
|
||||
request_role := &groupsmanagement.AddGroupRequest{
|
||||
Group: &groupsmanagement.Group{
|
||||
Id: groupid + ":admin",
|
||||
Namespace: "parcoursmob_roles",
|
||||
},
|
||||
}
|
||||
|
||||
// Create organization group
|
||||
_, err = h.services.GRPC.GroupsManagement.AddGroup(ctx, request_organization)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("Issue in Groups management service - AddGroup")
|
||||
return "", fmt.Errorf("failed to create organization group: %w", err)
|
||||
}
|
||||
|
||||
// Create admin role for the organization
|
||||
_, err = h.services.GRPC.GroupsManagement.AddGroup(ctx, request_role)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("Issue in Groups management service - AddGroup")
|
||||
return "", fmt.Errorf("failed to create admin role: %w", err)
|
||||
}
|
||||
|
||||
return groupid, nil
|
||||
}
|
||||
|
||||
type AdministrationGroupDataResult struct {
|
||||
Group groupstorage.Group
|
||||
Members []mobilityaccountsstorage.Account
|
||||
Admins []mobilityaccountsstorage.Account
|
||||
}
|
||||
|
||||
// GetAdministrationGroupData retrieves data for a specific administration group
|
||||
func (h *ApplicationHandler) GetAdministrationGroupData(ctx context.Context, groupID string) (*AdministrationGroupDataResult, error) {
|
||||
request := &groupsmanagement.GetGroupRequest{
|
||||
Id: groupID,
|
||||
}
|
||||
|
||||
resp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, request)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("Issue in Groups management service - GetGroup")
|
||||
return nil, fmt.Errorf("failed to get group: %w", err)
|
||||
}
|
||||
|
||||
groupmembers, admins, err := h.groupmembers(groupID)
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("issue retrieving group members")
|
||||
return nil, fmt.Errorf("failed to get group members: %w", err)
|
||||
}
|
||||
|
||||
return &AdministrationGroupDataResult{
|
||||
Group: resp.Group.ToStorageType(),
|
||||
Members: groupmembers,
|
||||
Admins: admins,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// InviteAdministrationGroupAdmin invites a user as admin to an administration group
|
||||
func (h *ApplicationHandler) InviteAdministrationGroupAdmin(ctx context.Context, groupID, username string) error {
|
||||
// Get group info
|
||||
groupResp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, &groupsmanagement.GetGroupRequest{
|
||||
Id: groupID,
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get group: %w", err)
|
||||
}
|
||||
|
||||
group := groupResp.Group.ToStorageType()
|
||||
|
||||
accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(ctx, &mobilityaccounts.GetAccountUsernameRequest{
|
||||
Username: username,
|
||||
Namespace: "parcoursmob",
|
||||
})
|
||||
|
||||
if err == nil {
|
||||
// Account already exists: adding the existing account to group as admin
|
||||
account := accountresp.Account.ToStorageType()
|
||||
if account.Data["groups"] == nil {
|
||||
account.Data["groups"] = []any{}
|
||||
}
|
||||
account.Data["groups"] = append(account.Data["groups"].([]any), groupID+":admin")
|
||||
|
||||
as, err := mobilityaccounts.AccountFromStorageType(&account)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to convert account: %w", err)
|
||||
}
|
||||
|
||||
_, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, &mobilityaccounts.UpdateDataRequest{
|
||||
Account: as,
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to update account: %w", err)
|
||||
}
|
||||
|
||||
data := map[string]any{
|
||||
"group": group.Data["name"],
|
||||
"baseUrl": h.config.GetString("base_url"),
|
||||
}
|
||||
|
||||
if err := h.emailing.Send("onboarding.existing_administrator", username, data); err != nil {
|
||||
log.Warn().Err(err).Msg("failed to send existing admin email")
|
||||
}
|
||||
} else {
|
||||
// Create onboarding for new admin
|
||||
onboarding := map[string]any{
|
||||
"username": username,
|
||||
"group": groupID,
|
||||
"admin": true,
|
||||
}
|
||||
|
||||
b := make([]byte, 16)
|
||||
if _, err := io.ReadFull(rand.Reader, b); err != nil {
|
||||
return fmt.Errorf("failed to generate random key: %w", err)
|
||||
}
|
||||
key := base64.RawURLEncoding.EncodeToString(b)
|
||||
|
||||
h.cache.PutWithTTL("onboarding/"+key, onboarding, 72*time.Hour)
|
||||
|
||||
data := map[string]any{
|
||||
"group": group.Data["name"],
|
||||
"key": key,
|
||||
"baseUrl": h.config.GetString("base_url"),
|
||||
}
|
||||
|
||||
if err := h.emailing.Send("onboarding.new_administrator", username, data); err != nil {
|
||||
return fmt.Errorf("failed to send new admin email: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// InviteAdministrationGroupMember invites a user as member to an administration group
|
||||
func (h *ApplicationHandler) InviteAdministrationGroupMember(ctx context.Context, groupID, username string) error {
|
||||
// Get group info
|
||||
groupResp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, &groupsmanagement.GetGroupRequest{
|
||||
Id: groupID,
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get group: %w", err)
|
||||
}
|
||||
|
||||
group := groupResp.Group.ToStorageType()
|
||||
|
||||
accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(ctx, &mobilityaccounts.GetAccountUsernameRequest{
|
||||
Username: username,
|
||||
Namespace: "parcoursmob",
|
||||
})
|
||||
|
||||
if err == nil {
|
||||
// Account already exists: adding the existing account to group
|
||||
account := accountresp.Account.ToStorageType()
|
||||
if account.Data["groups"] == nil {
|
||||
account.Data["groups"] = []any{}
|
||||
}
|
||||
account.Data["groups"] = append(account.Data["groups"].([]any), groupID)
|
||||
|
||||
as, err := mobilityaccounts.AccountFromStorageType(&account)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to convert account: %w", err)
|
||||
}
|
||||
|
||||
_, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, &mobilityaccounts.UpdateDataRequest{
|
||||
Account: as,
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to update account: %w", err)
|
||||
}
|
||||
|
||||
data := map[string]any{
|
||||
"group": group.Data["name"],
|
||||
"baseUrl": h.config.GetString("base_url"),
|
||||
}
|
||||
|
||||
if err := h.emailing.Send("onboarding.existing_member", username, data); err != nil {
|
||||
log.Warn().Err(err).Msg("failed to send existing member email")
|
||||
}
|
||||
} else {
|
||||
// Create onboarding for new member
|
||||
onboarding := map[string]any{
|
||||
"username": username,
|
||||
"group": groupID,
|
||||
"admin": false,
|
||||
}
|
||||
|
||||
b := make([]byte, 16)
|
||||
if _, err := io.ReadFull(rand.Reader, b); err != nil {
|
||||
return fmt.Errorf("failed to generate random key: %w", err)
|
||||
}
|
||||
key := base64.RawURLEncoding.EncodeToString(b)
|
||||
|
||||
h.cache.PutWithTTL("onboarding/"+key, onboarding, 72*time.Hour)
|
||||
|
||||
data := map[string]any{
|
||||
"group": group.Data["name"],
|
||||
"key": key,
|
||||
"baseUrl": h.config.GetString("base_url"),
|
||||
}
|
||||
|
||||
if err := h.emailing.Send("onboarding.new_member", username, data); err != nil {
|
||||
return fmt.Errorf("failed to send new member email: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
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) GetVehiclesStats() (*AdminVehiclesStatsResult, error) {
|
||||
bookings := []fleetsstorage.Booking{}
|
||||
administrators := []string{}
|
||||
request := &fleets.GetVehiclesRequest{
|
||||
Namespaces: []string{"parcoursmob"},
|
||||
}
|
||||
resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
vehicles := []fleetsstorage.Vehicle{}
|
||||
for _, vehicle := range resp.Vehicles {
|
||||
v := vehicle.ToStorageType()
|
||||
adminfound := false
|
||||
for _, a := range administrators {
|
||||
if len(v.Administrators) > 0 && a == v.Administrators[0] {
|
||||
adminfound = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !adminfound && len(v.Administrators) > 0 {
|
||||
administrators = append(administrators, v.Administrators[0])
|
||||
}
|
||||
|
||||
vehicleBookings := []fleetsstorage.Booking{}
|
||||
for _, b := range v.Bookings {
|
||||
if b.Unavailableto.After(time.Now()) {
|
||||
vehicleBookings = append(vehicleBookings, b)
|
||||
}
|
||||
}
|
||||
|
||||
v.Bookings = vehicleBookings
|
||||
vehicles = append(vehicles, v)
|
||||
}
|
||||
|
||||
groups := map[string]any{}
|
||||
if len(administrators) > 0 {
|
||||
admingroups, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
|
||||
Groupids: administrators,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, g := range admingroups.Groups {
|
||||
groups[g.Id] = g.ToStorageType()
|
||||
}
|
||||
}
|
||||
|
||||
sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
|
||||
sort.Sort(sorting.BookingsByStartdate(bookings))
|
||||
|
||||
return &AdminVehiclesStatsResult{
|
||||
Vehicles: vehicles,
|
||||
Bookings: bookings,
|
||||
Groups: groups,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *ApplicationHandler) GetBookingsStats(status, startDate, endDate string) (*AdminBookingsStatsResult, error) {
|
||||
vehicles := map[string]fleetsstorage.Vehicle{}
|
||||
bookings := []fleetsstorage.Booking{}
|
||||
|
||||
// Parse start date filter
|
||||
var startdate time.Time
|
||||
if startDate != "" {
|
||||
if parsed, err := time.Parse("2006-01-02", startDate); err == nil {
|
||||
startdate = parsed
|
||||
}
|
||||
}
|
||||
|
||||
// Parse end date filter
|
||||
var enddate time.Time
|
||||
if endDate != "" {
|
||||
if parsed, err := time.Parse("2006-01-02", endDate); err == nil {
|
||||
enddate = parsed.Add(24 * time.Hour) // End of day
|
||||
}
|
||||
}
|
||||
|
||||
request := &fleets.GetVehiclesRequest{
|
||||
Namespaces: []string{"parcoursmob"},
|
||||
IncludeDeleted: true,
|
||||
}
|
||||
resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
beneficiaries_ids := []string{}
|
||||
|
||||
for _, vehicle := range resp.Vehicles {
|
||||
v := vehicle.ToStorageType()
|
||||
|
||||
for _, b := range v.Bookings {
|
||||
// Apply status filter
|
||||
if status != "" {
|
||||
bookingStatus := b.Status()
|
||||
statusInt := 0
|
||||
|
||||
if b.Deleted {
|
||||
statusInt = -2 // Use -2 for cancelled to distinguish from terminated
|
||||
} else {
|
||||
statusInt = bookingStatus
|
||||
}
|
||||
|
||||
// Map status string to int
|
||||
var filterStatusInt int
|
||||
switch status {
|
||||
case "FORTHCOMING":
|
||||
filterStatusInt = 1
|
||||
case "ONGOING":
|
||||
filterStatusInt = 0
|
||||
case "TERMINATED":
|
||||
filterStatusInt = -1
|
||||
case "CANCELLED":
|
||||
filterStatusInt = -2
|
||||
default:
|
||||
filterStatusInt = 999 // Invalid status, won't match anything
|
||||
}
|
||||
|
||||
if statusInt != filterStatusInt {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// Apply date filter (on startdate)
|
||||
if !startdate.IsZero() && b.Startdate.Before(startdate) {
|
||||
continue
|
||||
}
|
||||
if !enddate.IsZero() && b.Startdate.After(enddate) {
|
||||
continue
|
||||
}
|
||||
|
||||
bookings = append(bookings, b)
|
||||
beneficiaries_ids = append(beneficiaries_ids, b.Driver)
|
||||
}
|
||||
|
||||
vehicles[v.ID] = v
|
||||
}
|
||||
|
||||
groups := map[string]any{}
|
||||
|
||||
admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{
|
||||
Namespaces: []string{"parcoursmob_organizations"},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, g := range admingroups.Groups {
|
||||
groups[g.Id] = g.ToStorageType()
|
||||
}
|
||||
|
||||
beneficiaries, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), &accounts.GetAccountsBatchRequest{
|
||||
Accountids: beneficiaries_ids,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
beneficiaries_map := map[string]any{}
|
||||
for _, ben := range beneficiaries.Accounts {
|
||||
beneficiaries_map[ben.Id] = ben.ToStorageType()
|
||||
}
|
||||
|
||||
return &AdminBookingsStatsResult{
|
||||
Vehicles: vehicles,
|
||||
Bookings: bookings,
|
||||
Groups: groups,
|
||||
BeneficiariesMap: beneficiaries_map,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *ApplicationHandler) GetBeneficiariesStats() (*AdminBeneficiariesStatsResult, error) {
|
||||
beneficiaries, err := h.services.GetBeneficiaries()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cacheid := uuid.New().String()
|
||||
h.cache.Put(cacheid, beneficiaries)
|
||||
|
||||
return &AdminBeneficiariesStatsResult{
|
||||
Beneficiaries: beneficiaries,
|
||||
CacheID: cacheid,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *ApplicationHandler) GetEventsStats() (*AdminEventsStatsResult, error) {
|
||||
resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
|
||||
Namespaces: []string{"parcoursmob_dispositifs"},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
responses := []agendastorage.Event{}
|
||||
groupids := []string{}
|
||||
|
||||
for _, event := range resp.Events {
|
||||
responses = append(responses, event.ToStorageType())
|
||||
groupids = append(groupids, event.Owners...)
|
||||
}
|
||||
|
||||
groupsResponse, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{
|
||||
Groupids: groupids,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
groups := map[string]any{}
|
||||
for _, g := range groupsResponse.Groups {
|
||||
groups[g.Id] = g.ToStorageType()
|
||||
}
|
||||
|
||||
return &AdminEventsStatsResult{
|
||||
Events: responses,
|
||||
Groups: groups,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
|
||||
resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), &accounts.GetAccountsRequest{
|
||||
Namespaces: []string{"parcoursmob"},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return resp.Accounts, nil
|
||||
}
|
||||
|
||||
func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobilityaccountsstorage.Account, admins []mobilityaccountsstorage.Account, err error) {
|
||||
members, err := h.members()
|
||||
if err != nil {
|
||||
if err != nil {
|
||||
log.Error().Err(err).Msg("Cannot get members")
|
||||
return nil, nil, err
|
||||
}
|
||||
}
|
||||
|
||||
groupmembers = []mobilityaccountsstorage.Account{}
|
||||
admins = []mobilityaccountsstorage.Account{}
|
||||
|
||||
for _, m := range members {
|
||||
mm := m.ToStorageType()
|
||||
for _, g := range mm.Data["groups"].([]any) {
|
||||
if g.(string) == groupid {
|
||||
groupmembers = append(groupmembers, mm)
|
||||
}
|
||||
if g.(string) == groupid+":admin" {
|
||||
admins = append(admins, mm)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return groupmembers, admins, err
|
||||
}
|
||||
Reference in New Issue
Block a user