package application import ( "context" "crypto/rand" "encoding/base64" "fmt" "io" "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" fleetsstorage "git.coopgo.io/coopgo-platform/fleets/storage" groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi" "git.coopgo.io/coopgo-platform/groups-management/storage" groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage" accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi" mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage" "github.com/google/uuid" "github.com/gorilla/mux" "google.golang.org/protobuf/types/known/structpb" ) func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) { accounts, err := h.services.GetAccounts() if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } beneficiaries, err := h.services.GetBeneficiaries() if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } bookings, err := h.services.GetBookings() if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } request := &groupsmanagement.GetGroupsRequest{ Namespaces: []string{"parcoursmob_organizations"}, } resp, err := h.services.GRPC.GroupsManagement.GetGroups(context.TODO(), request) if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } var groups = []groupstorage.Group{} for _, group := range resp.Groups { g := group.ToStorageType() groups = append(groups, g) } sort.Sort(sorting.GroupsByName(groups)) ////////////////////////////////////add event//////////////////////////////////////////// rresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{ Namespaces: []string{"parcoursmob_dispositifs"}, }) if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } responses := []agendastorage.Event{} groupids := []string{} for _, e := range rresp.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, }) groupps := map[string]any{} if err == nil { for _, g := range groupsresp.Groups { groupps[g.Id] = g.ToStorageType() } } 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") == "" { fmt.Println("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", } groupid := uuid.NewString() dataMap := map[string]any{ "name": r.FormValue("name"), "modules": modules, } data, err := structpb.NewValue(dataMap) if err != nil { fmt.Println(err) 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", }, } _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization) if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } // Create the admin role for the organization _, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role) if err != nil { fmt.Println(err) 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 { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } groupmembers, admins, err := h.groupmembers(groupid) if err != nil { fmt.Println(err) 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"] groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{ Id: groupid, Namespace: "parcoursmob_organizations", }) if err != nil { fmt.Println(err) 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 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) _, err = h.services.GRPC.MobilityAccounts.UpdateData( context.TODO(), &accounts.UpdateDataRequest{ Account: as, }, ) fmt.Println(err) data := map[string]any{ "group": groupresp.Group.ToStorageType().Data["name"], } if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil { fmt.Println(err) } http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound) return } 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 { fmt.Println(err) 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": groupresp.Group.ToStorageType().Data["name"], "key": key, } if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } } http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound) return } func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) groupid := vars["groupid"] groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{ Id: groupid, Namespace: "parcoursmob_organizations", }) if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } group := groupresp.Group.ToStorageType() 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, }, ) fmt.Println(err) data := map[string]any{ "group": group.Data["name"], } if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil { fmt.Println(err) } 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 { fmt.Println(err) 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, } if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } } http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound) return } func filteVehicle(r *http.Request, v *fleets.Vehicle) bool { g := r.Context().Value(identification.GroupKey) if g == nil { return false } group := g.(storage.Group) for _, n := range v.Administrators { if n == group.ID { return true } } return false } func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Request) { bookings := []fleetsstorage.Booking{} administrators := []string{} reequest := &fleets.GetVehiclesRequest{ Namespaces: []string{"parcoursmob"}, } reesp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), reequest) if err != nil { fmt.Println(err) w.WriteHeader(http.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]) } 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 { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } for _, g := range admingroups.Groups { groups[g.Id] = g.ToStorageType() } } sort.Sort(sorting.VehiclesByLicencePlate(vehicles)) sort.Sort(sorting.BookingsByStartdate(bookings)) h.Renderer.AdminStatVehicles(w, r, vehicles, bookings, groups) } 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 { fmt.Println(err) 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 { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } cacheid := uuid.NewString() h.cache.PutWithTTL(cacheid, beneficiaries, 1*time.Hour) h.Renderer.AdminStatBeneficaires(w, r, beneficiaries, cacheid) } func (h ApplicationHandler) AdminStatEvents(w http.ResponseWriter, r *http.Request) { resp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{ Namespaces: []string{"parcoursmob_dispositifs"}, }) if err != nil { fmt.Println(err) w.WriteHeader(http.StatusInternalServerError) return } responses := []agendastorage.Event{} groupids := []string{} for _, e := range resp.Events { groupids = append(groupids, e.Owners...) responses = append(responses, e.ToStorageType()) } sort.Sort(sorting.EventsByStartdate(responses)) groupsresp, err := h.services.GRPC.GroupsManagement.GetGroupsBatch(context.TODO(), &groupsmanagement.GetGroupsBatchRequest{ Groupids: groupids, }) groups := map[string]any{} if err == nil { for _, g := range groupsresp.Groups { groups[g.Id] = g.ToStorageType() } } h.Renderer.AdminStatEvents(w, r, responses, groups) }