handlers/application/administration.go

@@ -11,8 +11,6 @@ import (
 	"time"
 
 	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
-	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
-	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
 	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
 	"git.coopgo.io/coopgo-platform/fleets/storage"
 	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
@@ -22,7 +20,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"google.golang.org/protobuf/types/known/structpb"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Request) {
@@ -67,40 +64,8 @@ func (h *ApplicationHandler) Administration(w http.ResponseWriter, r *http.Reque
 	}
 
 	sort.Sort(sorting.GroupsByName(groups))
-	////////////////////////////////////add event////////////////////////////////////////////
-	rresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
-		Namespaces: []string{"parcoursmob_dispositifs"},
-		Mindate:    timestamppb.New(time.Now().Add(-24 * time.Hour)),
-	})
 
-	if err != nil {
+	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings)
-		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) {
@@ -389,8 +354,7 @@ func (h ApplicationHandler) AdminStatVehicles(w http.ResponseWriter, r *http.Req
 
 	vehicles, _ := h.services.GetVehiclesMap()
 	groups, _ := h.services.GetGroupsMap()
-	// fmt.Println(vehicles)
+
-	// fmt.Println("////////////////////////////////////////:")
 	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
 }
 

handlers/application/agenda.go

@@ -67,6 +67,7 @@ func (h *ApplicationHandler) AgendaHome(w http.ResponseWriter, r *http.Request)
 			groups[g.Id] = g.ToStorageType()
 		}
 	}
+
 	h.Renderer.AgendaHome(w, r, responses, groups)
 }
 

handlers/application/members.go

@@ -6,12 +6,9 @@ import (
 	"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"
 	"google.golang.org/protobuf/types/known/structpb"
 )
 
@@ -39,34 +36,8 @@ func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Reques
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	//////////////////////////////////add organisations/////////////////////////////////////////////////
 
-	var allIds []string
+	h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType())
-	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 {
-		fmt.Println(err)
-		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) {
@@ -105,7 +76,7 @@ func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request
 			return
 		}
 
-		http.Redirect(w, r, fmt.Sprintf("/app/members/%s", resp.Account.Id), http.StatusFound)
+		http.Redirect(w, r, fmt.Sprintf("/app/profile/%s", resp.Account.Id), http.StatusFound)
 
 		return
 	}
@@ -155,59 +126,3 @@ func parseUserForm(r *http.Request) (map[string]any, error) {
 
 	return dataMap, nil
 }
-
-func (h *ApplicationHandler) MembersList(w http.ResponseWriter, r *http.Request) {
-
-	accounts, err := h.services.GetAccounts()
-	if err != nil {
-		fmt.Println(err)
-		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 {
-			fmt.Println(err)
-			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 {
-			fmt.Println(err)
-			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)
-}

handlers/application/vehicles-management.go

@@ -52,16 +52,10 @@ func (h *ApplicationHandler) VehiclesManagementOverview(w http.ResponseWriter, r
 
 		}
 	}
-	// vehiicles := []fleetsstorage.Vehicle{}
+
-	// for i, vehiicle := range resp.Vehicles {
-	// 	if len(resp.Vehicles[i].Bookings) == 0 {
-	// 		v := vehiicle.ToStorageType()
-	// 		vehiicles = append(vehiicles, v)
-	// 	}
-	// }
-	//fmt.Println(vehiicles)
 	sort.Sort(sorting.VehiclesByLicencePlate(vehicles))
 	sort.Sort(sorting.BookingsByStartdate(bookings))
+
 	h.Renderer.VehiclesManagementOverview(w, r, vehicles, vehicles_map, bookings)
 }
 
@@ -190,10 +184,7 @@ func (h *ApplicationHandler) VehiclesFleetDisplay(w http.ResponseWriter, r *http
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	// if len(resp.Vehicle.ToStorageType().Bookings) == 0 {
+
-	// 	fmt.Println("lol")
-	// }
-	// fmt.Println(resp.Vehicle.ToStorageType().Bookings)
 	h.Renderer.VehiclesFleetDisplay(w, r, resp.Vehicle.ToStorageType())
 }
 
@@ -466,28 +457,3 @@ func (h ApplicationHandler) VehiclesFleetMakeUnavailable(w http.ResponseWriter,
 
 	http.Redirect(w, r, fmt.Sprintf("/app/vehicles-management/fleet/%s", vehicleid), http.StatusFound)
 }
-
-// func (h *ApplicationHandler) UnbookingVehicles(w http.ResponseWriter, r *http.Request) {
-// 	request := &fleets.GetVehiclesRequest{
-// 		Namespaces: []string{"parcoursmob"},
-// 	}
-// 	resp, err := h.services.GRPC.Fleets.GetVehicles(context.TODO(), request)
-// 	if err != nil {
-// 		fmt.Println(err)
-// 		w.WriteHeader(http.StatusInternalServerError)
-// 	}
-// 	vehicles := []fleetsstorage.Vehicle{}
-// 	fmt.Println(resp.Vehicles[0].Bookings)
-// 	for i, vehicle := range resp.Vehicles {
-// 		if len(resp.Vehicles[i].Bookings) == 0 {
-// 			v := vehicle.ToStorageType()
-// 			vehicles = append(vehicles, v)
-// 		}
-// 	}
-// 	// if len(resp.Vehicle.ToStorageType().Bookings) == 0 {
-// 	// 	h.Renderer.UnbookingVehicles(w, r, resp.Vehicle.ToStorageType())
-// 	// }
-// 	// fmt.Println(resp.Vehicle.ToStorageType().Bookings)
-// 	fmt.Println(vehicles)
-// 	h.Renderer.UnbookingVehicles(w, r, vehicles)
-// }

main.go

@@ -87,7 +87,6 @@ func main() {
 	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("/vehicles/", applicationHandler.VehiclesSearch)
 	application.HandleFunc("/vehicles/bookings/", applicationHandler.VehiclesBookingsList)
@@ -137,10 +136,6 @@ func main() {
 	appAdmin.HandleFunc("/groups/{groupid}/invite-admin", applicationHandler.AdministrationGroupInviteAdmin)
 	appAdmin.HandleFunc("/groups/{groupid}/invite-member", applicationHandler.AdministrationGroupInviteMember)
 	appAdmin.HandleFunc("/stats/vehicles", applicationHandler.AdminStatVehicles)
-	//add statistiques
-	appAdmin.HandleFunc("/stats/vehicles/available", applicationHandler.AdminStatAvailableVehicles)
-	appAdmin.HandleFunc("/stats/beneficaires", applicationHandler.AdminStatBeneficaires)
-	appAdmin.HandleFunc("/stats/events", applicationHandler.AdminStatEvents)
 
 	fmt.Println("-> HTTP server listening on", address)
 

renderer/administration.go

@@ -3,13 +3,12 @@ package renderer
 import (
 	"net/http"
 
-	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
 	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
 const administrationMenu = "administration"
 
-func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request, accounts any, beneficiaries any, groups any, bookings any, events []agendastorage.Event) {
+func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request, accounts any, beneficiaries any, groups any, bookings any) {
 	files := renderer.ThemeConfig.GetStringSlice("views.administration.home.files")
 	state := NewState(r, renderer.ThemeConfig, administrationMenu)
 	state.ViewState = map[string]any{
@@ -17,7 +16,6 @@ func (renderer *Renderer) Administration(w http.ResponseWriter, r *http.Request,
 		"beneficiaries": beneficiaries,
 		"bookings":      bookings,
 		"groups":        groups,
-		"events":        events,
 	}
 
 	renderer.Render("administration", w, r, files, state)

renderer/members.go

@@ -1,22 +1,17 @@
 package renderer
 
 import (
-	"encoding/json"
-	"html/template"
 	"net/http"
-
-	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
 )
 
 const membersMenu = "members"
 
-func (renderer *Renderer) MemberDisplay(w http.ResponseWriter, r *http.Request, admins any, groups []string) {
+func (renderer *Renderer) MemberDisplay(w http.ResponseWriter, r *http.Request, admins any) {
 	files := renderer.ThemeConfig.GetStringSlice("views.members.display.files")
 
 	state := NewState(r, renderer.ThemeConfig, membersMenu)
 	state.ViewState = map[string]any{
 		"admins": admins,
-		"groups": groups,
 	}
 	renderer.Render("members_list", w, r, files, state)
 }
@@ -27,41 +22,3 @@ func (renderer *Renderer) MemberUpdate(w http.ResponseWriter, r *http.Request, u
 	state.ViewState = user
 	renderer.Render("members_update", w, r, files, state)
 }
-
-type MembersListState struct {
-	Count   int                               `json:"count"`
-	CacheId string                            `json:"cache_id"`
-	Members []mobilityaccountsstorage.Account `json:"members"`
-	Groups  []string                          `json:"groups"`
-}
-
-func (s MembersListState) JSON() template.JS {
-	result, _ := json.Marshal(s)
-	return template.JS(result)
-}
-
-func (s MembersListState) JSONWithLimits(a int, b int) template.JS {
-	if b < len(s.Members) {
-		s.Members = s.Members[a:b]
-	}
-	return s.JSON()
-}
-
-func (renderer *Renderer) MembersList(w http.ResponseWriter, r *http.Request, accounts []mobilityaccountsstorage.Account, cacheid string, groups []string) {
-	files := renderer.ThemeConfig.GetStringSlice("views.members.list.files")
-
-	state := NewState(r, renderer.ThemeConfig, membersMenu)
-
-	state.ViewState = map[string]any{
-
-		"list": MembersListState{
-			Count:   len(accounts),
-			CacheId: cacheid,
-			Members: accounts,
-			Groups:  groups,
-		},
-		"groups": groups,
-	}
-
-	renderer.Render("members_list", w, r, files, state)
-}

renderer/vehicle-management.go

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

renderer/vehicles.go

@@ -78,15 +78,3 @@ func (renderer *Renderer) VehicleBookingsList(w http.ResponseWriter, r *http.Req
 
 	renderer.Render("vehicles search", w, r, files, state)
 }
-
-// func (renderer *Renderer) VehicleUnbookingsList(w http.ResponseWriter, r *http.Request, bookings []storage.Booking, vehiclesMap any, groupsMap any) {
-// 	files := renderer.ThemeConfig.GetStringSlice("views.vehicles.bookings_list.files")
-// 	state := NewState(r, renderer.ThemeConfig, vehiclesMenu)
-// 	state.ViewState = map[string]any{
-// 		"bookings":     bookings,
-// 		"vehicles_map": vehiclesMap,
-// 		"groups_map":   groupsMap,
-// 	}
-
-// 	renderer.Render("vehicles search", w, r, files, state)
-// }