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

package directeurs

import (
	"bytes"
	"errors"
	"fmt"
	"path"
	"sort"
	"time"

	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/pdf"
	"github.com/benoitkugler/goACVE/server/core/utils/table"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/labstack/echo"
)

// ResumeMessage simplifie l'affichage des messages
// pour le directeur.
type ResumeMessage struct {
	Label   string         `json:"label"`
	Created time.Time      `json:"created"`
	Contenu string         `json:"contenu"`
	Kind    rd.MessageKind `json:"kind"`
}

type Responsable struct {
	Valide            bool            `json:"valide"`
	Id                int64           `json:"id"`
	Nom               string          `json:"nom"`
	Prenom            string          `json:"prenom"`
	Mail              string          `json:"mail"`
	MailsCopies       []string        `json:"mails_copies"`
	Tels              string          `json:"tels"`
	Adresse           string          `json:"adresse"`
	CodePostal        string          `json:"code_postal"`
	Ville             string          `json:"ville"`
	PaiementComplet   rd.Completion   `json:"paiement_complet"`
	Messages          []ResumeMessage `json:"messages"`
	InscriptionValide bool            `json:"inscription_valide"`
}

type InscritWritable struct {
	IdGroupe rd.OptionnalId        `json:"id_groupe"`
	Options  rd.OptionsParticipant `json:"options"`
	Mail     string                `json:"mail"`
}

func (i InscritWritable) ToPersonneParticipant(personne *rd.BasePersonne, participant *rd.Participant) {
	participant.Options = i.Options

	personne.Mail = rd.String(i.Mail)
}

type Inscrit struct {
	InscritWritable

	Id int64 `json:"id"`

	IsAttente       bool `json:"is_attente"`
	HasAnniversaire bool `json:"has_anniversaire"`
	AgeDebutCamp    int  `json:"age_debut_camp"`

	Responsable Responsable `json:"responsable"`

	Nom           string  `json:"nom"`
	Prenom        string  `json:"prenom"`
	Sexe          rd.Sexe `json:"sexe"`
	DateNaissance rd.Date `json:"date_naissance"`

	// Fiche sanitaire et vaccins
	FicheSanitaire           rd.FicheSanitaire          `json:"fiche_sanitaire"`
	Vaccins                  []documents.PublicDocument `json:"vaccins"`
	IsFicheSanitaireUpToDate rd.OptionnalBool           `json:"is_fiche_sanitaire_up_to_date"`
	LienFicheSanitaire       string                     `json:"lien_fiche_sanitaire"`

	// Pour les participants simples
	Info rd.String `json:"info"`
}

type optionsExportExcel struct {
	bus         rd.Bus
	triGroupe   bool
	withAttente bool
	showColors  bool
	simple      bool
}

func newOptionsExportExcel(c echo.Context) optionsExportExcel {
	return optionsExportExcel{
		bus:         rd.Bus(c.QueryParam("bus")),
		triGroupe:   c.QueryParam("with_groupe") != "",
		withAttente: c.QueryParam("with_attente") != "",
		showColors:  c.QueryParam("show_colors") != "",
		simple:      c.QueryParam("simple") != "",
	}
}

// charge les infos de base et met à jour `base`
// (fonctionnalité partagée avec joomeo)
func (rc DriverCampComplet) loadInscritsResponsables() error {
	groupes, campContraintes, groupesContraintes, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return err
	}

	rows, err := rc.DB.Query(`SELECT factures.* FROM factures
		JOIN participants ON participants.id_facture = factures.id 	
		WHERE participants.id_camp = $1`, rc.camp.Id)
	if err != nil {
		return err
	}
	factures, err := rd.ScanFactures(rows)
	if err != nil {
		return err
	}

	// on charge les participants : concernés directement ou via un dossier
	rows, err = rc.DB.Query("SELECT * FROM participants WHERE id_camp = $1 OR id_facture = ANY($2)", rc.camp.Id, factures.Ids().AsSQL())
	if err != nil {
		return err
	}
	participants, err := rd.ScanParticipants(rows)
	if err != nil {
		return err
	}

	// les personnes sont les responsables et les participants (même indirects)
	rows, err = rc.DB.Query(`SELECT * FROM personnes WHERE 
		id = ANY(SELECT id_personne FROM factures WHERE id = ANY($1)) OR
		id = ANY(SELECT id_personne FROM participants WHERE id = ANY($2))`,
		factures.Ids().AsSQL(), participants.Ids().AsSQL())
	if err != nil {
		return err
	}
	personnes, err := rd.ScanPersonnes(rows)
	if err != nil {
		return err
	}

	rc.camp.Base.Groupes = groupes
	rc.camp.Base.GroupeContraintes = groupesContraintes.ByIdGroupe()
	rc.camp.Base.CampContraintes = campContraintes.ByIdCamp()
	rc.camp.Base.Personnes = personnes
	rc.camp.Base.Participants = participants
	rc.camp.Base.Factures = factures
	return nil
}

// renvoie les données nécessaires aux inscrits (dont informations financières et documents)
func (d DriverCampComplet) loadDataInscrits() error {
	err := d.loadInscritsResponsables()
	if err != nil {
		return err
	}

	aides, err := rd.SelectAidesByIdParticipants(d.DB, d.camp.Base.Participants.Ids()...)
	if err != nil {
		return err
	}

	structures, err := rd.SelectAllStructureaides(d.DB) // on peut se permettre de tout renvoyer, la table est petite.
	if err != nil {
		return err
	}

	paiements, err := rd.SelectPaiementsByIdFactures(d.DB, d.camp.Base.Factures.Ids()...)
	if err != nil {
		return err
	}

	docs, err := d.LoadDocuments(d.camp.Base.Personnes.Ids())
	if err != nil {
		return err
	}

	if err = d.loadMessages(); err != nil {
		return err
	}

	// répartitions des groupes
	groupeParticipants, err := rd.SelectGroupeParticipantsByIdCamps(d.DB, d.camp.Id)
	if err != nil {
		return err
	}

	// ajout des animateurs de référence
	participantEquipiers, err := rd.SelectParticipantEquipiersByIdParticipants(d.DB, d.camp.Base.Participants.Ids()...)
	if err != nil {
		return err
	}

	d.camp.Base.Contraintes = docs.Contraintes
	d.camp.Base.Paiements = paiements
	d.camp.Base.Aides = aides
	d.camp.Base.Structureaides = structures
	d.camp.Base.Documents = docs.Documents
	d.camp.Base.DocumentPersonnes = docs.Liens
	d.camp.Base.ParticipantGroupe = groupeParticipants.ByIdParticipant()
	d.camp.Base.ParticipantEquipier = participantEquipiers.ByIdParticipant()
	return nil
}

func (d DriverCampComplet) loadMessages() error {
	messages, err := rd.SelectMessagesByIdFactures(d.DB, d.camp.Base.Factures.Ids()...)
	if err != nil {
		return err
	}

	mAttestations, err := rd.SelectMessageAttestationsByIdMessages(d.DB, messages.Ids()...)
	if err != nil {
		return err
	}
	mDocuments, err := rd.SelectMessageDocumentsByIdMessages(d.DB, messages.Ids()...)
	if err != nil {
		return err
	}
	mMessages, err := rd.SelectMessageMessagesByIdMessages(d.DB, messages.Ids()...)
	if err != nil {
		return err
	}
	mSondages, err := rd.SelectMessageSondagesByIdMessages(d.DB, messages.Ids()...)
	if err != nil {
		return err
	}
	mPlaceliberes, err := rd.SelectMessagePlaceliberesByIdMessages(d.DB, messages.Ids()...)
	if err != nil {
		return err
	}

	d.camp.Base.Messages = messages
	d.camp.Base.MessageAttestations = mAttestations.ByIdMessage()
	d.camp.Base.MessageDocuments = mDocuments.ByIdMessage()
	d.camp.Base.MessageMessages = mMessages.ByIdMessage()
	d.camp.Base.MessageSondages = mSondages.ByIdMessage()
	d.camp.Base.MessagePlaceliberes = mPlaceliberes.ByIdMessage()
	return nil
}

// lien vers l'espace perso, avec un tag pour éviter de marquer la connexion
// a maintenir synchronisé avec le frontend espace_perso
func getLienFicheSanitaire(host string, fac rd.Facture, nomPrenom string) string {
	pathFs := path.Join(fac.UrlEspacePerso("espace_perso"), "fiches_sanitaires")
	return shared.BuildUrl(host, pathFs, map[string]string{
		"directeur":  "ok",
		"nom_prenom": nomPrenom,
	})
}

func (d DriverCampComplet) getInscrits(host string) ([]Inscrit, error) {
	insc := append(d.camp.GetInscrits(nil), d.camp.GetAttente(nil)...)
	out := make([]Inscrit, len(insc))
	cache := d.camp.Base.ResoudDocumentsPersonnes()
	cache2, cache3 := d.camp.Base.ResoudMessages(), d.camp.Base.ResoudPaiements()
	_, cache4 := d.camp.Base.ResoudParticipants()

	for index, part := range insc {
		var (
			respo              Responsable
			lienFicheSanitaire string
		)
		rawPart, pers := part.RawData(), part.GetPersonne()

		if fac, has := part.GetFacture(); has {
			persResp := fac.GetPersonne().AsItem(0)
			respo.Valide = true
			respo.Id = fac.Id
			respo.Nom = persResp.Fields.Data(dm.PersonneNom).String()
			respo.Prenom = persResp.Fields.Data(dm.PersonnePrenom).String()
			respo.Mail = persResp.Fields.Data(dm.PersonneMail).String()
			respo.MailsCopies = fac.RawData().CopiesMails
			respo.Tels = persResp.Fields.Data(dm.PersonneTels).String()
			respo.Adresse = persResp.Fields.Data(dm.PersonneAdresse).String()
			respo.CodePostal = persResp.Fields.Data(dm.PersonneCodePostal).String()
			respo.Ville = persResp.Fields.Data(dm.PersonneVille).String()
			respo.PaiementComplet = fac.EtatFinancier(dm.CacheEtatFinancier{}, false).StatutPaiement()
			respo.InscriptionValide = fac.RawData().IsValidated
			lienFicheSanitaire = getLienFicheSanitaire(host, fac.RawData(), pers.RawData().NomPrenom().String())

			for _, message := range fac.GetEtat(cache2, cache3).PseudoMessages(dm.POVCentre) {
				str, _ := message.Contenu.(dm.ContenuPerso) // simple
				respo.Messages = append(respo.Messages, ResumeMessage{
					Kind:    message.Kind,
					Label:   message.Label,
					Contenu: string(str), // souvent zero
					Created: message.Created.Time(),
				})
			}
		}

		var vaccins []documents.PublicDocument
		for _, doc := range pers.GetDocuments(cache) {
			lien := doc.GetContrainte()
			if lien.Builtin == rd.CVaccin {
				publicDoc, err := documents.PublieDocument(d.Signing, host, doc.RawData())
				if err != nil {
					return nil, err
				}
				vaccins = append(vaccins, publicDoc)
			}
		}
		partFields := part.AsItem(cache4).Fields
		groupe, hasGroupe := part.GetGroupe()
		var idGroupe rd.OptionnalId
		if hasGroupe {
			idGroupe = rd.NewOptionnalId(groupe.Id)
		}
		out[index] = Inscrit{
			Id: part.Id,
			InscritWritable: InscritWritable{
				Options:  rawPart.Options,
				Mail:     pers.RawData().Mail.String(),
				IdGroupe: idGroupe,
			},
			IsAttente:                !rawPart.ListeAttente.IsInscrit(),
			AgeDebutCamp:             part.AgeDebutCamp().Age(),
			HasAnniversaire:          part.HasAnniversaire(),
			Nom:                      partFields.Data(dm.PersonneNom).String(),
			Prenom:                   partFields.Data(dm.PersonnePrenom).String(),
			Sexe:                     pers.RawData().Sexe,
			DateNaissance:            pers.RawData().DateNaissance,
			FicheSanitaire:           pers.RawData().FicheSanitaire,
			Vaccins:                  vaccins,
			Responsable:              respo,
			IsFicheSanitaireUpToDate: part.IsFicheSanitaireUpToDate(),
			LienFicheSanitaire:       lienFicheSanitaire,
		}
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].Nom+out[i].Prenom < out[j].Nom+out[j].Prenom
	})
	return out, nil
}

// -------------------- Fiches sanitaires  ----------------------------------

// renvoie les données nécessaires
func fetchFicheSanitaire(part dm.AccesParticipant) (personne, responsable rd.Personne, nom string, err error) {
	personne = part.GetPersonne().RawData()
	fac, has := part.GetFacture()
	if !has {
		err = errors.New(`Le participant n'est pas suivi par un dossier. 
		La fiche sanitaire ne peut pas être modifiée dans ce cas, cette situation ne devrait pas donc se produire.
		Pouvez-vous le signaler (au centre d'inscriptions ou par mail) ?`)
		return
	}
	responsable = fac.GetPersonne().RawData()
	nom = reduitNom(personne.NomPrenom().String())
	return
}

func (d DriverCampComplet) downloadFicheSanitaire(idParticipant int64) (*bytes.Buffer, string, error) {
	pers, resp, s, err := fetchFicheSanitaire(d.camp.Base.NewParticipant(idParticipant))
	s = fmt.Sprintf("fiche_sanitaire_%s.pdf", s)
	out := new(bytes.Buffer)
	if err == nil {
		err = pdf.FicheSanitaire(pers, resp, out)
	}
	return out, s, err
}

func filterPartsFicheSanitaire(camp dm.AccesCamp, onlyMineurs, triGroupe bool) []dm.AccesParticipant {
	insc, att := camp.GetInscrits(nil), camp.GetAttente(nil)
	dm.TriParticipants(insc, triGroupe)
	dm.TriParticipants(att, triGroupe)
	var final []dm.AccesParticipant
	for _, part := range append(insc, att...) {
		if onlyMineurs && part.AgeDebutCamp().Age() >= 18 {
			continue
		}
		if part.GetPersonne().RawData().FicheSanitaire.IsNone() {
			continue
		}
		final = append(final, part)
	}
	return final
}

// downloadFichesSanitaires regroupe les fiches sanitaires et les vaccins
// (contrairement à `downloadFicheSanitaire`)
func (d DriverCampComplet) downloadFichesSanitaires(onlyMineurs bool) (*bytes.Buffer, error) {
	insc := filterPartsFicheSanitaire(d.camp, onlyMineurs, false)

	archive := cd.NewArchiveZip()

	for _, part := range insc {
		pers, resp, proprio, err := fetchFicheSanitaire(part)
		if err != nil {
			return nil, err
		}
		content := new(bytes.Buffer)
		err = pdf.FicheSanitaire(pers, resp, content)
		if err != nil {
			return nil, err
		}
		filename := fmt.Sprintf("%s_fiche_sanitaire.pdf", proprio)
		archive.AddFile(filename, content)
		var idsVaccins []int64
		acPers := part.GetPersonne()
		for _, doc := range acPers.GetDocuments(nil) {
			if doc.GetContrainte().Builtin == rd.CVaccin {
				idsVaccins = append(idsVaccins, doc.Id)
			}
		}
		archive.Renamer = func(s string) string {
			return fmt.Sprintf("%s_vaccin_%s", proprio, s)
		}
		if err = documents.LoadDocsAndAdd(d.DB, idsVaccins, archive, nil); err != nil {
			return nil, err
		}
	}
	return archive.Close()
}

func (d DriverCampComplet) downloadFichesSanitairesOneDocument(onlyMineurs, triGroupe bool) (*bytes.Buffer, error) {
	insc := filterPartsFicheSanitaire(d.camp, onlyMineurs, triGroupe)
	var personnes, responsables []rd.Personne
	for _, part := range insc {
		pers, resp, _, err := fetchFicheSanitaire(part)
		if err != nil {
			return nil, err
		}
		personnes, responsables = append(personnes, pers), append(responsables, resp)
	}
	buf := new(bytes.Buffer)
	err := pdf.FicheSanitaires(personnes, responsables, buf)
	return buf, err
}

func (d DriverCampComplet) modifieInscrit(modif InscritWritable, id int64) error {
	if modif.IdGroupe.Valid && d.camp.Base.Groupes[modif.IdGroupe.Int64].IdCamp != d.camp.Id {
		return fmt.Errorf("Le groupe (%d) n'est pas lié au séjour", modif.IdGroupe.Int64)
	}

	tx, err := d.DB.Begin()
	if err != nil {
		return err
	}
	participant, err := rd.SelectParticipant(tx, id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	personne, err := rd.SelectPersonne(tx, participant.IdPersonne)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	modif.ToPersonneParticipant(&personne.BasePersonne, &participant)
	participant, err = participant.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	personne, err = personne.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// mise à jour locale
	d.camp.Base.Participants[participant.Id] = participant
	d.camp.Base.Personnes[personne.Id] = personne

	// modification du groupe

	gp, hasGroupe, err := rd.SelectGroupeParticipantByIdParticipant(tx, participant.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// dans le cas ou on ne change pas de groupe, on ne supprime pas l'animateur de référence éventuel
	noChange := hasGroupe && modif.IdGroupe.Valid && (gp.IdGroupe == modif.IdGroupe.Int64)

	if !noChange { // on supprime le groupe et l'animateur de référence
		_, err = rd.DeleteParticipantEquipiersByIdParticipants(tx, participant.Id)
		if err != nil {
			return shared.Rollback(tx, err)
		}
		_, err = rd.DeleteGroupeParticipantsByIdParticipants(tx, participant.Id)
		if err != nil {
			return shared.Rollback(tx, err)
		}
		delete(d.camp.Base.ParticipantGroupe, participant.Id)
	}

	if idGroupe := modif.IdGroupe; !noChange && idGroupe.Valid { // on ajoute un lien
		// le mode manuel est activé si la modification est différente du groupe actuel
		// ou que le mode est déjà manuel
		manuel := gp.Manuel || gp.IdGroupe != idGroupe.Int64
		gp = rd.GroupeParticipant{IdCamp: participant.IdCamp, IdParticipant: participant.Id, IdGroupe: idGroupe.Int64, Manuel: manuel}
		err = rd.InsertManyGroupeParticipants(tx, gp)
		if err != nil {
			return shared.Rollback(tx, err)
		}
		d.camp.Base.ParticipantGroupe[participant.Id] = gp // mise à jour locale
	}

	err = tx.Commit()
	return err
}

func (d DriverCampComplet) exportListeInscrits(options optionsExportExcel) (*bytes.Buffer, error) {
	// les animateurs nécéssitent les équipiers
	personnes, equipiers, err := d.scanDataEquipiers()
	if err != nil {
		return nil, err
	}
	// fusion avec existant
	for _, personne := range personnes {
		d.camp.Base.Personnes[personne.Id] = personne
	}
	d.camp.Base.Equipiers = equipiers

	inscrits, attente := d.camp.GetListes(options.triGroupe, options.bus, true, false)
	if !options.withAttente {
		attente = nil
	}
	hideColumns := func(header []rd.Header, ignoreFields ...rd.Field) []rd.Header {
		var out []rd.Header
		ignore := map[rd.Field]bool{}
		for _, field := range ignoreFields {
			ignore[field] = true
		}
		for _, h := range header {
			if ignore[h.Field] {
				continue
			}
			out = append(out, h)
		}
		return out
	}

	// choisit un mode simplifié
	headerInscrit := HeaderExportInscrits
	if options.simple {
		headerInscrit = HeaderExportInscritsSimple
	}
	headerResponsable := HeaderExportResponsables
	if options.simple {
		headerResponsable = HeaderExportResponsablesSimple
	}

	// enlève les champs inutile
	var ignoreFields []rd.Field
	if showBus := d.camp.RawData().Options.Bus.Actif; !showBus {
		ignoreFields = append(ignoreFields, dm.ParticipantBus)
	}
	if showSki := d.camp.RawData().Options.MaterielSki.Actif; !showSki {
		ignoreFields = append(ignoreFields, dm.ParticipantMaterielSki, dm.ParticipantMaterielSkiType)
	}
	if showGroupes := len(d.camp.GetGroupes()) > 0; !showGroupes {
		ignoreFields = append(ignoreFields, dm.ParticipantGroupe, dm.ParticipantAnimateur)
	}
	if hasOption := d.camp.RawData().OptionPrix.Active != ""; !hasOption {
		ignoreFields = append(ignoreFields, dm.ParticipantOptionPrix)
	}
	headerInscrit = hideColumns(headerInscrit, ignoreFields...)

	return table.GenereListeParticipants(headerInscrit, headerResponsable,
		inscrits, attente, options.showColors)
}

func (d DriverCampComplet) exportListeFinances() (*bytes.Buffer, error) {
	parts, totalDemande, totalAides := d.camp.Base.SuiviFinancier(d.camp)
	return table.GenereSuiviFinancierCamp(cd.HeadersSuiviParticipants, parts, totalDemande, totalAides)
}