789 lines
22 KiB
Go
Executable File
789 lines
22 KiB
Go
Executable File
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
|
|
}
|
|
|
|
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)
|
|
|
|
}
|