673 lines
20 KiB
Go
Executable File
673 lines
20 KiB
Go
Executable File
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/motis"
|
|
"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 []*motis.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{}
|
|
|
|
searched := false
|
|
|
|
var (
|
|
departuregeo *geojson.Feature
|
|
destinationgeo *geojson.Feature
|
|
// journeys *navitia.JourneyResults
|
|
// carpoolresults []any
|
|
)
|
|
|
|
if departuredate != "" && departuretime != "" && departure != "" && destination != "" {
|
|
searched = true
|
|
|
|
var err error
|
|
|
|
departuregeo, err = geojson.UnmarshalFeature([]byte(departure))
|
|
if err != nil {
|
|
log.Error().Err(err).Msg("error unmarshalling departure")
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
destinationgeo, err = geojson.UnmarshalFeature([]byte(destination))
|
|
if err != nil {
|
|
log.Error().Err(err).Msg("error unmarshalling destination")
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// 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 !yield(dj) {
|
|
return
|
|
}
|
|
}
|
|
})
|
|
// res.DriverJourneys
|
|
sort.Slice(driverJourneys, func(i, j int) bool {
|
|
return driverJourneys[i].DriverDistance < driverJourneys[j].DriverDistance
|
|
})
|
|
}
|
|
|
|
// 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),
|
|
})
|
|
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 *motis.Itinerary)
|
|
go func(transitch chan *motis.Itinerary, departure *geojson.Feature, destination *geojson.Feature, datetime *time.Time) {
|
|
defer close(transitch)
|
|
// timetableView := false
|
|
searchWindows := 1800
|
|
response, err := h.services.TransitRouting.PlanWithResponse(context.Background(), &motis.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,
|
|
// TimetableView: &timetableView,
|
|
SearchWindow: &searchWindows,
|
|
})
|
|
if err != nil {
|
|
log.Error().Err(err).Msg("error retrieving transit data from MOTIS server")
|
|
return
|
|
}
|
|
for _, i := range response.JSON200.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)
|
|
}
|
|
|
|
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)
|
|
}
|