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

package directeurs

import (
	"bytes"
	"errors"
	"fmt"

	"github.com/benoitkugler/goACVE/server/shared"

	"github.com/avct/uasurfer"
	"github.com/benoitkugler/goACVE/server/documents"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	cd "github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"

	"github.com/labstack/echo"
)

const (
	UrlApiDirecteurs = "/directeurs/api/"

	ExportInscrits export = "inscrits"
	ExportEquipe   export = "equipe"
	ExportFinances export = "finances"

	DetailsDetails details = "details"
	DetailsEnvois  details = "envois"

	LVCurrent listeVetements = "current"
	LVEte     listeVetements = "ete"
	LVHiver   listeVetements = "hiver"

	InviteTous formulaireEquipier = "all"
	InviteNew  formulaireEquipier = "new"
	InviteOne  formulaireEquipier = "one"
)

// Accueil renvoie l'application statique du portail des directeurs
func Accueil(c echo.Context) error {
	ua := uasurfer.Parse(c.Request().UserAgent())
	if ua.Browser.Name == uasurfer.BrowserIE && ua.Browser.Version.Major < 12 {
		return shared.RedirectError(c, errors.New(`Ce portail ne supporte pas Internet Explorer. 
			<br/> Veuillez nous excuser pour le désagrement occasioné. <br/>
			Plusieurs très bons navigateurs libres et gratuits sont disponibles (Mozilla Firefox, Google Chrome, ...).
			`))
	}
	return c.File("server/static/directeurs/index.html")
}

// DataLoggin renvoie la liste des camps disponibles
func (ct Controller) DataLoggin(c echo.Context) error {
	camps, err := ct.getCamps()
	if err != nil {
		return err
	}
	return c.JSON(200, camps)
}

// Loggin vérifie le password
func (ct Controller) Loggin(c echo.Context) error {
	var params LogginIn
	if err := c.Bind(&params); err != nil {
		return shared.FormatErr("Champs manquants !", err)
	}
	camp, token, err := ct.checkPassword(params.IdCamp, params.Password)
	if err != nil {
		return err
	}
	var out LogginOut
	if token != "" { // sinon, mauvais mot de passe
		out.Valide = true
		out.Token = token
		out.Camp.From(camp)
		out.LienCompta = string(camp.LienCompta)
	}
	return c.JSON(200, out)
}

// GetDocumentsEquipe renvoie les exigences de documents des équipiers
func (ct Controller) GetDocumentsEquipe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}
	l, err := rc.getPiecesJustificatives(c.Request().Host)
	if err != nil {
		return err
	}
	out := DocumentsEquipeOut{
		Token:  rc.Token(),
		Pieces: l,
	}
	return c.JSON(200, out)
}

// DownloadDocumentsEquipe renvoie une archive avec plusieurs documents
func (ct Controller) DownloadDocumentsEquipe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	onlyRequis := c.QueryParam("only-requis") != ""
	buf, err := rc.downloadDocumentsEquipiers(onlyRequis)
	if err != nil {
		return shared.FormatErr("La compilation des documents a échoué.", err)
	}
	filename := reduitNom(fmt.Sprintf("Documents Equipe %s.zip", rc.Camp().RawData().Label().String()))
	return documents.Attachment(c, filename, buf.Bytes(), true)
}

// SetDocumentsEquipe met à jour les exigences de documents
func (ct Controller) SetDocumentsEquipe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	var args UpdateContrainteEquipierIn
	if err = c.Bind(&args); err != nil {
		return err
	}
	if err := rc.setExigenceDocument(args); err != nil {
		return err
	}
	return c.NoContent(200)
}

// AddDocumentEquipe upload un document d'un équipier
func (ct Controller) AddDocumentEquipe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	var args AddDocumentIn
	fileName, fileContent, err := documents.ReceiveUploadWithMeta(c, apiserver.DOCUMENT_MAX_SIZE, &args)
	if err != nil {
		return shared.FormatErr("Téléversement impossible.", err)
	}

	newDoc, err := rc.creeDocumentEquipier(c.Request().Host, args.IdEquipier, documents.ParamsNewDocument{
		IdContrainte: args.IdContrainte,
		Description:  args.Description,
		FileContent:  fileContent,
		FileName:     fileName,
	})
	if err != nil {
		return err
	}
	out := AddDocumentOut{
		Token:    rc.Token(),
		Document: newDoc,
	}
	return c.JSON(200, out)
}

// RechercheProfil renvoie les personnes proches de la recherche
func (ct Controller) RechercheProfil(c echo.Context) error {
	_, token, err := ct.authentifie(c.Request())
	if err != nil {
		return err
	}

	var args matching.PatternsSimilarite
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Le format des critères de recherche est invalide.", err)
	}
	out, err := ct.chercheSimilaires(args)
	if err != nil {
		return shared.FormatErr("La recherche a échoué.", err)
	}
	return c.JSON(200, ChercheSimilaireOut{
		Token:        token,
		Propositions: out,
	})
}

// GetEquipier renvoie la liste des équipiers
func (ct Controller) GetEquipe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	equipe, err := rc.getEquipe(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadEquipiersOut{
		Token:  rc.Token(),
		Equipe: equipe,
	}
	return c.JSON(200, out)
}

// AddEquipier ajoute un équipier, temporaire ou non
func (ct Controller) AddEquipier(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	var args CreateEquipierIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Nouvel équipier invalide.", err)
	}
	if err := args.Roles.Check(); err != nil {
		return err
	}
	if args.Rattache {
		_, err = rc.rattacheEquipier(args.IdPersonne, args.Roles)
	} else {
		_, err = rc.ajouteEquipierTmp(args.Personne, args.Roles)
	}
	if err != nil {
		return shared.FormatErr("La création de l'équipier a échoué.", err)
	}
	equipe, err := rc.getEquipe(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadEquipiersOut{
		Token:  rc.Token(),
		Equipe: equipe,
	}
	return c.JSON(200, out)
}

// ModifieEquipier met à jour un équipier et la personne sous-jacente
func (ct Controller) ModifieEquipier(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	var args EquipierDirecteur
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Equipier invalide.", err)
	}
	if err = rc.modifieEquipier(args); err != nil {
		return shared.FormatErr("Impossible de modifier l'équipier", err)
	}
	equipe, err := rc.getEquipe(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadEquipiersOut{
		Token:  rc.Token(),
		Equipe: equipe,
	}
	return c.JSON(200, out)
}

// DeleteEquipier supprime l'équipier (et la personne temporaire
// le cas échéant)
func (ct Controller) DeleteEquipier(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	id, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	if err = rc.deleteEquipier(id); err != nil {
		return shared.FormatErr("Impossible de supprimer l'équipier", err)
	}
	equipe, err := rc.getEquipe(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadEquipiersOut{
		Token:  rc.Token(),
		Equipe: equipe,
	}
	return c.JSON(200, out)
}

// InviteFormulaireEquipier envoie un mail d'invitation
// à remplir le formulaire équipier
func (ct Controller) InviteFormulaireEquipier(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadEquipiers)
	if err != nil {
		return err
	}

	var args InviteFormulaireIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Paramètres invalides.", err)
	}
	switch args.Mode {
	case InviteOne:
		err = rc.inviteFormulaireEquipier(c.Request().Host, args.IdParticipant)
	case InviteNew, InviteTous:
		err = rc.inviteFormulairesEquipiers(c.Request().Host, args.Mode == InviteNew)
	default:
		return fmt.Errorf("Mode non supporté : %s", args.Mode)
	}
	if err != nil {
		return err
	}
	equipe, err := rc.getEquipe(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadEquipiersOut{
		Token:  rc.Token(),
		Equipe: equipe,
	}
	return c.JSON(200, out)
}

// GetInscrits renvoie la liste des participants
func (ct Controller) GetInscrits(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), loadInscrits)
	if err != nil {
		return err
	}

	insc, err := rc.getInscrits(c.Request().Host)
	if err != nil {
		return shared.FormatErr("Renvoi des inscrits impossible.", err)
	}
	out := LoadInscritsOut{
		Token:    rc.Token(),
		Inscrits: insc,
	}
	return c.JSON(200, out)
}

// UpdateInscrit met à jour le profil d'un inscrit et renvoie la liste
// mise à jour
func (ct Controller) UpdateInscrit(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), loadInscrits)
	if err != nil {
		return err
	}

	var args UpdateInscritIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Champs invalides.", err)
	}
	if err = rc.modifieInscrit(args.Modifications, args.Id); err != nil {
		return shared.FormatErr("La modification du participant a échoué.", err)
	}
	insc, err := rc.getInscrits(c.Request().Host)
	if err != nil {
		return shared.FormatErr("Renvoi des inscrits impossible.", err)
	}
	out := LoadInscritsOut{
		Token:    rc.Token(),
		Inscrits: insc,
	}
	return c.JSON(200, out)
}

// LoadContraintes renvoie les contraintes accessibles par le séjour
func (ct Controller) LoadContraintes(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	contraintes, err := rc.loadContraintes(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadContraintesOut{
		Token:       rc.Token(),
		Contraintes: contraintes,
	}
	return c.JSON(200, out)
}

// CreateContrainte ajoute la contrainte et renvoie les contraintes mise à jour
func (ct Controller) CreateContrainte(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.Contrainte
	if err := c.Bind(&args); err != nil {
		return err
	}
	if err := rc.createContrainte(args); err != nil {
		return err
	}
	contraintes, err := rc.loadContraintes(c.Request().Host)
	if err != nil {
		return err
	}
	out := LoadContraintesOut{
		Token:       rc.Token(),
		Contraintes: contraintes,
	}
	return c.JSON(200, out)
}

// UpdateContrainte met à jour la contrainte
func (ct Controller) UpdateContrainte(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.Contrainte
	if err := c.Bind(&args); err != nil {
		return err
	}
	contrainte, err := rc.updateContrainte(args)
	if err != nil {
		return err
	}
	out := UpdateContrainteOut{
		Token:      rc.Token(),
		Contrainte: contrainte,
	}
	return c.JSON(200, out)
}

// LieDocument prépare l'ajout d'un document à la contrainte donnée
func (ct Controller) LieDocument(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	idContrainte, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	doc, err := rc.lieDocument(c.Request().Host, idContrainte)
	if err != nil {
		return err
	}
	out := LieDocumentOut{
		Token:    rc.Token(),
		Document: doc,
	}
	return c.JSON(200, out)
}

// DeleteContrainte supprime la contrainte personnalisée et tous les documents associés
// Les contraintes doivent être chargées à nouveau
func (ct Controller) DeleteContrainte(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	idContrainte, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	nbDocs, err := rc.deleteContrainte(idContrainte)
	if err != nil {
		return err
	}
	out := DeleteContrainteOut{
		Token:       rc.Token(),
		NbDocuments: nbDocs,
	}
	return c.JSON(200, out)
}

// LoadGroupes renvois les groupes du séjour
func (ct Controller) LoadGroupes(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	groupes, campContraintes, groupeContraintes, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return err
	}
	out := LoadGroupesOut{
		Token:             rc.Token(),
		Groupes:           groupes,
		CampContraintes:   campContraintes,
		GroupeContraintes: groupeContraintes,
	}
	return c.JSON(200, out)
}

// CreateGroupe ajoute un groupe au séjour et renvois les groupe mis à jour
// seul le champ 'nom' est utilisé
func (ct Controller) CreateGroupe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.Groupe
	if err := c.Bind(&args); err != nil {
		return err
	}
	args, err = rc.createGroupe(args)
	if err != nil {
		return err
	}

	out := UpdateGroupeOut{
		Token:  rc.Token(),
		Groupe: args,
	}
	return c.JSON(200, out)
}

func (ct Controller) UpdateGroupe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.Groupe
	if err := c.Bind(&args); err != nil {
		return err
	}
	args, err = rc.updateGroupe(args)
	if err != nil {
		return err
	}
	out := UpdateGroupeOut{
		Token:  rc.Token(),
		Groupe: args,
	}
	return c.JSON(200, out)
}

// DeleteGroupe supprime le groupe donné et renvois les groupes mis à jour
// Les participants doivent être rechargés aussi
func (ct Controller) DeleteGroupe(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}

	idGroupe, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	err = rc.deleteGroupe(idGroupe)
	if err != nil {
		return err
	}
	groupes, campContraintes, groupeContraintes, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return err
	}
	out := LoadGroupesOut{
		Token:             rc.Token(),
		Groupes:           groupes,
		CampContraintes:   campContraintes,
		GroupeContraintes: groupeContraintes,
	}
	return c.JSON(200, out)
}

// UpdatePlages met à jour les plages des groupes et les participants
// Les inscrits doivent être rechargés
func (ct Controller) UpdatePlages(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args UpdatePlageIn
	if err := c.Bind(&args); err != nil {
		return err
	}
	nbParts, err := rc.updatePlages(args.Groupes, args.Erase)
	if err != nil {
		return err
	}
	out := UpdatePlageOut{Token: rc.Token(), NbParticipants: nbParts}
	return c.JSON(200, out)
}

// UpdateGroupesContraintes met à jour les documents demandés pour chaque groupe
// et renvoie les groupes mis à jour
func (ct Controller) UpdateGroupesContraintes(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args DemandeContraintesIn
	if err := c.Bind(&args); err != nil {
		return err
	}
	err = rc.updateGroupesContraintes(args)
	if err != nil {
		return err
	}
	groupes, campContraintes, groupeContraintes, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return err
	}
	out := LoadGroupesOut{
		Token:             rc.Token(),
		Groupes:           groupes,
		CampContraintes:   campContraintes,
		GroupeContraintes: groupeContraintes,
	}
	return c.JSON(200, out)

}

// LoadGroupeAnimateurs renvoie les animateurs de référence
func (ct Controller) LoadGroupeAnimateurs(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	idGroupe, err := shared.ParseId(c, "id")
	if err != nil {
		return err
	}
	out, err := rc.loadGroupeAnimateurs(idGroupe)
	if err != nil {
		return err
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// AddGroupeAnimateurs ajoute des animateurs à un groupe
func (ct Controller) AddGroupeAnimateurs(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var params AddGroupeAnimateursIn
	if err := c.Bind(&params); err != nil {
		return err
	}
	err = rc.addGroupeAnimateurs(params)
	if err != nil {
		return err
	}
	out, err := rc.loadGroupeAnimateurs(params.IdGroupe)
	if err != nil {
		return err
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// DeleteGroupeAnimateur supprime l'animateurs d'un groupe
// ainsi que tous les liens inscrits
func (ct Controller) DeleteGroupeAnimateur(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var params DeleteGroupeAnimateurIn
	if err := c.Bind(&params); err != nil {
		return err
	}
	err = rc.deleteGroupeAnimateur(params)
	if err != nil {
		return err
	}
	out, err := rc.loadGroupeAnimateurs(params.IdGroupe)
	if err != nil {
		return err
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// UpdateInscritsAnimateur associe les inscrits à l'animateur,
// et renvoie les liens (complets) du groupe
func (ct Controller) UpdateInscritsAnimateur(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var params UpdateInscritsAnimateurIn
	if err := c.Bind(&params); err != nil {
		return err
	}
	pe, err := rc.updateInscritsAnimateur(params)
	if err != nil {
		return err
	}
	out := UpdateInsritsAnimateurOut{
		Token:                rc.Token(),
		ParticipantEquipiers: pe,
	}
	return c.JSON(200, out)
}

// AutoRepartitInscritsAnimateur propose et applique une répartition des inscrits du groupe,
// en utilisant les critères de sexe, puis d'âge
// Les affections courantes ne sont pas modifiées, seul les inscrits sans animateur sont affectés
func (ct Controller) AutoRepartitInscritsAnimateur(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	idGroupe, err := shared.ParseId(c, "id-groupe")
	if err != nil {
		return err
	}
	pe, err := rc.autoRepartitionAnimateurs(idGroupe)
	if err != nil {
		return err
	}
	out := UpdateInsritsAnimateurOut{
		Token:                rc.Token(),
		ParticipantEquipiers: pe,
	}
	return c.JSON(200, out)
}

// PreviewDocumentInscrits renvoie le nombre de documents demandés
// et mis en ligne (en terme de participants)
func (ct Controller) PreviewDocumentInscrits(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadInscrits)
	if err != nil {
		return err
	}

	idContrainte, err := shared.ParseId(c, "id-contrainte")
	if err != nil {
		return err
	}

	out := rc.previewDocsContrainte(idContrainte)
	return c.JSON(200, out)
}

// DownloadDocumentInscrits télécharge une archive des documents
// des inscrits correspondant à la contrainte donnée.
func (ct Controller) DownloadDocumentInscrits(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadInscrits)
	if err != nil {
		return err
	}

	var args rd.OptionnalId
	if err := c.Bind(&args); err != nil {
		return err
	}

	buf, err := rc.downloadDocsParticipants(args)
	if err != nil {
		return shared.FormatErr("La compilation des documents a échoué.", err)
	}
	filename := reduitNom(fmt.Sprintf("Documents inscrits %s.zip", rc.Camp().RawData().Label().String()))
	return documents.Attachment(c, filename, buf.Bytes(), true)
}

// DownloadFicheSanitaire télécharge une ou plusieurs fiches sanitaires
func (ct Controller) DownloadFicheSanitaire(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), loadInscrits)
	if err != nil {
		return err
	}

	var args DownloadFicheSanitaireIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Paramètres d'export invalides.", err)
	}
	var (
		buf      *bytes.Buffer
		filename string
	)

	switch args.Mode {
	case DownloadOne:
		buf, filename, err = rc.downloadFicheSanitaire(args.IdParticipant)
	case DownloadAll:
		filename = "fiches_sanitaires_vaccins.zip"
		buf, err = rc.downloadFichesSanitaires(args.OnlyMineurs)
	case DownloadAllInOneDocument:
		filename = "fiches_sanitaires.pdf"
		buf, err = rc.downloadFichesSanitairesOneDocument(args.OnlyMineurs, args.TriGroupe)
	default:
		return fmt.Errorf("Mode de téléchargement inconnu : %s", args.Mode)
	}
	if err != nil {
		return shared.FormatErr("La création des fiches sanitaires a échoué.", err)
	}
	return documents.Attachment(c, filename, buf.Bytes(), true)
}

// ExportsExcel permet de télécharger un document
func (ct Controller) ExportsExcel(c echo.Context) error {
	ex := export(c.Param("categorie"))
	load := loadInscrits
	if ex == ExportEquipe {
		load = loadEquipiers
	}

	rc, err := ct.setupRequest(c.Request(), load)
	if err != nil {
		return err
	}

	var (
		filename string
		buf      *bytes.Buffer
	)
	switch ex {
	case ExportInscrits:
		options := newOptionsExportExcel(c)
		buf, err = rc.exportListeInscrits(options)
		filename = "liste_participants"
	case ExportFinances:
		buf, err = rc.exportListeFinances()
		filename = "liste_finances"
	case ExportEquipe:
		buf, err = rc.exportListeEquipiers()
		filename = "liste_equipiers"
	default:
		return fmt.Errorf("Type d'export inconnu : %s", ex)
	}
	if err != nil {
		return shared.FormatErr("La génération de la liste a échoué.", err)
	}
	filename = reduitNom(fmt.Sprintf("%s %s.xlsx", filename, rc.Camp().RawData().Label().String()))
	return documents.Attachment(c, filename, buf.Bytes(), true)
}

// GetDetails renvoie les paramètres du camp
func (ct Controller) GetDetails(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}

	de := details(c.Param("categorie"))
	var out interface{}
	switch de {
	case DetailsDetails:
		out = DetailsDetailsOutput{
			Token:   rc.Token(),
			Details: rc.getDetails(),
		}
	case DetailsEnvois:
		docs, err := rc.getBonusDocs(c.Request().Host)
		if err != nil {
			return err
		}
		out = DetailsEnvoisOut{
			Token:         rc.Token(),
			Envois:        rc.Camp().RawData().Envois,
			PiecesJointes: docs,
		}
	default:
		return fmt.Errorf("Type de détails inconnu : %s", de)
	}
	return c.JSON(200, out)

}

// UpdateDetails met à jour certains paramètres du séjour
func (ct Controller) UpdateDetails(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}

	de := details(c.Param("categorie"))
	var out interface{}
	switch de {
	case DetailsDetails:
		var det DetailsWritable
		if err = c.Bind(&det); err != nil {
			return shared.FormatErr("Paramètres invalides", err)
		}
		if err = rc.updateDetails(det); err != nil {
			return shared.FormatErr("La mise à jour des détails a échoué.", err)
		}
		out = DetailsDetailsOutput{
			Token:   rc.Token(),
			Details: rc.getDetails(),
		}
	case DetailsEnvois:
		var env rd.Envois
		if err = c.Bind(&env); err != nil {
			return shared.FormatErr("Paramètres d'envoi invalides", err)
		}
		if err = rc.updateEnvois(env); err != nil {
			return shared.FormatErr("La mise à jour des préférences d'envoi a échoué.", err)
		}
		out = DetailsEnvoisOut{
			Token:  rc.Token(),
			Envois: rc.Camp().RawData().Envois,
		}
	default:
		return fmt.Errorf("Type de détails inconnu : %s", de)
	}
	return c.JSON(200, out)
}

// AjouteBonusDoc upload une pièce jointe additionelle
func (ct Controller) AjouteBonusDoc(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	fileHeader, err := c.FormFile("file")
	if err != nil {
		return shared.FormatErr("Fichier manquant.", err)
	}
	fileName, fileContent, err := documents.ReceiveUpload(fileHeader, apiserver.DOCUMENT_MAX_SIZE)
	if err != nil {
		return shared.FormatErr("L'ajout du document a échoué.", err)
	}
	pub, err := rc.addBonusDoc(c.Request().Host, fileName, fileContent)
	if err != nil {
		return shared.FormatErr("La création du document a échoué", err)
	}
	out := AddBonusDocOut{
		Token:    rc.Token(),
		Document: pub,
	}
	return c.JSON(200, out)
}

// GetListeVetements renvoie la liste de vêtements
// actuelle, ou une par défaut
func (ct Controller) GetListeVetements(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var out ListeVetementsOut
	lv := listeVetements(c.Param("default"))
	switch lv {
	case LVCurrent:
		out.Liste = rc.Camp().RawData().ListeVetements
	case LVEte:
		out.Liste.Liste = ct.defaultListe.Ete
	case LVHiver:
		out.Liste.Liste = ct.defaultListe.Hiver
	default:
		return fmt.Errorf("Type de liste inconnu : %s", lv)
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// UpdateListeVetements met à jour la liste de vêtements
func (ct Controller) UpdateListeVetements(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.ListeVetements
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Liste de vêtements invalide !", err)
	}
	if err = rc.updateListeVetements(args); err != nil {
		return shared.FormatErr("La modification de la liste de vêtements a échoué.", err)
	}
	out := ListeVetementsOut{
		Token: rc.Token(),
		Liste: rc.Camp().RawData().ListeVetements,
	}
	return c.JSON(200, out)
}

// PreviewListeVetements génère le document contenant la liste de vêtements
func (ct Controller) PreviewListeVetements(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}

	docR := cd.NewListeVetements(rc.Camp().RawData())
	byt, err := docR.Generate()
	if err != nil {
		return shared.FormatErr("La création de la liste a échoué.", err)
	}
	return documents.Attachment(c, docR.FileName(), byt, true)
}

// GetLettreDirecteur renvoie le HTML de la lettre, et un éventuel
// document publique.
func (ct Controller) GetLettreDirecteur(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var out LettreDirecteurOut
	out.Document, out.Lettre, err = rc.getLettreDirecteur(c.Request().Host)
	if err != nil {
		return err
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// UpdateLettreDirecteur met à jour le contenu de la lettre et la publie
func (ct Controller) UpdateLettreDirecteur(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var args rd.Lettredirecteur
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Paramètres invalides.", err)
	}
	doc, err := rc.updateLettreDirecteur(c.Request().Host, args)
	if err != nil {
		return shared.FormatErr("La création de la lettre a échoué.", err)
	}
	out := LettreDirecteurOut{
		Token:    rc.Token(),
		Lettre:   args,
		Document: doc,
	}
	return c.JSON(200, out)
}

// GetJoomeo renvoie les informations relatives au compte Joomeo du séjour
func (ct Controller) GetJoomeo(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}
	data, err := rc.loadJoomeoData()
	if err != nil {
		return shared.FormatErr("La lecture des informations JOOMEO a échoué.", err)
	}
	out := LoadJoomeoOut{
		Token:      rc.Token(),
		JoomeoData: data,
	}
	return c.JSON(200, out)
}

// AddContactsJoomeo ajoute plusieurs contacts au séjour
func (ct Controller) AddContactsJoomeo(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}

	var args AddContactJoomeoIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Arguments invalides.", err)
	}
	var out AddContactJoomeoOut
	out.Contacts, out.Errors, err = rc.addJoomeoContacts(args.Mails, args.SendMail)
	if err != nil {
		return shared.FormatErr("L'envoi des invitations a échoué.", err)
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// SetContactUploader élève les permissions du contact
func (ct Controller) SetContactUploader(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}

	var args SetContactUploaderIn
	if err = c.Bind(&args); err != nil {
		return shared.FormatErr("Arguments invalides.", err)
	}
	var (
		out             SetContactUploaderOut
		errSuperContact error
	)
	out.Contacts, errSuperContact, err = rc.setContactUploader(args.Contactid)
	if errSuperContact != nil {
		out.ErrSuperContact = errSuperContact.Error()
	}
	if err != nil {
		return shared.FormatErr("La modification du contact a échoué.", err)
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// DeleteContact enlève le contact des contacts Joomeo
func (ct Controller) DeleteContact(c echo.Context) error {
	rc, err := ct.setupRequest(c.Request(), noLoad)
	if err != nil {
		return err
	}

	id := c.QueryParam("contactid")
	if id == "" {
		return errors.New("Id non fourni !")
	}
	var out DeleteContactOut
	out.Contacts, err = rc.deleteContact(id)
	if err != nil {
		return shared.FormatErr("La suppression du contact a échoué.", err)
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}

// LoadSondages renvoie les retours sur le séjour.
func (ct Controller) LoadSondages(c echo.Context) error {
	rc, err := ct.setupRequestComplet(c.Request(), noLoad)
	if err != nil {
		return err
	}
	var out LoadSondagesOut
	out.Sondages, err = rc.loadSondages()
	if err != nil {
		return err
	}
	out.Token = rc.Token()
	return c.JSON(200, out)
}