Merge branch 'infoAboutGroupMember' into dev

This commit is contained in:
soukainna 2023-02-22 14:04:09 +01:00
commit 3bfce72512
5 changed files with 572 additions and 5 deletions

2
go.mod
View File

@ -4,7 +4,7 @@ go 1.18
// replace git.coopgo.io/coopgo-platform/mobility-accounts => ../../coopgo-platform/mobility-accounts/
// replace git.coopgo.io/coopgo-platform/groups-management => ../../coopgo-platform/groups-management/
replace git.coopgo.io/coopgo-platform/groups-management => ../../coopgo-platform/groups-management/
// replace git.coopgo.io/coopgo-platform/fleets => ../../coopgo-platform/fleets/

View File

@ -5,14 +5,26 @@ import (
"encoding/json"
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"time"
fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
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"
geojson "github.com/paulmach/go.geojson"
"gitlab.scity.coop/maas/navitia-golang"
"gitlab.scity.coop/maas/navitia-golang/types"
"google.golang.org/protobuf/types/known/structpb"
)
var Depart any
var Arrive any
func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
@ -144,3 +156,413 @@ func (h *ApplicationHandler) JourneysSearch(w http.ResponseWriter, r *http.Reque
h.Renderer.JourneysSearch(w, r, carpoolresults, journeys, vehicles, searched, departuregeo, destinationgeo, departuredate, departuretime)
}
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 {
fmt.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
var 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 {
fmt.Println(err)
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 {
fmt.Println(err)
w.WriteHeader(http.StatusBadRequest)
return
}
dstinationgeo, err = geojson.UnmarshalFeature([]byte(destination))
if err != nil {
fmt.Println(err)
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") == "" {
fmt.Println("invalid name")
w.WriteHeader(http.StatusBadRequest)
return
}
if r.FormValue("number") == "" {
fmt.Println("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 {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
fmt.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
var 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 {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
// fmt.Println(err)
// 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)
//fmt.Println(groups)
var number string = strconv.Itoa(len(resp.Group.Members))
/////////////////////
accountsBeneficaire, err := h.beneficiaries(r)
if err != nil {
fmt.Println(err)
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 {
fmt.Println(err)
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 {
fmt.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
req := &groupsmanagement.UnsubscribeMemberRequest{
Id: ressp.Group.Id,
}
_, errr := h.services.GRPC.GroupsManagement.UnsubscribeMember(context.TODO(), req)
if errr != nil {
fmt.Println(errr)
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 {
fmt.Println(err)
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)
}

View File

@ -116,9 +116,10 @@ func main() {
application.HandleFunc("/group/settings/invite-member", applicationHandler.GroupSettingsInviteMember)
/****************************Groupe Déplacement ************************************/
// 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", 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)
/****************************************************************/
/********************Code Supprt Emailing************************/

View File

@ -1,9 +1,40 @@
package renderer
import "net/http"
import (
"encoding/json"
"html/template"
"net/http"
groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
)
const journeysMenu = "journeys"
type BeneficiariesCovoiturage struct {
Group string `json:"group"`
Count int `json:"count"`
CacheId string `json:"cache_id"`
Beneficiaries []any `json:"beneficiaries"`
}
type BeneficiariesCovoiturageA struct {
Count int `json:"count"`
CacheId string `json:"cache_id"`
Beneficiaries []any `json:"beneficiaries"`
}
func (s BeneficiariesCovoiturage) JSON() template.JS {
result, _ := json.Marshal(s)
return template.JS(result)
}
func (s BeneficiariesCovoiturage) JSONWithLimits(a int, b int) template.JS {
if b < len(s.Beneficiaries) {
s.Beneficiaries = s.Beneficiaries[a:b]
}
return s.JSON()
}
func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request, carpools any, transitjourneys any, vehicles []any, searched bool, departure any, destination any, departuredate string, departuretime string) {
files := renderer.ThemeConfig.GetStringSlice("views.journeys.search.files")
state := NewState(r, renderer.ThemeConfig, journeysMenu)
@ -20,3 +51,100 @@ func (renderer *Renderer) JourneysSearch(w http.ResponseWriter, r *http.Request,
renderer.Render("journeys", w, r, files, state)
}
type BeneficiariesListstate struct {
Count int `json:"count"`
CacheId string `json:"cache_id"`
Beneficiaries []groupstorage.Group `json:"beneficiaries"`
}
func (s BeneficiariesListstate) JSON() template.JS {
result, _ := json.Marshal(s)
return template.JS(result)
}
func (s BeneficiariesListstate) JSONWithLimits(a int, b int) template.JS {
if b < len(s.Beneficiaries) {
s.Beneficiaries = s.Beneficiaries[a:b]
}
return s.JSON()
}
func (renderer *Renderer) GroupsGestion(w http.ResponseWriter, r *http.Request, groups []groupstorage.Group, cacheid string) {
files := renderer.ThemeConfig.GetStringSlice("views.journeys.list.files")
state := NewState(r, renderer.ThemeConfig, journeysMenu)
state.ViewState = BeneficiariesListstate{
Count: len(groups),
CacheId: cacheid,
Beneficiaries: groups,
}
renderer.Render("journeys", w, r, files, state)
}
func (renderer *Renderer) CreateGroup(w http.ResponseWriter, r *http.Request, depart any, arrive any, searched bool, beneficiary any, beneficiaries []mobilityaccountsstorage.Account, departure any, destination any) {
files := renderer.ThemeConfig.GetStringSlice("views.journeys.create.files")
state := NewState(r, renderer.ThemeConfig, journeysMenu)
viewstate := map[string]any{
"deeparture": depart,
"deestination": arrive,
"beneficiaries": beneficiaries,
"searched": searched,
"departure": departure,
"destination": destination,
}
if searched {
viewstate["search"] = map[string]any{
"beneficiary": beneficiary,
}
}
state.ViewState = viewstate
renderer.Render("journeys", w, r, files, state)
}
func (renderer *Renderer) DisplayGroupCovoiturage(w http.ResponseWriter, r *http.Request, number string, groupid string, depart any, arrive any, accounts []any, cacheid string, searched bool, beneficiary any, group any, beneficiaries []mobilityaccountsstorage.Account, groups map[string]any) {
files := renderer.ThemeConfig.GetStringSlice("views.journeys.display.files")
state := NewState(r, renderer.ThemeConfig, journeysMenu)
viewstate := map[string]any{
"beneficiaries": beneficiaries,
"searched": searched,
"group": group,
"deeparture": depart,
"deestination": arrive,
"groups": groups,
"ben": accounts,
"number": number,
"list": BeneficiariesCovoiturage{
Group: groupid,
Count: len(accounts),
CacheId: cacheid,
Beneficiaries: accounts,
},
}
if searched {
viewstate["search"] = map[string]any{
"beneficiary": beneficiary,
}
}
state.ViewState = viewstate
renderer.Render("journeys", w, r, files, state)
}
func (renderer *Renderer) UpdateGroupCovoiturage(w http.ResponseWriter, r *http.Request, groupid string, memberid string) {
files := renderer.ThemeConfig.GetStringSlice("views.journeys.update.files")
state := NewState(r, renderer.ThemeConfig, journeysMenu)
state.ViewState = map[string]any{
"groupid": groupid,
"memberid": memberid,
}
renderer.Render("journeys", w, r, files, state)
}

View File

@ -40,3 +40,19 @@ func (s *ServicesHandler) GetGroupsMap() (groups map[string]storage.Group, err e
return
}
////////////////////////////////optimize the code//////////////////////////////////////
func (s *ServicesHandler) GetGroupsMemberMap(id string) (groups map[string]any, err error) {
groups = map[string]any{}
request := &groupsmanagement.GetGroupsBatchMemberRequest{
Groupids: []string{id},
}
resp, err := s.GRPC.GroupsManagement.GetGroupsBatchMember(context.TODO(), request)
if err == nil {
for _, group := range resp.Groups {
groups[group.Memberid] = group.ToStorageType()
}
}
return
}