github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/main.go

package main

// TODO: dons: ajout rechercehe + switch organism/persone + switch anéee + montant total
// TODO: enlever don annonymes (inutiles)

// virement ; accés de la banque par marie pierre
// paiement en ligne : accés compta pour basculer les sommes
// dons : accès marie-pierre, jean-pierre barbe
// dons; ajouter champ libre numéro
// TODO: recus fiscaux attention à la performance

// TODO: ajouter notifications direct sur paiement par mail
// TODO: paiement en plusieurs fois (autoriser une somme plus faible)

// TODO: (Moyen terme) Joomeo : message personnalisé
// TODO: (Moyen terme) mails pour relance fiche sanitaire (en cc)
import (
	"database/sql"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"

	"os/exec"
	"path"
	"strconv"
	"time"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/benoitkugler/goACVE/server/acvegestion"
	"github.com/benoitkugler/goACVE/server/directeurs"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/equipier"
	"github.com/benoitkugler/goACVE/server/espaceperso"
	"github.com/benoitkugler/goACVE/server/inscriptions"
	"github.com/benoitkugler/goACVE/server/misc"
	"github.com/benoitkugler/goACVE/server/passwords"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/benoitkugler/goACVE/server/sondages"
	"github.com/benoitkugler/goACVE/server/vote"

	"github.com/benoitkugler/goACVE/server/core/apiserver"

	"github.com/benoitkugler/goACVE/logs"
	cd "github.com/benoitkugler/goACVE/server/core/documents"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/benoitkugler/goACVE/server/core/utils/pdf"

	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
)

const (
	urlACVEGestion = "/ACVEGestion/api/"

	urlCleanupTmpDocuments = "/api/admin/cleanup_tmp_docs"
)

func initDB(dev bool) *sql.DB {
	var (
		db  *sql.DB
		err error
	)
	if dev {
		db, err = rd.ConnectDB(logs.DBDev)
		logSetup(err, dev, "DB dev")
	} else {
		db, err = rd.ConnectDB(logs.DBProd)
		logSetup(err, dev, "DB production")
	}
	return db
}

func parseFlags() (dev, dry bool) {
	devPtr := flag.Bool("dev", false, "utilise les crédences de développement")
	dryPtr := flag.Bool("dry", false, "vérifie les connections et quite")
	flag.Parse()
	return *devPtr, *dryPtr
}

func logSetup(err error, dev bool, label string) {
	if err != nil {
		if dev {
			log.Println(label, "error :", err)
		} else {
			log.Fatal(label, "error :", err)
		}
	} else {
		fmt.Println(label, "--> OK")
	}
}

func checks(db *sql.DB, dev bool) {
	// si les DB sont nils, en mode production
	// on s'arrête avant
	if db != nil {
		err := db.Ping()
		logSetup(err, dev, "Ping DB")
	}

	err := exec.Command("gs", "--version").Run()
	logSetup(err, dev, "Ghostscript")

	urlWeasyprint, err := pdf.TestWeasyprint()
	logSetup(err, dev, "Server weasyprint "+urlWeasyprint)

	err = cd.TestRIB()
	logSetup(err, dev, "RIB")

	err = pdf.CheckPdfToolkit()
	logSetup(err, dev, "PdfToolkit")
}

func getAdress(dev bool) string {
	var adress string
	if dev {
		adress = "localhost:1323"
	} else {
		// alwaysdata use IP and PORT env var
		host := os.Getenv("IP")
		port, err := strconv.Atoi(os.Getenv("PORT"))
		if err != nil {
			log.Fatal("No PORT found", err)
		}
		if strings.Count(host, ":") >= 2 { // ipV6 -> besoin de crochet
			host = "[" + host + "]"
		}
		adress = fmt.Sprintf("%s:%d", host, port)
	}
	return adress
}

func setDevMode(e *echo.Echo, ct directeurs.Controller) {
	fmt.Println("Dev mode :")
	e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
		AllowMethods:  append(middleware.DefaultCORSConfig.AllowMethods, http.MethodOptions),
		AllowHeaders:  []string{"Authorization", "Content-Type", "Access-Control-Allow-Origin"},
		ExposeHeaders: []string{"Content-Disposition"},
	}))
	fmt.Println("\tCORS activé.")

	e.GET("test/error", func(c echo.Context) error {
		return shared.RedirectError(c, errors.New("erreur de test. <br/> Détails : <i>dssdmsldkmslk</i>"))
	}, shared.RedirectIE11)
	e.GET("test/success", func(c echo.Context) error {
		return shared.RedirectSuccess(c, "Validation", "Mail validé", "Mail validé. <br/> <b>Merci !</b>")
	}, shared.RedirectIE11)

	e.GET("test/success", func(c echo.Context) error {
		return shared.RedirectSuccess(c, "Validation", "Mail validé", "Mail validé. <br/> <b>Merci !</b>")
	}, shared.RedirectIE11)

	e.GET("/test/stream", func(c echo.Context) error {
		c.Response().Header().Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
		c.Response().WriteHeader(http.StatusOK)
		enc := json.NewEncoder(c.Response())
		for range [20]byte{} {
			if err := enc.Encode("ldslmksml"); err != nil {
				return err
			}
			c.Response().Flush()
			time.Sleep(500 * time.Millisecond)
		}
		return nil
	})

	e.GET("test/routes", func(c echo.Context) error {
		return c.JSONPretty(200, e.Routes(), " ")
	})
	fmt.Println("\tRoutes /test/... setup")
	token, err := ct.ShowTokenDev()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("\t" + token)
}

func main() {
	dev, dry := parseFlags()

	e := echo.New()

	e.HTTPErrorHandler = func(err error, c echo.Context) {
		err = echo.NewHTTPError(400, err.Error())
		e.DefaultHTTPErrorHandler(err, c)
	}

	// on se connecte sur la bonne base de donnée
	db := initDB(dev)
	defer db.Close()

	e.Group("/static", middleware.Gzip(), shared.CacheStatic).Static("/*", "server/static")

	// on ajuste les crédences
	logsStmp, logsJoomeo, signing := logs.SmtpProd, logs.JoomeoProd, logs.PASSPHRASE
	if dev {
		logsStmp, logsJoomeo, signing = logs.SmtpDev, logs.JoomeoDev, logs.PASSPHRASE_DEV
	}

	// on crée les controllers
	basic := shared.Controller{SMTP: logsStmp, DB: db, Signing: signing}

	ctMisc := misc.Controller{Controller: basic}
	ctSondages := sondages.Controller{Controller: basic}
	ctDocuments := documents.Controller{Controller: basic}
	ctPageEquipier := equipier.NewController(basic, logsJoomeo)

	ctEspacePerso, err := espaceperso.NewController(basic, logsJoomeo, ctSondages)
	if err != nil {
		log.Fatalf("can't init espace perso : %s", err)
	}

	ctDirecteurs, err := directeurs.NewController(basic, logsJoomeo, "ressources/")
	if err != nil {
		log.Fatalf("can't init directeurs : %s", err)
	}

	ctAcvegestion := acvegestion.Controller{Controller: basic, FicheSanitaireNotifier: ctEspacePerso, ContraintesEquipiers: ctDirecteurs.ContraintesEquipiers}

	ctInscriptions := inscriptions.Controller{Controller: basic}

	ctVote, err := vote.NewController(basic.DB, basic.SMTP, ".")
	if err != nil {
		log.Fatalf("can't init votes : %s", err)

	}
	ctPasswords := passwords.Controller{DB: basic.DB}

	if dev {
		setDevMode(e, ctDirecteurs)
	}

	setupRoutesACVEGestion(e, ctAcvegestion)
	setupRoutesDirecteurs(e, ctDirecteurs)
	setupRoutesMisc(e, ctMisc, ctSondages)
	setupRoutesDocuments(e, ctDocuments)
	setupRoutesInscriptions(e, ctInscriptions)
	setupRoutesEspacePerso(e, ctEspacePerso)
	setupRoutesEquipier(e, ctPageEquipier)
	setupRoutesVote(e, ctVote)
	setupRoutesPasswords(e, ctPasswords)

	mails.InitTemplates("ressources/")
	logSetup(nil, dev, "Templates mails")

	err = pdf.InitImages()
	logSetup(err, dev, "Images")

	if dry {
		checks(db, dev)
		fmt.Println("Setup done. Exiting.")
		return
	} else {
		// on lance la vérification dans une goroutine
		// pour ne pas retarder le lancement principal
		go checks(db, dev)

		adress := getAdress(dev)
		log.Println("Setup done. Listening...")
		e.Logger.Fatal(e.Start(adress))
	}
}

func setupRoutesDirecteurs(e *echo.Echo, ct directeurs.Controller) {
	for _, route := range []string{
		"/directeurs/inscrits",
		"/directeurs/equipe",
		"/directeurs/lettre_directeur",
		"/directeurs/liste_vetements",
		"/directeurs/details",
		"/directeurs/photos",
		"/directeurs/retours",
		"/directeurs/",
		"/directeurs",
		"/directeurs/home",
	} {
		e.GET(route, directeurs.Accueil, shared.NoCache)
	}

	p := func(s string) string {
		return path.Join(directeurs.UrlApiDirecteurs, s)
	}
	e.GET(p("identification"), ct.DataLoggin)
	e.POST(p("identification"), ct.Loggin)

	e.GET(p("details/:categorie"), ct.GetDetails)
	e.POST(p("details/:categorie"), ct.UpdateDetails)
	e.PUT(p("details/document"), ct.AjouteBonusDoc)

	e.GET(p("inscrits"), ct.GetInscrits)
	e.POST(p("inscrits"), ct.UpdateInscrit)

	e.GET(p("contraintes"), ct.LoadContraintes)
	e.PUT(p("contraintes"), ct.CreateContrainte)
	e.POST(p("contraintes"), ct.UpdateContrainte)
	e.DELETE(p("contraintes"), ct.DeleteContrainte)
	e.GET(p("contraintes/lie_document"), ct.LieDocument)

	e.GET(p("groupes"), ct.LoadGroupes)
	e.PUT(p("groupes"), ct.CreateGroupe)
	e.POST(p("groupes"), ct.UpdateGroupe)
	e.DELETE(p("groupes"), ct.DeleteGroupe)
	e.POST(p("groupes/plages"), ct.UpdatePlages)

	e.GET(p("groupes/animateurs"), ct.LoadGroupeAnimateurs)
	e.PUT(p("groupes/animateurs"), ct.AddGroupeAnimateurs)
	e.POST(p("groupes/animateurs"), ct.DeleteGroupeAnimateur)
	e.POST(p("groupes/animateurs/inscrits"), ct.UpdateInscritsAnimateur)
	e.PUT(p("groupes/animateurs/inscrits"), ct.AutoRepartitInscritsAnimateur)

	e.POST(p("groupes/contraintes"), ct.UpdateGroupesContraintes)

	e.GET(p("inscrits/documents"), ct.PreviewDocumentInscrits)
	e.POST(p("inscrits/documents"), ct.DownloadDocumentInscrits)
	e.POST(p("inscrits/fiche_sanitaire"), ct.DownloadFicheSanitaire)

	e.GET(p("equipe/pieces"), ct.GetDocumentsEquipe)
	e.POST(p("equipe/pieces"), ct.SetDocumentsEquipe)
	e.GET(p("equipe/pieces/download"), ct.DownloadDocumentsEquipe)
	e.PUT(p("equipe/pieces/upload"), ct.AddDocumentEquipe)

	e.POST(p("equipe/recherche"), ct.RechercheProfil)

	e.GET(p("equipe"), ct.GetEquipe)
	e.PUT(p("equipe"), ct.AddEquipier)
	e.POST(p("equipe"), ct.ModifieEquipier)
	e.DELETE(p("equipe"), ct.DeleteEquipier)
	e.POST(p("equipe/invite"), ct.InviteFormulaireEquipier)

	e.GET(p("exports/:categorie"), ct.ExportsExcel)

	e.GET(p("liste_vetements/:default"), ct.GetListeVetements)
	e.POST(p("liste_vetements"), ct.UpdateListeVetements)
	e.GET(p("liste_vetements/preview"), ct.PreviewListeVetements)

	e.GET(p("lettre_directeur"), ct.GetLettreDirecteur)
	e.POST(p("lettre_directeur"), ct.UpdateLettreDirecteur)
	e.POST(p("lettre_directeur/upload_image/:id_camp/:token"), ct.UploadImageLettre)
	e.GET(directeurs.PATH_LOAD_IMAGES_LETTRE, ct.LoadImageLettre)

	e.GET(p("photos"), ct.GetJoomeo)
	e.PUT(p("photos"), ct.AddContactsJoomeo)
	e.POST(p("photos"), ct.SetContactUploader)
	e.DELETE(p("photos"), ct.DeleteContact)

	e.GET(p("retours"), ct.LoadSondages)
}

func setupRoutesMisc(e *echo.Echo, ct misc.Controller, ct2 sondages.Controller) {
	// accueil général
	e.GET("/", func(c echo.Context) error {
		return c.File("server/static/bv/accueil.html")
	})

	// cgu
	e.GET("/cgu", func(c echo.Context) error {
		return c.File("server/static/bv/cgu.html")
	})

	e.GET("/logiciel", misc.HandleLogiciel)
	e.POST("/logiciel", misc.DownloadLogiciel)

	// Hello Asso
	e.POST("/helloasso/nouveau_paiement", func(c echo.Context) error {
		c.Logger().Printf("HELLOASSO - Notification")
		return c.NoContent(200)
	})

	// vue globale des sondages
	e.GET(sondages.EndpointSondages, sondages.PageSondages)
	e.POST(sondages.EndpointSondages, ct2.LoadSondages)

	// url de nettoyage des documents temporaires
	e.GET(urlCleanupTmpDocuments, ct.Controller.CleanupTmpDocuments)

	// url de récupération du lien de suivi
	e.POST("/lien_espace_perso", ct.SearchMail)
}

func setupRoutesDocuments(e *echo.Echo, ct documents.Controller) {
	e.GET(documents.EndPointMiniature, ct.SertMiniature)
	e.GET(documents.EndPointDocument, ct.SertDocument)
	e.POST(documents.EndPointDocument, ct.HandleUpload)
	e.DELETE(documents.EndPointDocument, ct.HandleDelete)
}

func setupRoutesInscriptions(e *echo.Echo, ct inscriptions.Controller) {
	p := func(s string) string {
		return path.Join(inscriptions.UrlInscriptions, s)
	}

	e.GET(p(""), ct.FormulaireInscription, middleware.Gzip(), shared.RedirectIE11, shared.NoCache)
	e.GET(p("/:preselected"), ct.FormulaireInscription, middleware.Gzip(), shared.RedirectIE11, shared.NoCache)

	e.GET(p("/api"), ct.HandleLoadDataInscriptions)
	e.POST(p("/api"), ct.EnregistreInscriptionComplete)
	e.POST(p("/api/no-check-mail"), ct.RejoueInscriptionComplete)
	e.GET(p("/api/check-mail"), ct.CheckMail)

	e.GET(p(inscriptions.EndPointValidMail), ct.ValideMail)

	e.POST(p("/api/simple"), ct.EnregistreInscriptionSimple)
}

func setupRoutesEspacePerso(e *echo.Echo, ct espaceperso.Controller) {
	for _, route := range []string{
		"/espace_perso/:key",
		"/espace_perso/",
		"/espace_perso",
		"/espace_perso/:key/participants",
		"/espace_perso/:key/paiement",
		"/espace_perso/:key/documents",
		"/espace_perso/:key/fiches_sanitaires",
		"/espace_perso/:key/joomeo",
		"/espace_perso/:key/retours",
	} {
		e.GET(route, espaceperso.Accueil, middleware.Gzip(), shared.RedirectIE11, shared.NoCache)
	}

	e.GET("/espace_perso/:key/api/metas", ct.GetMetas)
	e.GET("/espace_perso/:key/api/datas", ct.GetData)
	e.GET("/espace_perso/:key/api/finances", ct.GetFinances)
	e.GET("/espace_perso/:key/api/joomeo", ct.LoadJoomeo)

	e.PUT("/espace_perso/:key/api/document", ct.CreateDocument)
	e.PUT("/espace_perso/:key/api/aide", ct.CreateAide)
	e.POST("/espace_perso/:key/api/aide", ct.UpdateAide)
	e.DELETE("/espace_perso/:key/api/aide", ct.DeleteAide)
	e.GET("/espace_perso/:key/api/fiche_sanitaire", ct.TransfertFicheSanitaire)
	e.POST("/espace_perso/:key/api/fiche_sanitaire", ct.UpdateFicheSanitaire)
	e.POST("/espace_perso/:key/api/participants", ct.UpdateOptionsParticipants)

	e.GET(espaceperso.EndPointPartageFicheSanitaire, ct.ValideTransfertFicheSanitaire)

	e.GET("/espace_perso/:key/api/connected", ct.MarkConnection)

	e.GET("/espace_perso/:key/api/download/facture", ct.DownloadFacture)
	e.GET("/espace_perso/:key/api/download/presence", ct.DownloadAttestationPresence)

	e.POST("/espace_perso/:key/api/sondage", ct.SaveSondage)

	e.PUT("/espace_perso/:key/api/message", ct.CreeMessage)
	e.POST("/espace_perso/:key/api/message", ct.EditMessage)
	e.DELETE("/espace_perso/:key/api/message", ct.DeleteMessage)

	e.POST("/espace_perso/:key/api/placeliberee", ct.ConfirmePlaceliberee)
}

func setupRoutesEquipier(e *echo.Echo, ct equipier.Controller) {
	p := func(s string) string {
		return path.Join(directeurs.EndPointEquipier, s)
	}

	e.GET(p("/:cryptedId"), equipier.FormulaireEquipier, middleware.Gzip(), shared.RedirectIE11, shared.NoCache)

	e.GET(p("/:cryptedId/datas"), ct.DatasEquipier)
	e.GET(p("/:cryptedId/datas/joomeo"), ct.DatasJoomeo)
	e.POST(p("/:cryptedId"), ct.UpdateEquipier)
	e.PUT(p("/:cryptedId"), ct.AjouteDocumentEquipier)

	e.POST(p("/:cryptedId/charte"), ct.UpdateCharte)
}

func setupRoutesACVEGestion(e *echo.Echo, ct acvegestion.Controller) {
	p := func(s string) string {
		return path.Join(urlACVEGestion, s)
	}

	e.GET(p(apiserver.UrlUpdate+"/:platform"), acvegestion.SertUpdateInfos)
	e.POST(p(apiserver.UrlUpdate+"/:platform"), acvegestion.SertUpdate)

	e.GET(p(apiserver.UrlUsers), ct.GetUsers)
	e.POST(p(apiserver.UrlUsers), ct.CheckPassword)

	e.GET(p(apiserver.UrlDB), ct.SertDB)
	e.PUT(p(apiserver.UrlDB), ct.SertDBHash)
	e.POST(p(apiserver.UrlDB), ct.SertDBPartiel)

	e.PUT(p(apiserver.UrlAides), ct.CreateAide)
	e.POST(p(apiserver.UrlAides), ct.UpdateAide)
	e.DELETE(p(apiserver.UrlAides), ct.DeleteAide)

	e.PUT(p(apiserver.UrlPersonnes), ct.CreatePersonne)
	e.POST(p(apiserver.UrlPersonnes), ct.UpdatePersonne)
	e.DELETE(p(apiserver.UrlPersonnes), ct.DeletePersonne)

	e.PUT(p(apiserver.UrlOrganismes), ct.CreateOrganisme)
	e.POST(p(apiserver.UrlOrganismes), ct.UpdateOrganisme)
	e.DELETE(p(apiserver.UrlOrganismes), ct.DeleteOrganisme)

	e.POST(p(apiserver.UrlCamps), ct.UpdateCamp)
	e.PUT(p(apiserver.UrlCamps), ct.CreateCamp)
	e.DELETE(p(apiserver.UrlCamps), ct.DeleteCamp)

	e.PUT(p(apiserver.UrlDons), ct.CreateDon)
	e.POST(p(apiserver.UrlDons), ct.UpdateDon)
	e.DELETE(p(apiserver.UrlDons), ct.DeleteDon)
	e.POST(p(apiserver.UrlRecuFiscal), ct.GenereRecuFiscal)
	e.GET(p(apiserver.UrlDonsHelloasso), ct.ImportDonsHelloasso)
	e.POST(p(apiserver.UrlDonsHelloasso), ct.IdentifieDonHelloasso)

	e.PUT(p(apiserver.UrlFactures), ct.CreateFacture)
	e.POST(p(apiserver.UrlFactures), ct.UpdateFacture)
	e.DELETE(p(apiserver.UrlFactures), ct.DeleteFacture)
	e.POST(p(apiserver.UrlFacturesFusion), ct.FusionneFactures)

	e.GET(p(apiserver.UrlInscriptions), ct.LoadInscriptions)
	e.DELETE(p(apiserver.UrlInscriptions), ct.DeleteInscription)
	e.POST(p(apiserver.UrlValideInscriptions), ct.ValideInscription)

	e.PUT(p(apiserver.UrlIdentifieEquipier), ct.IdentifieEquipier)
	e.PUT(p(apiserver.UrlIdentifieResponsable), ct.IdentifieResponsable)
	e.PUT(p(apiserver.UrlIdentifieParticipant), ct.IdentifieParticipant)
	e.PUT(p(apiserver.UrlIdentifieParticipantsimple), ct.IdentifieParticipantsimple)

	e.PUT(p(apiserver.UrlPaiements), ct.CreatePaiement)
	e.POST(p(apiserver.UrlPaiements), ct.UpdatePaiement)
	e.DELETE(p(apiserver.UrlPaiements), ct.DeletePaiement)
	e.POST(p(apiserver.UrlPaiementsBordereau), ct.MarquePaiementsBordereau)

	e.PUT(p(apiserver.UrlParticipants), ct.CreateParticipant)
	e.POST(p(apiserver.UrlParticipants), ct.UpdateParticipant)
	e.DELETE(p(apiserver.UrlParticipants), ct.DeleteParticipant)

	e.PUT(p(apiserver.UrlParticipantsimples), ct.CreateParticipantsimple)
	e.POST(p(apiserver.UrlParticipantsimples), ct.UpdateParticipantsimple)
	e.DELETE(p(apiserver.UrlParticipantsimples), ct.DeleteParticipantsimple)

	e.PUT(p(apiserver.UrlStructureaides), ct.CreateStructureaide)
	e.POST(p(apiserver.UrlStructureaides), ct.UpdateStructureaide)
	e.DELETE(p(apiserver.UrlStructureaides), ct.DeleteStructureaide)

	e.PUT(p(apiserver.UrlEquipiers), ct.CreateEquipier)
	e.POST(p(apiserver.UrlEquipiers), ct.UpdateEquipier)
	e.DELETE(p(apiserver.UrlEquipiers), ct.DeleteEquipier)

	e.PUT(p(apiserver.UrlDocuments), ct.CreateDocument)
	e.POST(p(apiserver.UrlDocuments), ct.UpdateDocument)
	e.DELETE(p(apiserver.UrlDocuments), ct.DeleteDocument)
	e.POST(p(apiserver.UrlDocumentsMiniatures), ct.GetDocumentsMiniatures)
	e.GET(p(apiserver.UrlDocumentsTransfert), ct.DownloadDocument)
	e.POST(p(apiserver.UrlDocumentsTransfert), ct.UploadDocument)

	e.POST(p(apiserver.UrlNotifieMessage), ct.NotifieSimple)

	e.PUT(p(apiserver.UrlNotifieMessagePerso), ct.NotifieMessage)
	e.POST(p(apiserver.UrlNotifieMessagePerso), ct.EditMessage)
	e.POST(p(apiserver.UrlMessages), ct.UpdateMessage)
	e.PUT(p(apiserver.UrlMessages), ct.CreateMessageMessage)

	e.POST(p(apiserver.UrlDeleteMessages), ct.DeleteMessages)

	e.POST(p(apiserver.UrlNotifiePlaceLiberee), ct.NotifiePlaceLiberee)
	e.POST(p(apiserver.UrlNotifieAttestation), ct.NotifieAttestation)
	e.POST(p(apiserver.UrlNotifieMessagePersos), ct.NotifieMany)
	e.POST(p(apiserver.UrlNotifieDocuments), ct.NotifieDocuments)
	e.POST(p(apiserver.UrlNotifieSondages), ct.NotifieSondages)
}

func setupRoutesVote(e *echo.Echo, ct vote.Controller) {
	e.GET("/vote_admin/:key", vote.PageAdmin, shared.NoCache)

	e.GET("/vote_admin/:key/api/membres", ct.GetMembres)
	e.PUT("/vote_admin/:key/api/membres", ct.InviteOne)
	e.POST("/vote_admin/:key/api/membres", ct.InviteAll)

	e.GET("/vote_admin/:key/api/votes", ct.GetVotes)
	e.PUT("/vote_admin/:key/api/votes", ct.CreateVote)
	e.POST("/vote_admin/:key/api/votes", ct.UpdateVote)
	e.DELETE("/vote_admin/:key/api/votes", ct.DeleteVote)

	e.GET("/vote_admin/:key/api/votes/clear", ct.ClearVote)
	e.POST("/vote_admin/:key/api/votes/lock", ct.LockVote)
	e.GET("/vote_admin/:key/api/votes/export", ct.ExportBilanVotes)

	e.GET(vote.EndpointVote+"/:key", ct.PageVote)
	e.POST(vote.EndpointVote+"/:key", ct.LoadVotes)
	e.PUT(vote.EndpointVote+"/:key", ct.EffectueVote)
	e.DELETE(vote.EndpointVote+"/:key", ct.ResetVote)
	e.GET(vote.EndpointVote+"/:key/export", ct.ExportBilanPersonne)
}

func setupRoutesPasswords(e *echo.Echo, ct passwords.Controller) {
	e.GET("/passwords/:key", passwords.PagePasswords, shared.NoCache)

	e.GET("/passwords/:key/api", ct.GetPasswords)
	e.PUT("/passwords/:key/api", ct.CreatePassword)
	e.POST("/passwords/:key/api", ct.UpdatePassword)
	e.DELETE("/passwords/:key/api", ct.DeletePassword)
}