diff --git a/.gitignore b/.gitignore index fa74cfc..de54a0e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,6 @@ /config.yaml themes/* .vscode -__debug_bin \ No newline at end of file +__debug_bin +parcoursmob +.idea diff --git a/config.go b/config.go index 5b928ed..de19421 100755 --- a/config.go +++ b/config.go @@ -14,7 +14,15 @@ func ReadConfig() (*viper.Viper, error) { "public_dir": "template/default/public", }, "server": map[string]any{ - "listen": "0.0.0.0:9000", + "listen": "0.0.0.0:9000", // DEPRECATED + "web": map[string]any{ + "enabled": true, + "listen": "0.0.0.0:8080", + }, + "mcp": map[string]any{ + "enabled": false, + "listen": "0.0.0.0:8081", + }, }, "identification": map[string]any{ "sessions": map[string]any{ @@ -113,10 +121,15 @@ func ReadConfig() (*viper.Viper, error) { }, }, "journeys": map[string]any{ - "enabled": true, + "enabled": true, + "search_view": "tabs", }, "solidarity_transport": map[string]any{ "enabled": true, + "pagination": map[string]any{ + "trips_items_per_page": 10, + "drivers_items_per_page": 10, + }, "drivers": map[string]any{ "documents_types": []string{"membership_form", "driving_licence", "identity_proof", "other"}, "validated_profile": map[string]any{ @@ -150,9 +163,24 @@ func ReadConfig() (*viper.Viper, error) { }, }, }, + "booking_motivations": []map[string]string{ + {"value": "Administratif", "label": "Administratif (trajet garanti)"}, + {"value": "Commerce", "label": "Commerce"}, + {"value": "Courses", "label": "Courses"}, + {"value": "Insertion", "label": "Insertion (trajet garanti)"}, + {"value": "Loisirs", "label": "Loisirs"}, + {"value": "Visite à un proche", "label": "Visite à un proche"}, + {"value": "Santé", "label": "Santé (trajet garanti)"}, + {"value": "", "label": "Autre "}, + }, + "guaranteed_trip_motivations": []string{"Santé", "Insertion", "Administratif"}, }, "organized_carpool": map[string]any{ "enabled": true, + "pagination": map[string]any{ + "trips_items_per_page": 10, + "drivers_items_per_page": 10, + }, "drivers": map[string]any{ "documents_types": []string{"membership_form", "driving_licence", "identity_proof", "other"}, "validated_profile": map[string]any{ @@ -163,6 +191,18 @@ func ReadConfig() (*viper.Viper, error) { }, }, }, + "booking_motivations": []map[string]string{ + {"value": "Administratif", "label": "Administratif"}, + {"value": "Commerce", "label": "Commerce"}, + {"value": "Courses", "label": "Courses"}, + {"value": "Insertion", "label": "Insertion"}, + {"value": "Loisirs", "label": "Loisirs"}, + {"value": "Travail", "label": "Travail"}, + {"value": "Formation", "label": "Formation"}, + {"value": "Visite à un proche", "label": "Visite à un proche"}, + {"value": "Santé", "label": "Santé"}, + {"value": "", "label": "Autre "}, + }, }, "vehicles": map[string]any{ "enabled": true, @@ -170,6 +210,10 @@ func ReadConfig() (*viper.Viper, error) { "vehicles_management": map[string]any{ "enabled": true, }, + "fleets": map[string]any{ + "vehicle_types": []string{"Voiture", "Voiture sans permis", "Scooter", "Trotinette", "Vélo électrique"}, + "vehicle_optional_fields": []map[string]any{}, + }, "agenda": map[string]any{ "enabled": true, }, @@ -178,6 +222,7 @@ func ReadConfig() (*viper.Viper, error) { }, "support": map[string]any{ "enabled": true, + "email": "support@mobicoop.fr", }, }, "geo": map[string]any{ @@ -208,6 +253,10 @@ func ReadConfig() (*viper.Viper, error) { "communes": "https://etalab-datasets.geo.data.gouv.fr/contours-administratifs/latest/geojson/communes-50m.geojson", }, }, + "filters": map[string]any{ + "enabled": false, + "geographies": []map[string]string{}, + }, }, } v := viper.New() diff --git a/core/application/administration.go b/core/application/administration.go new file mode 100755 index 0000000..0e7871d --- /dev/null +++ b/core/application/administration.go @@ -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 +} diff --git a/core/application/agenda.go b/core/application/agenda.go new file mode 100755 index 0000000..53e1c3f --- /dev/null +++ b/core/application/agenda.go @@ -0,0 +1,602 @@ +package application + +import ( + "context" + "fmt" + "io" + "sort" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" + "git.coopgo.io/coopgo-apps/parcoursmob/services" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi" + agendastorage "git.coopgo.io/coopgo-platform/agenda/storage" + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + ics "github.com/arran4/golang-ical" + "github.com/google/uuid" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" +) + + +type AgendaEventsResult struct { + Events []agendastorage.Event + Groups map[string]any +} + +func (h *ApplicationHandler) GetAgendaEvents(ctx context.Context, minDate, maxDate *time.Time) (*AgendaEventsResult, error) { + request := &agenda.GetEventsRequest{ + Namespaces: []string{"parcoursmob_dispositifs"}, + } + + if minDate != nil { + request.Mindate = timestamppb.New(*minDate) + } + if maxDate != nil { + request.Maxdate = timestamppb.New(*maxDate) + } + + resp, err := h.services.GRPC.Agenda.GetEvents(ctx, request) + if err != nil { + return nil, err + } + + 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)) + + groups := map[string]any{} + if len(groupids) > 0 { + groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(ctx, &groupsmanagement.GetGroupsBatchRequest{ + Groupids: groupids, + }) + if err == nil { + for _, g := range groupsresp.Groups { + groups[g.Id] = g.ToStorageType() + } + } + } + + return &AgendaEventsResult{ + Events: responses, + Groups: groups, + }, nil +} + + + +func (h *ApplicationHandler) CreateAgendaEvent(ctx context.Context, name, eventType, description string, address any, allday bool, startdate, enddate *time.Time, starttime, endtime string, maxSubscribers int, file io.Reader, filename string, fileSize int64, documentType, documentName string) (string, error) { + // Get current group + g := ctx.Value(identification.GroupKey) + if g == nil { + return "", fmt.Errorf("no group found in context") + } + + group := g.(storage.Group) + + data, _ := structpb.NewStruct(map[string]any{ + "address": address, + }) + + request := &agenda.CreateEventRequest{ + Event: &agenda.Event{ + Namespace: "parcoursmob_dispositifs", + Owners: []string{group.ID}, + Type: eventType, + Name: name, + Description: description, + Startdate: timestamppb.New(*startdate), + Enddate: timestamppb.New(*enddate), + Starttime: starttime, + Endtime: endtime, + Allday: allday, + MaxSubscribers: int64(maxSubscribers), + Data: data, + Deleted: false, + }, + } + + resp, err := h.services.GRPC.Agenda.CreateEvent(ctx, request) + if err != nil { + return "", err + } + + // Handle file upload if provided + if file != nil && filename != "" { + fileid := uuid.NewString() + + metadata := map[string]string{ + "file_type": documentType, + "file_name": documentName, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", resp.Event.Id, fileid, filename), fileSize, metadata); err != nil { + return "", err + } + } + + return resp.Event.Id, nil +} + + +type AgendaEventResult struct { + Event agendastorage.Event + Group storage.Group + Documents []filestorage.FileInfo + Subscribers map[string]any + Accounts []any +} + +func (h *ApplicationHandler) GetAgendaEvent(ctx context.Context, eventID string) (*AgendaEventResult, error) { + request := &agenda.GetEventRequest{ + Id: eventID, + } + + resp, err := h.services.GRPC.Agenda.GetEvent(ctx, request) + if err != nil { + return nil, err + } + + grouprequest := &groupsmanagement.GetGroupRequest{ + Id: resp.Event.Owners[0], + } + + groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, grouprequest) + if err != nil { + return nil, err + } + + subscribers := map[string]any{} + accids := []string{} + for _, v := range resp.Event.Subscriptions { + accids = append(accids, v.Subscriber) + } + + if len(accids) > 0 { + subscriberresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( + ctx, + &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: accids, + }, + ) + if err == nil { + for _, sub := range subscriberresp.Accounts { + subscribers[sub.Id] = sub.ToStorageType() + } + } + } + + g := ctx.Value(identification.GroupKey) + if g == nil { + return nil, fmt.Errorf("no group found in context") + } + + group := g.(storage.Group) + + accountids := []string{} + for _, m := range group.Members { + if !contains(resp.Event.Subscriptions, m) { + accountids = append(accountids, m) + } + } + + accounts := []any{} + if len(accountids) > 0 { + accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( + ctx, + &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: accountids, + }, + ) + if err == nil { + for _, acc := range accountresp.Accounts { + accounts = append(accounts, acc) + } + } + } + + documents := h.filestorage.List(filestorage.PREFIX_AGENDA + "/" + eventID) + + return &AgendaEventResult{ + Event: resp.Event.ToStorageType(), + Group: groupresp.Group.ToStorageType(), + Documents: documents, + Subscribers: subscribers, + Accounts: accounts, + }, nil +} + + +func (h *ApplicationHandler) SubscribeToAgendaEvent(ctx context.Context, eventID, subscriber string, subscriptionData map[string]any) error { + datapb, err := structpb.NewStruct(subscriptionData) + if err != nil { + return err + } + + request := &agenda.SubscribeEventRequest{ + Eventid: eventID, + Subscriber: subscriber, + Data: datapb, + } + + _, err = h.services.GRPC.Agenda.SubscribeEvent(ctx, request) + return err +} + +func (h *ApplicationHandler) UnsubscribeFromAgendaEvent(ctx context.Context, eventID, subscribeID, motif, currentUserID, currentUserDisplayName, currentUserEmail, currentGroupID, currentGroupName string) error { + // Get the event first + request := &agenda.GetEventRequest{ + Id: eventID, + } + + resp, err := h.services.GRPC.Agenda.GetEvent(ctx, request) + if err != nil { + return err + } + + // Find subscription data for the subscriber being removed + var s_b_id, s_b_name, s_b_email, s_b_group_id, s_b_group_name string + for i := range resp.Event.Subscriptions { + if resp.Event.Subscriptions[i].Subscriber == subscribeID { + s_b_id = resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue() + s_b_name = resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue() + s_b_email = resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue() + s_b_group_id = resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue() + s_b_group_name = resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue() + break + } + } + + data := map[string]any{ + "subscribed_by": map[string]any{ + "user": map[string]any{ + "id": s_b_id, + "display_name": s_b_name, + "email": s_b_email, + }, + "group": map[string]any{ + "id": s_b_group_id, + "name": s_b_group_name, + }, + }, + "unsubscribed_by": map[string]any{ + "user": map[string]any{ + "id": currentUserID, + "display_name": currentUserDisplayName, + "email": currentUserEmail, + }, + "group": map[string]any{ + "id": currentGroupID, + "name": currentGroupName, + }, + }, + "motif": motif, + } + + datapb, err := structpb.NewStruct(data) + if err != nil { + return err + } + + deleteRequest := &agenda.DeleteSubscriptionRequest{ + Subscriber: subscribeID, + Eventid: eventID, + Data: datapb, + } + + _, err = h.services.GRPC.Agenda.DeleteSubscription(ctx, deleteRequest) + if err != nil { + return err + } + + // Send email notification + emailData := map[string]any{ + "motif": motif, + "user": currentUserDisplayName, + "subscriber": fmt.Sprintf("http://localhost:9000/app/beneficiaries/%s", subscribeID), + "link": fmt.Sprintf("http://localhost:9000/app/agenda/%s", eventID), + } + + if err := h.emailing.Send("delete_subscriber.request", s_b_email, emailData); err != nil { + log.Error().Err(err).Msg("Cannot send email") + // Don't return error for email failure + } + + return nil +} + +type AgendaEventHistoryResult struct { + Event agendastorage.Event + Group storage.Group + Subscribers map[string]any + Accounts []any +} + +func (h *ApplicationHandler) GetAgendaEventHistory(ctx context.Context, eventID string) (*AgendaEventHistoryResult, error) { + request := &agenda.GetEventRequest{ + Id: eventID, + } + + resp, err := h.services.GRPC.Agenda.GetEvent(ctx, request) + if err != nil { + return nil, err + } + + grouprequest := &groupsmanagement.GetGroupRequest{ + Id: resp.Event.Owners[0], + } + + groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, grouprequest) + if err != nil { + return nil, err + } + + subscribers := map[string]any{} + + accids := []string{} + for _, v := range resp.Event.DeletedSubscription { + accids = append(accids, v.Subscriber) + } + + if len(accids) > 0 { + subscriberresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( + ctx, + &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: accids, + }, + ) + + if err == nil { + for _, sub := range subscriberresp.Accounts { + subscribers[sub.Id] = sub.ToStorageType() + } + } + } + + g := ctx.Value(identification.GroupKey) + if g == nil { + return nil, fmt.Errorf("no group found in context") + } + + group := g.(storage.Group) + + accountids := []string{} + for _, m := range group.Members { + if !contains(resp.Event.DeletedSubscription, m) { + accountids = append(accountids, m) + } + } + + accounts := []any{} + if len(accountids) > 0 { + accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( + ctx, + &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: accountids, + }, + ) + + if err == nil { + for _, acc := range accountresp.Accounts { + accounts = append(accounts, acc) + } + } + } + + return &AgendaEventHistoryResult{ + Event: resp.Event.ToStorageType(), + Group: groupresp.Group.ToStorageType(), + Subscribers: subscribers, + Accounts: accounts, + }, nil +} + +func (h *ApplicationHandler) AddEventDocument(ctx context.Context, eventID string, file io.Reader, filename string, fileSize int64, documentType, documentName string) error { + fileid := uuid.NewString() + + metadata := map[string]string{ + "type": documentType, + "name": documentName, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", eventID, fileid, filename), fileSize, metadata); err != nil { + return err + } + + return nil +} + +func (h *ApplicationHandler) GetEventDocument(ctx context.Context, eventID, document string) (io.Reader, *filestorage.FileInfo, error) { + file, info, err := h.filestorage.Get(filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s", eventID, document)) + if err != nil { + return nil, nil, err + } + + return file, info, nil +} + + + +func contains(s []*agenda.Subscription, e string) bool { + for _, a := range s { + if a.Subscriber == e { + return true + } + } + return false +} + +func (h *ApplicationHandler) UpdateAgendaEvent(ctx context.Context, eventID, name, eventType, description string, address any, allday bool, startdate, enddate *time.Time, starttime, endtime string, maxSubscribers int) (string, error) { + // Get current group + g := ctx.Value(identification.GroupKey) + if g == nil { + return "", fmt.Errorf("no group found in context") + } + + group := g.(storage.Group) + + // Get existing event first + getRequest := &agenda.GetEventRequest{ + Id: eventID, + } + + resp, err := h.services.GRPC.Agenda.GetEvent(ctx, getRequest) + if err != nil { + return "", err + } + + data, _ := structpb.NewStruct(map[string]any{ + "address": address, + }) + + request := &agenda.UpdateEventRequest{ + Event: &agenda.Event{ + Namespace: "parcoursmob_dispositifs", + Id: eventID, + Owners: []string{group.ID}, + Type: eventType, + Name: name, + Description: description, + Startdate: timestamppb.New(*startdate), + Enddate: timestamppb.New(*enddate), + Starttime: starttime, + Endtime: endtime, + Allday: allday, + MaxSubscribers: int64(maxSubscribers), + Data: data, + Subscriptions: resp.Event.Subscriptions, + }, + } + + updateResp, err := h.services.GRPC.Agenda.UpdateEvent(ctx, request) + if err != nil { + return "", err + } + + return updateResp.Event.Id, nil +} + + +func (h *ApplicationHandler) DeleteAgendaEvent(ctx context.Context, eventID string) error { + request := &agenda.GetEventRequest{ + Id: eventID, + } + + resp, err := h.services.GRPC.Agenda.GetEvent(ctx, request) + if err != nil { + return err + } + + updateRequest := &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, + }, + } + + _, err = h.services.GRPC.Agenda.UpdateEvent(ctx, updateRequest) + return err +} + +type CalendarResult struct { + CalendarData string +} + +func (h *ApplicationHandler) GenerateGlobalCalendar(ctx context.Context) (*CalendarResult, error) { + events, err := h.services.GetAgendaEvents() + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda events") + return nil, err + } + + calendar, err := h.icsCalendar(events) + if err != nil { + return nil, err + } + + return &CalendarResult{ + CalendarData: calendar.Serialize(), + }, nil +} + +func (h *ApplicationHandler) GenerateOrganizationCalendar(ctx context.Context, groupID string) (*CalendarResult, error) { + events, err := h.services.GetAgendaEvents() + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda events") + return nil, err + } + + filteredEvents := []services.AgendaEvent{} + for _, e := range events { + for _, g := range e.Owners { + if g == groupID { + filteredEvents = append(filteredEvents, e) + break + } + } + } + + calendar, err := h.icsCalendar(filteredEvents) + if err != nil { + return nil, err + } + + return &CalendarResult{ + CalendarData: calendar.Serialize(), + }, nil +} + +func (h *ApplicationHandler) icsCalendar(events []services.AgendaEvent) (*ics.Calendar, error) { + calendar := ics.NewCalendarFor(h.config.GetString("service_name")) + + for _, e := range events { + vevent := ics.NewEvent(e.ID) + vevent.SetSummary(e.Name) + vevent.SetDescription(e.Description) + if e.Allday { + vevent.SetAllDayStartAt(e.Startdate) + if e.Enddate.After(e.Startdate) { + vevent.SetAllDayEndAt(e.Enddate.Add(24 * time.Hour)) + } + } else { + timeloc, err := time.LoadLocation("Europe/Paris") + if err != nil { + log.Error().Err(err).Msg("Tried to load timezone location Europe/Paris. Error. Missing zones in container ?") + return nil, err + } + vevent.SetStartAt(e.Startdate.In(timeloc)) + vevent.SetEndAt(e.Enddate.In(timeloc)) + } + calendar.AddVEvent(vevent) + } + + return calendar, nil +} + + + + + diff --git a/handlers/application/application.go b/core/application/application.go similarity index 76% rename from handlers/application/application.go rename to core/application/application.go index 942dc54..81fb6b1 100755 --- a/handlers/application/application.go +++ b/core/application/application.go @@ -4,10 +4,9 @@ import ( "errors" "net/http" - "git.coopgo.io/coopgo-apps/parcoursmob/renderer" "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + cache "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" "git.coopgo.io/coopgo-platform/emailing" "git.coopgo.io/coopgo-platform/groups-management/storage" "github.com/coreos/go-oidc/v3/oidc" @@ -16,29 +15,24 @@ import ( type ApplicationHandler struct { config *viper.Viper - Renderer *renderer.Renderer services *services.ServicesHandler cache cache.CacheHandler filestorage cache.FileStorage emailing *emailing.Mailer + idp *identification.IdentificationProvider } -func NewApplicationHandler(cfg *viper.Viper, svc *services.ServicesHandler, cache cache.CacheHandler, filestorage cache.FileStorage, emailing *emailing.Mailer) (*ApplicationHandler, error) { - templates_root := cfg.GetString("templates.root") - renderer := renderer.NewRenderer(cfg, templates_root, filestorage) +func NewApplicationHandler(cfg *viper.Viper, svc *services.ServicesHandler, cache cache.CacheHandler, filestorage cache.FileStorage, emailing *emailing.Mailer, idp *identification.IdentificationProvider) (*ApplicationHandler, error) { return &ApplicationHandler{ config: cfg, - Renderer: renderer, services: svc, cache: cache, filestorage: filestorage, emailing: emailing, + idp: idp, }, nil } -func (h *ApplicationHandler) NotFound(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusNotFound) -} func (h *ApplicationHandler) templateFile(file string) string { return h.config.GetString("templates.root") + file @@ -70,4 +64,4 @@ func (h *ApplicationHandler) currentUser(r *http.Request) (current_user_token *o current_user_claims = c.(map[string]any) return current_user_token, current_user_claims, nil -} +} \ No newline at end of file diff --git a/core/application/auth.go b/core/application/auth.go new file mode 100644 index 0000000..bccba15 --- /dev/null +++ b/core/application/auth.go @@ -0,0 +1,240 @@ +package application + +import ( + "context" + "crypto/rand" + "encoding/base64" + "errors" + "io" + "time" + + "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + ma "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/coreos/go-oidc/v3/oidc" + "github.com/rs/zerolog/log" +) + +type OAuth2CallbackResult struct { + RedirectURL string + IDToken string +} + +func (h *ApplicationHandler) ProcessOAuth2Callback(code string, redirectSession string) (*OAuth2CallbackResult, error) { + oauth2Token, err := h.idp.OAuth2Config.Exchange(context.Background(), code) + if err != nil { + log.Error().Err(err).Msg("Exchange error") + return nil, err + } + + // Extract the ID Token from OAuth2 token. + rawIDToken, ok := oauth2Token.Extra("id_token").(string) + if !ok { + log.Error().Msg("Cannot retrieve ID token") + return nil, errors.New("cannot retrieve ID token") + } + + _, err = h.idp.TokenVerifier.Verify(context.Background(), rawIDToken) + if err != nil { + log.Error().Err(err).Msg("Not able to verify token") + return nil, err + } + + redirect := "/app/" + if redirectSession != "" { + redirect = redirectSession + } + + return &OAuth2CallbackResult{ + RedirectURL: redirect, + IDToken: rawIDToken, + }, nil +} + +type LostPasswordInitResult struct { + Success bool +} + +func (h *ApplicationHandler) InitiateLostPassword(email string) (*LostPasswordInitResult, error) { + account, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &mobilityaccounts.GetAccountUsernameRequest{ + Username: email, + Namespace: "parcoursmob", + }) + if err != nil { + return nil, err + } + + b := make([]byte, 16) + if _, err := io.ReadFull(rand.Reader, b); err != nil { + return nil, err + } + key := base64.RawURLEncoding.EncodeToString(b) + + passwordretrieval := map[string]any{ + "username": email, + "account_id": account.Account.Id, + "key": key, + } + + h.cache.PutWithTTL("retrieve-password/"+key, passwordretrieval, 72*time.Hour) + + if err := h.emailing.Send("auth.retrieve_password", email, passwordretrieval); err != nil { + return nil, err + } + + return &LostPasswordInitResult{Success: true}, nil +} + +type LostPasswordRecoverResult struct { + Success bool +} + +func (h *ApplicationHandler) RecoverLostPassword(key, newPassword string) (*LostPasswordRecoverResult, error) { + recover, err := h.cache.Get("retrieve-password/" + key) + if err != nil { + return nil, err + } + + if newPassword == "" { + return nil, errors.New("password is empty") + } + + _, err = h.services.GRPC.MobilityAccounts.ChangePassword(context.TODO(), &mobilityaccounts.ChangePasswordRequest{ + Id: recover.(map[string]any)["account_id"].(string), + Password: newPassword, + }) + if err != nil { + return nil, err + } + + err = h.cache.Delete("retrieve-password/" + key) + if err != nil { + log.Error().Err(err).Msg("Failed to delete password recovery key") + } + + return &LostPasswordRecoverResult{Success: true}, nil +} + +func (h *ApplicationHandler) GetPasswordRecoveryData(key string) (map[string]any, error) { + recover, err := h.cache.Get("retrieve-password/" + key) + if err != nil { + return nil, err + } + return recover.(map[string]any), nil +} + +type OnboardingResult struct { + Success bool +} + +func (h *ApplicationHandler) CompleteOnboarding(key, password, firstName, lastName string) (*OnboardingResult, error) { + onboarding, err := h.cache.Get("onboarding/" + key) + if err != nil { + return nil, err + } + + onboardingmap := onboarding.(map[string]any) + + if password == "" { + return nil, errors.New("password is empty") + } + + groups := []string{ + onboardingmap["group"].(string), + } + + if onboardingmap["admin"].(bool) { + groups = append(groups, onboardingmap["group"].(string)+":admin") + } + + display_name := firstName + " " + lastName + account := &ma.Account{ + Authentication: ma.AccountAuth{ + Local: ma.LocalAuth{ + Username: onboardingmap["username"].(string), + Password: password, + }, + }, + Namespace: "parcoursmob", + Data: map[string]any{ + "display_name": display_name, + "first_name": firstName, + "last_name": lastName, + "email": onboardingmap["username"], + "groups": groups, + }, + } + + acc, err := mobilityaccounts.AccountFromStorageType(account) + if err != nil { + return nil, err + } + + request := &mobilityaccounts.RegisterRequest{ + Account: acc, + } + + _, err = h.services.GRPC.MobilityAccounts.Register(context.TODO(), request) + if err != nil { + return nil, err + } + + err = h.cache.Delete("onboarding/" + key) + if err != nil { + log.Error().Err(err).Msg("Failed to delete onboarding key") + } + + return &OnboardingResult{Success: true}, nil +} + +func (h *ApplicationHandler) GetOnboardingData(key string) (map[string]any, error) { + onboarding, err := h.cache.Get("onboarding/" + key) + if err != nil { + return nil, err + } + return onboarding.(map[string]any), nil +} + +type UserGroupsResult struct { + Groups []groupsstorage.Group +} + +func (h *ApplicationHandler) GetUserGroups(idtoken *oidc.IDToken) (*UserGroupsResult, error) { + var claims map[string]any + err := idtoken.Claims(&claims) + if err != nil { + return nil, err + } + + g := claims["groups"] + groups_interface, ok := g.([]any) + if !ok { + return nil, errors.New("invalid groups format") + } + + groups := []string{} + for _, v := range groups_interface { + groups = append(groups, v.(string)) + } + + request := &grpcapi.GetGroupsBatchRequest{ + Groupids: groups, + } + + resp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), request) + if err != nil { + return nil, err + } + + var groupsresponse []groupsstorage.Group + for _, group := range resp.Groups { + if group.Namespace != "parcoursmob_organizations" { + continue + } + g := group.ToStorageType() + groupsresponse = append(groupsresponse, g) + } + + return &UserGroupsResult{Groups: groupsresponse}, nil +} \ No newline at end of file diff --git a/core/application/beneficiaries.go b/core/application/beneficiaries.go new file mode 100644 index 0000000..ce687fe --- /dev/null +++ b/core/application/beneficiaries.go @@ -0,0 +1,927 @@ +package application + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "image/png" + "io" + "net/http" + "sort" + "strings" + "time" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + profilepictures "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/profile-pictures" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi" + agendastorage "git.coopgo.io/coopgo-platform/agenda/storage" + "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" + 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" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" + solidaritytransformers "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" + solidaritytypes "git.coopgo.io/coopgo-platform/solidarity-transport/types" + "github.com/google/uuid" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type BeneficiariesResult struct { + Accounts []mobilityaccountsstorage.Account + CacheID string +} + +func (h *ApplicationHandler) GetBeneficiaries(ctx context.Context, searchFilter string, archivedFilter bool) (*BeneficiariesResult, error) { + accounts, err := h.getBeneficiariesWithFilters(ctx, searchFilter, archivedFilter) + if err != nil { + return nil, err + } + + sort.Sort(sorting.BeneficiariesByName(accounts)) + + cacheID := uuid.NewString() + h.cache.PutWithTTL(cacheID, accounts, 1*time.Hour) + + return &BeneficiariesResult{ + Accounts: accounts, + CacheID: cacheID, + }, nil +} + +func (h *ApplicationHandler) CreateBeneficiary(ctx context.Context, firstName, lastName, email string, birthdate *time.Time, phoneNumber, fileNumber string, address any, gender string, otherProperties any) (string, error) { + // Get current group + g := ctx.Value(identification.GroupKey) + if g == nil { + return "", fmt.Errorf("no group found in context") + } + group := g.(storage.Group) + + // Create data map for the beneficiary + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "file_number": fileNumber, + "gender": gender, + } + + // Convert birthdate to string format for structpb compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format("2006-01-02") + } + + if address != nil { + dataMap["address"] = address + } + if otherProperties != nil { + dataMap["other_properties"] = otherProperties + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.RegisterRequest{ + Account: &mobilityaccounts.Account{ + Namespace: "parcoursmob_beneficiaries", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.Register(ctx, request) + if err != nil { + return "", err + } + + subscribe := &groupsmanagement.SubscribeRequest{ + Groupid: group.ID, + Memberid: resp.Account.Id, + } + + _, err = h.services.GRPC.GroupsManagement.Subscribe(ctx, subscribe) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +type BeneficiaryDataResult struct { + Account mobilityaccountsstorage.Account + Bookings []fleetsstorage.Booking + Organizations []any + Documents []filestorage.FileInfo + EventsList []Event_Beneficiary + SolidarityTransportStats map[string]int64 + SolidarityTransportBookings []*solidaritytypes.Booking + SolidarityDriversMap map[string]mobilityaccountsstorage.Account + OrganizedCarpoolStats map[string]int64 + OrganizedCarpoolBookings []*proto.CarpoolServiceBooking + OrganizedCarpoolDriversMap map[string]mobilityaccountsstorage.Account + WalletBalance float64 +} + +func (h *ApplicationHandler) GetBeneficiaryData(ctx context.Context, beneficiaryID string) (*BeneficiaryDataResult, error) { + // Get beneficiary account + request := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a beneficiary account + if resp.Account.Namespace != "parcoursmob_beneficiaries" { + return nil, fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, resp.Account.Namespace) + } + + account := resp.Account.ToStorageType() + + // Get documents + documents := h.filestorage.List(filestorage.PREFIX_BENEFICIARIES + "/" + beneficiaryID) + + // Get events subscriptions + subscriptionRequest := &agenda.GetSubscriptionByUserRequest{ + Subscriber: beneficiaryID, + } + + subscriptionResp, err := h.services.GRPC.Agenda.GetSubscriptionByUser(ctx, subscriptionRequest) + if err != nil { + return nil, err + } + + events := []agendastorage.Event{} + currentTime := time.Now().Truncate(24 * time.Hour) + + for _, e := range subscriptionResp.Subscription { + eventRequest := &agenda.GetEventRequest{ + Id: e.Eventid, + } + eventResp, err := h.services.GRPC.Agenda.GetEvent(ctx, eventRequest) + if err != nil { + return nil, err + } + events = append(events, eventResp.Event.ToStorageType()) + } + + sort.Sort(sorting.EventsByStartdate(events)) + + // Get bookings + bookingsRequest := &fleets.GetDriverBookingsRequest{ + Driver: beneficiaryID, + } + bookingsResp, err := h.services.GRPC.Fleets.GetDriverBookings(ctx, bookingsRequest) + if err != nil { + return nil, err + } + + bookings := []fleetsstorage.Booking{} + for _, b := range bookingsResp.Bookings { + bookings = append(bookings, b.ToStorageType()) + } + + // Build events list + var eventsList []Event_Beneficiary + var statusEvent int + + for _, e := range events { + if e.Startdate.After(currentTime) { + statusEvent = 1 + } else if e.Startdate.Before(currentTime) && e.Enddate.After(currentTime) || e.Enddate.Equal(currentTime) { + statusEvent = 2 + } else { + statusEvent = 3 + } + + event := Event{ + NameVal: e.Name, + DateVal: e.Startdate, + DateEndVal: e.Enddate, + TypeVal: e.Type, + IDVal: e.ID, + DbVal: "/app/agenda/", + IconSet: "calendar", + StatusVal: statusEvent, + } + + eventsList = append(eventsList, event) + } + + // Add vehicle bookings to events list + var statusBooking int + for _, b := range bookings { + if b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) { + getVehicleRequest := &fleets.GetVehicleRequest{ + Vehicleid: b.Vehicleid, + } + + getVehicleResp, err := h.services.GRPC.Fleets.GetVehicle(ctx, getVehicleRequest) + if err != nil { + return nil, err + } + + if b.Startdate.After(currentTime) { + statusBooking = 1 + } else if b.Startdate.Before(currentTime) && b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) { + statusBooking = 2 + } else { + statusBooking = 3 + } + + event := Event{ + NameVal: getVehicleResp.Vehicle.ToStorageType().Data["name"].(string), + DateVal: b.Startdate, + DateEndVal: b.Enddate, + TypeVal: "Réservation de véhicule", + IDVal: b.ID, + DbVal: "/app/vehicles-management/bookings/", + IconSet: "vehicle", + StatusVal: statusBooking, + } + + eventsList = append(eventsList, event) + } + } + + // Get solidarity transport bookings (all statuses for display) + solidarityResp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, &gen.GetSolidarityTransportBookingsRequest{ + Passengerid: beneficiaryID, + StartDate: timestamppb.New(time.Now().Add(-365 * 24 * time.Hour)), + EndDate: timestamppb.New(time.Now().Add(365 * 24 * time.Hour)), + }) + + protoBookings := []*gen.SolidarityTransportBooking{} + if err == nil { + protoBookings = solidarityResp.Bookings + } else { + log.Error().Err(err).Msg("error retrieving solidarity transport bookings for beneficiary") + } + + // Convert proto bookings to types with geojson.Feature + solidarityTransportBookings := []*solidaritytypes.Booking{} + for _, protoBooking := range protoBookings { + booking, err := solidaritytransformers.BookingProtoToType(protoBooking) + if err != nil { + log.Error().Err(err).Msg("error converting booking proto to type") + continue + } + solidarityTransportBookings = append(solidarityTransportBookings, booking) + } + + // Collect unique driver IDs + driverIDs := []string{} + driverIDsMap := make(map[string]bool) + for _, booking := range solidarityTransportBookings { + if booking.DriverId != "" { + if !driverIDsMap[booking.DriverId] { + driverIDs = append(driverIDs, booking.DriverId) + driverIDsMap[booking.DriverId] = true + } + } + } + + // Get drivers in batch + driversMap := make(map[string]mobilityaccountsstorage.Account) + if len(driverIDs) > 0 { + driversResp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: driverIDs, + }) + if err == nil { + for _, account := range driversResp.Accounts { + a := account.ToStorageType() + driversMap[a.ID] = a + } + } + } + + // Calculate stats only for validated bookings + solidarityTransportStats := map[string]int64{ + "count": 0, + "km": 0, + } + + for _, b := range solidarityTransportBookings { + if b.Status == "VALIDATED" { + solidarityTransportStats["count"] = solidarityTransportStats["count"] + 1 + if b.Journey != nil { + solidarityTransportStats["km"] = solidarityTransportStats["km"] + b.Journey.PassengerDistance + } + + // Add to events list + event := Event{ + NameVal: fmt.Sprintf("%s (%d km)", b.Journey.PassengerDrop.Properties.MustString("label", ""), b.Journey.PassengerDistance), + DateVal: b.Journey.PassengerPickupDate, + DateEndVal: b.Journey.PassengerPickupDate, + TypeVal: "Transport solidaire", + IDVal: b.Id, + DbVal: "/app/solidarity-transport/bookings/", + IconSet: "vehicle", + StatusVal: 1, + } + + eventsList = append(eventsList, event) + } + } + + // Get organized carpool bookings + carpoolBookingsResp, err := h.services.GRPC.CarpoolService.GetUserBookings(ctx, &proto.GetUserBookingsRequest{ + UserId: beneficiaryID, + }) + + organizedCarpoolBookings := []*proto.CarpoolServiceBooking{} + if err == nil { + organizedCarpoolBookings = carpoolBookingsResp.Bookings + } else { + log.Error().Err(err).Msg("error retrieving organized carpool bookings for beneficiary") + } + + // Collect unique driver IDs from organized carpool bookings + carpoolDriverIDs := []string{} + carpoolDriverIDsMap := make(map[string]bool) + for _, booking := range organizedCarpoolBookings { + if booking.Driver != nil && booking.Driver.Id != "" { + if !carpoolDriverIDsMap[booking.Driver.Id] { + carpoolDriverIDs = append(carpoolDriverIDs, booking.Driver.Id) + carpoolDriverIDsMap[booking.Driver.Id] = true + } + } + } + + // Get organized carpool drivers in batch + organizedCarpoolDriversMap := make(map[string]mobilityaccountsstorage.Account) + if len(carpoolDriverIDs) > 0 { + carpoolDriversResp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: carpoolDriverIDs, + }) + if err == nil { + for _, account := range carpoolDriversResp.Accounts { + a := account.ToStorageType() + organizedCarpoolDriversMap[a.ID] = a + } + } + } + + // Calculate organized carpool stats (only confirmed bookings) + organizedCarpoolStats := map[string]int64{ + "count": 0, + "km": 0, + } + + for _, cb := range organizedCarpoolBookings { + if cb.Status == proto.CarpoolServiceBookingStatus_CONFIRMED { + organizedCarpoolStats["count"]++ + if cb.Distance != nil { + organizedCarpoolStats["km"] += *cb.Distance + } + + // Build journey name from drop address and distance for events + journeyName := "Covoiturage" + if cb.PassengerDropAddress != nil { + if cb.Distance != nil { + journeyName = fmt.Sprintf("%s (%d km)", *cb.PassengerDropAddress, *cb.Distance) + } else { + journeyName = *cb.PassengerDropAddress + } + } + + // Get departure date + departureDate := time.Now() + if cb.PassengerPickupDate != nil { + departureDate = cb.PassengerPickupDate.AsTime() + } + + event := Event{ + NameVal: journeyName, + DateVal: departureDate, + DateEndVal: departureDate, + TypeVal: "Covoiturage solidaire", + IDVal: cb.Id, + DbVal: "/app/organized-carpool/bookings/", + IconSet: "vehicle", + StatusVal: 1, + } + + eventsList = append(eventsList, event) + } + } + + sortByDate(eventsList) + + // Get organizations + groupsRequest := &groupsmanagement.GetGroupsRequest{ + Namespaces: []string{"parcoursmob_organizations"}, + Member: beneficiaryID, + } + + groupsResp, err := h.services.GRPC.GroupsManagement.GetGroups(ctx, groupsRequest) + if err != nil { + return nil, err + } + + organizations := []any{} + for _, o := range groupsResp.Groups { + organizations = append(organizations, o.ToStorageType()) + } + + // Calculate wallet balance + walletBalance := h.calculateWalletBalance(account) + + return &BeneficiaryDataResult{ + Account: account, + Bookings: bookings, + Organizations: organizations, + Documents: documents, + EventsList: eventsList, + SolidarityTransportStats: solidarityTransportStats, + SolidarityTransportBookings: solidarityTransportBookings, + SolidarityDriversMap: driversMap, + OrganizedCarpoolStats: organizedCarpoolStats, + OrganizedCarpoolBookings: organizedCarpoolBookings, + OrganizedCarpoolDriversMap: organizedCarpoolDriversMap, + WalletBalance: walletBalance, + }, nil +} + +type BeneficiaryResult struct { + Account mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetBeneficiary(ctx context.Context, beneficiaryID string) (*BeneficiaryResult, error) { + request := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a beneficiary account + if resp.Account.Namespace != "parcoursmob_beneficiaries" { + return nil, fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, resp.Account.Namespace) + } + + return &BeneficiaryResult{ + Account: resp.Account.ToStorageType(), + }, nil +} + +func (h *ApplicationHandler) UpdateBeneficiary(ctx context.Context, beneficiaryID, firstName, lastName, email string, birthdate *time.Time, phoneNumber, fileNumber string, address any, gender string, otherProperties any) (string, error) { + // Security check: verify the account exists and is a beneficiary + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return "", err + } + if getResp.Account.Namespace != "parcoursmob_beneficiaries" { + return "", fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, getResp.Account.Namespace) + } + + // Create data map for the beneficiary + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "file_number": fileNumber, + "gender": gender, + } + + // Handle birthdate conversion for protobuf compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format(time.RFC3339) + } + + if address != nil { + dataMap["address"] = address + } + if otherProperties != nil { + dataMap["other_properties"] = otherProperties + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: beneficiaryID, + Namespace: "parcoursmob_beneficiaries", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +func (h *ApplicationHandler) ArchiveBeneficiary(ctx context.Context, beneficiaryID string) error { + // Security check: verify the account exists and is a beneficiary + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "parcoursmob_beneficiaries" { + return fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, getResp.Account.Namespace) + } + + data, err := structpb.NewValue(map[string]any{ + "archived": true, + }) + if err != nil { + return err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: beneficiaryID, + Namespace: "parcoursmob_beneficiaries", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) UnarchiveBeneficiary(ctx context.Context, beneficiaryID string) error { + // Security check: verify the account exists and is a beneficiary + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "parcoursmob_beneficiaries" { + return fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, getResp.Account.Namespace) + } + + data, err := structpb.NewValue(map[string]any{ + "archived": false, + }) + if err != nil { + return err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: beneficiaryID, + Namespace: "parcoursmob_beneficiaries", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) GetBeneficiaryPicture(ctx context.Context, beneficiaryID string) ([]byte, string, error) { + request := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, "", err + } + + // Security check: ensure this is actually a beneficiary account + // if resp.Account.Namespace != "parcoursmob_beneficiaries" { + // return nil, "", fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, resp.Account.Namespace) + // } + + account := resp.Account.ToStorageType() + + firstName, ok := account.Data["first_name"].(string) + if !ok || firstName == "" { + firstName = "U" + } + lastName, ok := account.Data["last_name"].(string) + if !ok || lastName == "" { + lastName = "U" + } + + initials := strings.ToUpper(string(firstName[0]) + string(lastName[0])) + picture := profilepictures.DefaultProfilePicture(initials) + + buffer := new(bytes.Buffer) + if err := png.Encode(buffer, picture); err != nil { + return nil, "", err + } + + return buffer.Bytes(), "image/png", nil +} + +func (h *ApplicationHandler) AddBeneficiaryDocument(ctx context.Context, beneficiaryID string, file io.Reader, filename string, fileSize int64, documentType, documentName string) error { + // Security check: verify the account exists and is a beneficiary + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "parcoursmob_beneficiaries" { + return fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, getResp.Account.Namespace) + } + + fileid := uuid.NewString() + + metadata := map[string]string{ + "type": documentType, + "name": documentName, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s_%s", beneficiaryID, fileid, filename), fileSize, metadata); err != nil { + return err + } + + return nil +} + +func (h *ApplicationHandler) GetBeneficiaryDocument(ctx context.Context, beneficiaryID, document string) (io.Reader, *filestorage.FileInfo, error) { + // Security check: verify the account exists and is a beneficiary + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return nil, nil, err + } + if getResp.Account.Namespace != "parcoursmob_beneficiaries" { + return nil, nil, fmt.Errorf("account %s is not a beneficiary (namespace: %s)", beneficiaryID, getResp.Account.Namespace) + } + + file, info, err := h.filestorage.Get(filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s", beneficiaryID, document)) + if err != nil { + return nil, nil, err + } + + return file, info, nil +} + +func (h *ApplicationHandler) DeleteBeneficiaryDocument(ctx context.Context, beneficiaryID, document string) error { + return h.DeleteDocument(ctx, BeneficiaryDocumentConfig, beneficiaryID, document) +} + +func (h *ApplicationHandler) getBeneficiariesWithFilters(ctx context.Context, searchFilter string, archivedFilter bool) ([]mobilityaccountsstorage.Account, error) { + accounts := []mobilityaccountsstorage.Account{} + g := ctx.Value(identification.GroupKey) + if g == nil { + return accounts, errors.New("no group provided") + } + + group := g.(storage.Group) + + request := &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: group.Members, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, request) + if err != nil { + log.Error().Err(err).Msg("issue in mobilityaccounts call") + return accounts, err + } + + for _, account := range resp.Accounts { + if h.filterAccount(account, searchFilter, archivedFilter) { + a := account.ToStorageType() + accounts = append(accounts, a) + } + } + + return accounts, err +} + +func (h *ApplicationHandler) filterAccount(a *mobilityaccounts.Account, searchFilter string, archivedFilter bool) bool { + // Search filter + if searchFilter != "" { + name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) + if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter)) { + return false + } + } + + // Archived filter + if archivedFilter { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return true + } + return false + } else { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return false + } + } + + return true +} + +type Event_Beneficiary interface { + Name() string + Date() time.Time + DateEnd() time.Time + Type() string + Db() string + ID() string + Icons() string + Status() int +} + +type Event struct { + IDVal string + NameVal string + DateVal time.Time + DateEndVal time.Time + TypeVal string + DbVal string + Deleted bool + IconSet string + StatusVal int +} + +func (e Event) Name() string { + return e.NameVal +} + +func (e Event) Date() time.Time { + return e.DateVal +} + +func (e Event) DateEnd() time.Time { + return e.DateEndVal +} + +func (e Event) Type() string { + return e.TypeVal +} + +func (e Event) ID() string { + return e.IDVal +} + +func (e Event) Db() string { + return e.DbVal +} + +func (e Event) Icons() string { + return e.IconSet +} + +func (e Event) Status() int { + return e.StatusVal +} + +func sortByDate(events []Event_Beneficiary) { + sort.Slice(events, func(i, j int) bool { + return events[i].Date().After(events[j].Date()) + }) +} + +// Utility functions needed by other modules +func filterAccount(r *http.Request, a *mobilityaccounts.Account) bool { + searchFilter, ok := r.URL.Query()["search"] + + if ok && len(searchFilter[0]) > 0 { + name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) + if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter[0])) { + return false + } + } + + archivedFilter, ok := r.URL.Query()["archived"] + if ok && archivedFilter[0] == "true" { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return true + } + return false + } else { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return false + } + } + + return true +} + +func (h *ApplicationHandler) beneficiaries(r *http.Request) ([]mobilityaccountsstorage.Account, error) { + accounts := []mobilityaccountsstorage.Account{} + g := r.Context().Value(identification.GroupKey) + if g == nil { + return accounts, errors.New("no group provided") + } + + 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("issue in mobilityaccounts call") + return accounts, err + } + + for _, account := range resp.Accounts { + if filterAccount(r, account) { + a := account.ToStorageType() + accounts = append(accounts, a) + } + } + + return accounts, err +} + +type BeneficiariesForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + Birthdate *time.Time `json:"birthdate" validate:"required"` + PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` + FileNumber string `json:"file_number"` + Address any `json:"address,omitempty"` + Gender string `json:"gender"` + OtherProperties any `json:"other_properties,omitempty"` +} + +func parseBeneficiariesForm(r *http.Request) (map[string]any, error) { + if err := r.ParseForm(); err != nil { + return nil, err + } + + var date *time.Time + + if r.PostFormValue("birthdate") != "" { + d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) + if err != nil { + return nil, err + } + date = &d + } + + formData := BeneficiariesForm{ + FirstName: r.PostFormValue("first_name"), + LastName: r.PostFormValue("last_name"), + Email: r.PostFormValue("email"), + Birthdate: date, + PhoneNumber: r.PostFormValue("phone_number"), + FileNumber: r.PostFormValue("file_number"), + Gender: r.PostFormValue("gender"), + } + + if r.PostFormValue("address") != "" { + var a any + json.Unmarshal([]byte(r.PostFormValue("address")), &a) + formData.Address = a + } + + if r.PostFormValue("other_properties") != "" { + var a any + json.Unmarshal([]byte(r.PostFormValue("other_properties")), &a) + formData.OtherProperties = a + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return nil, err + } + + d, err := json.Marshal(formData) + if err != nil { + return nil, err + } + + var dataMap map[string]any + err = json.Unmarshal(d, &dataMap) + if err != nil { + return nil, err + } + + return dataMap, nil +} diff --git a/core/application/dashboard.go b/core/application/dashboard.go new file mode 100755 index 0000000..5a561b5 --- /dev/null +++ b/core/application/dashboard.go @@ -0,0 +1,228 @@ +package application + +import ( + "context" + "encoding/json" + "fmt" + "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" + 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" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/paulmach/orb" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type DashboardResult struct { + Accounts []mobilityaccountsstorage.Account + Members []mobilityaccountsstorage.Account + Events []agendastorage.Event + Bookings []fleetstorage.Booking + SolidarityDrivers []mobilityaccountsstorage.Account + OrganizedCarpoolDrivers []mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetDashboardData(ctx context.Context, driverAddressGeoLayer, driverAddressGeoCode string) (*DashboardResult, error) { + g := ctx.Value(identification.GroupKey) + if g == nil { + return nil, fmt.Errorf("no group found in context") + } + group := g.(storage.Group) + + // Load geography polygons for driver address filtering + var driverAddressPolygons []orb.Polygon + if driverAddressGeoLayer != "" && driverAddressGeoCode != "" { + polygons, err := h.loadGeographyPolygon(driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load driver address geography filter") + } else { + driverAddressPolygons = polygons + } + } + + // Get accounts (recent beneficiaries) + request := &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: group.Members, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, request) + if err != nil { + return nil, err + } + + accounts := []mobilityaccountsstorage.Account{} + + // We only display the 5 most recent here + count := len(resp.Accounts) + min := count - 5 + if min < 0 { + min = 0 + } + + for _, account := range resp.Accounts[min:] { + // Check if not archived + if archived, ok := account.Data.AsMap()["archived"].(bool); !ok || !archived { + a := account.ToStorageType() + accounts = append([]mobilityaccountsstorage.Account{a}, accounts...) + } + } + + // Fetch remaining data in parallel using goroutines + var wg sync.WaitGroup + var mu sync.Mutex + + var members []mobilityaccountsstorage.Account + var events []agendastorage.Event + var bookings []fleetstorage.Booking + var solidarityDrivers []mobilityaccountsstorage.Account + var organizedCarpoolDrivers []mobilityaccountsstorage.Account + + // Get members + wg.Add(1) + go func() { + defer wg.Done() + m, _, err := h.groupmembers(group.ID) + if err == nil { + mu.Lock() + members = m + mu.Unlock() + } + }() + + // Get events + wg.Add(1) + go func() { + defer wg.Done() + eventsresp, err := h.services.GRPC.Agenda.GetEvents(ctx, &agenda.GetEventsRequest{ + Namespaces: []string{"parcoursmob_dispositifs"}, + Mindate: timestamppb.Now(), + }) + if err == nil { + mu.Lock() + for _, e := range eventsresp.Events { + events = append(events, e.ToStorageType()) + } + sort.Sort(sorting.EventsByStartdate(events)) + mu.Unlock() + } + }() + + // Get bookings + wg.Add(1) + go func() { + defer wg.Done() + bookingsresp, err := h.services.GRPC.Fleets.GetBookings(ctx, &fleets.GetBookingsRequest{ + Namespaces: []string{"parcoursmob_dispositifs"}, + }) + if err == nil { + mu.Lock() + for _, b := range bookingsresp.Bookings { + if b.Enddate.AsTime().After(time.Now()) { + bookings = append(bookings, b.ToStorageType()) + } + } + mu.Unlock() + } + }() + + // Get solidarity transport drivers + wg.Add(1) + go func() { + defer wg.Done() + solidarityRequest := &mobilityaccounts.GetAccountsRequest{ + Namespaces: []string{"solidarity_drivers"}, + } + solidarityResp, err := h.services.GRPC.MobilityAccounts.GetAccounts(ctx, solidarityRequest) + if err == nil { + mu.Lock() + for _, account := range solidarityResp.Accounts { + // Only include non-archived drivers with addresses + if archived, ok := account.Data.AsMap()["archived"].(bool); !ok || !archived { + if address, ok := account.Data.AsMap()["address"]; ok && address != nil { + // Apply geography filter if specified + if len(driverAddressPolygons) > 0 { + if addr, ok := account.Data.AsMap()["address"].(map[string]interface{}); ok { + jsonAddr, err := json.Marshal(addr) + if err == nil { + addrGeojson, err := geojson.UnmarshalFeature(jsonAddr) + if err == nil && addrGeojson.Geometry != nil { + if point, ok := addrGeojson.Geometry.(orb.Point); ok { + if isPointInGeographies(point, driverAddressPolygons) { + solidarityDrivers = append(solidarityDrivers, account.ToStorageType()) + } + } + } + } + } + } else { + solidarityDrivers = append(solidarityDrivers, account.ToStorageType()) + } + } + } + } + mu.Unlock() + } + }() + + // Get organized carpool drivers + wg.Add(1) + go func() { + defer wg.Done() + carpoolRequest := &mobilityaccounts.GetAccountsRequest{ + Namespaces: []string{"organized_carpool_drivers"}, + } + carpoolResp, err := h.services.GRPC.MobilityAccounts.GetAccounts(ctx, carpoolRequest) + if err == nil { + mu.Lock() + for _, account := range carpoolResp.Accounts { + // Only include non-archived drivers with addresses + if archived, ok := account.Data.AsMap()["archived"].(bool); !ok || !archived { + if address, ok := account.Data.AsMap()["address"]; ok && address != nil { + // Apply geography filter if specified + if len(driverAddressPolygons) > 0 { + if addr, ok := account.Data.AsMap()["address"].(map[string]interface{}); ok { + jsonAddr, err := json.Marshal(addr) + if err == nil { + addrGeojson, err := geojson.UnmarshalFeature(jsonAddr) + if err == nil && addrGeojson.Geometry != nil { + if point, ok := addrGeojson.Geometry.(orb.Point); ok { + if isPointInGeographies(point, driverAddressPolygons) { + organizedCarpoolDrivers = append(organizedCarpoolDrivers, account.ToStorageType()) + } + } + } + } + } + } else { + organizedCarpoolDrivers = append(organizedCarpoolDrivers, account.ToStorageType()) + } + } + } + } + mu.Unlock() + } + }() + + // Wait for all goroutines to complete + wg.Wait() + + return &DashboardResult{ + Accounts: accounts, + Members: members, + Events: events, + Bookings: bookings, + SolidarityDrivers: solidarityDrivers, + OrganizedCarpoolDrivers: organizedCarpoolDrivers, + }, nil +} + diff --git a/core/application/directory.go b/core/application/directory.go new file mode 100755 index 0000000..7f9a5e9 --- /dev/null +++ b/core/application/directory.go @@ -0,0 +1,3 @@ +package application + +// Directory module - no business logic needed, all functionality moved to WebServer handlers diff --git a/core/application/documents.go b/core/application/documents.go new file mode 100644 index 0000000..1bdb2b7 --- /dev/null +++ b/core/application/documents.go @@ -0,0 +1,171 @@ +package application + +import ( + "context" + "fmt" + "io" + + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + "github.com/google/uuid" +) + +// DocumentConfig defines entity-specific document configuration +type DocumentConfig struct { + // Storage prefix for this entity type + StoragePrefix string + + // Namespace for account validation (empty if no validation needed) + AccountNamespace string + + // Whether to validate against MobilityAccounts service + RequiresAccountValidation bool + + // Custom validator function (optional) + CustomValidator func(ctx context.Context, entityID string) error +} + +// Pre-configured document configs for each entity type +var ( + BeneficiaryDocumentConfig = DocumentConfig{ + StoragePrefix: filestorage.PREFIX_BENEFICIARIES, + AccountNamespace: "parcoursmob_beneficiaries", + RequiresAccountValidation: true, + } + + SolidarityDriverDocumentConfig = DocumentConfig{ + StoragePrefix: filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS, + AccountNamespace: "solidarity_drivers", + RequiresAccountValidation: true, + } + + OrganizedCarpoolDriverDocumentConfig = DocumentConfig{ + StoragePrefix: filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS, + AccountNamespace: "organized_carpool_drivers", + RequiresAccountValidation: true, + } + + BookingDocumentConfig = DocumentConfig{ + StoragePrefix: filestorage.PREFIX_BOOKINGS, + RequiresAccountValidation: false, + } +) + +// AddDocument adds a document for any entity with validation +func (h *ApplicationHandler) AddDocument( + ctx context.Context, + config DocumentConfig, + entityID string, + file io.Reader, + filename string, + fileSize int64, + documentType string, + documentName string, +) error { + // Perform validation if required + if config.RequiresAccountValidation { + if err := h.validateAccountForDocument(ctx, entityID, config.AccountNamespace); err != nil { + return err + } + } + + // Custom validation if provided + if config.CustomValidator != nil { + if err := config.CustomValidator(ctx, entityID); err != nil { + return err + } + } + + // Generate unique file ID + fileid := uuid.NewString() + + // Prepare metadata + metadata := map[string]string{ + "type": documentType, + "name": documentName, + } + + // Construct file path + filepath := fmt.Sprintf("%s/%s_%s", entityID, fileid, filename) + + // Store file + return h.filestorage.Put(file, config.StoragePrefix, filepath, fileSize, metadata) +} + +// GetDocument retrieves a document for any entity with validation +func (h *ApplicationHandler) GetDocument( + ctx context.Context, + config DocumentConfig, + entityID string, + document string, +) (io.Reader, *filestorage.FileInfo, error) { + // Perform validation if required + if config.RequiresAccountValidation { + if err := h.validateAccountForDocument(ctx, entityID, config.AccountNamespace); err != nil { + return nil, nil, err + } + } + + // Custom validation if provided + if config.CustomValidator != nil { + if err := config.CustomValidator(ctx, entityID); err != nil { + return nil, nil, err + } + } + + // Retrieve file + filepath := fmt.Sprintf("%s/%s", entityID, document) + return h.filestorage.Get(config.StoragePrefix, filepath) +} + +// ListDocuments retrieves all documents for an entity +func (h *ApplicationHandler) ListDocuments( + config DocumentConfig, + entityID string, +) []filestorage.FileInfo { + prefix := fmt.Sprintf("%s/%s", config.StoragePrefix, entityID) + return h.filestorage.List(prefix) +} + +// DeleteDocument deletes a document for any entity with validation +func (h *ApplicationHandler) DeleteDocument( + ctx context.Context, + config DocumentConfig, + entityID string, + document string, +) error { + // Perform validation if required + if config.RequiresAccountValidation { + if err := h.validateAccountForDocument(ctx, entityID, config.AccountNamespace); err != nil { + return err + } + } + + // Custom validation if provided + if config.CustomValidator != nil { + if err := config.CustomValidator(ctx, entityID); err != nil { + return err + } + } + + // Delete file + filepath := fmt.Sprintf("%s/%s", entityID, document) + return h.filestorage.Delete(config.StoragePrefix, filepath) +} + +// validateAccountForDocument validates entity against MobilityAccounts service +func (h *ApplicationHandler) validateAccountForDocument(ctx context.Context, accountID string, expectedNamespace string) error { + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, &mobilityaccounts.GetAccountRequest{ + Id: accountID, + }) + if err != nil { + return err + } + + if resp.Account.Namespace != expectedNamespace { + return fmt.Errorf("account %s is not of type %s (namespace: %s)", + accountID, expectedNamespace, resp.Account.Namespace) + } + + return nil +} diff --git a/core/application/exports.go b/core/application/exports.go new file mode 100644 index 0000000..6473f91 --- /dev/null +++ b/core/application/exports.go @@ -0,0 +1,429 @@ +package application + +import ( + "context" + "encoding/json" + "fmt" + "sort" + "strconv" + + "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" + 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/xuri/excelize/v2" +) + +type FlatMaps []map[string]any + +func (maps FlatMaps) GetHeaders() (res []string) { + keys := map[string]bool{} + for _, m := range maps { + for k, _ := range m { + if _, ok := keys[k]; !ok { + keys[k] = true + res = append(res, k) + } + } + } + sort.Strings(res) + return +} + +func (maps FlatMaps) GetValues() (res [][]string) { + headers := maps.GetHeaders() + for _, m := range maps { + line := []string{} + for _, k := range headers { + if v, ok := m[k]; ok && v != nil { + line = append(line, fmt.Sprint(v)) + } else { + line = append(line, "") + } + } + res = append(res, line) + } + return +} + +type ExportCacheResult struct { + Headers []string + Values [][]string +} + +func (h *ApplicationHandler) ExportCacheAsCSV(cacheID string) (*ExportCacheResult, error) { + d, err := h.cache.Get(cacheID) + if err != nil { + return nil, err + } + + var data []any + if dataSlice, ok := d.([]any); ok { + data = dataSlice + } else { + // Convert single item to slice + jsonData, err := json.Marshal(d) + if err != nil { + return nil, err + } + if err := json.Unmarshal(jsonData, &data); err != nil { + return nil, err + } + } + + flatmaps := FlatMaps{} + for _, v := range data { + if vMap, ok := v.(map[string]any); ok { + fm := map[string]any{} + flatten("", vMap, fm) + flatmaps = append(flatmaps, fm) + } + } + + return &ExportCacheResult{ + Headers: flatmaps.GetHeaders(), + Values: flatmaps.GetValues(), + }, nil +} + +func flatten(prefix string, src map[string]any, dest map[string]any) { + if len(prefix) > 0 { + prefix += "." + } + for k, v := range src { + switch child := v.(type) { + case map[string]any: + flatten(prefix+k, child, dest) + case []any: + for i := 0; i < len(child); i++ { + dest[prefix+k+"."+strconv.Itoa(i)] = child[i] + } + default: + dest[prefix+k] = v + } + } +} + +type AgendaExportResult struct { + ExcelFile *excelize.File +} + +func (h *ApplicationHandler) ExportAllAgendaEvents() (*AgendaExportResult, error) { + resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{ + Namespaces: []string{"parcoursmob_dispositifs"}, + }) + if err != nil { + return nil, err + } + + events := []agendastorage.Event{} + groupids := []string{} + beneficiaries_ids := []string{} + + for _, e := range resp.Events { + groupids = append(groupids, e.Owners...) + events = append(events, e.ToStorageType()) + + for _, subscriptions := range e.Subscriptions { + beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber) + } + } + + sort.Sort(sorting.EventsByStartdate(events)) + + groups, beneficiaries_map, err := h.getAgendaMetadata(groupids, beneficiaries_ids) + if err != nil { + return nil, err + } + + file := h.generateAgendaExcel(events, groups, beneficiaries_map) + return &AgendaExportResult{ExcelFile: file}, nil +} + +func (h *ApplicationHandler) ExportSingleAgendaEvent(eventID string) (*AgendaExportResult, error) { + resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), &agenda.GetEventRequest{ + Id: eventID, + }) + if err != nil { + return nil, err + } + + groupids := []string{} + beneficiaries_ids := []string{} + groupids = append(groupids, resp.Event.Owners...) + + for _, subscriptions := range resp.Event.Subscriptions { + beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber) + } + + groups, beneficiaries_map, err := h.getAgendaMetadata(groupids, beneficiaries_ids) + if err != nil { + return nil, err + } + + events := []agendastorage.Event{resp.Event.ToStorageType()} + file := h.generateAgendaExcel(events, groups, beneficiaries_map) + return &AgendaExportResult{ExcelFile: file}, nil +} + +func (h *ApplicationHandler) getAgendaMetadata(groupids, beneficiaries_ids []string) (map[string]groupsstorage.Group, map[string]accountsstorage.Account, error) { + 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 { + return nil, nil, err + } + + beneficiaries_map := map[string]accountsstorage.Account{} + for _, ben := range beneficiaries.Accounts { + beneficiaries_map[ben.Id] = ben.ToStorageType() + } + + return groups, beneficiaries_map, nil +} + +func (h *ApplicationHandler) generateAgendaExcel(events []agendastorage.Event, groups map[string]groupsstorage.Group, beneficiaries_map map[string]accountsstorage.Account) *excelize.File { + f := excelize.NewFile() + + f.SetCellValue("Sheet1", "A1", "Evénement") + f.SetCellValue("Sheet1", "B1", "Date de début") + f.SetCellValue("Sheet1", "C1", "Date de fin") + f.SetCellValue("Sheet1", "D1", "Nom bénéficiaire") + f.SetCellValue("Sheet1", "E1", "Prenom bénéficiaire") + f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi") + f.SetCellValue("Sheet1", "G1", "Prescipteur") + f.SetCellValue("Sheet1", "H1", "Prescipteur Nom") + f.SetCellValue("Sheet1", "I1", "Prescipteur Email") + f.SetCellValue("Sheet1", "J1", "Gestionnaire événement") + + i := 2 + for _, e := range events { + if len(e.Owners) == 0 { + continue + } + admin := groups[e.Owners[0]] + + for _, s := range e.Subscriptions { + subscribedbygroup := "" + subscribedbyuser := "" + subscribedbyemail := "" + if v, ok := s.Data["subscribed_by"].(map[string]any); ok { + if v2, ok := v["group"].(map[string]any); ok { + if v3, ok := v2["name"].(string); ok { + subscribedbygroup = v3 + } + } + if v4, ok := v["user"].(map[string]any); ok { + if v5, ok := v4["display_name"].(string); ok { + subscribedbyuser = v5 + } + if v6, ok := v4["email"].(string); ok { + subscribedbyemail = v6 + } + } + } + + beneficiary := beneficiaries_map[s.Subscriber] + + f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), e.Name) + f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), e.Startdate.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), e.Enddate.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), beneficiary.Data["last_name"]) + f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), beneficiary.Data["first_name"]) + f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"]) + f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), subscribedbygroup) + f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), subscribedbyuser) + f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), subscribedbyemail) + f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), admin.Data["name"]) + i = i + 1 + } + } + return f +} + +type FleetBookingsExportResult struct { + ExcelFile *excelize.File +} + +func (h *ApplicationHandler) ExportAllFleetBookings() (*FleetBookingsExportResult, error) { + vehicles, bookings, err := h.getFleetData() + if err != nil { + return nil, err + } + + groups, beneficiaries_map, err := h.getFleetMetadata(bookings) + if err != nil { + return nil, err + } + + file := h.generateFleetExcel(bookings, vehicles, groups, beneficiaries_map, "") + return &FleetBookingsExportResult{ExcelFile: file}, nil +} + +func (h *ApplicationHandler) ExportFleetBookingsByGroup(groupID string) (*FleetBookingsExportResult, error) { + vehicles, bookings, err := h.getFleetData() + if err != nil { + return nil, err + } + + groups, beneficiaries_map, err := h.getFleetMetadata(bookings) + if err != nil { + return nil, err + } + + file := h.generateFleetExcel(bookings, vehicles, groups, beneficiaries_map, groupID) + return &FleetBookingsExportResult{ExcelFile: file}, nil +} + +func (h *ApplicationHandler) getFleetData() (map[string]fleetsstorage.Vehicle, []fleetsstorage.Booking, error) { + vehicles := map[string]fleetsstorage.Vehicle{} + bookings := []fleetsstorage.Booking{} + + request := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + } + resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request) + if err != nil { + return nil, nil, err + } + + for _, vehicle := range resp.Vehicles { + v := vehicle.ToStorageType() + for _, b := range v.Bookings { + bookings = append(bookings, b) + } + vehicles[vehicle.Id] = v + } + + return vehicles, bookings, nil +} + +func (h *ApplicationHandler) getFleetMetadata(bookings []fleetsstorage.Booking) (map[string]groupsstorage.Group, map[string]accountsstorage.Account, error) { + beneficiaries_ids := []string{} + for _, b := range bookings { + beneficiaries_ids = append(beneficiaries_ids, b.Driver) + } + + groups := map[string]groupsstorage.Group{} + admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{ + Namespaces: []string{"parcoursmob_organizations"}, + }) + if err != nil { + return nil, 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, nil, err + } + + beneficiaries_map := map[string]accountsstorage.Account{} + for _, ben := range beneficiaries.Accounts { + beneficiaries_map[ben.Id] = ben.ToStorageType() + } + + return groups, beneficiaries_map, nil +} + +func (h *ApplicationHandler) generateFleetExcel(bookings []fleetsstorage.Booking, vehicles map[string]fleetsstorage.Vehicle, groups map[string]groupsstorage.Group, beneficiaries_map map[string]accountsstorage.Account, filterGroupID string) *excelize.File { + f := excelize.NewFile() + + f.SetCellValue("Sheet1", "A1", "Numéro") + f.SetCellValue("Sheet1", "B1", "Type") + f.SetCellValue("Sheet1", "C1", "Gestionnaire") + f.SetCellValue("Sheet1", "D1", "Prescripteur") + f.SetCellValue("Sheet1", "E1", "Bénéficiaire") + f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi") + f.SetCellValue("Sheet1", "G1", "Début de Mise à disposition") + f.SetCellValue("Sheet1", "H1", "Fin de mise à disposition") + f.SetCellValue("Sheet1", "I1", "Début indisponibilité") + f.SetCellValue("Sheet1", "J1", "Fin indisponibilité") + f.SetCellValue("Sheet1", "K1", "Véhicule retiré") + f.SetCellValue("Sheet1", "L1", "Commentaire - Retrait véhicule") + f.SetCellValue("Sheet1", "M1", "Réservation supprimée") + f.SetCellValue("Sheet1", "N1", "Motif de la suppression") + + i := 2 + for _, b := range bookings { + vehicle := vehicles[b.Vehicleid] + if len(vehicle.Administrators) == 0 { + continue + } + admin := groups[vehicle.Administrators[0]] + + bookedby := "" + if v, ok := b.Data["booked_by"].(map[string]any); ok { + if v2, ok := v["user"].(map[string]any); ok { + if v3, ok := v2["display_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 if specified + if filterGroupID != "" && bookedbygroup != filterGroupID { + continue + } + + beneficiary := beneficiaries_map[b.Driver] + adminunavailability := false + + if av, ok := b.Data["administrator_unavailability"].(bool); ok && av { + adminunavailability = true + } + + deleted := "" + if b.Deleted { + deleted = "DELETED" + } + + f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), vehicle.Data["licence_plate"]) + f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), vehicle.Type) + f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), admin.Data["name"]) + f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), bookedby) + f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), fmt.Sprintf("%v %v", beneficiary.Data["first_name"], beneficiary.Data["last_name"])) + f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"]) + f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), b.Startdate.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), b.Enddate.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), b.Unavailablefrom.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), b.Unavailableto.Format("2006-01-02")) + f.SetCellValue("Sheet1", fmt.Sprintf("K%d", i), adminunavailability) + f.SetCellValue("Sheet1", fmt.Sprintf("L%d", i), b.Data["comment"]) + f.SetCellValue("Sheet1", fmt.Sprintf("M%d", i), deleted) + f.SetCellValue("Sheet1", fmt.Sprintf("N%d", i), b.Data["motif"]) + i = i + 1 + } + + return f +} \ No newline at end of file diff --git a/core/application/group.go b/core/application/group.go new file mode 100755 index 0000000..1593077 --- /dev/null +++ b/core/application/group.go @@ -0,0 +1,133 @@ +package application + +import ( + "context" + "crypto/rand" + "encoding/base64" + "fmt" + "io" + "time" + + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + "git.coopgo.io/coopgo-platform/groups-management/storage" + accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + "github.com/rs/zerolog/log" +) + +type GroupSettingsResult struct { + Group storage.Group + GroupMembers []any + Admins []any +} + +func (h *ApplicationHandler) GetGroupSettings(ctx context.Context, groupID string) (*GroupSettingsResult, error) { + // Get group info + groupResp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, &groupsmanagement.GetGroupRequest{ + Id: groupID, + }) + if err != nil { + return nil, fmt.Errorf("failed to get group: %w", err) + } + + group := groupResp.Group.ToStorageType() + + members, err := h.members() + if err != nil { + return nil, fmt.Errorf("failed to get members: %w", err) + } + + admins := []any{} + groupMembers := []any{} + + for _, m := range members { + mm := m.ToStorageType() + if groups, ok := mm.Data["groups"].([]any); ok { + for _, g := range groups { + if g.(string) == groupID { + groupMembers = append(groupMembers, mm) + } + if g.(string) == groupID+":admin" { + admins = append(admins, mm) + } + } + } + } + + return &GroupSettingsResult{ + Group: group, + GroupMembers: groupMembers, + Admins: admins, + }, nil +} + +func (h *ApplicationHandler) InviteMemberToGroup(ctx context.Context, groupID string, 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, &accounts.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 := accounts.AccountFromStorageType(&account) + if err != nil { + return fmt.Errorf("failed to convert account: %w", err) + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, &accounts.UpdateDataRequest{ + Account: as, + }) + if err != nil { + return fmt.Errorf("failed to update account: %w", err) + } + + data := map[string]any{ + "group": group.Data["name"], + } + + 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, + } + + 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 +} diff --git a/core/application/group_module.go b/core/application/group_module.go new file mode 100755 index 0000000..0e22bb4 --- /dev/null +++ b/core/application/group_module.go @@ -0,0 +1,219 @@ +package application + +import ( + "context" + "encoding/json" + "fmt" + "sort" + "strings" + "time" + + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + 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 GroupsResult struct { + Groups []groupstorage.Group +} + +type CreateGroupModuleResult struct { + GroupID string +} + +type GroupModuleCreateDataResult struct { + GroupTypes []string +} + +type DisplayGroupModuleResult struct { + GroupID string + Accounts []any + CacheID string + Searched bool + Beneficiary any + Group groupstorage.Group + AccountsBeneficiaire []mobilityaccountsstorage.Account +} + +var Addres any + +type BeneficiariesGroupForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + Birthdate *time.Time `json:"birthdate"` + PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` + Address any `json:"address,omitempty"` + Gender string `json:"gender"` +} + +type GroupsModuleByName []groupstorage.Group + +func (a GroupsModuleByName) Len() int { return len(a) } +func (a GroupsModuleByName) Less(i, j int) bool { + return strings.Compare(a[i].Data["name"].(string), a[j].Data["name"].(string)) < 0 +} +func (a GroupsModuleByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +func (h *ApplicationHandler) GetGroups(ctx context.Context) (*GroupsResult, error) { + request := &groupsmanagement.GetGroupsRequest{ + Namespaces: []string{"parcoursmob_groups"}, + } + + resp, err := h.services.GRPC.GroupsManagement.GetGroups(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get groups: %w", err) + } + + var groups = []groupstorage.Group{} + + for _, group := range resp.Groups { + g := group.ToStorageType() + groups = append(groups, g) + } + + sort.Sort(GroupsModuleByName(groups)) + + return &GroupsResult{ + Groups: groups, + }, nil +} + +func (h *ApplicationHandler) GetGroupModuleCreateData(ctx context.Context) (*GroupModuleCreateDataResult, error) { + groupTypes := h.config.GetStringSlice("modules.groups.group_types") + return &GroupModuleCreateDataResult{ + GroupTypes: groupTypes, + }, nil +} + +func (h *ApplicationHandler) CreateGroupModule(ctx context.Context, name, groupType, description, address string) (*CreateGroupModuleResult, error) { + if name == "" { + return nil, fmt.Errorf("name is required") + } + if groupType == "" { + return nil, fmt.Errorf("type is required") + } + + var addressData any + if address != "" { + if err := json.Unmarshal([]byte(address), &addressData); err != nil { + return nil, fmt.Errorf("failed to parse address: %w", err) + } + Addres = addressData + } + + groupID := uuid.NewString() + + dataMap := map[string]any{ + "name": name, + "type": groupType, + "description": description, + "address": Addres, + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return nil, fmt.Errorf("failed to create data structure: %w", err) + } + + request := &groupsmanagement.AddGroupRequest{ + Group: &groupsmanagement.Group{ + Id: groupID, + Namespace: "parcoursmob_groups", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.GroupsManagement.AddGroup(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to add group: %w", err) + } + + return &CreateGroupModuleResult{ + GroupID: groupID, + }, nil +} + +func filterAccountBySearch(searchFilter string, a *mobilityaccounts.Account) bool { + if searchFilter != "" { + name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) + if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter)) { + return false + } + } + return true +} +func (h *ApplicationHandler) DisplayGroupModule(ctx context.Context, groupID string, searchFilter string, currentUserGroup groupstorage.Group) (*DisplayGroupModuleResult, error) { + request := &groupsmanagement.GetGroupRequest{ + Id: groupID, + } + + resp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get group: %w", err) + } + + var accounts = []any{} + + accountsRequest := &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: resp.Group.Members, + } + + accountsResp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, accountsRequest) + if err != nil { + log.Warn().Err(err).Msg("failed to get accounts batch") + } else { + for _, account := range accountsResp.Accounts { + if filterAccountBySearch(searchFilter, account) { + a := account.ToStorageType() + accounts = append(accounts, a) + } + } + } + + cacheID := uuid.NewString() + h.cache.PutWithTTL(cacheID, accounts, 1*time.Hour) + + // Get beneficiaries in current user's group + accountsBeneficiaire, err := h.services.GetBeneficiariesInGroup(currentUserGroup) + if err != nil { + return nil, fmt.Errorf("failed to get beneficiaries in group: %w", err) + } + + return &DisplayGroupModuleResult{ + GroupID: resp.Group.ToStorageType().ID, + Accounts: accounts, + CacheID: cacheID, + Searched: false, + Beneficiary: nil, + Group: resp.Group.ToStorageType(), + AccountsBeneficiaire: accountsBeneficiaire, + }, nil +} + +func (h *ApplicationHandler) SubscribeBeneficiaryToGroup(ctx context.Context, groupID string, beneficiaryID string) error { + beneficiaryRequest := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + + beneficiaryResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, beneficiaryRequest) + if err != nil { + return fmt.Errorf("failed to get beneficiary: %w", err) + } + + subscribe := &groupsmanagement.SubscribeRequest{ + Groupid: groupID, + Memberid: beneficiaryResp.Account.Id, + } + + _, err = h.services.GRPC.GroupsManagement.Subscribe(ctx, subscribe) + if err != nil { + return fmt.Errorf("failed to subscribe beneficiary to group: %w", err) + } + + return nil +} diff --git a/core/application/journeys.go b/core/application/journeys.go new file mode 100755 index 0000000..04655dd --- /dev/null +++ b/core/application/journeys.go @@ -0,0 +1,401 @@ +package application + +import ( + "context" + "fmt" + "slices" + "sort" + "strings" + "sync" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" + carpoolproto "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" + fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi" + fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/multimodal-routing/libs/transit/transitous" + savedsearchtypes "git.coopgo.io/coopgo-platform/saved-search/data/types" + savedsearchproto "git.coopgo.io/coopgo-platform/saved-search/servers/grpc/proto/gen" + savedsearchtransformers "git.coopgo.io/coopgo-platform/saved-search/servers/grpc/transformers" + "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" + "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" + + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type SearchJourneysResult struct { + CarpoolResults []*geojson.FeatureCollection + TransitResults []*transitous.Itinerary + VehicleResults []fleetsstorage.Vehicle + Searched bool + DriverJourneys []*gen.SolidarityTransportDriverJourney + Drivers map[string]mobilityaccountsstorage.Account + OrganizedCarpools []*carpoolproto.CarpoolServiceDriverJourney + KnowledgeBaseResults []any +} + +// SearchJourneys performs the business logic for journey search +func (h *ApplicationHandler) SearchJourneys( + ctx context.Context, + departureDateTime time.Time, + departureGeo *geojson.Feature, + destinationGeo *geojson.Feature, + passengerID string, + solidarityTransportExcludeDriver string, +) (*SearchJourneysResult, error) { + var ( + // Results + transitResults []*transitous.Itinerary + carpoolResults []*geojson.FeatureCollection + vehicleResults []fleetsstorage.Vehicle + solidarityTransportResults []*gen.SolidarityTransportDriverJourney + organizedCarpoolResults []*carpoolproto.CarpoolServiceDriverJourney + knowledgeBaseResults []any + + drivers = map[string]mobilityaccountsstorage.Account{} + searched = false + ) + + // Only search if we have complete departure and destination info + if departureGeo != nil && destinationGeo != nil && !departureDateTime.IsZero() { + searched = true + + // SOLIDARITY TRANSPORT + var err error + drivers, err = h.services.GetAccountsInNamespacesMap([]string{"solidarity_drivers", "organized_carpool_drivers"}) + if err != nil { + drivers = map[string]mobilityaccountsstorage.Account{} + } + + protodep, _ := transformers.GeoJsonToProto(departureGeo) + protodest, _ := transformers.GeoJsonToProto(destinationGeo) + + log.Debug().Time("departure time", departureDateTime).Msg("calling driver journeys with ...") + + res, err := h.services.GRPC.SolidarityTransport.GetDriverJourneys(ctx, &gen.GetDriverJourneysRequest{ + Departure: protodep, + Arrival: protodest, + DepartureDate: timestamppb.New(departureDateTime), + }) + if err != nil { + log.Error().Err(err).Msg("error in grpc call to GetDriverJourneys") + } else { + solidarityTransportResults = slices.Collect(func(yield func(*gen.SolidarityTransportDriverJourney) bool) { + for _, dj := range res.DriverJourneys { + if a, ok := drivers[dj.DriverId].Data["archived"]; ok { + if archived, ok := a.(bool); ok { + if archived { + continue + } + } + } + if dj.DriverId == solidarityTransportExcludeDriver { + continue + } + if !yield(dj) { + return + } + } + }) + sort.Slice(solidarityTransportResults, func(i, j int) bool { + return solidarityTransportResults[i].DriverDistance < solidarityTransportResults[j].DriverDistance + }) + } + + // Get departure and destination addresses from properties + var departureAddress, destinationAddress string + if departureGeo.Properties != nil { + if label, ok := departureGeo.Properties["label"].(string); ok { + departureAddress = label + } + } + if destinationGeo.Properties != nil { + if label, ok := destinationGeo.Properties["label"].(string); ok { + destinationAddress = label + } + } + + radius := float64(5) + // ORGANIZED CARPOOL + organizedCarpoolResultsRes, err := h.services.GRPC.CarpoolService.DriverJourneys(ctx, &carpoolproto.DriverJourneysRequest{ + DepartureLat: departureGeo.Point().Lat(), + DepartureLng: departureGeo.Point().Lon(), + ArrivalLat: destinationGeo.Point().Lat(), + ArrivalLng: destinationGeo.Point().Lon(), + DepartureDate: timestamppb.New(departureDateTime), + DepartureAddress: &departureAddress, + ArrivalAddress: &destinationAddress, + DepartureRadius: &radius, + ArrivalRadius: &radius, + }) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpools") + } else { + organizedCarpoolResults = organizedCarpoolResultsRes.DriverJourneys + sort.Slice(organizedCarpoolResults, func(i, j int) bool { + return *organizedCarpoolResults[i].Distance < *organizedCarpoolResults[j].Distance + }) + } + + var wg sync.WaitGroup + // CARPOOL OPERATORS + carpools := make(chan *geojson.FeatureCollection) + go h.services.InteropCarpool.Search(carpools, *departureGeo, *destinationGeo, departureDateTime) + wg.Add(1) + go func() { + defer wg.Done() + for c := range carpools { + carpoolResults = append(carpoolResults, c) + } + }() + + // TRANSIT + transitch := make(chan *transitous.Itinerary) + go func(transitch chan *transitous.Itinerary, departure *geojson.Feature, destination *geojson.Feature, datetime *time.Time) { + defer close(transitch) + response, err := h.services.TransitRouting.PlanWithResponse(ctx, &transitous.PlanParams{ + FromPlace: fmt.Sprintf("%f,%f", departure.Point().Lat(), departure.Point().Lon()), + ToPlace: fmt.Sprintf("%f,%f", destination.Point().Lat(), destination.Point().Lon()), + Time: datetime, + }) + if err != nil { + log.Error().Err(err).Msg("error retrieving transit data from Transitous server") + return + } + for _, i := range response.Itineraries { + transitch <- &i + } + }(transitch, departureGeo, destinationGeo, &departureDateTime) + wg.Add(1) + go func() { + defer wg.Done() + paris, _ := time.LoadLocation("Europe/Paris") + requestedDay := departureDateTime.In(paris).Truncate(24 * time.Hour) + + for itinerary := range transitch { + // Only include journeys that start on the requested day (in Paris timezone) + if !itinerary.StartTime.IsZero() && !itinerary.EndTime.IsZero() { + log.Info(). + Time("startTime", itinerary.StartTime). + Time("endTime", itinerary.EndTime). + Str("startTimezone", itinerary.StartTime.Location().String()). + Str("endTimezone", itinerary.EndTime.Location().String()). + Str("startTimeRFC3339", itinerary.StartTime.Format(time.RFC3339)). + Str("endTimeRFC3339", itinerary.EndTime.Format(time.RFC3339)). + Msg("Journey search - received transit itinerary from Transitous") + + startInParis := itinerary.StartTime.In(paris) + startDay := startInParis.Truncate(24 * time.Hour) + + // Check if journey starts on the requested day + if startDay.Equal(requestedDay) { + transitResults = append(transitResults, itinerary) + } else { + log.Info(). + Str("requestedDay", requestedDay.Format("2006-01-02")). + Str("startDay", startDay.Format("2006-01-02")). + Msg("Journey search - filtered out transit journey (not on requested day)") + } + } + } + }() + + // VEHICLES + vehiclech := make(chan fleetsstorage.Vehicle) + go h.vehicleRequest(vehiclech, departureDateTime.Add(-24*time.Hour), departureDateTime.Add(168*time.Hour)) + wg.Add(1) + go func() { + defer wg.Done() + for vehicle := range vehiclech { + vehicleResults = append(vehicleResults, vehicle) + } + slices.SortFunc(vehicleResults, sorting.VehiclesByDistanceFrom(*departureGeo)) + }() + wg.Wait() + + // KNOWLEDGE BASE + departureGeoSearch, _ := h.services.Geography.GeoSearch(departureGeo) + kbData := h.config.Get("knowledge_base") + if kb, ok := kbData.([]any); ok { + for _, sol := range kb { + if solution, ok := sol.(map[string]any); ok { + if g, ok := solution["geography"]; ok { + if geography, ok := g.([]any); ok { + for _, gg := range geography { + if geog, ok := gg.(map[string]any); ok { + if layer, ok := geog["layer"].(string); ok { + code := geog["code"] + geo, err := h.services.Geography.Find(layer, fmt.Sprintf("%v", code)) + if err == nil { + geog["geography"] = geo + geog["name"] = geo.Properties.MustString("nom") + } + if strings.Compare(fmt.Sprintf("%v", code), departureGeoSearch[layer].Properties.MustString("code")) == 0 { + knowledgeBaseResults = append(knowledgeBaseResults, solution) + break + } + } + } + } + } + } + } + } + } + } + + return &SearchJourneysResult{ + CarpoolResults: carpoolResults, + TransitResults: transitResults, + VehicleResults: vehicleResults, + Searched: searched, + DriverJourneys: solidarityTransportResults, + Drivers: drivers, + OrganizedCarpools: organizedCarpoolResults, + KnowledgeBaseResults: knowledgeBaseResults, + }, nil +} + +func (h *ApplicationHandler) vehicleRequest(vehiclech chan fleetsstorage.Vehicle, start time.Time, end time.Time) { + defer close(vehiclech) + vehiclerequest := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + } + vehicleresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), vehiclerequest) + if err != nil { + log.Error().Err(err).Msg("") + return + } + for _, vehicle := range vehicleresp.Vehicles { + v := vehicle.ToStorageType() + if v.Free(start, end) { + vehiclech <- v + } + } +} + +// SaveSearch saves a group's search to the saved-search microservice +func (h *ApplicationHandler) SaveSearch( + ctx context.Context, + groupID string, + departureDateTime time.Time, + departureGeo *geojson.Feature, + destinationGeo *geojson.Feature, + additionalData map[string]interface{}, +) error { + // Convert geojson.Feature to proto format + var protoDepart, protoDest *savedsearchproto.SavedSearchGeoJsonFeature + + log.Debug(). + Bool("departure_nil", departureGeo == nil). + Bool("destination_nil", destinationGeo == nil). + Msg("SaveSearch: checking geo features") + + if departureGeo != nil { + departureBytes, err := departureGeo.MarshalJSON() + if err != nil { + return fmt.Errorf("error marshaling departure: %w", err) + } + protoDepart = &savedsearchproto.SavedSearchGeoJsonFeature{ + Serialized: string(departureBytes), + } + log.Debug().Str("departure_json", string(departureBytes)).Msg("SaveSearch: departure converted") + } + + if destinationGeo != nil { + destinationBytes, err := destinationGeo.MarshalJSON() + if err != nil { + return fmt.Errorf("error marshaling destination: %w", err) + } + protoDest = &savedsearchproto.SavedSearchGeoJsonFeature{ + Serialized: string(destinationBytes), + } + log.Debug().Str("destination_json", string(destinationBytes)).Msg("SaveSearch: destination converted") + } + + // Convert additional data to protobuf Struct + var protoData *structpb.Struct + if additionalData != nil && len(additionalData) > 0 { + var err error + protoData, err = structpb.NewStruct(additionalData) + if err != nil { + return fmt.Errorf("error converting additional data: %w", err) + } + } + + // Handle zero time value + var protoDateTime *timestamppb.Timestamp + if !departureDateTime.IsZero() { + protoDateTime = timestamppb.New(departureDateTime) + } + + // Call the saved-search service + _, err := h.services.GRPC.SavedSearch.CreateSavedSearch(ctx, &savedsearchproto.CreateSavedSearchRequest{ + OwnerId: groupID, + Departure: protoDepart, + Destination: protoDest, + Datetime: protoDateTime, + Data: protoData, + }) + if err != nil { + return fmt.Errorf("error calling saved-search service: %w", err) + } + + log.Info().Str("group_id", groupID).Msg("search saved successfully") + return nil +} + +// GetSavedSearchesByOwner retrieves saved searches for a group +func (h *ApplicationHandler) GetSavedSearchesByOwner( + ctx context.Context, + groupID string, +) ([]*savedsearchtypes.SavedSearch, error) { + // Call the saved-search service to get searches by owner + response, err := h.services.GRPC.SavedSearch.GetSavedSearchesByOwner(ctx, &savedsearchproto.GetSavedSearchesByOwnerRequest{ + OwnerId: groupID, + }) + if err != nil { + return nil, fmt.Errorf("error calling saved-search service: %w", err) + } + + // Convert protobuf searches to domain types + var searches []*savedsearchtypes.SavedSearch + for _, protoSearch := range response.SavedSearches { + search, err := savedsearchtransformers.SavedSearchProtoToType(protoSearch) + if err != nil { + log.Error().Err(err).Str("search_id", protoSearch.Id).Msg("failed to convert saved search") + continue + } + searches = append(searches, search) + } + + // Sort searches by datetime (earliest first) + sort.Slice(searches, func(i, j int) bool { + return searches[i].DateTime.Before(searches[j].DateTime) + }) + + return searches, nil +} + +// DeleteSavedSearch deletes a saved search by ID for the specified owner +func (h *ApplicationHandler) DeleteSavedSearch( + ctx context.Context, + searchID string, + ownerID string, +) error { + // Call the saved-search service to delete the search + _, err := h.services.GRPC.SavedSearch.DeleteSavedSearch(ctx, &savedsearchproto.DeleteSavedSearchRequest{ + Id: searchID, + OwnerId: ownerID, // For authorization - ensure only the owner can delete + }) + if err != nil { + return fmt.Errorf("error calling saved-search service: %w", err) + } + + log.Info().Str("search_id", searchID).Str("owner_id", ownerID).Msg("saved search deleted successfully") + return nil +} diff --git a/core/application/members.go b/core/application/members.go new file mode 100755 index 0000000..f926282 --- /dev/null +++ b/core/application/members.go @@ -0,0 +1,247 @@ +package application + +import ( + "context" + "fmt" + "strings" + "time" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/google/uuid" + "google.golang.org/protobuf/types/known/structpb" +) + +type MembersResult struct { + Accounts []mobilityaccountsstorage.Account + CacheID string + GroupsNames []string +} + +func (h *ApplicationHandler) GetMembers(ctx context.Context) (*MembersResult, error) { + accounts, err := h.services.GetAccounts() + if err != nil { + return nil, err + } + + var groupsNames []string + + for _, v := range accounts { + adminid := v.ID + request := &mobilityaccounts.GetAccountRequest{ + Id: adminid, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + var allIds []string + for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) { + s := fmt.Sprintf("%v", v) + if !(strings.Contains(s, "admin")) { + allIds = append(allIds, s) + } + } + + reques := &groupsmanagement.GetGroupsBatchRequest{ + Groupids: allIds, + } + + res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(ctx, reques) + if err != nil { + return nil, err + } + + g := "" + for _, group := range res.Groups { + g += fmt.Sprintf("%v", group.ToStorageType().Data["name"]) + " " + } + groupsNames = append(groupsNames, g) + } + + cacheID := uuid.NewString() + h.cache.PutWithTTL(cacheID, accounts, 1*time.Hour) + + return &MembersResult{ + Accounts: accounts, + CacheID: cacheID, + GroupsNames: groupsNames, + }, nil +} + +type MemberDataResult struct { + Account mobilityaccountsstorage.Account + GroupsNames []string +} + +func (h *ApplicationHandler) GetMemberData(ctx context.Context, memberID string) (*MemberDataResult, error) { + request := &mobilityaccounts.GetAccountRequest{ + Id: memberID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a member account + if resp.Account.Namespace != "parcoursmob" { + return nil, fmt.Errorf("account %s is not a member (namespace: %s)", memberID, resp.Account.Namespace) + } + + var allIds []string + for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) { + s := fmt.Sprintf("%v", v) + if !(strings.Contains(s, "admin")) { + allIds = append(allIds, s) + } + } + + reques := &groupsmanagement.GetGroupsBatchRequest{ + Groupids: allIds, + } + + res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(ctx, reques) + if err != nil { + return nil, err + } + + var groupsNames []string + for _, group := range res.Groups { + g := fmt.Sprintf("%v", group.ToStorageType().Data["name"]) + groupsNames = append(groupsNames, g) + } + + return &MemberDataResult{ + Account: resp.Account.ToStorageType(), + GroupsNames: groupsNames, + }, nil +} + +type MemberResult struct { + Account mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetMember(ctx context.Context, memberID string) (*MemberResult, error) { + request := &mobilityaccounts.GetAccountRequest{ + Id: memberID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a member account + if resp.Account.Namespace != "parcoursmob" { + return nil, fmt.Errorf("account %s is not a member (namespace: %s)", memberID, resp.Account.Namespace) + } + + return &MemberResult{ + Account: resp.Account.ToStorageType(), + }, nil +} + +func (h *ApplicationHandler) UpdateMember(ctx context.Context, memberID, firstName, lastName, email, phoneNumber, gender string) (string, error) { + // Security check: verify the account exists and is a member + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: memberID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return "", err + } + if getResp.Account.Namespace != "parcoursmob" { + return "", fmt.Errorf("account %s is not a member (namespace: %s)", memberID, getResp.Account.Namespace) + } + + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "gender": gender, + } + + // Validate the data + formData := UserForm{ + FirstName: firstName, + LastName: lastName, + Email: email, + PhoneNumber: phoneNumber, + Gender: gender, + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return "", err + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: memberID, + Namespace: "parcoursmob", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +type UserForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + PhoneNumber string `json:"phone_number" ` + Address any `json:"address,omitempty"` + Gender string `json:"gender"` +} + +type RegisterUserResult struct { + UserID string +} + +func (h *ApplicationHandler) RegisterUser(ctx context.Context, user mobilityaccountsstorage.Account) (*RegisterUserResult, error) { + account, err := mobilityaccounts.AccountFromStorageType(&user) + if err != nil { + return nil, err + } + + resp, err := h.services.GRPC.MobilityAccounts.Register(ctx, &mobilityaccounts.RegisterRequest{ + Account: account, + }) + if err != nil { + return nil, err + } + + if g, ok := user.Metadata["import_in_group"]; ok { + if group, ok := g.(string); ok { + _, err = h.services.GRPC.GroupsManagement.Subscribe(ctx, &groupsmanagement.SubscribeRequest{ + Groupid: group, + Memberid: resp.Account.Id, + }) + if err != nil { + return nil, err + } + } + } + + return &RegisterUserResult{ + UserID: resp.Account.Id, + }, nil +} + diff --git a/core/application/organized-carpool.go b/core/application/organized-carpool.go new file mode 100644 index 0000000..b7ff56b --- /dev/null +++ b/core/application/organized-carpool.go @@ -0,0 +1,1481 @@ +package application + +import ( + "cmp" + "context" + "encoding/json" + "fmt" + "io" + "slices" + "strconv" + "strings" + "time" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/payments/pricing" + "github.com/google/uuid" + "github.com/paulmach/orb" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type OrganizedCarpoolDriversForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + Birthdate *time.Time `json:"birthdate" validate:"required"` + PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` + FileNumber string `json:"file_number"` + Address any `json:"address,omitempty"` + AddressDestination any `json:"address_destination,omitempty"` + Gender string `json:"gender"` +} + +type OrganizedCarpoolOverviewResult struct { + Accounts []mobilityaccountsstorage.Account + AccountsMap map[string]mobilityaccountsstorage.Account + BeneficiariesMap map[string]mobilityaccountsstorage.Account + Bookings []*proto.CarpoolServiceBooking + BookingsHistory []*proto.CarpoolServiceBooking +} + +func (h *ApplicationHandler) getOrganizedCarpoolDrivers(ctx context.Context, searchFilter string, archivedFilter bool) ([]mobilityaccountsstorage.Account, error) { + request := &mobilityaccounts.GetAccountsRequest{ + Namespaces: []string{"organized_carpool_drivers"}, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(ctx, request) + if err != nil { + return nil, err + } + + // Create iterator that filters and transforms accounts + filteredAccounts := func(yield func(mobilityaccountsstorage.Account) bool) { + for _, account := range resp.Accounts { + if h.filterOrganizedCarpoolDriver(account, searchFilter, archivedFilter) { + if !yield(account.ToStorageType()) { + return + } + } + } + } + + return slices.Collect(filteredAccounts), nil +} + +func (h *ApplicationHandler) filterOrganizedCarpoolDriver(a *mobilityaccounts.Account, searchFilter string, archivedFilter bool) bool { + // Search filter + if searchFilter != "" { + name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) + if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter)) { + return false + } + } + + // Archived filter + if archivedFilter { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return true + } + return false + } else { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return false + } + } + + return true +} + +// filterOrganizedCarpoolBookingsByGeography filters bookings by departure and destination geography +func filterOrganizedCarpoolBookingsByGeography(bookings []*proto.CarpoolServiceBooking, departurePolygons, destinationPolygons []orb.Polygon) []*proto.CarpoolServiceBooking { + if len(departurePolygons) == 0 && len(destinationPolygons) == 0 { + return bookings + } + + filtered := []*proto.CarpoolServiceBooking{} + for _, booking := range bookings { + includeBooking := true + + // Check departure filter if provided + if len(departurePolygons) > 0 { + departureMatch := false + pickupPoint := orb.Point{booking.PassengerPickupLng, booking.PassengerPickupLat} + departureMatch = isPointInGeographies(pickupPoint, departurePolygons) + if !departureMatch { + includeBooking = false + } + } + + // Check destination filter if provided + if len(destinationPolygons) > 0 && includeBooking { + destinationMatch := false + dropPoint := orb.Point{booking.PassengerDropLng, booking.PassengerDropLat} + destinationMatch = isPointInGeographies(dropPoint, destinationPolygons) + if !destinationMatch { + includeBooking = false + } + } + + if includeBooking { + filtered = append(filtered, booking) + } + } + + return filtered +} + +// filterOrganizedCarpoolBookingsByPassengerAddressGeography filters bookings where passenger address is within geography +func filterOrganizedCarpoolBookingsByPassengerAddressGeography(bookings []*proto.CarpoolServiceBooking, beneficiariesMap map[string]mobilityaccountsstorage.Account, addressPolygons []orb.Polygon) []*proto.CarpoolServiceBooking { + if len(addressPolygons) == 0 { + return bookings + } + + filtered := []*proto.CarpoolServiceBooking{} + for _, booking := range bookings { + passenger, ok := beneficiariesMap[booking.Passenger.Id] + if !ok { + continue + } + + // Check if passenger has address - unmarshal as GeoJSON Feature + if pa, ok := passenger.Data["address"]; ok { + jsonpa, err := json.Marshal(pa) + if err == nil { + passGeojson, err := geojson.UnmarshalFeature(jsonpa) + if err == nil && passGeojson.Geometry != nil { + if point, ok := passGeojson.Geometry.(orb.Point); ok { + if isPointInGeographies(point, addressPolygons) { + filtered = append(filtered, booking) + } + } + } + } + } + } + + return filtered +} + +func (h *ApplicationHandler) GetOrganizedCarpoolOverview(ctx context.Context, status, driverID, startDate, endDate, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode, histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeoLayer, histDepartureGeoCode, histDestinationGeoLayer, histDestinationGeoCode, histPassengerAddressGeoLayer, histPassengerAddressGeoCode string, archivedFilter bool, driverAddressGeoLayer, driverAddressGeoCode string) (*OrganizedCarpoolOverviewResult, error) { + // Get ALL drivers for the accountsMap (used in bookings display) + allDrivers, err := h.getOrganizedCarpoolDrivers(ctx, "", false) + if err != nil { + log.Error().Err(err).Msg("issue getting all organized carpool drivers") + allDrivers = []mobilityaccountsstorage.Account{} + } + + // Build accountsMap with ALL drivers (for bookings to reference) + accountsMap := map[string]mobilityaccountsstorage.Account{} + for _, a := range allDrivers { + accountsMap[a.ID] = a + } + + // Get filtered drivers for the drivers tab display + accounts, err := h.getOrganizedCarpoolDrivers(ctx, "", archivedFilter) + if err != nil { + log.Error().Err(err).Msg("issue getting organized carpool drivers") + accounts = []mobilityaccountsstorage.Account{} + } + + // Apply driver address geography filtering only to the drivers tab list + if driverAddressGeoLayer != "" && driverAddressGeoCode != "" { + driverAddressPolygons, err := h.loadGeographyPolygon(driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load driver address geography filter") + } else { + filtered := []mobilityaccountsstorage.Account{} + for _, account := range accounts { + // Check if driver has address - unmarshal as GeoJSON Feature + if addr, ok := account.Data["address"]; ok { + jsonAddr, err := json.Marshal(addr) + if err == nil { + addrGeojson, err := geojson.UnmarshalFeature(jsonAddr) + if err == nil && addrGeojson.Geometry != nil { + if point, ok := addrGeojson.Geometry.(orb.Point); ok { + if isPointInGeographies(point, driverAddressPolygons) { + filtered = append(filtered, account) + } + } + } + } + } + } + accounts = filtered + } + } + + beneficiariesMap, err := h.services.GetBeneficiariesMap() + if err != nil { + beneficiariesMap = map[string]mobilityaccountsstorage.Account{} + } + + // Parse start date or use default + var startdate time.Time + if startDate != "" { + if parsed, err := time.Parse("2006-01-02", startDate); err == nil { + startdate = parsed + } else { + startdate = time.Now() + } + } else { + startdate = time.Now() + } + + // Parse end date or use default + 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 + } else { + enddate = time.Now().Add(24 * 365 * time.Hour) + } + } else { + enddate = time.Now().Add(24 * 365 * time.Hour) + } + + bookingsproto, err := h.services.GRPC.CarpoolService.GetCarpoolBookings(ctx, &proto.GetCarpoolBookingsRequest{ + MinDate: timestamppb.New(startdate), + MaxDate: timestamppb.New(enddate), + }) + if err != nil { + log.Error().Err(err).Msg("issue retrieving bookings") + } + + bookings := []*proto.CarpoolServiceBooking{} + if err == nil { + for _, b := range bookingsproto.Bookings { + // Apply driver filter if specified + if driverID != "" && b.Driver.Id != driverID { + continue + } + // Apply status filter if specified + if status != "" && b.Status.String() != status { + continue + } + bookings = append(bookings, b) + } + } + + // Apply geography filtering for current bookings + var departurePolygons, destinationPolygons, passengerAddressPolygons []orb.Polygon + if departureGeoLayer != "" && departureGeoCode != "" { + departurePolygons, err = h.loadGeographyPolygon(departureGeoLayer, departureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load departure geography filter") + } + } + if destinationGeoLayer != "" && destinationGeoCode != "" { + destinationPolygons, err = h.loadGeographyPolygon(destinationGeoLayer, destinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load destination geography filter") + } + } + if passengerAddressGeoLayer != "" && passengerAddressGeoCode != "" { + passengerAddressPolygons, err = h.loadGeographyPolygon(passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load passenger address geography filter") + } + } + bookings = filterOrganizedCarpoolBookingsByGeography(bookings, departurePolygons, destinationPolygons) + bookings = filterOrganizedCarpoolBookingsByPassengerAddressGeography(bookings, beneficiariesMap, passengerAddressPolygons) + + // Get bookings history with filters + // Parse history start date or use default (1 month ago) + var histStartdate time.Time + if histStartDate != "" { + if parsed, err := time.Parse("2006-01-02", histStartDate); err == nil { + histStartdate = parsed + } else { + histStartdate = time.Now().Add(-30 * 24 * time.Hour) + } + } else { + histStartdate = time.Now().Add(-30 * 24 * time.Hour) + } + + // Parse history end date or use default (yesterday) + var histEnddate time.Time + if histEndDate != "" { + if parsed, err := time.Parse("2006-01-02", histEndDate); err == nil { + histEnddate = parsed.Add(24 * time.Hour) // End of day + } else { + histEnddate = time.Now().Add(-24 * time.Hour) + } + } else { + histEnddate = time.Now().Add(-24 * time.Hour) + } + + historyBookingsproto, err := h.services.GRPC.CarpoolService.GetCarpoolBookings(ctx, &proto.GetCarpoolBookingsRequest{ + MinDate: timestamppb.New(histStartdate), + MaxDate: timestamppb.New(histEnddate), + }) + + bookingsHistory := []*proto.CarpoolServiceBooking{} + if err == nil { + for _, b := range historyBookingsproto.Bookings { + // Apply driver filter if specified + if histDriverID != "" && b.Driver.Id != histDriverID { + continue + } + // Apply status filter if specified + if histStatus != "" && b.Status.String() != histStatus { + continue + } + bookingsHistory = append(bookingsHistory, b) + } + } + + // Apply geography filtering for history bookings + var histDeparturePolygons, histDestinationPolygons, histPassengerAddressPolygons []orb.Polygon + if histDepartureGeoLayer != "" && histDepartureGeoCode != "" { + histDeparturePolygons, err = h.loadGeographyPolygon(histDepartureGeoLayer, histDepartureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history departure geography filter") + } + } + if histDestinationGeoLayer != "" && histDestinationGeoCode != "" { + histDestinationPolygons, err = h.loadGeographyPolygon(histDestinationGeoLayer, histDestinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history destination geography filter") + } + } + if histPassengerAddressGeoLayer != "" && histPassengerAddressGeoCode != "" { + histPassengerAddressPolygons, err = h.loadGeographyPolygon(histPassengerAddressGeoLayer, histPassengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history passenger address geography filter") + } + } + bookingsHistory = filterOrganizedCarpoolBookingsByGeography(bookingsHistory, histDeparturePolygons, histDestinationPolygons) + bookingsHistory = filterOrganizedCarpoolBookingsByPassengerAddressGeography(bookingsHistory, beneficiariesMap, histPassengerAddressPolygons) + + // Sort accounts by last name, then first name + slices.SortFunc(accounts, func(a, b mobilityaccountsstorage.Account) int { + lastNameA := strings.ToLower(a.Data["last_name"].(string)) + lastNameB := strings.ToLower(b.Data["last_name"].(string)) + if lastNameA != lastNameB { + return strings.Compare(lastNameA, lastNameB) + } + firstNameA := strings.ToLower(a.Data["first_name"].(string)) + firstNameB := strings.ToLower(b.Data["first_name"].(string)) + return strings.Compare(firstNameA, firstNameB) + }) + slices.SortFunc(bookings, func(a, b *proto.CarpoolServiceBooking) int { + return cmp.Compare(a.PassengerPickupDate.AsTime().Unix(), b.PassengerPickupDate.AsTime().Unix()) + }) + // Sort history bookings by date (most recent first) + slices.SortFunc(bookingsHistory, func(a, b *proto.CarpoolServiceBooking) int { + return cmp.Compare(b.PassengerPickupDate.AsTime().Unix(), a.PassengerPickupDate.AsTime().Unix()) + }) + + return &OrganizedCarpoolOverviewResult{ + Accounts: accounts, + AccountsMap: accountsMap, + BeneficiariesMap: beneficiariesMap, + Bookings: bookings, + BookingsHistory: bookingsHistory, + }, nil +} + +type OrganizedCarpoolBookingDataResult struct { + Booking *proto.CarpoolServiceBooking + Driver mobilityaccountsstorage.Account + Passenger mobilityaccountsstorage.Account + DriverDepartureAddress string + DriverArrivalAddress string +} + +func (h *ApplicationHandler) GetOrganizedCarpoolBookingData(ctx context.Context, bookingID string) (*OrganizedCarpoolBookingDataResult, error) { + resp, err := h.services.GRPC.CarpoolService.GetBooking(ctx, &proto.GetCarpoolBookingRequest{ + BookingId: bookingID, + }) + if err != nil { + return nil, fmt.Errorf("could not get carpool booking: %w", err) + } + + if resp.Booking == nil { + return nil, fmt.Errorf("carpool booking not found") + } + + driver, err := h.services.GetAccount(resp.Booking.Driver.Id) + if err != nil { + return nil, fmt.Errorf("driver retrieval issue: %w", err) + } + + passenger, err := h.services.GetAccount(resp.Booking.Passenger.Id) + if err != nil { + return nil, fmt.Errorf("passenger retrieval issue: %w", err) + } + + // Extract driver departure and arrival addresses from DriverRoute GeoJSON + var driverDepartureAddress, driverArrivalAddress string + if resp.Booking.DriverRoute != nil && resp.Booking.DriverRoute.Serialized != "" { + fc, err := geojson.UnmarshalFeatureCollection([]byte(resp.Booking.DriverRoute.Serialized)) + if err != nil { + log.Error().Err(err).Msg("could not unmarshal driver route geojson") + } else { + // Extract departure address (first feature) + if len(fc.Features) > 0 { + if addr, ok := fc.Features[0].Properties["label"]; ok { + if addrStr, ok := addr.(string); ok { + driverDepartureAddress = addrStr + } + } + } + // Extract arrival address (last feature) + if len(fc.Features) > 1 { + if addr, ok := fc.Features[1].Properties["label"]; ok { + if addrStr, ok := addr.(string); ok { + driverArrivalAddress = addrStr + } + } + } + } + } + + return &OrganizedCarpoolBookingDataResult{ + Booking: resp.Booking, + Driver: driver, + Passenger: passenger, + DriverDepartureAddress: driverDepartureAddress, + DriverArrivalAddress: driverArrivalAddress, + }, nil +} + +func (h *ApplicationHandler) UpdateOrganizedCarpoolBookingStatus(ctx context.Context, bookingID, action string) error { + var status proto.CarpoolServiceBookingStatus + if action == "confirm" { + status = proto.CarpoolServiceBookingStatus_CONFIRMED + } else if action == "cancel" { + status = proto.CarpoolServiceBookingStatus_CANCELLED + } else if action == "waitconfirmation" { + status = proto.CarpoolServiceBookingStatus_WAITING_DRIVER_CONFIRMATION + } else { + return fmt.Errorf("unknown booking action: %s", action) + } + + // Get booking details BEFORE updating to capture previous status + result, err := h.GetOrganizedCarpoolBookingData(ctx, bookingID) + if err != nil { + return err + } + + booking := result.Booking + driver := result.Driver + passenger := result.Passenger + previousStatus := booking.Status + + // Update booking status + _, err = h.services.GRPC.CarpoolService.UpdateBooking(ctx, &proto.UpdateCarpoolBookingRequest{ + BookingId: bookingID, + Status: status, + }) + if err != nil { + return fmt.Errorf("update carpool booking status issue: %w", err) + } + + // Handle wallet operations based on status transitions + // Credit driver / debit passenger when previous status was not CONFIRMED and new status is CONFIRMED + if previousStatus != proto.CarpoolServiceBookingStatus_CONFIRMED && status == proto.CarpoolServiceBookingStatus_CONFIRMED { + if booking.Price != nil && booking.Price.Amount != nil { + if err := h.CreditWallet(ctx, passenger.ID, -1*(*booking.Price.Amount), "Covoiturage solidaire", "Débit covoiturage solidaire"); err != nil { + return fmt.Errorf("could not debit passenger wallet: %w", err) + } + } + if booking.DriverCompensationAmount != nil && *booking.DriverCompensationAmount > 0 { + if err := h.CreditWallet(ctx, driver.ID, *booking.DriverCompensationAmount, "Covoiturage solidaire", "Crédit covoiturage solidaire"); err != nil { + return fmt.Errorf("could not credit driver wallet: %w", err) + } + } + } + + // Credit passenger / debit driver when previous status was CONFIRMED and new status is not CONFIRMED anymore + if previousStatus == proto.CarpoolServiceBookingStatus_CONFIRMED && status != proto.CarpoolServiceBookingStatus_CONFIRMED { + if booking.Price != nil && booking.Price.Amount != nil { + if err := h.CreditWallet(ctx, passenger.ID, *booking.Price.Amount, "Covoiturage solidaire", "Remboursement annulation covoiturage solidaire"); err != nil { + return fmt.Errorf("could not credit passenger wallet: %w", err) + } + } + if booking.DriverCompensationAmount != nil && *booking.DriverCompensationAmount > 0 { + if err := h.CreditWallet(ctx, driver.ID, -1*(*booking.DriverCompensationAmount), "Covoiturage solidaire", "Débit annulation covoiturage solidaire"); err != nil { + return fmt.Errorf("could not debit driver wallet: %w", err) + } + } + } + + return nil +} + +func (h *ApplicationHandler) CreateOrganizedCarpoolDriver(ctx context.Context, firstName, lastName, email string, birthdate *time.Time, phoneNumber, fileNumber string, address, addressDestination any, gender string) (string, error) { + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "file_number": fileNumber, + "gender": gender, + } + + // Convert birthdate to string format for structpb compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format("2006-01-02") + } + + if address != nil { + dataMap["address"] = address + } + if addressDestination != nil { + dataMap["address_destination"] = addressDestination + } + + // Validate the data + formData := OrganizedCarpoolDriversForm{ + FirstName: firstName, + LastName: lastName, + Email: email, + Birthdate: birthdate, + PhoneNumber: phoneNumber, + FileNumber: fileNumber, + Address: address, + AddressDestination: addressDestination, + Gender: gender, + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return "", err + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.RegisterRequest{ + Account: &mobilityaccounts.Account{ + Namespace: "organized_carpool_drivers", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.Register(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +type OrganizedCarpoolDriverDataResult struct { + Driver mobilityaccountsstorage.Account + Trips []*geojson.FeatureCollection + Documents []filestorage.FileInfo + Bookings any + BeneficiariesMap map[string]mobilityaccountsstorage.Account + Stats map[string]any + WalletBalance float64 +} + +func (h *ApplicationHandler) GetOrganizedCarpoolDriverData(ctx context.Context, driverID string) (*OrganizedCarpoolDriverDataResult, error) { + documents := h.filestorage.List(filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS + "/" + driverID) + + driver, err := h.services.GetAccount(driverID) + if err != nil { + return nil, fmt.Errorf("issue retrieving driver account: %w", err) + } + + // Security check: ensure this is actually an organized carpool driver account + if driver.Namespace != "organized_carpool_drivers" { + return nil, fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + trips := []*geojson.FeatureCollection{} + resp, err := h.services.GRPC.CarpoolService.GetRegularRoutes(ctx, &proto.GetRegularRoutesRequest{ + UserId: driverID, + }) + + for _, r := range resp.Routes { + t, err := geojson.UnmarshalFeatureCollection([]byte(r.Serialized)) + if err != nil { + log.Error().Err(err).Msg("could not unmarshall feature collection") + continue + } + trips = append(trips, t) + } + + // Get driver bookings + bookingsRequest := &proto.GetUserBookingsRequest{ + UserId: driverID, + MinDate: timestamppb.New(time.Now().Add(-365 * 24 * time.Hour)), + MaxDate: timestamppb.New(time.Now().Add(365 * 24 * time.Hour)), + } + + bookingsResp, err := h.services.GRPC.CarpoolService.GetUserBookings(ctx, bookingsRequest) + bookings := []*proto.CarpoolServiceBooking{} + if err == nil { + bookings = bookingsResp.Bookings + } + + // Collect unique passenger IDs + passengerIDs := []string{} + passengerIDsMap := make(map[string]bool) + for _, booking := range bookings { + if booking.Passenger != nil && booking.Passenger.Id != "" { + if !passengerIDsMap[booking.Passenger.Id] { + passengerIDs = append(passengerIDs, booking.Passenger.Id) + passengerIDsMap[booking.Passenger.Id] = true + } + } + } + + // Get beneficiaries in batch + beneficiariesMap := make(map[string]mobilityaccountsstorage.Account) + if len(passengerIDs) > 0 { + beneficiariesResp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: passengerIDs, + }) + if err == nil { + for _, account := range beneficiariesResp.Accounts { + a := account.ToStorageType() + beneficiariesMap[a.ID] = a + } + } + } + + // Calculate stats + confirmedCount := 0 + kmnb := 0 + for _, booking := range bookings { + if booking.Status.String() == "CONFIRMED" { + confirmedCount++ + if booking.Distance != nil { + kmnb += int(*booking.Distance) + } + } + } + stats := map[string]any{ + "bookings": map[string]any{ + "count": len(bookings), + "confirmed": confirmedCount, + "km": kmnb, + }, + } + + // Calculate wallet balance + walletBalance := h.calculateWalletBalance(driver) + + return &OrganizedCarpoolDriverDataResult{ + Driver: driver, + Trips: trips, + Documents: documents, + Bookings: bookings, + BeneficiariesMap: beneficiariesMap, + Stats: stats, + WalletBalance: walletBalance, + }, nil +} + +type OrganizedCarpoolDriverResult struct { + Driver mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetOrganizedCarpoolDriver(ctx context.Context, driverID string) (*OrganizedCarpoolDriverResult, error) { + driver, err := h.services.GetAccount(driverID) + if err != nil { + return nil, fmt.Errorf("issue retrieving driver account: %w", err) + } + + // Security check: ensure this is actually an organized carpool driver account + if driver.Namespace != "organized_carpool_drivers" { + return nil, fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + return &OrganizedCarpoolDriverResult{ + Driver: driver, + }, nil +} + +func (h *ApplicationHandler) UpdateOrganizedCarpoolDriver(ctx context.Context, driverID, firstName, lastName, email string, birthdate *time.Time, phoneNumber, fileNumber string, address, addressDestination any, gender, otherProperties string) (string, error) { + // Security check: verify the account exists and is an organized carpool driver + driver, err := h.services.GetAccount(driverID) + if err != nil { + return "", fmt.Errorf("issue retrieving driver account: %w", err) + } + if driver.Namespace != "organized_carpool_drivers" { + return "", fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "file_number": fileNumber, + "gender": gender, + } + + // Convert birthdate to string format for structpb compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format("2006-01-02") + } + + if address != nil { + dataMap["address"] = address + } + if addressDestination != nil { + dataMap["address_destination"] = addressDestination + } + + // Handle other_properties for update form + if otherProperties != "" { + var otherProps map[string]any + if err := json.Unmarshal([]byte(otherProperties), &otherProps); err == nil { + if dataMap["other_properties"] == nil { + dataMap["other_properties"] = make(map[string]any) + } + for k, v := range otherProps { + dataMap["other_properties"].(map[string]any)[k] = v + } + } + } + + // Validate the data + formData := OrganizedCarpoolDriversForm{ + FirstName: firstName, + LastName: lastName, + Email: email, + Birthdate: birthdate, + PhoneNumber: phoneNumber, + FileNumber: fileNumber, + Address: address, + AddressDestination: addressDestination, + Gender: gender, + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return "", err + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "organized_carpool_drivers", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +func (h *ApplicationHandler) ArchiveOrganizedCarpoolDriver(ctx context.Context, driverID string) error { + // Security check: verify the account exists and is an organized carpool driver + driver, err := h.services.GetAccount(driverID) + if err != nil { + return fmt.Errorf("issue retrieving driver account: %w", err) + } + if driver.Namespace != "organized_carpool_drivers" { + return fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + data, err := structpb.NewValue(map[string]any{ + "archived": true, + }) + if err != nil { + return err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "organized_carpool_drivers", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) UnarchiveOrganizedCarpoolDriver(ctx context.Context, driverID string) error { + // Security check: verify the account exists and is an organized carpool driver + driver, err := h.services.GetAccount(driverID) + if err != nil { + return fmt.Errorf("issue retrieving driver account: %w", err) + } + if driver.Namespace != "organized_carpool_drivers" { + return fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + data, err := structpb.NewValue(map[string]any{ + "archived": false, + }) + if err != nil { + return err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "organized_carpool_drivers", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) AddOrganizedCarpoolDriverDocument(ctx context.Context, driverID string, file io.Reader, filename string, fileSize int64, documentType, documentName string) error { + // Security check: verify the account exists and is an organized carpool driver + driver, err := h.services.GetAccount(driverID) + if err != nil { + return fmt.Errorf("issue retrieving driver account: %w", err) + } + if driver.Namespace != "organized_carpool_drivers" { + return fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + fileid := uuid.NewString() + + metadata := map[string]string{ + "type": documentType, + "name": documentName, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS, fmt.Sprintf("%s/%s_%s", driverID, fileid, filename), fileSize, metadata); err != nil { + return err + } + + return nil +} + +func (h *ApplicationHandler) GetOrganizedCarpoolDriverDocument(ctx context.Context, driverID, document string) (io.Reader, *filestorage.FileInfo, error) { + return h.GetDocument(ctx, OrganizedCarpoolDriverDocumentConfig, driverID, document) +} + +func (h *ApplicationHandler) DeleteOrganizedCarpoolDriverDocument(ctx context.Context, driverID, document string) error { + return h.DeleteDocument(ctx, OrganizedCarpoolDriverDocumentConfig, driverID, document) +} + +func (h *ApplicationHandler) AddOrganizedCarpoolTrip(ctx context.Context, driverID, outwardtime, returntime string, departure, destination *geojson.Feature, days map[string]bool) error { + // Security check: verify the account exists and is an organized carpool driver + driver, err := h.services.GetAccount(driverID) + if err != nil { + return fmt.Errorf("issue retrieving driver account: %w", err) + } + if driver.Namespace != "organized_carpool_drivers" { + return fmt.Errorf("account %s is not an organized carpool driver (namespace: %s)", driverID, driver.Namespace) + } + + trips := []*proto.CarpoolFeatureCollection{} + + outwardroute, err := h.services.Routing.Route([]orb.Point{departure.Point(), destination.Point()}) + if err != nil { + return fmt.Errorf("failed calling route search: %w", err) + } + returnroute, err := h.services.Routing.Route([]orb.Point{destination.Point(), departure.Point()}) + if err != nil { + return fmt.Errorf("failed calling route search: %w", err) + } + + outwardschedules := []map[string]any{} + returnschedules := []map[string]any{} + + dayMap := map[string]string{ + "monday": "MON", + "tuesday": "TUE", + "wednesday": "WED", + "thursday": "THU", + "friday": "FRI", + "saturday": "SAT", + "sunday": "SUN", + } + + for day, enabled := range days { + if enabled { + dayCode := dayMap[day] + outwardschedules = append(outwardschedules, map[string]any{ + "day": dayCode, + "time_of_day": outwardtime, + }) + returnschedules = append(returnschedules, map[string]any{ + "day": dayCode, + "time_of_day": returntime, + }) + } + } + + outward_fc := geojson.NewFeatureCollection() + outward_fc.Append(departure) + outward_fc.Append(destination) + outward_fc.ExtraMembers = geojson.Properties{} + outward_fc.ExtraMembers["properties"] = map[string]any{ + "is_driver": true, + "is_passenger": false, + "user": mobilityaccountsstorage.Account{ + ID: driverID, + }, + "polyline": outwardroute.Summary.Polyline, + "schedules": outwardschedules, + "driver_options": map[string]any{}, + "passenger_options": map[string]any{}, + } + outwardtrip, err := outward_fc.MarshalJSON() + if err != nil { + return fmt.Errorf("failed marshaling outward geojson: %w", err) + } + + return_fc := geojson.NewFeatureCollection() + return_fc.Append(destination) + return_fc.Append(departure) + return_fc.ExtraMembers = geojson.Properties{} + return_fc.ExtraMembers["properties"] = map[string]any{ + "is_driver": true, + "is_passenger": false, + "user": mobilityaccountsstorage.Account{ + ID: driverID, + }, + "polyline": returnroute.Summary.Polyline, + "schedules": returnschedules, + "driver_options": map[string]any{}, + "passenger_options": map[string]any{}, + } + returntrip, err := return_fc.MarshalJSON() + if err != nil { + return fmt.Errorf("failed marshaling return geojson: %w", err) + } + + trips = append(trips, &proto.CarpoolFeatureCollection{ + Serialized: string(outwardtrip), + }) + trips = append(trips, &proto.CarpoolFeatureCollection{ + Serialized: string(returntrip), + }) + + req := &proto.CreateRegularRoutesRequest{ + Routes: trips, + } + _, err = h.services.GRPC.CarpoolService.CreateRegularRoutes(ctx, req) + if err != nil { + return fmt.Errorf("could not create regular routes: %w", err) + } + + return nil +} + +func (h *ApplicationHandler) DeleteOrganizedCarpoolTrip(ctx context.Context, tripID string) error { + req := &proto.DeleteRegularRoutesRequest{ + Ids: []string{tripID}, + } + + _, err := h.services.GRPC.CarpoolService.DeleteRegularRoutes(ctx, req) + if err != nil { + return fmt.Errorf("could not delete regular routes: %w", err) + } + + return nil +} + +type OrganizedCarpoolJourneyDataResult struct { + Journey *geojson.FeatureCollection + Driver mobilityaccountsstorage.Account + Passenger mobilityaccountsstorage.Account + Beneficiaries []mobilityaccountsstorage.Account + PassengerWalletBalance float64 + PricingResult map[string]pricing.Price +} + +func (h *ApplicationHandler) GetOrganizedCarpoolJourneyData(ctx context.Context, driverID, journeyID, passengerID string, currentUserGroup groupstorage.Group) (*OrganizedCarpoolJourneyDataResult, error) { + // Get the planned trip data + journeyResp, err := h.services.GRPC.CarpoolService.GetPlannedTrip(ctx, &proto.GetPlannedTripRequest{ + Id: journeyID, + }) + if err != nil { + return nil, fmt.Errorf("could not get carpool journey: %w", err) + } + + journey, err := geojson.UnmarshalFeatureCollection([]byte(journeyResp.PlannedTrip.Serialized)) + if err != nil { + return nil, fmt.Errorf("could not unmarshal carpool journey: %w", err) + } + + driver, err := h.services.GetAccount(driverID) + if err != nil { + return nil, fmt.Errorf("could not get driver: %w", err) + } + + var passenger mobilityaccountsstorage.Account + if passengerID != "" { + passenger, err = h.services.GetAccount(passengerID) + if err != nil { + return nil, fmt.Errorf("could not get passenger account: %w", err) + } + } + + // Get beneficiaries in current user's group + beneficiaries, err := h.services.GetBeneficiariesInGroup(currentUserGroup) + if err != nil { + return nil, fmt.Errorf("could not get beneficiaries: %w", err) + } + + // Calculate pricing + pricingResult, err := h.calculateOrganizedCarpoolPricing(ctx, journey, passengerID, passenger) + if err != nil { + log.Error().Err(err).Msg("error calculating organized carpool pricing") + pricingResult = map[string]pricing.Price{ + "passenger": {Amount: 0.0, Currency: "EUR"}, + "driver": {Amount: 0.0, Currency: "EUR"}, + } + } + + // Calculate passenger wallet balance + passengerWalletBalance := h.calculateWalletBalance(passenger) + + return &OrganizedCarpoolJourneyDataResult{ + Journey: journey, + Driver: driver, + Passenger: passenger, + Beneficiaries: beneficiaries, + PassengerWalletBalance: passengerWalletBalance, + PricingResult: pricingResult, + }, nil +} + +func (h *ApplicationHandler) CreateOrganizedCarpoolJourneyBooking(ctx context.Context, driverID, journeyID, passengerID, motivation, message string, doNotSend bool) (string, error) { + if passengerID == "" { + return "", fmt.Errorf("missing passenger ID for carpool booking") + } + + // Get the planned trip data + journeyResp, err := h.services.GRPC.CarpoolService.GetPlannedTrip(ctx, &proto.GetPlannedTripRequest{ + Id: journeyID, + }) + if err != nil { + return "", fmt.Errorf("could not get carpool journey: %w", err) + } + + journey, err := geojson.UnmarshalFeatureCollection([]byte(journeyResp.PlannedTrip.Serialized)) + if err != nil { + return "", fmt.Errorf("could not unmarshal carpool journey: %w", err) + } + + departureDate := journey.ExtraMembers["departure_date"] + var departureTime *timestamppb.Timestamp + if departureDate != nil { + if dd, ok := departureDate.(string); ok { + dt, _ := time.Parse("2006-01-02 15:04", dd) + departureTime = timestamppb.New(dt) + } + } + + // Extract operator from journey data + var operatorID string + if operator, ok := journey.ExtraMembers["operator"]; ok { + if op, ok := operator.(string); ok { + operatorID = op + } + } + if operatorID == "" { + operatorID = "example.coopgo.fr" // fallback to default + } + + if departureTime == nil { + // Fallback to current time if we can't extract departure time + departureTime = timestamppb.New(time.Now()) + } + + // Extract journey properties from the geojson data + var journeyProps map[string]any + if props, ok := journey.ExtraMembers["properties"]; ok { + if propsMap, ok := props.(map[string]any); ok { + journeyProps = propsMap + } + } + + if journeyProps == nil { + return "", fmt.Errorf("could not extract journey properties") + } + + // Extract departure date from journey ExtraMembers + if depDate, ok := journey.ExtraMembers["departure_date"]; ok { + if depDateStr, ok := depDate.(string); ok { + if parsedTime, err := time.Parse("2006-01-02T15:04:05Z", depDateStr); err == nil { + departureTime = timestamppb.New(parsedTime) + } else if parsedTime, err := time.Parse("2006-01-02", depDateStr); err == nil { + departureTime = timestamppb.New(parsedTime) + } else { + log.Warn().Str("departure_date", depDateStr).Msg("could not parse departure date, using current time") + } + } + } + + // Extract passenger pickup/drop coordinates and addresses from stored passenger data + var pickupLat, pickupLng, dropLat, dropLng float64 + var pickupAddress, dropAddress string + + // Check if we have passenger pickup and drop features in the journey's extra members + if pickupData, ok := journey.ExtraMembers["passenger_pickup"]; ok { + if pickupMap, ok := pickupData.(map[string]interface{}); ok { + if geometry, ok := pickupMap["geometry"].(map[string]interface{}); ok { + if coords, ok := geometry["coordinates"].([]interface{}); ok && len(coords) >= 2 { + if lng, ok := coords[0].(float64); ok { + pickupLng = lng + } + if lat, ok := coords[1].(float64); ok { + pickupLat = lat + } + } + } + if properties, ok := pickupMap["properties"].(map[string]interface{}); ok { + if label, ok := properties["label"].(string); ok { + pickupAddress = label + } + } + } + } + + if dropData, ok := journey.ExtraMembers["passenger_drop"]; ok { + if dropMap, ok := dropData.(map[string]interface{}); ok { + if geometry, ok := dropMap["geometry"].(map[string]interface{}); ok { + if coords, ok := geometry["coordinates"].([]interface{}); ok && len(coords) >= 2 { + if lng, ok := coords[0].(float64); ok { + dropLng = lng + } + if lat, ok := coords[1].(float64); ok { + dropLat = lat + } + } + } + if properties, ok := dropMap["properties"].(map[string]interface{}); ok { + if label, ok := properties["label"].(string); ok { + dropAddress = label + } + } + } + } + + // Extract time from schedules if available and no specific departure_date was found + if departureTime.AsTime().Equal(time.Now().Truncate(time.Second)) { + if schedules, ok := journeyProps["schedules"]; ok { + if schedulesList, ok := schedules.([]any); ok && len(schedulesList) > 0 { + if schedule, ok := schedulesList[0].(map[string]any); ok { + if timeOfDay, ok := schedule["time_of_day"].(string); ok { + // Parse time and combine with current date + now := time.Now() + timeStr := fmt.Sprintf("%s %s", now.Format("2006-01-02"), timeOfDay) + if depTime, err := time.Parse("2006-01-02 15:04", timeStr); err == nil { + departureTime = timestamppb.New(depTime) + } + } + } + } + } + } + + // Get passenger account and calculate pricing + var passenger mobilityaccountsstorage.Account + if passengerID != "" { + passenger, err = h.services.GetAccount(passengerID) + if err != nil { + return "", fmt.Errorf("could not get passenger account: %w", err) + } + } + + pricingResult, err := h.calculateOrganizedCarpoolPricing(ctx, journey, passengerID, passenger) + if err != nil { + log.Error().Err(err).Msg("error calculating organized carpool pricing") + pricingResult = map[string]pricing.Price{ + "passenger": {Amount: 0.0, Currency: "EUR"}, + "driver": {Amount: 0.0, Currency: "EUR"}, + } + } + + // Extract price values + priceAmount := pricingResult["passenger"].Amount + priceCurrency := pricingResult["passenger"].Currency + driverCompensationAmount := pricingResult["driver"].Amount + driverCompensationCurrency := pricingResult["driver"].Currency + + // Determine price type + priceType := proto.CarpoolServicePriceType_PAYING + if priceAmount == 0 { + priceType = proto.CarpoolServicePriceType_FREE + } + + // Extract passenger distance from journey + var passengerDistance *int64 + if dist, ok := journey.ExtraMembers["passenger_distance"].(float64); ok { + distInt := int64(dist) + passengerDistance = &distInt + } + + // Create carpool booking using extracted journey data + booking := &proto.CarpoolServiceBooking{ + Id: uuid.NewString(), + Driver: &proto.CarpoolServiceUser{ + Id: driverID, + Operator: operatorID, + }, + Passenger: &proto.CarpoolServiceUser{ + Id: passengerID, + Operator: operatorID, + }, + PassengerPickupDate: departureTime, + PassengerPickupLat: pickupLat, + PassengerPickupLng: pickupLng, + PassengerDropLat: dropLat, + PassengerDropLng: dropLng, + PassengerPickupAddress: &pickupAddress, + PassengerDropAddress: &dropAddress, + Status: proto.CarpoolServiceBookingStatus_WAITING_DRIVER_CONFIRMATION, + Distance: passengerDistance, + DriverJourneyId: journeyID, + Price: &proto.CarpoolServicePrice{ + Type: &priceType, + Amount: &priceAmount, + Currency: &priceCurrency, + }, + DriverCompensationAmount: &driverCompensationAmount, + DriverCompensationCurrency: &driverCompensationCurrency, + Motivation: &motivation, + } + + bookingRes, err := h.services.GRPC.CarpoolService.CreateBooking(ctx, &proto.CreateCarpoolBookingRequest{ + Booking: booking, + }) + if err != nil { + return "", fmt.Errorf("cannot create carpool booking: %w", err) + } + + // Send SMS notification if requested + if message != "" && !doNotSend { + send_message := strings.ReplaceAll(message, "{booking_id}", bookingRes.Booking.Id) + log.Debug().Str("message", send_message).Msg("Carpool booking created: sending message") + h.GenerateSMS(driverID, send_message) + } + + return bookingRes.Booking.Id, nil +} + +func (h *ApplicationHandler) calculateOrganizedCarpoolPricing(ctx context.Context, tripGeoJSON *geojson.FeatureCollection, passengerID string, passenger mobilityaccountsstorage.Account) (map[string]pricing.Price, error) { + // For organized carpool, use simple pricing based on distance + // Extract distance from journey features if available + var passengerDistance int64 = 0 + var driverDistance int64 = 0 + + // Try to extract distance from journey extra members + if tripGeoJSON != nil && tripGeoJSON.ExtraMembers != nil { + if dist, ok := tripGeoJSON.ExtraMembers["passenger_distance"].(float64); ok { + passengerDistance = int64(dist) + } + if dist, ok := tripGeoJSON.ExtraMembers["driver_distance"].(float64); ok { + driverDistance = int64(dist) + } + } + + benefParams := pricing.BeneficiaryParams{} + if passengerID == "" { + benefParams = pricing.BeneficiaryParams{ + History: 99, + Priority: false, + } + } else { + // Get organized carpool history for passenger + carpoolBookings, err := h.services.GRPC.CarpoolService.GetUserBookings(ctx, &proto.GetUserBookingsRequest{ + UserId: passengerID, + }) + + // Check priority status + priority := false + if a, ok := passenger.Data["other_properties"]; ok { + if b, ok := a.(map[string]any); ok { + if c, ok := b["status"]; ok { + if p, ok := c.(string); ok { + priority = (p == "Prioritaire") + } + } + } + } + + // Calculate history from previous bookings and stored value + history := 0 + if op, ok := passenger.Data["other_properties"]; ok { + if op_map, ok := op.(map[string]any); ok { + if poc, ok := op_map["previous_organized_carpool"]; ok { + if poc_str, ok := poc.(string); ok { + if poc_str != "" { + if n, err := strconv.Atoi(poc_str); err == nil { + history = history + n + } else { + log.Error().Err(err).Str("n", poc_str).Msg("string to int conversion error") + } + } + } + } + } + } + + // Count only WAITING_DRIVER_CONFIRMATION, CONFIRMED and VALIDATED bookings + if err == nil { + for _, booking := range carpoolBookings.Bookings { + if booking.Status == proto.CarpoolServiceBookingStatus_WAITING_DRIVER_CONFIRMATION || + booking.Status == proto.CarpoolServiceBookingStatus_CONFIRMED || + booking.Status == proto.CarpoolServiceBookingStatus_VALIDATED { + history++ + } + } + } + + benefParams = pricing.BeneficiaryParams{ + History: history, + Priority: priority, + } + } + + pricingParams := pricing.PricingParams{ + MobilityType: "organized_carpool", + Beneficiary: benefParams, + SharedMobility: pricing.SharedMobilityParams{ + DriverDistance: driverDistance, + PassengerDistance: passengerDistance, + }, + } + + log.Info(). + Str("mobility_type", pricingParams.MobilityType). + Int("beneficiary_history", pricingParams.Beneficiary.History). + Bool("beneficiary_priority", pricingParams.Beneficiary.Priority). + Int64("driver_distance", pricingParams.SharedMobility.DriverDistance). + Int64("passenger_distance", pricingParams.SharedMobility.PassengerDistance). + Str("passenger_id", passengerID). + Msg("calling pricing service for organized carpool") + + pricingResult, err := h.services.Pricing.Prices(pricingParams) + if err != nil { + log.Error().Err(err).Msg("pricing service returned error") + return nil, err + } + + log.Info(). + Float64("passenger_price", pricingResult["passenger"].Amount). + Str("passenger_currency", pricingResult["passenger"].Currency). + Float64("driver_price", pricingResult["driver"].Amount). + Str("driver_currency", pricingResult["driver"].Currency). + Msg("pricing service result for organized carpool") + + return pricingResult, nil +} + +type OrganizedCarpoolBookingsResult struct { + Bookings []*proto.CarpoolServiceBooking + DriversMap map[string]mobilityaccountsstorage.Account + BeneficiariesMap map[string]mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetOrganizedCarpoolBookings(ctx context.Context, startDate, endDate *time.Time, status, driverID, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode string) (*OrganizedCarpoolBookingsResult, error) { + // Get all drivers + drivers, err := h.getOrganizedCarpoolDrivers(ctx, "", false) + if err != nil { + log.Error().Err(err).Msg("issue getting organized carpool drivers") + drivers = []mobilityaccountsstorage.Account{} + } + + driversMap := map[string]mobilityaccountsstorage.Account{} + for _, d := range drivers { + driversMap[d.ID] = d + } + + // Get beneficiaries + beneficiariesMap, err := h.services.GetBeneficiariesMap() + if err != nil { + beneficiariesMap = map[string]mobilityaccountsstorage.Account{} + } + + // Determine date range + var start, end time.Time + if startDate != nil { + start = *startDate + } else { + start = time.Now().Add(-365 * 24 * time.Hour) + } + if endDate != nil { + end = *endDate + } else { + end = time.Now() + } + + // Get bookings from gRPC service + request := &proto.GetCarpoolBookingsRequest{ + MinDate: timestamppb.New(start), + MaxDate: timestamppb.New(end), + } + + resp, err := h.services.GRPC.CarpoolService.GetCarpoolBookings(ctx, request) + if err != nil { + return nil, err + } + + bookings := []*proto.CarpoolServiceBooking{} + for _, b := range resp.Bookings { + // Apply driver filter if specified + if driverID != "" && b.Driver.Id != driverID { + continue + } + // Apply status filter if specified + if status != "" && b.Status.String() != status { + continue + } + bookings = append(bookings, b) + } + + // Apply geography filtering + var departurePolygons, destinationPolygons, passengerAddressPolygons []orb.Polygon + if departureGeoLayer != "" && departureGeoCode != "" { + departurePolygons, err = h.loadGeographyPolygon(departureGeoLayer, departureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load departure geography filter") + } + } + if destinationGeoLayer != "" && destinationGeoCode != "" { + destinationPolygons, err = h.loadGeographyPolygon(destinationGeoLayer, destinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load destination geography filter") + } + } + if passengerAddressGeoLayer != "" && passengerAddressGeoCode != "" { + passengerAddressPolygons, err = h.loadGeographyPolygon(passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load passenger address geography filter") + } + } + bookings = filterOrganizedCarpoolBookingsByGeography(bookings, departurePolygons, destinationPolygons) + bookings = filterOrganizedCarpoolBookingsByPassengerAddressGeography(bookings, beneficiariesMap, passengerAddressPolygons) + + // Sort by date (most recent first) + slices.SortFunc(bookings, func(a, b *proto.CarpoolServiceBooking) int { + return cmp.Compare(b.PassengerPickupDate.AsTime().Unix(), a.PassengerPickupDate.AsTime().Unix()) + }) + + return &OrganizedCarpoolBookingsResult{ + Bookings: bookings, + DriversMap: driversMap, + BeneficiariesMap: beneficiariesMap, + }, nil +} diff --git a/handlers/application/sms.go b/core/application/sms.go similarity index 60% rename from handlers/application/sms.go rename to core/application/sms.go index 4e234b9..91292bc 100644 --- a/handlers/application/sms.go +++ b/core/application/sms.go @@ -1,31 +1,14 @@ package application import ( + "context" "errors" - "net/http" "github.com/rs/zerolog/log" ) -func (h *ApplicationHandler) SendSMS(w http.ResponseWriter, r *http.Request) { - if r.Method != "POST" { - w.WriteHeader(http.StatusMethodNotAllowed) - return - } - referer := r.Referer() - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("Bad request") - w.WriteHeader(http.StatusBadRequest) - return - } - - message := r.PostFormValue("message") - beneficiaryid := r.PostFormValue("beneficiaryid") - - h.GenerateSMS(beneficiaryid, message) - - http.Redirect(w, r, referer, http.StatusFound) +func (h *ApplicationHandler) SendSMS(ctx context.Context, beneficiaryID, message string) error { + return h.GenerateSMS(beneficiaryID, message) } func (h *ApplicationHandler) GenerateSMS(recipientid string, message string) error { diff --git a/core/application/solidarity-transport.go b/core/application/solidarity-transport.go new file mode 100644 index 0000000..cef8576 --- /dev/null +++ b/core/application/solidarity-transport.go @@ -0,0 +1,1438 @@ +package application + +import ( + "context" + "encoding/json" + "fmt" + "io" + "slices" + "sort" + "strconv" + "strings" + "time" + + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/payments/pricing" + "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" + solidaritytransformers "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" + solidaritytypes "git.coopgo.io/coopgo-platform/solidarity-transport/types" + "github.com/google/uuid" + "github.com/paulmach/orb" + "github.com/paulmach/orb/geojson" + "github.com/paulmach/orb/planar" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" +) + +type DriversForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + Birthdate *time.Time `json:"birthdate" validate:"required"` + PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` + Address any `json:"address,omitempty"` + Gender string `json:"gender"` +} + +const ( + Sunday = iota + Monday + Tuesday + Wednesday + Thursday + Friday + Saturday +) + +type SolidarityTransportOverviewResult struct { + Accounts []mobilityaccountsstorage.Account + AccountsMap map[string]mobilityaccountsstorage.Account + BeneficiariesMap map[string]mobilityaccountsstorage.Account + Bookings []*solidaritytypes.Booking + BookingsHistory []*solidaritytypes.Booking +} + +// loadGeographyPolygon loads a single geography polygon for filtering +func (h *ApplicationHandler) loadGeographyPolygon(layer, code string) ([]orb.Polygon, error) { + if layer == "" || code == "" { + return nil, nil + } + + // Fetch geography from service + geoFeature, err := h.services.Geography.Find(layer, code) + if err != nil { + return nil, fmt.Errorf("failed to load geography %s/%s: %w", layer, code, err) + } + + polygons := []orb.Polygon{} + // Extract polygon from the feature + if geoFeature != nil && geoFeature.Geometry != nil { + switch geom := geoFeature.Geometry.(type) { + case orb.Polygon: + polygons = append(polygons, geom) + case orb.MultiPolygon: + for _, poly := range geom { + polygons = append(polygons, poly) + } + } + } + + return polygons, nil +} + +// isPointInGeographies checks if a point is within any of the geography polygons +func isPointInGeographies(point orb.Point, polygons []orb.Polygon) bool { + for _, poly := range polygons { + if planar.PolygonContains(poly, point) { + return true + } + } + return false +} + +// filterBookingsByPassengerAddressGeography filters bookings where passenger address is within geography +func filterBookingsByPassengerAddressGeography(bookings []*solidaritytypes.Booking, beneficiariesMap map[string]mobilityaccountsstorage.Account, addressPolygons []orb.Polygon) []*solidaritytypes.Booking { + if len(addressPolygons) == 0 { + return bookings + } + + filtered := []*solidaritytypes.Booking{} + for _, booking := range bookings { + passenger, ok := beneficiariesMap[booking.PassengerId] + if !ok { + continue + } + + // Check if passenger has address with geometry + if address, ok := passenger.Data["address"].(map[string]any); ok { + if geometry, ok := address["geometry"].(map[string]any); ok { + if geomType, ok := geometry["type"].(string); ok && geomType == "Point" { + if coords, ok := geometry["coordinates"].([]any); ok && len(coords) == 2 { + if lon, ok := coords[0].(float64); ok { + if lat, ok := coords[1].(float64); ok { + point := orb.Point{lon, lat} + if isPointInGeographies(point, addressPolygons) { + filtered = append(filtered, booking) + } + } + } + } + } + } + } + } + + return filtered +} + +// filterBookingsByGeography filters bookings based on geography constraints +func filterBookingsByGeography(bookings []*solidaritytypes.Booking, departurePolygons, destinationPolygons []orb.Polygon) []*solidaritytypes.Booking { + // If no filters, return all bookings + if len(departurePolygons) == 0 && len(destinationPolygons) == 0 { + return bookings + } + + filtered := []*solidaritytypes.Booking{} + for _, booking := range bookings { + if booking.Journey == nil { + continue + } + + includeBooking := true + + // Check departure filter if provided + if len(departurePolygons) > 0 { + departureMatch := false + if booking.Journey.PassengerPickup != nil && booking.Journey.PassengerPickup.Geometry != nil { + if point, ok := booking.Journey.PassengerPickup.Geometry.(orb.Point); ok { + departureMatch = isPointInGeographies(point, departurePolygons) + } + } + if !departureMatch { + includeBooking = false + } + } + + // Check destination filter if provided + if len(destinationPolygons) > 0 && includeBooking { + destinationMatch := false + if booking.Journey.PassengerDrop != nil && booking.Journey.PassengerDrop.Geometry != nil { + if point, ok := booking.Journey.PassengerDrop.Geometry.(orb.Point); ok { + destinationMatch = isPointInGeographies(point, destinationPolygons) + } + } + if !destinationMatch { + includeBooking = false + } + } + + if includeBooking { + filtered = append(filtered, booking) + } + } + + return filtered +} + +func (h *ApplicationHandler) GetSolidarityTransportOverview(ctx context.Context, status, driverID, startDate, endDate, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode, histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeoLayer, histDepartureGeoCode, histDestinationGeoLayer, histDestinationGeoCode, histPassengerAddressGeoLayer, histPassengerAddressGeoCode string, archivedFilter bool, driverAddressGeoLayer, driverAddressGeoCode string) (*SolidarityTransportOverviewResult, error) { + // Get ALL drivers for the accountsMap (used in bookings display) + allDrivers, err := h.solidarityDrivers("", false) + if err != nil { + log.Error().Err(err).Msg("issue getting all solidarity drivers") + allDrivers = []mobilityaccountsstorage.Account{} + } + + // Build accountsMap with ALL drivers (for bookings to reference) + accountsMap := map[string]mobilityaccountsstorage.Account{} + for _, a := range allDrivers { + accountsMap[a.ID] = a + } + + // Get filtered drivers for the drivers tab display + accounts, err := h.solidarityDrivers("", archivedFilter) + if err != nil { + log.Error().Err(err).Msg("issue getting solidarity drivers") + accounts = []mobilityaccountsstorage.Account{} + } + + // Apply driver address geography filtering only to the drivers tab list + if driverAddressGeoLayer != "" && driverAddressGeoCode != "" { + driverAddressPolygons, err := h.loadGeographyPolygon(driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load driver address geography filter") + } else { + filtered := []mobilityaccountsstorage.Account{} + for _, account := range accounts { + // Check if driver has address - unmarshal as GeoJSON Feature + if addr, ok := account.Data["address"]; ok { + jsonAddr, err := json.Marshal(addr) + if err == nil { + addrGeojson, err := geojson.UnmarshalFeature(jsonAddr) + if err == nil && addrGeojson.Geometry != nil { + if point, ok := addrGeojson.Geometry.(orb.Point); ok { + if isPointInGeographies(point, driverAddressPolygons) { + filtered = append(filtered, account) + } + } + } + } + } + } + accounts = filtered + } + } + + // Sort accounts by last name, then first name + slices.SortFunc(accounts, func(a, b mobilityaccountsstorage.Account) int { + lastNameA := strings.ToLower(a.Data["last_name"].(string)) + lastNameB := strings.ToLower(b.Data["last_name"].(string)) + if lastNameA != lastNameB { + return strings.Compare(lastNameA, lastNameB) + } + firstNameA := strings.ToLower(a.Data["first_name"].(string)) + firstNameB := strings.ToLower(b.Data["first_name"].(string)) + return strings.Compare(firstNameA, firstNameB) + }) + + beneficiariesMap, err := h.services.GetBeneficiariesMap() + if err != nil { + beneficiariesMap = map[string]mobilityaccountsstorage.Account{} + } + + // Parse start date or use default + var startdate time.Time + if startDate != "" { + if parsed, err := time.Parse("2006-01-02", startDate); err == nil { + startdate = parsed + } else { + startdate = time.Now() + } + } else { + startdate = time.Now() + } + + // Parse end date or use default + 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 + } else { + enddate = time.Now().Add(24 * 365 * time.Hour) + } + } else { + enddate = time.Now().Add(24 * 365 * time.Hour) + } + + request := &gen.GetSolidarityTransportBookingsRequest{ + StartDate: timestamppb.New(startdate), + EndDate: timestamppb.New(enddate), + Status: status, + Driverid: driverID, + } + + resp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, request) + if err != nil { + log.Error().Err(err).Msg("issue getting solidarity transport bookings") + return &SolidarityTransportOverviewResult{ + Accounts: accounts, + AccountsMap: accountsMap, + BeneficiariesMap: beneficiariesMap, + Bookings: []*solidaritytypes.Booking{}, + BookingsHistory: []*solidaritytypes.Booking{}, + }, nil + } + + // Get bookings history with filters + // Parse history start date or use default (1 month ago) + var histStartdate time.Time + if histStartDate != "" { + if parsed, err := time.Parse("2006-01-02", histStartDate); err == nil { + histStartdate = parsed + } else { + histStartdate = time.Now().Add(-30 * 24 * time.Hour) + } + } else { + histStartdate = time.Now().Add(-30 * 24 * time.Hour) + } + + // Parse history end date or use default (yesterday) + var histEnddate time.Time + if histEndDate != "" { + if parsed, err := time.Parse("2006-01-02", histEndDate); err == nil { + histEnddate = parsed.Add(24 * time.Hour) // End of day + } else { + histEnddate = time.Now().Add(-24 * time.Hour) + } + } else { + histEnddate = time.Now().Add(-24 * time.Hour) + } + + historyRequest := &gen.GetSolidarityTransportBookingsRequest{ + StartDate: timestamppb.New(histStartdate), + EndDate: timestamppb.New(histEnddate), + Status: histStatus, + Driverid: histDriverID, + } + + historyResp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, historyRequest) + bookingsHistory := []*gen.SolidarityTransportBooking{} + if err == nil { + bookingsHistory = historyResp.Bookings + } + + // Transform bookings to types + transformedBookings := []*solidaritytypes.Booking{} + for _, booking := range resp.Bookings { + if transformed, err := solidaritytransformers.BookingProtoToType(booking); err == nil { + transformedBookings = append(transformedBookings, transformed) + } + } + + // Apply geography filtering for current bookings + var departurePolygons, destinationPolygons, passengerAddressPolygons []orb.Polygon + if departureGeoLayer != "" && departureGeoCode != "" { + departurePolygons, err = h.loadGeographyPolygon(departureGeoLayer, departureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load departure geography filter") + } + } + if destinationGeoLayer != "" && destinationGeoCode != "" { + destinationPolygons, err = h.loadGeographyPolygon(destinationGeoLayer, destinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load destination geography filter") + } + } + if passengerAddressGeoLayer != "" && passengerAddressGeoCode != "" { + passengerAddressPolygons, err = h.loadGeographyPolygon(passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load passenger address geography filter") + } + } + transformedBookings = filterBookingsByGeography(transformedBookings, departurePolygons, destinationPolygons) + transformedBookings = filterBookingsByPassengerAddressGeography(transformedBookings, beneficiariesMap, passengerAddressPolygons) + + // Sort upcoming bookings by date (ascending - earliest first) + sort.Slice(transformedBookings, func(i, j int) bool { + if transformedBookings[i].Journey != nil && transformedBookings[j].Journey != nil { + return transformedBookings[i].Journey.PassengerPickupDate.Before(transformedBookings[j].Journey.PassengerPickupDate) + } + return false + }) + + transformedBookingsHistory := []*solidaritytypes.Booking{} + for _, booking := range bookingsHistory { + if transformed, err := solidaritytransformers.BookingProtoToType(booking); err == nil { + transformedBookingsHistory = append(transformedBookingsHistory, transformed) + } + } + + // Apply geography filtering for history bookings + var histDeparturePolygons, histDestinationPolygons, histPassengerAddressPolygons []orb.Polygon + if histDepartureGeoLayer != "" && histDepartureGeoCode != "" { + histDeparturePolygons, err = h.loadGeographyPolygon(histDepartureGeoLayer, histDepartureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history departure geography filter") + } + } + if histDestinationGeoLayer != "" && histDestinationGeoCode != "" { + histDestinationPolygons, err = h.loadGeographyPolygon(histDestinationGeoLayer, histDestinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history destination geography filter") + } + } + if histPassengerAddressGeoLayer != "" && histPassengerAddressGeoCode != "" { + histPassengerAddressPolygons, err = h.loadGeographyPolygon(histPassengerAddressGeoLayer, histPassengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load history passenger address geography filter") + } + } + transformedBookingsHistory = filterBookingsByGeography(transformedBookingsHistory, histDeparturePolygons, histDestinationPolygons) + transformedBookingsHistory = filterBookingsByPassengerAddressGeography(transformedBookingsHistory, beneficiariesMap, histPassengerAddressPolygons) + + // Sort history bookings by date (descending - most recent first) + sort.Slice(transformedBookingsHistory, func(i, j int) bool { + if transformedBookingsHistory[i].Journey != nil && transformedBookingsHistory[j].Journey != nil { + return transformedBookingsHistory[i].Journey.PassengerPickupDate.After(transformedBookingsHistory[j].Journey.PassengerPickupDate) + } + return false + }) + + return &SolidarityTransportOverviewResult{ + Accounts: accounts, + AccountsMap: accountsMap, + BeneficiariesMap: beneficiariesMap, + Bookings: transformedBookings, + BookingsHistory: transformedBookingsHistory, + }, nil +} + +type SolidarityTransportBookingsResult struct { + Bookings []*solidaritytypes.Booking + DriversMap map[string]mobilityaccountsstorage.Account + BeneficiariesMap map[string]mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetSolidarityTransportBookings(ctx context.Context, startDate, endDate *time.Time, status, driverID, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode string) (*SolidarityTransportBookingsResult, error) { + // Get all drivers + drivers, err := h.solidarityDrivers("", false) + if err != nil { + log.Error().Err(err).Msg("issue getting solidarity drivers") + drivers = []mobilityaccountsstorage.Account{} + } + + driversMap := map[string]mobilityaccountsstorage.Account{} + for _, d := range drivers { + driversMap[d.ID] = d + } + + // Get beneficiaries + beneficiariesMap, err := h.services.GetBeneficiariesMap() + if err != nil { + beneficiariesMap = map[string]mobilityaccountsstorage.Account{} + } + + // Determine date range + var start, end time.Time + if startDate != nil { + start = *startDate + } else { + // Default: 1 year ago + start = time.Now().Add(-365 * 24 * time.Hour) + } + + if endDate != nil { + end = *endDate + } else { + // Default: now + end = time.Now() + } + + // Get bookings + request := &gen.GetSolidarityTransportBookingsRequest{ + StartDate: timestamppb.New(start), + EndDate: timestamppb.New(end), + Status: status, + Driverid: driverID, + } + + resp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, request) + if err != nil { + log.Error().Err(err).Msg("issue getting solidarity transport bookings") + return &SolidarityTransportBookingsResult{ + Bookings: []*solidaritytypes.Booking{}, + DriversMap: driversMap, + BeneficiariesMap: beneficiariesMap, + }, nil + } + + // Transform bookings to types + transformedBookings := []*solidaritytypes.Booking{} + for _, booking := range resp.Bookings { + if transformed, err := solidaritytransformers.BookingProtoToType(booking); err == nil { + transformedBookings = append(transformedBookings, transformed) + } + } + + // Apply geography filtering + var departurePolygons, destinationPolygons, passengerAddressPolygons []orb.Polygon + if departureGeoLayer != "" && departureGeoCode != "" { + departurePolygons, err = h.loadGeographyPolygon(departureGeoLayer, departureGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load departure geography filter for export") + } + } + if destinationGeoLayer != "" && destinationGeoCode != "" { + destinationPolygons, err = h.loadGeographyPolygon(destinationGeoLayer, destinationGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load destination geography filter for export") + } + } + if passengerAddressGeoLayer != "" && passengerAddressGeoCode != "" { + passengerAddressPolygons, err = h.loadGeographyPolygon(passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Warn().Err(err).Msg("failed to load passenger address geography filter for export") + } + } + transformedBookings = filterBookingsByGeography(transformedBookings, departurePolygons, destinationPolygons) + transformedBookings = filterBookingsByPassengerAddressGeography(transformedBookings, beneficiariesMap, passengerAddressPolygons) + + // Sort bookings by date + sort.Slice(transformedBookings, func(i, j int) bool { + if transformedBookings[i].Journey != nil && transformedBookings[j].Journey != nil { + return transformedBookings[i].Journey.PassengerPickupDate.Before(transformedBookings[j].Journey.PassengerPickupDate) + } + return false + }) + + return &SolidarityTransportBookingsResult{ + Bookings: transformedBookings, + DriversMap: driversMap, + BeneficiariesMap: beneficiariesMap, + }, nil +} + +func (h *ApplicationHandler) CreateSolidarityTransportDriver(ctx context.Context, firstName, lastName, email string, birthdate *time.Time, phoneNumber string, address any, gender string, otherProperties any) (string, error) { + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "gender": gender, + } + + // Convert birthdate to string for structpb compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format(time.RFC3339) + } + + if address != nil { + dataMap["address"] = address + } + + if otherProperties != nil { + dataMap["other_properties"] = otherProperties + } + + // Validate the data + formData := DriversForm{ + FirstName: firstName, + LastName: lastName, + Email: email, + Birthdate: birthdate, + PhoneNumber: phoneNumber, + Address: address, + Gender: gender, + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return "", err + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.RegisterRequest{ + Account: &mobilityaccounts.Account{ + Namespace: "solidarity_drivers", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.Register(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +type SolidarityTransportDriverResult struct { + Driver mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetSolidarityTransportDriver(ctx context.Context, driverID string) (*SolidarityTransportDriverResult, error) { + request := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a solidarity transport driver account + if resp.Account.Namespace != "solidarity_drivers" { + return nil, fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, resp.Account.Namespace) + } + + return &SolidarityTransportDriverResult{ + Driver: resp.Account.ToStorageType(), + }, nil +} + +func (h *ApplicationHandler) UpdateSolidarityTransportDriver(ctx context.Context, driverID, firstName, lastName, email string, birthdate *time.Time, phoneNumber string, address any, gender string, otherProperties any) (string, error) { + // Security check: verify the account exists and is a solidarity transport driver + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return "", err + } + if getResp.Account.Namespace != "solidarity_drivers" { + return "", fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, getResp.Account.Namespace) + } + + dataMap := map[string]any{ + "first_name": firstName, + "last_name": lastName, + "email": email, + "phone_number": phoneNumber, + "gender": gender, + } + + // Convert birthdate to string for structpb compatibility + if birthdate != nil { + dataMap["birthdate"] = birthdate.Format(time.RFC3339) + } + + if address != nil { + dataMap["address"] = address + } + + if otherProperties != nil { + dataMap["other_properties"] = otherProperties + } + + // Validate the data + formData := DriversForm{ + FirstName: firstName, + LastName: lastName, + Email: email, + Birthdate: birthdate, + PhoneNumber: phoneNumber, + Address: address, + Gender: gender, + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return "", err + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", err + } + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "solidarity_drivers", + Data: data.GetStructValue(), + }, + } + + resp, err := h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + if err != nil { + return "", err + } + + return resp.Account.Id, nil +} + +type SolidarityTransportDriverDataResult struct { + Driver mobilityaccountsstorage.Account + Availabilities []*gen.DriverRegularAvailability + Documents []filestorage.FileInfo + Bookings []*solidaritytypes.Booking + BeneficiariesMap map[string]mobilityaccountsstorage.Account + Stats map[string]any + WalletBalance float64 +} + +func (h *ApplicationHandler) GetSolidarityTransportDriverData(ctx context.Context, driverID string) (*SolidarityTransportDriverDataResult, error) { + // Get driver account + request := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, request) + if err != nil { + return nil, err + } + + // Security check: ensure this is actually a solidarity transport driver account + if resp.Account.Namespace != "solidarity_drivers" { + return nil, fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, resp.Account.Namespace) + } + + driver := resp.Account.ToStorageType() + + // Ensure other_properties exists to prevent template errors + if driver.Data == nil { + driver.Data = make(map[string]interface{}) + } + if driver.Data["other_properties"] == nil { + driver.Data["other_properties"] = make(map[string]interface{}) + } + + // Get availabilities + availRequest := &gen.GetDriverRegularAvailabilitiesRequest{ + DriverId: driverID, + } + + availResp, err := h.services.GRPC.SolidarityTransport.GetDriverRegularAvailabilities(ctx, availRequest) + if err != nil { + return nil, err + } + + // Get documents + documents := h.filestorage.List(filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS + "/" + driverID) + + // Get driver bookings + bookingsRequest := &gen.GetSolidarityTransportBookingsRequest{ + StartDate: timestamppb.New(time.Now().Add(-365 * 24 * time.Hour)), + EndDate: timestamppb.New(time.Now().Add(365 * 24 * time.Hour)), + Driverid: driverID, + } + + bookingsResp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, bookingsRequest) + protoBookings := []*gen.SolidarityTransportBooking{} + if err == nil { + protoBookings = bookingsResp.Bookings + } + + // Convert proto bookings to types with geojson.Feature + bookings := []*solidaritytypes.Booking{} + for _, protoBooking := range protoBookings { + booking, err := solidaritytransformers.BookingProtoToType(protoBooking) + if err != nil { + log.Error().Err(err).Msg("error converting booking proto to type") + continue + } + bookings = append(bookings, booking) + } + + // Collect unique passenger IDs + passengerIDs := []string{} + passengerIDsMap := make(map[string]bool) + for _, booking := range bookings { + if booking.PassengerId != "" { + if !passengerIDsMap[booking.PassengerId] { + passengerIDs = append(passengerIDs, booking.PassengerId) + passengerIDsMap[booking.PassengerId] = true + } + } + } + + // Get beneficiaries in batch + beneficiariesMap := make(map[string]mobilityaccountsstorage.Account) + if len(passengerIDs) > 0 { + beneficiariesResp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch(ctx, &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: passengerIDs, + }) + if err == nil { + for _, account := range beneficiariesResp.Accounts { + a := account.ToStorageType() + beneficiariesMap[a.ID] = a + } + } + } + + // Calculate stats only for validated bookings + validatedCount := 0 + kmnb := 0 + for _, booking := range bookings { + if booking.Status == "VALIDATED" { + validatedCount++ + if booking.Journey != nil { + kmnb += int(booking.Journey.DriverDistance) + } + } + } + + stats := map[string]any{ + "bookings": map[string]any{ + "count": validatedCount, + "km": kmnb, + }, + } + + // Calculate wallet balance like in original handler + walletBalance := h.calculateWalletBalance(driver) + + return &SolidarityTransportDriverDataResult{ + Driver: driver, + Availabilities: availResp.Results, + Documents: documents, + Bookings: bookings, + BeneficiariesMap: beneficiariesMap, + Stats: stats, + WalletBalance: walletBalance, + }, nil +} + +func (h *ApplicationHandler) ArchiveSolidarityTransportDriver(ctx context.Context, driverID string) error { + // Security check: verify the account exists and is a solidarity transport driver + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "solidarity_drivers" { + return fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, getResp.Account.Namespace) + } + + data, _ := structpb.NewValue(map[string]any{ + "archived": true, + }) + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "solidarity_drivers", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) UnarchiveSolidarityTransportDriver(ctx context.Context, driverID string) error { + // Security check: verify the account exists and is a solidarity transport driver + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "solidarity_drivers" { + return fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, getResp.Account.Namespace) + } + + data, _ := structpb.NewValue(map[string]any{ + "archived": false, + }) + + request := &mobilityaccounts.UpdateDataRequest{ + Account: &mobilityaccounts.Account{ + Id: driverID, + Namespace: "solidarity_drivers", + Data: data.GetStructValue(), + }, + } + + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, request) + return err +} + +func (h *ApplicationHandler) AddSolidarityTransportDriverDocument(ctx context.Context, driverID string, file io.Reader, filename string, fileSize int64, documentType, documentName string) error { + // Security check: verify the account exists and is a solidarity transport driver + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "solidarity_drivers" { + return fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, getResp.Account.Namespace) + } + + fileid := uuid.NewString() + + metadata := map[string]string{ + "type": documentType, + "name": documentName, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS, fmt.Sprintf("%s/%s_%s", driverID, fileid, filename), fileSize, metadata); err != nil { + return err + } + + return nil +} + +func (h *ApplicationHandler) GetSolidarityTransportDriverDocument(ctx context.Context, driverID, document string) (io.Reader, *filestorage.FileInfo, error) { + return h.GetDocument(ctx, SolidarityDriverDocumentConfig, driverID, document) +} + +func (h *ApplicationHandler) DeleteSolidarityTransportDriverDocument(ctx context.Context, driverID, document string) error { + return h.DeleteDocument(ctx, SolidarityDriverDocumentConfig, driverID, document) +} + +func (h *ApplicationHandler) AddSolidarityTransportAvailability(ctx context.Context, driverID, starttime, endtime string, address any, days map[string]bool) error { + // Security check: verify the account exists and is a solidarity transport driver + getRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + getResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, getRequest) + if err != nil { + return err + } + if getResp.Account.Namespace != "solidarity_drivers" { + return fmt.Errorf("account %s is not a solidarity transport driver (namespace: %s)", driverID, getResp.Account.Namespace) + } + + availabilities := []*gen.DriverRegularAvailability{} + + // Convert address to JSON string for the GRPC call + addressJSON := "" + if address != nil { + if addressBytes, err := json.Marshal(address); err == nil { + addressJSON = string(addressBytes) + } + } + + for day, enabled := range days { + if enabled { + dayValue := h.getDayValue(day) + a := &gen.DriverRegularAvailability{ + DriverId: driverID, + Day: dayValue, + StartTime: starttime, + EndTime: endtime, + Address: &gen.GeoJsonFeature{ + Serialized: addressJSON, + }, + } + availabilities = append(availabilities, a) + } + } + + req := &gen.AddDriverRegularAvailabilitiesRequest{ + Availabilities: availabilities, + } + _, err = h.services.GRPC.SolidarityTransport.AddDriverRegularAvailabilities(ctx, req) + return err +} + +func (h *ApplicationHandler) getDayValue(day string) int32 { + switch day { + case "sunday": + return Sunday + case "monday": + return Monday + case "tuesday": + return Tuesday + case "wednesday": + return Wednesday + case "thursday": + return Thursday + case "friday": + return Friday + case "saturday": + return Saturday + default: + return Monday + } +} + +func (h *ApplicationHandler) DeleteSolidarityTransportAvailability(ctx context.Context, driverID, availabilityID string) error { + req := &gen.DeleteDriverRegularAvailabilityRequest{ + DriverId: driverID, + AvailabilityId: availabilityID, + } + _, err := h.services.GRPC.SolidarityTransport.DeleteDriverRegularAvailability(ctx, req) + return err +} + +type SolidarityTransportJourneyDataResult struct { + Journey *solidaritytypes.DriverJourney + Driver mobilityaccountsstorage.Account + Passenger mobilityaccountsstorage.Account + Beneficiaries []mobilityaccountsstorage.Account + PassengerWalletBalance float64 + PricingResult map[string]pricing.Price +} + +func (h *ApplicationHandler) GetSolidarityTransportJourneyData(ctx context.Context, driverID, journeyID, passengerID string, currentUserGroup groupstorage.Group) (*SolidarityTransportJourneyDataResult, error) { + // Get journey using the correct API + journeyRequest := &gen.GetDriverJourneyRequest{ + DriverId: driverID, + JourneyId: journeyID, + } + + journeyResp, err := h.services.GRPC.SolidarityTransport.GetDriverJourney(ctx, journeyRequest) + if err != nil { + return nil, err + } + + // Transform proto to type + journey, err := solidaritytransformers.DriverJourneyProtoToType(journeyResp.DriverJourney) + if err != nil { + return nil, err + } + + // Get driver account + driverRequest := &mobilityaccounts.GetAccountRequest{ + Id: driverID, + } + + driverResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, driverRequest) + if err != nil { + return nil, err + } + + // Get passenger account + var passenger mobilityaccountsstorage.Account + if passengerID != "" { + passengerResp, err := h.services.GetAccount(passengerID) + if err != nil { + return nil, fmt.Errorf("could not get passenger account: %w", err) + } + passenger = passengerResp + } + + // Calculate pricing + pricingResult, err := h.calculateSolidarityTransportPricing(ctx, journeyResp.DriverJourney, passengerID, passenger) + if err != nil { + log.Error().Err(err).Msg("error calculating pricing") + pricingResult = map[string]pricing.Price{ + "passenger": {Amount: 0.0, Currency: "EUR"}, + "driver": {Amount: 0.0, Currency: "EUR"}, + } + } + + // Get beneficiaries in current user's group + beneficiaries, err := h.services.GetBeneficiariesInGroup(currentUserGroup) + if err != nil { + return nil, fmt.Errorf("could not get beneficiaries: %w", err) + } + + // Calculate passenger wallet balance like in original handler + passengerWalletBalance := h.calculateWalletBalance(passenger) + + return &SolidarityTransportJourneyDataResult{ + Journey: journey, + Driver: driverResp.Account.ToStorageType(), + Passenger: passenger, + Beneficiaries: beneficiaries, + PassengerWalletBalance: passengerWalletBalance, + PricingResult: pricingResult, + }, nil +} + +func (h *ApplicationHandler) CreateSolidarityTransportJourneyBooking(ctx context.Context, driverID, journeyID, passengerID, motivation, message string, doNotSend bool, returnWaitingTimeMinutes int) (string, error) { + // Get journey for pricing calculation + journeyRequest := &gen.GetDriverJourneyRequest{ + DriverId: driverID, + JourneyId: journeyID, + } + + journeyResp, err := h.services.GRPC.SolidarityTransport.GetDriverJourney(ctx, journeyRequest) + if err != nil { + return "", err + } + + // Get passenger account for pricing + var passenger mobilityaccountsstorage.Account + if passengerID != "" { + passengerResp, err := h.services.GetAccount(passengerID) + if err != nil { + return "", fmt.Errorf("could not get passenger account: %w", err) + } + passenger = passengerResp + } + + // Calculate pricing + pricingResult, err := h.calculateSolidarityTransportPricing(ctx, journeyResp.DriverJourney, passengerID, passenger) + priceAmount := float64(0) + driverCompensation := float64(0) + if err == nil { + priceAmount = pricingResult["passenger"].Amount + driverCompensation = pricingResult["driver"].Amount + } + + // Convert return waiting time from minutes to nanoseconds (time.Duration is in nanoseconds) + returnWaitingDuration := int64(returnWaitingTimeMinutes) * int64(time.Minute) + + // Create booking request + bookingRequest := &gen.BookDriverJourneyRequest{ + PassengerId: passengerID, + DriverId: driverID, + DriverJourneyId: journeyID, + ReturnWaitingDuration: returnWaitingDuration, + PriceAmount: priceAmount, + PriceCurrency: "EUR", + DriverCompensationAmount: driverCompensation, + DriverCompensationCurrency: "EUR", + Data: &structpb.Struct{ + Fields: map[string]*structpb.Value{ + "motivation": structpb.NewStringValue(motivation), + "message": structpb.NewStringValue(message), + "do_not_send": structpb.NewBoolValue(doNotSend), + }, + }, + } + + resp, err := h.services.GRPC.SolidarityTransport.BookDriverJourney(ctx, bookingRequest) + if err != nil { + return "", err + } + + // Send SMS if not disabled + if !doNotSend && message != "" { + send_message := strings.ReplaceAll(message, "{booking_id}", resp.Booking.Id) + if err := h.GenerateSMS(driverID, send_message); err != nil { + log.Error().Err(err).Msg("failed to send SMS") + } + } + + return resp.Booking.Id, nil +} + +func (h *ApplicationHandler) ToggleSolidarityTransportJourneyNoreturn(ctx context.Context, driverID, journeyID string) error { + // Toggle noreturn status + updateRequest := &gen.ToggleSolidarityTransportNoreturnRequest{ + JourneyId: journeyID, + } + + _, err := h.services.GRPC.SolidarityTransport.ToggleSolidarityTransportNoreturn(ctx, updateRequest) + return err +} + +type SolidarityTransportBookingDataResult struct { + Booking *solidaritytypes.Booking + Driver mobilityaccountsstorage.Account + Passenger mobilityaccountsstorage.Account + Journey *solidaritytypes.DriverJourney + PassengerWalletBalance float64 +} + +func (h *ApplicationHandler) GetSolidarityTransportBookingData(ctx context.Context, bookingID string) (*SolidarityTransportBookingDataResult, error) { + // Get booking + bookingRequest := &gen.GetSolidarityTransportBookingRequest{ + Id: bookingID, + } + + bookingResp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(ctx, bookingRequest) + if err != nil { + return nil, err + } + + booking := bookingResp.Booking + + // Get driver account + driverRequest := &mobilityaccounts.GetAccountRequest{ + Id: booking.DriverId, + } + + driverResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, driverRequest) + if err != nil { + return nil, err + } + + // Get passenger account + passengerRequest := &mobilityaccounts.GetAccountRequest{ + Id: booking.PassengerId, + } + + passengerResp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, passengerRequest) + if err != nil { + return nil, err + } + + // Transform booking proto to type + bookingType, err := solidaritytransformers.BookingProtoToType(booking) + if err != nil { + return nil, err + } + + // Calculate passenger wallet balance like in original handler + passengerWalletBalance := h.calculateWalletBalance(passengerResp.Account.ToStorageType()) + + return &SolidarityTransportBookingDataResult{ + Booking: bookingType, + Driver: driverResp.Account.ToStorageType(), + Passenger: passengerResp.Account.ToStorageType(), + Journey: bookingType.Journey, + PassengerWalletBalance: passengerWalletBalance, + }, nil +} + +func (h *ApplicationHandler) solidarityDrivers(searchFilter string, archivedFilter bool) ([]mobilityaccountsstorage.Account, error) { + request := &mobilityaccounts.GetAccountsRequest{ + Namespaces: []string{"solidarity_drivers"}, + } + + resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), request) + if err != nil { + return nil, err + } + + // Create iterator that filters and transforms accounts + filteredAccounts := func(yield func(mobilityaccountsstorage.Account) bool) { + for _, account := range resp.Accounts { + if h.filterSolidarityDriver(account, searchFilter, archivedFilter) { + if !yield(account.ToStorageType()) { + return + } + } + } + } + + return slices.Collect(filteredAccounts), nil +} + +func (h *ApplicationHandler) filterSolidarityDriver(a *mobilityaccounts.Account, searchFilter string, archivedFilter bool) bool { + // Search filter + if searchFilter != "" { + name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) + if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter)) { + return false + } + } + + // Archived filter + if archivedFilter { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return true + } + return false + } else { + if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { + return false + } + } + + return true +} + +func (h *ApplicationHandler) pricingGeography(loc *geojson.Feature) pricing.GeographyParams { + if loc == nil { + return pricing.GeographyParams{} + } + + geo, err := h.services.Geography.GeoSearch(loc) + if err != nil { + log.Error().Err(err).Msg("issue in geosearch") + return pricing.GeographyParams{} + } + return pricing.GeographyParams{ + Location: loc, + CityCode: geo["communes"].Properties.MustString("code"), + IntercommunalityCode: geo["epci"].Properties.MustString("code"), + RegionCode: geo["regions"].Properties.MustString("code"), + DepartmentCode: geo["departements"].Properties.MustString("code"), + } +} + +func (h *ApplicationHandler) calculateSolidarityTransportPricing(ctx context.Context, journey *gen.SolidarityTransportDriverJourney, passengerID string, passenger mobilityaccountsstorage.Account) (map[string]pricing.Price, error) { + // Transform proto to type for geography access + journeyType, err := solidaritytransformers.DriverJourneyProtoToType(journey) + if err != nil { + return nil, err + } + + benefParams := pricing.BeneficiaryParams{} + if passengerID == "" { + benefParams = pricing.BeneficiaryParams{ + Address: h.pricingGeography(journeyType.PassengerPickup), + History: 99, + Priority: false, + } + } else { + // Get solidarity transport history for passenger + solidarity, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(ctx, &gen.GetSolidarityTransportBookingsRequest{ + Passengerid: passengerID, + StartDate: timestamppb.New(time.Now().Add(-12 * 730 * time.Hour)), + EndDate: timestamppb.New(time.Now().Add(12 * 730 * time.Hour)), + }) + + priority := false + if a, ok := passenger.Data["other_properties"]; ok { + if b, ok := a.(map[string]any); ok { + if c, ok := b["status"]; ok { + if p, ok := c.(string); ok { + priority = (p == "Prioritaire") + } + } + } + } + + history := 0 + if op, ok := passenger.Data["other_properties"]; ok { + if op_map, ok := op.(map[string]any); ok { + if pst, ok := op_map["previous_solidarity_transport"]; ok { + if pst_str, ok := pst.(string); ok { + if pst_str != "" { + if n, err := strconv.Atoi(pst_str); err == nil { + history = history + n + } else { + log.Error().Err(err).Str("n", pst_str).Msg("string to int conversion error") + } + } + } + } + } + } + + if err == nil { + history = history + len(solidarity.Bookings) + } + + var passengerGeo pricing.GeographyParams + if pa, ok := passenger.Data["address"]; ok { + jsonpa, err := json.Marshal(pa) + if err == nil { + passGeojson, err := geojson.UnmarshalFeature(jsonpa) + if err == nil { + passengerGeo = h.pricingGeography(passGeojson) + } + } + } + + benefParams = pricing.BeneficiaryParams{ + Address: passengerGeo, + History: history, + Priority: priority, + } + } + + pricingResult, err := h.services.Pricing.Prices(pricing.PricingParams{ + MobilityType: "solidarity_transport", + Beneficiary: benefParams, + SharedMobility: pricing.SharedMobilityParams{ + DriverDistance: journey.DriverDistance, + PassengerDistance: journey.PassengerDistance, + Departure: h.pricingGeography(journeyType.PassengerPickup), + Destination: h.pricingGeography(journeyType.PassengerDrop), + OutwardOnly: journey.Noreturn, + }, + }) + if err != nil { + log.Error().Err(err).Msg("error in pricing calculation") + return nil, err + } + + return pricingResult, nil +} + +func (h *ApplicationHandler) UpdateSolidarityTransportBookingStatus(ctx context.Context, bookingID, action, reason, message string, notify bool) error { + var status string + switch action { + case "confirm": + status = "VALIDATED" + case "cancel": + status = "CANCELLED" + case "waitconfirmation": + status = "WAITING_CONFIRMATION" + default: + return fmt.Errorf("invalid action: %s", action) + } + + // Get booking details BEFORE updating to capture previous status + result, err := h.GetSolidarityTransportBookingData(ctx, bookingID) + if err != nil { + return err + } + + booking := result.Booking + driver := result.Driver + passenger := result.Passenger + previousStatus := booking.Status + + // Update booking status + _, err = h.services.GRPC.SolidarityTransport.UpdateSolidarityTransportBookingStatus(ctx, &gen.UpdateSolidarityTransportBookingStatusRequest{ + BookingId: bookingID, + NewStatus: status, + Reason: reason, + }) + if err != nil { + return fmt.Errorf("update booking status issue: %w", err) + } + + // Handle wallet operations based on status transitions + // Credit driver / debit passenger when previous status was not VALIDATED and new status is VALIDATED + if previousStatus != "VALIDATED" && status == "VALIDATED" { + if message != "" { + send_message := strings.ReplaceAll(message, "{booking_id}", bookingID) + h.GenerateSMS(passenger.ID, send_message) + } + if err := h.CreditWallet(ctx, passenger.ID, -1*booking.Journey.Price.Amount, "Transport solidaire", "Débit transport solidaire"); err != nil { + return fmt.Errorf("could not debit passenger wallet: %w", err) + } + if err := h.CreditWallet(ctx, driver.ID, booking.DriverCompensationAmount, "Transport solidaire", "Crédit transport solidaire"); err != nil { + return fmt.Errorf("could not credit driver wallet: %w", err) + } + } + + // Credit passenger / debit driver when previous status was VALIDATED and new status is not VALIDATED anymore + if previousStatus == "VALIDATED" && status != "VALIDATED" { + if err := h.CreditWallet(ctx, passenger.ID, booking.Journey.Price.Amount, "Transport solidaire", "Remboursement annulation transport solidaire"); err != nil { + return fmt.Errorf("could not credit passenger wallet: %w", err) + } + if err := h.CreditWallet(ctx, driver.ID, -1*booking.DriverCompensationAmount, "Transport solidaire", "Débit annulation transport solidaire"); err != nil { + return fmt.Errorf("could not debit driver wallet: %w", err) + } + } + + // Handle notifications for cancelled status + if status == "CANCELLED" && notify { + // NOTIFY GROUP MEMBERS + groupsrequest := &groupsmanagement.GetGroupsRequest{ + Namespaces: []string{"parcoursmob_organizations"}, + Member: booking.PassengerId, + } + + groupsresp, err := h.services.GRPC.GroupsManagement.GetGroups(ctx, groupsrequest) + if err != nil { + log.Error().Err(err).Msg("") + return nil // Don't fail the whole operation for notification issues + } + + if len(groupsresp.Groups) > 0 { + members, _, err := h.groupmembers(groupsresp.Groups[0].Id) + if err != nil { + log.Error().Err(err).Msg("could not retrieve groupe members") + } else { + for _, m := range members { + if email, ok := m.Data["email"].(string); ok { + h.emailing.Send("solidarity_transport.booking_driver_decline", email, map[string]string{ + "bookingid": booking.Id, + "baseUrl": h.config.GetString("base_url"), + }) + } + } + } + } + } + + return nil +} diff --git a/core/application/support.go b/core/application/support.go new file mode 100755 index 0000000..4c9f7d9 --- /dev/null +++ b/core/application/support.go @@ -0,0 +1,33 @@ +package application + +import ( + "context" + "fmt" + + "github.com/rs/zerolog/log" +) + +type Message struct { + Content string +} + +func (h *ApplicationHandler) SendSupportMessage(ctx context.Context, comment, userEmail string) error { + data := map[string]any{ + "key": comment, + "user": userEmail, + } + + supportEmail := h.config.GetString("modules.support.email") + if supportEmail == "" { + supportEmail = "support@mobicoop.fr" + } + + log.Debug().Str("user_email", userEmail).Str("support_email", supportEmail).Msg("Sending support message") + + if err := h.emailing.Send("support.request", supportEmail, data); err != nil { + return fmt.Errorf("failed to send support email: %w", err) + } + + return nil +} + diff --git a/core/application/vehicles-management.go b/core/application/vehicles-management.go new file mode 100755 index 0000000..39c52dd --- /dev/null +++ b/core/application/vehicles-management.go @@ -0,0 +1,600 @@ +package application + +import ( + "context" + "fmt" + "sort" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/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" + 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" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type VehiclesManagementOverviewResult struct { + Vehicles []fleetsstorage.Vehicle + VehiclesMap map[string]fleetsstorage.Vehicle + DriversMap map[string]mobilityaccountsstorage.Account + Bookings []fleetsstorage.Booking +} + +func (h *ApplicationHandler) GetVehiclesManagementOverview(ctx context.Context, groupID string) (*VehiclesManagementOverviewResult, error) { + request := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + } + resp, err := h.services.GRPC.Fleets.GetVehicles(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get vehicles: %w", err) + } + + vehicles := []fleetsstorage.Vehicle{} + bookings := []fleetsstorage.Booking{} + vehiclesMap := map[string]fleetsstorage.Vehicle{} + + for _, vehicle := range resp.Vehicles { + if h.filterVehicleByGroup(vehicle, groupID) { + v := vehicle.ToStorageType() + vehicleBookings := []fleetsstorage.Booking{} + for _, b := range v.Bookings { + log.Debug().Any("booking", b).Msg("debug") + if b.Status() != fleetsstorage.StatusOld { + if !b.Deleted { + bookings = append(bookings, b) + } + } + if b.Unavailableto.After(time.Now()) { + vehicleBookings = append(vehicleBookings, b) + } + } + v.Bookings = vehicleBookings + vehicles = append(vehicles, v) + vehiclesMap[v.ID] = v + } + } + + driversMap, _ := h.services.GetBeneficiariesMap() + + sort.Sort(sorting.VehiclesByLicencePlate(vehicles)) + sort.Sort(sorting.BookingsByStartdate(bookings)) + + return &VehiclesManagementOverviewResult{ + Vehicles: vehicles, + VehiclesMap: vehiclesMap, + DriversMap: driversMap, + Bookings: bookings, + }, nil +} + +func (h *ApplicationHandler) filterVehicleByGroup(v *fleets.Vehicle, groupID string) bool { + if groupID == "" { + return false + } + + for _, n := range v.Administrators { + if n == groupID { + return true + } + } + return false +} + +type VehiclesManagementBookingsListResult struct { + VehiclesMap map[string]fleetsstorage.Vehicle + DriversMap map[string]mobilityaccountsstorage.Account + Bookings []fleetsstorage.Booking + CacheID string +} + +func (h *ApplicationHandler) GetVehiclesManagementBookingsList(ctx context.Context, groupID, status, startDate, endDate string) (*VehiclesManagementBookingsListResult, error) { + request := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + IncludeDeleted: true, + } + resp, err := h.services.GRPC.Fleets.GetVehicles(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get vehicles: %w", err) + } + + bookings := []fleetsstorage.Booking{} + vehiclesMap := map[string]fleetsstorage.Vehicle{} + + // 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 + } + } + + for _, vehicle := range resp.Vehicles { + if h.filterVehicleByGroup(vehicle, groupID) { + v := vehicle.ToStorageType() + vehiclesMap[v.ID] = v + for _, b := range v.Bookings { + if v, ok := b.Data["administrator_unavailability"].(bool); !ok || !v { + // 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) + } + } + } + } + + sort.Sort(sorting.BookingsByStartdate(bookings)) + + cacheID := uuid.NewString() + h.cache.PutWithTTL(cacheID, bookings, 1*time.Hour) + + driversMap, _ := h.services.GetBeneficiariesMap() + + return &VehiclesManagementBookingsListResult{ + VehiclesMap: vehiclesMap, + DriversMap: driversMap, + Bookings: bookings, + CacheID: cacheID, + }, nil +} + +func (h *ApplicationHandler) CreateVehicle(ctx context.Context, name, vehicleType, informations, licencePlate, kilometers string, automatic bool, address map[string]any, otherProperties map[string]any) (string, error) { + g := ctx.Value(identification.GroupKey) + if g == nil { + return "", fmt.Errorf("no group found in context") + } + group := g.(storage.Group) + + dataMap := map[string]any{} + if name != "" { + dataMap["name"] = name + } + if address != nil { + dataMap["address"] = address + } + if informations != "" { + dataMap["informations"] = informations + } + if licencePlate != "" { + dataMap["licence_plate"] = licencePlate + } + dataMap["automatic"] = automatic + if kilometers != "" { + dataMap["kilometers"] = kilometers + } + // Add other properties + for key, value := range otherProperties { + dataMap[key] = value + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", fmt.Errorf("failed to create data struct: %w", err) + } + + vehicle := &fleets.Vehicle{ + Id: uuid.NewString(), + Namespace: "parcoursmob", + Type: vehicleType, + Administrators: []string{group.ID}, + Data: data.GetStructValue(), + } + + request := &fleets.AddVehicleRequest{ + Vehicle: vehicle, + } + + _, err = h.services.GRPC.Fleets.AddVehicle(ctx, request) + if err != nil { + return "", fmt.Errorf("failed to add vehicle: %w", err) + } + + return vehicle.Id, nil +} + +func (h *ApplicationHandler) GetVehicleTypes(ctx context.Context) ([]string, error) { + return h.config.GetStringSlice("modules.fleets.vehicle_types"), nil +} + +type VehicleDisplayResult struct { + Vehicle fleetsstorage.Vehicle + Beneficiaries map[string]mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) GetVehicleDisplay(ctx context.Context, vehicleID string) (*VehicleDisplayResult, error) { + request := &fleets.GetVehicleRequest{ + Vehicleid: vehicleID, + } + + resp, err := h.services.GRPC.Fleets.GetVehicle(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get vehicle: %w", err) + } + + beneficiaries, err := h.services.GetBeneficiariesMap() + if err != nil { + return nil, fmt.Errorf("failed to get beneficiaries: %w", err) + } + + vehicle := resp.Vehicle.ToStorageType() + + // Sort bookings by start date (most recent first) + sort.Slice(vehicle.Bookings, func(i, j int) bool { + return vehicle.Bookings[i].Startdate.After(vehicle.Bookings[j].Startdate) + }) + + return &VehicleDisplayResult{ + Vehicle: vehicle, + Beneficiaries: beneficiaries, + }, nil +} + +func (h *ApplicationHandler) UpdateBooking(ctx context.Context, bookingID, startdate, enddate, unavailablefrom, unavailableto string) error { + booking, err := h.services.GetBooking(bookingID) + if err != nil { + return fmt.Errorf("failed to get booking: %w", err) + } + + newbooking, _ := fleets.BookingFromStorageType(&booking) + + if startdate != "" { + newstartdate, _ := time.Parse("2006-01-02", startdate) + newbooking.Startdate = timestamppb.New(newstartdate) + + if newstartdate.Before(newbooking.Unavailablefrom.AsTime()) { + newbooking.Unavailablefrom = timestamppb.New(newstartdate) + } + } + + if enddate != "" { + newenddate, _ := time.Parse("2006-01-02", enddate) + newbooking.Enddate = timestamppb.New(newenddate) + + if newenddate.After(newbooking.Unavailableto.AsTime()) || newenddate.Equal(newbooking.Unavailableto.AsTime()) { + newbooking.Unavailableto = timestamppb.New(newenddate.Add(24 * time.Hour)) + } + } + + if unavailablefrom != "" { + newunavailablefrom, _ := time.Parse("2006-01-02", unavailablefrom) + newbooking.Unavailablefrom = timestamppb.New(newunavailablefrom) + } + + if unavailableto != "" { + newunavailableto, _ := time.Parse("2006-01-02", unavailableto) + newbooking.Unavailableto = timestamppb.New(newunavailableto) + } + + request := &fleets.UpdateBookingRequest{ + Booking: newbooking, + } + + _, err = h.services.GRPC.Fleets.UpdateBooking(ctx, request) + return err +} + +type BookingDisplayResult struct { + Booking fleetsstorage.Booking + Vehicle fleetsstorage.Vehicle + Beneficiary mobilityaccountsstorage.Account + Group storage.Group + Documents []filestorage.FileInfo + FileTypesMap map[string]string + Alternatives []any +} + +func (h *ApplicationHandler) GetBookingDisplay(ctx context.Context, bookingID string) (*BookingDisplayResult, error) { + booking, err := h.services.GetBooking(bookingID) + if err != nil { + return nil, fmt.Errorf("failed to get booking: %w", err) + } + + beneficiary := mobilityaccountsstorage.Account{} + if booking.Driver != "" { + beneficiaryrequest := &mobilityaccounts.GetAccountRequest{ + Id: booking.Driver, + } + + beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, beneficiaryrequest) + if err != nil { + return nil, fmt.Errorf("failed to get beneficiary: %w", err) + } + beneficiary = beneficiaryresp.Account.ToStorageType() + } + + grouprequest := &groupsmanagement.GetGroupRequest{ + Id: booking.Vehicle.Administrators[0], + } + + groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, grouprequest) + if err != nil { + return nil, fmt.Errorf("failed to get group: %w", err) + } + + alternativerequest := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + Types: []string{booking.Vehicle.Type}, + Administrators: booking.Vehicle.Administrators, + AvailabilityFrom: timestamppb.New(booking.Startdate), + AvailabilityTo: timestamppb.New(booking.Enddate.Add(24 * time.Hour)), + } + + alternativeresp, err := h.services.GRPC.Fleets.GetVehicles(ctx, alternativerequest) + if err != nil { + log.Error().Err(err).Msg("failed to get alternative vehicles") + } + + alternatives := []any{} + for _, a := range alternativeresp.Vehicles { + alternatives = append(alternatives, a.ToStorageType()) + } + + documents := h.filestorage.List(filestorage.PREFIX_BOOKINGS + "/" + bookingID) + fileTypesMap := h.config.GetStringMapString("storage.files.file_types") + + return &BookingDisplayResult{ + Booking: booking, + Vehicle: booking.Vehicle, + Beneficiary: beneficiary, + Group: groupresp.Group.ToStorageType(), + Documents: documents, + FileTypesMap: fileTypesMap, + Alternatives: alternatives, + }, nil +} + +func (h *ApplicationHandler) ChangeBookingVehicle(ctx context.Context, bookingID, newVehicleID string) error { + booking, err := h.services.GetBooking(bookingID) + if err != nil { + return fmt.Errorf("failed to get booking: %w", err) + } + + booking.Vehicleid = newVehicleID + b, _ := fleets.BookingFromStorageType(&booking) + + request := &fleets.UpdateBookingRequest{ + Booking: b, + } + + _, err = h.services.GRPC.Fleets.UpdateBooking(ctx, request) + return err +} + +func (h *ApplicationHandler) MakeVehicleUnavailable(ctx context.Context, vehicleID, unavailablefrom, unavailableto, comment, currentUserID string, currentUserClaims map[string]any) error { + g := ctx.Value(identification.GroupKey) + if g == nil { + return fmt.Errorf("no group found in context") + } + currentGroup := g.(storage.Group) + + unavailablefromTime, _ := time.Parse("2006-01-02", unavailablefrom) + unavailabletoTime, _ := time.Parse("2006-01-02", unavailableto) + + data := map[string]any{ + "comment": comment, + "administrator_unavailability": true, + "booked_by": map[string]any{ + "user": map[string]any{ + "id": currentUserID, + "display_name": currentUserClaims["display_name"], + }, + "group": map[string]any{ + "id": currentGroup.ID, + "name": currentGroup.Data["name"], + }, + }, + } + + datapb, err := structpb.NewStruct(data) + if err != nil { + return fmt.Errorf("failed to create data struct: %w", err) + } + + booking := &fleets.Booking{ + Id: uuid.NewString(), + Vehicleid: vehicleID, + Unavailablefrom: timestamppb.New(unavailablefromTime), + Unavailableto: timestamppb.New(unavailabletoTime), + Data: datapb, + } + + request := &fleets.CreateBookingRequest{ + Booking: booking, + } + + _, err = h.services.GRPC.Fleets.CreateBooking(ctx, request) + return err +} + +func (h *ApplicationHandler) DeleteBooking(ctx context.Context, bookingID string) error { + request := &fleets.DeleteBookingRequest{ + Id: bookingID, + } + + _, err := h.services.GRPC.Fleets.DeleteBooking(ctx, request) + return err +} + +func (h *ApplicationHandler) GetBookingForUnbooking(ctx context.Context, bookingID string) (fleetsstorage.Booking, error) { + request := &fleets.GetBookingRequest{ + Bookingid: bookingID, + } + + resp, err := h.services.GRPC.Fleets.GetBooking(ctx, request) + if err != nil { + return fleetsstorage.Booking{}, fmt.Errorf("failed to get booking: %w", err) + } + + return resp.Booking.ToStorageType(), nil +} + +func (h *ApplicationHandler) UnbookVehicle(ctx context.Context, bookingID, motif, currentUserID string, currentUserClaims map[string]any, currentGroup any) error { + group := currentGroup.(storage.Group) + + // Prepare deletion metadata (microservice will add deleted_at automatically) + deletionMetadata := map[string]any{ + "deleted_by": map[string]any{ + "user": map[string]any{ + "id": currentUserID, + "display_name": currentUserClaims["first_name"].(string) + " " + currentUserClaims["last_name"].(string), + "email": currentUserClaims["email"], + }, + "group": map[string]any{ + "id": group.ID, + "name": group.Data["name"], + }, + }, + "reason": motif, + } + + deletionMetadataPb, err := structpb.NewStruct(deletionMetadata) + if err != nil { + return fmt.Errorf("failed to create deletion metadata: %w", err) + } + + // Use the microservice's delete endpoint with metadata + deleteRequest := &fleets.DeleteBookingRequest{ + Id: bookingID, + DeletionMetadata: deletionMetadataPb, + } + + _, err = h.services.GRPC.Fleets.DeleteBooking(ctx, deleteRequest) + return err +} + +type VehicleForUpdateResult struct { + Vehicle fleetsstorage.Vehicle + VehicleTypes []string +} + +func (h *ApplicationHandler) GetVehicleForUpdate(ctx context.Context, vehicleID string) (*VehicleForUpdateResult, error) { + request := &fleets.GetVehicleRequest{ + Vehicleid: vehicleID, + } + + resp, err := h.services.GRPC.Fleets.GetVehicle(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get vehicle: %w", err) + } + + vehicleTypes := h.config.GetStringSlice("modules.fleets.vehicle_types") + + return &VehicleForUpdateResult{ + Vehicle: resp.Vehicle.ToStorageType(), + VehicleTypes: vehicleTypes, + }, nil +} + +func (h *ApplicationHandler) UpdateVehicle(ctx context.Context, vehicleID, name, vehicleType, informations, licencePlate, kilometers string, automatic bool, address map[string]any, otherProperties map[string]any) (string, error) { + getRequest := &fleets.GetVehicleRequest{ + Vehicleid: vehicleID, + } + + resp, err := h.services.GRPC.Fleets.GetVehicle(ctx, getRequest) + if err != nil { + return "", fmt.Errorf("failed to get vehicle: %w", err) + } + + // Start with existing data to preserve all fields + dataMap := resp.Vehicle.Data.AsMap() + if dataMap == nil { + dataMap = map[string]any{} + } + + // Update with new values + if name != "" { + dataMap["name"] = name + } + if address != nil { + dataMap["address"] = address + } + if informations != "" { + dataMap["informations"] = informations + } + if licencePlate != "" { + dataMap["licence_plate"] = licencePlate + } + if kilometers != "" { + dataMap["kilometers"] = kilometers + } + dataMap["automatic"] = automatic + // Add other properties + for key, value := range otherProperties { + dataMap[key] = value + } + + data, err := structpb.NewValue(dataMap) + if err != nil { + return "", fmt.Errorf("failed to create data struct: %w", err) + } + + updateRequest := &fleets.UpdateVehicleRequest{ + Vehicle: &fleets.Vehicle{ + Id: vehicleID, + Namespace: resp.Vehicle.Namespace, + Type: vehicleType, + Administrators: resp.Vehicle.Administrators, + Data: data.GetStructValue(), + }, + } + + updateResp, err := h.services.GRPC.Fleets.UpdateVehicle(ctx, updateRequest) + if err != nil { + return "", fmt.Errorf("failed to update vehicle: %w", err) + } + + return updateResp.Vehicle.Id, nil +} + diff --git a/core/application/vehicles.go b/core/application/vehicles.go new file mode 100755 index 0000000..9427925 --- /dev/null +++ b/core/application/vehicles.go @@ -0,0 +1,393 @@ +package application + +import ( + "context" + "encoding/json" + "fmt" + "io" + "slices" + "sort" + "strings" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi" + "git.coopgo.io/coopgo-platform/fleets/storage" + groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" + groupsmanagementstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/google/uuid" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" + "google.golang.org/protobuf/types/known/structpb" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type VehiclesSearchResult struct { + Vehicles []storage.Vehicle + Beneficiary mobilityaccountsstorage.Account + BeneficiaryDocuments []filestorage.FileInfo + Groups map[string]any + Searched bool + StartDate string + EndDate string + VehicleType string + Automatic bool + MandatoryDocuments []string + FileTypesMap map[string]string + VehicleTypes []string + Beneficiaries []mobilityaccountsstorage.Account +} + +func (h *ApplicationHandler) SearchVehicles(ctx context.Context, beneficiaryID, startDateStr, endDateStr, vehicleType string, automatic bool) (*VehiclesSearchResult, error) { + var beneficiary mobilityaccountsstorage.Account + beneficiarydocuments := []filestorage.FileInfo{} + vehicles := []storage.Vehicle{} + searched := false + administrators := []string{} + + startdate, err := time.Parse("2006-01-02", startDateStr) + if err != nil { + startdate = time.Time{} + } + enddate, err := time.Parse("2006-01-02", endDateStr) + if err != nil { + enddate = time.Time{} + } + + if beneficiaryID != "" && startdate.After(time.Now().Add(-24*time.Hour)) && enddate.After(startdate) { + // Handler form + searched = true + + requestbeneficiary := &mobilityaccounts.GetAccountRequest{ + Id: beneficiaryID, + } + + respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, requestbeneficiary) + if err != nil { + return nil, fmt.Errorf("failed to get beneficiary: %w", err) + } + + beneficiary = respbeneficiary.Account.ToStorageType() + + request := &fleets.GetVehiclesRequest{ + Namespaces: []string{"parcoursmob"}, + AvailabilityFrom: timestamppb.New(startdate), + AvailabilityTo: timestamppb.New(enddate), + } + + if vehicleType != "" { + request.Types = []string{vehicleType} + } + + resp, err := h.services.GRPC.Fleets.GetVehicles(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get vehicles: %w", err) + } + + for _, vehicle := range resp.Vehicles { + v := vehicle.ToStorageType() + + if vehicleType == "Voiture" && automatic { + if auto, ok := v.Data["automatic"].(bool); !ok || !auto { + continue + } + } + + 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) + } + + // Sort vehicles if beneficiary address is set + if beneficiaryAddress, ok := beneficiary.Data["address"]; ok { + beneficiaryAddressJson, err := json.Marshal(beneficiaryAddress) + if err == nil { + beneficiaryAddressGeojson, err := geojson.UnmarshalFeature(beneficiaryAddressJson) + if err == nil { + slices.SortFunc(vehicles, sorting.VehiclesByDistanceFrom(*beneficiaryAddressGeojson)) + } else { + log.Error().Err(err).Msg("error transforming beneficiary address to GeoJSON") + } + } else { + log.Error().Err(err).Msg("error transforming beneficiary address to JSON") + } + } + + beneficiarydocuments = h.filestorage.List(filestorage.PREFIX_BENEFICIARIES + "/" + beneficiary.ID) + } + + accounts, err := h.services.GetBeneficiariesMap() + if err != nil { + return nil, fmt.Errorf("failed to get beneficiaries: %w", err) + } + + // Convert map to slice for compatibility + beneficiaries := make([]mobilityaccountsstorage.Account, 0, len(accounts)) + for _, account := range accounts { + beneficiaries = append(beneficiaries, account) + } + + groups := map[string]any{} + if len(administrators) > 0 { + admingroups, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(ctx, &groupsmanagement.GetGroupsBatchRequest{ + Groupids: administrators, + }) + if err != nil { + return nil, fmt.Errorf("failed to get admin groups: %w", err) + } + + for _, g := range admingroups.Groups { + groups[g.Id] = g.ToStorageType() + } + } + + sort.Sort(sorting.BeneficiariesByName(beneficiaries)) + + mandatoryDocuments := h.config.GetStringSlice("modules.fleets.booking_documents.mandatory") + fileTypesMap := h.config.GetStringMapString("storage.files.file_types") + vehicleTypes := h.config.GetStringSlice("modules.fleets.vehicle_types") + + return &VehiclesSearchResult{ + Vehicles: vehicles, + Beneficiary: beneficiary, + BeneficiaryDocuments: beneficiarydocuments, + Groups: groups, + Searched: searched, + StartDate: startDateStr, + EndDate: endDateStr, + VehicleType: vehicleType, + Automatic: automatic, + MandatoryDocuments: mandatoryDocuments, + FileTypesMap: fileTypesMap, + VehicleTypes: vehicleTypes, + Beneficiaries: beneficiaries, + }, nil +} + +type BookVehicleResult struct { + BookingID string +} + +func (h *ApplicationHandler) BookVehicle(ctx context.Context, vehicleID, beneficiaryID, startDateStr, endDateStr string, documents map[string]io.Reader, documentHeaders map[string]string, existingDocs map[string]string, currentUserID string, currentUserClaims map[string]any, currentGroup any) (*BookVehicleResult, error) { + group := currentGroup.(groupsmanagementstorage.Group) + + vehicle, err := h.services.GRPC.Fleets.GetVehicle(ctx, &fleets.GetVehicleRequest{ + Vehicleid: vehicleID, + }) + if err != nil { + return nil, fmt.Errorf("vehicle not found: %w", err) + } + + startdate, err := time.Parse("2006-01-02", startDateStr) + if err != nil { + return nil, fmt.Errorf("invalid start date: %w", err) + } + enddate, err := time.Parse("2006-01-02", endDateStr) + if err != nil { + return nil, fmt.Errorf("invalid end date: %w", err) + } + + data := map[string]any{ + "booked_by": map[string]any{ + "user": map[string]any{ + "id": currentUserID, + "display_name": fmt.Sprintf("%s %s", currentUserClaims["first_name"], currentUserClaims["last_name"]), + }, + "group": map[string]any{ + "id": group.ID, + "name": group.Data["name"], + }, + }, + } + datapb, err := structpb.NewStruct(data) + if err != nil { + return nil, fmt.Errorf("failed to create booking metadata: %w", err) + } + + bookingID := uuid.NewString() + booking := &fleets.Booking{ + Id: bookingID, + Vehicleid: vehicleID, + Driver: beneficiaryID, + Startdate: timestamppb.New(startdate), + Enddate: timestamppb.New(enddate), + Unavailablefrom: timestamppb.New(startdate), + Unavailableto: timestamppb.New(enddate.Add(72 * time.Hour)), + Data: datapb, + } + + request := &fleets.CreateBookingRequest{ + Booking: booking, + } + + // Handle document uploads + for docType, file := range documents { + fileid := uuid.NewString() + filename := documentHeaders[docType] + + metadata := map[string]string{ + "type": docType, + "name": filename, + } + + if err := h.filestorage.Put(file, filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s_%s", bookingID, fileid, filename), -1, metadata); err != nil { + return nil, fmt.Errorf("failed to upload document %s: %w", docType, err) + } + } + + // Handle existing documents + for docType, existingFile := range existingDocs { + path := strings.Split(existingFile, "/") + if err := h.filestorage.Copy(existingFile, fmt.Sprintf("%s/%s/%s", filestorage.PREFIX_BOOKINGS, bookingID, path[len(path)-1])); err != nil { + return nil, fmt.Errorf("failed to copy existing document %s: %w", docType, err) + } + } + + _, err = h.services.GRPC.Fleets.CreateBooking(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to create booking: %w", err) + } + + // NOTIFY GROUP MEMBERS + members, _, err := h.groupmembers(vehicle.Vehicle.Administrators[0]) + if err != nil { + log.Error().Err(err).Msg("failed to get group members for notification") + } else { + for _, m := range members { + if email, ok := m.Data["email"].(string); ok { + h.emailing.Send("fleets.bookings.creation_admin_alert", email, map[string]string{ + "bookingid": bookingID, + }) + } + } + } + + return &BookVehicleResult{ + BookingID: bookingID, + }, nil +} + + + + +type VehicleBookingDetailsResult struct { + Booking storage.Booking + Vehicle storage.Vehicle + Beneficiary mobilityaccountsstorage.Account + Group groupsmanagementstorage.Group + Documents []filestorage.FileInfo + FileTypesMap map[string]string +} + +func (h *ApplicationHandler) GetVehicleBookingDetails(ctx context.Context, bookingID string) (*VehicleBookingDetailsResult, error) { + request := &fleets.GetBookingRequest{ + Bookingid: bookingID, + } + resp, err := h.services.GRPC.Fleets.GetBooking(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get booking: %w", err) + } + + booking := resp.Booking.ToStorageType() + + beneficiaryrequest := &mobilityaccounts.GetAccountRequest{ + Id: booking.Driver, + } + + beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(ctx, beneficiaryrequest) + if err != nil { + beneficiaryresp = &mobilityaccounts.GetAccountResponse{ + Account: &mobilityaccounts.Account{}, + } + } + + grouprequest := &groupsmanagement.GetGroupRequest{ + Id: booking.Vehicle.Administrators[0], + } + + groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(ctx, grouprequest) + if err != nil { + return nil, fmt.Errorf("failed to get group: %w", err) + } + + documents := h.filestorage.List(filestorage.PREFIX_BOOKINGS + "/" + bookingID) + fileTypesMap := h.config.GetStringMapString("storage.files.file_types") + + return &VehicleBookingDetailsResult{ + Booking: booking, + Vehicle: booking.Vehicle, + Beneficiary: beneficiaryresp.Account.ToStorageType(), + Group: groupresp.Group.ToStorageType(), + Documents: documents, + FileTypesMap: fileTypesMap, + }, nil +} + +type VehicleBookingsListResult struct { + Bookings []storage.Booking + VehiclesMap map[string]storage.Vehicle + GroupsMap map[string]groupsmanagementstorage.Group +} + +func (h *ApplicationHandler) GetVehicleBookingsList(ctx context.Context, groupID string) (*VehicleBookingsListResult, error) { + request := &fleets.GetBookingsRequest{} + resp, err := h.services.GRPC.Fleets.GetBookings(ctx, request) + if err != nil { + return nil, fmt.Errorf("failed to get bookings: %w", err) + } + + bookings := []storage.Booking{} + + for _, b := range resp.Bookings { + booking := b.ToStorageType() + if b1, ok := booking.Data["booked_by"].(map[string]any); ok { + if b2, ok := b1["group"].(map[string]any); ok { + if b2["id"] == groupID { + bookings = append(bookings, booking) + } + } + } + } + + vehiclesMap, err := h.services.GetVehiclesMap() + if err != nil { + return nil, fmt.Errorf("failed to get vehicles map: %w", err) + } + + groupsMap, err := h.services.GetGroupsMap() + if err != nil { + return nil, fmt.Errorf("failed to get groups map: %w", err) + } + + return &VehicleBookingsListResult{ + Bookings: bookings, + VehiclesMap: vehiclesMap, + GroupsMap: groupsMap, + }, nil +} + +func (h *ApplicationHandler) GetBookingDocument(ctx context.Context, bookingID, document string) (io.Reader, string, error) { + file, info, err := h.filestorage.Get(filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s", bookingID, document)) + if err != nil { + return nil, "", fmt.Errorf("failed to get document: %w", err) + } + + return file, info.ContentType, nil +} + +// Helper method to expose config to web handlers +func (h *ApplicationHandler) GetConfig() interface{} { + return h.config +} diff --git a/handlers/application/wallets.go b/core/application/wallets.go similarity index 78% rename from handlers/application/wallets.go rename to core/application/wallets.go index 98918b2..f7045b4 100644 --- a/handlers/application/wallets.go +++ b/core/application/wallets.go @@ -2,52 +2,14 @@ package application import ( "context" - "net/http" - "strconv" "time" "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "github.com/gorilla/mux" "github.com/rs/zerolog/log" ) -func (h ApplicationHandler) CreditWallet(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - userid := vars["userid"] - - if r.Method != "POST" { - w.WriteHeader(http.StatusMethodNotAllowed) - return - } - - r.ParseForm() - - amountStr := r.FormValue("amount") - paymentMethod := r.FormValue("payment_method") - description := r.FormValue("description") - - amount, err := strconv.ParseFloat(amountStr, 64) - if err != nil { - log.Error().Err(err).Msg("could not read amount") - w.WriteHeader(http.StatusBadRequest) - return - } - - if paymentMethod == "" { - paymentMethod = "Paiement en espèce (MMS)" - } - - if err := h.creditWallet(userid, amount, paymentMethod, description); err != nil { - log.Error().Err(err).Msg("could not credit wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, r.Referer(), http.StatusFound) -} - -func (h *ApplicationHandler) creditWallet(userid string, amount float64, paymentMethod string, description string) error { +func (h *ApplicationHandler) CreditWallet(ctx context.Context, userid string, amount float64, paymentMethod string, description string) error { account, err := h.services.GetAccount(userid) if err != nil { log.Error().Err(err).Msg("could not retrieve account") @@ -112,7 +74,7 @@ func (h *ApplicationHandler) creditWallet(userid string, amount float64, payment return err } - _, err = h.services.GRPC.MobilityAccounts.UpdateData(context.Background(), &grpcapi.UpdateDataRequest{ + _, err = h.services.GRPC.MobilityAccounts.UpdateData(ctx, &grpcapi.UpdateDataRequest{ Account: accountproto, }) if err != nil { diff --git a/core/utils/cache/cache.go b/core/utils/cache/cache.go new file mode 100644 index 0000000..7922254 --- /dev/null +++ b/core/utils/cache/cache.go @@ -0,0 +1,74 @@ +package cache + +import ( + "encoding/json" + "strconv" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + "github.com/rs/zerolog/log" +) + +type CacheService struct { + cache storage.CacheHandler +} + +func NewCacheService(cache storage.CacheHandler) *CacheService { + return &CacheService{cache: cache} +} + +type GetCacheResult struct { + Data []byte +} + +func (s *CacheService) GetCacheData(cacheID string, limitsMin, limitsMax *int) (*GetCacheResult, error) { + d, err := s.cache.Get(cacheID) + if err != nil { + log.Error().Err(err).Msg("") + return nil, err + } + + var data []any + if val, ok := d.([]any); ok { + data = val + } else { + data = []any{d} + } + + result := data + if limitsMin != nil { + min := *limitsMin + if limitsMax != nil { + max := *limitsMax + if max > len(data) { + result = data[min:] + } else { + result = data[min:max] + } + } else { + result = data[min:] + } + } + + j, err := json.Marshal(result) + if err != nil { + return nil, err + } + + return &GetCacheResult{ + Data: j, + }, nil +} + +func ParseLimits(limitsMinStr, limitsMaxStr string) (limitsMin, limitsMax *int) { + if limitsMinStr != "" { + if min, err := strconv.Atoi(limitsMinStr); err == nil { + limitsMin = &min + } + } + if limitsMaxStr != "" { + if max, err := strconv.Atoi(limitsMaxStr); err == nil { + limitsMax = &max + } + } + return +} \ No newline at end of file diff --git a/utils/form-validators/form-validators.go b/core/utils/form-validators/form-validators.go similarity index 100% rename from utils/form-validators/form-validators.go rename to core/utils/form-validators/form-validators.go diff --git a/utils/form-validators/phone-numbers.go b/core/utils/form-validators/phone-numbers.go similarity index 100% rename from utils/form-validators/phone-numbers.go rename to core/utils/form-validators/phone-numbers.go diff --git a/core/utils/gender/gender.go b/core/utils/gender/gender.go new file mode 100644 index 0000000..202d9f4 --- /dev/null +++ b/core/utils/gender/gender.go @@ -0,0 +1,17 @@ +package gender + +// ISO5218ToString converts ISO 5218 gender codes to French text labels +func ISO5218ToString(value string) string { + switch value { + case "0": + return "Inconnu" + case "1": + return "Masculin" + case "2": + return "Féminin" + case "9": + return "Sans objet" + default: + return value + } +} diff --git a/core/utils/geo/geo.go b/core/utils/geo/geo.go new file mode 100644 index 0000000..eff43e5 --- /dev/null +++ b/core/utils/geo/geo.go @@ -0,0 +1,50 @@ +package geo + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + + "github.com/rs/zerolog/log" +) + +type GeoService struct { + peliasURL string +} + +func NewGeoService(peliasURL string) *GeoService { + return &GeoService{peliasURL: peliasURL} +} + +type AutocompleteResult struct { + Features []any +} + +func (s *GeoService) Autocomplete(text string) (*AutocompleteResult, error) { + resp, err := http.Get(fmt.Sprintf("%s/autocomplete?text=%s", s.peliasURL, text)) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + log.Error().Err(err).Msg("Failed to read response body") + return nil, err + } + + var response map[string]any + if err := json.Unmarshal(body, &response); err != nil { + return nil, err + } + + features, ok := response["features"].([]any) + if !ok { + features = []any{} + } + + return &AutocompleteResult{ + Features: features, + }, nil +} \ No newline at end of file diff --git a/utils/icons/svg-icons.go b/core/utils/icons/svg-icons.go similarity index 100% rename from utils/icons/svg-icons.go rename to core/utils/icons/svg-icons.go diff --git a/utils/identification/groups.go b/core/utils/identification/groups.go similarity index 100% rename from utils/identification/groups.go rename to core/utils/identification/groups.go diff --git a/utils/identification/oidc.go b/core/utils/identification/oidc.go similarity index 98% rename from utils/identification/oidc.go rename to core/utils/identification/oidc.go index 33470dc..8d2be67 100755 --- a/utils/identification/oidc.go +++ b/core/utils/identification/oidc.go @@ -8,7 +8,7 @@ import ( "net/http" "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" "github.com/coreos/go-oidc/v3/oidc" "github.com/gorilla/sessions" "github.com/rs/zerolog/log" diff --git a/utils/profile-pictures/profile-pictures.go b/core/utils/profile-pictures/profile-pictures.go similarity index 100% rename from utils/profile-pictures/profile-pictures.go rename to core/utils/profile-pictures/profile-pictures.go diff --git a/utils/sorting/beneficiaries.go b/core/utils/sorting/beneficiaries.go similarity index 100% rename from utils/sorting/beneficiaries.go rename to core/utils/sorting/beneficiaries.go diff --git a/utils/sorting/events.go b/core/utils/sorting/events.go similarity index 100% rename from utils/sorting/events.go rename to core/utils/sorting/events.go diff --git a/utils/sorting/fleets.go b/core/utils/sorting/fleets.go similarity index 100% rename from utils/sorting/fleets.go rename to core/utils/sorting/fleets.go diff --git a/utils/sorting/groups.go b/core/utils/sorting/groups.go similarity index 100% rename from utils/sorting/groups.go rename to core/utils/sorting/groups.go diff --git a/utils/sorting/solidarity-transport.go b/core/utils/sorting/solidarity-transport.go similarity index 100% rename from utils/sorting/solidarity-transport.go rename to core/utils/sorting/solidarity-transport.go diff --git a/utils/sorting/sorting.go b/core/utils/sorting/sorting.go similarity index 100% rename from utils/sorting/sorting.go rename to core/utils/sorting/sorting.go diff --git a/utils/storage/badger.go b/core/utils/storage/badger.go similarity index 100% rename from utils/storage/badger.go rename to core/utils/storage/badger.go diff --git a/utils/storage/cache.go b/core/utils/storage/cache.go similarity index 100% rename from utils/storage/cache.go rename to core/utils/storage/cache.go diff --git a/utils/storage/etcd.go b/core/utils/storage/etcd.go similarity index 100% rename from utils/storage/etcd.go rename to core/utils/storage/etcd.go diff --git a/utils/storage/files.go b/core/utils/storage/files.go similarity index 94% rename from utils/storage/files.go rename to core/utils/storage/files.go index a4e12f7..b43f87f 100755 --- a/utils/storage/files.go +++ b/core/utils/storage/files.go @@ -13,7 +13,6 @@ const ( PREFIX_ORGANIZED_CARPOOL_DRIVERS = "organized_carpool/drivers" PREFIX_BOOKINGS = "fleets_bookings" PREFIX_AGENDA = "event_files" - PREFIX_DIAGS = "diags" ) type FileInfo struct { @@ -29,6 +28,7 @@ type FileStorage interface { List(prefix string) []FileInfo Get(prefix string, file string) (io.Reader, *FileInfo, error) Copy(src string, dest string) error + Delete(prefix string, file string) error } func NewFileStorage(cfg *viper.Viper) (FileStorage, error) { diff --git a/utils/storage/kv.go b/core/utils/storage/kv.go similarity index 100% rename from utils/storage/kv.go rename to core/utils/storage/kv.go diff --git a/utils/storage/minio.go b/core/utils/storage/minio.go similarity index 91% rename from utils/storage/minio.go rename to core/utils/storage/minio.go index 7dd09e0..79322c6 100755 --- a/utils/storage/minio.go +++ b/core/utils/storage/minio.go @@ -122,3 +122,12 @@ func (s *MinioStorageHandler) Copy(src string, dst string) error { } return nil } + +func (s *MinioStorageHandler) Delete(prefix string, file string) error { + err := s.Client.RemoveObject(context.Background(), s.BucketName, prefix+"/"+file, minio.RemoveObjectOptions{}) + if err != nil { + log.Error().Err(err).Msg("Error deleting file from storage") + return err + } + return nil +} diff --git a/utils/storage/sessions.go b/core/utils/storage/sessions.go similarity index 100% rename from utils/storage/sessions.go rename to core/utils/storage/sessions.go diff --git a/utils/validated-profile/validated-profile.go b/core/utils/validated-profile/validated-profile.go similarity index 97% rename from utils/validated-profile/validated-profile.go rename to core/utils/validated-profile/validated-profile.go index ef18a94..f04df87 100644 --- a/utils/validated-profile/validated-profile.go +++ b/core/utils/validated-profile/validated-profile.go @@ -5,7 +5,7 @@ import ( "slices" "time" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" "github.com/go-viper/mapstructure/v2" "github.com/rs/zerolog/log" diff --git a/go.mod b/go.mod index 349acc1..1bf7780 100755 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module git.coopgo.io/coopgo-apps/parcoursmob -go 1.24.2 +go 1.24.6 // replace git.coopgo.io/coopgo-platform/mobility-accounts => ../../coopgo-platform/mobility-accounts/ @@ -16,6 +16,8 @@ go 1.24.2 // replace git.coopgo.io/coopgo-platform/solidarity-transport => ../../coopgo-platform/solidarity-transport/ +// replace git.coopgo.io/coopgo-platform/saved-search => ../../coopgo-platform/saved-search/ + // replace git.coopgo.io/coopgo-platform/carpool-service => ../../coopgo-platform/carpool-service/ // replace git.coopgo.io/coopgo-platform/multimodal-routing => ../../coopgo-platform/multimodal-routing/ @@ -33,41 +35,42 @@ require ( github.com/gorilla/mux v1.8.0 github.com/gorilla/sessions v1.2.1 github.com/paulmach/go.geojson v1.4.0 // indirect - github.com/spf13/viper v1.20.1 + github.com/spf13/viper v1.21.0 gitlab.scity.coop/maas/navitia-golang v0.0.0-20220429110621-5c22d6efdd0c go.etcd.io/etcd/client/v3 v3.5.12 - golang.org/x/image v0.5.0 + golang.org/x/image v0.25.0 golang.org/x/oauth2 v0.30.0 - google.golang.org/grpc v1.75.1 - google.golang.org/protobuf v1.36.6 + google.golang.org/grpc v1.76.0 + google.golang.org/protobuf v1.36.10 ) require ( git.coopgo.io/coopgo-platform/agenda v1.0.0 - git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20250925043614-b7ac71741f43 + git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20251008165122-38cb3c5ad9b4 git.coopgo.io/coopgo-platform/emailing v0.0.0-20250212064257-167ef5864260 - git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e - git.coopgo.io/coopgo-platform/geography v0.0.0-20250616160304-0285c9494673 + git.coopgo.io/coopgo-platform/fleets v1.1.0 + git.coopgo.io/coopgo-platform/geography v0.0.0-20251010131258-ec939649e858 git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386 - git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20250925053957-63fc3e7c834f - git.coopgo.io/coopgo-platform/payments v0.0.0-20250616162131-77f7b00b8fc3 + git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251013140400-42fb40437ac3 + git.coopgo.io/coopgo-platform/payments v0.0.0-20251013175712-75d0288d2d4f git.coopgo.io/coopgo-platform/routing-service v0.0.0-20250304234521-faabcc54f536 + git.coopgo.io/coopgo-platform/saved-search v0.0.0-20251008070953-efccea3f6463 git.coopgo.io/coopgo-platform/sms v0.0.0-20250523074631-1f1e7fc6b7af - git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20250910141021-fc5b33e88c2c + git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20251008070137-723c12a6573d github.com/arran4/golang-ical v0.3.1 github.com/coreos/go-oidc/v3 v3.11.0 - github.com/go-viper/mapstructure/v2 v2.2.1 + github.com/go-viper/mapstructure/v2 v2.4.0 github.com/gorilla/securecookie v1.1.1 github.com/minio/minio-go/v7 v7.0.43 - github.com/paulmach/orb v0.11.1 + github.com/paulmach/orb v0.12.0 github.com/rs/zerolog v1.34.0 - github.com/stretchr/objx v0.5.2 - github.com/xuri/excelize/v2 v2.7.1 + github.com/stretchr/objx v0.5.3 + github.com/xuri/excelize/v2 v2.9.1 ) require ( - git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20250429082239-a95cd6eb5523 // indirect + git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20251008142525-4392f227836a // indirect github.com/RoaringBitmap/roaring/v2 v2.4.5 // indirect github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect github.com/bits-and-blooms/bitset v1.22.0 // indirect @@ -93,27 +96,27 @@ require ( github.com/gabriel-vasile/mimetype v1.4.2 // indirect github.com/gorilla/schema v1.4.1 // indirect github.com/mschoch/smat v0.2.0 // indirect - github.com/sagikazarmark/locafero v0.9.0 // indirect - github.com/sourcegraph/conc v0.3.0 // indirect + github.com/sagikazarmark/locafero v0.12.0 // indirect github.com/tidwall/geoindex v1.7.0 // indirect github.com/tidwall/rtree v1.10.0 // indirect github.com/twpayne/go-polyline v1.1.1 // indirect github.com/zclconf/go-cty-yaml v1.1.0 // indirect go.etcd.io/bbolt v1.4.0 // indirect - golang.org/x/mod v0.25.0 // indirect - golang.org/x/tools v0.33.0 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect + golang.org/x/mod v0.28.0 // indirect + golang.org/x/tools v0.37.0 // indirect ) require ( - ariga.io/atlas v0.32.0 // indirect - git.coopgo.io/coopgo-platform/diags v0.0.0-20250212093351-64da61495c9d + ariga.io/atlas v0.37.0 // indirect + github.com/AlexJarrah/go-ods v1.0.7 // indirect github.com/agext/levenshtein v1.2.3 // indirect github.com/coreos/go-semver v0.3.0 // indirect github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/dustin/go-humanize v1.0.0 // indirect github.com/fsnotify/fsnotify v1.9.0 // indirect - github.com/go-jose/go-jose/v4 v4.1.1 // indirect - github.com/go-openapi/inflect v0.21.2 // indirect + github.com/go-jose/go-jose/v4 v4.1.2 // indirect + github.com/go-openapi/inflect v0.21.3 // indirect github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect @@ -121,7 +124,7 @@ require ( github.com/golang/protobuf v1.5.4 // indirect github.com/golang/snappy v1.0.0 // indirect github.com/google/go-cmp v0.7.0 // indirect - github.com/hashicorp/hcl/v2 v2.23.0 // indirect + github.com/hashicorp/hcl/v2 v2.24.0 // indirect github.com/json-iterator/go v1.1.12 // indirect github.com/klauspost/compress v1.18.0 // indirect github.com/klauspost/cpuid/v2 v2.2.5 // indirect @@ -140,35 +143,36 @@ require ( github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/richardlehane/mscfb v1.0.4 // indirect - github.com/richardlehane/msoleps v1.0.3 // indirect + github.com/richardlehane/msoleps v1.0.4 // indirect github.com/rs/xid v1.6.0 // indirect github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect github.com/sirupsen/logrus v1.9.3 // indirect - github.com/spf13/afero v1.14.0 // indirect - github.com/spf13/cast v1.7.1 // indirect - github.com/spf13/pflag v1.0.6 // indirect + github.com/spf13/afero v1.15.0 // indirect + github.com/spf13/cast v1.10.0 // indirect + github.com/spf13/pflag v1.0.10 // indirect github.com/subosito/gotenv v1.6.0 // indirect + github.com/tiendc/go-deepcopy v1.7.1 // indirect github.com/twpayne/go-geom v1.5.7 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect - github.com/xuri/efp v0.0.0-20220603152613-6918739fd470 // indirect - github.com/xuri/nfp v0.0.0-20220409054826-5e722a1d9e22 // indirect + github.com/xuri/efp v0.0.1 // indirect + github.com/xuri/nfp v0.0.1 // indirect github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect - github.com/zclconf/go-cty v1.16.2 // indirect + github.com/zclconf/go-cty v1.17.0 // indirect go.etcd.io/etcd/api/v3 v3.5.12 // indirect go.etcd.io/etcd/client/pkg/v3 v3.5.12 // indirect - go.mongodb.org/mongo-driver v1.17.3 // indirect + go.mongodb.org/mongo-driver v1.17.4 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.21.0 // indirect - golang.org/x/crypto v0.39.0 // indirect - golang.org/x/net v0.41.0 // indirect - golang.org/x/sync v0.15.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.26.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20250707201910-8d1bb00bc6a7 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 // indirect + golang.org/x/crypto v0.43.0 // indirect + golang.org/x/net v0.46.0 // indirect + golang.org/x/sync v0.17.0 // indirect + golang.org/x/sys v0.37.0 // indirect + golang.org/x/text v0.30.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20250804133106-a7a43d27e69b // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20251007200510-49b9836ed3ff // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect diff --git a/go.sum b/go.sum index 49b9067..5e361aa 100644 --- a/go.sum +++ b/go.sum @@ -1,33 +1,43 @@ -ariga.io/atlas v0.32.0 h1:y+77nueMrExLiKlz1CcPKh/nU7VSlWfBbwCShsJyvCw= -ariga.io/atlas v0.32.0/go.mod h1:Oe1xWPuu5q9LzyrWfbZmEZxFYeu4BHTyzfjeW2aZp/w= +ariga.io/atlas v0.37.0 h1:MvbQ25CAHFslttEKEySwYNFrFUdLAPhtU1izOzjXV+o= +ariga.io/atlas v0.37.0/go.mod h1:mHE83ptCxEkd3rO3c7Rvkk6Djf6mVhEiSVhoiNu96CI= git.coopgo.io/coopgo-platform/agenda v1.0.0 h1:rTHgva1JKKO0wAPlINegifMkHm+xOg3IWW4yQRy334w= git.coopgo.io/coopgo-platform/agenda v1.0.0/go.mod h1:/hToSla0p6SeWn1zo1MDrfxdmo7RBdZDkbLqCVituIM= -git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20250925043614-b7ac71741f43 h1:6gFe8+7tiAiUie7qCl4UaLv5QyUUtJvt23ju1Wa6Xg0= -git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20250925043614-b7ac71741f43/go.mod h1:J0vTvTd+NJ3dKcJ28Ca2xV7OMuglpJ9i4KPRb2SJqew= -git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20250429082239-a95cd6eb5523 h1:hXoUOEZ+umiyR0SzYbGacJxiUbW4puw4phmkfTVfqPU= -git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20250429082239-a95cd6eb5523/go.mod h1:c9aJwNtY4PJuqAFYZ9afnx46UAZtWJ3P8ICZM02/DBA= -git.coopgo.io/coopgo-platform/diags v0.0.0-20250212093351-64da61495c9d h1:fBxVvik4Cb/6d4+HAXZi9e8x8P9UBCJt8JcWgqnNjsE= -git.coopgo.io/coopgo-platform/diags v0.0.0-20250212093351-64da61495c9d/go.mod h1:diyq11WNkgJ0kYHdT7SphXPMQUyoq4lRk7T6IgM5yPA= +git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20251008165122-38cb3c5ad9b4 h1:L3HJnjQo5M0maOKkILAIq257tbHHCsr6OpAWGVQoGJs= +git.coopgo.io/coopgo-platform/carpool-service v0.0.0-20251008165122-38cb3c5ad9b4/go.mod h1:4qy6Ha8/cA3L+hZyzPYbKJ0dFO+zyDh8W7bMXDXE6WQ= +git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20251008142525-4392f227836a h1:roBn3oQRQ/j5JBAP01wIs1UQvtm3tjui+D4EAa/Hfa4= +git.coopgo.io/coopgo-platform/carpool-service/interoperability/ocss v0.0.0-20251008142525-4392f227836a/go.mod h1:c9aJwNtY4PJuqAFYZ9afnx46UAZtWJ3P8ICZM02/DBA= git.coopgo.io/coopgo-platform/emailing v0.0.0-20250212064257-167ef5864260 h1:Li3dotY6raKu9+oxEgICU7nwdomYpjgu19i3mZNiqTc= git.coopgo.io/coopgo-platform/emailing v0.0.0-20250212064257-167ef5864260/go.mod h1:6cvvjv0RLSwBthIQ4TiuZoXFGvQXZ55hNSJchWXAgB4= -git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e h1:eHahRTKlC8aBWYCd6LbXNcX8HoQhuZj31OFWrw0EL0U= -git.coopgo.io/coopgo-platform/fleets v0.0.0-20230310144446-feb935f8bf4e/go.mod h1:s9OIFCNcjBAbBzRNHwoCTYV6kAntPG9CpT3GVweGdTY= +git.coopgo.io/coopgo-platform/fleets v1.1.0 h1:pfW/K3fWfap54yNfkLzBXjvOjjoTaEGFEqS/+VkHv7s= +git.coopgo.io/coopgo-platform/fleets v1.1.0/go.mod h1:nuK2mi1M2+DdntinqK/8C4ttW4WWyKCCY/xD1D7XjkE= git.coopgo.io/coopgo-platform/geography v0.0.0-20250616160304-0285c9494673 h1:cth7a8Mnx1C6C6F5rv7SoKVMHYpI/CioFubyi0xB+Dw= git.coopgo.io/coopgo-platform/geography v0.0.0-20250616160304-0285c9494673/go.mod h1:TbR3g1Awa8hpAe6LR1z1EQbv2IBVgN5JQ/FjXfKX4K0= +git.coopgo.io/coopgo-platform/geography v0.0.0-20251010131258-ec939649e858 h1:4E0tbT8jj5oxaK66Ny61o7zqPaVc0qRN2cZG9IUR4Es= +git.coopgo.io/coopgo-platform/geography v0.0.0-20251010131258-ec939649e858/go.mod h1:TbR3g1Awa8hpAe6LR1z1EQbv2IBVgN5JQ/FjXfKX4K0= git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c h1:bY7PyrAgYY02f5IpDyf1WVfRqvWzivu31K6aEAYbWCw= git.coopgo.io/coopgo-platform/groups-management v0.0.0-20230310123255-5ef94ee0746c/go.mod h1:lozSy6qlIIYhvKKXscZzz28HAtS0qBDUTv5nofLRmYA= git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386 h1:v1JUdx8sknw2YYhFGz5cOAa1dEWNIBKvyiOpKr3RR+s= git.coopgo.io/coopgo-platform/mobility-accounts v0.0.0-20230329105908-a76c0412a386/go.mod h1:1typNYtO+PQT6KG77vs/PUv0fO60/nbeSGZL2tt1LLg= -git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20250925053957-63fc3e7c834f h1:uePG+xhXdFiOhSyoNjJ3ZElwe/cWRm/++6iUHseY3Q8= -git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20250925053957-63fc3e7c834f/go.mod h1:zDMfGVIvzuWV4Cw4bSi2kuEyMDbAfNfs7cGOAWNKfOo= -git.coopgo.io/coopgo-platform/payments v0.0.0-20250616162131-77f7b00b8fc3 h1:HGEo2E4IyprzshGKKeK7xMmorLNIGF8vbxa3zkBa+KM= -git.coopgo.io/coopgo-platform/payments v0.0.0-20250616162131-77f7b00b8fc3/go.mod h1:X2WqQN7ZLAucV9z1gPubkWChkHbmdOIxWdwn18DZ+YU= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251010131127-a2c82a1a5c8e h1:c0iCczcVxDbzbaQY04zzFpMXgHTRGcYOJ8LqYk9UYuo= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251010131127-a2c82a1a5c8e/go.mod h1:npYccQZcZj1WzTHhpLfFHFSBA3RiZOkO5R9x4uy1a9I= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251013125457-ab53f677d9cb h1:NotnSudZYn4cLAXJvtYor1XLkS5HXXNEPNgHy0Hw3Qs= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251013125457-ab53f677d9cb/go.mod h1:npYccQZcZj1WzTHhpLfFHFSBA3RiZOkO5R9x4uy1a9I= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251013140400-42fb40437ac3 h1:jo7fF7tLIAU110tUSIYXkMAvu30g8wHzZCLq3YomooQ= +git.coopgo.io/coopgo-platform/multimodal-routing v0.0.0-20251013140400-42fb40437ac3/go.mod h1:npYccQZcZj1WzTHhpLfFHFSBA3RiZOkO5R9x4uy1a9I= +git.coopgo.io/coopgo-platform/payments v0.0.0-20251008125601-e36cd6e557da h1:5D2B1WkRolbXFUHsqPHnYtTeweSZ+iCHlx6S2KKxmxQ= +git.coopgo.io/coopgo-platform/payments v0.0.0-20251008125601-e36cd6e557da/go.mod h1:gSAH2Tr9x8K8QC0vsUMwSWLrQOlsG+v64ACrjYw4BL0= +git.coopgo.io/coopgo-platform/payments v0.0.0-20251013175712-75d0288d2d4f h1:B/+AP+rLFx8AojO2bKV3R93kMU84g8Dhy7DNVoT8xCY= +git.coopgo.io/coopgo-platform/payments v0.0.0-20251013175712-75d0288d2d4f/go.mod h1:gSAH2Tr9x8K8QC0vsUMwSWLrQOlsG+v64ACrjYw4BL0= git.coopgo.io/coopgo-platform/routing-service v0.0.0-20250304234521-faabcc54f536 h1:SllXX1VJXulfhNi+Pd0R9chksm8zO6gkWcTQ/uSMsdc= git.coopgo.io/coopgo-platform/routing-service v0.0.0-20250304234521-faabcc54f536/go.mod h1:Nh7o15LlV0OuO9zxvJIs9FlelpeAaLYkXtFdgIkFrgg= +git.coopgo.io/coopgo-platform/saved-search v0.0.0-20251008070953-efccea3f6463 h1:TjjqFEkRLDqy300pGOLIhsVYBpE0J640pFW9//OknzA= +git.coopgo.io/coopgo-platform/saved-search v0.0.0-20251008070953-efccea3f6463/go.mod h1:0fuGuYub5CBy9NB6YMqxawE0HoBaxPb9gmSw1gjfDy0= git.coopgo.io/coopgo-platform/sms v0.0.0-20250523074631-1f1e7fc6b7af h1:KxHim1dFcOVbFhRqelec8cJ65QBD2cma6eytW8llgYY= git.coopgo.io/coopgo-platform/sms v0.0.0-20250523074631-1f1e7fc6b7af/go.mod h1:mad9D+WICDdpJzB+8H/wEVVbllK2mU6VLVByrppc9x0= -git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20250910141021-fc5b33e88c2c h1:U7EgF5Asj6a65nNXo6m4luR27CL5nDfxhY6GFWX46uU= -git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20250910141021-fc5b33e88c2c/go.mod h1:jnSYIECcH/nL8bLBwYD2WmJSPgWUC2rioOXxivWBTBM= +git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20251008070137-723c12a6573d h1:eBzRP50PXlXlLhgZjFhjTuoxIuQ3N/+5A6RIZyZEMAs= +git.coopgo.io/coopgo-platform/solidarity-transport v0.0.0-20251008070137-723c12a6573d/go.mod h1:iaFXcIn7DYtKlLrSYs9C47Dt7eeMGYkpx+unLCx8TpQ= +github.com/AlexJarrah/go-ods v1.0.7 h1:QxhYKncbsgf59BNNOcc4XB7wxKvOrSwtC0fpf6/gtsM= +github.com/AlexJarrah/go-ods v1.0.7/go.mod h1:tifLS6QTLIRhFV4zSjZ59700fZOGeqqQD8KBBOb/F3w= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= github.com/DATA-DOG/go-sqlmock v1.3.2/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= @@ -120,14 +130,14 @@ github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU= github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA= -github.com/go-jose/go-jose/v4 v4.1.1 h1:JYhSgy4mXXzAdF3nUx3ygx347LRXJRrpgyU3adRmkAI= -github.com/go-jose/go-jose/v4 v4.1.1/go.mod h1:BdsZGqgdO3b6tTc6LSE56wcDbMMLuPsw5d4ZD5f94kA= +github.com/go-jose/go-jose/v4 v4.1.2 h1:TK/7NqRQZfgAh+Td8AlsrvtPoUyiHh0LqVvokh+1vHI= +github.com/go-jose/go-jose/v4 v4.1.2/go.mod h1:22cg9HWM1pOlnRiY+9cQYJ9XHmya1bYW8OeDM6Ku6Oo= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-openapi/inflect v0.21.2 h1:0gClGlGcxifcJR56zwvhaOulnNgnhc4qTAkob5ObnSM= -github.com/go-openapi/inflect v0.21.2/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= +github.com/go-openapi/inflect v0.21.3 h1:TmQvw+9eLrsNp4X0BBQacEZZtAnzk2z1FaLdQQJsDiU= +github.com/go-openapi/inflect v0.21.3/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= @@ -138,8 +148,8 @@ github.com/go-playground/validator/v10 v10.14.1 h1:9c50NUPC30zyuKprjL3vNZ0m5oG+j github.com/go-playground/validator/v10 v10.14.1/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU= github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68= github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA= -github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss= -github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= @@ -170,8 +180,8 @@ github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+ github.com/gorilla/sessions v1.2.1 h1:DHd3rPN5lE3Ts3D8rKkQ8x/0kqfeNmBAaiSi+o7FsgI= github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM= github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY= -github.com/hashicorp/hcl/v2 v2.23.0 h1:Fphj1/gCylPxHutVSEOf2fBOh1VE4AuLV7+kbJf3qos= -github.com/hashicorp/hcl/v2 v2.23.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= +github.com/hashicorp/hcl/v2 v2.24.0 h1:2QJdZ454DSsYGoaE6QheQZjtKZSUs9Nh2izTWiwQxvE= +github.com/hashicorp/hcl/v2 v2.24.0/go.mod h1:oGoO1FIQYfn/AgyOhlg9qLC6/nOJPX3qGbkZpYAcqfM= github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= github.com/huandu/xstrings v1.3.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= @@ -242,8 +252,8 @@ github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59P github.com/ory/dockertest v3.3.4+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs= github.com/paulmach/go.geojson v1.4.0 h1:5x5moCkCtDo5x8af62P9IOAYGQcYHtxz2QJ3x1DoCgY= github.com/paulmach/go.geojson v1.4.0/go.mod h1:YaKx1hKpWF+T2oj2lFJPsW/t1Q5e1jQI61eoQSTwpIs= -github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU= -github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU= +github.com/paulmach/orb v0.12.0 h1:z+zOwjmG3MyEEqzv92UN49Lg1JFYx0L9GpGKNVDKk1s= +github.com/paulmach/orb v0.12.0/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU= github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= @@ -258,36 +268,36 @@ github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7 github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg= github.com/richardlehane/msoleps v1.0.3 h1:aznSZzrwYRl3rLKRT3gUk9am7T/mLNSnJINvN0AQoVM= github.com/richardlehane/msoleps v1.0.3/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg= +github.com/richardlehane/msoleps v1.0.4 h1:WuESlvhX3gH2IHcd8UqyCuFY5yiq/GR/yqaSM/9/g00= +github.com/richardlehane/msoleps v1.0.4/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY= github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ= -github.com/sagikazarmark/locafero v0.9.0 h1:GbgQGNtTrEmddYDSAH9QLRyfAHY12md+8YFTqyMTC9k= -github.com/sagikazarmark/locafero v0.9.0/go.mod h1:UBUyz37V+EdMS3hDF3QWIiVr/2dPrx49OMO0Bn0hJqk= +github.com/sagikazarmark/locafero v0.12.0 h1:/NQhBAkUb4+fH1jivKHWusDYFjMOOKU88eegjfxfHb4= +github.com/sagikazarmark/locafero v0.12.0/go.mod h1:sZh36u/YSZ918v0Io+U9ogLYQJ9tLLBmM4eneO6WwsI= github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 h1:TToq11gyfNlrMFZiYujSekIsPd9AmsA2Bj/iv+s4JHE= github.com/santhosh-tekuri/jsonschema/v5 v5.0.0/go.mod h1:FKdcjfQW6rpZSnxxUvEA5H/cDPdvJ/SZJQLWWXWGrZ0= github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= -github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= -github.com/spf13/afero v1.14.0 h1:9tH6MapGnn/j0eb0yIXiLjERO8RB6xIVZRDCX7PtqWA= -github.com/spf13/afero v1.14.0/go.mod h1:acJQ8t0ohCGuMN3O+Pv0V0hgMxNYDlvdk+VTfyZmbYo= -github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y= -github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= -github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= -github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.20.1 h1:ZMi+z/lvLyPSCoNtFCpqjy0S4kPbirhpTMwl8BkW9X4= -github.com/spf13/viper v1.20.1/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4= +github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I= +github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= +github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= +github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= +github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= +github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU= +github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= @@ -296,8 +306,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= github.com/tidwall/cities v0.1.0 h1:CVNkmMf7NEC9Bvokf5GoSsArHCKRMTgLuubRTHnH0mE= @@ -309,6 +319,8 @@ github.com/tidwall/lotsa v1.0.2/go.mod h1:X6NiU+4yHA3fE3Puvpnn1XMDrFZrE9JO2/w+UM github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= github.com/tidwall/rtree v1.10.0 h1:+EcI8fboEaW1L3/9oW/6AMoQ8HiEIHyR7bQOGnmz4Mg= github.com/tidwall/rtree v1.10.0/go.mod h1:iDJQ9NBRtbfKkzZu02za+mIlaP+bjYPnunbSNidpbCQ= +github.com/tiendc/go-deepcopy v1.7.1 h1:LnubftI6nYaaMOcaz0LphzwraqN8jiWTwm416sitff4= +github.com/tiendc/go-deepcopy v1.7.1/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ= github.com/twpayne/go-geom v1.2.1/go.mod h1:90yvs0wf/gyT5eQ9W4v5WOZ9w/Xnrj5RMlA9XNKqxyA= github.com/twpayne/go-geom v1.5.7 h1:7fdceDUr03/MP7rAKOaTV6x9njMiQdxB/D0PDzMTCDc= github.com/twpayne/go-geom v1.5.7/go.mod h1:y4fTAQtLedXW8eG2Yo4tYrIGN1yIwwKkmA+K3iSHKBA= @@ -326,10 +338,16 @@ github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6 github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM= github.com/xuri/efp v0.0.0-20220603152613-6918739fd470 h1:6932x8ltq1w4utjmfMPVj09jdMlkY0aiA6+Skbtl3/c= github.com/xuri/efp v0.0.0-20220603152613-6918739fd470/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI= +github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8= +github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI= github.com/xuri/excelize/v2 v2.7.1 h1:gm8q0UCAyaTt3MEF5wWMjVdmthm2EHAWesGSKS9tdVI= github.com/xuri/excelize/v2 v2.7.1/go.mod h1:qc0+2j4TvAUrBw36ATtcTeC1VCM0fFdAXZOmcF4nTpY= +github.com/xuri/excelize/v2 v2.9.1 h1:VdSGk+rraGmgLHGFaGG9/9IWu1nj4ufjJ7uwMDtj8Qw= +github.com/xuri/excelize/v2 v2.9.1/go.mod h1:x7L6pKz2dvo9ejrRuD8Lnl98z4JLt0TGAwjhW+EiP8s= github.com/xuri/nfp v0.0.0-20220409054826-5e722a1d9e22 h1:OAmKAfT06//esDdpi/DZ8Qsdt4+M5+ltca05dA5bG2M= github.com/xuri/nfp v0.0.0-20220409054826-5e722a1d9e22/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ= +github.com/xuri/nfp v0.0.1 h1:MDamSGatIvp8uOmDP8FnmjuQpu90NzdJxo7242ANR9Q= +github.com/xuri/nfp v0.0.1/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ= github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI= @@ -337,8 +355,8 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/zclconf/go-cty v1.16.2 h1:LAJSwc3v81IRBZyUVQDUdZ7hs3SYs9jv0eZJDWHD/70= -github.com/zclconf/go-cty v1.16.2/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE= +github.com/zclconf/go-cty v1.17.0 h1:seZvECve6XX4tmnvRzWtJNHdscMtYEx5R7bnnVyd/d0= +github.com/zclconf/go-cty v1.17.0/go.mod h1:wqFzcImaLTI6A5HfsRwB0nj5n0MRZFwmey8YoFPPs3U= github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo= github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM= github.com/zclconf/go-cty-yaml v1.1.0 h1:nP+jp0qPHv2IhUVqmQSzjvqAWcObN0KBkUl2rWBdig0= @@ -354,8 +372,8 @@ go.etcd.io/etcd/client/pkg/v3 v3.5.12/go.mod h1:seTzl2d9APP8R5Y2hFL3NVlD6qC/dOT+ go.etcd.io/etcd/client/v3 v3.5.12 h1:v5lCPXn1pf1Uu3M4laUE2hp/geOTc5uPcYYsNe1lDxg= go.etcd.io/etcd/client/v3 v3.5.12/go.mod h1:tSbBCakoWmmddL+BKVAJHa9km+O/E+bumDe9mSbPiqw= go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g= -go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ= -go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ= +go.mongodb.org/mongo-driver v1.17.4 h1:jUorfmVzljjr0FLzYQsGP8cgN/qzzxlY9Vh0C9KFXVw= +go.mongodb.org/mongo-driver v1.17.4/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ= go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= @@ -378,6 +396,8 @@ go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8= go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -385,18 +405,22 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= -golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= -golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI= +golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8= +golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= +golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= golang.org/x/image v0.5.0 h1:5JMiNunQeQw++mMOz48/ISeNu3Iweh/JaZU8ZLqHRrI= golang.org/x/image v0.5.0/go.mod h1:FVC7BI/5Ym8R25iw5OLsgshdUBbT1h5jZTpA+mvAdZ4= +golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ= +golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= -golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U= +golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -408,8 +432,10 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= -golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw= -golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA= +golang.org/x/net v0.45.0 h1:RLBg5JKixCy82FtLJpeNlVM0nrSqpCRYzVU1n8kj0tM= +golang.org/x/net v0.45.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY= +golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4= +golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210= golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI= golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -418,8 +444,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8= -golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -440,8 +466,8 @@ golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= @@ -454,8 +480,10 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= -golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk= +golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4= +golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k= +golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -464,24 +492,24 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc= -golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI= +golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE= +golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= -google.golang.org/genproto/googleapis/api v0.0.0-20250707201910-8d1bb00bc6a7 h1:FiusG7LWj+4byqhbvmB+Q93B/mOxJLN2DTozDuZm4EU= -google.golang.org/genproto/googleapis/api v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:kXqgZtrWaf6qS3jZOCnCH7WYfrvFjkC51bM8fz3RsCA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 h1:pFyd6EwwL2TqFf8emdthzeX+gZE1ElRq3iM8pui4KBY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= -google.golang.org/grpc v1.75.1 h1:/ODCNEuf9VghjgO3rqLcfg8fiOP0nSluljWFlDxELLI= -google.golang.org/grpc v1.75.1/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ= +google.golang.org/genproto/googleapis/api v0.0.0-20250804133106-a7a43d27e69b h1:ULiyYQ0FdsJhwwZUwbaXpZF5yUE3h+RA+gxvBu37ucc= +google.golang.org/genproto/googleapis/api v0.0.0-20250804133106-a7a43d27e69b/go.mod h1:oDOGiMSXHL4sDTJvFvIB9nRQCGdLP1o/iVaqQK8zB+M= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251007200510-49b9836ed3ff h1:A90eA31Wq6HOMIQlLfzFwzqGKBTuaVztYu/g8sn+8Zc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251007200510-49b9836ed3ff/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= +google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A= +google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= -google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= diff --git a/handlers/api/api.go b/handlers/api/api.go deleted file mode 100755 index 785db34..0000000 --- a/handlers/api/api.go +++ /dev/null @@ -1,30 +0,0 @@ -package api - -import ( - "net/http" - - "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - "github.com/spf13/viper" -) - -type APIHandler struct { - idp *identification.IdentificationProvider - config *viper.Viper - services *services.ServicesHandler - cache cache.CacheHandler -} - -func NewAPIHandler(cfg *viper.Viper, idp *identification.IdentificationProvider, svc *services.ServicesHandler, cache cache.CacheHandler) (*APIHandler, error) { - return &APIHandler{ - idp: idp, - config: cfg, - services: svc, - cache: cache, - }, nil -} - -func (h *APIHandler) NotFound(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusNotFound) -} diff --git a/handlers/api/cache.go b/handlers/api/cache.go deleted file mode 100755 index ee1a2ce..0000000 --- a/handlers/api/cache.go +++ /dev/null @@ -1,70 +0,0 @@ -package api - -import ( - "encoding/json" - "net/http" - "strconv" - - "github.com/rs/zerolog/log" - - "github.com/gorilla/mux" -) - -func (h APIHandler) GetCache(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - cacheid := vars["cacheid"] - // Use a channel to synchronize the goroutines - ch := make(chan []byte) - // Fetch data from cache asynchronously - go func() { - d, err := h.cache.Get(cacheid) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusNotFound) - ch <- nil - return - } - var data []any - if val, ok := d.([]any); ok { - data = val - } else { - data = []any{d} - } - j := toJSON(data, w, r) - ch <- j // Signal that the data has been fetched successfully - close(ch) - }() - // wait for the JSON marshaling goroutine to finish - j := <-ch - if j == nil { - return // Stop processing if an error occurred - } - // Send the JSON response to the client - w.WriteHeader(http.StatusOK) - w.Header().Set("Content-Type", "application/json") - w.Write(j) - - <-ch -} -func toJSON(data []any, w http.ResponseWriter, r *http.Request) []byte { - result := data - if limitsmin, ok := r.URL.Query()["limits.min"]; ok { - min, _ := strconv.Atoi(limitsmin[0]) - if limitsmax, ok := r.URL.Query()["limits.max"]; ok { - max, _ := strconv.Atoi(limitsmax[0]) - if max > len(data) { - result = data[min:] - } else { - result = data[min:max] - } - } else { - result = data[min:] - } - } - j, err := json.Marshal(result) - if err != nil { - w.WriteHeader(http.StatusNotFound) - return nil - } - return j -} diff --git a/handlers/api/calendars.go b/handlers/api/calendars.go deleted file mode 100644 index 715ed34..0000000 --- a/handlers/api/calendars.go +++ /dev/null @@ -1,120 +0,0 @@ -package api - -import ( - "net/http" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/services" - ics "github.com/arran4/golang-ical" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" -) - -func (h *APIHandler) icsCalendar(events []services.AgendaEvent) (*ics.Calendar, error) { - calendar := ics.NewCalendarFor(h.config.GetString("service_name")) - - for _, e := range events { - vevent := ics.NewEvent(e.ID) - vevent.SetSummary(e.Name) - vevent.SetDescription(e.Description) - if e.Allday { - vevent.SetAllDayStartAt(e.Startdate) - if e.Enddate.After(e.Startdate) { - vevent.SetAllDayEndAt(e.Enddate.Add(24 * time.Hour)) - } - } else { - timeloc, err := time.LoadLocation("Europe/Paris") - if err != nil { - log.Error().Err(err).Msg("Tried to load timezone location Europe/Paris. Error. Missing zones in container ?") - return nil, err - } - - starttime, err := time.ParseInLocation("15:04", e.Starttime, timeloc) - if err != nil { - return nil, err - } - startdatetime := time.Date(e.Startdate.Year(), e.Startdate.Month(), e.Startdate.Day(), starttime.Hour(), starttime.Minute(), 0, 0, timeloc) - - endtime, err := time.Parse("15:04", e.Endtime) - if err != nil { - return nil, err - } - enddatetime := time.Date(e.Enddate.Year(), e.Enddate.Month(), e.Enddate.Day(), endtime.Hour(), endtime.Minute(), 0, 0, timeloc) - - vevent.SetStartAt(startdatetime) - vevent.SetEndAt(enddatetime) - } - calendar.AddVEvent(vevent) - } - return calendar, nil -} - -func (h *APIHandler) CalendarGlobal(w http.ResponseWriter, r *http.Request) { - enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.global.enabled") - if !enabled { - log.Error().Msg("global calendar not activated in configuration") - w.WriteHeader(http.StatusForbidden) - return - } - - events, err := h.services.GetAgendaEvents() - if err != nil { - log.Error().Err(err).Msg("error retrieving agenda events") - w.WriteHeader(http.StatusInternalServerError) - return - } - - calendar, err := h.icsCalendar(events) - if err != nil { - log.Error().Err(err).Msg("error while creating ics calendar") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.WriteHeader(http.StatusOK) - w.Header().Set("Content-Type", "text/calendar") - w.Write([]byte(calendar.Serialize())) -} - -func (h *APIHandler) CalendarOrganizations(w http.ResponseWriter, r *http.Request) { - enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.organizations.enabled") - if !enabled { - log.Error().Msg("organizations calendar not activated in configuration") - w.WriteHeader(http.StatusForbidden) - return - } - - // TODO set additional calendar rights in group configuration to prevent default behavior ? - - vars := mux.Vars(r) - groupid := vars["groupid"] - - events, err := h.services.GetAgendaEvents() - if err != nil { - log.Error().Err(err).Msg("error retrieving agenda events") - w.WriteHeader(http.StatusInternalServerError) - return - } - - filteredEvents := []services.AgendaEvent{} - - for _, e := range events { - for _, g := range e.Owners { - if g == groupid { - filteredEvents = append(filteredEvents, e) - continue - } - } - } - - calendar, err := h.icsCalendar(filteredEvents) - if err != nil { - log.Error().Err(err).Msg("error while creating ics calendar") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.WriteHeader(http.StatusOK) - w.Header().Set("Content-Type", "text/calendar") - w.Write([]byte(calendar.Serialize())) -} diff --git a/handlers/api/export.go b/handlers/api/export.go deleted file mode 100755 index 59aeb2d..0000000 --- a/handlers/api/export.go +++ /dev/null @@ -1,97 +0,0 @@ -package api - -import ( - "encoding/csv" - "fmt" - "net/http" - "sort" - "strconv" - - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" -) - -type FlatMaps []map[string]any - -func (maps FlatMaps) GetHeaders() (res []string) { - keys := map[string]bool{} - for _, m := range maps { - for k, _ := range m { - if _, ok := keys[k]; !ok { - keys[k] = true - res = append(res, k) - } - } - } - sort.Strings(res) - return -} - -func (maps FlatMaps) GetValues() (res [][]string) { - headers := maps.GetHeaders() - for _, m := range maps { - line := []string{} - for _, k := range headers { - if v, ok := m[k]; ok && v != nil { - line = append(line, fmt.Sprint(v)) - } else { - line = append(line, "") - } - } - res = append(res, line) - } - return -} - -func (h APIHandler) CacheExport(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - cacheid := vars["cacheid"] - - d, err := h.cache.Get(cacheid) - if err != nil { - log.Error().Err(err).Msg("Error getting cache") - w.WriteHeader(http.StatusNotFound) - return - } - - if data, ok := d.([]any); ok { - - flatmaps := FlatMaps{} - - for _, v := range data { - fm := map[string]any{} - flatten("", v.(map[string]any), fm) - flatmaps = append(flatmaps, fm) - } - - w.Header().Set("Content-Type", "text/csv") - w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=export-%s.csv", cacheid)) - c := csv.NewWriter(w) - c.Write(flatmaps.GetHeaders()) - c.WriteAll(flatmaps.GetValues()) - return - - } - - w.WriteHeader(http.StatusNotFound) - -} - -func flatten(prefix string, src map[string]any, dest map[string]any) { - if len(prefix) > 0 { - prefix += "." - } - for k, v := range src { - switch child := v.(type) { - case map[string]any: - flatten(prefix+k, child, dest) - case []any: - for i := 0; i < len(child); i++ { - dest[prefix+k+"."+strconv.Itoa(i)] = child[i] - } - default: - // log.Trace().Str("key", prefix+k).Any("value", v).Msg("") - dest[prefix+k] = v - } - } -} diff --git a/handlers/api/geo.go b/handlers/api/geo.go deleted file mode 100755 index 34f2297..0000000 --- a/handlers/api/geo.go +++ /dev/null @@ -1,52 +0,0 @@ -package api - -import ( - "encoding/json" - "fmt" - "io" - "log" - "net/http" -) - -func (h *APIHandler) GeoAutocomplete(w http.ResponseWriter, r *http.Request) { - pelias := h.config.GetString("geo.pelias.url") - - t, ok := r.URL.Query()["text"] - - if !ok || len(t[0]) < 1 { - w.WriteHeader(http.StatusBadRequest) - return - } - - text := t[0] - - resp, err := http.Get(fmt.Sprintf("%s/autocomplete?text=%s", pelias, text)) - if err != nil { - w.WriteHeader(http.StatusInternalServerError) - return - } - - defer resp.Body.Close() - - body, err := io.ReadAll(resp.Body) - if err != nil { - log.Fatal(err) - } - - var response map[string]any - jsonErr := json.Unmarshal(body, &response) - if jsonErr != nil { - w.WriteHeader(http.StatusInternalServerError) - return - } - - j, err := json.Marshal(response["features"]) - if err != nil { - w.WriteHeader(http.StatusNotFound) - return - } - - w.WriteHeader(http.StatusOK) - w.Header().Set("Content-Type", "application/json") - w.Write(j) -} diff --git a/handlers/api/oidc.go b/handlers/api/oidc.go deleted file mode 100755 index f7b2b6a..0000000 --- a/handlers/api/oidc.go +++ /dev/null @@ -1,50 +0,0 @@ -package api - -import ( - "context" - "net/http" - - "github.com/rs/zerolog/log" -) - -func (h APIHandler) OAuth2Callback(w http.ResponseWriter, r *http.Request) { - oauth2Token, err := h.idp.OAuth2Config.Exchange(context.Background(), r.URL.Query().Get("code")) - if err != nil { - log.Error().Err(err).Msg("Exchange error") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // Extract the ID Token from OAuth2 token. - rawIDToken, ok := oauth2Token.Extra("id_token").(string) - if !ok { - log.Error().Msg("Cannot retrieve ID token") - w.WriteHeader(http.StatusInternalServerError) - return - } - - _, err = h.idp.TokenVerifier.Verify(context.Background(), rawIDToken) - if err != nil { - log.Error().Err(err).Msg("Not able to verify token") - w.WriteHeader(http.StatusUnauthorized) - return - } - - session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") - session.Values["idtoken"] = rawIDToken - - redirect := "/app/" - - if session.Values["redirect"] != nil && session.Values["redirect"] != "" { - redirect = session.Values["redirect"].(string) - delete(session.Values, "redirect") - } - - if err = session.Save(r, w); err != nil { - log.Error().Err(err).Msg("Cannot save session") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, redirect, http.StatusFound) -} diff --git a/handlers/api/protected/protected.go b/handlers/api/protected/protected.go deleted file mode 100644 index 0a31990..0000000 --- a/handlers/api/protected/protected.go +++ /dev/null @@ -1,32 +0,0 @@ -package protected - -import ( - "net/http" - - "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - "github.com/spf13/viper" -) - -type ProtectedAPIHandler struct { - ApiKey string - idp *identification.IdentificationProvider - config *viper.Viper - services *services.ServicesHandler - cache cache.CacheHandler -} - -func NewProtectedAPIHandler(cfg *viper.Viper, idp *identification.IdentificationProvider, svc *services.ServicesHandler, cache cache.CacheHandler) (*ProtectedAPIHandler, error) { - return &ProtectedAPIHandler{ - ApiKey: cfg.GetString("services.api.api_key"), - idp: idp, - config: cfg, - services: svc, - cache: cache, - }, nil -} - -func (h *ProtectedAPIHandler) NotFound(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusNotFound) -} diff --git a/handlers/api/protected/users.go b/handlers/api/protected/users.go deleted file mode 100644 index bc57632..0000000 --- a/handlers/api/protected/users.go +++ /dev/null @@ -1,65 +0,0 @@ -package protected - -import ( - "context" - "encoding/json" - "net/http" - - groupsgrpc "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "github.com/rs/zerolog/log" -) - -func (h *ProtectedAPIHandler) Users(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - h.postUsers(w, r) - return - } - - w.WriteHeader(http.StatusMethodNotAllowed) -} - -func (h *ProtectedAPIHandler) postUsers(w http.ResponseWriter, r *http.Request) { - var user storage.Account - - decoder := json.NewDecoder(r.Body) - err := decoder.Decode(&user) - if err != nil { - log.Error().Err(err).Msg("could not read account input") - w.WriteHeader(http.StatusBadRequest) - return - } - - account, err := grpcapi.AccountFromStorageType(&user) - if err != nil { - log.Error().Err(err).Msg("could not generate protobuf for account") - w.WriteHeader(http.StatusBadRequest) - return - } - - resp, err := h.services.GRPC.MobilityAccounts.Register(context.Background(), &grpcapi.RegisterRequest{ - Account: account, - }) - if err != nil { - log.Error().Err(err).Msg("grpc request issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if g, ok := user.Metadata["import_in_group"]; ok { - if group, ok := g.(string); ok { - _, err = h.services.GRPC.GroupsManagement.Subscribe(context.Background(), &groupsgrpc.SubscribeRequest{ - Groupid: group, - Memberid: resp.Account.Id, - }) - if err != nil { - log.Error().Err(err).Msg("grpc request issue, groups") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - - w.WriteHeader(http.StatusOK) -} diff --git a/handlers/application/administration.go b/handlers/application/administration.go deleted file mode 100755 index e9f9288..0000000 --- a/handlers/application/administration.go +++ /dev/null @@ -1,593 +0,0 @@ -package application - -import ( - "context" - "crypto/rand" - "encoding/base64" - "fmt" - "io" - "net/http" - "sort" - "sync" - "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" - 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" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" -) - -func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) { - 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{} - groupsBatchResponse *groupsmanagement.GetGroupsBatchResponse - ) - // 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 groupsRequest 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(context.TODO(), request) - 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(context.TODO(), &agenda.GetEventsRequest{ - Namespaces: []string{"parcoursmob_dispositifs"}, - }) - for _, e := range eventsResponse.Events { - groupids = append(groupids, e.Owners...) - responses = append(responses, e.ToStorageType()) - } - sort.Sort(sorting.EventsByStartdate(responses)) - }() - wg.Add(1) - // Retrieve groupsBatch in a goroutine - go func() { - defer wg.Done() - groupsBatchResponse, groupsBatchErr = h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{ - Groupids: groupids, - }) - groupps := map[string]any{} - if groupsBatchErr == nil { - for _, g := range groupsBatchResponse.Groups { - groupps[g.Id] = g.ToStorageType() - } - } - }() - wg.Wait() - 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") - w.WriteHeader(http.StatusInternalServerError) - return - } - h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings, responses) -} - -func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - r.ParseForm() - - if r.FormValue("name") == "" { - - log.Error().Str("name", r.FormValue("name")).Msg("Invalid name") - w.WriteHeader(http.StatusBadRequest) - return - } - - modules := map[string]any{ - "beneficiaries": r.FormValue("modules.beneficiaries") == "on", - "journeys": r.FormValue("modules.journeys") == "on", - "vehicles": r.FormValue("modules.vehicles") == "on", - "vehicles_management": r.FormValue("modules.vehicles_management") == "on", - "events": r.FormValue("modules.events") == "on", - "agenda": r.FormValue("modules.agenda") == "on", - "groups": r.FormValue("modules.groups") == "on", - "administration": r.FormValue("modules.administration") == "on", - "support": r.FormValue("modules.support") == "on", - "group_module": r.FormValue("modules.group_module") == "on", - "organized_carpool": r.FormValue("modules.organized_carpool") == "on", - "solidarity_transport": r.FormValue("modules.solidarity_transport") == "on", - } - - groupid := uuid.NewString() - - dataMap := map[string]any{ - "name": r.FormValue("name"), - "modules": modules, - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("Cannot create PB struct from data map") - w.WriteHeader(http.StatusInternalServerError) - return - } - - 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", - }, - } - go func() { - _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization) - if err != nil { - log.Error().Err(err).Msg("Issue in Groups management service - AddGroup") - w.WriteHeader(http.StatusInternalServerError) - return - } - }() - // Create the admin role for the organization - go func() { - _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role) - if err != nil { - log.Error().Err(err).Msg("Issue in Groups management service - AddGroup") - w.WriteHeader(http.StatusInternalServerError) - return - } - }() - http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound) - return - } - h.Renderer.AdministrationCreateGroup(w, r) -} - -func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - groupid := vars["groupid"] - - request := &groupsmanagement.GetGroupRequest{ - Id: groupid, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("Issue in Groups management service - GetGroup") - w.WriteHeader(http.StatusInternalServerError) - return - } - - groupmembers, admins, err := h.groupmembers(groupid) - if err != nil { - log.Error().Err(err).Msg("inssue retrieving group members") - w.WriteHeader(http.StatusInternalServerError) - return - } - - h.Renderer.AdministrationGroupDisplay(w, r, resp.Group.ToStorageType(), groupmembers, admins) -} - -func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - groupid := vars["groupid"] - var ( - groupresp *groupsmanagement.GetGroupResponse - accountresp *accounts.GetAccountUsernameResponse - err error - ) - groupresp, err = h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{ - Id: groupid, - Namespace: "parcoursmob_organizations", - }) - if err != nil { - log.Error().Err(err).Msg("Issue in Groups management service - GetGroup") - w.WriteHeader(http.StatusInternalServerError) - return - } - r.ParseForm() - - accountresp, err = h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{ - Username: r.FormValue("username"), - Namespace: "parcoursmob", - }) - if err == nil { - log.Print("account exists") - // Account already exists : adding the existing account to admin list - account := accountresp.Account.ToStorageType() - // account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid) - account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid+":admin") - - as, _ := accounts.AccountFromStorageType(&account) - - if _, err = h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), &accounts.UpdateDataRequest{Account: as}); err != nil { - log.Error().Err(err).Msg("could not set groups to user account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - data := map[string]any{ - "group": groupresp.Group.ToStorageType().Data["name"], - "baseUrl": h.config.GetString("base_url"), - } - - if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("Cannot send email") - } - - } else { - // Onboard now administrator - onboarding := map[string]any{ - "username": r.FormValue("username"), - "group": groupid, - "admin": true, - } - - b := make([]byte, 16) - if _, err := io.ReadFull(rand.Reader, b); err != nil { - log.Error().Err(err).Msg("Issue creating random bytes") - w.WriteHeader(http.StatusInternalServerError) - return - } - key := base64.RawURLEncoding.EncodeToString(b) - - if err := h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour); err != nil { // 1 week TTL - fmt.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - data := map[string]any{ - "group": groupresp.Group.ToStorageType().Data["name"], - "key": key, - "baseUrl": h.config.GetString("base_url"), - } - - if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("Cannot send email") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound) -} - -func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - groupid := vars["groupid"] - group, err := h.services.GetGroup(groupid) - if err != nil { - log.Error().Err(err).Msg("Issue in Groups management service - GetGroup") - w.WriteHeader(http.StatusInternalServerError) - return - } - r.ParseForm() - accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{ - Username: r.FormValue("username"), - Namespace: "parcoursmob", - }) - if err == nil { - account := accountresp.Account.ToStorageType() - account.Data["groups"] = append(account.Data["groups"].([]any), group.ID) - - as, _ := accounts.AccountFromStorageType(&account) - - _, err = h.services.GRPC.MobilityAccounts.UpdateData( - context.TODO(), - &accounts.UpdateDataRequest{ - Account: as, - }, - ) - data := map[string]any{ - "group": group.Data["name"], - "baseUrl": h.config.GetString("base_url"), - } - - if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("error sending email onboarding.existing_member") - } - - } else { - // Onboard new administrator - onboarding := map[string]any{ - "username": r.FormValue("username"), - "group": group.ID, - "admin": false, - } - - b := make([]byte, 16) - if _, err := io.ReadFull(rand.Reader, b); err != nil { - w.WriteHeader(http.StatusInternalServerError) - return - } - key := base64.RawURLEncoding.EncodeToString(b) - - h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL - data := map[string]any{ - "group": group.Data["name"], - "key": key, - "baseUrl": h.config.GetString("base_url"), - } - - if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("error sending email onboarding.new_member") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound) -} - -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) { - bookings := []fleetsstorage.Booking{} - administrators := []string{} - reequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("Issue in Fleets service - GetVehicles") - w.WriteHeader(http.StatusInternalServerError) - } - - 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]) - } - - 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 { - log.Error().Err(err).Msg("Issue in Groups management service - GetGroupsBatch") - 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) -} - -func (h ApplicationHandler) AdminStatBookings(w http.ResponseWriter, r *http.Request) { - vehicles := map[string]fleetsstorage.Vehicle{} - bookings := []fleetsstorage.Booking{} - - reequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("Issue in Fleets service - GetVehicles") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiaries_ids := []string{} - - for _, vehicle := range reesp.Vehicles { - - v := vehicle.ToStorageType() - - for _, b := range v.Bookings { - 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 { - log.Error().Err(err).Msg("Issue in Groups management service - GetGroups") - w.WriteHeader(http.StatusInternalServerError) - return - } - - 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 { - log.Error().Err(err).Msg("Issue in Mobility accounts service - GetAccountsBatch") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiaries_map := map[string]any{} - for _, ben := range beneficiaries.Accounts { - beneficiaries_map[ben.Id] = ben.ToStorageType() - } - - sort.Sort(sorting.BookingsByStartdate(bookings)) - h.Renderer.AdminStatBookings(w, r, vehicles, bookings, groups, beneficiaries_map) -} - -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 -} - -func (h ApplicationHandler) AdminStatBeneficaires(w http.ResponseWriter, r *http.Request) { - beneficiaries, err := h.services.GetBeneficiaries() - if err != nil { - log.Error().Err(err).Msg("Cannot get beneficiaries") - 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 { - log.Error().Err(err).Msg("Issue in Agenda service - GetEvents") - 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) -} diff --git a/handlers/application/agenda.go b/handlers/application/agenda.go deleted file mode 100755 index 3ceed18..0000000 --- a/handlers/application/agenda.go +++ /dev/null @@ -1,790 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "io" - "net/http" - "sort" - "strconv" - "strings" - "time" - - formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi" - agendastorage "git.coopgo.io/coopgo-platform/agenda/storage" - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - "git.coopgo.io/coopgo-platform/groups-management/storage" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -type EventsForm struct { - Name string `json:"name" validate:"required"` - Type string `json:"type" validate:"required"` - Description string `json:"description"` - Address any `json:"address,omitempty"` - Allday bool `json:"allday"` - Startdate *time.Time `json:"startdate"` - Enddate *time.Time `json:"enddate"` - Starttime string `json:"starttime"` - Endtime string `json:"endtime"` - MaxSubscribers int `json:"max_subscribers"` -} - -func (h *ApplicationHandler) AgendaHome(w http.ResponseWriter, r *http.Request) { - resp, 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 { - log.Error().Err(err).Msg("") - 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.AgendaHome(w, r, responses, groups) -} - -func (h *ApplicationHandler) AgendaHistory(w http.ResponseWriter, r *http.Request) { - resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{ - Namespaces: []string{"parcoursmob_dispositifs"}, - //Maxdate: timestamppb.New(time.Now().Add(24 * time.Hour)), - }) - - if err != nil { - log.Error().Err(err).Msg("") - 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.AgendaHistory(w, r, responses, groups) -} - -func (h *ApplicationHandler) AgendaCreateEvent(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - // Get current group - 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 { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - log.Debug().Any("eventFrom", eventForm).Msg("Form data submitted to create event") - - data, _ := structpb.NewStruct(map[string]any{ - "address": eventForm.Address, - }) - - request := &agenda.CreateEventRequest{ - Event: &agenda.Event{ - Namespace: "parcoursmob_dispositifs", - 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, - Deleted: false, - }, - } - - resp, err := h.services.GRPC.Agenda.CreateEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - contentType := r.Header.Get("Content-Type") - if strings.HasPrefix(contentType, "multipart/form-data") { - err = r.ParseMultipartForm(100 * 1024 * 1024) // 100 MB limit - if err != nil { - log.Error().Err(err).Msg("Error parsing multipart form") - w.WriteHeader(http.StatusBadRequest) - return - } - - file, header, err := r.FormFile("file-upload") - if err == nil { - defer file.Close() - - document_type := r.FormValue("file_type") - document_name := r.FormValue("file_name") - - fileid := uuid.NewString() - - metadata := map[string]string{ - "file_type": document_type, - "file_name": document_name, - } - - if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", resp.Event.Id, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("Error uploading file") - w.WriteHeader(http.StatusInternalServerError) - return - } - } else if err != http.ErrMissingFile { - log.Error().Err(err).Msg("Error retrieving file") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", resp.Event.Id), http.StatusFound) - return - } - - h.Renderer.AgendaCreateEvent(w, r, h.config.GetStringSlice("modules.agenda.documents_types"), h.config.GetStringMapString("storage.files.file_types"), nil) -} - -func (h *ApplicationHandler) AgendaDisplayEvent(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - eventid := vars["eventid"] - - request := &agenda.GetEventRequest{ - Id: eventid, - } - - resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - grouprequest := &groupsmanagement.GetGroupRequest{ - Id: resp.Event.Owners[0], - } - - groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - subscribers := map[string]any{} - - accids := []string{} - for _, v := range resp.Event.Subscriptions { - accids = append(accids, v.Subscriber) - } - - subscriberresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( - context.TODO(), - &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: accids, - }, - ) - - if err == nil { - for _, sub := range subscriberresp.Accounts { - subscribers[sub.Id] = sub.ToStorageType() - } - } - - g := r.Context().Value(identification.GroupKey) - if g == nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - group := g.(storage.Group) - - accountids := []string{} - for _, m := range group.Members { - if !contains(resp.Event.Subscriptions, m) { - accountids = append(accountids, m) - } - } - - accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( - context.TODO(), - &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: accountids, - }, - ) - - accounts := []any{} - - if err == nil { - for _, acc := range accountresp.Accounts { - accounts = append(accounts, acc) - } - } - - documents := h.filestorage.List(filestorage.PREFIX_AGENDA + "/" + eventid) - - events_file_types := h.config.GetStringSlice("modules.agenda.documents_types") - file_types_map := h.config.GetStringMapString("storage.files.file_types") - - h.Renderer.AgendaDisplayEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), events_file_types, file_types_map, documents, subscribers, accounts) -} - -func (h *ApplicationHandler) AgendaSubscribeEvent(w http.ResponseWriter, r *http.Request) { - current_group, err := h.currentGroup(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - current_user_token, current_user_claims, err := h.currentUser(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - vars := mux.Vars(r) - eventid := vars["eventid"] - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - subscriber := r.FormValue("subscriber") - data := map[string]any{ - "subscribed_by": map[string]any{ - "user": map[string]any{ - "id": current_user_token.Subject, - "display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string), - "email": current_user_claims["email"].(string), - }, - "group": map[string]any{ - "id": current_group.ID, - "name": current_group.Data["name"], - }, - }, - } - datapb, err := structpb.NewStruct(data) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &agenda.SubscribeEventRequest{ - Eventid: eventid, - Subscriber: subscriber, - Data: datapb, - } - - _, err = h.services.GRPC.Agenda.SubscribeEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventid), http.StatusFound) -} - -func parseEventsForm(r *http.Request) (*EventsForm, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - var startdate *time.Time - var enddate *time.Time - - if r.PostFormValue("startdate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("startdate")) - if err != nil { - return nil, err - } - startdate = &d - } - - if r.PostFormValue("enddate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("enddate")) - if err != nil { - return nil, err - } - enddate = &d - } - - max_subscribers, err := strconv.Atoi(r.PostFormValue("max_subscribers")) - if err != nil { - return nil, err - } - - formData := &EventsForm{ - Name: r.PostFormValue("name"), - Type: r.PostFormValue("type"), - Description: r.PostFormValue("description"), - Startdate: startdate, - Enddate: enddate, - Starttime: r.PostFormValue("starttime"), - Endtime: r.PostFormValue("endtime"), - MaxSubscribers: max_subscribers, - } - - if r.PostFormValue("allday") == "true" { - formData.Allday = true - } - - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - formData.Address = a - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - return formData, nil -} - -func contains(s []*agenda.Subscription, e string) bool { - for _, a := range s { - if a.Subscriber == e { - return true - } - } - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - 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) { - - vars := mux.Vars(r) - eventID := vars["eventid"] - request := &agenda.GetEventRequest{ - Id: eventID, - } - - resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - 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, - }, - } - - _, err := h.services.GRPC.Agenda.UpdateEvent(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, "/app/agenda/", http.StatusFound) - return - } - h.Renderer.AgendaDeleteEvent(w, r, resp.Event.ToStorageType()) -} - -// /////////////////////////Delete subscriber/////////////////////////////// -func (h *ApplicationHandler) AgendaDeleteSubscribeEvent(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - eventId := vars["eventid"] - subscribeid := vars["subscribeid"] - s_b_id := "" - s_b_name := "" - s_b_email := "" - s_b_group_id := "" - s_b_group_name := "" - request := &agenda.GetEventRequest{ - Id: eventId, - } - - resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for i := range resp.Event.Subscriptions { - if resp.Event.Subscriptions[i].Subscriber == subscribeid { - subscribed_by_id := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue() - subscribed_by_name := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue() - subscribed_by_email := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue() - subscribed_by_group_id := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue() - subscribed_by_group_name := resp.Event.Subscriptions[i].Data.Fields["subscribed_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue() - s_b_id = subscribed_by_id - s_b_name = subscribed_by_name - s_b_email = subscribed_by_email - s_b_group_id = subscribed_by_group_id - s_b_group_name = subscribed_by_group_name - } - } - - current_group, err := h.currentGroup(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - current_user_token, current_user_claims, err := h.currentUser(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - data := map[string]any{ - "subscribed_by": map[string]any{ - "user": map[string]any{ - "id": s_b_id, - "display_name": s_b_name, - "email": s_b_email, - }, - "group": map[string]any{ - "id": s_b_group_id, - "name": s_b_group_name, - }, - }, - "unsubscribed_by": map[string]any{ - "user": map[string]any{ - "id": current_user_token.Subject, - "display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string), - "email": current_user_claims["email"], - }, - "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 { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - request := &agenda.DeleteSubscriptionRequest{ - Subscriber: subscribeid, - Eventid: eventId, - Data: datapb, - } - - data := map[string]any{ - "motif": r.FormValue("motif"), - "user": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string), - "subscriber": fmt.Sprintf("http://localhost:9000/app/beneficiaries/%s", subscribeid), - "link": fmt.Sprintf("http://localhost:9000/app/agenda/%s", eventId), - } - - // récupérer l'adresse mail de l'utilisateur qui a créé l'événement - mail := s_b_email - log.Debug().Str("mail", mail).Msg("Email content") - - _, err := h.services.GRPC.Agenda.DeleteSubscription(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if err := h.emailing.Send("delete_subscriber.request", mail, data); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventId), http.StatusFound) - return - } - h.Renderer.AgendaDeleteSubscribeEvent(w, r, eventId) -} - -// ////////////////////////////////////////////////////// -// /////////////////////History Event//////////////////////// -func (h *ApplicationHandler) AgendaHistoryEvent(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - eventId := vars["eventid"] - request := &agenda.GetEventRequest{ - Id: eventId, - } - - resp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - grouprequest := &groupsmanagement.GetGroupRequest{ - Id: resp.Event.Owners[0], - } - - groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - subscribers := map[string]any{} - - accids := []string{} - for _, v := range resp.Event.DeletedSubscription { - accids = append(accids, v.Subscriber) - } - - subscriberresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( - context.TODO(), - &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: accids, - }, - ) - - if err == nil { - for _, sub := range subscriberresp.Accounts { - subscribers[sub.Id] = sub.ToStorageType() - } - } - - g := r.Context().Value(identification.GroupKey) - if g == nil { - w.WriteHeader(http.StatusInternalServerError) - return - } - - group := g.(storage.Group) - - accountids := []string{} - for _, m := range group.Members { - if !contains(resp.Event.DeletedSubscription, m) { - accountids = append(accountids, m) - } - } - - accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountsBatch( - context.TODO(), - &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: accountids, - }, - ) - - accounts := []any{} - - if err == nil { - for _, acc := range accountresp.Accounts { - accounts = append(accounts, acc) - } - } - - h.Renderer.AgendaHistoryEvent(w, r, resp.Event.ToStorageType(), groupresp.Group.ToStorageType(), subscribers, accounts) -} - -// //// ADD DOCUMENTS ////// -func (h *ApplicationHandler) EventDocuments(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - eventID := vars["eventid"] - - //r.ParseForm() - r.ParseMultipartForm(100 * 1024 * 1024) - - document_type := r.FormValue("type") - document_name := r.FormValue("name") - - file, header, err := r.FormFile("file-upload") - if err != nil { - log.Error().Err(err).Msg("") - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": document_type, - "name": document_name, - } - - if err := h.filestorage.Put(file, filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s_%s", eventID, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) - -} - -func (h *ApplicationHandler) EventDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - eventID := vars["eventid"] - document := vars["document"] - - file, info, err := h.filestorage.Get(filestorage.PREFIX_AGENDA, fmt.Sprintf("%s/%s", eventID, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) - -} diff --git a/handlers/application/beneficiaries.go b/handlers/application/beneficiaries.go deleted file mode 100755 index 7d2d59c..0000000 --- a/handlers/application/beneficiaries.go +++ /dev/null @@ -1,706 +0,0 @@ -package application - -import ( - "bytes" - "context" - "encoding/json" - "errors" - "fmt" - "image/png" - "io" - "net/http" - "sort" - "strconv" - "strings" - "time" - - formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - profilepictures "git.coopgo.io/coopgo-apps/parcoursmob/utils/profile-pictures" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi" - agendastorage "git.coopgo.io/coopgo-platform/agenda/storage" - diagsstorage "git.coopgo.io/coopgo-platform/diags/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" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -type BeneficiariesForm struct { - FirstName string `json:"first_name" validate:"required"` - LastName string `json:"last_name" validate:"required"` - Email string `json:"email" validate:"required,email"` - Birthdate *time.Time `json:"birthdate" validate:"required"` - PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` - FileNumber string `json:"file_number"` - Address any `json:"address,omitempty"` - Gender string `json:"gender"` - OtherProperties any `json:"other_properties,omitempty"` -} - -type Event_Beneficiary interface { - Name() string - Date() time.Time - DateEnd() time.Time - Type() string - Db() string - ID() string - Icons() string - Status() int -} - -type Event struct { - IDVal string - NameVal string - DateVal time.Time - DateEndVal time.Time - TypeVal string - DbVal string - Deleted bool - IconSet string - StatusVal int -} - -func (e Event) Name() string { - return e.NameVal -} - -func (e Event) Date() time.Time { - return e.DateVal -} - -func (e Event) DateEnd() time.Time { - return e.DateEndVal -} - -func (e Event) Type() string { - return e.TypeVal -} - -func (e Event) ID() string { - return e.IDVal -} - -func (e Event) Db() string { - return e.DbVal -} - -func (e Event) Icons() string { - return e.IconSet -} - -func (e Event) Status() int { - return e.StatusVal -} - -func sortByDate(events []Event_Beneficiary) { - sort.Slice(events, func(i, j int) bool { - return events[i].Date().After(events[j].Date()) - }) -} - -func (h *ApplicationHandler) BeneficiariesList(w http.ResponseWriter, r *http.Request) { - accounts, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - sort.Sort(sorting.BeneficiariesByName(accounts)) - - cacheid := uuid.NewString() - h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour) - h.Renderer.BeneficiariesList(w, r, accounts, cacheid) -} - -func (h *ApplicationHandler) BeneficiaryCreate(w http.ResponseWriter, r *http.Request) { - g := r.Context().Value(identification.GroupKey) - if g == nil { - log.Error().Msg("Create beneficiary : could not find group") - w.WriteHeader(http.StatusBadRequest) - return - } - - group := g.(storage.Group) - - if r.Method == "POST" { - - dataMap, err := parseBeneficiariesForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.RegisterRequest{ - Account: &mobilityaccounts.Account{ - Namespace: "parcoursmob_beneficiaries", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.Register(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - subscribe := &groupsmanagement.SubscribeRequest{ - Groupid: group.ID, - Memberid: resp.Account.Id, - } - - _, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", resp.Account.Id), http.StatusFound) - - return - } - h.Renderer.BeneficiaryCreate(w, r) -} - -func (h *ApplicationHandler) BeneficiaryDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - documents := h.filestorage.List(filestorage.PREFIX_BENEFICIARIES + "/" + beneficiaryID) - - request := &mobilityaccounts.GetAccountRequest{ - Id: beneficiaryID, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("cannot retrieve account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - subscriptionrequest := &agenda.GetSubscriptionByUserRequest{ - Subscriber: beneficiaryID, - } - - subcriptionresp, err := h.services.GRPC.Agenda.GetSubscriptionByUser(context.TODO(), subscriptionrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - events := []agendastorage.Event{} - currentTime := time.Now().Truncate(24 * time.Hour) - - for _, e := range subcriptionresp.Subscription { - eventresquest := &agenda.GetEventRequest{ - Id: e.Eventid, - } - eventresp, err := h.services.GRPC.Agenda.GetEvent(context.TODO(), eventresquest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - events = append(events, eventresp.Event.ToStorageType()) - } - - sort.Sort(sorting.EventsByStartdate(events)) - - bookingsrequest := &fleets.GetDriverBookingsRequest{ - Driver: beneficiaryID, - } - bookingsresp, err := h.services.GRPC.Fleets.GetDriverBookings(context.TODO(), bookingsrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - bookings := []fleetsstorage.Booking{} - - for _, b := range bookingsresp.Bookings { - bookings = append(bookings, b.ToStorageType()) - } - - var events_list []Event_Beneficiary - var status_event int - - for _, e := range events { - - if e.Startdate.After(currentTime) { - status_event = 1 - } else if e.Startdate.Before(currentTime) && e.Enddate.After(currentTime) || e.Enddate.Equal(currentTime) { - status_event = 2 - } else { - status_event = 3 - } - - event := Event{ - NameVal: e.Name, - DateVal: e.Startdate, - DateEndVal: e.Enddate, - TypeVal: e.Type, - IDVal: e.ID, - DbVal: "/app/agenda/", - IconSet: "calendar", - StatusVal: status_event, - } - - events_list = append(events_list, event) - } - - var status_booking int - for _, b := range bookings { - if b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) { - GetVehiculeRequest := &fleets.GetVehicleRequest{ - Vehicleid: b.Vehicleid, - } - - GetVehiculeResp, err := h.services.GRPC.Fleets.GetVehicle(context.Background(), GetVehiculeRequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if b.Startdate.After(currentTime) { - status_booking = 1 - } else if b.Startdate.Before(currentTime) && b.Enddate.After(currentTime) || b.Enddate.Equal(currentTime) { - status_booking = 2 - } else { - status_booking = 3 - } - - event := Event{ - NameVal: GetVehiculeResp.Vehicle.ToStorageType().Data["name"].(string), - DateVal: b.Startdate, - DateEndVal: b.Enddate, - TypeVal: "Réservation de véhicule", - IDVal: b.ID, - DbVal: "/app/vehicles-management/bookings/", - IconSet: "vehicle", - StatusVal: status_booking, - } - - events_list = append(events_list, event) - } - } - solidarity, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(context.Background(), &gen.GetSolidarityTransportBookingsRequest{ - Passengerid: beneficiaryID, - StartDate: timestamppb.New(time.Now().Add(-36 * 730 * time.Hour)), - EndDate: timestamppb.New(time.Now().Add(12 * 730 * time.Hour)), - Status: "VALIDATED", - }) - solidarityTransportStats := map[string]int64{ - "count": 0, - "km": 0, - } - for _, s := range solidarity.Bookings { - b, _ := transformers.BookingProtoToType(s) - event := Event{ - NameVal: fmt.Sprintf("%s (%d km)", b.Journey.PassengerDrop.Properties.MustString("label", ""), b.Journey.PassengerDistance), - DateVal: b.Journey.PassengerPickupDate, - DateEndVal: b.Journey.PassengerPickupDate, - TypeVal: "Transport solidaire", - IDVal: b.Id, - DbVal: "/app/solidarity-transport/bookings/", - IconSet: "vehicle", - StatusVal: 1, - } - - events_list = append(events_list, event) - - solidarityTransportStats["count"] = solidarityTransportStats["count"] + 1 - solidarityTransportStats["km"] = solidarityTransportStats["km"] + b.Journey.PassengerDistance - - } - sortByDate(events_list) - - diag := []diagsstorage.Diag{} - - /*diagsrequest := &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_beneficiaries"}, - } - - diagsresp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), diagsrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for _, d := range diagsresp.Diags { - diagData := d.Data.AsMap() - if beneficiary, ok := diagData["beneficiary"].(string); ok && beneficiary == beneficiaryID { - diag = append(diag, d.ToStorageType()) - } - }*/ - - groupsrequest := &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_organizations"}, - Member: beneficiaryID, - } - - groupsresp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), groupsrequest) - if err != nil { - log.Error().Err(err).Msg("") - } - - organizations := []any{} - for _, o := range groupsresp.Groups { - organizations = append(organizations, o.ToStorageType()) - } - - beneficiaries_file_types := h.config.GetStringSlice("modules.beneficiaries.documents_types") - file_types_map := h.config.GetStringMapString("storage.files.file_types") - - diagsAny := make([]any, len(diag)) - for i, d := range diag { - diagsAny[i] = d - } - - account := resp.Account.ToStorageType() - walletBalance := h.calculateWalletBalance(account) - - h.Renderer.BeneficiaryDisplay(w, r, account, bookings, organizations, beneficiaries_file_types, file_types_map, documents, events_list, diagsAny, solidarityTransportStats, walletBalance) -} - -func (h *ApplicationHandler) BeneficiaryUpdate(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - if r.Method == "POST" { - - dataMap, err := parseBeneficiariesForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: beneficiaryID, - Namespace: "parcoursmob_beneficiaries", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", resp.Account.Id), http.StatusFound) - - return - } - - request := &mobilityaccounts.GetAccountRequest{ - Id: beneficiaryID, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // TODO filter namespaces - // TODO filter groups - - h.Renderer.BeneficiaryUpdate(w, r, resp.Account.ToStorageType()) -} - -func (h *ApplicationHandler) BeneficiaryArchive(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - data, err := structpb.NewValue(map[string]any{ - "archived": true, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: beneficiaryID, - Namespace: "parcoursmob_beneficiaries", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) BeneficiaryUnarchive(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - data, err := structpb.NewValue(map[string]any{ - "archived": false, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: beneficiaryID, - Namespace: "parcoursmob_beneficiaries", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) BeneficiaryPicture(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - request := &mobilityaccounts.GetAccountRequest{ - Id: beneficiaryID, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - account := resp.Account.ToStorageType() - - firstName := account.Data["first_name"].(string) - lastName := account.Data["last_name"].(string) - picture := profilepictures.DefaultProfilePicture(strings.ToUpper(firstName[0:1] + lastName[0:1])) - - buffer := new(bytes.Buffer) - if err := png.Encode(buffer, picture); err != nil { - log.Error().Err(err).Msg("unable to encode image.") - } - - w.Header().Set("Content-Type", "image/png") - w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes()))) - if _, err := w.Write(buffer.Bytes()); err != nil { - log.Error().Err(err).Msg("unable to write image.") - } -} - -func (h *ApplicationHandler) BeneficiaryDocuments(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - // r.ParseForm() - r.ParseMultipartForm(100 * 1024 * 1024) - - document_type := r.FormValue("type") - document_name := r.FormValue("name") - - file, header, err := r.FormFile("file-upload") - if err != nil { - log.Error().Err(err).Msg("") - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": document_type, - "name": document_name, - } - - log.Debug().Any("metadata", metadata).Msg("Metadata") - - if err := h.filestorage.Put(file, filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s_%s", beneficiaryID, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) -} - -func (h *ApplicationHandler) BeneficiaryDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - document := vars["document"] - - file, info, err := h.filestorage.Get(filestorage.PREFIX_BENEFICIARIES, fmt.Sprintf("%s/%s", beneficiaryID, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) -} - -func filterAccount(r *http.Request, a *mobilityaccounts.Account) bool { - searchFilter, ok := r.URL.Query()["search"] - - if ok && len(searchFilter[0]) > 0 { - name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) - if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter[0])) { - return false - } - } - - archivedFilter, ok := r.URL.Query()["archived"] - if ok && archivedFilter[0] == "true" { - if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { - return true - } - return false - } else { - if archived, ok := a.Data.AsMap()["archived"].(bool); ok && archived { - return false - } - } - - return true -} - -// func BeneficiariesEventList() - -func (h *ApplicationHandler) beneficiaries(r *http.Request) ([]mobilityaccountsstorage.Account, error) { - accounts := []mobilityaccountsstorage.Account{} - g := r.Context().Value(identification.GroupKey) - if g == nil { - return accounts, errors.New("no group provided") - } - - 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("issue in mobilityaccounts call") - return accounts, err - } - - for _, account := range resp.Accounts { - if filterAccount(r, account) { - a := account.ToStorageType() - accounts = append(accounts, a) - } - } - - return accounts, err -} - -func parseBeneficiariesForm(r *http.Request) (map[string]any, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - var date *time.Time - - if r.PostFormValue("birthdate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) - if err != nil { - return nil, err - } - date = &d - } - - formData := BeneficiariesForm{ - FirstName: r.PostFormValue("first_name"), - LastName: r.PostFormValue("last_name"), - Email: r.PostFormValue("email"), - Birthdate: date, - PhoneNumber: r.PostFormValue("phone_number"), - FileNumber: r.PostFormValue("file_number"), - Gender: r.PostFormValue("gender"), - } - log.Trace().Any("address", r.PostFormValue("address")).Msg("address") - - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - formData.Address = a - } - - log.Trace().Any("otther properties", r.PostFormValue("other_properties")).Msg("other propperties ?") - - if r.PostFormValue("other_properties") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("other_properties")), &a) - - formData.OtherProperties = a - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - d, err := json.Marshal(formData) - if err != nil { - return nil, err - } - - var dataMap map[string]any - err = json.Unmarshal(d, &dataMap) - if err != nil { - return nil, err - } - - return dataMap, nil -} diff --git a/handlers/application/dashboard.go b/handlers/application/dashboard.go deleted file mode 100755 index fa52f3f..0000000 --- a/handlers/application/dashboard.go +++ /dev/null @@ -1,98 +0,0 @@ -package application - -import ( - "context" - "fmt" - "net/http" - "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" - 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 - } - - 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) { - fmt.Println(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 { - if b.Enddate.AsTime().After(time.Now()) { - bookings = append(bookings, b.ToStorageType()) - } - } - } - - h.Renderer.Dashboard(w, r, accounts, count, count_members, events, bookings) -} diff --git a/handlers/application/diags.go b/handlers/application/diags.go deleted file mode 100644 index 8d0bda4..0000000 --- a/handlers/application/diags.go +++ /dev/null @@ -1,642 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "errors" - "fmt" - "io" - - // "io" - "net/http" - // "strconv" - "strings" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - - // filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - diags "git.coopgo.io/coopgo-platform/diags/grpcapi" - diagsstorage "git.coopgo.io/coopgo-platform/diags/storage" - - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - "git.coopgo.io/coopgo-platform/groups-management/storage" - // mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - // "github.com/google/uuid" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -type DiagsForm struct { - Name string `json:"name" validate:"required"` - Namespace string `json:"namespace" validate:"required"` - JsonSchema string `json:"json_schema"` - UiSchema string `json:"ui_schema"` - Data map[string]any `json:"data"` - Deleted bool `json:"deleted"` - Diagdate *time.Time `json:"diagdate"` - Owners []string `json:"owners"` -} - -func (h *ApplicationHandler) DiagsHome(w http.ResponseWriter, r *http.Request) { - groupID := r.Context().Value(identification.GroupKey).(storage.Group).ID - - resp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_beneficiaries", "parcoursmob_diagnostiques", "parcoursmob_vehicles", "parcoursmob_bookings"}, - }) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - responses := []diagsstorage.Diag{} - - groupids := []string{} - for _, e := range resp.Diags { - groupids = append(groupids, e.Owners...) - responses = append(responses, e.ToStorageType()) - } - - 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() - } - } - - filteredDiags := []diagsstorage.Diag{} - for _, diag := range responses { - for _, owner := range diag.Owners { - if string(owner) == groupID { - filteredDiags = append(filteredDiags, diag) - log.Debug().Msgf("Diag %s added to filtered list", diag.ID) - break - } - } - } - - h.Renderer.DiagsHome(w, r, filteredDiags, groups) -} - -func (h *ApplicationHandler) DiagsHistory(w http.ResponseWriter, r *http.Request) { - resp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_beneficiaries", "parcoursmob_diagnostiques", "parcoursmob_vehicles", "parcoursmob_bookings"}, - }) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - responses := []diagsstorage.Diag{} - - for _, e := range resp.Diags { - if e.Deleted { - responses = append(responses, e.ToStorageType()) - } - } - - h.Renderer.DiagsHistory(w, r, responses) -} - -func (h *ApplicationHandler) BeneficiariesCreateDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - beneficiaryID := vars["beneficiaryid"] - - if h.services == nil || (h.services.GRPC == services.GRPCServices{}) || h.services.GRPC.Diags == nil { - log.Error().Msg("Diags service is not initialized") - http.Error(w, "Internal server error", http.StatusInternalServerError) - return - } - - - if r.Method == http.MethodPost { - g := r.Context().Value(identification.GroupKey) - if g == nil { - http.Error(w, "Missing group information", http.StatusBadRequest) - return - } - - group := g.(storage.Group) - - diagForm, err := parseDiagsForm(r) - if err != nil { - log.Error().Err(err).Msg("Invalid form data") - http.Error(w, err.Error(), http.StatusBadRequest) - return - } - - data, err := structpb.NewStruct(map[string]any{ - "beneficiary": beneficiaryID, - }) - if err != nil { - log.Error().Err(err).Msg("Failed to create protobuf struct") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &diags.CreateDiagRequest{ - Diag: &diags.Diag{ - Name: diagForm.Name, - Namespace: diagForm.Namespace, - JsonSchema: diagForm.JsonSchema, - UiSchema: diagForm.UiSchema, - Data: data, - Deleted: diagForm.Deleted, - Diagdate: timestamppb.New(time.Now()), - Owners: []string{group.ID}, - }, - } - - resp, err := h.services.GRPC.Diags.CreateDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("Failed to create diagnostic") - w.WriteHeader(http.StatusInternalServerError) - return - } - - contentType := r.Header.Get("Content-Type") - if strings.HasPrefix(contentType, "multipart/form-data") { - err = r.ParseMultipartForm(100 * 1024 * 1024) // 100 MB limit - if err != nil { - log.Error().Err(err).Msg("Error parsing multipart form") - w.WriteHeader(http.StatusBadRequest) - return - } - - file, header, err := r.FormFile("file-upload") - if err == nil { - defer file.Close() - - document_type := r.FormValue("file_type") - document_name := r.FormValue("file_name") - - fileid := uuid.NewString() - - metadata := map[string]string{ - "file_type": document_type, - "file_name": document_name, - } - - if err := h.filestorage.Put(file, filestorage.PREFIX_DIAGS, fmt.Sprintf("%s/%s_%s", resp.Diag.Id, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("Error uploading file") - w.WriteHeader(http.StatusInternalServerError) - return - } - } else if err != http.ErrMissingFile { - log.Error().Err(err).Msg("Error retrieving file") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound) - return - } - - h.Renderer.BeneficiariesCreateDiag(w, r, beneficiaryID, h.config.GetStringSlice("modules.diags.documents_types"), h.config.GetStringMapString("storage.files.file_types"), nil) -} - -func (h *ApplicationHandler) VehiclesCreateDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - vehicleID := vars["vehicleid"] - - if h.services == nil || (h.services.GRPC == services.GRPCServices{}) || h.services.GRPC.Diags == nil { - log.Error().Msg("Diags service is not initialized") - http.Error(w, "Internal server error", http.StatusInternalServerError) - return - } - - - if r.Method == http.MethodPost { - g := r.Context().Value(identification.GroupKey) - if g == nil { - http.Error(w, "Missing group information", http.StatusBadRequest) - return - } - - diagForm, err := parseDiagsForm(r) - if err != nil { - log.Error().Err(err).Msg("Invalid form data") - http.Error(w, err.Error(), http.StatusBadRequest) - return - } - - log.Debug().Interface("diagForm", diagForm).Msg("Form data parsed") - - data, err := structpb.NewStruct(map[string]any{ - "vehicle": vehicleID, - }) - if err != nil { - log.Error().Err(err).Msg("Failed to create protobuf struct") - w.WriteHeader(http.StatusInternalServerError) - return - } - - group := g.(storage.Group) - - request := &diags.CreateDiagRequest{ - Diag: &diags.Diag{ - Name: diagForm.Name, - Namespace: diagForm.Namespace, - JsonSchema: diagForm.JsonSchema, - UiSchema: diagForm.UiSchema, - Data: data, - Deleted: diagForm.Deleted, - Diagdate: timestamppb.New(time.Now()), - Owners: []string{group.ID}, - }, - } - - resp, err := h.services.GRPC.Diags.CreateDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("Failed to create diagnostic") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound) - return - } - - h.Renderer.VehiclesCreateDiag(w, r, vehicleID) -} - -func (h *ApplicationHandler) BookingsCreateDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingID := vars["bookingid"] - - if h.services == nil || (h.services.GRPC == services.GRPCServices{}) || h.services.GRPC.Diags == nil { - log.Error().Msg("Diags service is not initialized") - http.Error(w, "Internal server error", http.StatusInternalServerError) - return - } - - - if r.Method == http.MethodPost { - g := r.Context().Value(identification.GroupKey) - if g == nil { - http.Error(w, "Missing group information", http.StatusBadRequest) - return - } - - diagForm, err := parseDiagsForm(r) - if err != nil { - log.Error().Err(err).Msg("Invalid form data") - http.Error(w, err.Error(), http.StatusBadRequest) - return - } - - log.Debug().Interface("diagForm", diagForm).Msg("Form data parsed") - - data, err := structpb.NewStruct(map[string]any{ - "booking": bookingID, - }) - if err != nil { - log.Error().Err(err).Msg("Failed to create protobuf struct") - w.WriteHeader(http.StatusInternalServerError) - return - } - - group := g.(storage.Group) - - request := &diags.CreateDiagRequest{ - Diag: &diags.Diag{ - Name: diagForm.Name, - Namespace: diagForm.Namespace, - JsonSchema: diagForm.JsonSchema, - UiSchema: diagForm.UiSchema, - Data: data, - Deleted: diagForm.Deleted, - Diagdate: timestamppb.New(time.Now()), - Owners: []string{group.ID}, - }, - } - - resp, err := h.services.GRPC.Diags.CreateDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("Failed to create diagnostic") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound) - return - } - - h.Renderer.BookingsCreateDiag(w, r, bookingID) -} - -func (h *ApplicationHandler) VehicleBookingsCreateDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingID := vars["bookingid"] - - if h.services == nil || (h.services.GRPC == services.GRPCServices{}) || h.services.GRPC.Diags == nil { - log.Error().Msg("Diags service is not initialized") - http.Error(w, "Internal server error", http.StatusInternalServerError) - return - } - - - if r.Method == http.MethodPost { - g := r.Context().Value(identification.GroupKey) - if g == nil { - http.Error(w, "Missing group information", http.StatusBadRequest) - return - } - - diagForm, err := parseDiagsForm(r) - if err != nil { - log.Error().Err(err).Msg("Invalid form data") - http.Error(w, err.Error(), http.StatusBadRequest) - return - } - - log.Debug().Interface("diagForm", diagForm).Msg("Form data parsed") - - data, err := structpb.NewStruct(map[string]any{ - "booking": bookingID, - }) - if err != nil { - log.Error().Err(err).Msg("Failed to create protobuf struct") - w.WriteHeader(http.StatusInternalServerError) - return - } - - group := g.(storage.Group) - - request := &diags.CreateDiagRequest{ - Diag: &diags.Diag{ - Name: diagForm.Name, - Namespace: diagForm.Namespace, - JsonSchema: diagForm.JsonSchema, - UiSchema: diagForm.UiSchema, - Data: data, - Deleted: diagForm.Deleted, - Diagdate: timestamppb.New(time.Now()), - Owners: []string{group.ID}, - }, - } - - resp, err := h.services.GRPC.Diags.CreateDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("Failed to create diagnostic") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound) - return - } - - h.Renderer.VehicleBookingsCreateDiag(w, r, bookingID) -} - -func (h *ApplicationHandler) DiagsDisplayDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - diagid := vars["diagid"] - - request := &diags.GetDiagRequest{ - Id: diagid, - } - - resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - g := r.Context().Value(identification.GroupKey) - if g == nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - - documents := h.filestorage.List(filestorage.PREFIX_DIAGS + "/" + diagid) - - events_file_types := h.config.GetStringSlice("modules.diags.documents_types") - file_types_map := h.config.GetStringMapString("storage.files.file_types") - - h.Renderer.DiagsDisplayDiag(w, r, resp.Diag.ToStorageType(), events_file_types, file_types_map, documents) -} - -func parseDiagsForm(r *http.Request) (*DiagsForm, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - formData := &DiagsForm{ - Name: r.PostFormValue("name"), - Namespace: r.PostFormValue("namespace"), // Récupère le namespace - JsonSchema: r.PostFormValue("json_schema"), - UiSchema: r.PostFormValue("ui_schema"), - Deleted: false, - } - - if formData.Name == "" || formData.Namespace == "" { - return nil, errors.New("missing required fields: 'name' or 'namespace'") - } - - // Gestion de la valeur JSON dans `data` - if rawData := r.PostFormValue("data"); rawData != "" { - data := map[string]any{} - if err := json.Unmarshal([]byte(rawData), &data); err != nil { - return nil, errors.New("invalid 'data' field: must be a valid JSON object") - } - formData.Data = data - } - - return formData, nil -} - -func (h *ApplicationHandler) DiagUpdate(w http.ResponseWriter, r *http.Request) { - adm := strings.Split(r.URL.Path, "/") - diagID := adm[3] - request := &diags.GetDiagRequest{ - Id: diagID, - } - - resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - 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) - - diagForm, err := parseDiagsForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, _ := structpb.NewStruct(map[string]any{}) - - request := &diags.UpdateDiagRequest{ - Diag: &diags.Diag{ - Namespace: diagForm.Namespace, - Id: diagID, - Name: diagForm.Name, - JsonSchema: diagForm.JsonSchema, - UiSchema: diagForm.UiSchema, - Data: data, - Diagdate: timestamppb.New(time.Now()), - Owners: []string{group.ID}, - }, - } - - resp, err := h.services.GRPC.Diags.UpdateDiag(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound) - return - } - h.Renderer.DiagUpdate(w, r, resp.Diag.ToStorageType()) -} - -func (h *ApplicationHandler) DiagDelete(w http.ResponseWriter, r *http.Request) { - - vars := mux.Vars(r) - diagID := vars["diagid"] - request := &diags.GetDiagRequest{ - Id: diagID, - } - - resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - - request := &diags.UpdateDiagRequest{ - Diag: &diags.Diag{ - Namespace: resp.Diag.Namespace, - Id: resp.Diag.Id, - Name: resp.Diag.Name, - JsonSchema: resp.Diag.JsonSchema, - UiSchema: resp.Diag.UiSchema, - Data: resp.Diag.Data, - Deleted: true, - Diagdate: resp.Diag.Diagdate, - }, - } - - _, err := h.services.GRPC.Diags.UpdateDiag(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, "/app/diags/", http.StatusFound) - return - } - h.Renderer.DiagDelete(w, r, resp.Diag.ToStorageType()) -} - -func (h *ApplicationHandler) DiagsHistoryDiag(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - diagId := vars["diagid"] - request := &diags.GetDiagRequest{ - Id: diagId, - } - - resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - h.Renderer.DiagsHistoryDiag(w, r, resp.Diag.ToStorageType()) -} - -// //// ADD DOCUMENTS ////// -func (h *ApplicationHandler) DiagsDocuments(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - diagID := vars["diagid"] - - //r.ParseForm() - r.ParseMultipartForm(100 * 1024 * 1024) - - document_type := r.FormValue("type") - document_name := r.FormValue("name") - - file, header, err := r.FormFile("file-upload") - if err != nil { - log.Error().Err(err).Msg("") - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": document_type, - "name": document_name, - } - - if err := h.filestorage.Put(file, filestorage.PREFIX_DIAGS, fmt.Sprintf("%s/%s_%s", diagID, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", diagID), http.StatusFound) - -} - -func (h *ApplicationHandler) DiagsDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - diagID := vars["diagid"] - document := vars["document"] - - file, info, err := h.filestorage.Get(filestorage.PREFIX_DIAGS, fmt.Sprintf("%s/%s", diagID, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", diagID), http.StatusFound) - -} diff --git a/handlers/application/directory.go b/handlers/application/directory.go deleted file mode 100755 index d58478f..0000000 --- a/handlers/application/directory.go +++ /dev/null @@ -1,7 +0,0 @@ -package application - -import "net/http" - -func (h *ApplicationHandler) DirectoryHome(w http.ResponseWriter, r *http.Request) { - h.Renderer.DirectoryHome(w, r) -} diff --git a/handlers/application/group.go b/handlers/application/group.go deleted file mode 100755 index 5227b03..0000000 --- a/handlers/application/group.go +++ /dev/null @@ -1,130 +0,0 @@ -package application - -import ( - "context" - "crypto/rand" - "encoding/base64" - "io" - "net/http" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "git.coopgo.io/coopgo-platform/groups-management/storage" - accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "github.com/rs/zerolog/log" -) - -func (h *ApplicationHandler) GroupSettingsDisplay(w http.ResponseWriter, r *http.Request) { - g := r.Context().Value(identification.GroupKey) - if g == nil { - w.WriteHeader(http.StatusBadRequest) - return - } - - group := g.(storage.Group) - - members, err := h.members() - if err != nil { - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - admins := []any{} - groupMembers := []any{} - - for _, m := range members { - mm := m.ToStorageType() - for _, g := range mm.Data["groups"].([]any) { - if g.(string) == group.ID { - groupMembers = append(groupMembers, mm) - } - if g.(string) == group.ID+":admin" { - admins = append(admins, mm) - } - } - } - - h.Renderer.GroupSettingsDisplay(w, r, group, groupMembers, admins) -} - -func (h *ApplicationHandler) GroupSettingsInviteMember(w http.ResponseWriter, r *http.Request) { - g := r.Context().Value(identification.GroupKey) - if g == nil { - w.WriteHeader(http.StatusBadRequest) - return - } - - group := g.(storage.Group) - - r.ParseForm() - - accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{ - Username: r.FormValue("username"), - Namespace: "parcoursmob", - }) - - if err == nil { - // Account already exists : adding the existing account to admin list - account := accountresp.Account.ToStorageType() - //account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid) - account.Data["groups"] = append(account.Data["groups"].([]any), group.ID) - - as, _ := accounts.AccountFromStorageType(&account) - - _, err = h.services.GRPC.MobilityAccounts.UpdateData( - context.TODO(), - &accounts.UpdateDataRequest{ - Account: as, - }, - ) - - if err != nil { - log.Error().Err(err).Msg("") - } - - data := map[string]any{ - "group": group.Data["name"], - } - - if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("") - } - - http.Redirect(w, r, "/app/group/settings", http.StatusFound) - return - } else { - // Onboard now administrator - onboarding := map[string]any{ - "username": r.FormValue("username"), - "group": group.ID, - "admin": false, - } - - b := make([]byte, 16) - if _, err := io.ReadFull(rand.Reader, b); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - key := base64.RawURLEncoding.EncodeToString(b) - - h.cache.PutWithTTL("onboarding/"+key, onboarding, 72*time.Hour) - - data := map[string]any{ - "group": group.Data["name"], - "key": key, - } - - if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - http.Redirect(w, r, "/app/group/settings", http.StatusFound) - return -} diff --git a/handlers/application/group_module.go b/handlers/application/group_module.go deleted file mode 100755 index 6291a5b..0000000 --- a/handlers/application/group_module.go +++ /dev/null @@ -1,220 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "net/http" - "sort" - "strings" - "time" - - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" -) - -var Addres any - -type BeneficiariesGroupForm struct { - FirstName string `json:"first_name" validate:"required"` - LastName string `json:"last_name" validate:"required"` - Email string `json:"email" validate:"required,email"` - Birthdate *time.Time `json:"birthdate"` - PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` - Address any `json:"address,omitempty"` - Gender string `json:"gender"` -} - -type GroupsModuleByName []groupstorage.Group - -func (a GroupsModuleByName) Len() int { return len(a) } -func (a GroupsModuleByName) Less(i, j int) bool { - return strings.Compare(a[i].Data["name"].(string), a[j].Data["name"].(string)) < 0 -} -func (a GroupsModuleByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -func (h *ApplicationHandler) Groups(w http.ResponseWriter, r *http.Request) { - - request := &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_groups"}, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - var groups = []groupstorage.Group{} - - for _, group := range resp.Groups { - g := group.ToStorageType() - groups = append(groups, g) - } - - sort.Sort(GroupsModuleByName(groups)) - - h.Renderer.Groups(w, r, groups) -} - -func (h *ApplicationHandler) CreateGroupModule(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - Addres = a - } - r.ParseForm() - - if r.FormValue("name") == "" { - log.Error().Msg("Invalid name") - w.WriteHeader(http.StatusBadRequest) - return - } - if r.FormValue("type") == "" { - log.Error().Msg("Invalid type") - w.WriteHeader(http.StatusBadRequest) - return - } - - groupid := uuid.NewString() - - dataMap := map[string]any{ - "name": r.FormValue("name"), - "type": r.FormValue("type"), - "description": r.FormValue("description"), - "address": Addres, - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request_organization := &groupsmanagement.AddGroupRequest{ - Group: &groupsmanagement.Group{ - Id: groupid, - Namespace: "parcoursmob_groups", - Data: data.GetStructValue(), - }, - } - - _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/group_module/groups/%s", groupid), http.StatusFound) - return - } - group_types := h.config.GetStringSlice("modules.groups.group_types") - h.Renderer.CreateGroupModule(w, r, group_types) -} - -func filterAcccount(r *http.Request, a *mobilityaccounts.Account) bool { - searchFilter, ok := r.URL.Query()["search"] - - if ok && len(searchFilter[0]) > 0 { - name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) - if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter[0])) { - return false - } - } - - return true -} -func (h *ApplicationHandler) DisplayGroupModule(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - groupid := vars["groupid"] - - request := &groupsmanagement.GetGroupRequest{ - Id: groupid, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - var accounts = []any{} - - requesst := &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: resp.Group.Members, - } - - ressp, _ := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), requesst) - // if err != nil { - // return err - // } - for _, account := range ressp.Accounts { - if filterAcccount(r, account) { - a := account.ToStorageType() - accounts = append(accounts, a) - } - } - - cacheid := uuid.NewString() - h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour) - r.ParseForm() - - var beneficiary any - - searched := false - - // if r.Method == "POST" { - if r.FormValue("beneficiaryid") != "" { - // Handler form - searched = true - - requestbeneficiary := &mobilityaccounts.GetAccountRequest{ - Id: r.FormValue("beneficiaryid"), - } - - respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiary = respbeneficiary.Account.ToStorageType() - - subscribe := &groupsmanagement.SubscribeRequest{ - Groupid: resp.Group.ToStorageType().ID, - Memberid: respbeneficiary.Account.Id, - } - - _, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/group_module/groups/%s", resp.Group.ToStorageType().ID), http.StatusFound) - return - } - - accountsBeneficaire, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - //h.Renderer.BeneficaireSearch(w, r, accounts, searched, beneficiary, resp.Group.ToStorageType()) - h.Renderer.DisplayGroupModule(w, r, resp.Group.ToStorageType().ID, accounts, cacheid, searched, beneficiary, resp.Group.ToStorageType(), accountsBeneficaire) -} diff --git a/handlers/application/journeys.go b/handlers/application/journeys.go deleted file mode 100755 index ba981c7..0000000 --- a/handlers/application/journeys.go +++ /dev/null @@ -1,709 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "net/http" - "slices" - "sort" - "strconv" - "strings" - "sync" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - carpoolproto "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" - 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" - groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "git.coopgo.io/coopgo-platform/multimodal-routing/libs/transit/transitous" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/paulmach/orb/geojson" - "github.com/rs/zerolog/log" - - //"gitlab.scity.coop/maas/navitia-golang" - //"gitlab.scity.coop/maas/navitia-golang/types" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -var ( - Depart any - Arrive any -) - -func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - var ( - transit_results []*transitous.Itinerary - carpool_results []*geojson.FeatureCollection - vehicle_results []fleetsstorage.Vehicle - ) - // availableDrivers := []mobilityaccountsstorage.Account{} - drivers := map[string]mobilityaccountsstorage.Account{} - driverJourneys := []*gen.SolidarityTransportDriverJourney{} - var organizedCarpools []*carpoolproto.CarpoolServiceDriverJourney - // navitiaCh := make(chan *navitia.JourneyResults, 1) - // carpoolCh := make(chan []any, 1) - locTime, errTime := time.LoadLocation("Europe/Paris") - if errTime != nil { - log.Panic().Err(errTime).Msg("Tried to load timezone location Europe/Paris. Error. Missing zones in container ?") - } - - departuredate := r.FormValue("departuredate") - departuretime := r.FormValue("departuretime") - departuredatetime, _ := time.ParseInLocation("2006-01-02 15:04", fmt.Sprintf("%s %s", departuredate, departuretime), locTime) - - departure := r.FormValue("departure") - destination := r.FormValue("destination") - kb_results := []any{} - - passengerid := r.FormValue("passengerid") - solidarityTransportExcludeDriver := r.FormValue("solidarity_transport_exclude_driver") - - var ( - departuregeo *geojson.Feature - destinationgeo *geojson.Feature - // journeys *navitia.JourneyResults - // carpoolresults []any - ) - - if departure == "" && passengerid != "" { - log.Debug().Msg("departure empty and passengerid set") - p, err := h.services.GetAccount(passengerid) - if err != nil { - log.Error().Err(err).Msg("could not retrieve passenger") - w.WriteHeader(http.StatusNotFound) - return - } - departureBytes, err := json.Marshal(p.Data["address"]) - if err != nil { - log.Error().Err(err).Any("address", p.Data["address"]).Msg("could not marshal address") - } else { - departuregeo, err = geojson.UnmarshalFeature(departureBytes) - } - } - - var err error - searched := false - if departure != "" { - log.Debug().Str("departure", departure).Msg("departure value") - departuregeo, err = geojson.UnmarshalFeature([]byte(departure)) - if err != nil { - log.Error().Err(err).Msg("error unmarshalling departure") - w.WriteHeader(http.StatusBadRequest) - return - } - - } - - if destination != "" { - destinationgeo, err = geojson.UnmarshalFeature([]byte(destination)) - if err != nil { - log.Error().Err(err).Msg("error unmarshalling destination") - w.WriteHeader(http.StatusBadRequest) - return - } - } - - if departuredate != "" && departuretime != "" && departure != "" && destination != "" { - searched = true - - // SOLIDARITY TRANSPORT - drivers, err = h.services.GetAccountsInNamespacesMap([]string{"solidarity_drivers", "organized_carpool_drivers"}) - if err != nil { - drivers = map[string]mobilityaccountsstorage.Account{} - } - - protodep, _ := transformers.GeoJsonToProto(departuregeo) - protodest, _ := transformers.GeoJsonToProto(destinationgeo) - - log.Debug().Time("departure time", departuredatetime).Msg("calling driver journeys with ...") - - res, err := h.services.GRPC.SolidarityTransport.GetDriverJourneys(context.Background(), &gen.GetDriverJourneysRequest{ - Departure: protodep, - Arrival: protodest, - DepartureDate: timestamppb.New(departuredatetime), - }) - if err != nil { - log.Error().Err(err).Msg("error in grpc call to GetDriverJourneys") - } else { - driverJourneys = slices.Collect(func(yield func(*gen.SolidarityTransportDriverJourney) bool) { - for _, dj := range res.DriverJourneys { - if a, ok := drivers[dj.DriverId].Data["archived"]; ok { - if archived, ok := a.(bool); ok { - if archived { - continue - } - } - } - if dj.DriverId == solidarityTransportExcludeDriver { - continue - } - if !yield(dj) { - return - } - } - }) - // res.DriverJourneys - sort.Slice(driverJourneys, func(i, j int) bool { - return driverJourneys[i].DriverDistance < driverJourneys[j].DriverDistance - }) - } - - // Get departure and destination addresses from properties - var departureAddress, destinationAddress string - if departuregeo.Properties != nil { - if label, ok := departuregeo.Properties["label"].(string); ok { - departureAddress = label - } - } - if destinationgeo.Properties != nil { - if label, ok := destinationgeo.Properties["label"].(string); ok { - destinationAddress = label - } - } - - // ORGANIZED CARPOOL - organizedCarpoolsRes, err := h.services.GRPC.CarpoolService.DriverJourneys(context.Background(), &carpoolproto.DriverJourneysRequest{ - DepartureLat: departuregeo.Point().Lat(), - DepartureLng: departuregeo.Point().Lon(), - ArrivalLat: destinationgeo.Point().Lat(), - ArrivalLng: destinationgeo.Point().Lon(), - DepartureDate: timestamppb.New(departuredatetime), - DepartureAddress: &departureAddress, - ArrivalAddress: &destinationAddress, - }) - if err != nil { - log.Error().Err(err).Msg("error retrieving organized carpools") - } else { - organizedCarpools = organizedCarpoolsRes.DriverJourneys - sort.Slice(organizedCarpools, func(i, j int) bool { - return *organizedCarpools[i].Distance < *organizedCarpools[j].Distance - }) - } - - var wg sync.WaitGroup - // CARPOOL OPERATORS - carpools := make(chan *geojson.FeatureCollection) - go h.services.InteropCarpool.Search(carpools, *departuregeo, *destinationgeo, departuredatetime) - wg.Add(1) - go func() { - defer wg.Done() - for c := range carpools { - carpool_results = append(carpool_results, c) - } - }() - - // TRANSIT - transitch := make(chan *transitous.Itinerary) - go func(transitch chan *transitous.Itinerary, departure *geojson.Feature, destination *geojson.Feature, datetime *time.Time) { - defer close(transitch) - response, err := h.services.TransitRouting.PlanWithResponse(context.Background(), &transitous.PlanParams{ - FromPlace: fmt.Sprintf("%f,%f", departure.Point().Lat(), departure.Point().Lon()), - ToPlace: fmt.Sprintf("%f,%f", destination.Point().Lat(), destination.Point().Lon()), - Time: datetime, - }) - if err != nil { - log.Error().Err(err).Msg("error retrieving transit data from Transitous server") - return - } - for _, i := range response.Itineraries { - transitch <- &i - } - }(transitch, departuregeo, destinationgeo, &departuredatetime) - wg.Add(1) - go func() { - defer wg.Done() - for itinerary := range transitch { - transit_results = append(transit_results, itinerary) - } - }() - - // VEHICLES - vehiclech := make(chan fleetsstorage.Vehicle) - go h.vehicleRequest(vehiclech, departuredatetime.Add(-24*time.Hour), departuredatetime.Add(168*time.Hour)) - wg.Add(1) - go func() { - defer wg.Done() - for vehicle := range vehiclech { - vehicle_results = append(vehicle_results, vehicle) - } - slices.SortFunc(vehicle_results, sorting.VehiclesByDistanceFrom(*departuregeo)) - }() - // journeys_results = <-navitiaCh - wg.Wait() - // KNOWLEDGE BASE - departureGeo, _ := h.services.Geography.GeoSearch(departuregeo) - kbData := h.config.Get("knowledge_base") - if kb, ok := kbData.([]any); ok { - log.Debug().Msg("1") - for _, sol := range kb { - log.Debug().Msg("2") - if solution, ok := sol.(map[string]any); ok { - log.Debug().Msg("3") - if g, ok := solution["geography"]; ok { - log.Debug().Msg("4") - if geography, ok := g.([]any); ok { - log.Debug().Msg("5") - for _, gg := range geography { - log.Debug().Msg("6") - if geog, ok := gg.(map[string]any); ok { - log.Debug().Msg("7") - if layer, ok := geog["layer"].(string); ok { - log.Debug().Msg("8") - code := geog["code"] - log.Debug().Any("code", fmt.Sprintf("%s", code)).Any("departure geo", departureGeo[layer].Properties.MustString("code")).Msg("9") - if strings.Compare(fmt.Sprintf("%v", code), departureGeo[layer].Properties.MustString("code")) == 0 { - log.Debug().Msg("10") - kb_results = append(kb_results, solution) - break - } - - } - } - } - } - } - } - } - } - } - - beneficiaries, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("issue retrieving beneficiaries") - w.WriteHeader(http.StatusInternalServerError) - return - } - - h.Renderer.JourneysSearch(w, r, carpool_results, transit_results, vehicle_results, searched, departuregeo, destinationgeo, departuredate, departuretime, driverJourneys, drivers, organizedCarpools, beneficiaries, kb_results, passengerid) -} - -func (h *ApplicationHandler) vehicleRequest(vehiclech chan fleetsstorage.Vehicle, start time.Time, end time.Time) { - defer close(vehiclech) - vehiclerequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - vehicleresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), vehiclerequest) - if err != nil { - log.Error().Err(err).Msg("") - return - } - for _, vehicle := range vehicleresp.Vehicles { - v := vehicle.ToStorageType() - if v.Free(start, end) { - vehiclech <- v - } - } -} - -type GroupsModule []groupstorage.Group - -func (a GroupsModule) Len() int { return len(a) } -func (a GroupsModule) Less(i, j int) bool { - return strings.Compare(a[i].Data["name"].(string), a[j].Data["name"].(string)) < 0 -} -func (a GroupsModule) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -func (h *ApplicationHandler) GroupsGestion(w http.ResponseWriter, r *http.Request) { - request := &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_groups_covoiturage"}, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - groups := []groupstorage.Group{} - - for _, group := range resp.Groups { - g := group.ToStorageType() - groups = append(groups, g) - } - - cacheid := uuid.NewString() - - sort.Sort(GroupsModule(groups)) - h.cache.PutWithTTL(cacheid, groups, 1*time.Hour) - - h.Renderer.GroupsGestion(w, r, groups, cacheid) -} - -func filterAcc(r *http.Request, a *mobilityaccounts.Account) bool { - searchFilter, ok := r.URL.Query()["search"] - - if ok && len(searchFilter[0]) > 0 { - name := a.Data.AsMap()["first_name"].(string) + " " + a.Data.AsMap()["last_name"].(string) - if !strings.Contains(strings.ToLower(name), strings.ToLower(searchFilter[0])) { - return false - } - } - - return true -} - -func (h *ApplicationHandler) CreateGroup(w http.ResponseWriter, r *http.Request) { - var beneficiary any - var ( - departurgeo *geojson.Feature - dstinationgeo *geojson.Feature - ) - searched := false - - if r.FormValue("beneficiaryid") != "" { - - searched = true - - requestbeneficiary := &mobilityaccounts.GetAccountRequest{ - Id: r.FormValue("beneficiaryid"), - } - - respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiary = respbeneficiary.Account.ToStorageType() - - if r.Method == "POST" { - departure := r.FormValue("departure") - destination := r.FormValue("destination") - - if departure != "" && destination != "" { - - var err error - - departurgeo, err = geojson.UnmarshalFeature([]byte(departure)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - dstinationgeo, err = geojson.UnmarshalFeature([]byte(destination)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - } - if r.FormValue("departure") != "" { - var a any - json.Unmarshal([]byte(r.FormValue("departure")), &a) - - Depart = a - } - if r.FormValue("destination") != "" { - var a any - json.Unmarshal([]byte(r.FormValue("destination")), &a) - - Arrive = a - } - r.ParseForm() - - if r.FormValue("name") == "" { - - log.Error().Msg("invalid name") - w.WriteHeader(http.StatusBadRequest) - return - } - - if r.FormValue("number") == "" { - - log.Error().Msg("invalid number of personne") - w.WriteHeader(http.StatusBadRequest) - return - } - - planDays := map[string]any{ - "lundi": r.FormValue("lundi") == "on", - "mardi": r.FormValue("mardi") == "on", - "mercredi": r.FormValue("mercredi") == "on", - "jeudi": r.FormValue("jeudi") == "on", - "vendredi": r.FormValue("vendredi") == "on", - "samedi": r.FormValue("samedi") == "on", - "dimanche": r.FormValue("dimanche") == "on", - } - - groupidd := uuid.NewString() - - dataMap := map[string]any{ - "name": r.FormValue("name"), - "number": r.FormValue("number"), - "driver_first_name": respbeneficiary.Account.ToStorageType().Data["first_name"], - "driver_last_name": respbeneficiary.Account.ToStorageType().Data["last_name"], - "depart": Depart, - "arrive": Arrive, - "departdate": r.FormValue("departdate"), - "date": r.FormValue("date"), - "enddate": r.FormValue("enddate"), - "departtime": r.FormValue("departtime"), - "time": r.FormValue("time"), - - "planDays": planDays, - "recurrent": r.FormValue("recurrent"), - "pontuelle": r.FormValue("ponctuelle"), - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request_organization := &groupsmanagement.AddGroupRequest{ - Group: &groupsmanagement.Group{ - Id: groupidd, - Namespace: "parcoursmob_groups_covoiturage", - Data: data.GetStructValue(), - }, - } - - _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", request_organization.Group.ToStorageType().ID), http.StatusFound) - - return - } - } - accountsBeneficaire, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - h.Renderer.CreateGroup(w, r, Depart, Arrive, searched, beneficiary, accountsBeneficaire, departurgeo, dstinationgeo) -} - -func (h *ApplicationHandler) DisplayGroupCovoiturage(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - groupid := vars["groupid"] - - request := &groupsmanagement.GetGroupRequest{ - Id: groupid, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - accounts := []any{} - - requesst := &mobilityaccounts.GetAccountsBatchRequest{ - Accountids: resp.Group.Members, - } - - ressp, _ := h.services.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), requesst) - - for _, account := range ressp.Accounts { - if filterAcc(r, account) { - a := account.ToStorageType() - accounts = append(accounts, a) - } - } - - cacheid := uuid.NewString() - h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour) - r.ParseForm() - - var beneficiary any - searched := false - - if r.FormValue("beneficiaryid") != "" { - - searched = true - - requestbeneficiary := &mobilityaccounts.GetAccountRequest{ - Id: r.FormValue("beneficiaryid"), - } - - respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiary = respbeneficiary.Account.ToStorageType() - - subscribe := &groupsmanagement.SubscribeRequest{ - Groupid: resp.Group.ToStorageType().ID, - Memberid: respbeneficiary.Account.Id, - } - - _, err = h.services.GRPC.GroupsManagement.Subscribe(context.TODO(), subscribe) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - /*******************Code to store more information about mermbers groupscovoiturage**************/ - if r.FormValue("departure") != "" { - var a any - json.Unmarshal([]byte(r.FormValue("departure")), &a) - - Depart = a - } - if r.FormValue("destination") != "" { - var a any - json.Unmarshal([]byte(r.FormValue("destination")), &a) - - Arrive = a - } - r.ParseForm() - dataMap := map[string]any{ - "depart": Depart, - "arrive": Arrive, - } - id := uuid.NewString() - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request_organizatio := &groupsmanagement.AddGroupMemberRequest{ - Group: &groupsmanagement.GroupMember{ - Id: id, - Memberid: respbeneficiary.Account.Id, - Groupid: resp.Group.ToStorageType().ID, - Data: data.GetStructValue(), - }, - } - - _, err = h.services.GRPC.GroupsManagement.AddGroupMember(context.TODO(), request_organizatio) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", resp.Group.ToStorageType().ID), http.StatusFound) - return - } - //////////find all groups to store the adresse passenger/////// - // grp := &groupsmanagement.GetGroupsBatchMemberRequest{ - - // Groupids: []string{resp.Group.ToStorageType().ID}, - // } - // s, err := h.services.GRPC.GroupsManagement.GetGroupsBatchMember(context.TODO(), grp) - // if err != nil { - // log.Error().Err(err).Msg("") - // w.WriteHeader(http.StatusInternalServerError) - // return - // } - // groups := map[string]any{} - - // if err == nil { - // for _, g := range s.Groups { - // groups[g.Memberid] = g.ToStorageType() - // } - // } - //////////find all groups to store the adresse passenger/////// - ///////////try to optimise the code //////////////////////////// - groups, _ := h.services.GetGroupsMemberMap(resp.Group.ToStorageType().ID) - var number string = strconv.Itoa(len(resp.Group.Members)) - accountsBeneficaire, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - h.Renderer.DisplayGroupCovoiturage(w, r, number, resp.Group.ToStorageType().ID, Depart, Arrive, accounts, cacheid, searched, beneficiary, resp.Group.ToStorageType(), accountsBeneficaire, groups) -} - -func (h *ApplicationHandler) UpdateGroupCovoiturage(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - id := vars["id"] - groupid := vars["groupid"] - memberid := vars["memberid"] - - if r.Method == "POST" { - - //////////get groupid covoiturage////////// - request := &groupsmanagement.GetGroupRequest{ - Id: groupid, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - //////////////////////////get group member//////////////////////////////// - - reequest := &groupsmanagement.GetGroupMemberRequest{ - Id: id, - } - - ressp, err := h.services.GRPC.GroupsManagement.GetGroupMember(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - req := &groupsmanagement.UnsubscribeMemberRequest{ - Id: ressp.Group.Id, - } - - _, errr := h.services.GRPC.GroupsManagement.UnsubscribeMember(context.TODO(), req) - if errr != nil { - log.Error().Err(errr).Msg("Issue in groups management service - InsubscribeMember") - w.WriteHeader(http.StatusInternalServerError) - return - } - - members := resp.Group.Members - for i := 0; i < len(members); i++ { - if members[i] == memberid { - members = append(members[:i], members[(i+1):]...) - resp.Group.Members = members - reequest := &groupsmanagement.UnsubscribeRequest{ - Groupid: resp.Group.ToStorageType().ID, - Memberid: memberid, - } - - _, err := h.services.GRPC.GroupsManagement.Unsubscribe(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - http.Redirect(w, r, fmt.Sprintf("/app/journeys/groups_covoiturage/create/%s", groupid), http.StatusFound) - /* - I must add "return" to resolve the err - http: superfluous response.WriteHeader call from git.coopgo.io/coopgo-apps/parcoursmob/renderer.(*Renderer).Render (renderer.go:50) - */ - return - } - h.Renderer.UpdateGroupCovoiturage(w, r, groupid, memberid) -} diff --git a/handlers/application/members.go b/handlers/application/members.go deleted file mode 100755 index a9b6682..0000000 --- a/handlers/application/members.go +++ /dev/null @@ -1,214 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "net/http" - "strings" - "time" - - formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators" - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "github.com/google/uuid" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" -) - -type UserForm struct { - FirstName string `json:"first_name" validate:"required"` - LastName string `json:"last_name" validate:"required"` - Email string `json:"email" validate:"required,email"` - PhoneNumber string `json:"phone_number" ` - Address any `json:"address,omitempty"` - Gender string `json:"gender"` -} - -func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Request) { - - adm := strings.Split(r.URL.Path, "/") - adminid := adm[3] - - request := &mobilityaccounts.GetAccountRequest{ - Id: adminid, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - //////////////////////////////////add organisations///////////////////////////////////////////////// - - var allIds []string - for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) { - s := fmt.Sprintf("%v", v) - if !(strings.Contains(s, "admin")) { - allIds = append(allIds, s) - } - } - reques := &groupsmanagement.GetGroupsBatchRequest{ - Groupids: allIds, - } - - res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - var groupsName []string - - for _, group := range res.Groups { - g := fmt.Sprintf("%v", group.ToStorageType().Data["name"]) - groupsName = append(groupsName, g) - } - - h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType(), groupsName) -} - -func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request) { - adm := strings.Split(r.URL.Path, "/") - userID := adm[3] - - if r.Method == "POST" { - - dataMap, err := parseUserForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: userID, - Namespace: "parcoursmob", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/members/%s", resp.Account.Id), http.StatusFound) - - return - } - - request := &mobilityaccounts.GetAccountRequest{ - Id: userID, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - h.Renderer.MemberUpdate(w, r, resp.Account.ToStorageType()) -} - -func parseUserForm(r *http.Request) (map[string]any, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - formData := UserForm{ - FirstName: r.PostFormValue("first_name"), - LastName: r.PostFormValue("last_name"), - Email: r.PostFormValue("email"), - PhoneNumber: r.PostFormValue("phone_number"), - Gender: r.PostFormValue("gender"), - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - d, err := json.Marshal(formData) - if err != nil { - return nil, err - } - - var dataMap map[string]any - err = json.Unmarshal(d, &dataMap) - if err != nil { - return nil, err - } - - return dataMap, nil -} - -func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request) { - - accounts, err := h.services.GetAccounts() - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - var groupsName []string - - for _, v := range accounts { - adminid := v.ID - request := &mobilityaccounts.GetAccountRequest{ - Id: adminid, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - //////////////////////////////////add organisations///////////////////////////////////////////////// - - var allIds []string - for _, v := range resp.Account.ToStorageType().Data["groups"].([]any) { - s := fmt.Sprintf("%v", v) - if !(strings.Contains(s, "admin")) { - allIds = append(allIds, s) - } - - } - - reques := &groupsmanagement.GetGroupsBatchRequest{ - Groupids: allIds, - } - - res, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), reques) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - g := "" - for _, group := range res.Groups { - g += fmt.Sprintf("%v", group.ToStorageType().Data["name"]) + " " - } - groupsName = append(groupsName, g) - - } - cacheid := uuid.NewString() - h.cache.PutWithTTL(cacheid, accounts, 1*time.Hour) - - h.Renderer.MembersList(w, r, accounts, cacheid, groupsName) -} diff --git a/handlers/application/organized-carpool.go b/handlers/application/organized-carpool.go deleted file mode 100644 index f38ef46..0000000 --- a/handlers/application/organized-carpool.go +++ /dev/null @@ -1,999 +0,0 @@ -package application - -import ( - "cmp" - "context" - "encoding/json" - "fmt" - "io" - "net/http" - "slices" - "strings" - "time" - - formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" - mobilityaccounts "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" - "github.com/paulmach/orb" - "github.com/paulmach/orb/geojson" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -type OrganizedCarpoolDriversForm struct { - FirstName string `json:"first_name" validate:"required"` - LastName string `json:"last_name" validate:"required"` - Email string `json:"email" validate:"required,email"` - Birthdate *time.Time `json:"birthdate" validate:"required"` - PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` - FileNumber string `json:"file_number"` - Address any `json:"address,omitempty"` - AddressDestination any `json:"address_destination,omitempty"` - Gender string `json:"gender"` -} - -func (h *ApplicationHandler) OrganizedCarpoolOverview(w http.ResponseWriter, r *http.Request) { - accounts, err := h.organizedCarpoolDrivers(r) - if err != nil { - log.Error().Err(err).Msg("issue getting solidarity drivers") - accounts = []mobilityaccountsstorage.Account{} - } - - accountsMap := map[string]mobilityaccountsstorage.Account{} - - for _, a := range accounts { - accountsMap[a.ID] = a - } - - beneficiariesMap, err := h.services.GetBeneficiariesMap() - if err != nil { - beneficiariesMap = map[string]mobilityaccountsstorage.Account{} - } - - bookingsproto, err := h.services.GRPC.CarpoolService.GetCarpoolBookings(context.Background(), &proto.GetCarpoolBookingsRequest{ - MinDate: timestamppb.Now(), - MaxDate: timestamppb.New(time.Now().Add(24 * 365 * time.Hour)), - }) - if err != nil { - log.Error().Err(err).Msg("issue retreving bookings") - } - - bookings := []*proto.CarpoolServiceBooking{} - - if err == nil { - for _, b := range bookingsproto.Bookings { - bookings = append(bookings, b) - } - } - - slices.SortFunc(accounts, func(a, b mobilityaccountsstorage.Account) int { - return strings.Compare( - strings.ToLower(fmt.Sprintf("%s %s", a.Data["first_name"].(string), a.Data["last_name"].(string))), - strings.ToLower(fmt.Sprintf("%s %s", b.Data["first_name"].(string), b.Data["last_name"].(string))), - ) - }) - slices.SortFunc(bookings, func(a, b *proto.CarpoolServiceBooking) int { - return cmp.Compare(a.PassengerPickupDate.AsTime().Unix(), b.PassengerPickupDate.AsTime().Unix()) - }) - - h.Renderer.OrganizedCarpoolOverview(w, r, accounts, accountsMap, beneficiariesMap, bookings) -} - -func (h *ApplicationHandler) OrganizedCarpoolBookingDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingId := vars["bookingid"] - - resp, err := h.services.GRPC.CarpoolService.GetBooking(context.Background(), &proto.GetCarpoolBookingRequest{ - BookingId: bookingId, - }) - if err != nil { - log.Error().Err(err).Msg("could not get carpool booking") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if resp.Booking == nil { - log.Error().Msg("carpool booking not found") - w.WriteHeader(http.StatusNotFound) - return - } - - driver, err := h.services.GetAccount(resp.Booking.Driver.Id) - if err != nil { - log.Error().Err(err).Msg("driver retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - passenger, err := h.services.GetAccount(resp.Booking.Passenger.Id) - if err != nil { - log.Error().Err(err).Msg("passenger retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // Extract driver departure and arrival addresses from DriverRoute GeoJSON - var driverDepartureAddress, driverArrivalAddress string - if resp.Booking.DriverRoute != nil && resp.Booking.DriverRoute.Serialized != "" { - fc, err := geojson.UnmarshalFeatureCollection([]byte(resp.Booking.DriverRoute.Serialized)) - if err != nil { - log.Error().Err(err).Msg("could not unmarshal driver route geojson") - } else { - // Extract departure address (first feature) - if len(fc.Features) > 0 { - if addr, ok := fc.Features[0].Properties["label"]; ok { - if addrStr, ok := addr.(string); ok { - driverDepartureAddress = addrStr - } - } - } - // Extract arrival address (last feature) - if len(fc.Features) > 1 { - if addr, ok := fc.Features[1].Properties["label"]; ok { - if addrStr, ok := addr.(string); ok { - driverArrivalAddress = addrStr - } - } - } - } - } - - h.Renderer.OrganizedCarpoolBookingDisplay(w, r, resp.Booking, driver, passenger, driverDepartureAddress, driverArrivalAddress) -} - -func (h *ApplicationHandler) OrganizedCarpoolBookingStatus(action string) func(w http.ResponseWriter, r *http.Request) { - return func(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingId := vars["bookingid"] - - var status proto.CarpoolServiceBookingStatus - if action == "confirm" { - status = proto.CarpoolServiceBookingStatus_CONFIRMED - } else if action == "cancel" { - status = proto.CarpoolServiceBookingStatus_CANCELLED - } else if action == "waitconfirmation" { - status = proto.CarpoolServiceBookingStatus_WAITING_DRIVER_CONFIRMATION - } else { - log.Error().Str("action", action).Msg("unknown booking action") - w.WriteHeader(http.StatusBadRequest) - return - } - - _, err := h.services.GRPC.CarpoolService.UpdateBooking(context.Background(), &proto.UpdateCarpoolBookingRequest{ - BookingId: bookingId, - Status: status, - }) - if err != nil { - log.Error().Err(err).Msg("update carpool booking status issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // Redirect back to the booking display page - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/bookings/%s", bookingId), http.StatusSeeOther) - } -} - -func (h *ApplicationHandler) organizedCarpoolDrivers(r *http.Request) ([]mobilityaccountsstorage.Account, error) { - accounts := []mobilityaccountsstorage.Account{} - - request := &mobilityaccounts.GetAccountsRequest{ - Namespaces: []string{"organized_carpool_drivers"}, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), request) - if err != nil { - return accounts, err - } - - for _, account := range resp.Accounts { - if filterAccount(r, account) { - a := account.ToStorageType() - accounts = append(accounts, a) - } - } - - return accounts, err -} - -func (h *ApplicationHandler) OrganizedCarpoolCreateDriver(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - dataMap, err := parseOrganizedCarpoolDriversForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.RegisterRequest{ - Account: &mobilityaccounts.Account{ - Namespace: "organized_carpool_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.Register(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", resp.Account.Id), http.StatusFound) - return - } - - h.Renderer.OrganizedCarpoolCreateDriver(w, r) -} - -func (h *ApplicationHandler) OrganizedCarpoolUpdateDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - driver, err := h.services.GetAccount(driverID) - if err != nil { - log.Error().Err(err).Msg("Issue retrieving driver account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - dataMap, err := parseOrganizedCarpoolDriversUpdateForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "organized_carpool_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", resp.Account.Id), http.StatusFound) - return - } - - h.Renderer.OrganizedCarpoolUpdateDriver(w, r, driver) -} - -func (h *ApplicationHandler) OrganizedCarpoolDriverDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - documents := h.filestorage.List(filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS + "/" + driverID) - - driver, err := h.services.GetAccount(driverID) - if err != nil { - log.Error().Err(err).Msg("Issue retrieving driver account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - log.Info().Any("driver data", driver.Data).Msg("driver retrieved") - - trips := []*geojson.FeatureCollection{} - - resp, err := h.services.GRPC.CarpoolService.GetRegularRoutes(context.Background(), &proto.GetRegularRoutesRequest{ - UserId: driverID, - }) - - for _, r := range resp.Routes { - t, err := geojson.UnmarshalFeatureCollection([]byte(r.Serialized)) - if err != nil { - log.Error().Err(err).Msg("could not unmarshall feature collection") - continue - } - - trips = append(trips, t) - } - - h.Renderer.OrganizedCarpoolDriverDisplay(w, r, driver, trips, documents) -} - -func (h *ApplicationHandler) OrganizedCarpoolArchiveDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - data, _ := structpb.NewValue(map[string]any{ - "archived": true, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "organized_carpool_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolUnarchiveDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - data, _ := structpb.NewValue(map[string]any{ - "archived": false, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "organized_carpool_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolDriverDocuments(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - // r.ParseForm() - r.ParseMultipartForm(100 * 1024 * 1024) - - document_type := r.FormValue("type") - document_name := r.FormValue("name") - - file, header, err := r.FormFile("file-upload") - if err != nil { - log.Error().Err(err).Msg("") - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": document_type, - "name": document_name, - } - - log.Debug().Any("metadata", metadata).Msg("Metadata") - - if err := h.filestorage.Put(file, filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS, fmt.Sprintf("%s/%s_%s", driverID, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - document := vars["document"] - - file, info, err := h.filestorage.Get(filestorage.PREFIX_ORGANIZED_CARPOOL_DRIVERS, fmt.Sprintf("%s/%s", driverID, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolAddTrip(w http.ResponseWriter, r *http.Request) { - if r.Method != "POST" { - log.Error().Msg("Wrong method") - w.WriteHeader(http.StatusMethodNotAllowed) - return - } - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("error parsong availabilities form") - w.WriteHeader(http.StatusInternalServerError) - return - } - - vars := mux.Vars(r) - driverID := vars["driverid"] - - trips := []*proto.CarpoolFeatureCollection{} - - outwardtime := r.PostFormValue("outwardtime") - returntime := r.PostFormValue("returntime") - dep := r.PostFormValue("address_departure") - dest := r.PostFormValue("address_destination") - - departure, err := geojson.UnmarshalFeature([]byte(dep)) - if err != nil { - log.Error().Err(err).Msg("failed parsong departure geojson") - w.WriteHeader(http.StatusInternalServerError) - return - } - destination, err := geojson.UnmarshalFeature([]byte(dest)) - if err != nil { - log.Error().Err(err).Msg("failed parsong departure geojson") - w.WriteHeader(http.StatusInternalServerError) - return - } - - outwardroute, err := h.services.Routing.Route([]orb.Point{departure.Point(), destination.Point()}) - if err != nil { - log.Error().Err(err).Msg("failed calling route search") - w.WriteHeader(http.StatusInternalServerError) - return - } - returnroute, err := h.services.Routing.Route([]orb.Point{destination.Point(), departure.Point()}) - if err != nil { - log.Error().Err(err).Msg("failed calling route search") - w.WriteHeader(http.StatusInternalServerError) - return - } - - outwardschedules := []map[string]any{} - returnschedules := []map[string]any{} - - if r.PostFormValue("days.monday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "MON", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "MON", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.tuesday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "TUE", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "TUE", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.wednesday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "WED", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "WED", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.thursday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "THU", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "THU", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.friday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "FRI", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "FRI", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.saturday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "SAT", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "SAT", - "time_of_day": returntime, - }) - } - if r.PostFormValue("days.sunday") == "on" { - outwardschedules = append(outwardschedules, map[string]any{ - "day": "SUN", - "time_of_day": outwardtime, - }) - returnschedules = append(returnschedules, map[string]any{ - "day": "SUN", - "time_of_day": returntime, - }) - } - - outward_fc := geojson.NewFeatureCollection() - outward_fc.Append(departure) - outward_fc.Append(destination) - outward_fc.ExtraMembers = geojson.Properties{} - outward_fc.ExtraMembers["properties"] = map[string]any{ - "is_driver": true, - "is_passenger": false, - "user": mobilityaccountsstorage.Account{ - ID: driverID, - }, - "polyline": outwardroute.Summary.Polyline, - "schedules": outwardschedules, - "driver_options": map[string]any{}, - "passenger_options": map[string]any{}, - } - outwardtrip, err := outward_fc.MarshalJSON() - if err != nil { - log.Error().Err(err).Msg("failed parsong return geojson") - w.WriteHeader(http.StatusInternalServerError) - return - } - - return_fc := geojson.NewFeatureCollection() - return_fc.Append(destination) - return_fc.Append(departure) - return_fc.ExtraMembers = geojson.Properties{} - return_fc.ExtraMembers["properties"] = map[string]any{ - "is_driver": true, - "is_passenger": false, - "user": mobilityaccountsstorage.Account{ - ID: driverID, - }, - "polyline": returnroute.Summary.Polyline, - "schedules": returnschedules, - "driver_options": map[string]any{}, - "passenger_options": map[string]any{}, - } - returntrip, err := return_fc.MarshalJSON() - if err != nil { - log.Error().Err(err).Msg("failed parsong return geojson") - w.WriteHeader(http.StatusInternalServerError) - return - } - - trips = append(trips, &proto.CarpoolFeatureCollection{ - Serialized: string(outwardtrip), - }) - trips = append(trips, &proto.CarpoolFeatureCollection{ - Serialized: string(returntrip), - }) - - req := &proto.CreateRegularRoutesRequest{ - Routes: trips, - } - _, err = h.services.GRPC.CarpoolService.CreateRegularRoutes(context.Background(), req) - if err != nil { - log.Error().Err(err).Msg("could not create regular routes") - w.WriteHeader(http.StatusInternalServerError) - return - } - - log.Info().Msg("Finished creating carpool routes") - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolDeleteTrip(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - tripID := vars["tripid"] - - req := &proto.DeleteRegularRoutesRequest{ - Ids: []string{tripID}, - } - - _, err := h.services.GRPC.CarpoolService.DeleteRegularRoutes(context.Background(), req) - if err != nil { - log.Error().Err(err).Msg("could not delete regular routes") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) OrganizedCarpoolJourney(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverId := vars["driverid"] - journeyId := vars["journeyid"] - - var passenger mobilityaccountsstorage.Account - passengerId := r.URL.Query().Get("passengerid") - log.Info().Str("journeyid", journeyId).Str("driverid", driverId).Str("passengerid", passengerId).Msg("organized carpool journey") - - // Get the planned trip data - journeyResp, err := h.services.GRPC.CarpoolService.GetPlannedTrip(context.Background(), &proto.GetPlannedTripRequest{ - Id: journeyId, - }) - if err != nil { - log.Error().Err(err).Msg("could not get carpool journey") - w.WriteHeader(http.StatusNotFound) - return - } - journey, err := geojson.UnmarshalFeatureCollection([]byte(journeyResp.PlannedTrip.Serialized)) - if err != nil { - log.Error().Err(err).Msg("could not unmarshal carpool journey") - w.WriteHeader(http.StatusNotFound) - return - } - - departureDate := journey.ExtraMembers["departure_date"] - var departureTime *timestamppb.Timestamp - if departureDate != nil { - if dd, ok := departureDate.(string); ok { - dt, _ := time.Parse("2006-01-02 15:04", dd) - departureTime = timestamppb.New(dt) - } - } - - // Extract operator from journey data - var operatorID string - if operator, ok := journey.ExtraMembers["operator"]; ok { - if op, ok := operator.(string); ok { - operatorID = op - } - } - if operatorID == "" { - operatorID = "example.coopgo.fr" // fallback to default - } - - if departureTime == nil { - // Fallback to current time if we can't extract departure time - departureTime = timestamppb.New(time.Now()) - } - - if r.Method == "POST" { - if passengerId == "" { - log.Error().Msg("missing passenger ID for carpool booking") - w.WriteHeader(http.StatusBadRequest) - return - } - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("could not parse form input") - w.WriteHeader(http.StatusBadRequest) - return - } - - // Extract journey properties from the geojson data - var journeyProps map[string]any - if props, ok := journey.ExtraMembers["properties"]; ok { - if propsMap, ok := props.(map[string]any); ok { - journeyProps = propsMap - } - } - - if journeyProps == nil { - log.Error().Msg("could not extract journey properties") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // Extract departure date from journey ExtraMembers - if depDate, ok := journey.ExtraMembers["departure_date"]; ok { - if depDateStr, ok := depDate.(string); ok { - if parsedTime, err := time.Parse("2006-01-02T15:04:05Z", depDateStr); err == nil { - departureTime = timestamppb.New(parsedTime) - } else if parsedTime, err := time.Parse("2006-01-02", depDateStr); err == nil { - departureTime = timestamppb.New(parsedTime) - } else { - log.Warn().Str("departure_date", depDateStr).Msg("could not parse departure date, using current time") - } - } - } - - // Extract passenger pickup/drop coordinates and addresses from stored passenger data - var pickupLat, pickupLng, dropLat, dropLng float64 - var pickupAddress, dropAddress string - - // Check if we have passenger pickup and drop features in the journey's extra members - if pickupData, ok := journey.ExtraMembers["passenger_pickup"]; ok { - if pickupMap, ok := pickupData.(map[string]interface{}); ok { - if geometry, ok := pickupMap["geometry"].(map[string]interface{}); ok { - if coords, ok := geometry["coordinates"].([]interface{}); ok && len(coords) >= 2 { - if lng, ok := coords[0].(float64); ok { - pickupLng = lng - } - if lat, ok := coords[1].(float64); ok { - pickupLat = lat - } - } - } - if properties, ok := pickupMap["properties"].(map[string]interface{}); ok { - if label, ok := properties["label"].(string); ok { - pickupAddress = label - } - } - } - } - - if dropData, ok := journey.ExtraMembers["passenger_drop"]; ok { - if dropMap, ok := dropData.(map[string]interface{}); ok { - if geometry, ok := dropMap["geometry"].(map[string]interface{}); ok { - if coords, ok := geometry["coordinates"].([]interface{}); ok && len(coords) >= 2 { - if lng, ok := coords[0].(float64); ok { - dropLng = lng - } - if lat, ok := coords[1].(float64); ok { - dropLat = lat - } - } - } - if properties, ok := dropMap["properties"].(map[string]interface{}); ok { - if label, ok := properties["label"].(string); ok { - dropAddress = label - } - } - } - } - - log.Debug().Str("pickup_address", pickupAddress).Str("drop_address", dropAddress).Msg("Extracted addresses") - - // Extract time from schedules if available and no specific departure_date was found - if departureTime.AsTime().Equal(time.Now().Truncate(time.Second)) { - if schedules, ok := journeyProps["schedules"]; ok { - if schedulesList, ok := schedules.([]any); ok && len(schedulesList) > 0 { - if schedule, ok := schedulesList[0].(map[string]any); ok { - if timeOfDay, ok := schedule["time_of_day"].(string); ok { - // Parse time and combine with current date - now := time.Now() - timeStr := fmt.Sprintf("%s %s", now.Format("2006-01-02"), timeOfDay) - if depTime, err := time.Parse("2006-01-02 15:04", timeStr); err == nil { - departureTime = timestamppb.New(depTime) - } - } - } - } - } - } - - motivation := r.PostFormValue("motivation") - - // Create carpool booking using extracted journey data - booking := &proto.CarpoolServiceBooking{ - Id: uuid.NewString(), - Driver: &proto.CarpoolServiceUser{ - Id: driverId, - Operator: operatorID, - }, - Passenger: &proto.CarpoolServiceUser{ - Id: passengerId, - Operator: operatorID, - }, - PassengerPickupDate: departureTime, - PassengerPickupLat: pickupLat, - PassengerPickupLng: pickupLng, - PassengerDropLat: dropLat, - PassengerDropLng: dropLng, - PassengerPickupAddress: &pickupAddress, - PassengerDropAddress: &dropAddress, - Status: proto.CarpoolServiceBookingStatus_WAITING_DRIVER_CONFIRMATION, - DriverJourneyId: journeyId, - } - - bookingRes, err := h.services.GRPC.CarpoolService.CreateBooking(context.Background(), &proto.CreateCarpoolBookingRequest{ - Booking: booking, - }) - if err != nil { - log.Error().Err(err).Msg("cannot create carpool booking") - w.WriteHeader(http.StatusInternalServerError) - return - } - - log.Info().Str("booking_id", bookingRes.Booking.Id).Msg("Carpool booking created successfully") - - // Send SMS notification if requested - message := r.PostFormValue("message") - doNotSend := r.PostFormValue("do_not_send") - if message != "" && doNotSend != "on" { - send_message := strings.ReplaceAll(message, "{booking_id}", bookingRes.Booking.Id) - send_message = strings.ReplaceAll(send_message, "{motivation}", motivation) - log.Debug().Str("message", send_message).Msg("Carpool booking created: sending message") - h.GenerateSMS(driverId, send_message) - } - - http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/"), http.StatusFound) - return - } - - driver, err := h.services.GetAccount(driverId) - if err != nil { - log.Error().Err(err).Msg("could not get driver") - w.WriteHeader(http.StatusNotFound) - return - } - if passengerId != "" { - passenger, err = h.services.GetAccount(passengerId) - if err != nil { - log.Error().Err(err).Msg("could not get account") - w.WriteHeader(http.StatusNotFound) - return - } - } - - beneficiaries, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - h.Renderer.OrganizedCarpoolJourney(w, r, journey, driver, passenger, beneficiaries) -} - -func parseOrganizedCarpoolDriversForm(r *http.Request) (map[string]any, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - log.Info().Any("form content", r.Form).Msg("parsing form") - - var date *time.Time - - if r.PostFormValue("birthdate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) - if err != nil { - return nil, err - } - date = &d - } - - formData := OrganizedCarpoolDriversForm{ - FirstName: r.PostFormValue("first_name"), - LastName: r.PostFormValue("last_name"), - Email: r.PostFormValue("email"), - Birthdate: date, - PhoneNumber: r.PostFormValue("phone_number"), - FileNumber: r.PostFormValue("file_number"), - Gender: r.PostFormValue("gender"), - } - - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - formData.Address = a - } - - if r.PostFormValue("address_destination") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address_destination")), &a) - - formData.AddressDestination = a - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - d, err := json.Marshal(formData) - if err != nil { - return nil, err - } - - var dataMap map[string]any - err = json.Unmarshal(d, &dataMap) - if err != nil { - return nil, err - } - - return dataMap, nil -} - -func parseOrganizedCarpoolDriversUpdateForm(r *http.Request) (map[string]any, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - log.Info().Any("form content", r.Form).Msg("parsing update form") - - var date *time.Time - - if r.PostFormValue("birthdate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) - if err != nil { - return nil, err - } - date = &d - } - - formData := OrganizedCarpoolDriversForm{ - FirstName: r.PostFormValue("first_name"), - LastName: r.PostFormValue("last_name"), - Email: r.PostFormValue("email"), - Birthdate: date, - PhoneNumber: r.PostFormValue("phone_number"), - FileNumber: r.PostFormValue("file_number"), - Gender: r.PostFormValue("gender"), - } - - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - formData.Address = a - } - - if r.PostFormValue("address_destination") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address_destination")), &a) - - formData.AddressDestination = a - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - d, err := json.Marshal(formData) - if err != nil { - return nil, err - } - - var dataMap map[string]any - err = json.Unmarshal(d, &dataMap) - if err != nil { - return nil, err - } - - // Handle other_properties for update form - if r.PostFormValue("other_properties") != "" { - var otherProps map[string]any - if err := json.Unmarshal([]byte(r.PostFormValue("other_properties")), &otherProps); err == nil { - if dataMap["other_properties"] == nil { - dataMap["other_properties"] = make(map[string]any) - } - for k, v := range otherProps { - dataMap["other_properties"].(map[string]any)[k] = v - } - } - } - - return dataMap, nil -} diff --git a/handlers/application/solidarity-transport-ext.go b/handlers/application/solidarity-transport-ext.go deleted file mode 100644 index 42e611a..0000000 --- a/handlers/application/solidarity-transport-ext.go +++ /dev/null @@ -1,112 +0,0 @@ -package application - -import ( - "context" - "net/http" - - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" -) - -func (h *ApplicationHandler) SolidarityTransportExternalBookingProposal(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingId := vars["bookingid"] - - resp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(context.Background(), &gen.GetSolidarityTransportBookingRequest{ - Id: bookingId, - }) - - booking, err := transformers.BookingProtoToType(resp.Booking) - if err != nil { - log.Error().Err(err).Msg("could not transform booking type") - w.WriteHeader(http.StatusBadRequest) - return - } - - driver, err := h.services.GetAccount(booking.DriverId) - if err != nil { - log.Error().Err(err).Msg("driver retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - passenger, err := h.services.GetAccount(booking.PassengerId) - if err != nil { - log.Error().Err(err).Msg("passenger retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - if err = r.ParseForm(); err != nil { - log.Error().Err(err).Msg("error parsing form data") - } - message := r.FormValue("message") - action := r.FormValue("action") - var status string - if action == "confirm" { - status = "VALIDATED" - } else if action == "cancel" { - status = "CANCELLED" - } else if action == "waitconfirmation" { - status = "WAITING_CONFIRMATION" - } - if status != "" { - if _, err := h.services.GRPC.SolidarityTransport.UpdateSolidarityTransportBookingStatus(context.Background(), &gen.UpdateSolidarityTransportBookingStatusRequest{ - BookingId: bookingId, - NewStatus: status, - Reason: "Refusé par le bénévole", - }); err != nil { - log.Error().Err(err).Msg("update booking status issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - booking.Status = status - if status == "VALIDATED" { - h.GenerateSMS(passenger.ID, message) - if err := h.creditWallet(driver.ID, booking.Journey.Price.Amount, "Transport solidaire", "Crédit transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit driver wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - } else if status == "CANCELLED" { - if err := h.creditWallet(passenger.ID, booking.Journey.Price.Amount, "Transport solidaire", "Remboursement annulation transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - // NOTIFY GROUP MEMBERS - groupsrequest := &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_organizations"}, - Member: booking.PassengerId, - } - - groupsresp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), groupsrequest) - if err != nil { - log.Error().Err(err).Msg("") - } - if len(groupsresp.Groups) > 0 { - members, _, err := h.groupmembers(groupsresp.Groups[0].Id) - if err != nil { - log.Error().Err(err).Msg("could not retrieve groupe members") - } else { - for _, m := range members { - if email, ok := m.Data["email"].(string); ok { - h.emailing.Send("solidarity_transport.booking_driver_decline", email, map[string]string{ - "bookingid": booking.Id, - "baseUrl": h.config.GetString("base_url"), - }) - } - } - } - } - - } - } - } - - h.Renderer.SolidarityTransportExternalBookingDisplay(w, r, booking, driver, passenger) -} diff --git a/handlers/application/solidarity-transport.go b/handlers/application/solidarity-transport.go deleted file mode 100644 index 5e88160..0000000 --- a/handlers/application/solidarity-transport.go +++ /dev/null @@ -1,1001 +0,0 @@ -package application - -import ( - "cmp" - "context" - "encoding/json" - "fmt" - "io" - "net/http" - "slices" - "sort" - "strconv" - "strings" - "time" - - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "git.coopgo.io/coopgo-platform/payments/pricing" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" - "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers" - "git.coopgo.io/coopgo-platform/solidarity-transport/types" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/paulmach/orb/geojson" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" - - formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" -) - -type DriversForm struct { - FirstName string `json:"first_name" validate:"required"` - LastName string `json:"last_name" validate:"required"` - Email string `json:"email" validate:"required,email"` - Birthdate *time.Time `json:"birthdate" validate:"required"` - PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` - Address any `json:"address,omitempty"` - Gender string `json:"gender"` -} - -const ( - Sunday = iota - Monday - Tuesday - Wednesday - Thursday - Friday - Saturday -) - -func (h *ApplicationHandler) SolidarityTransportOverview(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - tab := r.FormValue("tab") - startdateStr := r.FormValue("date_start") - enddateStr := r.FormValue("date_end") - bookingstatusStr := r.FormValue("status") - - filters := map[string]string{} - hist_filters := map[string]string{} - - accounts, err := h.solidarityDrivers(r) - if err != nil { - log.Error().Err(err).Msg("issue getting solidarity drivers") - accounts = []mobilityaccountsstorage.Account{} - } - - accountsMap := map[string]mobilityaccountsstorage.Account{} - - for _, a := range accounts { - accountsMap[a.ID] = a - } - - beneficiariesMap, err := h.services.GetBeneficiariesMap() - if err != nil { - beneficiariesMap = map[string]mobilityaccountsstorage.Account{} - } - - // Get filters - startdate := time.Now() - enddate := time.Now().Add(24 * 365 * time.Hour) - bookingstatus := "" - - if tab == "solidarityService" { - if startdateStr != "" { - startdate, _ = time.Parse("2006-01-02", startdateStr) - } - if enddateStr != "" { - enddate, _ = time.Parse("2006-01-02", enddateStr) - enddate = enddate.Add(24 * time.Hour) - } - bookingstatus = bookingstatusStr - filters = map[string]string{ - "tab": tab, - "date_start": startdateStr, - "date_end": enddateStr, - "status": bookingstatusStr, - } - } - - bookingsproto, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(context.Background(), &gen.GetSolidarityTransportBookingsRequest{ - StartDate: timestamppb.New(startdate), - EndDate: timestamppb.New(enddate), - Status: bookingstatus, - }) - if err != nil { - log.Error().Err(err).Msg("issue retreving bookings") - } - - bookings := []*types.Booking{} - - if err == nil { - for _, b := range bookingsproto.Bookings { - booking, _ := transformers.BookingProtoToType(b) - bookings = append(bookings, booking) - } - } - - // filters - hist_enddate := time.Now() - hist_startdate := time.Now().Add(-1 * 24 * 365 * time.Hour) - hist_bookingstatus := "" - - if tab == "solidarityHistory" { - if startdateStr != "" { - hist_startdate, _ = time.Parse("2006-01-02", startdateStr) - } - if enddateStr != "" { - enddate, _ = time.Parse("2006-01-02", enddateStr) - hist_enddate = enddate.Add(24 * time.Hour) - } - hist_bookingstatus = bookingstatusStr - hist_filters = map[string]string{ - "tab": tab, - "date_start": startdateStr, - "date_end": enddateStr, - "status": bookingstatusStr, - } - } - - bookingshistoryproto, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(context.Background(), &gen.GetSolidarityTransportBookingsRequest{ - EndDate: timestamppb.New(hist_enddate), - StartDate: timestamppb.New(hist_startdate), - Status: hist_bookingstatus, - }) - if err != nil { - log.Error().Err(err).Msg("issue retreving bookings") - } - - bookingshistory := []*types.Booking{} - - if err == nil { - for _, b := range bookingshistoryproto.Bookings { - booking, _ := transformers.BookingProtoToType(b) - bookingshistory = append(bookingshistory, booking) - } - } - - slices.SortFunc(accounts, func(a, b mobilityaccountsstorage.Account) int { - return strings.Compare( - strings.ToLower(fmt.Sprintf("%s %s", a.Data["first_name"].(string), a.Data["last_name"].(string))), - strings.ToLower(fmt.Sprintf("%s %s", b.Data["first_name"].(string), b.Data["last_name"].(string))), - ) - }) - slices.SortFunc(bookings, func(a, b *types.Booking) int { - return cmp.Compare(a.Journey.PassengerPickupDate.Unix(), b.Journey.PassengerPickupDate.Unix()) - }) - slices.SortFunc(bookingshistory, func(a, b *types.Booking) int { - return cmp.Compare(a.Journey.PassengerPickupDate.Unix(), b.Journey.PassengerPickupDate.Unix()) - }) - - h.Renderer.SolidarityTransportOverview(w, r, accounts, accountsMap, beneficiariesMap, bookings, bookingshistory, filters, hist_filters, tab) -} - -func (h *ApplicationHandler) SolidarityTransportCreateDriver(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - dataMap, err := parseBeneficiariesForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.RegisterRequest{ - Account: &mobilityaccounts.Account{ - Namespace: "solidarity_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.Register(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", resp.Account.Id), http.StatusFound) - return - } - - h.Renderer.SolidarityTransportCreateDriver(w, r) -} - -func (h *ApplicationHandler) SolidarityTransportUpdateDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - driver, err := h.services.GetAccount(driverID) - if err != nil { - log.Error().Err(err).Msg("Issue retrieving driver account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - dataMap, err := parseBeneficiariesForm(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "solidarity_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", resp.Account.Id), http.StatusFound) - return - } - - h.Renderer.SolidarityTransportUpdateDriver(w, r, driver) -} - -func (h *ApplicationHandler) SolidarityTransportDriverDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - documents := h.filestorage.List(filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS + "/" + driverID) - - driver, err := h.services.GetAccount(driverID) - if err != nil { - log.Error().Err(err).Msg("Issue retrieving driver account") - w.WriteHeader(http.StatusInternalServerError) - return - } - - availabilities := []*gen.DriverRegularAvailability{} - - resp, err := h.services.GRPC.SolidarityTransport.GetDriverRegularAvailabilities(context.Background(), &gen.GetDriverRegularAvailabilitiesRequest{DriverId: driverID}) - if err != nil { - log.Error().Err(err).Msg("error calling GetDriverRegularAvailabilities") - } else { - availabilities = resp.Results - } - sort.Sort(sorting.SolidarityAvailabilitiesByDay(availabilities)) - - bookingsresp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(context.Background(), &gen.GetSolidarityTransportBookingsRequest{Driverid: driverID}) - if err != nil { - log.Error().Err(err).Msg("could not get driver bookings") - } - log.Debug().Any("bookings", bookingsresp.Bookings).Msg("bookings list") - kmnb := int64(0) - bookings := slices.Collect(func(yield func(*gen.SolidarityTransportBooking) bool) { - for _, b := range bookingsresp.Bookings { - log.Debug().Str("bokking status", b.Status).Msg("candidate booking") - if b.Status == "VALIDATED" { - kmnb = kmnb + b.Journey.DriverDistance - if !yield(b) { - return - } - } - } - }) - log.Debug().Any("bookings", bookings).Msg("bookings list") - - stats := map[string]any{ - "bookings": map[string]any{ - "count": len(bookings), - "km": kmnb, - }, - } - - walletBalance := h.calculateWalletBalance(driver) - - h.Renderer.SolidarityTransportDriverDisplay(w, r, driver, availabilities, documents, bookings, stats, walletBalance) -} - -func (h *ApplicationHandler) SolidarityTransportAddAvailability(w http.ResponseWriter, r *http.Request) { - if r.Method != "POST" { - log.Error().Msg("Wrong method") - w.WriteHeader(http.StatusMethodNotAllowed) - return - } - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("error parsong availabilities form") - w.WriteHeader(http.StatusInternalServerError) - return - } - - vars := mux.Vars(r) - driverID := vars["driverid"] - - availabilities := []*gen.DriverRegularAvailability{} - - starttime := r.PostFormValue("starttime") - endtime := r.PostFormValue("endtime") - address := r.PostFormValue("address") - - if r.PostFormValue("days.monday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Monday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.tuesday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Tuesday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.wednesday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Wednesday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.thursday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Thursday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.friday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Friday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.saturday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Saturday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - if r.PostFormValue("days.sunday") == "on" { - a := &gen.DriverRegularAvailability{ - DriverId: driverID, - Day: Sunday, - StartTime: starttime, - EndTime: endtime, - Address: &gen.GeoJsonFeature{ - Serialized: address, - }, - } - availabilities = append(availabilities, a) - } - - req := &gen.AddDriverRegularAvailabilitiesRequest{ - Availabilities: availabilities, - } - _, err := h.services.GRPC.SolidarityTransport.AddDriverRegularAvailabilities(context.Background(), req) - if err != nil { - log.Error().Err(err).Msg("could not add availabilities") - w.WriteHeader(http.StatusInternalServerError) - return - } - - log.Info().Msg("Finished creating availabilities") - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportUnarchiveDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - data, _ := structpb.NewValue(map[string]any{ - "archived": false, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "solidarity_transport_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportDriverDocuments(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - // r.ParseForm() - r.ParseMultipartForm(100 * 1024 * 1024) - - document_type := r.FormValue("type") - document_name := r.FormValue("name") - - file, header, err := r.FormFile("file-upload") - if err != nil { - log.Error().Err(err).Msg("") - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": document_type, - "name": document_name, - } - - log.Debug().Any("metadata", metadata).Msg("Metadata") - - if err := h.filestorage.Put(file, filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS, fmt.Sprintf("%s/%s_%s", driverID, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - document := vars["document"] - - file, info, err := h.filestorage.Get(filestorage.PREFIX_SOLIDARITY_TRANSPORT_DRIVERS, fmt.Sprintf("%s/%s", driverID, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - // http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportArchiveDriver(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - - data, _ := structpb.NewValue(map[string]any{ - "archived": true, - }) - - request := &mobilityaccounts.UpdateDataRequest{ - Account: &mobilityaccounts.Account{ - Id: driverID, - Namespace: "solidarity_transport_drivers", - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", resp.Account.Id), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportDeleteAvailability(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverID := vars["driverid"] - availabilityID := vars["availabilityid"] - - req := &gen.DeleteDriverRegularAvailabilityRequest{ - DriverId: driverID, - AvailabilityId: availabilityID, - } - - if _, err := h.services.GRPC.SolidarityTransport.DeleteDriverRegularAvailability(context.Background(), req); err != nil { - log.Error().Err(err).Msg("could not delete availability") - w.WriteHeader(http.StatusNotFound) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportDriverJourney(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - driverId := vars["driverid"] - journeyId := vars["journeyid"] - - var passenger mobilityaccountsstorage.Account - passengerId := r.URL.Query().Get("passengerid") - log.Info().Str("journeyid", journeyId).Str("driverid", driverId).Msg("driver journey") - - journey, err := h.services.GRPC.SolidarityTransport.GetDriverJourney(context.Background(), &gen.GetDriverJourneyRequest{ - DriverId: driverId, - JourneyId: journeyId, - }) - if err != nil { - log.Error().Err(err).Msg("could not get driver journey") - w.WriteHeader(http.StatusNotFound) - return - } - if passengerId != "" { - passenger, err = h.services.GetAccount(passengerId) - if err != nil { - log.Error().Err(err).Msg("could not get account") - w.WriteHeader(http.StatusNotFound) - return - } - } - - j, err := transformers.DriverJourneyProtoToType(journey.DriverJourney) - if err != nil { - log.Error().Err(err).Msg("could not get driver journey") - w.WriteHeader(http.StatusNotFound) - return - } - solidarity, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBookings(context.Background(), &gen.GetSolidarityTransportBookingsRequest{ - Passengerid: passengerId, - StartDate: timestamppb.New(time.Now().Add(-12 * 730 * time.Hour)), - EndDate: timestamppb.New(time.Now().Add(12 * 730 * time.Hour)), - }) - - priority := false - if a, ok := passenger.Data["other_properties"]; ok { - if b, ok := a.(map[string]any); ok { - if c, ok := b["status"]; ok { - if p, ok := c.(string); ok { - priority = (p == "Prioritaire") - } - } - } - } - - history := 0 - if op, ok := passenger.Data["other_properties"]; ok { - if op_map, ok := op.(map[string]any); ok { - if pst, ok := op_map["previous_solidarity_transport"]; ok { - if pst_str, ok := pst.(string); ok { - if pst_str != "" { - if n, err := strconv.Atoi(pst_str); err == nil { - history = history + n - } else { - log.Error().Err(err).Str("n", pst_str).Msg("string to int conversion error") - } - } - } - } - } - } - - history = history + len(solidarity.Bookings) - - log.Debug().Any("history", history).Msg("history check") - - benefParams := pricing.BeneficiaryParams{} - if passengerId == "" { - benefParams = pricing.BeneficiaryParams{ - Address: h.pricingGeography(j.PassengerPickup), - History: 99, - Priority: false, - } - } else { - log.Debug().Any("passenger data", passenger.Data).Msg("0") - var passengerGeo pricing.GeographyParams - if pa, ok := passenger.Data["address"]; ok { - jsonpa, err := json.Marshal(pa) - if err == nil { - passGeojson, err := geojson.UnmarshalFeature(jsonpa) - if err == nil { - passengerGeo = h.pricingGeography(passGeojson) - } - } - } - benefParams = pricing.BeneficiaryParams{ - Address: passengerGeo, - History: history, - Priority: priority, - } - } - pricing, err := h.services.Pricing.Prices(pricing.PricingParams{ - MobilityType: "solidarity_transport", - Beneficiary: benefParams, - SharedMobility: pricing.SharedMobilityParams{ - DriverDistance: journey.DriverJourney.DriverDistance, - PassengerDistance: journey.DriverJourney.PassengerDistance, - Departure: h.pricingGeography(j.PassengerPickup), - Destination: h.pricingGeography(j.PassengerDrop), - OutwardOnly: journey.DriverJourney.Noreturn, - }, - }) - if err != nil { - log.Error().Err(err).Msg("error in pricing calculation") - } - - journey.DriverJourney.Price.Amount = pricing["passenger"].Amount - journey.DriverJourney.Price.Currency = "EUR" - - if r.Method == "POST" { - if passengerId == "" { - log.Error().Err(err).Msg("could not get driver journey") - w.WriteHeader(http.StatusNotFound) - return - } - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("could not parse form input") - w.WriteHeader(http.StatusBadRequest) - return - } - - rwt := r.PostFormValue("return_waiting_time") - return_waiting_time := int64(0) - return_waiting_time, err := strconv.ParseInt(rwt, 10, 64) - if err == nil { - log.Error().Err(err).Msg("return waiting time error") - } - motivation := r.PostFormValue("motivation") - - data, err := structpb.NewStruct(map[string]any{ - "motivation": motivation, - }) - if err != nil { - log.Error().Err(err).Msg("issue creating data struct") - } - - bookingRes, err := h.services.GRPC.SolidarityTransport.BookDriverJourney(context.Background(), &gen.BookDriverJourneyRequest{ - PassengerId: passengerId, - DriverId: driverId, - DriverJourneyId: journeyId, - ReturnWaitingDuration: return_waiting_time * int64(time.Minute), - PriceAmount: journey.DriverJourney.Price.Amount, - PriceCurrency: journey.DriverJourney.Price.Currency, - Data: data, - }) - if err != nil { - log.Error().Err(err).Msg("cannot create booking") - w.WriteHeader(http.StatusInternalServerError) - return - } - - message := r.PostFormValue("message") - doNotSend := r.PostFormValue("do_not_send") - send_message := strings.ReplaceAll(message, "{booking_id}", bookingRes.Booking.Id) - log.Debug().Str("message", send_message).Str("do not send", doNotSend).Msg("Driver journey booked : sending message") - if doNotSend != "on" { - h.GenerateSMS(driverId, send_message) - - if err := h.creditWallet(passengerId, float64(-1)*journey.DriverJourney.Price.Amount, "Transport solidaire", "Débit pour réservation transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit passenger wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/"), http.StatusFound) - return - } - - driver, err := h.services.GetAccount(driverId) - if err != nil { - log.Error().Err(err).Msg("could not get driver") - w.WriteHeader(http.StatusNotFound) - return - } - - beneficiaries, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - driverjourney, err := transformers.DriverJourneyProtoToType(journey.DriverJourney) - if err != nil { - log.Error().Err(err).Msg("could not transform driver journey type") - w.WriteHeader(http.StatusBadRequest) - return - } - - passengerWalletBalance := h.calculateWalletBalance(passenger) - - h.Renderer.SolidarityTransportDriverJourney(w, r, driverjourney, driver, passenger, beneficiaries, passengerWalletBalance) -} - -func (h *ApplicationHandler) SolidarityTransportDriverJourneyToggleNoreturn(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - journeyId := vars["journeyid"] - - _, err := h.services.GRPC.SolidarityTransport.ToggleSolidarityTransportNoreturn(context.Background(), &gen.ToggleSolidarityTransportNoreturnRequest{ - JourneyId: journeyId, - }) - if err != nil { - log.Error().Err(err).Msg("could not get driver journey") - w.WriteHeader(http.StatusNotFound) - return - } - log.Debug().Msg("here") - http.Redirect(w, r, r.Referer(), http.StatusFound) -} - -func (h *ApplicationHandler) SolidarityTransportBookingDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingId := vars["bookingid"] - - resp, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(context.Background(), &gen.GetSolidarityTransportBookingRequest{ - Id: bookingId, - }) - if r.Method == "POST" { - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("could not parse form") - w.WriteHeader(http.StatusBadRequest) - return - } - - driverDistanceStr := r.PostFormValue("driver_distance") - - driverDistance, err := strconv.Atoi(driverDistanceStr) - if err != nil { - log.Error().Err(err).Msg("could not read distance") - w.WriteHeader(http.StatusBadRequest) - return - } - resp.Booking.Journey.DriverDistance = int64(driverDistance) - - _, err = h.services.GRPC.SolidarityTransport.UpdateSolidarityTransportBooking(context.Background(), &gen.UpdateSolidarityTransportBookingRequest{ - Booking: resp.Booking, - }) - if err != nil { - log.Error().Err(err).Msg("could not update booking") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - - booking, err := transformers.BookingProtoToType(resp.Booking) - if err != nil { - log.Error().Err(err).Msg("could not transform booking type") - w.WriteHeader(http.StatusBadRequest) - return - } - - driver, err := h.services.GetAccount(booking.DriverId) - if err != nil { - log.Error().Err(err).Msg("driver retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - passenger, err := h.services.GetAccount(booking.PassengerId) - if err != nil { - log.Error().Err(err).Msg("passenger retrieval issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - - passengerWalletBalance := h.calculateWalletBalance(passenger) - - h.Renderer.SolidarityTransportBookingDisplay(w, r, booking, driver, passenger, passengerWalletBalance) -} - -func (h *ApplicationHandler) SolidarityTransportBookingStatus(action string) func(w http.ResponseWriter, r *http.Request) { - return func(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingId := vars["bookingid"] - reason := "" - - status := "" - if action == "confirm" { - status = "VALIDATED" - } else if action == "cancel" { - status = "CANCELLED" - if r.Method == "POST" { - r.ParseForm() - reason = r.PostFormValue("reason") - } - } else if action == "waitconfirmation" { - status = "WAITING_CONFIRMATION" - } - - if status != "" { - if _, err := h.services.GRPC.SolidarityTransport.UpdateSolidarityTransportBookingStatus(context.Background(), &gen.UpdateSolidarityTransportBookingStatusRequest{ - BookingId: bookingId, - NewStatus: status, - Reason: reason, - }); err != nil { - log.Error().Err(err).Msg("update booking status issue") - w.WriteHeader(http.StatusInternalServerError) - return - } - if status == "CANCELLED" { - booking, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(context.Background(), &gen.GetSolidarityTransportBookingRequest{ - Id: bookingId, - }) - if err == nil { - if err := h.creditWallet(booking.Booking.PassengerId, booking.Booking.Journey.Price.Amount, "Transport solidaire", "Remboursement annulation transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - if status == "WAITING_CONFIRMATION" { - booking, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(context.Background(), &gen.GetSolidarityTransportBookingRequest{ - Id: bookingId, - }) - if err == nil { - if err := h.creditWallet(booking.Booking.PassengerId, float64(-1)*booking.Booking.Journey.Price.Amount, "Transport solidaire", "Débit transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - if status == "VALIDATED" { - booking, err := h.services.GRPC.SolidarityTransport.GetSolidarityTransportBooking(context.Background(), &gen.GetSolidarityTransportBookingRequest{ - Id: bookingId, - }) - if err == nil { - if err := h.creditWallet(booking.Booking.DriverId, booking.Booking.Journey.Price.Amount, "Transport solidaire", "Crédit transport solidaire"); err != nil { - log.Error().Err(err).Msg("could not credit driver wallet") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - } - http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/bookings/%s", bookingId), http.StatusFound) - } -} - -func parseDriversForm(r *http.Request) (map[string]any, error) { - if err := r.ParseForm(); err != nil { - return nil, err - } - - var date *time.Time - - if r.PostFormValue("birthdate") != "" { - d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) - if err != nil { - return nil, err - } - date = &d - } - - formData := DriversForm{ - FirstName: r.PostFormValue("first_name"), - LastName: r.PostFormValue("last_name"), - Email: r.PostFormValue("email"), - Birthdate: date, - PhoneNumber: r.PostFormValue("phone_number"), - Gender: r.PostFormValue("gender"), - } - - if r.PostFormValue("address") != "" { - var a any - json.Unmarshal([]byte(r.PostFormValue("address")), &a) - - formData.Address = a - } - - validate := formvalidators.New() - if err := validate.Struct(formData); err != nil { - return nil, err - } - - d, err := json.Marshal(formData) - if err != nil { - return nil, err - } - - var dataMap map[string]any - err = json.Unmarshal(d, &dataMap) - if err != nil { - return nil, err - } - - return dataMap, nil -} - -func (h *ApplicationHandler) solidarityDrivers(r *http.Request) ([]mobilityaccountsstorage.Account, error) { - accounts := []mobilityaccountsstorage.Account{} - - request := &mobilityaccounts.GetAccountsRequest{ - Namespaces: []string{"solidarity_drivers"}, - } - - resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), request) - if err != nil { - return accounts, err - } - - for _, account := range resp.Accounts { - if filterAccount(r, account) { - a := account.ToStorageType() - accounts = append(accounts, a) - } - } - - return accounts, err -} - -func (h *ApplicationHandler) pricingGeography(loc *geojson.Feature) pricing.GeographyParams { - if loc == nil { - return pricing.GeographyParams{} - } - - geo, err := h.services.Geography.GeoSearch(loc) - if err != nil { - log.Error().Err(err).Msg("issue in geosearch") - return pricing.GeographyParams{} - } - return pricing.GeographyParams{ - Location: loc, - CityCode: geo["communes"].Properties.MustString("code"), - IntercommunalityCode: geo["epci"].Properties.MustString("code"), - RegionCode: geo["regions"].Properties.MustString("code"), - DepartmentCode: geo["departements"].Properties.MustString("code"), - } -} diff --git a/handlers/application/support.go b/handlers/application/support.go deleted file mode 100755 index c5dab6d..0000000 --- a/handlers/application/support.go +++ /dev/null @@ -1,44 +0,0 @@ -package application - -import ( - "net/http" - - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "github.com/rs/zerolog/log" -) - -type Message struct { - Content string -} - -func (h *ApplicationHandler) SupportSend(w http.ResponseWriter, r *http.Request) { - c := r.Context().Value(identification.ClaimsKey) - if c == nil { - log.Error().Msg("no current user claims") - w.WriteHeader(http.StatusInternalServerError) - return - } - current_user_claims := c.(map[string]any) - - comment := r.PostFormValue(("comment")) - - if r.Method == "POST" { - user_email := current_user_claims["email"].(string) - - data := map[string]any{ - "key": comment, - "user": user_email, - } - - log.Debug().Str("user_email", user_email).Msg("Sending message") - - if err := h.emailing.Send("support.request", "support@parcoursmob.fr", data); err != nil { - log.Error().Err(err).Msg("error sending email") - w.WriteHeader(http.StatusInternalServerError) - return - } - http.Redirect(w, r, "/app/", http.StatusFound) - return - } - h.Renderer.SupportSend(w, r, comment, current_user_claims) -} diff --git a/handlers/application/vehicles-management.go b/handlers/application/vehicles-management.go deleted file mode 100755 index edc3ceb..0000000 --- a/handlers/application/vehicles-management.go +++ /dev/null @@ -1,710 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "net/http" - "sort" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/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" - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "github.com/coreos/go-oidc/v3/oidc" - "github.com/google/uuid" - "github.com/gorilla/mux" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r *http.Request) { - // Get Vehicles - request := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - } - - vehicles := []fleetsstorage.Vehicle{} - bookings := []fleetsstorage.Booking{} - vehicles_map := map[string]fleetsstorage.Vehicle{} - - for _, vehicle := range resp.Vehicles { - if filterVehicle(r, vehicle) { - v := vehicle.ToStorageType() - vehicleBookings := []fleetsstorage.Booking{} - for _, b := range v.Bookings { - if b.Status() != fleetsstorage.StatusOld { - if deleted, ok := b.Data["Deleted"].(bool); !ok && !deleted { - bookings = append(bookings, b) - } - } - if b.Unavailableto.After(time.Now()) { - vehicleBookings = append(vehicleBookings, b) - } - } - v.Bookings = vehicleBookings - vehicles = append(vehicles, v) - vehicles_map[v.ID] = v - - } - } - - driversMap, _ := h.services.GetBeneficiariesMap() - - sort.Sort(sorting.VehiclesByLicencePlate(vehicles)) - sort.Sort(sorting.BookingsByStartdate(bookings)) - h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, driversMap, bookings) -} - -func (h *ApplicationHandler) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request) { - // Get Vehicles - request := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - } - - bookings := []fleetsstorage.Booking{} - vehicles_map := map[string]fleetsstorage.Vehicle{} - - for _, vehicle := range resp.Vehicles { - if filterVehicle(r, vehicle) { - v := vehicle.ToStorageType() - vehicles_map[v.ID] = v - // bookings = append(bookings, v.Bookings...) - for _, b := range v.Bookings { - if v, ok := b.Data["administrator_unavailability"].(bool); !ok || !v { - bookings = append(bookings, b) - } - } - } - } - - sort.Sort(sorting.BookingsByStartdate(bookings)) - - cacheid := uuid.NewString() - h.cache.PutWithTTL(cacheid, bookings, 1*time.Hour) - - driversMap, _ := h.services.GetBeneficiariesMap() - - h.Renderer.VehiclesManagementBookingsList(w, r, vehicles_map, driversMap, bookings, cacheid) -} - -func (h *ApplicationHandler) VehiclesFleetAdd(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - g := r.Context().Value(identification.GroupKey) - if g == nil { - w.WriteHeader(http.StatusBadRequest) - return - } - - group := g.(storage.Group) - - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - dataMap := map[string]any{} - if v := r.FormValue("name"); v != "" { - dataMap["name"] = v - } - if v := r.FormValue("address"); v != "" { - var address map[string]any - err := json.Unmarshal([]byte(v), &address) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - dataMap["address"] = address - } - if v := r.FormValue("informations"); v != "" { - dataMap["informations"] = v - } - if v := r.FormValue("licence_plate"); v != "" { - dataMap["licence_plate"] = v - } - if v := r.FormValue("automatic"); v != "" { - dataMap["automatic"] = (v == "on") - } - if v := r.FormValue("kilometers"); v != "" { - dataMap["kilometers"] = v - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - vehicle := &fleets.Vehicle{ - Id: uuid.NewString(), - Namespace: "parcoursmob", - Type: r.FormValue("type"), - Administrators: []string{group.ID}, - Data: data.GetStructValue(), - } - - request := &fleets.AddVehicleRequest{ - Vehicle: vehicle, - } - - _, err = h.services.GRPC.Fleets.AddVehicle(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicle.Id), http.StatusFound) - return - } - - vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types") - h.Renderer.VehiclesFleetAdd(w, r, vehicles_types) -} - -func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - vehicleid := vars["vehicleid"] - - request := &fleets.GetVehicleRequest{ - Vehicleid: vehicleid, - } - - resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiaries, err := h.services.GetBeneficiariesMap() - if err != nil { - log.Error().Err(err).Msg("issue retrieving beneficiaries") - w.WriteHeader(http.StatusInternalServerError) - return - } - /*diag := []diagsstorage.Diag{} - - diagsrequest := &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_vehicles"}, - } - - diagsresp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), diagsrequest) - if err != nil { - log.Error().Err(err).Msg("did not retrieve diags") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for _, d := range diagsresp.Diags { - diagData := d.Data.AsMap() - if vehicle, ok := diagData["vehicle"].(string); ok && vehicle == vehicleid { - diag = append(diag, d.ToStorageType()) - } - } */ - - diagsAny := []any{} - /*for i, d := range diag { - diagsAny[i] = d - }*/ - - h.Renderer.VehiclesFleetDisplay(w, r, resp.Vehicle.ToStorageType(), beneficiaries, diagsAny) -} - -func filterVehicle(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) VehicleManagementBookingDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - - booking, err := h.services.GetBooking(bookingid) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - r.ParseForm() - - newbooking, _ := fleets.BookingFromStorageType(&booking) - - startdate := r.FormValue("startdate") - if startdate != "" { - newstartdate, _ := time.Parse("2006-01-02", startdate) - newbooking.Startdate = timestamppb.New(newstartdate) - - if newstartdate.Before(newbooking.Unavailablefrom.AsTime()) { - newbooking.Unavailablefrom = timestamppb.New(newstartdate) - } - } - - enddate := r.FormValue("enddate") - if enddate != "" { - newenddate, _ := time.Parse("2006-01-02", enddate) - newbooking.Enddate = timestamppb.New(newenddate) - - if newenddate.After(newbooking.Unavailableto.AsTime()) || newenddate.Equal(newbooking.Unavailableto.AsTime()) { - newbooking.Unavailableto = timestamppb.New(newenddate.Add(24 * time.Hour)) - } - } - - unavailablefrom := r.FormValue("unavailablefrom") - if unavailablefrom != "" { - newunavailablefrom, _ := time.Parse("2006-01-02", unavailablefrom) - newbooking.Unavailablefrom = timestamppb.New(newunavailablefrom) - } - - unavailableto := r.FormValue("unavailableto") - if unavailableto != "" { - newunavailableto, _ := time.Parse("2006-01-02", unavailableto) - newbooking.Unavailableto = timestamppb.New(newunavailableto) - } - - request := &fleets.UpdateBookingRequest{ - Booking: newbooking, - } - - _, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booking = newbooking.ToStorageType() - } - - beneficiary := mobilityaccountsstorage.Account{} - - if booking.Driver != "" { - beneficiaryrequest := &mobilityaccounts.GetAccountRequest{ - Id: booking.Driver, - } - - beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), beneficiaryrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiary = beneficiaryresp.Account.ToStorageType() - } - - grouprequest := &groupsmanagement.GetGroupRequest{ - Id: booking.Vehicle.Administrators[0], - } - - groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - alternativerequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - Types: []string{booking.Vehicle.Type}, - Administrators: booking.Vehicle.Administrators, - AvailabilityFrom: timestamppb.New(booking.Startdate), - AvailabilityTo: timestamppb.New(booking.Enddate.Add(24 * time.Hour)), - } - - alternativeresp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), alternativerequest) - if err != nil { - log.Error().Err(err).Msg("") - } - - alternatives := []any{} - - for _, a := range alternativeresp.Vehicles { - alternatives = append(alternatives, a.ToStorageType()) - } - - documents := h.filestorage.List(filestorage.PREFIX_BOOKINGS + "/" + bookingid) - file_types_map := h.config.GetStringMapString("storage.files.file_types") - - /* diag := []diagsstorage.Diag{} - - diagsrequest := &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_bookings"}, - } - - diagsresp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), diagsrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for _, d := range diagsresp.Diags { - diagData := d.Data.AsMap() - if booking, ok := diagData["booking"].(string); ok && booking == bookingid { - diag = append(diag, d.ToStorageType()) - } - }*/ - - diagsAny := []any{} - /*for i, d := range diag { - diagsAny[i] = d - }*/ - - h.Renderer.VehicleManagementBookingDisplay(w, r, booking, booking.Vehicle, beneficiary, groupresp.Group.ToStorageType(), documents, file_types_map, alternatives, diagsAny) -} - -func (h ApplicationHandler) VehicleManagementBookingChangeVehicle(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - - r.ParseForm() - - newvehicle := r.FormValue("vehicle") - - booking, err := h.services.GetBooking(bookingid) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booking.Vehicleid = newvehicle - - b, _ := fleets.BookingFromStorageType(&booking) - - request := &fleets.UpdateBookingRequest{ - Booking: b, - } - - _, err = h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/bookings/%s", bookingid), http.StatusFound) -} - -func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter, r *http.Request) { // Get Group - g := r.Context().Value(identification.GroupKey) - if g == nil { - log.Error().Msg("no current group") - w.WriteHeader(http.StatusInternalServerError) - return - } - current_group := g.(storage.Group) - - // Get current user ID - u := r.Context().Value(identification.IdtokenKey) - if u == nil { - log.Error().Msg("no current user") - w.WriteHeader(http.StatusInternalServerError) - return - } - current_user_token := u.(*oidc.IDToken) - - // Get current user claims - c := r.Context().Value(identification.ClaimsKey) - if c == nil { - log.Error().Msg("no current user claims") - w.WriteHeader(http.StatusInternalServerError) - return - } - current_user_claims := c.(map[string]any) - - vars := mux.Vars(r) - vehicleid := vars["vehicleid"] - - r.ParseForm() - - start := r.FormValue("unavailablefrom") - end := r.FormValue("unavailableto") - comment := r.FormValue("comment") - - unavailablefrom, _ := time.Parse("2006-01-02", start) - unavailableto, _ := time.Parse("2006-01-02", end) - - data := map[string]any{ - "comment": comment, - "administrator_unavailability": true, - "booked_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"], - }, - }, - } - - datapb, err := structpb.NewStruct(data) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booking := &fleets.Booking{ - Id: uuid.NewString(), - Vehicleid: vehicleid, - Unavailablefrom: timestamppb.New(unavailablefrom), - Unavailableto: timestamppb.New(unavailableto), - Data: datapb, - } - - request := &fleets.CreateBookingRequest{ - Booking: booking, - } - - _, err = h.services.GRPC.Fleets.CreateBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleid), http.StatusFound) -} - -func (h *ApplicationHandler) DeleteBooking(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - - request := &fleets.DeleteBookingRequest{ - Id: bookingid, - } - - _, err := h.services.GRPC.Fleets.DeleteBooking(context.TODO(), request) - if err != nil { - fmt.Println(err) - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, "/app/vehicles-management/bookings/", http.StatusSeeOther) -} - -func (h *ApplicationHandler) UnbookingVehicle(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - - request := &fleets.GetBookingRequest{ - Bookingid: bookingid, - } - - resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - // now := time.Now() - // date := now.Format("2006-01-02") - - date := "1970-01-01" - unavailableto, _ := time.Parse("2006-01-02", date) - unavailablefrom := unavailableto - - current_group, err := h.currentGroup(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - current_user_token, current_user_claims, err := h.currentUser(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booked_by_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["id"].GetStringValue() - booked_by_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["display_name"].GetStringValue() - booked_by_email := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["user"].GetStructValue().Fields["email"].GetStringValue() - booked_by_group_id := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["id"].GetStringValue() - booked_by_group_name := resp.Booking.Data.Fields["booked_by"].GetStructValue().Fields["group"].GetStructValue().Fields["name"].GetStringValue() - - data := map[string]any{ - "booked_by": map[string]any{ - "user": map[string]any{ - "id": booked_by_id, - "display_name": booked_by_name, - "email": booked_by_email, - }, - "group": map[string]any{ - "id": booked_by_group_id, - "name": booked_by_group_name, - }, - }, - "unbooked_by": map[string]any{ - "user": map[string]any{ - "id": current_user_token.Subject, - "display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string), - "email": current_user_claims["email"], - }, - "group": map[string]any{ - "id": current_group.ID, - "name": current_group.Data["name"], - }, - }, - "Deleted": true, - "motif": r.FormValue("motif"), - } - - datapb, err := structpb.NewStruct(data) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - if r.Method == "POST" { - - request := &fleets.UpdateBookingRequest{ - Booking: &fleets.Booking{ - Id: resp.Booking.Id, - Vehicleid: resp.Booking.Vehicleid, - Driver: resp.Booking.Driver, - Startdate: resp.Booking.Startdate, - Enddate: resp.Booking.Enddate, - Unavailablefrom: timestamppb.New(unavailablefrom), - Unavailableto: timestamppb.New(unavailableto), - Data: datapb, - }, - } - - _, err := h.services.GRPC.Fleets.UpdateBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, "/app/vehicles-management/", http.StatusFound) - return - } - h.Renderer.UnbookingVehicle(w, r, resp.Booking.ToStorageType()) -} - -////////////////////////UpdateVehicle/////////////////////// - -func (h *ApplicationHandler) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - vehicleID := vars["vehicleid"] - request := &fleets.GetVehicleRequest{ - Vehicleid: vehicleID, - } - - resp, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - namespaceV := resp.Vehicle.Namespace - // typeV := resp.Vehicle.Type - administratorsV := resp.Vehicle.Administrators - - if r.Method == "POST" { - fmt.Print(r.FormValue("vehicle_type")) - if err := r.ParseForm(); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - dataMap := map[string]any{} - if v := r.FormValue("name"); v != "" { - dataMap["name"] = v - } - if v := r.FormValue("address"); v != "" { - var address map[string]any - err := json.Unmarshal([]byte(v), &address) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - dataMap["address"] = address - } - if v := r.FormValue("informations"); v != "" { - dataMap["informations"] = v - } - if v := r.FormValue("licence_plate"); v != "" { - dataMap["licence_plate"] = v - } - if v := r.FormValue("kilometers"); v != "" { - dataMap["kilometers"] = v - } - if v := r.FormValue("automatic"); v != "" { - dataMap["automatic"] = (v == "on") - } - - data, err := structpb.NewValue(dataMap) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &fleets.UpdateVehicleRequest{ - Vehicle: &fleets.Vehicle{ - Id: vehicleID, - Namespace: namespaceV, - Type: r.FormValue("type"), - Administrators: administratorsV, - Data: data.GetStructValue(), - }, - } - - resp, err := h.services.GRPC.Fleets.UpdateVehicle(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", resp.Vehicle.Id), http.StatusFound) - return - } - vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types") - h.Renderer.VehiclesFleetUpdate(w, r, resp.Vehicle.ToStorageType(), vehicles_types) -} diff --git a/handlers/application/vehicles.go b/handlers/application/vehicles.go deleted file mode 100755 index 29d44aa..0000000 --- a/handlers/application/vehicles.go +++ /dev/null @@ -1,415 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "io" - "net/http" - "slices" - "sort" - "strings" - "time" - - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi" - "git.coopgo.io/coopgo-platform/fleets/storage" - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - groupsmanagementstorage "git.coopgo.io/coopgo-platform/groups-management/storage" - mobilityaccounts "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" - "github.com/paulmach/orb/geojson" - "github.com/rs/zerolog/log" - "google.golang.org/protobuf/types/known/structpb" - "google.golang.org/protobuf/types/known/timestamppb" -) - -func (h ApplicationHandler) VehiclesSearch(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - var beneficiary mobilityaccountsstorage.Account - - beneficiarydocuments := []filestorage.FileInfo{} - - vehicles := []storage.Vehicle{} - searched := false - start := r.FormValue("startdate") - end := r.FormValue("enddate") - - startdate, _ := time.Parse("2006-01-02", start) - enddate, _ := time.Parse("2006-01-02", end) - automatic := (r.FormValue("automatic") == "on") - - administrators := []string{} - - if r.FormValue("beneficiaryid") != "" && startdate.After(time.Now().Add(-24*time.Hour)) && enddate.After(startdate) { - // Handler form - searched = true - - requestbeneficiary := &mobilityaccounts.GetAccountRequest{ - Id: r.FormValue("beneficiaryid"), - } - - respbeneficiary, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), requestbeneficiary) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiary = respbeneficiary.Account.ToStorageType() - - request := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - AvailabilityFrom: timestamppb.New(startdate), - AvailabilityTo: timestamppb.New(enddate), - } - - if r.FormValue("type") != "" { - request.Types = []string{r.FormValue("type")} - } - - resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - } - - for _, vehicle := range resp.Vehicles { - v := vehicle.ToStorageType() - - if r.FormValue("type") == "Voiture" && automatic { - if auto, ok := v.Data["automatic"].(bool); !ok || !auto { - continue - } - } - - 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) - } - - // Sort vehicles if beneficiary address is set - if beneficiaryAddress, ok := beneficiary.Data["address"]; ok { - beneficiaryAddressJson, err := json.Marshal(beneficiaryAddress) - if err == nil { - beneficiaryAddressGeojson, err := geojson.UnmarshalFeature(beneficiaryAddressJson) - if err == nil { - slices.SortFunc(vehicles, sorting.VehiclesByDistanceFrom(*beneficiaryAddressGeojson)) - } else { - log.Error().Err(err).Msg("error transforming beneficiary address to GeoJSON") - } - } else { - log.Error().Err(err).Msg("error transforming beneficiary address to JSON") - } - } - - beneficiarydocuments = h.filestorage.List(filestorage.PREFIX_BENEFICIARIES + "/" + beneficiary.ID) - } - - accounts, err := h.beneficiaries(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - groups := map[string]any{} - - if len(administrators) > 0 { - admingroups, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{ - Groupids: administrators, - }) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for _, g := range admingroups.Groups { - groups[g.Id] = g.ToStorageType() - } - - } - sort.Sort(sorting.BeneficiariesByName(accounts)) - - mandatory_documents := h.config.GetStringSlice("modules.fleets.booking_documents.mandatory") - file_types_map := h.config.GetStringMapString("storage.files.file_types") - vehicles_types := h.config.GetStringSlice("modules.fleets.vehicle_types") - - h.Renderer.VehiclesSearch(w, r, accounts, searched, vehicles, beneficiary, r.FormValue("startdate"), r.FormValue("enddate"), mandatory_documents, file_types_map, beneficiarydocuments, r.FormValue("type"), automatic, vehicles_types, groups) -} - -func (h ApplicationHandler) Book(w http.ResponseWriter, r *http.Request) { - current_group, err := h.currentGroup(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - current_user_token, current_user_claims, err := h.currentUser(r) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - vars := mux.Vars(r) - vehicleid := vars["vehicleid"] - beneficiaryid := vars["beneficiaryid"] - - vehicle, err := h.services.GRPC.Fleets.GetVehicle(context.TODO(), &fleets.GetVehicleRequest{ - Vehicleid: vehicleid, - }) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - w.Write([]byte("Vehicle not found")) - w.Write([]byte(err.Error())) - return - } - - r.ParseMultipartForm(100 * 1024 * 1024) - - start := r.FormValue("startdate") - end := r.FormValue("enddate") - - startdate, _ := time.Parse("2006-01-02", start) - enddate, _ := time.Parse("2006-01-02", end) - - data := map[string]any{ - "booked_by": map[string]any{ - "user": map[string]any{ - "id": current_user_token.Subject, - "display_name": fmt.Sprintf("%s %s", current_user_claims["first_name"], current_user_claims["last_name"]), - }, - "group": map[string]any{ - "id": current_group.ID, - "name": current_group.Data["name"], - }, - }, - } - datapb, err := structpb.NewStruct(data) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booking := &fleets.Booking{ - Id: uuid.NewString(), - Vehicleid: vehicleid, - Driver: beneficiaryid, - Startdate: timestamppb.New(startdate), - Enddate: timestamppb.New(enddate), - Unavailablefrom: timestamppb.New(startdate), - Unavailableto: timestamppb.New(enddate.Add(72 * time.Hour)), - Data: datapb, - } - - request := &fleets.CreateBookingRequest{ - Booking: booking, - } - - for _, v := range h.config.GetStringSlice("modules.fleets.booking_documents.mandatory") { - existing_file := r.FormValue("type-" + v) - if existing_file == "" { - file, header, err := r.FormFile("doc-" + v) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - w.Write([]byte("Document manquant : " + v)) - return - } - defer file.Close() - - fileid := uuid.NewString() - - metadata := map[string]string{ - "type": v, - "name": header.Filename, - } - - if err := h.filestorage.Put(file, filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s_%s", booking.Id, fileid, header.Filename), header.Size, metadata); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - } else { - path := strings.Split(existing_file, "/") - - if err := h.filestorage.Copy(existing_file, fmt.Sprintf("%s/%s/%s", filestorage.PREFIX_BOOKINGS, booking.Id, path[len(path)-1])); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - } - } - - _, err = h.services.GRPC.Fleets.CreateBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusBadRequest) - return - } - - // NOTIFY GROUP MEMBERS - members, _, err := h.groupmembers(vehicle.Vehicle.Administrators[0]) - if err != nil { - log.Error().Err(err).Msg("") - } else { - for _, m := range members { - if email, ok := m.Data["email"].(string); ok { - h.emailing.Send("fleets.bookings.creation_admin_alert", email, map[string]string{ - "bookingid": booking.Id, - }) - } - } - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles/bookings/%s", booking.Id), http.StatusFound) -} - -func (h ApplicationHandler) VehicleBookingDisplay(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - - request := &fleets.GetBookingRequest{ - Bookingid: bookingid, - } - resp, err := h.services.GRPC.Fleets.GetBooking(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - booking := resp.Booking.ToStorageType() - - beneficiaryrequest := &mobilityaccounts.GetAccountRequest{ - Id: booking.Driver, - } - - beneficiaryresp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), beneficiaryrequest) - if err != nil { - beneficiaryresp = &mobilityaccounts.GetAccountResponse{ - Account: &mobilityaccounts.Account{}, - } - } - - grouprequest := &groupsmanagement.GetGroupRequest{ - Id: booking.Vehicle.Administrators[0], - } - - groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), grouprequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - documents := h.filestorage.List(filestorage.PREFIX_BOOKINGS + "/" + bookingid) - file_types_map := h.config.GetStringMapString("storage.files.file_types") - - /*diag := []diagsstorage.Diag{} - - diagsrequest := &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_bookings"}, - } - - diagsresp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), diagsrequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - for _, d := range diagsresp.Diags { - diagData := d.Data.AsMap() - if booking, ok := diagData["booking"].(string); ok && booking == bookingid { - diag = append(diag, d.ToStorageType()) - } - } */ - - diagsAny := []any{} - /*for i, d := range diag { - diagsAny[i] = d - }*/ - - h.Renderer.VehicleBookingDisplay(w, r, booking, booking.Vehicle, beneficiaryresp.Account.ToStorageType(), groupresp.Group.ToStorageType(), documents, file_types_map, diagsAny) -} - -func (h ApplicationHandler) VehiclesBookingsList(w http.ResponseWriter, r *http.Request) { - g := r.Context().Value(identification.GroupKey) - if g == nil { - w.WriteHeader(http.StatusBadRequest) - return - } - - group := g.(groupsmanagementstorage.Group) - - request := &fleets.GetBookingsRequest{} - resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusNotFound) - return - } - - bookings := []storage.Booking{} - - for _, b := range resp.Bookings { - booking := b.ToStorageType() - if b1, ok := booking.Data["booked_by"].(map[string]any); ok { - if b2, ok := b1["group"].(map[string]any); ok { - if b2["id"] == group.ID { - bookings = append(bookings, booking) - } - } - } - - } - - sort.Sort(sorting.BookingsByStartdate(bookings)) - - vehicles, _ := h.services.GetVehiclesMap() - groups, _ := h.services.GetGroupsMap() - - h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups) -} - -func (h *ApplicationHandler) BookingDocumentDownload(w http.ResponseWriter, r *http.Request) { - vars := mux.Vars(r) - bookingid := vars["bookingid"] - document := vars["document"] - - log.Debug().Str("booking id", bookingid).Str("document", document).Msg("Document and booking ID") - - file, info, err := h.filestorage.Get(filestorage.PREFIX_BOOKINGS, fmt.Sprintf("%s/%s", bookingid, document)) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - w.Header().Set("Content-Type", info.ContentType) - if _, err = io.Copy(w, file); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, fmt.Sprintf("/app/vehicles/bookings/%s", bookingid), http.StatusFound) -} diff --git a/handlers/auth/auth.go b/handlers/auth/auth.go deleted file mode 100755 index 92eea63..0000000 --- a/handlers/auth/auth.go +++ /dev/null @@ -1,32 +0,0 @@ -package auth - -import ( - "git.coopgo.io/coopgo-apps/parcoursmob/renderer" - "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - "git.coopgo.io/coopgo-platform/emailing" - "github.com/spf13/viper" -) - -type AuthHandler struct { - idp *identification.IdentificationProvider - config *viper.Viper - services *services.ServicesHandler - Renderer *renderer.Renderer - cache cache.CacheHandler - emailing *emailing.Mailer -} - -func NewAuthHandler(cfg *viper.Viper, idp *identification.IdentificationProvider, svc *services.ServicesHandler, cache cache.CacheHandler, emailing *emailing.Mailer, filestorage cache.FileStorage) (*AuthHandler, error) { - templates_root := cfg.GetString("templates.root") - renderer := renderer.NewRenderer(cfg, templates_root, filestorage) - return &AuthHandler{ - idp: idp, - config: cfg, - services: svc, - Renderer: renderer, - cache: cache, - emailing: emailing, - }, nil -} diff --git a/handlers/auth/groups.go b/handlers/auth/groups.go deleted file mode 100755 index e647a4e..0000000 --- a/handlers/auth/groups.go +++ /dev/null @@ -1,91 +0,0 @@ -package auth - -import ( - "context" - "net/http" - - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - "github.com/rs/zerolog/log" -) - -func (h *AuthHandler) Groups(w http.ResponseWriter, r *http.Request) { - session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") - - if r.Method == "POST" { - r.ParseForm() - - groupid := r.FormValue("group") - - session.Values["organization"] = groupid - session.Save(r, w) - - http.Redirect(w, r, "/app/", http.StatusFound) - - return - } - - tokenstring, ok := session.Values["idtoken"] - - if !ok { - http.Redirect(w, r, "/app/", http.StatusFound) - return - } - - idtoken, err := h.idp.TokenVerifier.Verify(context.Background(), tokenstring.(string)) - if err != nil { - delete(session.Values, "idtoken") - http.Redirect(w, r, "/app/", http.StatusFound) - return - } - - var claims map[string]any - - err = idtoken.Claims(&claims) - if err != nil { - log.Error().Err(err).Msg("") - } - - g := claims["groups"] - - groups_interface, ok := g.([]any) - if !ok { - w.WriteHeader(http.StatusInternalServerError) - return - } - - groups := []string{} - - for _, v := range groups_interface { - groups = append(groups, v.(string)) - } - - request := &groupsmanagement.GetGroupsBatchRequest{ - Groupids: groups, - } - - resp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), request) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - var groupsresponse = []any{} - - for _, group := range resp.Groups { - if group.Namespace != "parcoursmob_organizations" { - continue - } - g := group.ToStorageType() - groupsresponse = append(groupsresponse, g) - } - - h.Renderer.AuthGroups(w, r, groupsresponse) -} - -func (h *AuthHandler) GroupSwitch(w http.ResponseWriter, r *http.Request) { - session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") - delete(session.Values, "organization") - session.Save(r, w) - http.Redirect(w, r, "/app/", http.StatusFound) -} diff --git a/handlers/auth/lost_password.go b/handlers/auth/lost_password.go deleted file mode 100755 index 65acbb7..0000000 --- a/handlers/auth/lost_password.go +++ /dev/null @@ -1,97 +0,0 @@ -package auth - -import ( - "context" - "crypto/rand" - "encoding/base64" - "io" - "net/http" - "time" - - "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - "github.com/rs/zerolog/log" -) - -func (h *AuthHandler) LostPasswordInit(w http.ResponseWriter, r *http.Request) { - if r.Method == "POST" { - r.ParseForm() - email := r.FormValue("email") - if email != "" { - account, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &grpcapi.GetAccountUsernameRequest{ - Username: email, - Namespace: "parcoursmob", - }) - if err != nil { - log.Error().Err(err).Msg("") - http.Redirect(w, r, "/app/", http.StatusFound) - return - } - - b := make([]byte, 16) - if _, err := io.ReadFull(rand.Reader, b); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - key := base64.RawURLEncoding.EncodeToString(b) - - passwordretrieval := map[string]any{ - "username": email, - "account_id": account.Account.Id, - "key": key, - } - - h.cache.PutWithTTL("retrieve-password/"+key, passwordretrieval, 72*time.Hour) - - if err := h.emailing.Send("auth.retrieve_password", email, passwordretrieval); err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - http.Redirect(w, r, "/app/", http.StatusFound) - } - } - h.Renderer.LostPasswordInit(w, r) - -} - -func (h *AuthHandler) LostPasswordRecover(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - - key := r.FormValue("key") - recover, err := h.cache.Get("retrieve-password/" + key) - if err != nil { - log.Error().Err(err).Msg("") - h.Renderer.LostPasswordRecoverKO(w, r, key) - return - } - - if r.Method == "POST" { - newpassword := r.FormValue("password") - if newpassword == "" { - w.WriteHeader(http.StatusInternalServerError) - w.Write([]byte("Password is empty")) - return - } - - _, err := h.services.GRPC.MobilityAccounts.ChangePassword(context.TODO(), &grpcapi.ChangePasswordRequest{ - Id: recover.(map[string]any)["account_id"].(string), - Password: newpassword, - }) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - } - - err = h.cache.Delete("retrieve-password/" + key) - if err != nil { - log.Error().Err(err).Msg("") - } - - http.Redirect(w, r, "/app/", http.StatusFound) - - } - h.Renderer.LostPasswordRecover(w, r, recover) -} diff --git a/handlers/auth/onboarding.go b/handlers/auth/onboarding.go deleted file mode 100755 index cdfdc3f..0000000 --- a/handlers/auth/onboarding.go +++ /dev/null @@ -1,88 +0,0 @@ -package auth - -import ( - "context" - "fmt" - "net/http" - - mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" - ma "git.coopgo.io/coopgo-platform/mobility-accounts/storage" - "github.com/rs/zerolog/log" -) - -func (h *AuthHandler) Onboarding(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - - key := r.FormValue("key") - onboarding, err := h.cache.Get("onboarding/" + key) - if err != nil { - log.Error().Err(err).Msg("") - h.Renderer.AuthOnboardingKO(w, r, key) - return - } - - onboardingmap := onboarding.(map[string]any) - - if r.Method == "POST" { - if r.FormValue("password") == "" { - log.Error().Msg("Password is empty") - w.WriteHeader(http.StatusInternalServerError) - return - } - - groups := []string{ - onboardingmap["group"].(string), - //onboardingmap["group"].(string) + ":admin", - } - - 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{ - Username: onboardingmap["username"].(string), - Password: r.FormValue("password"), - }, - }, - 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, - }, - } - - acc, err := mobilityaccounts.AccountFromStorageType(account) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - request := &mobilityaccounts.RegisterRequest{ - Account: acc, - } - - _, err = h.services.GRPC.MobilityAccounts.Register(context.TODO(), request) - - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - err = h.cache.Delete("onboarding/" + key) - if err != nil { - log.Error().Err(err).Msg("") - } - - http.Redirect(w, r, "/app/", http.StatusFound) - } - - h.Renderer.AuthOnboarding(w, r, key, onboarding) -} diff --git a/handlers/exports/agenda.go b/handlers/exports/agenda.go deleted file mode 100755 index 3025cf1..0000000 --- a/handlers/exports/agenda.go +++ /dev/null @@ -1,205 +0,0 @@ -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" - groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" - 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/rs/zerolog/log" - "github.com/xuri/excelize/v2" -) - -func (h *ExportsHandler) Agenda(filter string) func(w http.ResponseWriter, r *http.Request) { - switch filter { - case "allEvents": - 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 { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - events := []agendastorage.Event{} - - groupids := []string{} - beneficiaries_ids := []string{} - for _, e := range resp.Events { - groupids = append(groupids, e.Owners...) - events = append(events, e.ToStorageType()) - - for _, subscriptions := range e.Subscriptions { - beneficiaries_ids = append(beneficiaries_ids, subscriptions.Subscriber) - } - } - - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - 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) - - } - } - return nil -} - -func (h *ExportsHandler) generateExcel(events []agendastorage.Event, groups map[string]groupsstorage.Group, - beneficiaries_map map[string]accountsstorage.Account) *excelize.File { - f := excelize.NewFile() - defer func() { - if err := f.Close(); err != nil { - log.Error().Err(err).Msg("") - } - }() - f.SetCellValue("Sheet1", "A1", "Evénement") - f.SetCellValue("Sheet1", "B1", "Date de début") - f.SetCellValue("Sheet1", "C1", "Date de fin") - f.SetCellValue("Sheet1", "D1", "Nom bénéficiaire") - f.SetCellValue("Sheet1", "E1", "Prenom bénéficiaire") - f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi") - f.SetCellValue("Sheet1", "G1", "Prescipteur") - f.SetCellValue("Sheet1", "H1", "Prescipteur Nom") - f.SetCellValue("Sheet1", "I1", "Prescipteur Email") - f.SetCellValue("Sheet1", "J1", "Gestionnaire événement") - // f.SetCellValue("Sheet1", "I1", "Prescripteur téléphone") - - i := 2 - for _, e := range events { - if len(e.Owners) == 0 { - continue - } - admin := groups[e.Owners[0]] - - for _, s := range e.Subscriptions { - subscribedbygroup := "" - subscribedbyuser := "" - subscribedbyemail := "" - if v, ok := s.Data["subscribed_by"].(map[string]any); ok { - if v2, ok := v["group"].(map[string]any); ok { - if v3, ok := v2["name"].(string); ok { - subscribedbygroup = v3 - } - - } - if v4, ok := v["user"].(map[string]any); ok { - if v5, ok := v4["display_name"].(string); ok { - subscribedbyuser = v5 - } - if v6, ok := v4["email"].(string); ok { - subscribedbyemail = v6 - } - - } - } - - beneficiary := beneficiaries_map[s.Subscriber] - - f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), e.Name) - f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), e.Startdate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), e.Enddate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), beneficiary.Data["last_name"]) - f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), beneficiary.Data["first_name"]) - f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"]) - f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), subscribedbygroup) - f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), subscribedbyuser) - f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), subscribedbyemail) - f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), admin.Data["name"]) - i = i + 1 - } - - } - 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) -} diff --git a/handlers/exports/exports.go b/handlers/exports/exports.go deleted file mode 100755 index c3eec40..0000000 --- a/handlers/exports/exports.go +++ /dev/null @@ -1,21 +0,0 @@ -package exports - -import ( - "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-platform/emailing" - "github.com/spf13/viper" -) - -type ExportsHandler struct { - config *viper.Viper - services *services.ServicesHandler - emailing *emailing.Mailer -} - -func NewExportsHandler(cfg *viper.Viper, svc *services.ServicesHandler, emailing *emailing.Mailer) (*ExportsHandler, error) { - return &ExportsHandler{ - config: cfg, - services: svc, - emailing: emailing, - }, nil -} diff --git a/handlers/exports/fleets.go b/handlers/exports/fleets.go deleted file mode 100755 index 35db848..0000000 --- a/handlers/exports/fleets.go +++ /dev/null @@ -1,308 +0,0 @@ -package exports - -import ( - "context" - "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" - 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/rs/zerolog/log" - "github.com/xuri/excelize/v2" -) - -func (h *ExportsHandler) Bookings(w http.ResponseWriter, r *http.Request) { - vehicles := map[string]fleetsstorage.Vehicle{} - bookings := []fleetsstorage.Booking{} - reequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiaries_ids := []string{} - - for _, vehicle := range reesp.Vehicles { - - v := vehicle.ToStorageType() - - for _, b := range v.Bookings { - bookings = append(bookings, b) - beneficiaries_ids = append(beneficiaries_ids, b.Driver) - } - - vehicles[vehicle.Id] = v - - } - - groups := map[string]groupsstorage.Group{} - - admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_organizations"}, - }) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - } - }() - - f.SetCellValue("Sheet1", "A1", "Numéro") - f.SetCellValue("Sheet1", "B1", "Type") - f.SetCellValue("Sheet1", "C1", "Gestionnaire") - f.SetCellValue("Sheet1", "D1", "Prescripteur") - f.SetCellValue("Sheet1", "E1", "Bénéficiaire") - f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi") - f.SetCellValue("Sheet1", "G1", "Début de Mise à disposition") - f.SetCellValue("Sheet1", "H1", "Fin de mise à disposition") - f.SetCellValue("Sheet1", "I1", "Début indisponibilité") - f.SetCellValue("Sheet1", "J1", "Fin indisponibilité") - f.SetCellValue("Sheet1", "K1", "Véhicule retiré") - f.SetCellValue("Sheet1", "L1", "Commentaire - Retrait véhicule") - f.SetCellValue("Sheet1", "M1", "Réservation supprimée") - f.SetCellValue("Sheet1", "N1", "Motif de la suppression") - - i := 2 - for _, b := range bookings { - vehicle := vehicles[b.Vehicleid] - if len(vehicle.Administrators) == 0 { - continue - } - admin := groups[vehicle.Administrators[0]] - - bookedby := "" - if v, ok := b.Data["booked_by"].(map[string]any); ok { - if v2, ok := v["user"].(map[string]any); ok { - if v3, ok := v2["display_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 - - if av, ok := b.Data["administrator_unavailability"].(bool); ok && av { - adminunavailability = true - } - - deleted := "" - v, ok := b.Data["Deleted"] - fmt.Println(v) - fmt.Println(ok) - if b.Deleted || (ok && v.(bool)) { - deleted = "DELETED" - } - - f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), vehicle.Data["licence_plate"]) - f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), vehicle.Type) - f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), admin.Data["name"]) - f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), bookedby) - f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), fmt.Sprintf("%v %v", beneficiary.Data["first_name"], beneficiary.Data["last_name"])) - f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"]) - f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), b.Startdate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), b.Enddate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), b.Unavailablefrom.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), b.Unavailableto.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("K%d", i), adminunavailability) - f.SetCellValue("Sheet1", fmt.Sprintf("L%d", i), b.Data["comment"]) - f.SetCellValue("Sheet1", fmt.Sprintf("M%d", i), deleted) - f.SetCellValue("Sheet1", fmt.Sprintf("N%d", i), b.Data["motif"]) - i = i + 1 - } - - 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") - f.Write(w) -} - -func (h *ExportsHandler) AllBookings(w http.ResponseWriter, r *http.Request) { - vehicles := map[string]fleetsstorage.Vehicle{} - bookings := []fleetsstorage.Booking{} - reequest := &fleets.GetVehiclesRequest{ - Namespaces: []string{"parcoursmob"}, - } - reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - beneficiaries_ids := []string{} - - for _, vehicle := range reesp.Vehicles { - - v := vehicle.ToStorageType() - - for _, b := range v.Bookings { - bookings = append(bookings, b) - beneficiaries_ids = append(beneficiaries_ids, b.Driver) - } - - vehicles[vehicle.Id] = v - - } - - groups := map[string]groupsstorage.Group{} - - admingroups, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), &groupsmanagement.GetGroupsRequest{ - Namespaces: []string{"parcoursmob_organizations"}, - }) - if err != nil { - log.Error().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - 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 { - log.Error().Err(err).Msg("") - 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 { - log.Error().Err(err).Msg("") - } - }() - - f.SetCellValue("Sheet1", "A1", "Numéro") - f.SetCellValue("Sheet1", "B1", "Type") - f.SetCellValue("Sheet1", "C1", "Gestionnaire") - f.SetCellValue("Sheet1", "D1", "Prescripteur") - f.SetCellValue("Sheet1", "E1", "Bénéficiaire") - f.SetCellValue("Sheet1", "F1", "Numéro allocataire / Pole emploi") - f.SetCellValue("Sheet1", "G1", "Début de Mise à disposition") - f.SetCellValue("Sheet1", "H1", "Fin de mise à disposition") - f.SetCellValue("Sheet1", "I1", "Début indisponibilité") - f.SetCellValue("Sheet1", "J1", "Fin indisponibilité") - f.SetCellValue("Sheet1", "K1", "Véhicule retiré") - f.SetCellValue("Sheet1", "L1", "Commentaire - Retrait véhicule") - f.SetCellValue("Sheet1", "M1", "Réservation supprimée") - f.SetCellValue("Sheet1", "N1", "Motif de la suppression") - - i := 2 - for _, b := range bookings { - vehicle := vehicles[b.Vehicleid] - if len(vehicle.Administrators) == 0 { - continue - } - admin := groups[vehicle.Administrators[0]] - - bookedby := "" - if v, ok := b.Data["booked_by"].(map[string]any); ok { - if v2, ok := v["user"].(map[string]any); ok { - if v3, ok := v2["display_name"].(string); ok { - bookedby = v3 - } - } - } - - beneficiary := beneficiaries_map[b.Driver] - adminunavailability := false - - if av, ok := b.Data["administrator_unavailability"].(bool); ok && av { - adminunavailability = true - } - - deleted := "" - v, ok := b.Data["Deleted"] - fmt.Println(v) - fmt.Println(ok) - if b.Deleted || (ok && v.(bool)) { - deleted = "DELETED" - } - - f.SetCellValue("Sheet1", fmt.Sprintf("A%d", i), vehicle.Data["licence_plate"]) - f.SetCellValue("Sheet1", fmt.Sprintf("B%d", i), vehicle.Type) - f.SetCellValue("Sheet1", fmt.Sprintf("C%d", i), admin.Data["name"]) - f.SetCellValue("Sheet1", fmt.Sprintf("D%d", i), bookedby) - f.SetCellValue("Sheet1", fmt.Sprintf("E%d", i), fmt.Sprintf("%v %v", beneficiary.Data["first_name"], beneficiary.Data["last_name"])) - f.SetCellValue("Sheet1", fmt.Sprintf("F%d", i), beneficiary.Data["file_number"]) - f.SetCellValue("Sheet1", fmt.Sprintf("G%d", i), b.Startdate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("H%d", i), b.Enddate.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("I%d", i), b.Unavailablefrom.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("J%d", i), b.Unavailableto.Format("2006-01-02")) - f.SetCellValue("Sheet1", fmt.Sprintf("K%d", i), adminunavailability) - f.SetCellValue("Sheet1", fmt.Sprintf("L%d", i), b.Data["comment"]) - f.SetCellValue("Sheet1", fmt.Sprintf("M%d", i), deleted) - f.SetCellValue("Sheet1", fmt.Sprintf("N%d", i), b.Data["motif"]) - i = i + 1 - } - - 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") - f.Write(w) -} diff --git a/main.go b/main.go index bb86854..eda1f4b 100755 --- a/main.go +++ b/main.go @@ -1,25 +1,18 @@ package main import ( - "net/http" "os" - "time" + "sync" "github.com/rs/zerolog" "github.com/rs/zerolog/log" - "github.com/gorilla/mux" - - "git.coopgo.io/coopgo-apps/parcoursmob/handlers/api" - "git.coopgo.io/coopgo-apps/parcoursmob/handlers/api/protected" - "git.coopgo.io/coopgo-apps/parcoursmob/handlers/application" - "git.coopgo.io/coopgo-apps/parcoursmob/handlers/auth" - "git.coopgo.io/coopgo-apps/parcoursmob/handlers/exports" + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" "git.coopgo.io/coopgo-apps/parcoursmob/renderer" + "git.coopgo.io/coopgo-apps/parcoursmob/servers/web" "git.coopgo.io/coopgo-apps/parcoursmob/services" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/protectapi" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + cache "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" ) func main() { @@ -30,10 +23,8 @@ func main() { } var ( - address = cfg.GetString("server.listen") - service_name = cfg.GetString("service_name") - templates_public_dir = cfg.GetString("templates.public_dir") - dev_env = cfg.GetBool("dev_env") + dev_env = cfg.GetBool("dev_env") + webEnabled = cfg.GetBool("server.web.enabled") ) if dev_env { @@ -63,223 +54,21 @@ func main() { log.Panic().Err(err).Msg("Error creating emailing handler") } - apiHandler, _ := api.NewAPIHandler(cfg, idp, svc, kv) - protectedApiHandler, _ := protected.NewProtectedAPIHandler(cfg, idp, svc, kv) - applicationHandler, _ := application.NewApplicationHandler(cfg, svc, kv, filestorage, emailing) - exportsHandler, _ := exports.NewExportsHandler(cfg, svc, emailing) - authHandler, _ := auth.NewAuthHandler(cfg, idp, svc, kv, emailing, filestorage) + // Create renderer for web server + templates_root := cfg.GetString("templates.root") + webRenderer := renderer.NewRenderer(cfg, templates_root, filestorage) - r := mux.NewRouter() + applicationHandler, _ := application.NewApplicationHandler(cfg, svc, kv, filestorage, emailing, idp) - r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir(templates_public_dir)))) + var wg sync.WaitGroup - r.HandleFunc("/auth/onboarding", authHandler.Onboarding) - r.HandleFunc("/auth/disconnect", authHandler.Disconnect) - r.HandleFunc("/auth/lost-password", authHandler.LostPasswordInit) - r.HandleFunc("/auth/lost-password/recover", authHandler.LostPasswordRecover) - r.HandleFunc("/auth/groups/", authHandler.Groups) - r.HandleFunc("/auth/groups/switch", authHandler.GroupSwitch) - r.HandleFunc("/", redirectApp) - - if dev_env { - r.Use(trackPage) + if webEnabled { + wg.Add(1) + go func() { + defer wg.Done() + web.Run(cfg, svc, webRenderer, applicationHandler, idp, kv, filestorage) + }() } - calendars_router := r.PathPrefix("/api/calendars").Subrouter() - calendars_router.HandleFunc("/global.ics", apiHandler.CalendarGlobal) - calendars_router.HandleFunc("/organizations/{groupid}.ics", apiHandler.CalendarOrganizations) - - ext_router := r.PathPrefix("/ext").Subrouter() - ext_router.HandleFunc("/st/bp/{bookingid}", applicationHandler.SolidarityTransportExternalBookingProposal) - - api_router := r.PathPrefix("/api").Subrouter() - api_router.HandleFunc("/", apiHandler.NotFound) - api_router.HandleFunc("/geo/autocomplete", apiHandler.GeoAutocomplete) - api_router.HandleFunc("/cache/{cacheid}", apiHandler.GetCache) - api_router.HandleFunc("/cache/{cacheid}/export", apiHandler.CacheExport) - api_router.HandleFunc("/oauth2/callback", apiHandler.OAuth2Callback) - - protected_api_router := api_router.PathPrefix("/protected").Subrouter() - protected_api_router.HandleFunc("/users", protectedApiHandler.Users) - protected_api_router.Use(protectapi.ApiKey(cfg.GetString("services.api.api_key"))) - - interact_router := r.PathPrefix("/int").Subrouter() - interact_router.HandleFunc("/", apiHandler.NotFound) - - application := r.PathPrefix("/app").Subrouter() - application.HandleFunc("/", applicationHandler.Dashboard) - application.HandleFunc("/beneficiaries/", applicationHandler.BeneficiariesList) - application.HandleFunc("/beneficiaries/create", applicationHandler.BeneficiaryCreate) - application.HandleFunc("/beneficiaries/{beneficiaryid}", applicationHandler.BeneficiaryDisplay) - application.HandleFunc("/beneficiaries/{beneficiaryid}/update", applicationHandler.BeneficiaryUpdate) - application.HandleFunc("/beneficiaries/{beneficiaryid}/archive", applicationHandler.BeneficiaryArchive) - application.HandleFunc("/beneficiaries/{beneficiaryid}/unarchive", applicationHandler.BeneficiaryUnarchive) - application.HandleFunc("/beneficiaries/{beneficiaryid}/documents", applicationHandler.BeneficiaryDocuments) - application.HandleFunc("/beneficiaries/{beneficiaryid}/documents/{document}", applicationHandler.BeneficiaryDocumentDownload) - application.HandleFunc("/beneficiaries/{beneficiaryid}/picture", applicationHandler.BeneficiaryPicture) - application.HandleFunc("/wallets/{userid}/credit", applicationHandler.CreditWallet) - application.HandleFunc("/members/{beneficiaryid}/picture", applicationHandler.BeneficiaryPicture) - application.HandleFunc("/members/{adminid}", applicationHandler.MemberDisplay) - application.HandleFunc("/members/{adminid}/update", applicationHandler.MemberUpdate) - application.HandleFunc("/members/", applicationHandler.MembersList) - application.HandleFunc("/journeys/", applicationHandler.JourneysSearch) - application.HandleFunc("/solidarity-transport/", applicationHandler.SolidarityTransportOverview) - application.HandleFunc("/solidarity-transport/drivers/create", applicationHandler.SolidarityTransportCreateDriver) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/update", applicationHandler.SolidarityTransportUpdateDriver) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/availabilities", applicationHandler.SolidarityTransportAddAvailability) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/archive", applicationHandler.SolidarityTransportArchiveDriver) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/unarchive", applicationHandler.SolidarityTransportUnarchiveDriver) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/documents", applicationHandler.SolidarityTransportDriverDocuments) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/documents/{document}", applicationHandler.SolidarityTransportDocumentDownload) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/availabilities/{availabilityid}/delete", applicationHandler.SolidarityTransportDeleteAvailability) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/journeys/{journeyid}", applicationHandler.SolidarityTransportDriverJourney) - application.HandleFunc("/solidarity-transport/drivers/{driverid}/journeys/{journeyid}/noreturn", applicationHandler.SolidarityTransportDriverJourneyToggleNoreturn) - application.HandleFunc("/solidarity-transport/drivers/{driverid}", applicationHandler.SolidarityTransportDriverDisplay) - application.HandleFunc("/solidarity-transport/bookings/{bookingid}", applicationHandler.SolidarityTransportBookingDisplay) - application.HandleFunc("/solidarity-transport/bookings/{bookingid}/confirm", applicationHandler.SolidarityTransportBookingStatus("confirm")) - application.HandleFunc("/solidarity-transport/bookings/{bookingid}/cancel", applicationHandler.SolidarityTransportBookingStatus("cancel")) - application.HandleFunc("/solidarity-transport/bookings/{bookingid}/waitconfirmation", applicationHandler.SolidarityTransportBookingStatus("waitconfirmation")) - application.HandleFunc("/organized-carpool/", applicationHandler.OrganizedCarpoolOverview) - application.HandleFunc("/organized-carpool/drivers/create", applicationHandler.OrganizedCarpoolCreateDriver) - application.HandleFunc("/organized-carpool/drivers/{driverid}/update", applicationHandler.OrganizedCarpoolUpdateDriver) - application.HandleFunc("/organized-carpool/drivers/{driverid}/trips", applicationHandler.OrganizedCarpoolAddTrip) - application.HandleFunc("/organized-carpool/drivers/{driverid}/archive", applicationHandler.OrganizedCarpoolArchiveDriver) - application.HandleFunc("/organized-carpool/drivers/{driverid}/unarchive", applicationHandler.OrganizedCarpoolUnarchiveDriver) - application.HandleFunc("/organized-carpool/drivers/{driverid}/documents", applicationHandler.OrganizedCarpoolDriverDocuments) - application.HandleFunc("/organized-carpool/drivers/{driverid}/documents/{document}", applicationHandler.OrganizedCarpoolDocumentDownload) - application.HandleFunc("/organized-carpool/drivers/{driverid}/trips/{tripid}/delete", applicationHandler.OrganizedCarpoolDeleteTrip) - application.HandleFunc("/organized-carpool/drivers/{driverid}", applicationHandler.OrganizedCarpoolDriverDisplay) - application.HandleFunc("/organized-carpool/drivers/{driverid}/journeys/{journeyid}", applicationHandler.OrganizedCarpoolJourney) - application.HandleFunc("/organized-carpool/bookings/{bookingid}", applicationHandler.OrganizedCarpoolBookingDisplay) - application.HandleFunc("/organized-carpool/bookings/{bookingid}/confirm", applicationHandler.OrganizedCarpoolBookingStatus("confirm")) - application.HandleFunc("/organized-carpool/bookings/{bookingid}/cancel", applicationHandler.OrganizedCarpoolBookingStatus("cancel")) - application.HandleFunc("/organized-carpool/bookings/{bookingid}/waitconfirmation", applicationHandler.OrganizedCarpoolBookingStatus("waitconfirmation")) - application.HandleFunc("/vehicles/", applicationHandler.VehiclesSearch) - application.HandleFunc("/vehicles/bookings/", applicationHandler.VehiclesBookingsList) - application.HandleFunc("/vehicles/bookings/{bookingid}", applicationHandler.VehicleBookingDisplay) - application.HandleFunc("/vehicles/v/{vehicleid}/b/{beneficiaryid}", applicationHandler.Book) - application.HandleFunc("/vehicles/bookings/{bookingid}/documents/{document}", applicationHandler.BookingDocumentDownload) - application.HandleFunc("/vehicles-management/", applicationHandler.VehiclesManagementOverview) - application.HandleFunc("/vehicles-management/fleet/add", applicationHandler.VehiclesFleetAdd) - application.HandleFunc("/vehicles-management/fleet/{vehicleid}", applicationHandler.VehiclesFleetDisplay) - application.HandleFunc("/vehicles-management/fleet/{vehicleid}/unavailability", applicationHandler.VehiclesFleetMakeUnavailable) - application.HandleFunc("/vehicles-management/fleet/{vehicleid}/update", applicationHandler.VehiclesFleetUpdate) - application.HandleFunc("/vehicles-management/bookings/", applicationHandler.VehiclesManagementBookingsList) - application.HandleFunc("/vehicles-management/bookings/{bookingid}", applicationHandler.VehicleManagementBookingDisplay) - application.HandleFunc("/vehicles-management/bookings/{bookingid}/change-vehicle", applicationHandler.VehicleManagementBookingChangeVehicle) - /////////////////////////////////////Remove booking vehicle///////////////////////////////////////// - application.HandleFunc("/vehicles-management/bookings/{bookingid}/delete", applicationHandler.UnbookingVehicle) - // application.HandleFunc("/vehicles-management/bookings/{bookingid}/delete", applicationHandler.DeleteBooking) - //////////////////////////////////////////////////////////////////////////////////////////////////// - application.HandleFunc("/vehicles-management/bookings/{bookingid}/documents/{document}", applicationHandler.BookingDocumentDownload) - application.HandleFunc("/agenda/", applicationHandler.AgendaHome) - application.HandleFunc("/agenda/history", applicationHandler.AgendaHistory) - 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) - - application.HandleFunc("/group/settings", applicationHandler.GroupSettingsDisplay) - application.HandleFunc("/group/settings/invite-member", applicationHandler.GroupSettingsInviteMember) - - application.HandleFunc("/journeys/groups_covoiturage", applicationHandler.GroupsGestion) - application.HandleFunc("/journeys/groups_covoiturage/create", applicationHandler.CreateGroup) - application.HandleFunc("/journeys/groups_covoiturage/create/{groupid}", applicationHandler.DisplayGroupCovoiturage) - application.HandleFunc("/journeys/groups_covoiturage/create/{id}/{groupid}/{memberid}", applicationHandler.UpdateGroupCovoiturage) - - application.HandleFunc("/sms/send", applicationHandler.SendSMS) - - application.HandleFunc("/support/", applicationHandler.SupportSend) - - appGroup := application.PathPrefix("/group_module").Subrouter() - appGroup.HandleFunc("/", applicationHandler.Groups) - appGroup.HandleFunc("/groups", applicationHandler.CreateGroupModule) - appGroup.HandleFunc("/groups/{groupid}", applicationHandler.DisplayGroupModule) - - // TODO Subrouters with middlewares checking security for each module ? - application.Use(idp.Middleware) - application.Use(idp.GroupsMiddleware) - - appAdmin := application.PathPrefix("/administration").Subrouter() - appAdmin.HandleFunc("/", applicationHandler.Administration) - appAdmin.HandleFunc("/groups/", applicationHandler.AdministrationCreateGroup) - appAdmin.HandleFunc("/groups/{groupid}", applicationHandler.AdministrationGroupDisplay) - appAdmin.HandleFunc("/groups/{groupid}/invite-admin", applicationHandler.AdministrationGroupInviteAdmin) - appAdmin.HandleFunc("/groups/{groupid}/invite-member", applicationHandler.AdministrationGroupInviteMember) - // add statistiques - appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles) - appAdmin.HandleFunc("/stats/bookings", applicationHandler.AdminStatBookings) - appAdmin.HandleFunc("/stats/beneficaires", applicationHandler.AdminStatBeneficaires) - appAdmin.HandleFunc("/stats/events", applicationHandler.AdminStatEvents) - - /////////////////////////////////////Delete subscriber/////////////////////////////////////////////// - application.HandleFunc("/agenda/{eventid}/{subscribeid}/delete", applicationHandler.AgendaDeleteSubscribeEvent) - application.HandleFunc("/agenda/{eventid}/history", applicationHandler.AgendaHistoryEvent) - ///////////////////////////////////////////////////////////////////////////////////////////////////// - //////////////////Add documents in event//////////////////////// - application.HandleFunc("/agenda/{eventid}/documents", applicationHandler.EventDocuments) - application.HandleFunc("/agenda/{eventid}/documents/{document}", applicationHandler.EventDocumentDownload) - //////////////////////////////////////////////////////////////// - //////////////////Diag in event//////////////////////// - // application.HandleFunc("/agenda/{eventid}/create-diag", applicationHandler.DiagsCreateDiag) - application.HandleFunc("/agenda/{eventid}/diags", applicationHandler.DiagsHome) - application.HandleFunc("/agenda/{eventid}/diags/{diagid}", applicationHandler.DiagsDisplayDiag) - application.HandleFunc("/agenda/{eventid}/diags/history", applicationHandler.DiagsHistory) - application.HandleFunc("/agenda/{eventid}/diags/{diagid}/history", applicationHandler.DiagsHistoryDiag) - //////////////////////////////////////////////////////////////// - //////////////////Diag in benefeciaries//////////////////////// - application.HandleFunc("/beneficiaries/{beneficiaryid}/create-diag", applicationHandler.BeneficiariesCreateDiag) - application.HandleFunc("/beneficiaries/{beneficiaryid}/diags/{diagid}", applicationHandler.DiagsDisplayDiag) - //////////////////////////////////////////////////////////////// - //////////////////Diag in vehicules//////////////////////// - application.HandleFunc("/vehicles-management/fleet/{vehicleid}/create-diag", applicationHandler.VehiclesCreateDiag) - application.HandleFunc("/vehicles-management/fleet/{vehicleid}/diags", applicationHandler.DiagsHome) - application.HandleFunc("/vehicles-management/fleet/{vehicleid}/diags/{diagid}", applicationHandler.DiagsDisplayDiag) - //////////////////////////////////////////////////////////////// - //////////////////Diag in bookings//////////////////////// - application.HandleFunc("/vehicles-management/bookings/{bookingid}/create-diag", applicationHandler.BookingsCreateDiag) - application.HandleFunc("/vehicles/bookings/{vehicleid}/diags", applicationHandler.DiagsHome) - application.HandleFunc("/vehicles/bookings/{bookingid}/create-diag", applicationHandler.VehicleBookingsCreateDiag) - //////////////////Diags//////////////////////// - application.HandleFunc("/diags/", applicationHandler.DiagsHome) - application.HandleFunc("/diags/{diagid}/documents", applicationHandler.DiagsDocuments) - application.HandleFunc("/diags/{diagid}/documents/{document}", applicationHandler.DiagsDocumentDownload) - application.HandleFunc("/diags/{diagid}", applicationHandler.DiagsDisplayDiag) - application.HandleFunc("/diags/{diagid}/update", applicationHandler.DiagUpdate) - application.HandleFunc("/diags/{diagid}/delete", applicationHandler.DiagDelete) - - export := r.PathPrefix("/exports").Subrouter() - export.HandleFunc("/fleets/bookings", exportsHandler.AllBookings) - export.HandleFunc("/fleets/bookings/{groupid}", exportsHandler.Bookings) - export.HandleFunc("/agenda/subscriptions", exportsHandler.Agenda("allEvents")) - export.HandleFunc("/agenda/{eventid}", exportsHandler.Agenda("oneEvent")) - export.Use(idp.Middleware) - export.Use(idp.GroupsMiddleware) - - srv := &http.Server{ - Handler: r, - Addr: address, - WriteTimeout: 30 * time.Second, - ReadTimeout: 15 * time.Second, - } - - log.Info().Str("service_name", service_name).Str("address", address).Msg("Running HTTP server") - - log.Fatal().Err(srv.ListenAndServe()).Msg("Failed") -} - -func redirectApp(w http.ResponseWriter, r *http.Request) { - http.Redirect(w, r, "/app/", http.StatusFound) -} - -func trackPage(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - log.Trace().Str("requested_uri", r.RequestURI).Msg("New request") - next.ServeHTTP(w, r.WithContext(r.Context())) - }) + wg.Wait() } diff --git a/renderer/administration.go b/renderer/administration.go index aaa41ff..4c7d105 100755 --- a/renderer/administration.go +++ b/renderer/administration.go @@ -100,7 +100,7 @@ func (renderer *Renderer) AdminStatVehicles(w http.ResponseWriter, r *http.Reque renderer.Render("vehicles_state", w, r, files, state) } -func (renderer *Renderer) AdminStatBookings(w http.ResponseWriter, r *http.Request, vehicles map[string]fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, admingroups map[string]any, beneficiaries map[string]any) { +func (renderer *Renderer) AdminStatBookings(w http.ResponseWriter, r *http.Request, vehicles map[string]fleetsstorage.Vehicle, bookings []fleetsstorage.Booking, admingroups map[string]any, beneficiaries map[string]any, filters map[string]string) { files := renderer.ThemeConfig.GetStringSlice("views.administration.bookings_list.files") state := NewState(r, renderer.ThemeConfig, administrationMenu) state.ViewState = map[string]any{ @@ -108,6 +108,7 @@ func (renderer *Renderer) AdminStatBookings(w http.ResponseWriter, r *http.Reque "bookings": bookings, "admingroups": admingroups, "beneficiaries_map": beneficiaries, + "filters": filters, } renderer.Render("bookings_stats", w, r, files, state) diff --git a/renderer/beneficiaries.go b/renderer/beneficiaries.go index 0aae98e..ffb7361 100755 --- a/renderer/beneficiaries.go +++ b/renderer/beneficiaries.go @@ -15,6 +15,7 @@ type BeneficiariesListState struct { Count int `json:"count"` CacheId string `json:"cache_id"` Beneficiaries []mobilityaccountsstorage.Account `json:"beneficiaries"` + Archived bool `json:"archived"` } func (s BeneficiariesListState) JSON() template.JS { @@ -29,7 +30,7 @@ func (s BeneficiariesListState) JSONWithLimits(a int, b int) template.JS { return s.JSON() } -func (renderer *Renderer) BeneficiariesList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account, cacheid string) { +func (renderer *Renderer) BeneficiariesList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account, cacheid string, archived bool) { files := renderer.ThemeConfig.GetStringSlice("views.beneficiaries.list.files") state := NewState(r, renderer.ThemeConfig, beneficiariesMenu) @@ -37,6 +38,7 @@ func (renderer *Renderer) BeneficiariesList(w http.ResponseWriter, r *http.Reque Count: len(accounts), CacheId: cacheid, Beneficiaries: accounts, + Archived: archived, } renderer.Render("beneficiaries_list", w, r, files, state) @@ -58,23 +60,29 @@ type BeneficiariesDisplayState struct { Beneficiary any } -func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Request, beneficiary any, bookings []fleetsstorage.Booking, organizations []any, beneficiaries_file_types []string, file_types_map map[string]string, documents any, event interface{}, diags []any, solidarityTransportStats any, walletBalance float64) { +func (renderer *Renderer) BeneficiaryDisplay(w http.ResponseWriter, r *http.Request, beneficiary any, bookings []fleetsstorage.Booking, organizations []any, beneficiaries_file_types []string, file_types_map map[string]string, documents any, event interface{}, solidarityTransportStats any, solidarityTransportBookings any, solidarityDriversMap any, organizedCarpoolStats any, organizedCarpoolBookings any, organizedCarpoolDriversMap any, walletBalance float64, tab string) { files := renderer.ThemeConfig.GetStringSlice("views.beneficiaries.display.files") profileFields := renderer.GlobalConfig.Get("modules.beneficiaries.profile_optional_fields") state := NewState(r, renderer.ThemeConfig, beneficiariesMenu) state.ViewState = map[string]any{ - "beneficiary": beneficiary, - "bookings": bookings, - "beneficiaries_file_types": beneficiaries_file_types, - "file_types_map": file_types_map, - "documents": documents, - "organizations": organizations, - "event": event, - "diags": diags, - "solidarity_transport_stats": solidarityTransportStats, - "profile_optional_fields": profileFields, - "wallet_balance": walletBalance, + "beneficiary": beneficiary, + "bookings": bookings, + "beneficiaries_file_types": beneficiaries_file_types, + "file_types_map": file_types_map, + "documents": documents, + "organizations": organizations, + "event": event, + "solidarity_transport_stats": solidarityTransportStats, + "solidarity_transport_bookings": solidarityTransportBookings, + "solidarity_transport_drivers_map": solidarityDriversMap, + "organized_carpool_stats": organizedCarpoolStats, + "organized_carpool_bookings": organizedCarpoolBookings, + "organized_carpool_drivers_map": organizedCarpoolDriversMap, + "profile_optional_fields": profileFields, + "wallet_balance": walletBalance, + "tab": tab, + "search_view": renderer.GlobalConfig.GetString("modules.journeys.search_view"), } renderer.Render("beneficiaries_display", w, r, files, state) } diff --git a/renderer/dashboard.go b/renderer/dashboard.go index 0caf84b..0680e68 100755 --- a/renderer/dashboard.go +++ b/renderer/dashboard.go @@ -5,11 +5,12 @@ import ( agendastorage "git.coopgo.io/coopgo-platform/agenda/storage" fleetstorage "git.coopgo.io/coopgo-platform/fleets/storage" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" ) const dashboardMenu = "dashboard" -func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, accounts []any, nbaccounts int, count_members int, events []agendastorage.Event, fleets []fleetstorage.Booking) { +func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, accounts any, nbaccounts int, count_members int, events []agendastorage.Event, fleets []fleetstorage.Booking, solidarityDrivers []mobilityaccountsstorage.Account, organizedCarpoolDrivers []mobilityaccountsstorage.Account, driverAddressGeo string, enrichedGeoFilters []map[string]string) { files := renderer.ThemeConfig.GetStringSlice("views.dashboard.files") state := NewState(r, renderer.ThemeConfig, dashboardMenu) state.ViewState = map[string]any{ @@ -17,9 +18,16 @@ func (renderer *Renderer) Dashboard(w http.ResponseWriter, r *http.Request, acco "count": nbaccounts, "latest": accounts, }, - "count_members": count_members, - "events": events, - "fleets": fleets, + "count_members": count_members, + "events": events, + "fleets": fleets, + "solidarity_drivers": solidarityDrivers, + "organized_carpool_drivers": organizedCarpoolDrivers, + "geography_filters_enabled": renderer.GlobalConfig.GetBool("geography.filters.enabled"), + "geography_filters_list": enrichedGeoFilters, + "filters": map[string]any{ + "driver_address_geo": driverAddressGeo, + }, } renderer.Render("dashboard", w, r, files, state) diff --git a/renderer/diags.go b/renderer/diags.go deleted file mode 100644 index 0ef0a1e..0000000 --- a/renderer/diags.go +++ /dev/null @@ -1,115 +0,0 @@ -package renderer - -import ( - "net/http" - - diagsstorage "git.coopgo.io/coopgo-platform/diags/storage" -) - -const diagsMenu = "diags" - -func (renderer *Renderer) DiagsHome(w http.ResponseWriter, r *http.Request, diags []diagsstorage.Diag, groups map[string]any) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.list.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - state.ViewState = map[string]any{ - "diags": diags, - "groups": groups, - } - - renderer.Render("diags home", w, r, files, state) -} - -func (renderer *Renderer) DiagsHistory(w http.ResponseWriter, r *http.Request, diags []diagsstorage.Diag) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.history.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - state.ViewState = map[string]any{ - "diags": diags, - } - - renderer.Render("diags history", w, r, files, state) -} - -func (renderer *Renderer) BeneficiariesCreateDiag(w http.ResponseWriter, r *http.Request, beneficiary string, diags_file_types []string, file_types_map map[string]string, documents any) { - state := NewState(r, renderer.ThemeConfig, diagsMenu) - files := renderer.ThemeConfig.GetStringSlice("views.beneficiaries.create_diag.files") - state.ViewState = map[string]any{ - "beneficiary": beneficiary, - "diags_file_types": diags_file_types, - "file_types_map": file_types_map, - "documents": documents, - } - renderer.Render("diag create for beneficiary", w, r, files, state) -} - -func (renderer *Renderer) VehiclesCreateDiag(w http.ResponseWriter, r *http.Request, vehicle string) { - state := NewState(r, renderer.ThemeConfig, diagsMenu) - files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.create_vehicle_diag.files") - state.ViewState = map[string]any{ - "vehicle": vehicle, - } - renderer.Render("diag create for vehicle", w, r, files, state) -} - -func (renderer *Renderer) BookingsCreateDiag(w http.ResponseWriter, r *http.Request, booking string) { - state := NewState(r, renderer.ThemeConfig, diagsMenu) - files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.create_booking_diag.files") - state.ViewState = map[string]any{ - "booking": booking, - } - renderer.Render("diag create for booking", w, r, files, state) -} - -func (renderer *Renderer) VehicleBookingsCreateDiag(w http.ResponseWriter, r *http.Request, booking string) { - state := NewState(r, renderer.ThemeConfig, diagsMenu) - files := renderer.ThemeConfig.GetStringSlice("views.vehicles.create_booking_diag.files") - state.ViewState = map[string]any{ - "booking": booking, - } - renderer.Render("diag create for booking", w, r, files, state) -} - -func (renderer *Renderer) DiagsDisplayDiag(w http.ResponseWriter, r *http.Request, diag any, diags_file_types []string, file_types_map map[string]string, documents any) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.display_diag.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - - state.ViewState = map[string]any{ - "diag": diag, - "diags_file_types": diags_file_types, - "file_types_map": file_types_map, - "documents": documents, - } - - renderer.Render("diags create diag", w, r, files, state) -} - -func (renderer *Renderer) DiagsHistoryDiag(w http.ResponseWriter, r *http.Request, diag any) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.history_diag.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - state.ViewState = map[string]any{ - "diag": diag, - } - - renderer.Render("diags history diag", w, r, files, state) -} - -func (renderer *Renderer) DiagUpdate(w http.ResponseWriter, r *http.Request, diag any) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.update.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - - state.ViewState = map[string]any{ - "diag": diag, - } - - renderer.Render("diag_update", w, r, files, state) -} - -func (renderer *Renderer) DiagDelete(w http.ResponseWriter, r *http.Request, diag any) { - files := renderer.ThemeConfig.GetStringSlice("views.diags.delete.files") - state := NewState(r, renderer.ThemeConfig, diagsMenu) - - state.ViewState = map[string]any{ - "diag": diag, - } - - renderer.Render("diag_deleteDiag", w, r, files, state) -} \ No newline at end of file diff --git a/renderer/func-maps.go b/renderer/func-maps.go index e42882e..9a4902f 100755 --- a/renderer/func-maps.go +++ b/renderer/func-maps.go @@ -5,12 +5,13 @@ import ( "encoding/json" "fmt" "html/template" + "math" "reflect" "strings" "time" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" - validatedprofile "git.coopgo.io/coopgo-apps/parcoursmob/utils/validated-profile" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + validatedprofile "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/validated-profile" groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage" "github.com/rs/zerolog/log" "github.com/spf13/viper" @@ -151,6 +152,24 @@ func strval(v interface{}) string { } } +// JSEscape escapes a string for safe use in JavaScript +func JSEscape(s string) template.JS { + return template.JS(template.JSEscapeString(s)) +} + +// IsGuaranteedTripMotivation checks if a motivation is a guaranteed trip +func IsGuaranteedTripMotivation(globalConfig *viper.Viper) func(string) bool { + return func(motivation string) bool { + guaranteedMotivations := globalConfig.GetStringSlice("modules.solidarity_transport.guaranteed_trip_motivations") + for _, m := range guaranteedMotivations { + if m == motivation { + return true + } + } + return false + } +} + // GetTemplateFuncMap returns the common template functions for rendering func GetTemplateFuncMap(group groupsstorage.Group, globalConfig *viper.Viper, fileStorage filestorage.FileStorage) template.FuncMap { return template.FuncMap{ @@ -162,14 +181,17 @@ func GetTemplateFuncMap(group groupsstorage.Group, globalConfig *viper.Viper, fi "json": JSON, "rawjson": RawJSON, "unescapeHTML": UnescapeHTML, + "jsEscape": JSEscape, "walkingLength": WalkingLength, "divideFloat64": Divide[float64], "divideInt": Divide[int], "typeOf": reflect.TypeOf, "shortDuration": ShortDuration, + "round2": Round2, "beneficiaryValidatedProfile": validatedprofile.ValidateProfile(globalConfig.Sub("modules.beneficiaries.validated_profile")), "solidarityDriverValidatedProfile": validatedprofile.ValidateProfile(globalConfig.Sub("modules.solidarity_transport.drivers.validated_profile")), "carpoolDriverValidatedProfile": validatedprofile.ValidateProfile(globalConfig.Sub("modules.organized_carpool.drivers.validated_profile")), + "isGuaranteedTripMotivation": IsGuaranteedTripMotivation(globalConfig), "beneficiaryDocuments": func(id string) []filestorage.FileInfo { return fileStorage.List(filestorage.PREFIX_BENEFICIARIES + "/" + id) }, @@ -211,3 +233,25 @@ func ShortDuration(d interface{}) string { } return s } + +// Round2 rounds a float64 to 2 decimal places to avoid floating point issues +func Round2(value interface{}) float64 { + var f float64 + switch v := value.(type) { + case float64: + f = v + case *float64: + if v != nil { + f = *v + } + case float32: + f = float64(v) + case int: + f = float64(v) + case int64: + f = float64(v) + default: + return 0 + } + return math.Round(f*100) / 100 +} diff --git a/renderer/journeys.go b/renderer/journeys.go index 00776c2..250d70a 100755 --- a/renderer/journeys.go +++ b/renderer/journeys.go @@ -36,7 +36,7 @@ func (s BeneficiariesCovoiturage) JSONWithLimits(a int, b int) template.JS { return s.JSON() } -func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, carpools []*geojson.FeatureCollection, transitjourneys any, vehicles any, searched bool, departure any, destination any, departuredate string, departuretime string, driverJourneys any, solidarityDrivers any, organizedCarpools any, beneficiaries any, kbData any, passengerid string) { +func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, carpools []*geojson.FeatureCollection, transitjourneys any, vehicles any, searched bool, departure any, destination any, departuredate string, departuretime string, driverJourneys any, solidarityDrivers any, organizedCarpools any, beneficiaries any, kbData any, passengerid string, savedSearches any, beneficiariesMap any) { files := renderer.ThemeConfig.GetStringSlice("views.journeys.search.files") state := NewState(r, renderer.ThemeConfig, journeysMenu) journeyTabs := renderer.ThemeConfig.Get("journey_tabs") @@ -53,10 +53,13 @@ func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, "driver_journeys": driverJourneys, "solidarity_drivers": solidarityDrivers, "querystring": r.URL.RawQuery, - "beneficiaries": beneficiaries, + "beneficiaries": beneficiariesMap, + "beneficiaries_list": beneficiaries, "kb_data": kbData, "passengerid": passengerid, "journey_tabs": journeyTabs, + "saved_searches": savedSearches, + "search_view": renderer.GlobalConfig.GetString("modules.journeys.search_view"), } renderer.Render("journeys", w, r, files, state) @@ -156,3 +159,28 @@ func (renderer *Renderer) UpdateGroupCovoiturage(w http.ResponseWriter, r *http. } renderer.Render("journeys", w, r, files, state) } + +func (renderer *Renderer) JourneysSearchCompact(w http.ResponseWriter, r *http.Request, carpools []*geojson.FeatureCollection, transitjourneys any, vehicles any, searched bool, departure any, destination any, departuredate string, departuretime string, driverJourneys any, solidarityDrivers any, organizedCarpools any, kbData any, passengerid string) { + files := renderer.ThemeConfig.GetStringSlice("views.journeys.search_compact.files") + vehicleOptionalFields := renderer.GlobalConfig.Get("modules.fleets.vehicle_optional_fields") + + state := NewState(r, renderer.ThemeConfig, journeysMenu) + state.ViewState = map[string]any{ + "searched": searched, + "departuredate": departuredate, + "departuretime": departuretime, + "departure": departure, + "destination": destination, + "journeys": transitjourneys, + "carpools": carpools, + "organized_carpools": organizedCarpools, + "vehicles": vehicles, + "vehicle_optional_fields": vehicleOptionalFields, + "driver_journeys": driverJourneys, + "solidarity_drivers": solidarityDrivers, + "kb_data": kbData, + "passengerid": passengerid, + } + + renderer.Render("journeys", w, r, files, state) +} diff --git a/renderer/organized-carpool.go b/renderer/organized-carpool.go index b091fb3..3b760d5 100644 --- a/renderer/organized-carpool.go +++ b/renderer/organized-carpool.go @@ -4,18 +4,33 @@ import ( "net/http" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/payments/pricing" ) const organizedCarpoolMenu = "organized_carpool" -func (renderer *Renderer) OrganizedCarpoolOverview(w http.ResponseWriter, r *http.Request, drivers any, driversMap any, passengersMap any, bookings any) { +func (renderer *Renderer) OrganizedCarpoolOverview(w http.ResponseWriter, r *http.Request, drivers any, driversMap any, passengersMap any, bookings any, bookingsHistory any, filters map[string]any, histFilters map[string]any, tab string, enrichedGeoFilters []map[string]string, archived bool) { files := renderer.ThemeConfig.GetStringSlice("views.organized_carpool.overview.files") + tripsItemsPerPage := renderer.GlobalConfig.GetInt("modules.organized_carpool.pagination.trips_items_per_page") + driversItemsPerPage := renderer.GlobalConfig.GetInt("modules.organized_carpool.pagination.drivers_items_per_page") + + geoFiltersEnabled := len(enrichedGeoFilters) > 0 + state := NewState(r, renderer.ThemeConfig, organizedCarpoolMenu) state.ViewState = map[string]any{ - "drivers": drivers, - "drivers_map": driversMap, - "passengers_map": passengersMap, - "bookings": bookings, + "drivers": drivers, + "drivers_map": driversMap, + "passengers_map": passengersMap, + "bookings": bookings, + "bookings_history": bookingsHistory, + "filters": filters, + "hist_filters": histFilters, + "tab": tab, + "trips_items_per_page": tripsItemsPerPage, + "drivers_items_per_page": driversItemsPerPage, + "geography_filters_enabled": geoFiltersEnabled, + "geography_filters_list": enrichedGeoFilters, + "archived": archived, } renderer.Render("organized carpool overview", w, r, files, state) @@ -39,7 +54,7 @@ func (renderer *Renderer) OrganizedCarpoolUpdateDriver(w http.ResponseWriter, r renderer.Render("organized carpool driver update", w, r, files, state) } -func (renderer *Renderer) OrganizedCarpoolDriverDisplay(w http.ResponseWriter, r *http.Request, driver mobilityaccountsstorage.Account, trips any, documents any) { +func (renderer *Renderer) OrganizedCarpoolDriverDisplay(w http.ResponseWriter, r *http.Request, driver mobilityaccountsstorage.Account, trips any, documents any, bookings any, beneficiariesMap any, stats map[string]any, walletBalance float64, tab string) { files := renderer.ThemeConfig.GetStringSlice("views.organized_carpool.driver_display.files") state := NewState(r, renderer.ThemeConfig, organizedCarpoolMenu) @@ -50,22 +65,31 @@ func (renderer *Renderer) OrganizedCarpoolDriverDisplay(w http.ResponseWriter, r "driver": driver, "trips": trips, "documents": documents, + "bookings": bookings, + "beneficiaries_map": beneficiariesMap, + "stats": stats, "drivers_file_types": drivers_file_types, "file_types_map": file_types_map, + "wallet_balance": walletBalance, + "tab": tab, } renderer.Render("organized carpool driver display", w, r, files, state) } -func (renderer *Renderer) OrganizedCarpoolJourney(w http.ResponseWriter, r *http.Request, journey any, driver any, passenger any, beneficiaries any) { +func (renderer *Renderer) OrganizedCarpoolJourney(w http.ResponseWriter, r *http.Request, journey any, driver any, passenger any, beneficiaries any, passengerWalletBalance float64, pricingResult map[string]pricing.Price) { files := renderer.ThemeConfig.GetStringSlice("views.organized_carpool.journey.files") - state := NewState(r, renderer.ThemeConfig, solidarityTransportMenu) + bookingMotivations := renderer.GlobalConfig.Get("modules.organized_carpool.booking_motivations") + state := NewState(r, renderer.ThemeConfig, organizedCarpoolMenu) state.ViewState = map[string]any{ - "driver": driver, - "passenger": passenger, - "beneficiaries": beneficiaries, - "journey": journey, - "config": renderer.GlobalConfig, + "driver": driver, + "passenger": passenger, + "beneficiaries": beneficiaries, + "journey": journey, + "config": renderer.GlobalConfig, + "booking_motivations": bookingMotivations, + "passenger_wallet_balance": passengerWalletBalance, + "pricing_result": pricingResult, } renderer.Render("organized carpool journey", w, r, files, state) @@ -75,11 +99,11 @@ func (renderer *Renderer) OrganizedCarpoolBookingDisplay(w http.ResponseWriter, files := renderer.ThemeConfig.GetStringSlice("views.organized_carpool.booking_display.files") state := NewState(r, renderer.ThemeConfig, organizedCarpoolMenu) state.ViewState = map[string]any{ - "driver": driver, - "passenger": passenger, - "booking": booking, - "driverDepartureAddress": driverDepartureAddress, - "driverArrivalAddress": driverArrivalAddress, + "driver": driver, + "passenger": passenger, + "booking": booking, + "driverDepartureAddress": driverDepartureAddress, + "driverArrivalAddress": driverArrivalAddress, } renderer.Render("organized carpool booking display", w, r, files, state) diff --git a/renderer/renderer.go b/renderer/renderer.go index d15a0d9..606806e 100755 --- a/renderer/renderer.go +++ b/renderer/renderer.go @@ -5,9 +5,10 @@ import ( "html/template" "net/http" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/icons" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/identification" - cache "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/icons" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + cache "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + xlsxrenderer "git.coopgo.io/coopgo-apps/parcoursmob/renderer/xlsx" "git.coopgo.io/coopgo-platform/emailing" "git.coopgo.io/coopgo-platform/groups-management/storage" "github.com/coreos/go-oidc/v3/oidc" @@ -21,6 +22,7 @@ type Renderer struct { ThemeConfig *viper.Viper Mailer *emailing.Mailer FileStorage cache.FileStorage + XLSX *xlsxrenderer.XLSXRenderer } func NewRenderer(global *viper.Viper, templates_dir string, filestorage cache.FileStorage) *Renderer { @@ -36,6 +38,7 @@ func NewRenderer(global *viper.Viper, templates_dir string, filestorage cache.Fi GlobalConfig: global, ThemeConfig: theme, FileStorage: filestorage, + XLSX: xlsxrenderer.NewXLSXRenderer(global), } } @@ -138,7 +141,8 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende Active: menuState == administrationMenu, }, - Menu: menu, + Menu: menu, + ActiveMenu: menuState, // DEPRECATED MenuItems: []MenuItem{ @@ -232,14 +236,6 @@ func NewState(r *http.Request, themeConfig *viper.Viper, menuState string) Rende Icon: "hero:outline/document-text", }) } - /*if modules["diags"] != nil && modules["diags"].(bool) { - ls.MenuItems = append(ls.MenuItems, MenuItem{ - Title: "Diagnostics", - Link: "/app/diags/", - Active: menuState == diagsMenu, - Icon: "hero:outline/document-text", - }) - }*/ return RenderState{ IconSet: icons.NewIconSet(iconset), diff --git a/renderer/solidarity-transport.go b/renderer/solidarity-transport.go index 84dea43..47da5db 100644 --- a/renderer/solidarity-transport.go +++ b/renderer/solidarity-transport.go @@ -4,22 +4,37 @@ import ( "net/http" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "git.coopgo.io/coopgo-platform/payments/pricing" ) const solidarityTransportMenu = "solidarity_transport" -func (renderer *Renderer) SolidarityTransportOverview(w http.ResponseWriter, r *http.Request, drivers any, driversMap any, passengersMap any, bookings any, bookingsHistory any, filters any, hist_filters any, tab string) { +func (renderer *Renderer) SolidarityTransportOverview(w http.ResponseWriter, r *http.Request, drivers any, driversMap any, passengersMap any, bookings any, bookingsHistory any, filters any, hist_filters any, tab string, enrichedGeoFilters []map[string]string, archived bool) { files := renderer.ThemeConfig.GetStringSlice("views.solidarity_transport.overview.files") + tripsItemsPerPage := renderer.GlobalConfig.GetInt("modules.solidarity_transport.pagination.trips_items_per_page") + driversItemsPerPage := renderer.GlobalConfig.GetInt("modules.solidarity_transport.pagination.drivers_items_per_page") + + guaranteedMotivations := renderer.GlobalConfig.GetStringSlice("modules.solidarity_transport.guaranteed_trip_motivations") + + // Geography filters + geoFiltersEnabled := len(enrichedGeoFilters) > 0 + state := NewState(r, renderer.ThemeConfig, solidarityTransportMenu) state.ViewState = map[string]any{ - "drivers": drivers, - "drivers_map": driversMap, - "passengers_map": passengersMap, - "bookings": bookings, - "bookings_history": bookingsHistory, - "filters": filters, - "hist_filters": hist_filters, - "tab": tab, + "drivers": drivers, + "drivers_map": driversMap, + "passengers_map": passengersMap, + "bookings": bookings, + "bookings_history": bookingsHistory, + "filters": filters, + "hist_filters": hist_filters, + "tab": tab, + "trips_items_per_page": tripsItemsPerPage, + "drivers_items_per_page": driversItemsPerPage, + "guaranteed_trip_motivations": guaranteedMotivations, + "geography_filters_enabled": geoFiltersEnabled, + "geography_filters_list": enrichedGeoFilters, + "archived": archived, } renderer.Render("solidarity transport overview", w, r, files, state) @@ -50,7 +65,7 @@ func (renderer *Renderer) SolidarityTransportUpdateDriver(w http.ResponseWriter, renderer.Render("solidarity transport driver update", w, r, files, state) } -func (renderer *Renderer) SolidarityTransportDriverDisplay(w http.ResponseWriter, r *http.Request, driver mobilityaccountsstorage.Account, availabilities any, documents any, bookings any, stats map[string]any, walletBalance float64) { +func (renderer *Renderer) SolidarityTransportDriverDisplay(w http.ResponseWriter, r *http.Request, driver mobilityaccountsstorage.Account, availabilities any, documents any, bookings any, beneficiariesMap any, stats map[string]any, walletBalance float64, tab string) { files := renderer.ThemeConfig.GetStringSlice("views.solidarity_transport.driver_display.files") profileFields := renderer.GlobalConfig.Get("modules.solidarity_transport.drivers.profile_optional_fields") state := NewState(r, renderer.ThemeConfig, solidarityTransportMenu) @@ -62,19 +77,22 @@ func (renderer *Renderer) SolidarityTransportDriverDisplay(w http.ResponseWriter "driver": driver, "availabilities": availabilities, "bookings": bookings, + "beneficiaries_map": beneficiariesMap, "documents": documents, "drivers_file_types": drivers_file_types, "file_types_map": file_types_map, "stats": stats, "profile_optional_fields": profileFields, "wallet_balance": walletBalance, + "tab": tab, } renderer.Render("solidarity transport driver creation", w, r, files, state) } -func (renderer *Renderer) SolidarityTransportDriverJourney(w http.ResponseWriter, r *http.Request, driverJourney any, driver any, passenger any, beneficiaries any, passengerWalletBalance float64) { +func (renderer *Renderer) SolidarityTransportDriverJourney(w http.ResponseWriter, r *http.Request, driverJourney any, driver any, passenger any, beneficiaries any, passengerWalletBalance float64, pricingResult map[string]pricing.Price) { files := renderer.ThemeConfig.GetStringSlice("views.solidarity_transport.driver_journey.files") + bookingMotivations := renderer.GlobalConfig.Get("modules.solidarity_transport.booking_motivations") state := NewState(r, renderer.ThemeConfig, solidarityTransportMenu) state.ViewState = map[string]any{ "driver": driver, @@ -83,6 +101,8 @@ func (renderer *Renderer) SolidarityTransportDriverJourney(w http.ResponseWriter "driver_journey": driverJourney, "config": renderer.GlobalConfig, "passenger_wallet_balance": passengerWalletBalance, + "pricing_result": pricingResult, + "booking_motivations": bookingMotivations, } renderer.Render("solidarity transport driver creation", w, r, files, state) @@ -90,12 +110,14 @@ func (renderer *Renderer) SolidarityTransportDriverJourney(w http.ResponseWriter func (renderer *Renderer) SolidarityTransportBookingDisplay(w http.ResponseWriter, r *http.Request, booking any, driver any, passenger any, passengerWalletBalance float64) { files := renderer.ThemeConfig.GetStringSlice("views.solidarity_transport.booking_display.files") + bookingMotivations := renderer.GlobalConfig.Get("modules.solidarity_transport.booking_motivations") state := NewState(r, renderer.ThemeConfig, solidarityTransportMenu) state.ViewState = map[string]any{ "driver": driver, "passenger": passenger, "booking": booking, "passenger_wallet_balance": passengerWalletBalance, + "booking_motivations": bookingMotivations, } renderer.Render("booking display", w, r, files, state) diff --git a/renderer/vehicle-management.go b/renderer/vehicle-management.go index 6826998..25e62f1 100755 --- a/renderer/vehicle-management.go +++ b/renderer/vehicle-management.go @@ -3,7 +3,7 @@ package renderer import ( "net/http" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" ) @@ -23,7 +23,7 @@ func (renderer *Renderer) VehiclesManagementOverview(w http.ResponseWriter, r *h renderer.Render("fleet overview", w, r, files, state) } -func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request, vehiclesMap map[string]fleetsstorage.Vehicle, driversMap map[string]mobilityaccountsstorage.Account, bookings []fleetsstorage.Booking, cacheid string) { +func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, r *http.Request, vehiclesMap map[string]fleetsstorage.Vehicle, driversMap map[string]mobilityaccountsstorage.Account, bookings []fleetsstorage.Booking, cacheid string, filters map[string]string) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.bookings_list.files") state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu) state.ViewState = map[string]any{ @@ -31,6 +31,7 @@ func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, "vehicles_map": vehiclesMap, "drivers_map": driversMap, "cacheid": cacheid, + "filters": filters, } renderer.Render("fleet overview", w, r, files, state) @@ -38,21 +39,26 @@ func (renderer *Renderer) VehiclesManagementBookingsList(w http.ResponseWriter, func (renderer *Renderer) VehiclesFleetAdd(w http.ResponseWriter, r *http.Request, vehicle_types []string) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.fleet_add.files") + vehicleOptionalFields := renderer.GlobalConfig.Get("modules.fleets.vehicle_optional_fields") + state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu) state.ViewState = map[string]any{ - "vehicle_types": vehicle_types, + "vehicle_types": vehicle_types, + "vehicle_optional_fields": vehicleOptionalFields, } renderer.Render("fleet add vehicle", w, r, files, state) } -func (renderer *Renderer) VehiclesFleetDisplay(w http.ResponseWriter, r *http.Request, vehicle any, beneficiaries any, diags []any) { +func (renderer *Renderer) VehiclesFleetDisplay(w http.ResponseWriter, r *http.Request, vehicle any, beneficiaries any) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.fleet_display.files") + vehicleOptionalFields := renderer.GlobalConfig.Get("modules.fleets.vehicle_optional_fields") + state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu) state.ViewState = map[string]any{ - "vehicle": vehicle, - "beneficiaries": beneficiaries, - "diags": diags, + "vehicle": vehicle, + "beneficiaries": beneficiaries, + "vehicle_optional_fields": vehicleOptionalFields, } renderer.Render("fleet display vehicle", w, r, files, state) @@ -60,16 +66,19 @@ func (renderer *Renderer) VehiclesFleetDisplay(w http.ResponseWriter, r *http.Re func (renderer *Renderer) VehiclesFleetUpdate(w http.ResponseWriter, r *http.Request, vehicle any, vehicle_types []string) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.fleet_update.files") + vehicleOptionalFields := renderer.GlobalConfig.Get("modules.fleets.vehicle_optional_fields") + state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu) state.ViewState = map[string]any{ - "vehicle": vehicle, - "vehicle_types": vehicle_types, + "vehicle": vehicle, + "vehicle_types": vehicle_types, + "vehicle_optional_fields": vehicleOptionalFields, } renderer.Render("fleet display vehicle", w, r, files, state) } -func (renderer *Renderer) VehicleManagementBookingDisplay(w http.ResponseWriter, r *http.Request, booking any, vehicle any, beneficiary any, group any, documents []filestorage.FileInfo, file_types_map map[string]string, alternative_vehicles []any, diags []any) { +func (renderer *Renderer) VehicleManagementBookingDisplay(w http.ResponseWriter, r *http.Request, booking any, vehicle any, beneficiary any, group any, documents []filestorage.FileInfo, file_types_map map[string]string, alternative_vehicles []any) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles_management.booking_display.files") state := NewState(r, renderer.ThemeConfig, vehiclesmanagementMenu) state.ViewState = map[string]any{ @@ -80,7 +89,6 @@ func (renderer *Renderer) VehicleManagementBookingDisplay(w http.ResponseWriter, "documents": documents, "file_types_map": file_types_map, "alternative_vehicles": alternative_vehicles, - "diags": diags, } renderer.Render("vehicles search", w, r, files, state) diff --git a/renderer/vehicles.go b/renderer/vehicles.go index 80d1fa6..b4d1529 100755 --- a/renderer/vehicles.go +++ b/renderer/vehicles.go @@ -3,7 +3,7 @@ package renderer import ( "net/http" - filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage" + filestorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" "git.coopgo.io/coopgo-platform/fleets/storage" fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" @@ -53,7 +53,7 @@ func (renderer *Renderer) VehiclesSearch(w http.ResponseWriter, r *http.Request, renderer.Render("vehicles search", w, r, files, state) } -func (renderer *Renderer) VehicleBookingDisplay(w http.ResponseWriter, r *http.Request, booking any, vehicle any, beneficiary any, group any, documents []filestorage.FileInfo, file_types_map map[string]string, diags []any) { +func (renderer *Renderer) VehicleBookingDisplay(w http.ResponseWriter, r *http.Request, booking any, vehicle any, beneficiary any, group any, documents []filestorage.FileInfo, file_types_map map[string]string) { files := renderer.ThemeConfig.GetStringSlice("views.vehicles.booking_display.files") state := NewState(r, renderer.ThemeConfig, vehiclesMenu) state.ViewState = map[string]any{ @@ -63,7 +63,6 @@ func (renderer *Renderer) VehicleBookingDisplay(w http.ResponseWriter, r *http.R "group": group, "documents": documents, "file_types_map": file_types_map, - "diags": diags, } renderer.Render("vehicles search", w, r, files, state) diff --git a/renderer/xlsx/organized-carpool.go b/renderer/xlsx/organized-carpool.go new file mode 100644 index 0000000..c07f1bc --- /dev/null +++ b/renderer/xlsx/organized-carpool.go @@ -0,0 +1,273 @@ +package xlsx + +import ( + "fmt" + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/gender" + "github.com/rs/zerolog/log" +) + +func (r *XLSXRenderer) OrganizedCarpoolBookings(w http.ResponseWriter, result *application.OrganizedCarpoolBookingsResult) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Covoiturage solidaire") + + // Build headers dynamically based on configuration + headers := []string{ + "ID Réservation", + "Statut", + "Motif de réservation", + "Date de prise en charge", + "Heure de prise en charge", + } + + // Add driver fields from config + driverOptionalFields := r.Config.Get("modules.organized_carpool.profile_optional_fields") + driverFields := []string{"last_name", "first_name", "email", "phone_number"} + driverHeaders := []string{"Conducteur - Nom", "Conducteur - Prénom", "Conducteur - Email", "Conducteur - Téléphone"} + + if driverOptionalFieldsList, ok := driverOptionalFields.([]interface{}); ok { + for _, field := range driverOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + driverFields = append(driverFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + driverHeaders = append(driverHeaders, fmt.Sprintf("Conducteur - %s", label)) + } + } + } + } + headers = append(headers, driverHeaders...) + + // Add beneficiary fields from config + beneficiaryOptionalFields := r.Config.Get("modules.beneficiaries.profile_optional_fields") + beneficiaryFields := []string{"last_name", "first_name", "email", "phone_number"} + beneficiaryHeaders := []string{"Bénéficiaire - Nom", "Bénéficiaire - Prénom", "Bénéficiaire - Email", "Bénéficiaire - Téléphone"} + + if beneficiaryOptionalFieldsList, ok := beneficiaryOptionalFields.([]interface{}); ok { + for _, field := range beneficiaryOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + beneficiaryFields = append(beneficiaryFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + beneficiaryHeaders = append(beneficiaryHeaders, fmt.Sprintf("Bénéficiaire - %s", label)) + } + } + } + } + headers = append(headers, beneficiaryHeaders...) + + // Add journey information headers + headers = append(headers, + "Lieu de départ - Adresse", + "Destination - Adresse", + "Distance passager (km)", + "Durée trajet (minutes)", + "Prix passager", + "Devise prix passager", + "Compensation conducteur", + "Devise compensation", + ) + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, booking := range result.Bookings { + driver := result.DriversMap[booking.Driver.Id] + beneficiary := result.BeneficiariesMap[booking.Passenger.Id] + + row := []interface{}{} + + // Booking information + row = append(row, booking.Id) + row = append(row, booking.Status.String()) + + // Motivation + motivation := "" + if booking.Motivation != nil { + motivation = *booking.Motivation + } + row = append(row, motivation) + + // Journey date and time + row = append(row, booking.PassengerPickupDate.AsTime().Format("2006-01-02")) + row = append(row, booking.PassengerPickupDate.AsTime().Format("15:04")) + + // Driver data + for _, field := range driverFields { + row = append(row, getAccountFieldValue(driver.Data, field)) + } + + // Beneficiary data + for _, field := range beneficiaryFields { + row = append(row, getAccountFieldValue(beneficiary.Data, field)) + } + + // Journey information + if booking.PassengerPickupAddress != nil { + row = append(row, *booking.PassengerPickupAddress) + } else { + row = append(row, "") + } + + if booking.PassengerDropAddress != nil { + row = append(row, *booking.PassengerDropAddress) + } else { + row = append(row, "") + } + + // Distance + if booking.Distance != nil { + row = append(row, *booking.Distance) + } else { + row = append(row, "") + } + + // Duration + if booking.Duration != nil { + row = append(row, *booking.Duration) + } else { + row = append(row, "") + } + + // Pricing + if booking.Price != nil && booking.Price.Amount != nil { + row = append(row, fmt.Sprintf("%.2f", *booking.Price.Amount)) + if booking.Price.Currency != nil { + row = append(row, *booking.Price.Currency) + } else { + row = append(row, "") + } + } else { + row = append(row, "", "") + } + + // Driver compensation + if booking.DriverCompensationAmount != nil { + row = append(row, fmt.Sprintf("%.2f", *booking.DriverCompensationAmount)) + if booking.DriverCompensationCurrency != nil { + row = append(row, *booking.DriverCompensationCurrency) + } else { + row = append(row, "") + } + } else { + row = append(row, "", "") + } + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"export-covoiturage-solidaire.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} + +func (r *XLSXRenderer) OrganizedCarpoolDrivers(w http.ResponseWriter, result *application.OrganizedCarpoolOverviewResult) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Covoitureurs solidaires") + + // Build headers dynamically based on configuration + driverOptionalFields := r.Config.Get("modules.organized_carpool.drivers.profile_optional_fields") + driverFields := []string{"last_name", "first_name", "email", "phone_number", "birthdate", "gender", "file_number"} + headers := []string{"ID", "Nom", "Prénom", "Email", "Téléphone", "Date de naissance", "Genre", "Numéro de dossier"} + + if driverOptionalFieldsList, ok := driverOptionalFields.([]interface{}); ok { + for _, field := range driverOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + driverFields = append(driverFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + headers = append(headers, label) + } + } + } + } + + // Add address columns + headers = append(headers, "Adresse départ", "Adresse destination", "Archivé") + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, driver := range result.Accounts { + row := []interface{}{} + + // Driver ID + row = append(row, driver.ID) + + // Driver data + for _, field := range driverFields { + value := getAccountFieldValue(driver.Data, field) + // Convert gender code to text + if field == "gender" && value != "" { + value = gender.ISO5218ToString(value) + } + row = append(row, value) + } + + // Address departure + addressDeparture := "" + if addr, ok := driver.Data["address"]; ok { + if addrMap, ok := addr.(map[string]interface{}); ok { + if props, ok := addrMap["properties"]; ok { + if propsMap, ok := props.(map[string]interface{}); ok { + if label, ok := propsMap["label"].(string); ok { + addressDeparture = label + } + } + } + } + } + row = append(row, addressDeparture) + + // Address destination + addressDestination := "" + if addr, ok := driver.Data["address_destination"]; ok { + if addrMap, ok := addr.(map[string]interface{}); ok { + if props, ok := addrMap["properties"]; ok { + if propsMap, ok := props.(map[string]interface{}); ok { + if label, ok := propsMap["label"].(string); ok { + addressDestination = label + } + } + } + } + } + row = append(row, addressDestination) + + // Archived status + archived := "Non" + if archivedVal, ok := driver.Data["archived"].(bool); ok && archivedVal { + archived = "Oui" + } + row = append(row, archived) + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"export-covoitureurs-solidaires.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} diff --git a/renderer/xlsx/solidarity-transport.go b/renderer/xlsx/solidarity-transport.go new file mode 100644 index 0000000..a78e3c5 --- /dev/null +++ b/renderer/xlsx/solidarity-transport.go @@ -0,0 +1,320 @@ +package xlsx + +import ( + "fmt" + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/gender" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" +) + +func (r *XLSXRenderer) SolidarityTransportBookings(w http.ResponseWriter, result *application.SolidarityTransportBookingsResult) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Transport solidaire") + + // Build headers dynamically based on configuration + headers := []string{ + "ID Réservation", + "Statut", + "Motif de réservation", + "Raison d'annulation", + "Date de prise en charge", + "Heure de prise en charge", + } + + // Add driver fields from config + driverOptionalFields := r.Config.Get("modules.solidarity_transport.profile_optional_fields") + driverFields := []string{"last_name", "first_name", "email", "phone_number"} + driverHeaders := []string{"Conducteur - Nom", "Conducteur - Prénom", "Conducteur - Email", "Conducteur - Téléphone"} + + if driverOptionalFieldsList, ok := driverOptionalFields.([]interface{}); ok { + for _, field := range driverOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + driverFields = append(driverFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + driverHeaders = append(driverHeaders, fmt.Sprintf("Conducteur - %s", label)) + } + } + } + } + headers = append(headers, driverHeaders...) + + // Add beneficiary fields from config + beneficiaryOptionalFields := r.Config.Get("modules.beneficiaries.profile_optional_fields") + beneficiaryFields := []string{"last_name", "first_name", "email", "phone_number"} + beneficiaryHeaders := []string{"Bénéficiaire - Nom", "Bénéficiaire - Prénom", "Bénéficiaire - Email", "Bénéficiaire - Téléphone"} + + if beneficiaryOptionalFieldsList, ok := beneficiaryOptionalFields.([]interface{}); ok { + for _, field := range beneficiaryOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + beneficiaryFields = append(beneficiaryFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + beneficiaryHeaders = append(beneficiaryHeaders, fmt.Sprintf("Bénéficiaire - %s", label)) + } + } + } + } + headers = append(headers, beneficiaryHeaders...) + + // Add journey information headers + headers = append(headers, + "Lieu de départ - Adresse", + "Lieu de départ - Latitude", + "Lieu de départ - Longitude", + "Destination - Adresse", + "Destination - Latitude", + "Destination - Longitude", + "Distance passager (km)", + "Distance conducteur totale (km)", + "Durée trajet (minutes)", + "Prix passager", + "Devise prix passager", + "Compensation conducteur", + "Devise compensation", + "Temps d'attente retour", + "Aller simple", + "Départ conducteur - Adresse", + "Départ conducteur - Latitude", + "Départ conducteur - Longitude", + "Arrivée conducteur - Adresse", + "Arrivée conducteur - Latitude", + "Arrivée conducteur - Longitude", + ) + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, booking := range result.Bookings { + driver := result.DriversMap[booking.DriverId] + beneficiary := result.BeneficiariesMap[booking.PassengerId] + + row := []interface{}{} + + // Booking information + row = append(row, booking.Id) + row = append(row, booking.Status) + + // Motivation (from booking.Data) + motivation := "" + if booking.Data != nil { + if motivationVal, ok := booking.Data["motivation"]; ok && motivationVal != nil { + motivation = fmt.Sprint(motivationVal) + } + } + row = append(row, motivation) + + // Cancellation reason (from booking.Data) + cancellationReason := "" + if booking.Data != nil { + if reasonVal, ok := booking.Data["reason"]; ok && reasonVal != nil { + cancellationReason = fmt.Sprint(reasonVal) + } + } + row = append(row, cancellationReason) + + // Journey date and time + if booking.Journey != nil { + row = append(row, booking.Journey.PassengerPickupDate.Format("2006-01-02")) + row = append(row, booking.Journey.PassengerPickupDate.Format("15:04")) + } else { + row = append(row, "", "") + } + + // Driver data + for _, field := range driverFields { + row = append(row, getAccountFieldValue(driver.Data, field)) + } + + // Beneficiary data + for _, field := range beneficiaryFields { + row = append(row, getAccountFieldValue(beneficiary.Data, field)) + } + + // Journey locations and details + if booking.Journey != nil { + // Passenger pickup + pickupAddr, pickupLat, pickupLon := getLocationData(booking.Journey.PassengerPickup) + row = append(row, pickupAddr, pickupLat, pickupLon) + + // Passenger drop + dropAddr, dropLat, dropLon := getLocationData(booking.Journey.PassengerDrop) + row = append(row, dropAddr, dropLat, dropLon) + + // Distances and duration + row = append(row, booking.Journey.PassengerDistance) + row = append(row, booking.Journey.DriverDistance) + row = append(row, int64(booking.Journey.Duration.Minutes())) + + // Pricing + row = append(row, fmt.Sprintf("%.2f", booking.Journey.Price.Amount)) + row = append(row, booking.Journey.Price.Currency) + + // Driver compensation + if booking.DriverCompensationAmount > 0 { + row = append(row, fmt.Sprintf("%.2f", booking.DriverCompensationAmount)) + row = append(row, booking.DriverCompensationCurrency) + } else { + row = append(row, "", "") + } + + // Return wait time + row = append(row, "") + + // One way trip (Noreturn field) + if booking.Journey.Noreturn { + row = append(row, "Oui") + } else { + row = append(row, "Non") + } + + // Driver departure + driverDepartAddr, driverDepartLat, driverDepartLon := getLocationData(booking.Journey.DriverDeparture) + row = append(row, driverDepartAddr, driverDepartLat, driverDepartLon) + + // Driver arrival + driverArrivalAddr, driverArrivalLat, driverArrivalLon := getLocationData(booking.Journey.DriverArrival) + row = append(row, driverArrivalAddr, driverArrivalLat, driverArrivalLon) + } else { + // No journey data - fill with empty values + for i := 0; i < 21; i++ { + row = append(row, "") + } + } + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"export-transport-solidaire.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} + +func getAccountFieldValue(data map[string]interface{}, field string) string { + // First check direct field + if val, ok := data[field]; ok && val != nil { + return fmt.Sprint(val) + } + + // Check in other_properties + if otherProps, ok := data["other_properties"]; ok { + if otherPropsMap, ok := otherProps.(map[string]interface{}); ok { + if val, ok := otherPropsMap[field]; ok && val != nil { + return fmt.Sprint(val) + } + } + } + + return "" +} + +func getLocationData(feature *geojson.Feature) (address string, lat interface{}, lon interface{}) { + if feature != nil && feature.Properties != nil { + if label, ok := feature.Properties["label"].(string); ok { + address = label + } + if feature.Geometry != nil { + coords := feature.Geometry.Bound().Center() + lat = fmt.Sprintf("%.6f", coords.Lat()) + lon = fmt.Sprintf("%.6f", coords.Lon()) + } + } + return +} + +func (r *XLSXRenderer) SolidarityTransportDrivers(w http.ResponseWriter, result *application.SolidarityTransportOverviewResult) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Conducteurs solidaires") + + // Build headers dynamically based on configuration + driverOptionalFields := r.Config.Get("modules.solidarity_transport.drivers.profile_optional_fields") + driverFields := []string{"last_name", "first_name", "email", "phone_number", "birthdate", "gender", "file_number"} + headers := []string{"ID", "Nom", "Prénom", "Email", "Téléphone", "Date de naissance", "Genre", "Numéro de dossier"} + + if driverOptionalFieldsList, ok := driverOptionalFields.([]interface{}); ok { + for _, field := range driverOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + driverFields = append(driverFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + headers = append(headers, label) + } + } + } + } + + // Add address and archived columns + headers = append(headers, "Adresse", "Archivé") + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, driver := range result.Accounts { + row := []interface{}{} + + // Driver ID + row = append(row, driver.ID) + + // Driver data + for _, field := range driverFields { + value := getAccountFieldValue(driver.Data, field) + // Convert gender code to text + if field == "gender" && value != "" { + value = gender.ISO5218ToString(value) + } + row = append(row, value) + } + + // Address + address := "" + if addr, ok := driver.Data["address"]; ok { + if addrMap, ok := addr.(map[string]interface{}); ok { + if props, ok := addrMap["properties"]; ok { + if propsMap, ok := props.(map[string]interface{}); ok { + if label, ok := propsMap["label"].(string); ok { + address = label + } + } + } + } + } + row = append(row, address) + + // Archived status + archived := "Non" + if archivedVal, ok := driver.Data["archived"].(bool); ok && archivedVal { + archived = "Oui" + } + row = append(row, archived) + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"export-conducteurs-solidaires.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} diff --git a/renderer/xlsx/vehicle-bookings.go b/renderer/xlsx/vehicle-bookings.go new file mode 100644 index 0000000..8263d84 --- /dev/null +++ b/renderer/xlsx/vehicle-bookings.go @@ -0,0 +1,350 @@ +package xlsx + +import ( + "fmt" + "net/http" + + fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage" + groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/rs/zerolog/log" +) + +func (r *XLSXRenderer) VehicleBookings(w http.ResponseWriter, bookings []fleetsstorage.Booking, vehiclesMap map[string]fleetsstorage.Vehicle, driversMap map[string]mobilityaccountsstorage.Account) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Réservations véhicules") + + // Build headers + headers := []string{ + "ID Réservation", + "Statut", + "Type de véhicule", + "Nom du véhicule", + "Immatriculation", + } + + // Add beneficiary fields from config + beneficiaryOptionalFields := r.Config.Get("modules.beneficiaries.profile_optional_fields") + beneficiaryFields := []string{"last_name", "first_name", "email", "phone_number"} + beneficiaryHeaders := []string{"Bénéficiaire - Nom", "Bénéficiaire - Prénom", "Bénéficiaire - Email", "Bénéficiaire - Téléphone"} + + if beneficiaryOptionalFieldsList, ok := beneficiaryOptionalFields.([]interface{}); ok { + for _, field := range beneficiaryOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + beneficiaryFields = append(beneficiaryFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + beneficiaryHeaders = append(beneficiaryHeaders, fmt.Sprintf("Bénéficiaire - %s", label)) + } + } + } + } + headers = append(headers, beneficiaryHeaders...) + + // Add booking date headers + headers = append(headers, + "Date de début", + "Date de fin", + "Durée (jours)", + "Commentaire", + "Raison d'annulation", + ) + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, booking := range bookings { + vehicle := vehiclesMap[booking.Vehicleid] + beneficiary := driversMap[booking.Driver] + + row := []interface{}{} + + // Booking information + row = append(row, booking.ID) + + // Status + status := "" + if booking.Deleted { + status = "Annulé" + } else { + switch booking.Status() { + case 1: + status = "A venir" + case 0: + status = "En cours" + case -1: + status = "Terminé" + } + } + row = append(row, status) + + // Vehicle information + row = append(row, vehicle.Type) + if vehicleName, ok := vehicle.Data["name"].(string); ok { + row = append(row, vehicleName) + } else { + row = append(row, "") + } + if licencePlate, ok := vehicle.Data["licence_plate"].(string); ok { + row = append(row, licencePlate) + } else { + row = append(row, "") + } + + // Beneficiary data (including other_properties) + for _, field := range beneficiaryFields { + value := "" + // First check direct field + if val, ok := beneficiary.Data[field]; ok && val != nil { + value = fmt.Sprint(val) + } else { + // Check in other_properties + if otherProps, ok := beneficiary.Data["other_properties"]; ok { + if otherPropsMap, ok := otherProps.(map[string]interface{}); ok { + if val, ok := otherPropsMap[field]; ok && val != nil { + value = fmt.Sprint(val) + } + } + } + } + row = append(row, value) + } + + // Booking dates + row = append(row, booking.Startdate.Format("2006-01-02")) + row = append(row, booking.Enddate.Format("2006-01-02")) + + // Duration in days + duration := booking.Enddate.Sub(booking.Startdate).Hours() / 24 + row = append(row, fmt.Sprintf("%.0f", duration)) + + // Comment + comment := "" + if booking.Data != nil { + if commentVal, ok := booking.Data["comment"]; ok && commentVal != nil { + comment = fmt.Sprint(commentVal) + } + } + row = append(row, comment) + + // Cancellation reason + cancellationReason := "" + if booking.Deleted && booking.Data != nil { + if reasonVal, ok := booking.Data["reason"]; ok && reasonVal != nil { + cancellationReason = fmt.Sprint(reasonVal) + } + } + row = append(row, cancellationReason) + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"export-reservations-vehicules.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} + +func (r *XLSXRenderer) VehicleBookingsAdmin(w http.ResponseWriter, bookings []fleetsstorage.Booking, vehiclesMap map[string]interface{}, driversMap map[string]interface{}, groupsMap map[string]any) { + // Create Excel spreadsheet + spreadsheet := r.NewSpreadsheet("Réservations véhicules") + + // Build headers + headers := []string{ + "ID Réservation", + "Statut", + "Date de début", + "Date de fin", + "Durée (jours)", + "Commentaire", + "Raison d'annulation", + "Type de véhicule", + "Nom du véhicule", + "Immatriculation", + "Gestionnaire véhicule", + } + + // Add vehicle optional fields from config + vehicleOptionalFields := r.Config.Get("modules.fleets.vehicle_optional_fields") + vehicleFields := []string{} + vehicleHeaders := []string{} + + if vehicleOptionalFieldsList, ok := vehicleOptionalFields.([]interface{}); ok { + for _, field := range vehicleOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + vehicleFields = append(vehicleFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + vehicleHeaders = append(vehicleHeaders, fmt.Sprintf("Véhicule - %s", label)) + } + } + } + } + headers = append(headers, vehicleHeaders...) + + // Add beneficiary fields from config + beneficiaryOptionalFields := r.Config.Get("modules.beneficiaries.profile_optional_fields") + beneficiaryFields := []string{"last_name", "first_name", "email", "phone_number"} + beneficiaryHeaders := []string{"Bénéficiaire - Nom", "Bénéficiaire - Prénom", "Bénéficiaire - Email", "Bénéficiaire - Téléphone"} + + if beneficiaryOptionalFieldsList, ok := beneficiaryOptionalFields.([]interface{}); ok { + for _, field := range beneficiaryOptionalFieldsList { + if fieldMap, ok := field.(map[string]interface{}); ok { + if name, ok := fieldMap["name"].(string); ok { + beneficiaryFields = append(beneficiaryFields, name) + label := name + if labelVal, ok := fieldMap["label"].(string); ok { + label = labelVal + } + beneficiaryHeaders = append(beneficiaryHeaders, fmt.Sprintf("Bénéficiaire - %s", label)) + } + } + } + } + headers = append(headers, beneficiaryHeaders...) + + spreadsheet.SetHeaders(headers) + + // Add data rows + for _, booking := range bookings { + // Get vehicle from map + var vehicle fleetsstorage.Vehicle + if v, ok := vehiclesMap[booking.Vehicleid]; ok { + if vTyped, ok := v.(fleetsstorage.Vehicle); ok { + vehicle = vTyped + } + } + + // Get beneficiary from map + var beneficiary mobilityaccountsstorage.Account + if d, ok := driversMap[booking.Driver]; ok { + if dTyped, ok := d.(mobilityaccountsstorage.Account); ok { + beneficiary = dTyped + } + } + + row := []interface{}{} + + // Booking information + row = append(row, booking.ID) + + // Status + status := "" + if booking.Deleted { + status = "Annulé" + } else { + switch booking.Status() { + case 1: + status = "A venir" + case 0: + status = "En cours" + case -1: + status = "Terminé" + } + } + row = append(row, status) + + // Booking dates + row = append(row, booking.Startdate.Format("2006-01-02")) + row = append(row, booking.Enddate.Format("2006-01-02")) + + // Duration in days + duration := booking.Enddate.Sub(booking.Startdate).Hours() / 24 + row = append(row, fmt.Sprintf("%.0f", duration)) + + // Comment + comment := "" + if booking.Data != nil { + if commentVal, ok := booking.Data["comment"]; ok && commentVal != nil { + comment = fmt.Sprint(commentVal) + } + } + row = append(row, comment) + + // Cancellation reason + cancellationReason := "" + if booking.Deleted && booking.Data != nil { + if reasonVal, ok := booking.Data["reason"]; ok && reasonVal != nil { + cancellationReason = fmt.Sprint(reasonVal) + } + } + row = append(row, cancellationReason) + + // Vehicle information + row = append(row, vehicle.Type) + if vehicleName, ok := vehicle.Data["name"].(string); ok { + row = append(row, vehicleName) + } else { + row = append(row, "") + } + if licencePlate, ok := vehicle.Data["licence_plate"].(string); ok { + row = append(row, licencePlate) + } else { + row = append(row, "") + } + + // Vehicle administrator (group name) + administratorName := "" + if len(vehicle.Administrators) > 0 { + if group, ok := groupsMap[vehicle.Administrators[0]]; ok { + if groupTyped, ok := group.(groupsstorage.Group); ok { + if name, ok := groupTyped.Data["name"]; ok { + administratorName = fmt.Sprint(name) + } + } + } + } + row = append(row, administratorName) + + // Vehicle optional fields + for _, field := range vehicleFields { + value := "" + if val, ok := vehicle.Data[field]; ok && val != nil { + value = fmt.Sprint(val) + } + row = append(row, value) + } + + // Beneficiary data (including other_properties) + for _, field := range beneficiaryFields { + value := "" + // First check direct field + if val, ok := beneficiary.Data[field]; ok && val != nil { + value = fmt.Sprint(val) + } else { + // Check in other_properties + if otherProps, ok := beneficiary.Data["other_properties"]; ok { + if otherPropsMap, ok := otherProps.(map[string]interface{}); ok { + if val, ok := otherPropsMap[field]; ok && val != nil { + value = fmt.Sprint(val) + } + } + } + } + row = append(row, value) + } + + spreadsheet.AddRow(row) + } + + // Write Excel to response + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", "attachment; filename=\"all_bookings.xlsx\"") + + if err := spreadsheet.GetFile().Write(w); err != nil { + log.Error().Err(err).Msg("Error generating Excel file") + http.Error(w, "Error generating Excel file", http.StatusInternalServerError) + return + } +} diff --git a/renderer/xlsx/xlsx.go b/renderer/xlsx/xlsx.go new file mode 100644 index 0000000..2bee13d --- /dev/null +++ b/renderer/xlsx/xlsx.go @@ -0,0 +1,60 @@ +package xlsx + +import ( + "github.com/spf13/viper" + "github.com/xuri/excelize/v2" +) + +// XLSXRenderer handles rendering data to Excel XLSX format +type XLSXRenderer struct { + Config *viper.Viper +} + +func NewXLSXRenderer(config *viper.Viper) *XLSXRenderer { + return &XLSXRenderer{ + Config: config, + } +} + +// Spreadsheet represents an Excel spreadsheet +type Spreadsheet struct { + file *excelize.File + sheetName string + rowIndex int +} + +// NewSpreadsheet creates a new Excel spreadsheet +func (r *XLSXRenderer) NewSpreadsheet(sheetName string) *Spreadsheet { + f := excelize.NewFile() + // Rename default sheet + f.SetSheetName("Sheet1", sheetName) + + return &Spreadsheet{ + file: f, + sheetName: sheetName, + rowIndex: 1, + } +} + +// SetHeaders sets the header row +func (s *Spreadsheet) SetHeaders(headers []string) { + for i, header := range headers { + cell, _ := excelize.CoordinatesToCellName(i+1, s.rowIndex) + s.file.SetCellValue(s.sheetName, cell, header) + } + s.rowIndex++ +} + +// AddRow adds a data row +func (s *Spreadsheet) AddRow(values []interface{}) { + for i, value := range values { + cell, _ := excelize.CoordinatesToCellName(i+1, s.rowIndex) + s.file.SetCellValue(s.sheetName, cell, value) + } + s.rowIndex++ +} + +// GetFile returns the underlying excelize File +func (s *Spreadsheet) GetFile() *excelize.File { + return s.file +} diff --git a/servers/web/api/auth.go b/servers/web/api/auth.go new file mode 100644 index 0000000..edc1c3e --- /dev/null +++ b/servers/web/api/auth.go @@ -0,0 +1,38 @@ +package api + +import ( + "net/http" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) OAuth2Callback(w http.ResponseWriter, r *http.Request) { + code := r.URL.Query().Get("code") + if code == "" { + w.WriteHeader(http.StatusBadRequest) + return + } + + session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") + redirectSession := "" + if session.Values["redirect"] != nil && session.Values["redirect"] != "" { + redirectSession = session.Values["redirect"].(string) + delete(session.Values, "redirect") + } + + result, err := h.applicationHandler.ProcessOAuth2Callback(code, redirectSession) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + return + } + + session.Values["idtoken"] = result.IDToken + + if err = session.Save(r, w); err != nil { + log.Error().Err(err).Msg("Cannot save session") + w.WriteHeader(http.StatusInternalServerError) + return + } + + http.Redirect(w, r, result.RedirectURL, http.StatusFound) +} \ No newline at end of file diff --git a/servers/web/api/cache.go b/servers/web/api/cache.go new file mode 100644 index 0000000..93aecc3 --- /dev/null +++ b/servers/web/api/cache.go @@ -0,0 +1,48 @@ +package api + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/cache" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) GetCache(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + cacheID := vars["cacheid"] + + // Parse query parameters + limitsMinStr := r.URL.Query().Get("limits.min") + limitsMaxStr := r.URL.Query().Get("limits.max") + limitsMin, limitsMax := cache.ParseLimits(limitsMinStr, limitsMaxStr) + + // Use a channel to synchronize the goroutines + ch := make(chan []byte) + + // Fetch data from cache asynchronously + go func() { + result, err := h.cacheService.GetCacheData(cacheID, limitsMin, limitsMax) + if err != nil { + log.Error().Err(err).Msg("Failed to get cache data") + w.WriteHeader(http.StatusNotFound) + ch <- nil + return + } + ch <- result.Data // Signal that the data has been fetched successfully + close(ch) + }() + + // Wait for the JSON marshaling goroutine to finish + data := <-ch + if data == nil { + return // Stop processing if an error occurred + } + + // Send the JSON response to the client + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(data) + + <-ch +} \ No newline at end of file diff --git a/servers/web/api/calendars.go b/servers/web/api/calendars.go new file mode 100644 index 0000000..40ce8e8 --- /dev/null +++ b/servers/web/api/calendars.go @@ -0,0 +1,51 @@ +package api + +import ( + "net/http" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) CalendarGlobal(w http.ResponseWriter, r *http.Request) { + enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.global.enabled") + if !enabled { + log.Error().Msg("global calendar not activated in configuration") + w.WriteHeader(http.StatusForbidden) + return + } + + result, err := h.applicationHandler.GenerateGlobalCalendar(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error generating global calendar") + w.WriteHeader(http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", "text/calendar; charset=utf-8") + w.WriteHeader(http.StatusOK) + w.Write([]byte(result.CalendarData)) +} + +func (h *Handler) CalendarOrganizations(w http.ResponseWriter, r *http.Request) { + enabled := h.config.GetBool("modules.agenda.enabled") && h.config.GetBool("modules.agenda.calendars.organizations.enabled") + if !enabled { + log.Error().Msg("organizations calendar not activated in configuration") + w.WriteHeader(http.StatusForbidden) + return + } + + vars := mux.Vars(r) + groupID := vars["groupid"] + + result, err := h.applicationHandler.GenerateOrganizationCalendar(r.Context(), groupID) + if err != nil { + log.Error().Err(err).Msg("error generating organization calendar") + w.WriteHeader(http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", "text/calendar; charset=utf-8") + w.WriteHeader(http.StatusOK) + w.Write([]byte(result.CalendarData)) +} \ No newline at end of file diff --git a/servers/web/api/export.go b/servers/web/api/export.go new file mode 100644 index 0000000..a296d97 --- /dev/null +++ b/servers/web/api/export.go @@ -0,0 +1,31 @@ +package api + +import ( + "encoding/csv" + "fmt" + "net/http" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) CacheExport(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + cacheID := vars["cacheid"] + + result, err := h.applicationHandler.ExportCacheAsCSV(cacheID) + if err != nil { + log.Error().Err(err).Msg("Error exporting cache") + w.WriteHeader(http.StatusNotFound) + return + } + + w.Header().Set("Content-Type", "text/csv") + w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=export-%s.csv", cacheID)) + + csvWriter := csv.NewWriter(w) + defer csvWriter.Flush() + + csvWriter.Write(result.Headers) + csvWriter.WriteAll(result.Values) +} \ No newline at end of file diff --git a/servers/web/api/geo.go b/servers/web/api/geo.go new file mode 100644 index 0000000..4f3dd17 --- /dev/null +++ b/servers/web/api/geo.go @@ -0,0 +1,32 @@ +package api + +import ( + "encoding/json" + "net/http" +) + +func (h *Handler) GeoAutocomplete(w http.ResponseWriter, r *http.Request) { + t, ok := r.URL.Query()["text"] + if !ok || len(t[0]) < 1 { + w.WriteHeader(http.StatusBadRequest) + return + } + + text := t[0] + + result, err := h.geoService.Autocomplete(text) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + return + } + + j, err := json.Marshal(result.Features) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(j) +} \ No newline at end of file diff --git a/servers/web/api/handler.go b/servers/web/api/handler.go new file mode 100644 index 0000000..376615a --- /dev/null +++ b/servers/web/api/handler.go @@ -0,0 +1,37 @@ +package api + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/cache" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/geo" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + cacheStorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + "github.com/spf13/viper" +) + +type Handler struct { + config *viper.Viper + idp *identification.IdentificationProvider + applicationHandler *application.ApplicationHandler + cacheService *cache.CacheService + geoService *geo.GeoService +} + +func NewHandler(cfg *viper.Viper, idp *identification.IdentificationProvider, appHandler *application.ApplicationHandler, cacheHandler cacheStorage.CacheHandler) *Handler { + cacheService := cache.NewCacheService(cacheHandler) + geoService := geo.NewGeoService(cfg.GetString("geo.pelias.url")) + + return &Handler{ + config: cfg, + idp: idp, + applicationHandler: appHandler, + cacheService: cacheService, + geoService: geoService, + } +} + +func (h *Handler) NotFound(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) +} \ No newline at end of file diff --git a/servers/web/api/protected/handler.go b/servers/web/api/protected/handler.go new file mode 100644 index 0000000..e1cc3e1 --- /dev/null +++ b/servers/web/api/protected/handler.go @@ -0,0 +1,26 @@ +package protected + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "github.com/spf13/viper" +) + +type Handler struct { + apiKey string + config *viper.Viper + applicationHandler *application.ApplicationHandler +} + +func NewHandler(cfg *viper.Viper, appHandler *application.ApplicationHandler) *Handler { + return &Handler{ + apiKey: cfg.GetString("services.api.api_key"), + config: cfg, + applicationHandler: appHandler, + } +} + +func (h *Handler) NotFound(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) +} \ No newline at end of file diff --git a/servers/web/api/protected/users.go b/servers/web/api/protected/users.go new file mode 100644 index 0000000..2600525 --- /dev/null +++ b/servers/web/api/protected/users.go @@ -0,0 +1,29 @@ +package protected + +import ( + "context" + "encoding/json" + "net/http" + + "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/rs/zerolog/log" +) + +func (h *Handler) RegisterUserHTTP(w http.ResponseWriter, r *http.Request) { + var user storage.Account + if err := json.NewDecoder(r.Body).Decode(&user); err != nil { + w.WriteHeader(http.StatusBadRequest) + return + } + + result, err := h.applicationHandler.RegisterUser(context.Background(), user) + if err != nil { + log.Error().Err(err).Msg("Failed to register user") + w.WriteHeader(http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(result) +} \ No newline at end of file diff --git a/servers/web/api_routes.go b/servers/web/api_routes.go new file mode 100644 index 0000000..eaeec83 --- /dev/null +++ b/servers/web/api_routes.go @@ -0,0 +1,14 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupAPIRoutes(r *mux.Router) { + api_router := r.PathPrefix("/api").Subrouter() + api_router.HandleFunc("/", ws.webAPIHandler.NotFound) + api_router.HandleFunc("/geo/autocomplete", ws.webAPIHandler.GeoAutocomplete) + api_router.HandleFunc("/cache/{cacheid}", ws.webAPIHandler.GetCache) + api_router.HandleFunc("/cache/{cacheid}/export", ws.webAPIHandler.CacheExport) + api_router.HandleFunc("/oauth2/callback", ws.webAPIHandler.OAuth2Callback) +} \ No newline at end of file diff --git a/servers/web/app_administration_routes.go b/servers/web/app_administration_routes.go new file mode 100644 index 0000000..cfd94eb --- /dev/null +++ b/servers/web/app_administration_routes.go @@ -0,0 +1,22 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupAdministrationRoutes(appRouter *mux.Router) { + admin := appRouter.PathPrefix("/administration").Subrouter() + admin.HandleFunc("/", ws.appHandler.AdministrationHTTPHandler()) + + // Groups + admin.HandleFunc("/groups/", ws.appHandler.AdministrationCreateGroupHTTPHandler()) + admin.HandleFunc("/groups/{groupid}", ws.appHandler.AdministrationGroupDisplayHTTPHandler()) + admin.HandleFunc("/groups/{groupid}/invite-admin", ws.appHandler.AdministrationGroupInviteAdminHTTPHandler()) + admin.HandleFunc("/groups/{groupid}/invite-member", ws.appHandler.AdministrationGroupInviteMemberHTTPHandler()) + + // Statistics + admin.HandleFunc("/stats/vehicles", ws.appHandler.AdminStatsVehiclesHTTPHandler()) + admin.HandleFunc("/stats/bookings", ws.appHandler.AdminStatsBookingsHTTPHandler()) + admin.HandleFunc("/stats/beneficaires", ws.appHandler.AdminStatsBeneficiariesHTTPHandler()) + admin.HandleFunc("/stats/events", ws.appHandler.AdminStatsEventsHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_agenda_routes.go b/servers/web/app_agenda_routes.go new file mode 100644 index 0000000..c8b4048 --- /dev/null +++ b/servers/web/app_agenda_routes.go @@ -0,0 +1,26 @@ +package web + +import ( + "github.com/gorilla/mux" +) + + +func (ws *WebServer) setupAgendaRoutes(appRouter *mux.Router) { + agenda := appRouter.PathPrefix("/agenda").Subrouter() + agenda.HandleFunc("/", ws.appHandler.AgendaHomeHTTPHandler()) + agenda.HandleFunc("/history", ws.appHandler.AgendaHistoryHTTPHandler()) + agenda.HandleFunc("/create-event", ws.appHandler.AgendaCreateEventHTTPHandler()) + + // Events + agenda.HandleFunc("/{eventid}", ws.appHandler.AgendaDisplayEventHTTPHandler()) + agenda.HandleFunc("/{eventid}/update", ws.appHandler.AgendaUpdateEventHTTPHandler()) + agenda.HandleFunc("/{eventid}/delete", ws.appHandler.AgendaDeleteEventHTTPHandler()) + agenda.HandleFunc("/{eventid}/subscribe", ws.appHandler.AgendaSubscribeEventHTTPHandler()) + agenda.HandleFunc("/{eventid}/{subscribeid}/delete", ws.appHandler.AgendaDeleteSubscribeEventHTTPHandler()) + agenda.HandleFunc("/{eventid}/history", ws.appHandler.AgendaHistoryEventHTTPHandler()) + + // Documents + agenda.HandleFunc("/{eventid}/documents", ws.appHandler.EventDocumentsHTTPHandler()) + agenda.HandleFunc("/{eventid}/documents/{document}", ws.appHandler.EventDocumentDownloadHTTPHandler()) + +} \ No newline at end of file diff --git a/servers/web/app_beneficiaries_routes.go b/servers/web/app_beneficiaries_routes.go new file mode 100644 index 0000000..d2c7746 --- /dev/null +++ b/servers/web/app_beneficiaries_routes.go @@ -0,0 +1,20 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupBeneficiariesRoutes(appRouter *mux.Router) { + beneficiaries := appRouter.PathPrefix("/beneficiaries").Subrouter() + beneficiaries.HandleFunc("/", ws.appHandler.BeneficiariesListHTTPHandler()) + beneficiaries.HandleFunc("/create", ws.appHandler.BeneficiaryCreateHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}", ws.appHandler.BeneficiaryDisplayHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/update", ws.appHandler.BeneficiaryUpdateHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/archive", ws.appHandler.BeneficiaryArchiveHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/unarchive", ws.appHandler.BeneficiaryUnarchiveHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/documents", ws.appHandler.BeneficiaryDocumentsHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/documents/{document}", ws.appHandler.BeneficiaryDocumentDownloadHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/documents/{document}/delete", ws.appHandler.BeneficiaryDocumentDeleteHTTPHandler()) + beneficiaries.HandleFunc("/{beneficiaryid}/picture", ws.appHandler.BeneficiaryPictureHTTPHandler()) + +} \ No newline at end of file diff --git a/servers/web/app_dashboard_routes.go b/servers/web/app_dashboard_routes.go new file mode 100644 index 0000000..7b9cf9d --- /dev/null +++ b/servers/web/app_dashboard_routes.go @@ -0,0 +1,10 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupDashboardRoutes(appRouter *mux.Router) { + // Dashboard + appRouter.HandleFunc("/", ws.appHandler.DashboardHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_directory_routes.go b/servers/web/app_directory_routes.go new file mode 100644 index 0000000..e178b75 --- /dev/null +++ b/servers/web/app_directory_routes.go @@ -0,0 +1,9 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupDirectoryRoutes(appRouter *mux.Router) { + appRouter.HandleFunc("/directory/", ws.appHandler.DirectoryHomeHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_group_module_routes.go b/servers/web/app_group_module_routes.go new file mode 100644 index 0000000..efe10f7 --- /dev/null +++ b/servers/web/app_group_module_routes.go @@ -0,0 +1,12 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupGroupModuleRoutes(appRouter *mux.Router) { + groupModule := appRouter.PathPrefix("/group_module").Subrouter() + groupModule.HandleFunc("/", ws.appHandler.GroupsHTTPHandler()) + groupModule.HandleFunc("/groups", ws.appHandler.CreateGroupModuleHTTPHandler()) + groupModule.HandleFunc("/groups/{groupid}", ws.appHandler.DisplayGroupModuleHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_group_routes.go b/servers/web/app_group_routes.go new file mode 100644 index 0000000..12bbf30 --- /dev/null +++ b/servers/web/app_group_routes.go @@ -0,0 +1,11 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupGroupRoutes(appRouter *mux.Router) { + // Group Settings + appRouter.HandleFunc("/group/settings", ws.appHandler.GroupSettingsDisplayHTTPHandler()) + appRouter.HandleFunc("/group/settings/invite-member", ws.appHandler.GroupSettingsInviteMemberHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_journeys_routes.go b/servers/web/app_journeys_routes.go new file mode 100644 index 0000000..006deb6 --- /dev/null +++ b/servers/web/app_journeys_routes.go @@ -0,0 +1,14 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupJourneysRoutes(appRouter *mux.Router) { + journeys := appRouter.PathPrefix("/journeys").Subrouter() + journeys.HandleFunc("/", ws.appHandler.JourneysSearchHTTPHandler()) + journeys.HandleFunc("/search", ws.appHandler.JourneysSearchCompactHTTPHandler()) + journeys.HandleFunc("/save", ws.appHandler.SaveSearchHTTPHandler()).Methods("GET") + journeys.HandleFunc("/saved-searches/{id}/delete", ws.appHandler.DeleteSavedSearchHTTPHandler()).Methods("GET") +} + diff --git a/servers/web/app_members_routes.go b/servers/web/app_members_routes.go new file mode 100644 index 0000000..ef35463 --- /dev/null +++ b/servers/web/app_members_routes.go @@ -0,0 +1,12 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupMembersRoutes(appRouter *mux.Router) { + members := appRouter.PathPrefix("/members").Subrouter() + members.HandleFunc("/", ws.appHandler.MembersListHTTPHandler()) + members.HandleFunc("/{adminid}", ws.appHandler.MemberDisplayHTTPHandler()) + members.HandleFunc("/{adminid}/update", ws.appHandler.MemberUpdateHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_misc_routes.go b/servers/web/app_misc_routes.go new file mode 100644 index 0000000..991902d --- /dev/null +++ b/servers/web/app_misc_routes.go @@ -0,0 +1,10 @@ +package web + +import ( + "github.com/gorilla/mux" + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" +) + +func setupMiscRoutes(appRouter *mux.Router, applicationHandler *application.ApplicationHandler) { + // Future misc routes can be added here +} \ No newline at end of file diff --git a/servers/web/app_organized_carpool_routes.go b/servers/web/app_organized_carpool_routes.go new file mode 100644 index 0000000..02607ec --- /dev/null +++ b/servers/web/app_organized_carpool_routes.go @@ -0,0 +1,29 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupOrganizedCarpoolRoutes(appRouter *mux.Router) { + organizedCarpool := appRouter.PathPrefix("/organized-carpool").Subrouter() + organizedCarpool.HandleFunc("/", ws.appHandler.OrganizedCarpoolOverviewHTTPHandler()) + + // Drivers + organizedCarpool.HandleFunc("/drivers/create", ws.appHandler.OrganizedCarpoolCreateDriverHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/update", ws.appHandler.OrganizedCarpoolUpdateDriverHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/trips", ws.appHandler.OrganizedCarpoolAddTripHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/archive", ws.appHandler.OrganizedCarpoolArchiveDriverHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/unarchive", ws.appHandler.OrganizedCarpoolUnarchiveDriverHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/documents", ws.appHandler.OrganizedCarpoolDriverDocumentsHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/documents/{document}", ws.appHandler.OrganizedCarpoolDocumentDownloadHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/documents/{document}/delete", ws.appHandler.OrganizedCarpoolDocumentDeleteHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/trips/{tripid}/delete", ws.appHandler.OrganizedCarpoolDeleteTripHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}", ws.appHandler.OrganizedCarpoolDriverDisplayHTTPHandler()) + organizedCarpool.HandleFunc("/drivers/{driverid}/journeys/{journeyid}", ws.appHandler.OrganizedCarpoolJourneyHTTPHandler()) + + // Bookings + organizedCarpool.HandleFunc("/bookings/{bookingid}", ws.appHandler.OrganizedCarpoolBookingDisplayHTTPHandler()) + organizedCarpool.HandleFunc("/bookings/{bookingid}/confirm", ws.appHandler.OrganizedCarpoolBookingStatusHTTPHandler("confirm")) + organizedCarpool.HandleFunc("/bookings/{bookingid}/cancel", ws.appHandler.OrganizedCarpoolBookingStatusHTTPHandler("cancel")) + organizedCarpool.HandleFunc("/bookings/{bookingid}/waitconfirmation", ws.appHandler.OrganizedCarpoolBookingStatusHTTPHandler("waitconfirmation")) +} \ No newline at end of file diff --git a/servers/web/app_sms_routes.go b/servers/web/app_sms_routes.go new file mode 100644 index 0000000..cde161d --- /dev/null +++ b/servers/web/app_sms_routes.go @@ -0,0 +1,9 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupSMSRoutes(appRouter *mux.Router) { + appRouter.HandleFunc("/sms/send", ws.appHandler.SendSMSHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_solidarity_transport_routes.go b/servers/web/app_solidarity_transport_routes.go new file mode 100644 index 0000000..a6c769a --- /dev/null +++ b/servers/web/app_solidarity_transport_routes.go @@ -0,0 +1,30 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupSolidarityTransportRoutes(appRouter *mux.Router) { + solidarityTransport := appRouter.PathPrefix("/solidarity-transport").Subrouter() + solidarityTransport.HandleFunc("/", ws.appHandler.SolidarityTransportOverviewHTTPHandler()) + + // Drivers + solidarityTransport.HandleFunc("/drivers/create", ws.appHandler.SolidarityTransportCreateDriverHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/update", ws.appHandler.SolidarityTransportUpdateDriverHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/availabilities", ws.appHandler.SolidarityTransportAddAvailabilityHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/archive", ws.appHandler.SolidarityTransportArchiveDriverHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/unarchive", ws.appHandler.SolidarityTransportUnarchiveDriverHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/documents", ws.appHandler.SolidarityTransportDriverDocumentsHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/documents/{document}", ws.appHandler.SolidarityTransportDocumentDownloadHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/documents/{document}/delete", ws.appHandler.SolidarityTransportDocumentDeleteHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/availabilities/{availabilityid}/delete", ws.appHandler.SolidarityTransportDeleteAvailabilityHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/journeys/{journeyid}", ws.appHandler.SolidarityTransportDriverJourneyHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}/journeys/{journeyid}/noreturn", ws.appHandler.SolidarityTransportDriverJourneyToggleNoreturnHTTPHandler()) + solidarityTransport.HandleFunc("/drivers/{driverid}", ws.appHandler.SolidarityTransportDriverDisplayHTTPHandler()) + + // Bookings + solidarityTransport.HandleFunc("/bookings/{bookingid}", ws.appHandler.SolidarityTransportBookingDisplayHTTPHandler()) + solidarityTransport.HandleFunc("/bookings/{bookingid}/confirm", ws.appHandler.SolidarityTransportBookingStatusHTTPHandler("confirm")) + solidarityTransport.HandleFunc("/bookings/{bookingid}/cancel", ws.appHandler.SolidarityTransportBookingStatusHTTPHandler("cancel")) + solidarityTransport.HandleFunc("/bookings/{bookingid}/waitconfirmation", ws.appHandler.SolidarityTransportBookingStatusHTTPHandler("waitconfirmation")) +} \ No newline at end of file diff --git a/servers/web/app_support_routes.go b/servers/web/app_support_routes.go new file mode 100644 index 0000000..8bfccb8 --- /dev/null +++ b/servers/web/app_support_routes.go @@ -0,0 +1,10 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupSupportRoutes(appRouter *mux.Router) { + // Support + appRouter.HandleFunc("/support/", ws.appHandler.SupportSendHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_vehicles_management_routes.go b/servers/web/app_vehicles_management_routes.go new file mode 100644 index 0000000..29e6132 --- /dev/null +++ b/servers/web/app_vehicles_management_routes.go @@ -0,0 +1,24 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupVehiclesManagementRoutes(appRouter *mux.Router) { + vehiclesManagement := appRouter.PathPrefix("/vehicles-management").Subrouter() + vehiclesManagement.HandleFunc("/", ws.appHandler.VehiclesManagementOverviewHTTPHandler()) + + // Fleet + vehiclesManagement.HandleFunc("/fleet/add", ws.appHandler.VehiclesFleetAddHTTPHandler()) + vehiclesManagement.HandleFunc("/fleet/{vehicleid}", ws.appHandler.VehiclesFleetDisplayHTTPHandler()) + vehiclesManagement.HandleFunc("/fleet/{vehicleid}/unavailability", ws.appHandler.VehiclesFleetMakeUnavailableHTTPHandler()) + vehiclesManagement.HandleFunc("/fleet/{vehicleid}/update", ws.appHandler.VehiclesFleetUpdateHTTPHandler()) + + // Bookings + vehiclesManagement.HandleFunc("/bookings/", ws.appHandler.VehiclesManagementBookingsListHTTPHandler()) + vehiclesManagement.HandleFunc("/bookings/{bookingid}", ws.appHandler.VehicleManagementBookingDisplayHTTPHandler()) + vehiclesManagement.HandleFunc("/bookings/{bookingid}/change-vehicle", ws.appHandler.VehicleManagementBookingChangeVehicleHTTPHandler()) + vehiclesManagement.HandleFunc("/bookings/{bookingid}/delete", ws.appHandler.DeleteBookingHTTPHandler()) + vehiclesManagement.HandleFunc("/bookings/{bookingid}/unbooking", ws.appHandler.UnbookingVehicleHTTPHandler()) + vehiclesManagement.HandleFunc("/bookings/{bookingid}/documents/{document}", ws.appHandler.BookingDocumentDownloadHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_vehicles_routes.go b/servers/web/app_vehicles_routes.go new file mode 100644 index 0000000..c1933c6 --- /dev/null +++ b/servers/web/app_vehicles_routes.go @@ -0,0 +1,18 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupVehiclesRoutes(appRouter *mux.Router) { + vehicles := appRouter.PathPrefix("/vehicles").Subrouter() + vehicles.HandleFunc("/", ws.appHandler.VehiclesSearchHTTPHandler()) + + // Bookings + vehicles.HandleFunc("/bookings/", ws.appHandler.VehiclesBookingsListHTTPHandler()) + vehicles.HandleFunc("/bookings/{bookingid}", ws.appHandler.VehicleBookingDisplayHTTPHandler()) + vehicles.HandleFunc("/bookings/{bookingid}/documents/{document}", ws.appHandler.BookingDocumentDownloadHTTPHandler()) + + // Vehicle booking + vehicles.HandleFunc("/v/{vehicleid}/b/{beneficiaryid}", ws.appHandler.BookVehicleHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/app_wallets_routes.go b/servers/web/app_wallets_routes.go new file mode 100644 index 0000000..7b09eb6 --- /dev/null +++ b/servers/web/app_wallets_routes.go @@ -0,0 +1,10 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupWalletsRoutes(appRouter *mux.Router) { + wallets := appRouter.PathPrefix("/wallets").Subrouter() + wallets.HandleFunc("/{userid}/credit", ws.appHandler.CreditWalletHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/application/administration.go b/servers/web/application/administration.go new file mode 100644 index 0000000..2304586 --- /dev/null +++ b/servers/web/application/administration.go @@ -0,0 +1,247 @@ +package application + +import ( + "net/http" + "time" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) AdministrationHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Call business logic handler + result, err := h.applicationHandler.GetAdministrationData(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error retrieving administration data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Render HTTP response + h.renderer.Administration( + w, r, + result.Accounts, + result.Beneficiaries, + result.Groups, + result.Bookings, + result.Events, + ) + } +} + +func (h *Handler) AdministrationCreateGroupHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract and validate form parameters + name := r.FormValue("name") + if name == "" { + log.Error().Str("name", name).Msg("Invalid name") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract modules configuration + modules := map[string]any{ + "beneficiaries": r.FormValue("modules.beneficiaries") == "on", + "journeys": r.FormValue("modules.journeys") == "on", + "vehicles": r.FormValue("modules.vehicles") == "on", + "vehicles_management": r.FormValue("modules.vehicles_management") == "on", + "events": r.FormValue("modules.events") == "on", + "agenda": r.FormValue("modules.agenda") == "on", + "groups": r.FormValue("modules.groups") == "on", + "administration": r.FormValue("modules.administration") == "on", + "support": r.FormValue("modules.support") == "on", + "group_module": r.FormValue("modules.group_module") == "on", + "organized_carpool": r.FormValue("modules.organized_carpool") == "on", + "solidarity_transport": r.FormValue("modules.solidarity_transport") == "on", + } + + // Call business logic handler + groupID, err := h.applicationHandler.CreateAdministrationGroup(r.Context(), name, modules) + if err != nil { + log.Error().Err(err).Msg("error creating administration group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Redirect to group display + http.Redirect(w, r, "/app/administration/groups/"+groupID, http.StatusFound) + return + } + + // For GET requests, render the create group form + h.renderer.AdministrationCreateGroup(w, r) + } +} + +func (h *Handler) AdministrationGroupDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + groupID := vars["groupid"] + + // Call business logic handler + result, err := h.applicationHandler.GetAdministrationGroupData(r.Context(), groupID) + if err != nil { + log.Error().Err(err).Msg("error retrieving administration group data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Render HTTP response + h.renderer.AdministrationGroupDisplay(w, r, result.Group, result.Members, result.Admins) + } +} + +func (h *Handler) AdministrationGroupInviteAdminHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + groupID := vars["groupid"] + + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract form parameters + username := r.FormValue("username") + if username == "" { + log.Error().Str("username", username).Msg("Invalid username") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Call business logic handler + err := h.applicationHandler.InviteAdministrationGroupAdmin(r.Context(), groupID, username) + if err != nil { + log.Error().Err(err).Msg("error inviting group admin") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Redirect back to group display + http.Redirect(w, r, "/app/administration/groups/"+groupID, http.StatusFound) + return + } + + // For GET requests, redirect to group display (no separate form) + http.Redirect(w, r, "/app/administration/groups/"+groupID, http.StatusFound) + } +} + +func (h *Handler) AdministrationGroupInviteMemberHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + groupID := vars["groupid"] + + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract form parameters + username := r.FormValue("username") + if username == "" { + log.Error().Str("username", username).Msg("Invalid username") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Call business logic handler + err := h.applicationHandler.InviteAdministrationGroupMember(r.Context(), groupID, username) + if err != nil { + log.Error().Err(err).Msg("error inviting group member") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Redirect back to group display + http.Redirect(w, r, "/app/administration/groups/"+groupID, http.StatusFound) + return + } + + // For GET requests, redirect to group display (no separate form) + http.Redirect(w, r, "/app/administration/groups/"+groupID, http.StatusFound) + } +} +func (h *Handler) AdminStatsVehiclesHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetVehiclesStats() + if err != nil { + log.Error().Err(err).Msg("error retrieving vehicles stats") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AdminStatVehicles(w, r, result.Vehicles, result.Bookings, result.Groups) + } +} + +func (h *Handler) AdminStatsBookingsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Extract filter parameters from query + status := r.URL.Query().Get("status") + dateStart := r.URL.Query().Get("date_start") + dateEnd := r.URL.Query().Get("date_end") + + // Default to last month if no dates specified + if dateStart == "" { + dateStart = time.Now().AddDate(0, -1, 0).Format("2006-01-02") + } + if dateEnd == "" { + dateEnd = time.Now().Format("2006-01-02") + } + + result, err := h.applicationHandler.GetBookingsStats(status, dateStart, dateEnd) + if err != nil { + log.Error().Err(err).Msg("error retrieving bookings stats") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Prepare filters map for template + filters := map[string]string{ + "status": status, + "date_start": dateStart, + "date_end": dateEnd, + } + + h.renderer.AdminStatBookings(w, r, result.Vehicles, result.Bookings, result.Groups, result.BeneficiariesMap, filters) + } +} + +func (h *Handler) AdminStatsBeneficiariesHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetBeneficiariesStats() + if err != nil { + log.Error().Err(err).Msg("error retrieving beneficiaries stats") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AdminStatBeneficaires(w, r, result.Beneficiaries, result.CacheID) + } +} + +func (h *Handler) AdminStatsEventsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetEventsStats() + if err != nil { + log.Error().Err(err).Msg("error retrieving events stats") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AdminStatEvents(w, r, result.Events, result.Groups) + } +} diff --git a/servers/web/application/agenda.go b/servers/web/application/agenda.go new file mode 100644 index 0000000..7ac52a2 --- /dev/null +++ b/servers/web/application/agenda.go @@ -0,0 +1,469 @@ +package application + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "time" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +type EventsForm struct { + Name string `json:"name" validate:"required"` + Type string `json:"type" validate:"required"` + Description string `json:"description"` + Address any `json:"address,omitempty"` + Allday bool `json:"allday"` + Startdate *time.Time `json:"startdate"` + Enddate *time.Time `json:"enddate"` + Starttime string `json:"starttime"` + Endtime string `json:"endtime"` + MaxSubscribers int `json:"max_subscribers"` +} + +func parseEventsForm(r *http.Request) (*EventsForm, error) { + if err := r.ParseForm(); err != nil { + return nil, err + } + + var startdate *time.Time + var enddate *time.Time + + if r.PostFormValue("startdate") != "" { + d, err := time.Parse("2006-01-02", r.PostFormValue("startdate")) + if err != nil { + return nil, err + } + startdate = &d + } + + if r.PostFormValue("enddate") != "" { + d, err := time.Parse("2006-01-02", r.PostFormValue("enddate")) + if err != nil { + return nil, err + } + enddate = &d + } + + max_subscribers, err := strconv.Atoi(r.PostFormValue("max_subscribers")) + if err != nil { + return nil, err + } + + formData := &EventsForm{ + Name: r.PostFormValue("name"), + Type: r.PostFormValue("type"), + Description: r.PostFormValue("description"), + Startdate: startdate, + Enddate: enddate, + Starttime: r.PostFormValue("starttime"), + Endtime: r.PostFormValue("endtime"), + MaxSubscribers: max_subscribers, + } + + if r.PostFormValue("allday") == "true" { + formData.Allday = true + } + + if r.PostFormValue("address") != "" { + var a any + json.Unmarshal([]byte(r.PostFormValue("address")), &a) + + formData.Address = a + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return nil, err + } + + return formData, nil +} + +func (h *Handler) AgendaHomeHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + today := time.Now().Truncate(24 * time.Hour) + result, err := h.applicationHandler.GetAgendaEvents(r.Context(), &today, nil) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda events") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AgendaHome(w, r, result.Events, result.Groups) + } +} + +func (h *Handler) AgendaHistoryHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetAgendaEvents(r.Context(), nil, nil) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda events") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AgendaHistory(w, r, result.Events, result.Groups) + } +} + +func (h *Handler) AgendaCreateEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + // Parse form data + eventForm, err := parseEventsForm(r) + if err != nil { + log.Error().Err(err).Msg("error parsing event form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Handle file upload if present + var file io.Reader + var filename string + var fileSize int64 + var documentType, documentName string + + contentType := r.Header.Get("Content-Type") + if strings.HasPrefix(contentType, "multipart/form-data") { + err = r.ParseMultipartForm(100 * 1024 * 1024) // 100 MB limit + if err != nil { + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + uploadedFile, header, err := r.FormFile("file-upload") + if err == nil { + defer uploadedFile.Close() + file = uploadedFile + filename = header.Filename + fileSize = header.Size + documentType = r.FormValue("file_type") + documentName = r.FormValue("file_name") + } else if err != http.ErrMissingFile { + log.Error().Err(err).Msg("error retrieving file") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + eventID, err := h.applicationHandler.CreateAgendaEvent( + r.Context(), + eventForm.Name, + eventForm.Type, + eventForm.Description, + eventForm.Address, + eventForm.Allday, + eventForm.Startdate, + eventForm.Enddate, + eventForm.Starttime, + eventForm.Endtime, + eventForm.MaxSubscribers, + file, + filename, + fileSize, + documentType, + documentName, + ) + if err != nil { + log.Error().Err(err).Msg("error creating agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + return + } + + // For GET requests, render the create event form with config data + documentTypes := h.cfg.GetStringSlice("modules.agenda.documents_types") + fileTypes := h.cfg.GetStringMapString("storage.files.file_types") + h.renderer.AgendaCreateEvent(w, r, documentTypes, fileTypes, nil) + } +} + +func (h *Handler) AgendaDisplayEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + result, err := h.applicationHandler.GetAgendaEvent(r.Context(), eventID) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + documentTypes := h.cfg.GetStringSlice("modules.agenda.documents_types") + fileTypes := h.cfg.GetStringMapString("storage.files.file_types") + h.renderer.AgendaDisplayEvent(w, r, result.Event, result.Group, documentTypes, fileTypes, result.Documents, result.Subscribers, result.Accounts) + } +} + +func (h *Handler) AgendaUpdateEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + if r.Method == "POST" { + // Parse form data + eventForm, err := parseEventsForm(r) + if err != nil { + log.Error().Err(err).Msg("error parsing event form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + updatedEventID, err := h.applicationHandler.UpdateAgendaEvent( + r.Context(), + eventID, + eventForm.Name, + eventForm.Type, + eventForm.Description, + eventForm.Address, + eventForm.Allday, + eventForm.Startdate, + eventForm.Enddate, + eventForm.Starttime, + eventForm.Endtime, + eventForm.MaxSubscribers, + ) + if err != nil { + log.Error().Err(err).Msg("error updating agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", updatedEventID), http.StatusFound) + return + } + + // For GET requests, render the update event form + result, err := h.applicationHandler.GetAgendaEvent(r.Context(), eventID) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AgendaUpdateEvent(w, r, result.Event) + } +} + +func (h *Handler) AgendaDeleteEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + if r.Method == "POST" { + if err := h.applicationHandler.DeleteAgendaEvent(r.Context(), eventID); err != nil { + log.Error().Err(err).Msg("error deleting agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/agenda/", http.StatusFound) + return + } + + // For GET requests, render the delete confirmation form + result, err := h.applicationHandler.GetAgendaEvent(r.Context(), eventID) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AgendaDeleteEvent(w, r, result.Event) + } +} + +func (h *Handler) AgendaSubscribeEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + subscriber := r.FormValue("subscriber") + + // Get current user and group information + current_group, err := h.currentGroup(r) + if err != nil { + log.Error().Err(err).Msg("error getting current group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + current_user_token, current_user_claims, err := h.currentUser(r) + if err != nil { + log.Error().Err(err).Msg("error getting current user") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + subscriptionData := map[string]any{ + "subscribed_by": map[string]any{ + "user": map[string]any{ + "id": current_user_token.Subject, + "display_name": current_user_claims["first_name"].(string) + " " + current_user_claims["last_name"].(string), + "email": current_user_claims["email"].(string), + }, + "group": map[string]any{ + "id": current_group.ID, + "name": current_group.Data["name"], + }, + }, + } + + if err := h.applicationHandler.SubscribeToAgendaEvent(r.Context(), eventID, subscriber, subscriptionData); err != nil { + log.Error().Err(err).Msg("error subscribing to agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + return + } + + // For GET requests, redirect to event display + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + } +} + +func (h *Handler) AgendaDeleteSubscribeEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + subscribeID := vars["subscribeid"] + + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + motif := r.FormValue("motif") + + // Get current user and group information + current_group, err := h.currentGroup(r) + if err != nil { + log.Error().Err(err).Msg("error getting current group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + current_user_token, current_user_claims, err := h.currentUser(r) + if err != nil { + log.Error().Err(err).Msg("error getting current user") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + if err := h.applicationHandler.UnsubscribeFromAgendaEvent( + r.Context(), + eventID, + subscribeID, + motif, + current_user_token.Subject, + current_user_claims["first_name"].(string)+" "+current_user_claims["last_name"].(string), + current_user_claims["email"].(string), + current_group.ID, + current_group.Data["name"].(string), + ); err != nil { + log.Error().Err(err).Msg("error unsubscribing from agenda event") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + return + } + + // For GET requests, render the delete subscription form + h.renderer.AgendaDeleteSubscribeEvent(w, r, eventID) + } +} + +func (h *Handler) AgendaHistoryEventHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + result, err := h.applicationHandler.GetAgendaEventHistory(r.Context(), eventID) + if err != nil { + log.Error().Err(err).Msg("error retrieving agenda event history") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.AgendaHistoryEvent(w, r, result.Event, result.Group, result.Subscribers, result.Accounts) + } +} + +func (h *Handler) EventDocumentsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + if err := r.ParseMultipartForm(100 * 1024 * 1024); err != nil { // 100 MB limit + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + documentType := r.FormValue("type") + documentName := r.FormValue("name") + + file, header, err := r.FormFile("file-upload") + if err != nil { + log.Error().Err(err).Msg("error retrieving file") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + defer file.Close() + + if err := h.applicationHandler.AddEventDocument(r.Context(), eventID, file, header.Filename, header.Size, documentType, documentName); err != nil { + log.Error().Err(err).Msg("error adding event document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + } +} + +func (h *Handler) EventDocumentDownloadHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + document := vars["document"] + + file, info, err := h.applicationHandler.GetEventDocument(r.Context(), eventID, document) + if err != nil { + log.Error().Err(err).Msg("error retrieving event document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", info.ContentType) + if _, err = io.Copy(w, file); err != nil { + log.Error().Err(err).Msg("error copying file content") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/agenda/%s", eventID), http.StatusFound) + } +} \ No newline at end of file diff --git a/servers/web/application/beneficiaries.go b/servers/web/application/beneficiaries.go new file mode 100644 index 0000000..07e8d6d --- /dev/null +++ b/servers/web/application/beneficiaries.go @@ -0,0 +1,324 @@ +package application + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "strconv" + "time" + + formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/form-validators" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +type BeneficiariesForm struct { + FirstName string `json:"first_name" validate:"required"` + LastName string `json:"last_name" validate:"required"` + Email string `json:"email" validate:"required,email"` + Birthdate *time.Time `json:"birthdate" validate:"required"` + PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"` + FileNumber string `json:"file_number"` + Address any `json:"address,omitempty"` + Gender string `json:"gender"` + OtherProperties any `json:"other_properties,omitempty"` +} + +func parseBeneficiariesForm(r *http.Request) (*BeneficiariesForm, error) { + if err := r.ParseForm(); err != nil { + return nil, err + } + + var date *time.Time + + if r.PostFormValue("birthdate") != "" { + d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")) + if err != nil { + return nil, err + } + date = &d + } + + formData := &BeneficiariesForm{ + FirstName: r.PostFormValue("first_name"), + LastName: r.PostFormValue("last_name"), + Email: r.PostFormValue("email"), + Birthdate: date, + PhoneNumber: r.PostFormValue("phone_number"), + FileNumber: r.PostFormValue("file_number"), + Gender: r.PostFormValue("gender"), + } + + if r.PostFormValue("address") != "" { + var a any + json.Unmarshal([]byte(r.PostFormValue("address")), &a) + formData.Address = a + } + + if r.PostFormValue("other_properties") != "" { + var a any + json.Unmarshal([]byte(r.PostFormValue("other_properties")), &a) + formData.OtherProperties = a + } + + validate := formvalidators.New() + if err := validate.Struct(formData); err != nil { + return nil, err + } + + return formData, nil +} + +func (h *Handler) BeneficiariesListHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Extract search and archived filters from query parameters + searchFilter := "" + if search := r.URL.Query().Get("search"); search != "" { + searchFilter = search + } + + archivedFilter := false + if archived := r.URL.Query().Get("archived"); archived == "true" { + archivedFilter = true + } + + result, err := h.applicationHandler.GetBeneficiaries(r.Context(), searchFilter, archivedFilter) + if err != nil { + log.Error().Err(err).Msg("error retrieving beneficiaries") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.BeneficiariesList(w, r, result.Accounts, result.CacheID, archivedFilter) + } +} + +func (h *Handler) BeneficiaryCreateHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + beneficiaryForm, err := parseBeneficiariesForm(r) + if err != nil { + log.Error().Err(err).Msg("error parsing beneficiary form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + beneficiaryID, err := h.applicationHandler.CreateBeneficiary( + r.Context(), + beneficiaryForm.FirstName, + beneficiaryForm.LastName, + beneficiaryForm.Email, + beneficiaryForm.Birthdate, + beneficiaryForm.PhoneNumber, + beneficiaryForm.FileNumber, + beneficiaryForm.Address, + beneficiaryForm.Gender, + beneficiaryForm.OtherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error creating beneficiary") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) + return + } + + h.renderer.BeneficiaryCreate(w, r) + } +} + +func (h *Handler) BeneficiaryDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + // Extract tab parameter + tab := r.URL.Query().Get("tab") + if tab == "" { + tab = "documents" // Default tab + } + + result, err := h.applicationHandler.GetBeneficiaryData(r.Context(), beneficiaryID) + if err != nil { + log.Error().Err(err).Msg("error retrieving beneficiary data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + beneficiariesFileTypes := h.cfg.GetStringSlice("modules.beneficiaries.documents_types") + fileTypesMap := h.cfg.GetStringMapString("storage.files.file_types") + + h.renderer.BeneficiaryDisplay(w, r, result.Account, result.Bookings, result.Organizations, beneficiariesFileTypes, fileTypesMap, result.Documents, result.EventsList, result.SolidarityTransportStats, result.SolidarityTransportBookings, result.SolidarityDriversMap, result.OrganizedCarpoolStats, result.OrganizedCarpoolBookings, result.OrganizedCarpoolDriversMap, result.WalletBalance, tab) + } +} + +func (h *Handler) BeneficiaryUpdateHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + if r.Method == "POST" { + beneficiaryForm, err := parseBeneficiariesForm(r) + if err != nil { + log.Error().Err(err).Msg("error parsing beneficiary form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + updatedBeneficiaryID, err := h.applicationHandler.UpdateBeneficiary( + r.Context(), + beneficiaryID, + beneficiaryForm.FirstName, + beneficiaryForm.LastName, + beneficiaryForm.Email, + beneficiaryForm.Birthdate, + beneficiaryForm.PhoneNumber, + beneficiaryForm.FileNumber, + beneficiaryForm.Address, + beneficiaryForm.Gender, + beneficiaryForm.OtherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error updating beneficiary") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", updatedBeneficiaryID), http.StatusFound) + return + } + + // For GET requests, just get the basic beneficiary account data + result, err := h.applicationHandler.GetBeneficiary(r.Context(), beneficiaryID) + if err != nil { + log.Error().Err(err).Msg("error retrieving beneficiary for update") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.BeneficiaryUpdate(w, r, result.Account) + } +} + +func (h *Handler) BeneficiaryArchiveHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + if err := h.applicationHandler.ArchiveBeneficiary(r.Context(), beneficiaryID); err != nil { + log.Error().Err(err).Msg("error archiving beneficiary") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) + } +} + +func (h *Handler) BeneficiaryUnarchiveHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + if err := h.applicationHandler.UnarchiveBeneficiary(r.Context(), beneficiaryID); err != nil { + log.Error().Err(err).Msg("error unarchiving beneficiary") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) + } +} + +func (h *Handler) BeneficiaryPictureHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + imageData, contentType, err := h.applicationHandler.GetBeneficiaryPicture(r.Context(), beneficiaryID) + if err != nil { + log.Error().Err(err).Msg("error generating beneficiary picture") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", contentType) + w.Header().Set("Content-Length", strconv.Itoa(len(imageData))) + if _, err := w.Write(imageData); err != nil { + log.Error().Err(err).Msg("unable to write image") + } + } +} + +func (h *Handler) BeneficiaryDocumentsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + + if err := r.ParseMultipartForm(100 * 1024 * 1024); err != nil { // 100 MB limit + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + documentType := r.FormValue("type") + documentName := r.FormValue("name") + + file, header, err := r.FormFile("file-upload") + if err != nil { + log.Error().Err(err).Msg("error retrieving file") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + defer file.Close() + + if err := h.applicationHandler.AddBeneficiaryDocument(r.Context(), beneficiaryID, file, header.Filename, header.Size, documentType, documentName); err != nil { + log.Error().Err(err).Msg("error adding beneficiary document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) + } +} + +func (h *Handler) BeneficiaryDocumentDownloadHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + document := vars["document"] + + file, info, err := h.applicationHandler.GetBeneficiaryDocument(r.Context(), beneficiaryID, document) + if err != nil { + log.Error().Err(err).Msg("error retrieving beneficiary document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", info.ContentType) + if _, err = io.Copy(w, file); err != nil { + log.Error().Err(err).Msg("error copying file content") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } +} + +func (h *Handler) BeneficiaryDocumentDeleteHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + beneficiaryID := vars["beneficiaryid"] + document := vars["document"] + + if err := h.applicationHandler.DeleteBeneficiaryDocument(r.Context(), beneficiaryID, document); err != nil { + log.Error().Err(err).Msg("error deleting beneficiary document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/beneficiaries/%s", beneficiaryID), http.StatusFound) + } +} \ No newline at end of file diff --git a/servers/web/application/dashboard.go b/servers/web/application/dashboard.go new file mode 100644 index 0000000..8a464d2 --- /dev/null +++ b/servers/web/application/dashboard.go @@ -0,0 +1,74 @@ +package application + +import ( + "net/http" + "sort" + "strings" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) DashboardHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Parse driver address geography filter + driverAddressGeo := r.URL.Query().Get("driver_address_geo") + driverAddressGeoLayer, driverAddressGeoCode := "", "" + if driverAddressGeo != "" { + parts := strings.SplitN(driverAddressGeo, ":", 2) + if len(parts) == 2 { + driverAddressGeoLayer, driverAddressGeoCode = parts[0], parts[1] + } + } + + result, err := h.applicationHandler.GetDashboardData(r.Context(), driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Error().Err(err).Msg("error retrieving dashboard data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Enrich geography filters with names from geography service + var enrichedGeoFilters []map[string]string + if h.cfg.GetBool("geography.filters.enabled") { + geoFilters := h.cfg.Get("geography.filters.geographies") + if geoList, ok := geoFilters.([]any); ok { + for _, geoItem := range geoList { + if geoMap, ok := geoItem.(map[string]any); ok { + layer := "" + code := "" + if l, ok := geoMap["layer"].(string); ok { + layer = l + } + if c, ok := geoMap["code"].(string); ok { + code = c + } + + enrichedGeo := map[string]string{ + "layer": layer, + "code": code, + "name": code, // Default to code if name fetch fails + } + + // Fetch name from geography service + if layer != "" && code != "" { + if geoFeature, err := h.services.Geography.Find(layer, code); err == nil { + if name := geoFeature.Properties.MustString("nom"); name != "" { + enrichedGeo["name"] = name + } + } + } + + enrichedGeoFilters = append(enrichedGeoFilters, enrichedGeo) + } + } + } + + // Sort by name + sort.Slice(enrichedGeoFilters, func(i, j int) bool { + return enrichedGeoFilters[i]["name"] < enrichedGeoFilters[j]["name"] + }) + } + + h.renderer.Dashboard(w, r, result.Accounts, len(result.Accounts), len(result.Members), result.Events, result.Bookings, result.SolidarityDrivers, result.OrganizedCarpoolDrivers, driverAddressGeo, enrichedGeoFilters) + } +} \ No newline at end of file diff --git a/servers/web/application/directory.go b/servers/web/application/directory.go new file mode 100644 index 0000000..2af66bd --- /dev/null +++ b/servers/web/application/directory.go @@ -0,0 +1,11 @@ +package application + +import ( + "net/http" +) + +func (h *Handler) DirectoryHomeHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + h.renderer.DirectoryHome(w, r) + } +} \ No newline at end of file diff --git a/servers/web/application/group.go b/servers/web/application/group.go new file mode 100644 index 0000000..2489efc --- /dev/null +++ b/servers/web/application/group.go @@ -0,0 +1,54 @@ +package application + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/rs/zerolog/log" +) + +func (h *Handler) GroupSettingsDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + g := r.Context().Value(identification.GroupKey) + if g == nil { + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + group := g.(storage.Group) + + result, err := h.applicationHandler.GetGroupSettings(r.Context(), group.ID) + if err != nil { + log.Error().Err(err).Msg("error getting group settings") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.GroupSettingsDisplay(w, r, result.Group, result.GroupMembers, result.Admins) + } +} + +func (h *Handler) GroupSettingsInviteMemberHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + g := r.Context().Value(identification.GroupKey) + if g == nil { + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + group := g.(storage.Group) + + r.ParseForm() + username := r.FormValue("username") + + err := h.applicationHandler.InviteMemberToGroup(r.Context(), group.ID, username) + if err != nil { + log.Error().Err(err).Msg("error inviting member to group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/group/settings", http.StatusFound) + } +} \ No newline at end of file diff --git a/servers/web/application/group_module.go b/servers/web/application/group_module.go new file mode 100644 index 0000000..8a96b45 --- /dev/null +++ b/servers/web/application/group_module.go @@ -0,0 +1,101 @@ +package application + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) GroupsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetGroups(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error getting groups") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.Groups(w, r, result.Groups) + } +} + +func (h *Handler) CreateGroupModuleHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + r.ParseForm() + + name := r.FormValue("name") + groupType := r.FormValue("type") + description := r.FormValue("description") + address := r.PostFormValue("address") + + result, err := h.applicationHandler.CreateGroupModule(r.Context(), name, groupType, description, address) + if err != nil { + log.Error().Err(err).Msg("error creating group module") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/group_module/groups/"+result.GroupID, http.StatusFound) + return + } + + result, err := h.applicationHandler.GetGroupModuleCreateData(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error getting group module create data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.CreateGroupModule(w, r, result.GroupTypes) + } +} + +func (h *Handler) DisplayGroupModuleHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + groupID := vars["groupid"] + + if r.Method == "POST" || r.FormValue("beneficiaryid") != "" { + r.ParseForm() + beneficiaryID := r.FormValue("beneficiaryid") + + err := h.applicationHandler.SubscribeBeneficiaryToGroup(r.Context(), groupID, beneficiaryID) + if err != nil { + log.Error().Err(err).Msg("error subscribing beneficiary to group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/group_module/groups/"+groupID, http.StatusFound) + return + } + + // Get current user's group from context + g := r.Context().Value(identification.GroupKey) + if g == nil { + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + currentUserGroup := g.(storage.Group) + + // Parse search filter + searchFilter := "" + if searchFilters, ok := r.URL.Query()["search"]; ok && len(searchFilters) > 0 { + searchFilter = searchFilters[0] + } + + result, err := h.applicationHandler.DisplayGroupModule(r.Context(), groupID, searchFilter, currentUserGroup) + if err != nil { + log.Error().Err(err).Msg("error displaying group module") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.DisplayGroupModule(w, r, result.GroupID, result.Accounts, result.CacheID, + result.Searched, result.Beneficiary, result.Group, result.AccountsBeneficiaire) + } +} \ No newline at end of file diff --git a/servers/web/application/handler.go b/servers/web/application/handler.go new file mode 100644 index 0000000..fd5c074 --- /dev/null +++ b/servers/web/application/handler.go @@ -0,0 +1,60 @@ +package application + +import ( + "errors" + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/renderer" + "git.coopgo.io/coopgo-apps/parcoursmob/services" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/coreos/go-oidc/v3/oidc" + "github.com/spf13/viper" +) + +type Handler struct { + cfg *viper.Viper + renderer *renderer.Renderer + applicationHandler *application.ApplicationHandler + idp *identification.IdentificationProvider + services *services.ServicesHandler +} + +func NewHandler(cfg *viper.Viper, renderer *renderer.Renderer, applicationHandler *application.ApplicationHandler, idp *identification.IdentificationProvider, services *services.ServicesHandler) *Handler { + return &Handler{ + cfg: cfg, + renderer: renderer, + applicationHandler: applicationHandler, + idp: idp, + services: services, + } +} + +func (h *Handler) currentGroup(r *http.Request) (current_group storage.Group, err error) { + g := r.Context().Value(identification.GroupKey) + if g == nil { + return storage.Group{}, errors.New("current group not found") + } + current_group = g.(storage.Group) + + return current_group, nil +} + +func (h *Handler) currentUser(r *http.Request) (current_user_token *oidc.IDToken, current_user_claims map[string]any, err error) { + // Get current user ID + u := r.Context().Value(identification.IdtokenKey) + if u == nil { + return nil, nil, errors.New("current user not found") + } + current_user_token = u.(*oidc.IDToken) + + // Get current user claims + c := r.Context().Value(identification.ClaimsKey) + if c == nil { + return nil, nil, errors.New("current user claims not found") + } + current_user_claims = c.(map[string]any) + + return current_user_token, current_user_claims, nil +} \ No newline at end of file diff --git a/servers/web/application/journeys.go b/servers/web/application/journeys.go new file mode 100644 index 0000000..1f6f291 --- /dev/null +++ b/servers/web/application/journeys.go @@ -0,0 +1,418 @@ +package application + +import ( + "encoding/json" + "net/http" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + savedsearchtypes "git.coopgo.io/coopgo-platform/saved-search/data/types" + "github.com/gorilla/mux" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" +) + +func (h *Handler) JourneysSearchHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract and convert HTTP parameters + departureDate := r.FormValue("departuredate") + departureTime := r.FormValue("departuretime") + departure := r.FormValue("departure") + destination := r.FormValue("destination") + passengerID := r.FormValue("passengerid") + solidarityTransportExcludeDriver := r.FormValue("solidarity_transport_exclude_driver") + + // Parse timezone and datetime + locTime, err := time.LoadLocation("Europe/Paris") + if err != nil { + log.Error().Err(err).Msg("timezone error") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + var departureDateTime time.Time + if departureDate != "" && departureTime != "" { + departureDateTime, err = time.ParseInLocation("2006-01-02 15:04", departureDate+" "+departureTime, locTime) + if err != nil { + log.Error().Err(err).Msg("error parsing datetime") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + log.Info(). + Str("departureDate", departureDate). + Str("departureTime", departureTime). + Time("departureDateTime", departureDateTime). + Str("timezone", departureDateTime.Location().String()). + Str("RFC3339", departureDateTime.Format(time.RFC3339)). + Msg("Journey search - parsed departure datetime") + } + + // Parse departure location + var departureGeo *geojson.Feature + if departure == "" && passengerID != "" { + // Get passenger address + p, err := h.services.GetAccount(passengerID) + if err != nil { + log.Error().Err(err).Msg("could not retrieve passenger") + http.Error(w, "Not Found", http.StatusNotFound) + return + } + + departureBytes, err := json.Marshal(p.Data["address"]) + if err != nil { + log.Error().Err(err).Any("address", p.Data["address"]).Msg("could not marshal address") + } else { + departureGeo, err = geojson.UnmarshalFeature(departureBytes) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling passenger departure") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + } else if departure != "" { + departureGeo, err = geojson.UnmarshalFeature([]byte(departure)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling departure") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse destination location + var destinationGeo *geojson.Feature + if destination != "" { + destinationGeo, err = geojson.UnmarshalFeature([]byte(destination)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling destination") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Call business logic handler + result, err := h.applicationHandler.SearchJourneys( + r.Context(), + departureDateTime, + departureGeo, + destinationGeo, + passengerID, + solidarityTransportExcludeDriver, + ) + if err != nil { + log.Error().Err(err).Msg("error in journey search") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Get beneficiaries for rendering + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("group not found in request context") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + group := g.(groupstorage.Group) + + beneficiaries, err := h.services.GetBeneficiariesInGroup(group) + if err != nil { + log.Error().Err(err).Msg("issue retrieving beneficiaries") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Get saved searches for this group when no search has been performed + var savedSearches []*savedsearchtypes.SavedSearch + var beneficiariesMap map[string]mobilityaccountsstorage.Account + if !result.Searched { + savedSearches, err = h.applicationHandler.GetSavedSearchesByOwner(r.Context(), group.ID) + if err != nil { + log.Error().Err(err).Msg("issue retrieving saved searches") + // Don't fail the request, just log the error + savedSearches = []*savedsearchtypes.SavedSearch{} + } + + // Create beneficiaries map for template lookup + beneficiariesMap = make(map[string]mobilityaccountsstorage.Account) + for _, b := range beneficiaries { + beneficiariesMap[b.ID] = b + } + } + + // Render HTTP response + h.renderer.JourneysSearch( + w, r, + result.CarpoolResults, + result.TransitResults, + result.VehicleResults, + result.Searched, + departureGeo, + destinationGeo, + departureDate, + departureTime, + result.DriverJourneys, + result.Drivers, + result.OrganizedCarpools, + beneficiaries, + result.KnowledgeBaseResults, + passengerID, + savedSearches, + beneficiariesMap, + ) + } +} + +func (h *Handler) SaveSearchHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract search parameters from URL query + query := r.URL.Query() + departureDate := query.Get("departuredate") + departureTime := query.Get("departuretime") + departure := query.Get("departure") + destination := query.Get("destination") + passengerID := query.Get("passengerid") + + // Debug logging + log.Debug(). + Str("departuredate", departureDate). + Str("departuretime", departureTime). + Str("departure", departure). + Str("destination", destination). + Str("passengerid", passengerID). + Str("query", r.URL.RawQuery). + Msg("SaveSearch request parameters") + + // Parse timezone and datetime + locTime, err := time.LoadLocation("Europe/Paris") + if err != nil { + log.Error().Err(err).Msg("timezone error") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + var departureDateTime time.Time + if departureDate != "" && departureTime != "" { + departureDateTime, err = time.ParseInLocation("2006-01-02 15:04", departureDate+" "+departureTime, locTime) + if err != nil { + log.Error().Err(err).Msg("error parsing datetime") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse departure location + var departureGeo *geojson.Feature + if departure != "" { + departureGeo, err = geojson.UnmarshalFeature([]byte(departure)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling departure") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse destination location + var destinationGeo *geojson.Feature + if destination != "" { + destinationGeo, err = geojson.UnmarshalFeature([]byte(destination)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling destination") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Get group ID from session/context + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("group not found in request context") + http.Error(w, "Unauthorized", http.StatusUnauthorized) + return + } + group := g.(groupstorage.Group) + + // Prepare additional data + additionalData := map[string]interface{}{} + if passengerID != "" { + additionalData["passenger_id"] = passengerID + } + + // Save the search using the business logic + err = h.applicationHandler.SaveSearch( + r.Context(), + group.ID, + departureDateTime, + departureGeo, + destinationGeo, + additionalData, + ) + if err != nil { + log.Error().Err(err).Msg("error saving search") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Redirect back to search with success message + http.Redirect(w, r, "/app/journeys/", http.StatusSeeOther) + } +} + +func (h *Handler) DeleteSavedSearchHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Get search ID from URL parameters + vars := mux.Vars(r) + searchID := vars["id"] + if searchID == "" { + log.Error().Msg("search ID not provided") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Get group ID from session/context for authorization + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("group not found in request context") + http.Error(w, "Unauthorized", http.StatusUnauthorized) + return + } + group := g.(groupstorage.Group) + + // Delete the saved search using the business logic + err := h.applicationHandler.DeleteSavedSearch(r.Context(), searchID, group.ID) + if err != nil { + log.Error().Err(err).Str("search_id", searchID).Msg("error deleting saved search") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + log.Info().Str("search_id", searchID).Str("group_id", group.ID).Msg("saved search deleted successfully") + + // Redirect back to journeys page + http.Redirect(w, r, "/app/journeys/?deleted=1", http.StatusSeeOther) + } +} + +func (h *Handler) JourneysSearchCompactHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract and convert HTTP parameters (same as JourneysSearchHTTPHandler) + departureDate := r.FormValue("departuredate") + departureTime := r.FormValue("departuretime") + departure := r.FormValue("departure") + destination := r.FormValue("destination") + passengerID := r.FormValue("passengerid") + solidarityTransportExcludeDriver := r.FormValue("solidarity_transport_exclude_driver") + + // Parse timezone and datetime + locTime, err := time.LoadLocation("Europe/Paris") + if err != nil { + log.Error().Err(err).Msg("timezone error") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + var departureDateTime time.Time + if departureDate != "" && departureTime != "" { + departureDateTime, err = time.ParseInLocation("2006-01-02 15:04", departureDate+" "+departureTime, locTime) + if err != nil { + log.Error().Err(err).Msg("error parsing datetime") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse departure location + var departureGeo *geojson.Feature + if departure == "" && passengerID != "" { + // Get passenger address + p, err := h.services.GetAccount(passengerID) + if err != nil { + log.Error().Err(err).Msg("could not retrieve passenger") + http.Error(w, "Not Found", http.StatusNotFound) + return + } + + departureBytes, err := json.Marshal(p.Data["address"]) + if err != nil { + log.Error().Err(err).Any("address", p.Data["address"]).Msg("could not marshal address") + } else { + departureGeo, err = geojson.UnmarshalFeature(departureBytes) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling passenger departure") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + } else if departure != "" { + departureGeo, err = geojson.UnmarshalFeature([]byte(departure)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling departure") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse destination location + var destinationGeo *geojson.Feature + if destination != "" { + destinationGeo, err = geojson.UnmarshalFeature([]byte(destination)) + if err != nil { + log.Error().Err(err).Msg("error unmarshalling destination") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Call business logic handler + result, err := h.applicationHandler.SearchJourneys( + r.Context(), + departureDateTime, + departureGeo, + destinationGeo, + passengerID, + solidarityTransportExcludeDriver, + ) + if err != nil { + log.Error().Err(err).Msg("error in journey search") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Render compact HTTP response + h.renderer.JourneysSearchCompact( + w, r, + result.CarpoolResults, + result.TransitResults, + result.VehicleResults, + result.Searched, + departureGeo, + destinationGeo, + departureDate, + departureTime, + result.DriverJourneys, + result.Drivers, + result.OrganizedCarpools, + result.KnowledgeBaseResults, + passengerID, + ) + } +} + diff --git a/servers/web/application/members.go b/servers/web/application/members.go new file mode 100644 index 0000000..44ac557 --- /dev/null +++ b/servers/web/application/members.go @@ -0,0 +1,72 @@ +package application + +import ( + "fmt" + "net/http" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) MembersListHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.GetMembers(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error retrieving members") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.MembersList(w, r, result.Accounts, result.CacheID, result.GroupsNames) + } +} + +func (h *Handler) MemberDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + memberID := vars["adminid"] + + result, err := h.applicationHandler.GetMemberData(r.Context(), memberID) + if err != nil { + log.Error().Err(err).Msg("error retrieving member data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.MemberDisplay(w, r, result.Account, result.GroupsNames) + } +} + +func (h *Handler) MemberUpdateHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + memberID := vars["adminid"] + + if r.Method == "POST" { + firstName := r.PostFormValue("first_name") + lastName := r.PostFormValue("last_name") + email := r.PostFormValue("email") + phoneNumber := r.PostFormValue("phone_number") + gender := r.PostFormValue("gender") + + updatedMemberID, err := h.applicationHandler.UpdateMember(r.Context(), memberID, firstName, lastName, email, phoneNumber, gender) + if err != nil { + log.Error().Err(err).Msg("error updating member") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/members/%s", updatedMemberID), http.StatusFound) + return + } + + result, err := h.applicationHandler.GetMember(r.Context(), memberID) + if err != nil { + log.Error().Err(err).Msg("error retrieving member for update") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.MemberUpdate(w, r, result.Account) + } +} \ No newline at end of file diff --git a/servers/web/application/organized_carpool.go b/servers/web/application/organized_carpool.go new file mode 100644 index 0000000..adecf15 --- /dev/null +++ b/servers/web/application/organized_carpool.go @@ -0,0 +1,596 @@ +package application + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "sort" + "strings" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/gorilla/mux" + "github.com/paulmach/orb/geojson" + "github.com/rs/zerolog/log" +) + +func (h *Handler) OrganizedCarpoolOverviewHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Parse form to get both query params and form data + r.ParseForm() + + // Extract filter parameters + tab := r.FormValue("tab") + if tab == "" { + tab = "carpoolService" // Default to showing current bookings + } + + // Extract archived filter + archivedFilter := false + if archived := r.URL.Query().Get("archived"); archived == "true" { + archivedFilter = true + } + + // Apply filters conditionally based on tab + var status, driverID, startDate, endDate, departureGeo, destinationGeo, passengerAddressGeo, driverAddressGeo string + var histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeo, histDestinationGeo, histPassengerAddressGeo string + + // Driver address geography filter (applies when on drivers tab) + if tab == "drivers" { + driverAddressGeo = r.FormValue("driver_address_geo") + } + + if tab == "carpoolService" { + status = r.FormValue("status") + driverID = r.FormValue("driver_id") + startDate = r.FormValue("date_start") + endDate = r.FormValue("date_end") + departureGeo = r.FormValue("departure_geo") + destinationGeo = r.FormValue("destination_geo") + passengerAddressGeo = r.FormValue("passenger_address_geo") + } + + // History filters (apply when on carpoolHistory tab) + if tab == "carpoolHistory" { + histStatus = r.FormValue("status") + histDriverID = r.FormValue("driver_id") + histStartDate = r.FormValue("date_start") + histEndDate = r.FormValue("date_end") + histDepartureGeo = r.FormValue("departure_geo") + histDestinationGeo = r.FormValue("destination_geo") + histPassengerAddressGeo = r.FormValue("passenger_address_geo") + } + + // Set default history dates if not provided + if histStartDate == "" { + histStartDate = time.Now().Add(-30 * 24 * time.Hour).Format("2006-01-02") + } + if histEndDate == "" { + histEndDate = time.Now().Add(-24 * time.Hour).Format("2006-01-02") + } + + // Parse geography parameters (format: "layer:code") + departureGeoLayer, departureGeoCode := "", "" + if departureGeo != "" { + parts := strings.SplitN(departureGeo, ":", 2) + if len(parts) == 2 { + departureGeoLayer, departureGeoCode = parts[0], parts[1] + } + } + destinationGeoLayer, destinationGeoCode := "", "" + if destinationGeo != "" { + parts := strings.SplitN(destinationGeo, ":", 2) + if len(parts) == 2 { + destinationGeoLayer, destinationGeoCode = parts[0], parts[1] + } + } + passengerAddressGeoLayer, passengerAddressGeoCode := "", "" + if passengerAddressGeo != "" { + parts := strings.SplitN(passengerAddressGeo, ":", 2) + if len(parts) == 2 { + passengerAddressGeoLayer, passengerAddressGeoCode = parts[0], parts[1] + } + } + + histDepartureGeoLayer, histDepartureGeoCode := "", "" + if histDepartureGeo != "" { + parts := strings.SplitN(histDepartureGeo, ":", 2) + if len(parts) == 2 { + histDepartureGeoLayer, histDepartureGeoCode = parts[0], parts[1] + } + } + histDestinationGeoLayer, histDestinationGeoCode := "", "" + if histDestinationGeo != "" { + parts := strings.SplitN(histDestinationGeo, ":", 2) + if len(parts) == 2 { + histDestinationGeoLayer, histDestinationGeoCode = parts[0], parts[1] + } + } + histPassengerAddressGeoLayer, histPassengerAddressGeoCode := "", "" + if histPassengerAddressGeo != "" { + parts := strings.SplitN(histPassengerAddressGeo, ":", 2) + if len(parts) == 2 { + histPassengerAddressGeoLayer, histPassengerAddressGeoCode = parts[0], parts[1] + } + } + + // Parse driver address geography parameter + driverAddressGeoLayer, driverAddressGeoCode := "", "" + if driverAddressGeo != "" { + parts := strings.SplitN(driverAddressGeo, ":", 2) + if len(parts) == 2 { + driverAddressGeoLayer, driverAddressGeoCode = parts[0], parts[1] + } + } + + result, err := h.applicationHandler.GetOrganizedCarpoolOverview(r.Context(), status, driverID, startDate, endDate, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode, histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeoLayer, histDepartureGeoCode, histDestinationGeoLayer, histDestinationGeoCode, histPassengerAddressGeoLayer, histPassengerAddressGeoCode, archivedFilter, driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool overview") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Build filters map for template + filters := map[string]any{ + "tab": tab, + "date_start": startDate, + "date_end": endDate, + "status": status, + "driver_id": driverID, + "departure_geo": departureGeo, + "destination_geo": destinationGeo, + "passenger_address_geo": passengerAddressGeo, + "driver_address_geo": driverAddressGeo, + } + + histFilters := map[string]any{ + "tab": tab, + "date_start": histStartDate, + "date_end": histEndDate, + "status": histStatus, + "driver_id": histDriverID, + "departure_geo": histDepartureGeo, + "destination_geo": histDestinationGeo, + "passenger_address_geo": histPassengerAddressGeo, + } + + // Enrich geography filters with names from geography service + var enrichedGeoFilters []map[string]string + if h.cfg.GetBool("geography.filters.enabled") { + geoFilters := h.cfg.Get("geography.filters.geographies") + if geoList, ok := geoFilters.([]any); ok { + for _, geoItem := range geoList { + if geoMap, ok := geoItem.(map[string]any); ok { + layer := "" + code := "" + if l, ok := geoMap["layer"].(string); ok { + layer = l + } + if c, ok := geoMap["code"].(string); ok { + code = c + } + + enrichedGeo := map[string]string{ + "layer": layer, + "code": code, + "name": code, // Default to code if name fetch fails + } + + // Fetch name from geography service + if layer != "" && code != "" { + if geoFeature, err := h.services.Geography.Find(layer, code); err == nil { + if name := geoFeature.Properties.MustString("nom"); name != "" { + enrichedGeo["name"] = name + } + } + } + + enrichedGeoFilters = append(enrichedGeoFilters, enrichedGeo) + } + } + } + + // Sort by name + sort.Slice(enrichedGeoFilters, func(i, j int) bool { + return enrichedGeoFilters[i]["name"] < enrichedGeoFilters[j]["name"] + }) + } + + h.renderer.OrganizedCarpoolOverview(w, r, result.Accounts, result.AccountsMap, result.BeneficiariesMap, result.Bookings, result.BookingsHistory, filters, histFilters, tab, enrichedGeoFilters, archivedFilter) + } +} + +func (h *Handler) OrganizedCarpoolBookingDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + result, err := h.applicationHandler.GetOrganizedCarpoolBookingData(r.Context(), bookingID) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool booking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.OrganizedCarpoolBookingDisplay(w, r, result.Booking, result.Driver, result.Passenger, result.DriverDepartureAddress, result.DriverArrivalAddress) + } +} + +func (h *Handler) OrganizedCarpoolBookingStatusHTTPHandler(action string) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + err := h.applicationHandler.UpdateOrganizedCarpoolBookingStatus(r.Context(), bookingID, action) + if err != nil { + log.Error().Err(err).Msg("error updating organized carpool booking status") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/bookings/%s", bookingID), http.StatusSeeOther) + } +} + +func (h *Handler) OrganizedCarpoolCreateDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + // Parse form data + firstName := r.PostFormValue("first_name") + lastName := r.PostFormValue("last_name") + email := r.PostFormValue("email") + phoneNumber := r.PostFormValue("phone_number") + fileNumber := r.PostFormValue("file_number") + gender := r.PostFormValue("gender") + + var birthdate *time.Time + if r.PostFormValue("birthdate") != "" { + if d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")); err == nil { + birthdate = &d + } + } + + // Parse JSON address fields + var address, addressDestination any + if r.PostFormValue("address") != "" { + json.Unmarshal([]byte(r.PostFormValue("address")), &address) + } + if r.PostFormValue("address_destination") != "" { + json.Unmarshal([]byte(r.PostFormValue("address_destination")), &addressDestination) + } + + driverID, err := h.applicationHandler.CreateOrganizedCarpoolDriver( + r.Context(), + firstName, + lastName, + email, + birthdate, + phoneNumber, + fileNumber, + address, + addressDestination, + gender, + ) + if err != nil { + log.Error().Err(err).Msg("error creating organized carpool driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + return + } + + h.renderer.OrganizedCarpoolCreateDriver(w, r) + } +} + +func (h *Handler) OrganizedCarpoolDriverDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + // Extract tab parameter + tab := r.URL.Query().Get("tab") + if tab == "" { + tab = "documents" // Default tab + } + + result, err := h.applicationHandler.GetOrganizedCarpoolDriverData(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool driver data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.OrganizedCarpoolDriverDisplay(w, r, result.Driver, result.Trips, result.Documents, result.Bookings, result.BeneficiariesMap, result.Stats, result.WalletBalance, tab) + } +} + +func (h *Handler) OrganizedCarpoolUpdateDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + if r.Method == "POST" { + // Parse form data + firstName := r.PostFormValue("first_name") + lastName := r.PostFormValue("last_name") + email := r.PostFormValue("email") + phoneNumber := r.PostFormValue("phone_number") + fileNumber := r.PostFormValue("file_number") + gender := r.PostFormValue("gender") + + var birthdate *time.Time + if r.PostFormValue("birthdate") != "" { + if d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")); err == nil { + birthdate = &d + } + } + + // Parse JSON address fields + var address, addressDestination any + if r.PostFormValue("address") != "" { + json.Unmarshal([]byte(r.PostFormValue("address")), &address) + } + if r.PostFormValue("address_destination") != "" { + json.Unmarshal([]byte(r.PostFormValue("address_destination")), &addressDestination) + } + + updatedDriverID, err := h.applicationHandler.UpdateOrganizedCarpoolDriver( + r.Context(), + driverID, + firstName, + lastName, + email, + birthdate, + phoneNumber, + fileNumber, + address, + addressDestination, + gender, + r.PostFormValue("other_properties"), + ) + if err != nil { + log.Error().Err(err).Msg("error updating organized carpool driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", updatedDriverID), http.StatusFound) + return + } + + result, err := h.applicationHandler.GetOrganizedCarpoolDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool driver for update") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.OrganizedCarpoolUpdateDriver(w, r, result.Driver) + } +} + +func (h *Handler) OrganizedCarpoolArchiveDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + err := h.applicationHandler.ArchiveOrganizedCarpoolDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error archiving organized carpool driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolUnarchiveDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + err := h.applicationHandler.UnarchiveOrganizedCarpoolDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error unarchiving organized carpool driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolDriverDocumentsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + if err := r.ParseMultipartForm(100 * 1024 * 1024); err != nil { // 100 MB limit + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + documentType := r.FormValue("type") + documentName := r.FormValue("name") + + file, header, err := r.FormFile("file-upload") + if err != nil { + log.Error().Err(err).Msg("error retrieving file") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + defer file.Close() + + if err := h.applicationHandler.AddOrganizedCarpoolDriverDocument(r.Context(), driverID, file, header.Filename, header.Size, documentType, documentName); err != nil { + log.Error().Err(err).Msg("error adding organized carpool driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolDocumentDownloadHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + document := vars["document"] + + file, info, err := h.applicationHandler.GetOrganizedCarpoolDriverDocument(r.Context(), driverID, document) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", info.ContentType) + if _, err = io.Copy(w, file); err != nil { + log.Error().Err(err).Msg("error copying file content") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } +} + +func (h *Handler) OrganizedCarpoolDocumentDeleteHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + document := vars["document"] + + if err := h.applicationHandler.DeleteOrganizedCarpoolDriverDocument(r.Context(), driverID, document); err != nil { + log.Error().Err(err).Msg("error deleting organized carpool driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolAddTripHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + log.Error().Msg("Wrong method") + http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed) + return + } + + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing availabilities form") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + vars := mux.Vars(r) + driverID := vars["driverid"] + + // Parse form data + outwardtime := r.PostFormValue("outwardtime") + returntime := r.PostFormValue("returntime") + + // Parse GeoJSON features + departure, err := geojson.UnmarshalFeature([]byte(r.PostFormValue("address_departure"))) + if err != nil { + log.Error().Err(err).Msg("failed parsing departure geojson") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + destination, err := geojson.UnmarshalFeature([]byte(r.PostFormValue("address_destination"))) + if err != nil { + log.Error().Err(err).Msg("failed parsing destination geojson") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Parse days + days := map[string]bool{ + "monday": r.PostFormValue("days.monday") == "on", + "tuesday": r.PostFormValue("days.tuesday") == "on", + "wednesday": r.PostFormValue("days.wednesday") == "on", + "thursday": r.PostFormValue("days.thursday") == "on", + "friday": r.PostFormValue("days.friday") == "on", + "saturday": r.PostFormValue("days.saturday") == "on", + "sunday": r.PostFormValue("days.sunday") == "on", + } + + err = h.applicationHandler.AddOrganizedCarpoolTrip(r.Context(), driverID, outwardtime, returntime, departure, destination, days) + if err != nil { + log.Error().Err(err).Msg("error adding organized carpool trip") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolDeleteTripHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + tripID := vars["tripid"] + + err := h.applicationHandler.DeleteOrganizedCarpoolTrip(r.Context(), tripID) + if err != nil { + log.Error().Err(err).Msg("error deleting organized carpool trip") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) OrganizedCarpoolJourneyHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + journeyID := vars["journeyid"] + passengerID := r.URL.Query().Get("passengerid") + + if r.Method == "POST" { + // Parse form data + motivation := r.PostFormValue("motivation") + message := r.PostFormValue("message") + doNotSend := r.PostFormValue("do_not_send") == "on" + + bookingID, err := h.applicationHandler.CreateOrganizedCarpoolJourneyBooking(r.Context(), driverID, journeyID, passengerID, motivation, message, doNotSend) + if err != nil { + log.Error().Err(err).Msg("error creating organized carpool journey booking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + log.Info().Str("booking_id", bookingID).Msg("Carpool booking created successfully") + http.Redirect(w, r, fmt.Sprintf("/app/organized-carpool/"), http.StatusFound) + return + } + + // Get current user's group + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("group not found in request context") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + group := g.(groupstorage.Group) + + result, err := h.applicationHandler.GetOrganizedCarpoolJourneyData(r.Context(), driverID, journeyID, passengerID, group) + if err != nil { + log.Error().Err(err).Msg("error retrieving organized carpool journey data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.OrganizedCarpoolJourney(w, r, result.Journey, result.Driver, result.Passenger, result.Beneficiaries, result.PassengerWalletBalance, result.PricingResult) + } +} \ No newline at end of file diff --git a/servers/web/application/sms.go b/servers/web/application/sms.go new file mode 100644 index 0000000..a653683 --- /dev/null +++ b/servers/web/application/sms.go @@ -0,0 +1,36 @@ +package application + +import ( + "net/http" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) SendSMSHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + w.WriteHeader(http.StatusMethodNotAllowed) + return + } + + referer := r.Referer() + + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("Bad request") + w.WriteHeader(http.StatusBadRequest) + return + } + + message := r.PostFormValue("message") + beneficiaryID := r.PostFormValue("beneficiaryid") + + err := h.applicationHandler.SendSMS(r.Context(), beneficiaryID, message) + if err != nil { + log.Error().Err(err).Msg("error sending SMS") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, referer, http.StatusFound) + } +} \ No newline at end of file diff --git a/servers/web/application/solidarity_transport.go b/servers/web/application/solidarity_transport.go new file mode 100644 index 0000000..e2f1baa --- /dev/null +++ b/servers/web/application/solidarity_transport.go @@ -0,0 +1,636 @@ +package application + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "sort" + "strings" + "time" + + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) SolidarityTransportOverviewHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Parse form to get both query params and form data + r.ParseForm() + + // Extract filter parameters using the same field names as the old handler + tab := r.FormValue("tab") + if tab == "" { + tab = "solidarityService" // Default to showing current bookings + } + + // Extract archived filter + archivedFilter := false + if archived := r.URL.Query().Get("archived"); archived == "true" { + archivedFilter = true + } + + // Apply filters conditionally based on tab (matching old handler logic) + var status, driverID, startDate, endDate, departureGeo, destinationGeo, passengerAddressGeo, driverAddressGeo string + var histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeo, histDestinationGeo, histPassengerAddressGeo string + + // Driver address geography filter (applies when on drivers tab) + if tab == "drivers" { + driverAddressGeo = r.FormValue("driver_address_geo") + } + + if tab == "solidarityService" { + status = r.FormValue("status") + driverID = r.FormValue("driver_id") + startDate = r.FormValue("date_start") + endDate = r.FormValue("date_end") + departureGeo = r.FormValue("departure_geo") + destinationGeo = r.FormValue("destination_geo") + passengerAddressGeo = r.FormValue("passenger_address_geo") + } + + // History filters (apply when on solidarityHistory tab) + if tab == "solidarityHistory" { + histStatus = r.FormValue("status") // Note: history uses same field names as current + histDriverID = r.FormValue("driver_id") + histStartDate = r.FormValue("date_start") + histEndDate = r.FormValue("date_end") + histDepartureGeo = r.FormValue("departure_geo") + histDestinationGeo = r.FormValue("destination_geo") + histPassengerAddressGeo = r.FormValue("passenger_address_geo") + } + + // Set default history dates if not provided + if histStartDate == "" { + histStartDate = time.Now().Add(-30 * 24 * time.Hour).Format("2006-01-02") + } + if histEndDate == "" { + histEndDate = time.Now().Add(-24 * time.Hour).Format("2006-01-02") + } + + // Parse geography parameters (format: "layer:code") + departureGeoLayer, departureGeoCode := "", "" + if departureGeo != "" { + parts := strings.SplitN(departureGeo, ":", 2) + if len(parts) == 2 { + departureGeoLayer, departureGeoCode = parts[0], parts[1] + } + } + destinationGeoLayer, destinationGeoCode := "", "" + if destinationGeo != "" { + parts := strings.SplitN(destinationGeo, ":", 2) + if len(parts) == 2 { + destinationGeoLayer, destinationGeoCode = parts[0], parts[1] + } + } + passengerAddressGeoLayer, passengerAddressGeoCode := "", "" + if passengerAddressGeo != "" { + parts := strings.SplitN(passengerAddressGeo, ":", 2) + if len(parts) == 2 { + passengerAddressGeoLayer, passengerAddressGeoCode = parts[0], parts[1] + } + } + + histDepartureGeoLayer, histDepartureGeoCode := "", "" + if histDepartureGeo != "" { + parts := strings.SplitN(histDepartureGeo, ":", 2) + if len(parts) == 2 { + histDepartureGeoLayer, histDepartureGeoCode = parts[0], parts[1] + } + } + histDestinationGeoLayer, histDestinationGeoCode := "", "" + if histDestinationGeo != "" { + parts := strings.SplitN(histDestinationGeo, ":", 2) + if len(parts) == 2 { + histDestinationGeoLayer, histDestinationGeoCode = parts[0], parts[1] + } + } + histPassengerAddressGeoLayer, histPassengerAddressGeoCode := "", "" + if histPassengerAddressGeo != "" { + parts := strings.SplitN(histPassengerAddressGeo, ":", 2) + if len(parts) == 2 { + histPassengerAddressGeoLayer, histPassengerAddressGeoCode = parts[0], parts[1] + } + } + + // Parse driver address geography parameter + driverAddressGeoLayer, driverAddressGeoCode := "", "" + if driverAddressGeo != "" { + parts := strings.SplitN(driverAddressGeo, ":", 2) + if len(parts) == 2 { + driverAddressGeoLayer, driverAddressGeoCode = parts[0], parts[1] + } + } + + result, err := h.applicationHandler.GetSolidarityTransportOverview(r.Context(), status, driverID, startDate, endDate, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode, histStatus, histDriverID, histStartDate, histEndDate, histDepartureGeoLayer, histDepartureGeoCode, histDestinationGeoLayer, histDestinationGeoCode, histPassengerAddressGeoLayer, histPassengerAddressGeoCode, archivedFilter, driverAddressGeoLayer, driverAddressGeoCode) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport overview") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Build filters map for template (matching old handler format) + filters := map[string]any{ + "tab": tab, + "date_start": startDate, + "date_end": endDate, + "status": status, + "driver_id": driverID, + "departure_geo": departureGeo, + "destination_geo": destinationGeo, + "passenger_address_geo": passengerAddressGeo, + "driver_address_geo": driverAddressGeo, + } + + histFilters := map[string]any{ + "tab": tab, + "date_start": histStartDate, + "date_end": histEndDate, + "status": histStatus, + "driver_id": histDriverID, + "departure_geo": histDepartureGeo, + "destination_geo": histDestinationGeo, + "passenger_address_geo": histPassengerAddressGeo, + } + + // Enrich geography filters with names from geography service + var enrichedGeoFilters []map[string]string + if h.cfg.GetBool("geography.filters.enabled") { + geoFilters := h.cfg.Get("geography.filters.geographies") + if geoList, ok := geoFilters.([]any); ok { + for _, geoItem := range geoList { + if geoMap, ok := geoItem.(map[string]any); ok { + layer := "" + code := "" + if l, ok := geoMap["layer"].(string); ok { + layer = l + } + if c, ok := geoMap["code"].(string); ok { + code = c + } + + enrichedGeo := map[string]string{ + "layer": layer, + "code": code, + "name": code, // Default to code if name fetch fails + } + + // Fetch name from geography service + if layer != "" && code != "" { + if geoFeature, err := h.services.Geography.Find(layer, code); err == nil { + if name := geoFeature.Properties.MustString("nom"); name != "" { + enrichedGeo["name"] = name + } + } + } + + enrichedGeoFilters = append(enrichedGeoFilters, enrichedGeo) + } + } + } + + // Sort by name + sort.Slice(enrichedGeoFilters, func(i, j int) bool { + return enrichedGeoFilters[i]["name"] < enrichedGeoFilters[j]["name"] + }) + } + + h.renderer.SolidarityTransportOverview(w, r, result.Accounts, result.AccountsMap, result.BeneficiariesMap, result.Bookings, result.BookingsHistory, filters, histFilters, tab, enrichedGeoFilters, archivedFilter) + } +} + +func (h *Handler) SolidarityTransportCreateDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + // Parse form data + firstName := r.PostFormValue("first_name") + lastName := r.PostFormValue("last_name") + email := r.PostFormValue("email") + phoneNumber := r.PostFormValue("phone_number") + gender := r.PostFormValue("gender") + + var birthdate *time.Time + if r.PostFormValue("birthdate") != "" { + if d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")); err == nil { + birthdate = &d + } + } + + // Parse JSON address field + var address any + if r.PostFormValue("address") != "" { + if err := json.Unmarshal([]byte(r.PostFormValue("address")), &address); err != nil { + log.Error().Err(err).Msg("failed parsing address JSON") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse JSON other_properties field + var otherProperties any + if r.PostFormValue("other_properties") != "" { + if err := json.Unmarshal([]byte(r.PostFormValue("other_properties")), &otherProperties); err != nil { + log.Error().Err(err).Msg("failed parsing other_properties JSON") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + driverID, err := h.applicationHandler.CreateSolidarityTransportDriver( + r.Context(), + firstName, + lastName, + email, + birthdate, + phoneNumber, + address, + gender, + otherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error creating solidarity transport driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + return + } + + h.renderer.SolidarityTransportCreateDriver(w, r) + } +} + +func (h *Handler) SolidarityTransportUpdateDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + if r.Method == "POST" { + // Parse form data + firstName := r.PostFormValue("first_name") + lastName := r.PostFormValue("last_name") + email := r.PostFormValue("email") + phoneNumber := r.PostFormValue("phone_number") + gender := r.PostFormValue("gender") + + var birthdate *time.Time + if r.PostFormValue("birthdate") != "" { + if d, err := time.Parse("2006-01-02", r.PostFormValue("birthdate")); err == nil { + birthdate = &d + } + } + + // Parse JSON address field + var address any + if r.PostFormValue("address") != "" { + if err := json.Unmarshal([]byte(r.PostFormValue("address")), &address); err != nil { + log.Error().Err(err).Msg("failed parsing address JSON") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse JSON other_properties field + var otherProperties any + if r.PostFormValue("other_properties") != "" { + if err := json.Unmarshal([]byte(r.PostFormValue("other_properties")), &otherProperties); err != nil { + log.Error().Err(err).Msg("failed parsing other_properties JSON") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + updatedDriverID, err := h.applicationHandler.UpdateSolidarityTransportDriver( + r.Context(), + driverID, + firstName, + lastName, + email, + birthdate, + phoneNumber, + address, + gender, + otherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error updating solidarity transport driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", updatedDriverID), http.StatusFound) + return + } + + result, err := h.applicationHandler.GetSolidarityTransportDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport driver for update") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.SolidarityTransportUpdateDriver(w, r, result.Driver) + } +} + +func (h *Handler) SolidarityTransportDriverDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + // Extract tab parameter + tab := r.URL.Query().Get("tab") + if tab == "" { + tab = "documents" // Default tab + } + + result, err := h.applicationHandler.GetSolidarityTransportDriverData(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport driver data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.SolidarityTransportDriverDisplay(w, r, result.Driver, result.Availabilities, result.Documents, result.Bookings, result.BeneficiariesMap, result.Stats, result.WalletBalance, tab) + } +} + +func (h *Handler) SolidarityTransportAddAvailabilityHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + log.Error().Msg("Wrong method") + http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed) + return + } + + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing availabilities form") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + vars := mux.Vars(r) + driverID := vars["driverid"] + + // Parse form data + starttime := r.PostFormValue("starttime") + endtime := r.PostFormValue("endtime") + + // Parse JSON address field + var address any + if r.PostFormValue("address") != "" { + if err := json.Unmarshal([]byte(r.PostFormValue("address")), &address); err != nil { + log.Error().Err(err).Msg("failed parsing address JSON") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + } + + // Parse days + days := map[string]bool{ + "monday": r.PostFormValue("days.monday") == "on", + "tuesday": r.PostFormValue("days.tuesday") == "on", + "wednesday": r.PostFormValue("days.wednesday") == "on", + "thursday": r.PostFormValue("days.thursday") == "on", + "friday": r.PostFormValue("days.friday") == "on", + "saturday": r.PostFormValue("days.saturday") == "on", + "sunday": r.PostFormValue("days.sunday") == "on", + } + + err := h.applicationHandler.AddSolidarityTransportAvailability(r.Context(), driverID, starttime, endtime, address, days) + if err != nil { + log.Error().Err(err).Msg("error adding solidarity transport availability") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportArchiveDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + err := h.applicationHandler.ArchiveSolidarityTransportDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error archiving solidarity transport driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportUnarchiveDriverHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + err := h.applicationHandler.UnarchiveSolidarityTransportDriver(r.Context(), driverID) + if err != nil { + log.Error().Err(err).Msg("error unarchiving solidarity transport driver") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportDriverDocumentsHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + + if err := r.ParseMultipartForm(100 * 1024 * 1024); err != nil { // 100 MB limit + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + documentType := r.FormValue("type") + documentName := r.FormValue("name") + + file, header, err := r.FormFile("file-upload") + if err != nil { + log.Error().Err(err).Msg("error retrieving file") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + defer file.Close() + + if err := h.applicationHandler.AddSolidarityTransportDriverDocument(r.Context(), driverID, file, header.Filename, header.Size, documentType, documentName); err != nil { + log.Error().Err(err).Msg("error adding solidarity transport driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportDocumentDownloadHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + document := vars["document"] + + file, info, err := h.applicationHandler.GetSolidarityTransportDriverDocument(r.Context(), driverID, document) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", info.ContentType) + if _, err = io.Copy(w, file); err != nil { + log.Error().Err(err).Msg("error copying file content") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } +} + +func (h *Handler) SolidarityTransportDeleteAvailabilityHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + availabilityID := vars["availabilityid"] + + err := h.applicationHandler.DeleteSolidarityTransportAvailability(r.Context(), driverID, availabilityID) + if err != nil { + log.Error().Err(err).Msg("error deleting solidarity transport availability") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportDriverJourneyHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + journeyID := vars["journeyid"] + passengerID := r.URL.Query().Get("passengerid") + + if r.Method == "POST" { + // Parse form data + motivation := r.PostFormValue("motivation") + message := r.PostFormValue("message") + doNotSend := r.PostFormValue("do_not_send") == "on" + returnWaitingTimeMinutes := 0 + if r.PostFormValue("return_waiting_time") != "" { + fmt.Sscanf(r.PostFormValue("return_waiting_time"), "%d", &returnWaitingTimeMinutes) + } + + bookingID, err := h.applicationHandler.CreateSolidarityTransportJourneyBooking(r.Context(), driverID, journeyID, passengerID, motivation, message, doNotSend, returnWaitingTimeMinutes) + if err != nil { + log.Error().Err(err).Msg("error creating solidarity transport journey booking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + log.Info().Str("booking_id", bookingID).Msg("Solidarity transport booking created successfully") + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/"), http.StatusFound) + return + } + + // Get current user's group + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("group not found in request context") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + group := g.(groupstorage.Group) + + result, err := h.applicationHandler.GetSolidarityTransportJourneyData(r.Context(), driverID, journeyID, passengerID, group) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport journey data") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.SolidarityTransportDriverJourney(w, r, result.Journey, result.Driver, result.Passenger, result.Beneficiaries, result.PassengerWalletBalance, result.PricingResult) + } +} + +func (h *Handler) SolidarityTransportDriverJourneyToggleNoreturnHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + journeyID := vars["journeyid"] + + err := h.applicationHandler.ToggleSolidarityTransportJourneyNoreturn(r.Context(), driverID, journeyID) + if err != nil { + log.Error().Err(err).Msg("error toggling solidarity transport journey noreturn") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s/journeys/%s", driverID, journeyID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportBookingDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + result, err := h.applicationHandler.GetSolidarityTransportBookingData(r.Context(), bookingID) + if err != nil { + log.Error().Err(err).Msg("error retrieving solidarity transport booking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.SolidarityTransportBookingDisplay(w, r, result.Booking, result.Driver, result.Passenger, result.PassengerWalletBalance) + } +} + +func (h *Handler) SolidarityTransportDocumentDeleteHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + driverID := vars["driverid"] + document := vars["document"] + + if err := h.applicationHandler.DeleteSolidarityTransportDriverDocument(r.Context(), driverID, document); err != nil { + log.Error().Err(err).Msg("error deleting solidarity transport driver document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/drivers/%s", driverID), http.StatusFound) + } +} + +func (h *Handler) SolidarityTransportBookingStatusHTTPHandler(action string) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + // Extract reason from form data for cancellations + reason := "" + if action == "cancel" && r.Method == "POST" { + r.ParseForm() + reason = r.PostFormValue("reason") + } + + err := h.applicationHandler.UpdateSolidarityTransportBookingStatus(r.Context(), bookingID, action, reason, "", false) + if err != nil { + log.Error().Err(err).Msg("error updating solidarity transport booking status") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/solidarity-transport/bookings/%s", bookingID), http.StatusSeeOther) + } +} \ No newline at end of file diff --git a/servers/web/application/support.go b/servers/web/application/support.go new file mode 100644 index 0000000..c278abe --- /dev/null +++ b/servers/web/application/support.go @@ -0,0 +1,40 @@ +package application + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "github.com/rs/zerolog/log" +) + +func (h *Handler) SupportSendHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + c := r.Context().Value(identification.ClaimsKey) + if c == nil { + log.Error().Msg("no current user claims") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + currentUserClaims := c.(map[string]any) + + if r.Method == "POST" { + // Parse form data + comment := r.PostFormValue("comment") + userEmail := currentUserClaims["email"].(string) + + err := h.applicationHandler.SendSupportMessage(r.Context(), comment, userEmail) + if err != nil { + log.Error().Err(err).Msg("error sending support message") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + // GET request - show form + comment := r.FormValue("comment") + h.renderer.SupportSend(w, r, comment, currentUserClaims) + } +} \ No newline at end of file diff --git a/servers/web/application/vehicles.go b/servers/web/application/vehicles.go new file mode 100644 index 0000000..86b1063 --- /dev/null +++ b/servers/web/application/vehicles.go @@ -0,0 +1,161 @@ +package application + +import ( + "fmt" + "io" + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/coreos/go-oidc/v3/oidc" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) VehiclesSearchHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + r.ParseForm() + + // Extract parameters + beneficiaryID := r.FormValue("beneficiaryid") + startDate := r.FormValue("startdate") + endDate := r.FormValue("enddate") + vehicleType := r.FormValue("type") + automatic := r.FormValue("automatic") == "on" + + // Call business logic + result, err := h.applicationHandler.SearchVehicles(r.Context(), beneficiaryID, startDate, endDate, vehicleType, automatic) + if err != nil { + log.Error().Err(err).Msg("error searching vehicles") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Render response + h.renderer.VehiclesSearch(w, r, result.Beneficiaries, result.Searched, result.Vehicles, result.Beneficiary, + result.StartDate, result.EndDate, result.MandatoryDocuments, result.FileTypesMap, + result.BeneficiaryDocuments, result.VehicleType, result.Automatic, result.VehicleTypes, result.Groups) + } +} + +func (h *Handler) BookVehicleHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Extract URL parameters + vars := mux.Vars(r) + vehicleID := vars["vehicleid"] + beneficiaryID := vars["beneficiaryid"] + + // Extract user context + currentUserToken := r.Context().Value(identification.IdtokenKey).(*oidc.IDToken) + currentUserClaims := r.Context().Value(identification.ClaimsKey).(map[string]any) + currentGroup := r.Context().Value(identification.GroupKey) + + // Parse multipart form + if err := r.ParseMultipartForm(100 * 1024 * 1024); err != nil { + log.Error().Err(err).Msg("error parsing multipart form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Extract form data + startDate := r.FormValue("startdate") + endDate := r.FormValue("enddate") + + // Extract documents + documents := make(map[string]io.Reader) + documentHeaders := make(map[string]string) + existingDocs := make(map[string]string) + + // Get mandatory document types from config + mandatoryDocTypes := h.cfg.GetStringSlice("modules.fleets.booking_documents.mandatory") + + for _, docType := range mandatoryDocTypes { + existingFile := r.FormValue("type-" + docType) + if existingFile != "" { + existingDocs[docType] = existingFile + } else { + file, header, err := r.FormFile("doc-" + docType) + if err != nil { + log.Error().Err(err).Msg("missing required document: " + docType) + http.Error(w, "Document manquant : "+docType, http.StatusBadRequest) + return + } + documents[docType] = file + documentHeaders[docType] = header.Filename + } + } + + // Call business logic + result, err := h.applicationHandler.BookVehicle(r.Context(), vehicleID, beneficiaryID, startDate, endDate, + documents, documentHeaders, existingDocs, currentUserToken.Subject, currentUserClaims, currentGroup) + if err != nil { + log.Error().Err(err).Msg("error booking vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Redirect to booking details + http.Redirect(w, r, fmt.Sprintf("/app/vehicles/bookings/%s", result.BookingID), http.StatusFound) + } +} + +func (h *Handler) VehicleBookingDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + result, err := h.applicationHandler.GetVehicleBookingDetails(r.Context(), bookingID) + if err != nil { + log.Error().Err(err).Msg("error getting booking details") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehicleBookingDisplay(w, r, result.Booking, result.Vehicle, result.Beneficiary, + result.Group, result.Documents, result.FileTypesMap) + } +} + +func (h *Handler) VehiclesBookingsListHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Get group from context + g := r.Context().Value(identification.GroupKey) + if g == nil { + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + group := g.(storage.Group) + + result, err := h.applicationHandler.GetVehicleBookingsList(r.Context(), group.ID) + if err != nil { + log.Error().Err(err).Msg("error getting bookings list") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehicleBookingsList(w, r, result.Bookings, result.VehiclesMap, result.GroupsMap) + } +} + +func (h *Handler) BookingDocumentDownloadHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + document := vars["document"] + + fileReader, contentType, err := h.applicationHandler.GetBookingDocument(r.Context(), bookingID, document) + if err != nil { + log.Error().Err(err).Msg("error getting booking document") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", contentType) + if _, err = io.Copy(w, fileReader); err != nil { + log.Error().Err(err).Msg("error writing document to response") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } +} \ No newline at end of file diff --git a/servers/web/application/vehicles_management.go b/servers/web/application/vehicles_management.go new file mode 100644 index 0000000..b48d3d8 --- /dev/null +++ b/servers/web/application/vehicles_management.go @@ -0,0 +1,408 @@ +package application + +import ( + "encoding/json" + "fmt" + "net/http" + "time" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/coreos/go-oidc/v3/oidc" + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) VehiclesManagementOverviewHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Extract filter parameters from request + groupID := "" + if g := r.Context().Value(identification.GroupKey); g != nil { + group := g.(storage.Group) + groupID = group.ID + } + + result, err := h.applicationHandler.GetVehiclesManagementOverview(r.Context(), groupID) + if err != nil { + log.Error().Err(err).Msg("error retrieving vehicles management overview") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehiclesManagementOverview(w, r, result.Vehicles, result.VehiclesMap, result.DriversMap, result.Bookings) + } +} + +func (h *Handler) VehiclesManagementBookingsListHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Extract filter parameters from request + groupID := "" + if g := r.Context().Value(identification.GroupKey); g != nil { + group := g.(storage.Group) + groupID = group.ID + } + + // Extract filter parameters from query + status := r.URL.Query().Get("status") + dateStart := r.URL.Query().Get("date_start") + dateEnd := r.URL.Query().Get("date_end") + + // Default to last month if no dates specified + if dateStart == "" { + dateStart = time.Now().AddDate(0, -1, 0).Format("2006-01-02") + } + if dateEnd == "" { + dateEnd = time.Now().Format("2006-01-02") + } + + result, err := h.applicationHandler.GetVehiclesManagementBookingsList(r.Context(), groupID, status, dateStart, dateEnd) + if err != nil { + log.Error().Err(err).Msg("error retrieving vehicles management bookings list") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + // Prepare filters map for template + filters := map[string]string{ + "status": status, + "date_start": dateStart, + "date_end": dateEnd, + } + + h.renderer.VehiclesManagementBookingsList(w, r, result.VehiclesMap, result.DriversMap, result.Bookings, result.CacheID, filters) + } +} + +func (h *Handler) VehiclesFleetAddHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + // Get group from context + g := r.Context().Value(identification.GroupKey) + if g == nil { + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Parse form data + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Parse address JSON + var address map[string]any + if addressStr := r.FormValue("address"); addressStr != "" { + if err := json.Unmarshal([]byte(addressStr), &address); err != nil { + log.Error().Err(err).Msg("error parsing address JSON") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } + + // Parse other_properties from form fields + otherProperties := make(map[string]any) + vehicleOptionalFields := h.cfg.Get("modules.fleets.vehicle_optional_fields") + log.Debug().Msgf("CREATE: vehicleOptionalFields type: %T, value: %+v", vehicleOptionalFields, vehicleOptionalFields) + if fields, ok := vehicleOptionalFields.([]map[string]any); ok { + log.Debug().Msgf("CREATE: Successfully cast to []map[string]any, length: %d", len(fields)) + for _, field := range fields { + log.Debug().Any("field", field).Msg("vehicle other properties field handling") + if fieldName, ok := field["name"].(string); ok { + value := r.FormValue(fieldName) + log.Debug().Msgf("CREATE: Field %s: value='%s'", fieldName, value) + if value != "" { + otherProperties[fieldName] = value + } + } + } + } else { + log.Debug().Msg("CREATE: Failed to cast vehicleOptionalFields to []map[string]any") + } + log.Debug().Msgf("CREATE: Final otherProperties: %+v", otherProperties) + + vehicleID, err := h.applicationHandler.CreateVehicle(r.Context(), + r.FormValue("name"), + r.FormValue("type"), + r.FormValue("informations"), + r.FormValue("licence_plate"), + r.FormValue("kilometers"), + r.FormValue("automatic") == "on", + address, + otherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error creating vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleID), http.StatusFound) + return + } + + // GET request - show form + vehicleTypes, err := h.applicationHandler.GetVehicleTypes(r.Context()) + if err != nil { + log.Error().Err(err).Msg("error getting vehicle types") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehiclesFleetAdd(w, r, vehicleTypes) + } +} + +func (h *Handler) VehiclesFleetDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + vehicleID := vars["vehicleid"] + + result, err := h.applicationHandler.GetVehicleDisplay(r.Context(), vehicleID) + if err != nil { + log.Error().Err(err).Msg("error retrieving vehicle display") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehiclesFleetDisplay(w, r, result.Vehicle, result.Beneficiaries) + } +} + +func (h *Handler) VehicleManagementBookingDisplayHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + if r.Method == "POST" { + // Parse form data + r.ParseForm() + + err := h.applicationHandler.UpdateBooking(r.Context(), bookingID, + r.FormValue("startdate"), + r.FormValue("enddate"), + r.FormValue("unavailablefrom"), + r.FormValue("unavailableto"), + ) + if err != nil { + log.Error().Err(err).Msg("error updating booking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } + + result, err := h.applicationHandler.GetBookingDisplay(r.Context(), bookingID) + if err != nil { + log.Error().Err(err).Msg("error retrieving booking display") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehicleManagementBookingDisplay(w, r, result.Booking, result.Vehicle, result.Beneficiary, result.Group, result.Documents, result.FileTypesMap, result.Alternatives) + } +} + +func (h *Handler) VehicleManagementBookingChangeVehicleHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + r.ParseForm() + newVehicle := r.FormValue("vehicle") + + err := h.applicationHandler.ChangeBookingVehicle(r.Context(), bookingID, newVehicle) + if err != nil { + log.Error().Err(err).Msg("error changing booking vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/bookings/%s", bookingID), http.StatusFound) + } +} + +func (h *Handler) VehiclesFleetMakeUnavailableHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + // Get context values + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("no current group") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + u := r.Context().Value(identification.IdtokenKey) + if u == nil { + log.Error().Msg("no current user") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + currentUserToken := u.(*oidc.IDToken) + + c := r.Context().Value(identification.ClaimsKey) + if c == nil { + log.Error().Msg("no current user claims") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + currentUserClaims := c.(map[string]any) + + vars := mux.Vars(r) + vehicleID := vars["vehicleid"] + + r.ParseForm() + + err := h.applicationHandler.MakeVehicleUnavailable(r.Context(), vehicleID, + r.FormValue("unavailablefrom"), + r.FormValue("unavailableto"), + r.FormValue("comment"), + currentUserToken.Subject, + currentUserClaims, + ) + if err != nil { + log.Error().Err(err).Msg("error making vehicle unavailable") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleID), http.StatusFound) + } +} + +func (h *Handler) DeleteBookingHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + // Get form data + motif := r.FormValue("motif") + + // Get current user information + currentUserToken := r.Context().Value(identification.IdtokenKey).(*oidc.IDToken) + currentUserClaims := r.Context().Value(identification.ClaimsKey).(map[string]any) + currentGroup := r.Context().Value(identification.GroupKey) + + err := h.applicationHandler.UnbookVehicle(r.Context(), bookingID, motif, currentUserToken.Subject, currentUserClaims, currentGroup) + if err != nil { + log.Error().Err(err).Msg("error unbooking vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/vehicles-management/bookings/", http.StatusSeeOther) + } +} + +func (h *Handler) UnbookingVehicleHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingID := vars["bookingid"] + + if r.Method == "POST" { + // Extract user and group info from context + currentUserToken := r.Context().Value(identification.IdtokenKey).(*oidc.IDToken) + currentUserClaims := r.Context().Value(identification.ClaimsKey).(map[string]any) + currentGroup := r.Context().Value(identification.GroupKey) + + motif := r.FormValue("motif") + + err := h.applicationHandler.UnbookVehicle(r.Context(), bookingID, motif, + currentUserToken.Subject, currentUserClaims, currentGroup) + if err != nil { + log.Error().Err(err).Msg("error unbooking vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/vehicles-management/", http.StatusFound) + return + } + + // GET request - show form + booking, err := h.applicationHandler.GetBookingForUnbooking(r.Context(), bookingID) + if err != nil { + log.Error().Err(err).Msg("error retrieving booking for unbooking") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.UnbookingVehicle(w, r, booking) + } +} + +func (h *Handler) VehiclesFleetUpdateHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + vehicleID := vars["vehicleid"] + + if r.Method == "POST" { + if err := r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + // Parse address JSON + var address map[string]any + if addressStr := r.FormValue("address"); addressStr != "" { + if err := json.Unmarshal([]byte(addressStr), &address); err != nil { + log.Error().Err(err).Msg("error parsing address JSON") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + } + + // Parse other_properties from form fields + otherProperties := make(map[string]any) + vehicleOptionalFields := h.cfg.Get("modules.fleets.vehicle_optional_fields") + log.Debug().Msgf("UPDATE: vehicleOptionalFields type: %T, value: %+v", vehicleOptionalFields, vehicleOptionalFields) + if fields, ok := vehicleOptionalFields.([]any); ok { + log.Debug().Msgf("UPDATE: Successfully cast to []map[string]any, length: %d", len(fields)) + for _, f := range fields { + if field, ok := f.(map[string]any); ok { + log.Debug().Any("field", field).Msg("vehicle other properties field handling (update)") + if fieldName, ok := field["name"].(string); ok { + value := r.FormValue(fieldName) + log.Debug().Msgf("UPDATE: Field %s: value='%s'", fieldName, value) + if value != "" { + otherProperties[fieldName] = value + } + } + } + } + } else { + log.Debug().Msg("UPDATE: Failed to cast vehicleOptionalFields to []map[string]any") + } + log.Debug().Msgf("UPDATE: Final otherProperties: %+v", otherProperties) + + updatedVehicleID, err := h.applicationHandler.UpdateVehicle(r.Context(), vehicleID, + r.FormValue("name"), + r.FormValue("type"), + r.FormValue("informations"), + r.FormValue("licence_plate"), + r.FormValue("kilometers"), + r.FormValue("automatic") == "on", + address, + otherProperties, + ) + if err != nil { + log.Error().Err(err).Msg("error updating vehicle") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", updatedVehicleID), http.StatusFound) + return + } + + // GET request - show form + result, err := h.applicationHandler.GetVehicleForUpdate(r.Context(), vehicleID) + if err != nil { + log.Error().Err(err).Msg("error retrieving vehicle for update") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + h.renderer.VehiclesFleetUpdate(w, r, result.Vehicle, result.VehicleTypes) + } +} diff --git a/servers/web/application/wallets.go b/servers/web/application/wallets.go new file mode 100644 index 0000000..55ae5ed --- /dev/null +++ b/servers/web/application/wallets.go @@ -0,0 +1,58 @@ +package application + +import ( + "net/http" + "net/url" + "strconv" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) CreditWalletHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + userid := vars["userid"] + + if r.Method != "POST" { + http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed) + return + } + + r.ParseForm() + + amountStr := r.FormValue("amount") + paymentMethod := r.FormValue("payment_method") + description := r.FormValue("description") + + amount, err := strconv.ParseFloat(amountStr, 64) + if err != nil { + log.Error().Err(err).Msg("could not read amount") + http.Error(w, "Bad Request", http.StatusBadRequest) + return + } + + if paymentMethod == "" { + paymentMethod = "Paiement en espèce (MMS)" + } + + err = h.applicationHandler.CreditWallet(r.Context(), userid, amount, paymentMethod, description) + if err != nil { + log.Error().Err(err).Msg("could not credit wallet") + http.Error(w, "Internal Server Error", http.StatusInternalServerError) + return + } + + refererURL, err := url.Parse(r.Referer()) + if err != nil { + http.Redirect(w, r, r.Referer(), http.StatusFound) + return + } + + query := refererURL.Query() + query.Set("tab", "wallet") + refererURL.RawQuery = query.Encode() + + http.Redirect(w, r, refererURL.String(), http.StatusFound) + } +} \ No newline at end of file diff --git a/servers/web/application_routes.go b/servers/web/application_routes.go new file mode 100644 index 0000000..5053814 --- /dev/null +++ b/servers/web/application_routes.go @@ -0,0 +1,32 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupApplicationRoutes(r *mux.Router) { + application := r.PathPrefix("/app").Subrouter() + + // Setup all application route groups + ws.setupDashboardRoutes(application) + setupMiscRoutes(application, ws.applicationHandler) + ws.setupDirectoryRoutes(application) + ws.setupGroupRoutes(application) + ws.setupBeneficiariesRoutes(application) + ws.setupMembersRoutes(application) + ws.setupWalletsRoutes(application) + ws.setupJourneysRoutes(application) + ws.setupSolidarityTransportRoutes(application) + ws.setupOrganizedCarpoolRoutes(application) + ws.setupVehiclesRoutes(application) + ws.setupVehiclesManagementRoutes(application) + ws.setupSMSRoutes(application) + ws.setupSupportRoutes(application) + ws.setupAgendaRoutes(application) + ws.setupGroupModuleRoutes(application) + ws.setupAdministrationRoutes(application) + + // Apply middleware + application.Use(ws.idp.Middleware) + application.Use(ws.idp.GroupsMiddleware) +} \ No newline at end of file diff --git a/handlers/auth/disconnect.go b/servers/web/auth/disconnect.go old mode 100755 new mode 100644 similarity index 73% rename from handlers/auth/disconnect.go rename to servers/web/auth/disconnect.go index be3cc25..a224d4a --- a/handlers/auth/disconnect.go +++ b/servers/web/auth/disconnect.go @@ -2,7 +2,7 @@ package auth import "net/http" -func (h *AuthHandler) Disconnect(w http.ResponseWriter, r *http.Request) { +func (h *Handler) Disconnect(w http.ResponseWriter, r *http.Request) { session, err := h.idp.SessionsStore.Get(r, "parcoursmob_session") if err == nil { session.Options.MaxAge = -1 @@ -10,4 +10,4 @@ func (h *AuthHandler) Disconnect(w http.ResponseWriter, r *http.Request) { } http.Redirect(w, r, "/", http.StatusOK) -} +} \ No newline at end of file diff --git a/servers/web/auth/groups.go b/servers/web/auth/groups.go new file mode 100644 index 0000000..a240a10 --- /dev/null +++ b/servers/web/auth/groups.go @@ -0,0 +1,58 @@ +package auth + +import ( + "context" + "net/http" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) Groups(w http.ResponseWriter, r *http.Request) { + session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") + + if r.Method == "POST" { + r.ParseForm() + + groupid := r.FormValue("group") + + session.Values["organization"] = groupid + session.Save(r, w) + + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + tokenstring, ok := session.Values["idtoken"] + if !ok { + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + idtoken, err := h.idp.TokenVerifier.Verify(context.Background(), tokenstring.(string)) + if err != nil { + delete(session.Values, "idtoken") + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + result, err := h.applicationHandler.GetUserGroups(idtoken) + if err != nil { + log.Error().Err(err).Msg("Failed to get user groups") + w.WriteHeader(http.StatusInternalServerError) + return + } + + var groupsresponse = []any{} + for _, group := range result.Groups { + groupsresponse = append(groupsresponse, group) + } + + h.renderer.AuthGroups(w, r, groupsresponse) +} + +func (h *Handler) GroupSwitch(w http.ResponseWriter, r *http.Request) { + session, _ := h.idp.SessionsStore.Get(r, "parcoursmob_session") + delete(session.Values, "organization") + session.Save(r, w) + http.Redirect(w, r, "/app/", http.StatusFound) +} \ No newline at end of file diff --git a/servers/web/auth/handler.go b/servers/web/auth/handler.go new file mode 100644 index 0000000..1c61914 --- /dev/null +++ b/servers/web/auth/handler.go @@ -0,0 +1,30 @@ +package auth + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-apps/parcoursmob/renderer" + "github.com/spf13/viper" +) + +type Handler struct { + config *viper.Viper + applicationHandler *application.ApplicationHandler + idp *identification.IdentificationProvider + renderer *renderer.Renderer +} + +func NewHandler(cfg *viper.Viper, applicationHandler *application.ApplicationHandler, idp *identification.IdentificationProvider, renderer *renderer.Renderer) *Handler { + return &Handler{ + config: cfg, + applicationHandler: applicationHandler, + idp: idp, + renderer: renderer, + } +} + +func (h *Handler) NotFound(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) +} \ No newline at end of file diff --git a/servers/web/auth/lost_password.go b/servers/web/auth/lost_password.go new file mode 100644 index 0000000..de5d9a7 --- /dev/null +++ b/servers/web/auth/lost_password.go @@ -0,0 +1,52 @@ +package auth + +import ( + "net/http" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) LostPasswordInit(w http.ResponseWriter, r *http.Request) { + if r.Method == "POST" { + r.ParseForm() + email := r.FormValue("email") + if email != "" { + _, err := h.applicationHandler.InitiateLostPassword(email) + if err != nil { + log.Error().Err(err).Msg("Failed to initiate password reset") + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + http.Redirect(w, r, "/app/", http.StatusFound) + } + } + h.renderer.LostPasswordInit(w, r) +} + +func (h *Handler) LostPasswordRecover(w http.ResponseWriter, r *http.Request) { + r.ParseForm() + + key := r.FormValue("key") + recover, err := h.applicationHandler.GetPasswordRecoveryData(key) + if err != nil { + log.Error().Err(err).Msg("Failed to get password recovery data") + h.renderer.LostPasswordRecoverKO(w, r, key) + return + } + + if r.Method == "POST" { + newpassword := r.FormValue("password") + _, err := h.applicationHandler.RecoverLostPassword(key, newpassword) + if err != nil { + log.Error().Err(err).Msg("Failed to recover password") + w.WriteHeader(http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + h.renderer.LostPasswordRecover(w, r, recover) +} \ No newline at end of file diff --git a/servers/web/auth/onboarding.go b/servers/web/auth/onboarding.go new file mode 100644 index 0000000..47f0b7a --- /dev/null +++ b/servers/web/auth/onboarding.go @@ -0,0 +1,37 @@ +package auth + +import ( + "net/http" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) Onboarding(w http.ResponseWriter, r *http.Request) { + r.ParseForm() + + key := r.FormValue("key") + onboarding, err := h.applicationHandler.GetOnboardingData(key) + if err != nil { + log.Error().Err(err).Msg("Failed to get onboarding data") + h.renderer.AuthOnboardingKO(w, r, key) + return + } + + if r.Method == "POST" { + firstName := r.FormValue("first_name") + lastName := r.FormValue("last_name") + password := r.FormValue("password") + + _, err := h.applicationHandler.CompleteOnboarding(key, password, firstName, lastName) + if err != nil { + log.Error().Err(err).Msg("Failed to complete onboarding") + w.WriteHeader(http.StatusInternalServerError) + return + } + + http.Redirect(w, r, "/app/", http.StatusFound) + return + } + + h.renderer.AuthOnboarding(w, r, key, onboarding) +} \ No newline at end of file diff --git a/servers/web/auth_routes.go b/servers/web/auth_routes.go new file mode 100644 index 0000000..ad8d308 --- /dev/null +++ b/servers/web/auth_routes.go @@ -0,0 +1,14 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupAuthRoutes(r *mux.Router) { + r.HandleFunc("/auth/onboarding", ws.authHandler.Onboarding) + r.HandleFunc("/auth/disconnect", ws.authHandler.Disconnect) + r.HandleFunc("/auth/lost-password", ws.authHandler.LostPasswordInit) + r.HandleFunc("/auth/lost-password/recover", ws.authHandler.LostPasswordRecover) + r.HandleFunc("/auth/groups/", ws.authHandler.Groups) + r.HandleFunc("/auth/groups/switch", ws.authHandler.GroupSwitch) +} \ No newline at end of file diff --git a/servers/web/calendars_routes.go b/servers/web/calendars_routes.go new file mode 100644 index 0000000..781ca6f --- /dev/null +++ b/servers/web/calendars_routes.go @@ -0,0 +1,11 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupCalendarsRoutes(r *mux.Router) { + calendars_router := r.PathPrefix("/api/calendars").Subrouter() + calendars_router.HandleFunc("/global.ics", ws.webAPIHandler.CalendarGlobal) + calendars_router.HandleFunc("/organizations/{groupid}.ics", ws.webAPIHandler.CalendarOrganizations) +} \ No newline at end of file diff --git a/servers/web/exports/agenda.go b/servers/web/exports/agenda.go new file mode 100644 index 0000000..ac83bf0 --- /dev/null +++ b/servers/web/exports/agenda.go @@ -0,0 +1,47 @@ +package exports + +import ( + "net/http" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" +) + +func (h *Handler) AllAgendaEvents(w http.ResponseWriter, r *http.Request) { + result, err := h.applicationHandler.ExportAllAgendaEvents() + if err != nil { + log.Error().Err(err).Msg("Failed to export all agenda events") + w.WriteHeader(http.StatusInternalServerError) + return + } + + defer func() { + if err := result.ExcelFile.Close(); err != nil { + log.Error().Err(err).Msg("Failed to close Excel file") + } + }() + + h.writeFileResponse(w, "Agenda_Events.xlsx") + result.ExcelFile.Write(w) +} + +func (h *Handler) SingleAgendaEvent(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + eventID := vars["eventid"] + + result, err := h.applicationHandler.ExportSingleAgendaEvent(eventID) + if err != nil { + log.Error().Err(err).Msg("Failed to export single agenda event") + w.WriteHeader(http.StatusInternalServerError) + return + } + + defer func() { + if err := result.ExcelFile.Close(); err != nil { + log.Error().Err(err).Msg("Failed to close Excel file") + } + }() + + h.writeFileResponse(w, "Event_"+eventID+".xlsx") + result.ExcelFile.Write(w) +} \ No newline at end of file diff --git a/servers/web/exports/fleets.go b/servers/web/exports/fleets.go new file mode 100644 index 0000000..9355740 --- /dev/null +++ b/servers/web/exports/fleets.go @@ -0,0 +1,66 @@ +package exports + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + groupsstorage "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/rs/zerolog/log" +) + +func (h *Handler) AllFleetBookings(w http.ResponseWriter, r *http.Request) { + // Extract filter parameters from query + status := r.URL.Query().Get("status") + dateStart := r.URL.Query().Get("date_start") + dateEnd := r.URL.Query().Get("date_end") + + // Get bookings using the admin stats function (all bookings across all groups) + result, err := h.applicationHandler.GetBookingsStats(status, dateStart, dateEnd) + if err != nil { + log.Error().Err(err).Msg("Failed to get all vehicle bookings for export") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Convert vehicles map to the format expected by VehicleBookings renderer + vehiclesMap := make(map[string]interface{}) + for k, v := range result.Vehicles { + vehiclesMap[k] = v + } + + // Convert beneficiaries map to the format expected by VehicleBookings renderer + driversMap := make(map[string]interface{}) + for k, v := range result.BeneficiariesMap { + driversMap[k] = v + } + + // Render to Excel + h.renderer.XLSX.VehicleBookingsAdmin(w, result.Bookings, vehiclesMap, driversMap, result.Groups) +} + +func (h *Handler) FleetBookingsInGroup(w http.ResponseWriter, r *http.Request) { + // Get current group from context (set by middleware) + g := r.Context().Value(identification.GroupKey) + if g == nil { + log.Error().Msg("No group found in context") + w.WriteHeader(http.StatusUnauthorized) + return + } + group := g.(groupsstorage.Group) + + // Extract filter parameters from query + status := r.URL.Query().Get("status") + dateStart := r.URL.Query().Get("date_start") + dateEnd := r.URL.Query().Get("date_end") + + result, err := h.applicationHandler.GetVehiclesManagementBookingsList(r.Context(), group.ID, status, dateStart, dateEnd) + if err != nil { + log.Error().Err(err).Msg("Failed to get vehicle bookings for export") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Render to Excel + h.renderer.XLSX.VehicleBookings(w, result.Bookings, result.VehiclesMap, result.DriversMap) +} + diff --git a/servers/web/exports/handler.go b/servers/web/exports/handler.go new file mode 100644 index 0000000..0febe56 --- /dev/null +++ b/servers/web/exports/handler.go @@ -0,0 +1,33 @@ +package exports + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + "git.coopgo.io/coopgo-apps/parcoursmob/renderer" + "github.com/spf13/viper" +) + +type Handler struct { + config *viper.Viper + applicationHandler *application.ApplicationHandler + idp *identification.IdentificationProvider + renderer *renderer.Renderer +} + +func NewHandler(cfg *viper.Viper, applicationHandler *application.ApplicationHandler, idp *identification.IdentificationProvider, renderer *renderer.Renderer) *Handler { + return &Handler{ + config: cfg, + applicationHandler: applicationHandler, + idp: idp, + renderer: renderer, + } +} + +func (h *Handler) writeFileResponse(w http.ResponseWriter, filename string) { + w.Header().Set("Content-Type", "application/octet-stream") + w.Header().Set("Content-Disposition", "attachment; filename="+filename) + w.Header().Set("Content-Transfer-Encoding", "binary") + w.Header().Set("Expires", "0") +} \ No newline at end of file diff --git a/servers/web/exports/organized-carpool.go b/servers/web/exports/organized-carpool.go new file mode 100644 index 0000000..5060c70 --- /dev/null +++ b/servers/web/exports/organized-carpool.go @@ -0,0 +1,99 @@ +package exports + +import ( + "net/http" + "strings" + "time" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) OrganizedCarpoolBookings(w http.ResponseWriter, r *http.Request) { + // Parse query parameters + var startDate, endDate *time.Time + + if startDateStr := r.URL.Query().Get("start_date"); startDateStr != "" { + if parsed, err := time.Parse("2006-01-02", startDateStr); err == nil { + startDate = &parsed + } + } + + if endDateStr := r.URL.Query().Get("end_date"); endDateStr != "" { + if parsed, err := time.Parse("2006-01-02", endDateStr); err == nil { + endDate = &parsed + } + } + + status := r.URL.Query().Get("status") + driverID := r.URL.Query().Get("driver_id") + + // Parse geography parameters + departureGeo := r.URL.Query().Get("departure_geo") + destinationGeo := r.URL.Query().Get("destination_geo") + passengerAddressGeo := r.URL.Query().Get("passenger_address_geo") + + departureGeoLayer, departureGeoCode := "", "" + if departureGeo != "" { + parts := strings.SplitN(departureGeo, ":", 2) + if len(parts) == 2 { + departureGeoLayer, departureGeoCode = parts[0], parts[1] + } + } + destinationGeoLayer, destinationGeoCode := "", "" + if destinationGeo != "" { + parts := strings.SplitN(destinationGeo, ":", 2) + if len(parts) == 2 { + destinationGeoLayer, destinationGeoCode = parts[0], parts[1] + } + } + passengerAddressGeoLayer, passengerAddressGeoCode := "", "" + if passengerAddressGeo != "" { + parts := strings.SplitN(passengerAddressGeo, ":", 2) + if len(parts) == 2 { + passengerAddressGeoLayer, passengerAddressGeoCode = parts[0], parts[1] + } + } + + // Get bookings data + result, err := h.applicationHandler.GetOrganizedCarpoolBookings(r.Context(), startDate, endDate, status, driverID, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Error().Err(err).Msg("Failed to get organized carpool bookings") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Render to Excel + h.renderer.XLSX.OrganizedCarpoolBookings(w, result) +} + +func (h *Handler) OrganizedCarpoolDrivers(w http.ResponseWriter, r *http.Request) { + // Parse query parameters - same as web page + archivedFilter := r.URL.Query().Get("archived") == "true" + driverAddressGeo := r.URL.Query().Get("driver_address_geo") + + // Parse driver address geography parameter + driverAddressGeoLayer, driverAddressGeoCode := "", "" + if driverAddressGeo != "" { + parts := strings.SplitN(driverAddressGeo, ":", 2) + if len(parts) == 2 { + driverAddressGeoLayer, driverAddressGeoCode = parts[0], parts[1] + } + } + + // Get drivers data through overview (same as web page) + result, err := h.applicationHandler.GetOrganizedCarpoolOverview( + r.Context(), + "", "", "", "", "", "", "", "", "", "", // booking filters (empty) + "", "", "", "", "", "", "", "", "", "", // history booking filters (empty) + archivedFilter, + driverAddressGeoLayer, driverAddressGeoCode, + ) + if err != nil { + log.Error().Err(err).Msg("Failed to get organized carpool drivers") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Render to Excel + h.renderer.XLSX.OrganizedCarpoolDrivers(w, result) +} diff --git a/servers/web/exports/solidarity-transport.go b/servers/web/exports/solidarity-transport.go new file mode 100644 index 0000000..e6fe672 --- /dev/null +++ b/servers/web/exports/solidarity-transport.go @@ -0,0 +1,99 @@ +package exports + +import ( + "net/http" + "strings" + "time" + + "github.com/rs/zerolog/log" +) + +func (h *Handler) SolidarityTransportBookings(w http.ResponseWriter, r *http.Request) { + // Parse query parameters + var startDate, endDate *time.Time + + if startDateStr := r.URL.Query().Get("start_date"); startDateStr != "" { + if parsed, err := time.Parse("2006-01-02", startDateStr); err == nil { + startDate = &parsed + } + } + + if endDateStr := r.URL.Query().Get("end_date"); endDateStr != "" { + if parsed, err := time.Parse("2006-01-02", endDateStr); err == nil { + endDate = &parsed + } + } + + status := r.URL.Query().Get("status") + driverID := r.URL.Query().Get("driver_id") + + // Parse geography parameters + departureGeo := r.URL.Query().Get("departure_geo") + destinationGeo := r.URL.Query().Get("destination_geo") + passengerAddressGeo := r.URL.Query().Get("passenger_address_geo") + + departureGeoLayer, departureGeoCode := "", "" + if departureGeo != "" { + parts := strings.SplitN(departureGeo, ":", 2) + if len(parts) == 2 { + departureGeoLayer, departureGeoCode = parts[0], parts[1] + } + } + destinationGeoLayer, destinationGeoCode := "", "" + if destinationGeo != "" { + parts := strings.SplitN(destinationGeo, ":", 2) + if len(parts) == 2 { + destinationGeoLayer, destinationGeoCode = parts[0], parts[1] + } + } + passengerAddressGeoLayer, passengerAddressGeoCode := "", "" + if passengerAddressGeo != "" { + parts := strings.SplitN(passengerAddressGeo, ":", 2) + if len(parts) == 2 { + passengerAddressGeoLayer, passengerAddressGeoCode = parts[0], parts[1] + } + } + + // Get bookings data + result, err := h.applicationHandler.GetSolidarityTransportBookings(r.Context(), startDate, endDate, status, driverID, departureGeoLayer, departureGeoCode, destinationGeoLayer, destinationGeoCode, passengerAddressGeoLayer, passengerAddressGeoCode) + if err != nil { + log.Error().Err(err).Msg("Failed to get solidarity transport bookings") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Render to Excel + h.renderer.XLSX.SolidarityTransportBookings(w, result) +} + +func (h *Handler) SolidarityTransportDrivers(w http.ResponseWriter, r *http.Request) { + // Parse query parameters - same as web page + archivedFilter := r.URL.Query().Get("archived") == "true" + driverAddressGeo := r.URL.Query().Get("driver_address_geo") + + // Parse driver address geography parameter + driverAddressGeoLayer, driverAddressGeoCode := "", "" + if driverAddressGeo != "" { + parts := strings.SplitN(driverAddressGeo, ":", 2) + if len(parts) == 2 { + driverAddressGeoLayer, driverAddressGeoCode = parts[0], parts[1] + } + } + + // Get drivers data through overview (same as web page) + result, err := h.applicationHandler.GetSolidarityTransportOverview( + r.Context(), + "", "", "", "", "", "", "", "", "", "", // booking filters (empty) + "", "", "", "", "", "", "", "", "", "", // history booking filters (empty) + archivedFilter, + driverAddressGeoLayer, driverAddressGeoCode, + ) + if err != nil { + log.Error().Err(err).Msg("Failed to get solidarity transport drivers") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Render to Excel + h.renderer.XLSX.SolidarityTransportDrivers(w, result) +} diff --git a/servers/web/exports_routes.go b/servers/web/exports_routes.go new file mode 100644 index 0000000..50c6005 --- /dev/null +++ b/servers/web/exports_routes.go @@ -0,0 +1,20 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupExportsRoutes(r *mux.Router) { + export := r.PathPrefix("/exports").Subrouter() + export.HandleFunc("/fleets/bookings/all_bookings.xlsx", ws.exportsHandler.AllFleetBookings) + export.HandleFunc("/fleets/bookings/group_bookings.xlsx", ws.exportsHandler.FleetBookingsInGroup) + export.HandleFunc("/agenda/subscriptions", ws.exportsHandler.AllAgendaEvents) + export.HandleFunc("/agenda/{eventid}", ws.exportsHandler.SingleAgendaEvent) + export.HandleFunc("/solidarity-transport/bookings.xlsx", ws.exportsHandler.SolidarityTransportBookings) + export.HandleFunc("/solidarity-transport/drivers.xlsx", ws.exportsHandler.SolidarityTransportDrivers) + export.HandleFunc("/organized-carpool/bookings.xlsx", ws.exportsHandler.OrganizedCarpoolBookings) + export.HandleFunc("/organized-carpool/drivers.xlsx", ws.exportsHandler.OrganizedCarpoolDrivers) + export.Use(ws.idp.Middleware) + export.Use(ws.idp.GroupsMiddleware) +} + diff --git a/servers/web/external/handler.go b/servers/web/external/handler.go new file mode 100644 index 0000000..c88e4c3 --- /dev/null +++ b/servers/web/external/handler.go @@ -0,0 +1,21 @@ +package external + +import ( + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + cache "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + "github.com/spf13/viper" +) + +type Handler struct { + cfg *viper.Viper + applicationHandler *application.ApplicationHandler + filestorage cache.FileStorage +} + +func NewHandler(cfg *viper.Viper, applicationHandler *application.ApplicationHandler, filestorage cache.FileStorage) *Handler { + return &Handler{ + cfg: cfg, + applicationHandler: applicationHandler, + filestorage: filestorage, + } +} \ No newline at end of file diff --git a/servers/web/external/solidarity_transport.go b/servers/web/external/solidarity_transport.go new file mode 100644 index 0000000..696b3aa --- /dev/null +++ b/servers/web/external/solidarity_transport.go @@ -0,0 +1,55 @@ +package external + +import ( + "net/http" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" + "git.coopgo.io/coopgo-apps/parcoursmob/renderer" +) + +func (h *Handler) SolidarityTransportExternalBookingProposalHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + bookingId := vars["bookingid"] + + // Get booking data + result, err := h.applicationHandler.GetSolidarityTransportBookingData(r.Context(), bookingId) + if err != nil { + log.Error().Err(err).Msg("could not get booking data") + w.WriteHeader(http.StatusBadRequest) + return + } + + // Handle POST form submission + if r.Method == "POST" { + if err = r.ParseForm(); err != nil { + log.Error().Err(err).Msg("error parsing form data") + } + message := r.FormValue("message") + action := r.FormValue("action") + + if action != "" { + err := h.applicationHandler.UpdateSolidarityTransportBookingStatus(r.Context(), bookingId, action, "Refusé par le bénévole", message, true) + if err != nil { + log.Error().Err(err).Msg("update booking status issue") + w.WriteHeader(http.StatusInternalServerError) + return + } + + // Get updated booking data + result, err = h.applicationHandler.GetSolidarityTransportBookingData(r.Context(), bookingId) + if err != nil { + log.Error().Err(err).Msg("could not get updated booking data") + w.WriteHeader(http.StatusInternalServerError) + return + } + } + } + + // Create renderer temporarily to maintain functionality + templates_root := h.cfg.GetString("templates.root") + renderer := renderer.NewRenderer(h.cfg, templates_root, h.filestorage) + renderer.SolidarityTransportExternalBookingDisplay(w, r, result.Booking, result.Driver, result.Passenger) + } +} \ No newline at end of file diff --git a/servers/web/external_routes.go b/servers/web/external_routes.go new file mode 100644 index 0000000..1e76def --- /dev/null +++ b/servers/web/external_routes.go @@ -0,0 +1,10 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (webServer *WebServer) setupExternalRoutes(r *mux.Router) { + ext_router := r.PathPrefix("/ext").Subrouter() + ext_router.HandleFunc("/st/bp/{bookingid}", webServer.extHandler.SolidarityTransportExternalBookingProposalHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/protected_api/handler.go b/servers/web/protected_api/handler.go new file mode 100644 index 0000000..33f56b2 --- /dev/null +++ b/servers/web/protected_api/handler.go @@ -0,0 +1,31 @@ +package protected_api + +import ( + "net/http" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "github.com/spf13/viper" +) + +type Handler struct { + cfg *viper.Viper + applicationHandler *application.ApplicationHandler +} + +func NewHandler(cfg *viper.Viper, applicationHandler *application.ApplicationHandler) *Handler { + return &Handler{ + cfg: cfg, + applicationHandler: applicationHandler, + } +} + +func (h *Handler) ApiKeyMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + apiKey := r.Header.Get("X-API-Key") + if apiKey != h.cfg.GetString("services.api.api_key") { + w.WriteHeader(http.StatusUnauthorized) + return + } + next.ServeHTTP(w, r) + }) +} \ No newline at end of file diff --git a/servers/web/protected_api/users.go b/servers/web/protected_api/users.go new file mode 100644 index 0000000..d7c02c0 --- /dev/null +++ b/servers/web/protected_api/users.go @@ -0,0 +1,39 @@ +package protected_api + +import ( + "encoding/json" + "net/http" + + "git.coopgo.io/coopgo-platform/mobility-accounts/storage" + "github.com/rs/zerolog/log" +) + +func (h *Handler) UsersHTTPHandler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + if r.Method != "POST" { + w.WriteHeader(http.StatusMethodNotAllowed) + return + } + + var user storage.Account + decoder := json.NewDecoder(r.Body) + err := decoder.Decode(&user) + if err != nil { + log.Error().Err(err).Msg("could not read account input") + w.WriteHeader(http.StatusBadRequest) + return + } + + result, err := h.applicationHandler.RegisterUser(r.Context(), user) + if err != nil { + log.Error().Err(err).Msg("error registering user") + w.WriteHeader(http.StatusInternalServerError) + return + } + + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string]string{ + "user_id": result.UserID, + }) + } +} \ No newline at end of file diff --git a/servers/web/protected_api_routes.go b/servers/web/protected_api_routes.go new file mode 100644 index 0000000..16c9f63 --- /dev/null +++ b/servers/web/protected_api_routes.go @@ -0,0 +1,12 @@ +package web + +import ( + "github.com/gorilla/mux" +) + +func (ws *WebServer) setupProtectedAPIRoutes(r *mux.Router) { + api_router := r.PathPrefix("/api").Subrouter() + protected_api_router := api_router.PathPrefix("/protected").Subrouter() + protected_api_router.Use(ws.protectedAPIHandler.ApiKeyMiddleware) + protected_api_router.HandleFunc("/users", ws.protectedAPIHandler.UsersHTTPHandler()) +} \ No newline at end of file diff --git a/servers/web/web.go b/servers/web/web.go new file mode 100644 index 0000000..a08bb95 --- /dev/null +++ b/servers/web/web.go @@ -0,0 +1,141 @@ +package web + +import ( + "errors" + "net/http" + "time" + + "github.com/gorilla/mux" + "github.com/rs/zerolog/log" + "github.com/spf13/viper" + + "git.coopgo.io/coopgo-apps/parcoursmob/core/application" + "git.coopgo.io/coopgo-apps/parcoursmob/renderer" + webapi "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/api" + webapplication "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/application" + webauth "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/auth" + webexports "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/exports" + webexternal "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/external" + webprotectedapi "git.coopgo.io/coopgo-apps/parcoursmob/servers/web/protected_api" + "git.coopgo.io/coopgo-apps/parcoursmob/services" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/identification" + cacheStorage "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/storage" + "git.coopgo.io/coopgo-platform/groups-management/storage" + "github.com/coreos/go-oidc/v3/oidc" +) + +type WebServer struct { + cfg *viper.Viper + services *services.ServicesHandler + renderer *renderer.Renderer + applicationHandler *application.ApplicationHandler + exportsHandler *webexports.Handler + authHandler *webauth.Handler + idp *identification.IdentificationProvider + + // Web handler subpackages + appHandler *webapplication.Handler + extHandler *webexternal.Handler + protectedAPIHandler *webprotectedapi.Handler + webAPIHandler *webapi.Handler +} + +func Run(cfg *viper.Viper, services *services.ServicesHandler, renderer *renderer.Renderer, applicationHandler *application.ApplicationHandler, idp *identification.IdentificationProvider, cacheHandler cacheStorage.CacheHandler, filestorage cacheStorage.FileStorage) { + var ( + address = cfg.GetString("server.web.listen") + service_name = cfg.GetString("service_name") + templates_public_dir = cfg.GetString("templates.public_dir") + dev_env = cfg.GetBool("dev_env") + ) + + webServer := &WebServer{ + cfg: cfg, + services: services, + renderer: renderer, + applicationHandler: applicationHandler, + idp: idp, + + // Initialize web handler subpackages + appHandler: webapplication.NewHandler(cfg, renderer, applicationHandler, idp, services), + authHandler: webauth.NewHandler(cfg, applicationHandler, idp, renderer), + exportsHandler: webexports.NewHandler(cfg, applicationHandler, idp, renderer), + extHandler: webexternal.NewHandler(cfg, applicationHandler, filestorage), + protectedAPIHandler: webprotectedapi.NewHandler(cfg, applicationHandler), + webAPIHandler: webapi.NewHandler(cfg, idp, applicationHandler, cacheHandler), + } + + r := mux.NewRouter() + + // Static files + r.PathPrefix("/public/").Handler(http.StripPrefix("/public/", http.FileServer(http.Dir(templates_public_dir)))) + + // Root redirect + r.HandleFunc("/", redirectApp) + + // Development middleware + if dev_env { + r.Use(trackPage) + } + + // Setup all route groups + webServer.setupAuthRoutes(r) + webServer.setupCalendarsRoutes(r) + webServer.setupExternalRoutes(r) + webServer.setupAPIRoutes(r) + webServer.setupProtectedAPIRoutes(r) + webServer.setupApplicationRoutes(r) + webServer.setupExportsRoutes(r) + + srv := &http.Server{ + Handler: r, + Addr: address, + WriteTimeout: 30 * time.Second, + ReadTimeout: 15 * time.Second, + } + + log.Info().Str("service_name", service_name).Str("address", address).Msg("Running HTTP server") + + err := srv.ListenAndServe() + log.Error().Err(err).Msg("Web server error") +} + +func redirectApp(w http.ResponseWriter, r *http.Request) { + http.Redirect(w, r, "/app/", http.StatusFound) +} + +func trackPage(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + log.Trace().Str("requested_uri", r.RequestURI).Msg("New request") + next.ServeHTTP(w, r.WithContext(r.Context())) + }) +} + +// Helper functions for extracting user and group information from request context +func currentGroup(r *http.Request) (current_group storage.Group, err error) { + g := r.Context().Value(identification.GroupKey) + if g == nil { + return storage.Group{}, errors.New("current group not found") + } + current_group = g.(storage.Group) + + return current_group, nil +} + +func currentUser(r *http.Request) (current_user_token *oidc.IDToken, current_user_claims map[string]any, err error) { + // Get current user ID + u := r.Context().Value(identification.IdtokenKey) + if u == nil { + return nil, nil, errors.New("current user not found") + } + current_user_token = u.(*oidc.IDToken) + + // Get current user claims + c := r.Context().Value(identification.ClaimsKey) + if c == nil { + return current_user_token, nil, errors.New("current user claims not found") + } + current_user_claims = c.(map[string]any) + + return current_user_token, current_user_claims, nil +} + diff --git a/services/diags.go b/services/diags.go deleted file mode 100644 index 5ca6a38..0000000 --- a/services/diags.go +++ /dev/null @@ -1,55 +0,0 @@ -package services - -import ( - "context" - // "time" - - diags "git.coopgo.io/coopgo-platform/diags/grpcapi" - "git.coopgo.io/coopgo-platform/diags/storage" - "google.golang.org/grpc" - // "google.golang.org/protobuf/types/known/timestamppb" -) - -type DiagsService struct { - diags.DiagsClient -} - -func NewDiagsService(dial string) (*DiagsService, error) { - conn, err := grpc.Dial(dial, grpc.WithInsecure()) - - client := diags.NewDiagsClient(conn) - if err != nil { - return nil, err - } - - return &DiagsService{ - DiagsClient: client, - }, nil -} - -func (s *ServicesHandler) GetDiagsDiags() ([]DiagsDiag, error) { - resp, err := s.GRPC.Diags.GetDiags(context.TODO(), &diags.GetDiagsRequest{ - Namespaces: []string{"parcoursmob_beneficiaires", "parcoursmob_diagnostiques"}, - }) - if err != nil { - return nil, err - } - - diags := []DiagsDiag{} - - for _, e := range resp.Diags { - newDiag := DiagsDiag{ - Diag: e.ToStorageType(), - } - diags = append(diags, newDiag) - } - - return diags, nil -} - -// Enriched types - -type DiagsDiag struct { - OwnersGroups []GroupsManagementGroup - storage.Diag -} diff --git a/services/fleets.go b/services/fleets.go index fc3381e..724a62f 100755 --- a/services/fleets.go +++ b/services/fleets.go @@ -4,7 +4,7 @@ import ( "context" "sort" - "git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting" + "git.coopgo.io/coopgo-apps/parcoursmob/core/utils/sorting" fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi" "git.coopgo.io/coopgo-platform/fleets/storage" "github.com/rs/zerolog/log" diff --git a/services/mobilityaccounts.go b/services/mobilityaccounts.go index 5bde04e..7c99263 100755 --- a/services/mobilityaccounts.go +++ b/services/mobilityaccounts.go @@ -3,6 +3,7 @@ package services import ( "context" + groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" "git.coopgo.io/coopgo-platform/mobility-accounts/storage" "google.golang.org/grpc" @@ -134,3 +135,27 @@ func (s *ServicesHandler) GetAccount(id string) (account storage.Account, err er return resp.Account.ToStorageType(), nil } + +func (s *ServicesHandler) GetBeneficiariesInGroup(group groupstorage.Group) (accounts []storage.Account, err error) { + accounts = []storage.Account{} + + if len(group.Members) == 0 { + return accounts, nil + } + + request := &mobilityaccounts.GetAccountsBatchRequest{ + Accountids: group.Members, + } + + resp, err := s.GRPC.MobilityAccounts.GetAccountsBatch(context.TODO(), request) + if err != nil { + return accounts, err + } + + for _, account := range resp.Accounts { + a := account.ToStorageType() + accounts = append(accounts, a) + } + + return accounts, nil +} diff --git a/services/savedsearch.go b/services/savedsearch.go new file mode 100644 index 0000000..c0556c2 --- /dev/null +++ b/services/savedsearch.go @@ -0,0 +1,23 @@ +package services + +import ( + "git.coopgo.io/coopgo-platform/saved-search/servers/grpc/proto/gen" + "google.golang.org/grpc" +) + +type SavedSearchService struct { + gen.SavedSearchServiceClient +} + +func NewSavedSearchService(dial string) (*SavedSearchService, error) { + conn, err := grpc.Dial(dial, grpc.WithInsecure()) + + client := gen.NewSavedSearchServiceClient(conn) + if err != nil { + return nil, err + } + + return &SavedSearchService{ + SavedSearchServiceClient: client, + }, nil +} \ No newline at end of file diff --git a/services/services.go b/services/services.go index 893d14d..9818b24 100755 --- a/services/services.go +++ b/services/services.go @@ -3,7 +3,6 @@ package services import ( agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi" carpoolservice "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto" - diags "git.coopgo.io/coopgo-platform/diags/grpcapi" fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi" "git.coopgo.io/coopgo-platform/geography/handlers/admin" groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" @@ -12,6 +11,7 @@ import ( "git.coopgo.io/coopgo-platform/multimodal-routing/libs/transit/transitous" "git.coopgo.io/coopgo-platform/payments/pricing" "git.coopgo.io/coopgo-platform/routing-service" + savedsearch "git.coopgo.io/coopgo-platform/saved-search/servers/grpc/proto/gen" "git.coopgo.io/coopgo-platform/sms" solidaritytransport "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen" "github.com/rs/zerolog/log" @@ -35,7 +35,7 @@ type GRPCServices struct { Agenda agenda.AgendaClient SolidarityTransport solidaritytransport.SolidarityTransportClient CarpoolService carpoolservice.CarpoolServiceClient - Diags diags.DiagsClient + SavedSearch savedsearch.SavedSearchServiceClient } func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) { @@ -46,10 +46,10 @@ func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) { agendaDial = cfg.GetString("services.grpc.agenda.dial") solidarityTransportDial = cfg.GetString("services.grpc.solidaritytransport.dial") carpoolServiceDial = cfg.GetString("services.grpc.carpoolservice.dial") + savedSearchDial = cfg.GetString("services.grpc.savedsearch.dial") routing_service_type = cfg.GetString("routing.type") valhalla_base_url = cfg.GetString("routing.valhalla.base_url") - // diagsDial = cfg.GetString("services.grpc.diags.dial") ) mobilityAccounts, err := NewMobilityAccountService(mobilityAccountsDial) if err != nil { @@ -86,11 +86,12 @@ func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) { return nil, err } - //diagsSvc, err := NewDiagsService(diagsDial) - // log.Error().Err(err).Msg("Mobility Accounts service issue") - //if err != nil { - // return nil, err - //} + savedSearchSvc, err := NewSavedSearchService(savedSearchDial) + if err != nil { + log.Error().Err(err).Msg("Saved Search service issue") + return nil, err + } + routing, err := routing.NewRoutingService(routing_service_type, valhalla_base_url) if err != nil { log.Fatal().Err(err).Msg("Could not initiate the routing service") @@ -135,7 +136,7 @@ func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) { Agenda: agendaSvc, SolidarityTransport: solidarityTransportSvc, CarpoolService: carpoolSvc, - // Diags: diagsSvc, + SavedSearch: savedSearchSvc, }, Routing: routing, InteropCarpool: carpoolRouting, diff --git a/utils/protectapi/api_key.go b/utils/protectapi/api_key.go deleted file mode 100644 index 19f24c2..0000000 --- a/utils/protectapi/api_key.go +++ /dev/null @@ -1,19 +0,0 @@ -package protectapi - -import ( - "net/http" - - "github.com/rs/zerolog/log" -) - -func ApiKey(apiKey string) func(http.Handler) http.Handler { - return func(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if apiKey == "" || r.Header.Get("X_API_KEY") != apiKey { - log.Info().Msg("call to api not allowed") - w.WriteHeader(http.StatusForbidden) - } - next.ServeHTTP(w, r) - }) - } -}