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

// Expose les fonctionnalités de la page de suivi personnelle
package espaceperso

import (
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/logs"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	cd "github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/utils/joomeo"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"

	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/lib/pq"
)

const (
	EndPointPartageFicheSanitaire = "/partage_fiche_sanitaire"

	// Pas de modification directe après J-7 (début du camp).
	UpdateLimitation = 7 * 24 * time.Hour
)

type Controller struct {
	shared.Controller

	joomeo           logs.Joomeo
	contrainteVaccin rd.Contrainte

	sondageNotifier SondageNotifier
}

type SondageNotifier interface {
	Notifie(host string, sondage rd.Sondage) error
}

// NewController charge les données initiales
func NewController(ct shared.Controller, joomeo logs.Joomeo, sondageNotifier SondageNotifier) (Controller, error) {
	out := Controller{Controller: ct, joomeo: joomeo, sondageNotifier: sondageNotifier}

	// on préselectionne la contrainte 'vaccins'
	row := ct.DB.QueryRow("SELECT * FROM contraintes WHERE builtin = 'vaccin'")
	var err error
	out.contrainteVaccin, err = rd.ScanContrainte(row)
	return out, err
}

type Participant struct {
	Id                       int64                 `json:"id,omitempty"` // en lecture seulement, les modifications sont sécurisées avec IdCrypted
	IdCrypted                string                `json:"id_crypted,omitempty"`
	IdPersonneCrypted        string                `json:"id_personne_crypted,omitempty"`
	IdCamp                   int64                 `json:"id_camp,omitempty"`
	ListeAttente             rd.ListeAttente       `json:"liste_attente,omitempty"`
	HintsAttente             rd.HintsAttente       `json:"hints_attente,omitempty"`
	IsFicheSanitaireUpToDate bool                  `json:"is_fiche_sanitaire_up_to_date,omitempty"`
	Options                  rd.OptionsParticipant `json:"options,omitempty"`
}

type partageFicheSanitaire struct {
	Mail       string
	IdPersonne int64
}

func (ct Controller) decrypteKey(key string) (idFacture int64, err error) {
	key = strings.TrimSpace(key)
	if key == "" {
		return 0, fmt.Errorf("Merci de fournir une clé de dossier !")
	}
	row := ct.DB.QueryRow("SELECT id FROM factures WHERE key = $1", key)
	var idFac int64
	if err = row.Scan(&idFac); err != nil {
		return 0, shared.FormatErr(fmt.Sprintf("Votre dossier (n° %s) est introuvable : êtes-vous sûr du lien utilisé ?", key), err)
	}
	return idFac, nil
}

// loadData charge depuis la base toutes les données nécessaires
// à l'affichage de l'espace personnel de suivi.
// La base renvoyée est PARTIELLE.
func (ct Controller) loadData(idFacture int64) (*dm.BaseLocale, error) {
	fac, err := rd.SelectFacture(ct.DB, idFacture)
	if err != nil {
		return nil, err
	}
	idsPersonnes := rd.Ids{fac.IdPersonne}

	participants, err := rd.SelectParticipantsByIdFactures(ct.DB, idFacture)
	if err != nil {
		return nil, err
	}

	rows, err := ct.DB.Query(`SELECT groupes.* FROM groupes 
	JOIN groupe_participants ON groupe_participants.id_groupe = groupes.id
	WHERE groupe_participants.id_participant = ANY($1)`, participants.Ids().AsSQL())
	if err != nil {
		return nil, err
	}
	groupes, err := rd.ScanGroupes(rows)
	if err != nil {
		return nil, err
	}
	groupeParticipants, err := rd.SelectGroupeParticipantsByIdGroupes(ct.DB, groupes.Ids()...)
	if err != nil {
		return nil, err
	}

	var idsParticipants, idsCamps rd.Ids
	for _, part := range participants {
		idsParticipants = append(idsParticipants, part.Id)
		idsCamps = append(idsCamps, part.IdCamp)
		idsPersonnes = append(idsPersonnes, part.IdPersonne)
	}

	campContraintes, err := rd.SelectCampContraintesByIdCamps(ct.DB, idsCamps...)
	if err != nil {
		return nil, err
	}

	groupeContraintes, err := rd.SelectGroupeContraintesByIdGroupes(ct.DB, groupes.Ids()...)
	if err != nil {
		return nil, err
	}

	aides, err := rd.SelectAidesByIdParticipants(ct.DB, idsParticipants...)
	if err != nil {
		return nil, err
	}

	documentAides, err := rd.SelectDocumentAidesByIdAides(ct.DB, aides.Ids()...)
	if err != nil {
		return nil, err
	}

	documentPersonnes, err := rd.SelectDocumentPersonnesByIdPersonnes(ct.DB, idsPersonnes...)
	if err != nil {
		return nil, err
	}

	documentCamps, err := rd.SelectDocumentCampsByIdCamps(ct.DB, idsCamps...)
	if err != nil {
		return nil, err
	}

	rows, err = ct.DB.Query(`SELECT documents.* FROM documents
		JOIN document_aides ON document_aides.id_document = documents.id
		WHERE document_aides.id_aide = ANY($1)
		UNION
		SELECT documents.* FROM documents
		JOIN document_camps ON document_camps.id_document = documents.id
		WHERE document_camps.id_camp = ANY($2)
		UNION
		SELECT documents.* FROM documents
		JOIN document_personnes ON document_personnes.id_document = documents.id
		WHERE document_personnes.id_personne = ANY($3)
	`, aides.Ids().AsSQL(), idsCamps.AsSQL(), idsPersonnes.AsSQL())
	if err != nil {
		return nil, err
	}
	docs, err := rd.ScanDocuments(rows)
	if err != nil {
		return nil, err
	}

	// les contraintes sont celles des groupes, des séjours et celles des documents des personnes
	rows, err = ct.DB.Query(`SELECT contraintes.* FROM contraintes 
		JOIN groupe_contraintes ON groupe_contraintes.id_contrainte = contraintes.id
		WHERE groupe_contraintes.id_groupe = ANY($1)
		UNION
		SELECT contraintes.* FROM contraintes 
		JOIN camp_contraintes ON camp_contraintes.id_contrainte = contraintes.id
		WHERE camp_contraintes.id_camp = ANY($2)
		UNION 
		SELECT contraintes.* FROM contraintes 
		JOIN document_personnes ON document_personnes.id_contrainte = contraintes.id
		WHERE document_personnes.id_document = ANY($3)`,
		groupes.Ids().AsSQL(), idsCamps.AsSQL(), docs.Ids().AsSQL())
	if err != nil {
		return nil, err
	}
	contraintes, err := rd.ScanContraintes(rows)
	if err != nil {
		return nil, err
	}

	rows, err = ct.DB.Query("SELECT * FROM camps WHERE id = ANY($1)", idsCamps.AsSQL())
	if err != nil {
		return nil, err
	}
	camps, err := rd.ScanCamps(rows)
	if err != nil {
		return nil, err
	}

	// récupération des directeurs (equipiers et personnes)
	rows, err = ct.DB.Query("SELECT * FROM equipiers WHERE id_camp = ANY($1) AND $2 = ANY(roles)", idsCamps.AsSQL(), rd.RDirecteur)
	if err != nil {
		return nil, err
	}
	equipiers, err := rd.ScanEquipiers(rows)
	if err != nil {
		return nil, err
	}
	for _, directeur := range equipiers {
		idsPersonnes = append(idsPersonnes, directeur.IdPersonne)
	}

	rows, err = ct.DB.Query("SELECT * FROM personnes WHERE id = ANY ($1)", idsPersonnes.AsSQL())
	if err != nil {
		return nil, err
	}
	personnes, err := rd.ScanPersonnes(rows)
	if err != nil {
		return nil, err
	}

	structures, err := rd.SelectAllStructureaides(ct.DB)
	if err != nil {
		return nil, err
	}

	paiements, err := rd.SelectPaiementsByIdFactures(ct.DB, idFacture)
	if err != nil {
		return nil, err
	}

	// messages
	messages, err := rd.SelectMessagesByIdFactures(ct.DB, idFacture)
	if err != nil {
		return nil, err
	}
	// compléments
	mA, err := rd.SelectMessageAttestationsByIdMessages(ct.DB, messages.Ids()...)
	if err != nil {
		return nil, err
	}
	mC, err := rd.SelectMessageDocumentsByIdMessages(ct.DB, messages.Ids()...)
	if err != nil {
		return nil, err
	}
	mS, err := rd.SelectMessageSondagesByIdMessages(ct.DB, messages.Ids()...)
	if err != nil {
		return nil, err
	}
	mP, err := rd.SelectMessagePlaceliberesByIdMessages(ct.DB, messages.Ids()...)
	if err != nil {
		return nil, err
	}
	mM, err := rd.SelectMessageMessagesByIdMessages(ct.DB, messages.Ids()...)
	if err != nil {
		return nil, err
	}

	sondages, err := rd.SelectSondagesByIdFactures(ct.DB, idFacture)
	if err != nil {
		return nil, err
	}

	out := dm.BaseLocale{
		Personnes:      personnes,
		Paiements:      paiements,
		Participants:   participants,
		Groupes:        groupes,
		Equipiers:      equipiers,
		Factures:       rd.Factures{fac.Id: fac},
		Aides:          aides,
		Structureaides: structures,
		Camps:          camps,
		Contraintes:    contraintes,
		Documents:      docs,
		Messages:       messages,
		Sondages:       sondages,
	}
	out.ProcessRawLinks(dm.RawLinks{
		DocumentAides:       documentAides,
		DocumentCamps:       documentCamps,
		DocumentPersonnes:   documentPersonnes,
		GroupeContraintes:   groupeContraintes,
		GroupeParticipants:  groupeParticipants,
		CampContraintes:     campContraintes,
		MessageDocuments:    mC,
		MessageSondages:     mS,
		MessageAttestations: mA,
		MessagePlaceliberes: mP,
		MessageMessages:     mM,
	})

	return &out, nil
}

func (ct Controller) crypteIds(dossiers []dm.AccesParticipant) (personnes, participants map[int64]string, err error) {
	personnes, participants = map[int64]string{}, map[int64]string{}
	var idC, idPC string
	for _, part := range dossiers {
		rawPart := part.RawData()
		idC, err = shared.EncodeID(ct.Signing, shared.OrParticipant, rawPart.Id)
		if err != nil {
			return
		}
		participants[part.Id] = idC
		idPC, err = shared.EncodeID(ct.Signing, shared.OrPersonne, rawPart.IdPersonne)
		if err != nil {
			return
		}
		personnes[rawPart.IdPersonne] = idPC
	}
	return
}

func (ct Controller) compileData(host string, idFacture int64, base *dm.BaseLocale) (out ContentEspacePerso, err error) {
	fac := base.NewFacture(idFacture)
	respPers := fac.GetPersonne().RawData()

	out.Responsable = Responsable{
		Prenom:          respPers.FPrenom(),
		Sexe:            respPers.Sexe,
		NomPrenom:       respPers.NomPrenom().String(),
		CopiesMails:     fac.RawData().CopiesMails,
		SecuriteSociale: respPers.SecuriteSociale,
		Coordonnees: Coordonnees{
			Mail:       respPers.Mail,
			Tels:       respPers.Tels,
			Adresse:    respPers.Adresse,
			CodePostal: respPers.CodePostal,
			Ville:      respPers.Ville,
			Pays:       respPers.Pays,
		},
		DestinatairesOptionnels: fac.ChoixDestinataires(),
	}

	dossiers := fac.GetDossiers(nil)

	persCrypted, partsCrypted, err := ct.crypteIds(dossiers)
	if err != nil {
		return out, err
	}

	idsCamps := rd.NewSet()
	personneContraintes := map[int64]map[int64]rd.Ids{} // id personne -> id contrainte -> ids camps (demandant la contrainte)
	for _, part := range dossiers {
		rawPart := part.RawData()
		idP, idCamp := rawPart.IdPersonne, part.GetCamp().Id

		// on ajoute à la personne sous jacente les contraintes, en gardant le séjour
		cont := personneContraintes[idP]
		if cont == nil {
			cont = make(map[int64]rd.Ids)
		}
		// contraintes communes à tout le séjour
		for _, campContrainte := range part.Base.CampContraintes[idCamp] {
			cont[campContrainte.IdContrainte] = append(cont[campContrainte.IdContrainte], idCamp)
		}
		// contraintes spécifiques au groupe
		groupe, hasGroupe := part.GetGroupe()
		if hasGroupe {
			for _, groupeContrainte := range part.Base.GroupeContraintes[groupe.Id] {
				cont[groupeContrainte.IdContrainte] = append(cont[groupeContrainte.IdContrainte], idCamp)
			}
		}

		personneContraintes[idP] = cont

		// on ajoute le camp
		idsCamps.Add(idCamp)

		out.Participants = append(out.Participants, Participant{
			Id:                       part.Id,
			IdCrypted:                partsCrypted[rawPart.Id],
			IdPersonneCrypted:        persCrypted[idP],
			IdCamp:                   idCamp,
			ListeAttente:             rawPart.ListeAttente,
			HintsAttente:             part.HintsAttente(nil),
			IsFicheSanitaireUpToDate: part.IsFicheSanitaireUpToDate().Bool(),
			Options:                  rawPart.Options,
		})

	}

	out.Personnes, err = ct.compileParticipantsPersonnes(host, respPers.Mail, personneContraintes, persCrypted, base)
	if err != nil {
		return
	}

	out.Camps, err = ct.compileCamps(host, idsCamps, base)
	if err != nil {
		return
	}
	out.Sondages, err = ct.compileSondages(base.Sondages)
	if err != nil {
		return
	}

	out.Messages = compileMessages(fac)
	return
}

// marque les messages comme vu/non vu, basé sur la dernière connection
func compileMessages(fac dm.AccesFacture) []dm.PseudoMessage {
	messages := fac.GetEtat(nil, nil).PseudoMessages(dm.POVResponsable)
	// on présente le dernier message en haut
	sort.Slice(messages, func(i, j int) bool {
		return messages[i].Created.Time().After(messages[j].Created.Time())
	})
	lastCo := fac.RawData().LastConnection
	for i, message := range messages {
		messages[i].Vu = isOld(message, lastCo)
	}
	return messages
}

func (ct Controller) getMeta(host string) (out MetaEspacePerso, err error) {
	out.UpdateLimitation = int(UpdateLimitation.Hours())
	out.MailCentreInscription = rd.CoordonnesCentre.Mail
	out.ContrainteVaccin, err = documents.PublieContrainte(ct.Signing, ct.DB, host, ct.contrainteVaccin)
	return
}

func (ct Controller) loadFinances(host string, idFacture int64, base *dm.BaseLocale) (Finances, error) {
	var (
		out               Finances
		err               error
		aides             []Aide
		structuresCrypted map[int64]string
	)

	out.Structureaides, structuresCrypted, err = ct.compileStructureaides(base)
	if err != nil {
		return out, err
	}

	fac := base.NewFacture(idFacture)
	dossiers := fac.GetDossiers(nil)
	_, partsCrypted, err := ct.crypteIds(dossiers)
	if err != nil {
		return out, err
	}

	for _, part := range dossiers {
		aides, err = ct.compileAides(host, partsCrypted[part.Id], structuresCrypted, part.GetAides(nil))
		if err != nil {
			return out, err
		}
		out.Aides = append(out.Aides, aides...)
	}

	for _, paie := range fac.GetPaiements(nil, true) {
		r := paie.RawData()
		out.Paiements = append(out.Paiements, Paiement{
			LabelPayeur:     r.LabelPayeur,
			DateReglement:   r.DateReglement,
			IsInvalide:      r.IsInvalide,
			IsRemboursement: r.IsRemboursement,
			Valeur:          r.Valeur,
			ModePaiement:    r.ModePaiement,
		})
	}

	// bilan financier
	bilan := fac.EtatFinancier(dm.CacheEtatFinancier{}, false)
	apresPaiement := bilan.ApresPaiement()
	var totalSejours, totalAides rd.Euros
	for _, part := range bilan.Participants {
		d := part.EtatFinancier(nil, false)
		totalAides += d.TotalAides().Remise(d.Remises.Pourcent())
		totalSejours += d.PrixSansAide()
	}
	out.EtatFinancier = etatFinancier{
		TotalSejours:   totalSejours,
		TotalAides:     totalAides,
		TotalPaiements: bilan.Recu,
		TotalRestant:   apresPaiement,
	}
	out.LabelVirement = fac.LabelVirement()
	return out, nil
}

func (ct Controller) compileParticipantsPersonnes(host string, mailRespo rd.String, personnesContraintes map[int64]map[int64]rd.Ids,
	crypted map[int64]string, base *dm.BaseLocale) (map[string]Personne, error) {
	personnes := make(map[string]Personne, len(personnesContraintes))
	for idPers, contrainteCamps := range personnesContraintes {
		rawPers := base.Personnes[idPers]
		var vaccins []documents.PublicDocument

		docs := map[int64]ContrainteWithOrigine{}
		// on commence par copier les contraintes demandées
		for idContrainte, idsCamps := range contrainteCamps {
			pubCt, err := documents.PublieContrainte(ct.Signing, ct.DB, host, base.Contraintes[idContrainte])
			if err != nil {
				return nil, err
			}
			docs[idContrainte] = ContrainteWithOrigine{
				ContrainteDocuments: documents.ContrainteDocuments{
					Contrainte: pubCt,
				},
				Origine: idsCamps.AsSet().Keys(), // unicité
			}
		}

		for _, doc := range base.NewPersonne(idPers).GetDocuments(nil) {
			contrainteDoc := doc.GetContrainte()
			isVaccin := contrainteDoc.Builtin == rd.CVaccin
			_, isNeeded := docs[contrainteDoc.Id]
			if !(isVaccin || isNeeded) {
				continue
			}

			docPub, err := documents.PublieDocument(ct.Signing, host, doc.RawData())
			if err != nil {
				return nil, err
			}

			if isVaccin {
				// cas particulier pour les vaccins
				vaccins = append(vaccins, docPub)
			} else if isNeeded {
				// on aggrege les documents présents par contrainte
				cwo := docs[contrainteDoc.Id] // nécessaire si réallocation
				cwo.Docs = append(cwo.Docs, docPub)
				docs[contrainteDoc.Id] = cwo
			}
		}

		isLocked := isFicheSanitaireLocked(mailRespo.String(), rawPers.FicheSanitaire.Mails)
		fsl := LockableFicheSanitaire{Locked: isLocked}
		if isLocked { // seulement les meta données
			fsl.FicheSanitaire.Mails = rawPers.FicheSanitaire.Mails
			fsl.FicheSanitaire.LastModif = rawPers.FicheSanitaire.LastModif
		} else {
			fsl.FicheSanitaire = rawPers.FicheSanitaire
		}
		out := Personne{
			IdCrypted:      crypted[idPers],
			Prenom:         rawPers.FPrenom(),
			NomPrenom:      rawPers.NomPrenom().String(),
			Sexe:           rawPers.Sexe,
			DateNaissance:  rawPers.DateNaissance,
			FicheSanitaire: fsl,
			Vaccins:        vaccins,
			IsTemporaire:   rawPers.IsTemporaire,
		}

		sortByTime := func(l []documents.PublicDocument) {
			sort.Slice(l, func(i int, j int) bool {
				return l[i].DateHeureModif.Time().After(l[j].DateHeureModif.Time())
			})
		}
		sortByTime(out.Vaccins)
		for _, l := range docs {
			sortByTime(l.Docs) // sort in place backing array
			out.Documents = append(out.Documents, l)
		}
		sort.Slice(out.Documents, func(i, j int) bool { // déterministe
			return out.Documents[i].Contrainte.Nom < out.Documents[j].Contrainte.Nom
		})

		personnes[out.IdCrypted] = out
	}
	return personnes, nil
}

func (ct Controller) compileCamps(host string, idsCamps map[int64]bool, base *dm.BaseLocale) (map[int64]CampPlus, error) {
	out := make(map[int64]CampPlus, len(idsCamps))
	for idCamp := range idsCamps {
		rawCamp := base.Camps[idCamp]
		var docs []documents.PublicDocument
		envois := rawCamp.Envois
		acCamp := base.NewCamp(idCamp)
		if !envois.Locked {
			for _, m := range acCamp.GetRegisteredDocuments(envois.LettreDirecteur, true) {
				up, err := documents.PublieDocument(ct.Signing, host, m)
				if err != nil {
					return nil, err
				}
				docs = append(docs, up)
			}
			if envois.ListeParticipants {
				doc, err := documents.MetaDoc{IdCamp: idCamp, Categorie: documents.ListeParticipants}.Share(ct.Signing, host)
				if err != nil {
					return nil, err
				}
				docs = append(docs, doc)
			}
			if envois.ListeVetements {
				doc, err := documents.MetaDoc{IdCamp: idCamp, Categorie: documents.ListeVetements}.Share(ct.Signing, host)
				if err != nil {
					return nil, err
				}
				docs = append(docs, doc)
			}
		}
		mailDirecteur := ""
		if directeur, hasDirecteur := acCamp.GetDirecteur(); hasDirecteur {
			mailDirecteur = directeur.RawData().Mail.String()
		}
		pCamp := CampPlus{
			Documents:     docs,
			MailDirecteur: mailDirecteur,
		}
		pCamp.Camp.From(rawCamp)
		out[rawCamp.Id] = pCamp
	}
	return out, nil
}

func (ct Controller) compileStructureaides(base *dm.BaseLocale) (map[string]Structureaide, map[int64]string, error) {
	out := make(map[string]Structureaide, len(base.Structureaides))
	structures := make(map[int64]string, len(base.Structureaides))

	for _, sa := range base.Structureaides {
		publicSa, err := ct.newStructureaide(sa)
		if err != nil {
			return nil, nil, err
		}
		structures[sa.Id] = publicSa.IdCrypted
		out[publicSa.IdCrypted] = publicSa
	}
	return out, structures, nil
}

// ne remplit les champs IdParticipant et IdStructure
func (ct Controller) shareAide(host string, accesAide dm.AccesAide) (Aide, error) {
	rawAide := accesAide.RawData()
	idC, err := shared.EncodeID(ct.Signing, shared.OrAide, rawAide.Id)
	if err != nil {
		return Aide{}, err
	}
	docs := accesAide.GetDocuments()
	var doc documents.PublicDocument
	if len(docs) > 0 {
		doc, err = documents.PublieDocument(ct.Signing, host, accesAide.Base.Documents[docs[0].Id.Int64()])
		if err != nil {
			return Aide{}, err
		}
	}
	return Aide{
		ChampsAideEditables: ChampsAideEditables{
			IdCrypted:  idC,
			NbJoursMax: rawAide.NbJoursMax,
			Valeur:     rd.Euros(rawAide.Valeur.Round()),
			ParJour:    rawAide.ParJour,
		},
		Valid:          rawAide.Valide,
		ValeurComputed: rd.Euros(accesAide.ValeurEffective(true).Round()),
		Document:       doc,
	}, nil
}

func (ct Controller) compileAides(host, idParticipantCrypted string, structures map[int64]string, aides []dm.AccesAide) ([]Aide, error) {
	out := make([]Aide, len(aides))
	for index, accesAide := range aides {
		aide, err := ct.shareAide(host, accesAide)
		if err != nil {
			return nil, err
		}
		aide.IdParticipantCrypted = idParticipantCrypted
		aide.IdStructureCrypted = structures[accesAide.RawData().IdStructureaide]
		out[index] = aide
	}
	return out, nil
}

func (ct Controller) compileSondages(sondages rd.Sondages) (map[int64]PublicSondage, error) {
	out := make(map[int64]PublicSondage)
	for _, sondage := range sondages {
		publicSd, err := ct.newPublicSondage(sondage)
		if err != nil {
			return nil, err
		}
		out[sondage.IdCamp] = publicSd
	}
	return out, nil
}

func (ct Controller) loadDataFicheSanitaire(idFacture int64, idCrypted string) (respo, pers rd.Personne, err error) {
	id, err := shared.DecodeID(ct.Signing, idCrypted, shared.OrPersonne)
	if err != nil {
		err = shared.FormatErr("Le participant n'a pu être identifié.", err)
		return
	}

	row := ct.DB.QueryRow(`SELECT personnes.* FROM personnes 
		JOIN factures ON factures.id_personne = personnes.id
		WHERE factures.id = $1`, idFacture)
	respo, err = rd.ScanPersonne(row)
	if err != nil {
		err = shared.FormatErr("Le responsable légal est introuvable.", err)
		return
	}
	pers, err = rd.SelectPersonne(ct.DB, id)
	if err != nil {
		err = shared.FormatErr("Le participant est introuvable.", err)
		return
	}
	return respo, pers, nil
}

func (ct Controller) lienPartageFicheSanitaire(host, mail string, idPersonne int64) (string, error) {
	m := partageFicheSanitaire{Mail: mail, IdPersonne: idPersonne}
	s, err := shared.Encode(ct.Signing, m)
	if err != nil {
		return "", shared.FormatErr("Erreur pendant le cryptage des données.", err)
	}
	lien := shared.BuildUrl(host, EndPointPartageFicheSanitaire, map[string]string{
		"target": s,
	})
	return lien, nil
}

// SendMailPartageFicheSanitaire envoie un mail aux adresses autorisées par la fiche sanitaire,
// demandant d'inclure `respoMail`. Le mail contient une url relative à `host`.
func (ct Controller) SendMailPartageFicheSanitaire(host, respoMail string, participant rd.Personne) ([]string, error) {
	urlDebloque, err := ct.lienPartageFicheSanitaire(host, respoMail, participant.Id)
	if err != nil {
		return nil, err
	}
	html, err := mails.NewDebloqueFicheSanitaire(urlDebloque, respoMail, participant.NomPrenom().String())
	if err != nil {
		return nil, shared.FormatErr("La création du mail a échoué", err)
	}
	pool, err := mails.NewPool(ct.SMTP, nil)
	if err != nil {
		return nil, shared.FormatErr("Le serveur de mail est indisponible", err)
	}
	defer pool.Close()
	var errs []string
	for _, mail := range participant.FicheSanitaire.Mails {
		if err = pool.SendMail(mail, "[ACVE] - Partage d'une fiche sanitaire", html, nil, nil); err != nil {
			errs = append(errs, err.Error())
		}
	}
	return errs, nil
}

func (ct Controller) validePartageFicheSanitaire(target string) error {
	var args partageFicheSanitaire
	if err := shared.Decode(ct.Signing, target, &args); err != nil {
		return shared.FormatErr("Le lien semble invalide.", err)
	}
	pers, err := rd.SelectPersonne(ct.DB, args.IdPersonne)
	if err != nil {
		return shared.FormatErr("Le participant est introuvable.", err)
	}
	uniq := rd.StringSet{}
	for _, mail := range pers.FicheSanitaire.Mails {
		uniq[mail] = true
	}
	uniq[args.Mail] = true
	newMails := pq.StringArray(uniq.ToList())
	_, err = ct.DB.Query("UPDATE personnes SET fiche_sanitaire = jsonb_set(fiche_sanitaire, '{mails}', array_to_json($1::varchar[])::jsonb)"+
		"WHERE id = $2", newMails, args.IdPersonne)
	if err != nil {
		return shared.FormatErr("La mise à jour des propriétaires de la fiche a échoué.", err)
	}
	return nil
}

func (ct Controller) updateFicheSanitaire(idFacture int64, params InFicheSanitaire) (OutFicheSanitaire, error) {
	var out OutFicheSanitaire
	respo, pers, err := ct.loadDataFicheSanitaire(idFacture, params.IdCrypted)
	if err != nil {
		return out, err
	}
	if isFicheSanitaireLocked(respo.Mail.String(), pers.FicheSanitaire.Mails) { // impossible normalement
		return out, errors.New("La fiche sanitaire est verrouillée !")
	}
	if pers.IsTemporaire { // impossible normalement
		return out, errors.New("La modification de la fiche sanitaire est désactivée pour les profils temporaires.")
	}
	if len(pers.FicheSanitaire.Mails) == 0 {
		// le premier responsable à modifier devient le proprio de la fiche
		params.FicheSanitaire.Mails = []string{respo.Mail.String()}
	}
	params.FicheSanitaire.LastModif = rd.Time(time.Now())
	tx, err := ct.DB.Begin()
	if err != nil {
		return out, shared.FormatErr("La base de données est injoinable.", err)
	}
	row := tx.QueryRow("UPDATE personnes SET securite_sociale = $1 WHERE id = $2 RETURNING *",
		params.SecuriteSociale, respo.Id)
	respo, err = rd.ScanPersonne(row)
	if err != nil {
		err = shared.FormatErr("Erreur pendant la mise à jour du numéro de sécurité sociale.", err)
		return out, shared.Rollback(tx, err)
	}
	row = tx.QueryRow("UPDATE personnes SET fiche_sanitaire = $1 WHERE id = $2 RETURNING *", params.FicheSanitaire, pers.Id)
	pers, err = rd.ScanPersonne(row)
	if err != nil {
		err = shared.FormatErr("Erreur pendant l'enregistrement de la fiche sanitaire.", err)
		return out, shared.Rollback(tx, err)
	}
	if err = tx.Commit(); err != nil {
		return out, shared.FormatErr("Erreur pendant l'enregistrement de la fiche sanitaire.", err)
	}
	out.SecuriteSociale = respo.SecuriteSociale
	out.FicheSanitaire.FicheSanitaire = pers.FicheSanitaire
	return out, nil
}

func (ct Controller) updateOptionsParticipants(participants []Participant) error {
	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}
	for _, part := range participants {
		id, err := shared.DecodeID(ct.Signing, part.IdCrypted, shared.OrParticipant)
		if err != nil {
			err = shared.FormatErr("Les identifiants sont corrompus.", err)
			return shared.Rollback(tx, err)
		}
		row := tx.QueryRow(`SELECT * FROM camps 
			JOIN participants ON participants.id_camp = camps.id 
			WHERE participants.id = $1`, id)
		camp, err := rd.ScanCamp(row)
		if err != nil {
			err = shared.FormatErr("Le camp est introuvable.", err)
			return shared.Rollback(tx, err)
		}
		if time.Until(camp.DateDebut.Time()) < UpdateLimitation {
			err = fmt.Errorf("Les modifications sur le séjour %s sont maintenant désactivées.", camp.Label())
			return shared.Rollback(tx, err)
		}
		_, err = tx.Exec("UPDATE participants SET options = $1 WHERE id = $2", part.Options, id)
		if err != nil {
			err = shared.FormatErr("La modification des options a échoué.", err)
			return shared.Rollback(tx, err)
		}
	}

	if err = tx.Commit(); err != nil {
		return shared.FormatErr("Les modifications n'ont pas pu être enregistrées.", err)
	}
	return nil
}

func (ct Controller) loadJoomeo(idFacture int64) (JoomeoOutput, error) {
	var out JoomeoOutput
	row := ct.DB.QueryRow(`SELECT mail FROM personnes 
	JOIN factures ON factures.id_personne = personnes.id
	WHERE factures.id = $1`, idFacture)
	var mail string
	if err := row.Scan(&mail); err != nil {
		return out, shared.FormatErr("L'adresse mail liée à votre dossier n'a pu être retrouvée.", err)
	}

	api, err := joomeo.InitApi(ct.joomeo)
	if err != nil {
		return out, shared.FormatErr("Le serveur Joomeo est indisponible.", err)
	}
	defer api.Kill()
	out.UrlSpace = api.SpaceURL

	contact, albums, err := api.GetLoginFromMail(mail)
	if err != nil {
		return out, shared.FormatErr("L'accès à vos informations Joomeo a échoué.", err)
	}
	out.Loggin = contact.Login
	out.Password = contact.Password
	out.Albums = albums
	return out, nil
}

// dispatch entre acquittée ou non
func (ct Controller) downloadFacture(idFacture int64, indexDestinataire int) ([]byte, string, error) {
	// on rassemble les données
	base, err := ct.loadData(idFacture)
	if err != nil {
		return nil, "", err
	}
	ac := base.NewFacture(idFacture)
	// dans tous les cas, on crée le pdf en mémoire vive
	destinataire, err := ac.ChoixDestinataires().Index(indexDestinataire)
	if err != nil {
		return nil, "", err
	}
	meta := cd.Facture{
		Destinataire: destinataire,
		Bilan:        ac.EtatFinancier(dm.CacheEtatFinancier{}, false),
	}
	file, err := meta.Generate()
	if err != nil {
		return nil, "", err
	}
	if ac.EtatFinancier(dm.CacheEtatFinancier{}, false).IsAcquitte() {
		err = ct.markFactureAcquittee(idFacture, base.Messages, base.MessageAttestations)
	} else {
		err = ct.markFactureCourante(base.Messages)
	}
	return file, meta.FileName(), err
}

// met à jour les message concernés : messages "Facture"
// n'ayant pas encore été modifiés
func (ct Controller) markFactureCourante(messages rd.Messages) error {
	// logique côté serveur
	var ids rd.Ids
	for _, message := range messages {
		isNotModified := message.Modified.Time().IsZero()
		isFacture := message.Kind == rd.MFacture
		if isFacture && isNotModified {
			ids = append(ids, message.Id)
		}
	}
	_, err := ct.DB.Exec("UPDATE messages SET modified = now() WHERE id = ANY($1)", ids.AsSQL())
	return err
}

// met à jour les messages concernés
func (ct Controller) markFactureAcquittee(idFacture int64, messages rd.Messages, messageAttestations map[int64]rd.MessageAttestation) error {
	return ct.markAttestation(rd.MFactureAcquittee, idFacture, messages, messageAttestations)
}

// indexDestinataire fait référence à ChoixDestinataire
func (ct Controller) downloadAttestationPresence(idFacture int64, indexDestinataire int) ([]byte, error) {
	// on rassemble les données
	base, err := ct.loadData(idFacture)
	if err != nil {
		return nil, err
	}
	ac := base.NewFacture(idFacture)
	// on vérifie que le séjour est terminé pour tout les participants inscrits
	now := time.Now()
	for _, part := range ac.GetDossiers(nil) {
		if part.RawData().ListeAttente.IsInscrit() && part.GetCamp().RawData().DateFin.Time().After(now) {
			return nil, fmt.Errorf("Le séjour %s n'est pas encore terminé.", part.GetCamp().RawData().Label())
		}
	}
	destinataire, err := ac.ChoixDestinataires().Index(indexDestinataire)
	if err != nil {
		return nil, err
	}
	meta := cd.Presence{
		Destinataire: destinataire,
		// uniquement inscrits
		Participants: ac.EtatFinancier(dm.CacheEtatFinancier{}, false).Participants,
	}
	doc, err := meta.Generate()
	if err != nil {
		return nil, err
	}
	err = ct.markAttestation(rd.MAttestationPresence, idFacture, base.Messages, base.MessageAttestations)
	return doc, err
}

// kind est FactureAc ou AttestationPres
func (ct Controller) markAttestation(targetKind rd.MessageKind, idFacture int64, messages rd.Messages, messageAttestations map[int64]rd.MessageAttestation) error {
	// on cherche les nouveaux mails annoncant une attestation
	var ids rd.Ids
	for _, message := range messages {
		isAttest := message.Kind == targetKind
		isMail := messageAttestations[message.Id].Distribution == rd.DMail
		if isAttest && isMail {
			ids = append(ids, message.Id)
		}
	}

	tx, err := ct.DB.Begin()
	if err != nil {
		return err
	}

	if len(ids) == 0 {
		// il n'y a pas de nouveau mail, on crée un message
		// pour garder trace du téléchargement
		message := rd.Message{
			IdFacture: idFacture,
			Created:   rd.Time(time.Now()),
			Kind:      targetKind,
		}
		message, err = message.Insert(tx)
		if err != nil {
			return shared.Rollback(tx, err)
		}
		dist := rd.MessageAttestation{IdMessage: message.Id, Distribution: rd.DEspacePerso, GuardKind: message.Kind}
		err = rd.InsertManyMessageAttestations(tx, dist)
	} else {
		// on met à jour les messages courants ...
		_, err = tx.Exec("UPDATE messages SET modified = now() WHERE id = ANY($1)", ids.AsSQL())
		if err != nil {
			return shared.Rollback(tx, err)
		}
		// ... et les compléments
		_, err = tx.Exec("UPDATE message_attestations SET distribution = $1 WHERE id_message = ANY($2)", rd.DMailAndDownload, ids.AsSQL())
	}
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}

func (ct Controller) markConnection(idFacture int64) error {
	_, err := ct.DB.Exec("UPDATE factures SET last_connection = now() WHERE id = $1", idFacture)
	return err
}

// vérifie que le camp est "ouvert au sondage" pour le dossier
func (ct Controller) isSondageOpen(idFacture, idCamp int64) (bool, error) {
	rows, err := ct.DB.Query(`SELECT message_sondages.* FROM message_sondages
	JOIN messages ON message_sondages.id_message = messages.id
	WHERE messages.id_facture = $1 AND messages.kind = $2`, idFacture, rd.MSondage)
	if err != nil {
		return false, err
	}
	messages, err := rd.ScanMessageSondages(rows)
	if err != nil {
		return false, err
	}
	for _, message := range messages {
		if message.IdCamp == idCamp {
			return true, nil
		}
	}
	return false, nil
}

// update or create
func (ct Controller) saveSondage(host string, idFacture int64, sondage PublicSondage) (PublicSondage, error) {
	// on vérifie que le camp est "ouvert au sondage" pour le dossier
	isOpen, err := ct.isSondageOpen(idFacture, sondage.IdCamp)
	if err != nil {
		return PublicSondage{}, fmt.Errorf("Impossible de vérifier l'état du séjour : %s", err)
	}
	if !isOpen {
		return PublicSondage{}, fmt.Errorf("Le séjour (%d) n'enregistre pas de retours.", sondage.IdCamp)
	}

	var sd rd.Sondage
	tx, err := ct.DB.Begin()
	if err != nil {
		return PublicSondage{}, err
	}

	if sondage.IdCrypted == "" { // créé un retour
		sd = rd.Sondage{
			IdCamp:     sondage.IdCamp,
			IdFacture:  idFacture,
			Modified:   time.Now(),
			RepSondage: sondage.RepSondage,
		}
		sd, err = sd.Insert(tx)
		if err != nil {
			return PublicSondage{}, shared.Rollback(tx, err)
		}
	} else { // on décrypte l'id et on modifie
		var id int64
		id, err = shared.DecodeID(ct.Signing, sondage.IdCrypted, shared.OrSondage)
		if err != nil {
			return PublicSondage{}, shared.Rollback(tx, err)
		}
		sd, err = rd.SelectSondage(tx, id)
		if err != nil {
			return PublicSondage{}, shared.Rollback(tx, err)
		}
		// sécurité : on modifie juste le contenu
		sd.RepSondage = sondage.RepSondage
		sd.Modified = time.Now()
		sd, err = sd.Update(tx)
		if err != nil {
			return PublicSondage{}, shared.Rollback(tx, err)
		}
	}
	// Si le mail de notification échoue, on préfère annuler
	// le sondage, pour être certain que les sondages enregistrés
	// sont bien traités
	if err := ct.sondageNotifier.Notifie(host, sd); err != nil {
		return PublicSondage{}, shared.Rollback(tx, err)
	}
	out, err := ct.newPublicSondage(sd)
	if err != nil {
		return PublicSondage{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}