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

package directeurs

import (
	"bytes"
	"database/sql"
	"errors"
	"fmt"
	"path"
	"sort"
	"strings"

	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/benoitkugler/goACVE/server/core/utils/table"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
)

type ResultatRecherche struct {
	Id            int64     `json:"id"`
	Nom           rd.String `json:"nom"`
	Prenom        rd.String `json:"prenom"`
	DateNaissance string    `json:"date_naissance"`
	Pertinence    uint8     `json:"pertinence"` // en %
}

type EquipierDirecteur struct {
	shared.BaseEquipier

	Id             int64    `json:"id"`
	LienFormulaire string   `json:"lien_formulaire"`
	Roles          rd.Roles `json:"roles"`
	IsSb           rd.Bool  `json:"is_sb"`
}

func FromPersonneEquipier(personne rd.Personne, equipier rd.Equipier) EquipierDirecteur {
	out := EquipierDirecteur{BaseEquipier: shared.FromPersonneEquipier(personne, equipier)}

	out.Id = equipier.Id
	out.Roles = equipier.Roles

	return out
}

func (e EquipierDirecteur) ToPersonneEquipier(personne *rd.BasePersonne, equipier *rd.Equipier) {
	e.BaseEquipier.ToPersonneEquipier(personne, equipier)
	equipier.Roles = e.Roles
}

func (rc DriverCampComplet) scanDataEquipiers() (rd.Personnes, rd.Equipiers, error) {
	equipiers, err := rd.SelectEquipiersByIdCamps(rc.DB, rc.camp.Id)
	if err != nil {
		return nil, nil, err
	}

	rows, err := rc.DB.Query(`SELECT personnes.* FROM personnes 
		JOIN equipiers ON equipiers.id_personne = personnes.id
		WHERE equipiers.id = ANY($1)`, equipiers.Ids().AsSQL())
	if err != nil {
		return nil, nil, err
	}
	personnes, err := rd.ScanPersonnes(rows)
	return personnes, equipiers, err
}

// renvoie les données nécessaires à la base locale, pour les équipiers.
func (rc DriverCampComplet) loadDataEquipiers() error {
	personnes, equipiers, err := rc.scanDataEquipiers()

	// contraintes des équipiers
	equipierContraintes, err := rd.SelectEquipierContraintesByIdEquipiers(rc.DB, equipiers.Ids()...)
	if err != nil {
		return err
	}

	rc.camp.Base.Personnes = personnes
	rc.camp.Base.Equipiers = equipiers
	rc.camp.Base.EquipierContraintes = equipierContraintes.ByIdEquipier()
	return err
}

// charge en plus les données nécessaires aux pièces justificatives
func (d DriverCampComplet) loadDataDocumentsEquipiers() error {
	base := d.camp.Base

	// documents présents
	docs, err := d.LoadDocuments(base.Personnes.Ids())
	if err != nil {
		return err
	}

	// les contraintes (possibles) sont déjà chargées une fois pour toute
	contraintes := make(rd.Contraintes)
	for _, contrainte := range d.contraintesEquipiers {
		contraintes[contrainte.Id] = contrainte
	}

	base.Documents = docs.Documents
	base.DocumentPersonnes = docs.Liens
	base.Contraintes = contraintes
	return nil
}

// getPiecesJustificatives compile les documents et exigences
func (d DriverCampComplet) getPiecesJustificatives(host string) (Pieces, error) {
	err := d.loadDataDocumentsEquipiers()
	if err != nil {
		return Pieces{}, err
	}

	out := Pieces{Contraintes: d.contraintesEquipiers}

	cache := d.camp.Base.ResoudDocumentsPersonnes()
	equipiers := d.camp.GetEquipe(nil)
	out.Documents = make([]EquipierDocuments, len(equipiers))
	for index, equipier := range equipiers {
		docs := equipier.GetPersonne().GetDocuments(cache)
		publicDocs, err := d.compileDocs(host, docs)
		if err != nil {
			return Pieces{}, err
		}
		out.Documents[index] = EquipierDocuments{
			Contraintes: equipier.GetContraintes(),
			IdEquipier:  equipier.Id,
			NomPrenom:   equipier.GetPersonne().RawData().NomPrenom().String(),
			Documents:   publicDocs,
		}
	}
	sort.Slice(out.Documents, func(i int, j int) bool {
		return out.Documents[i].NomPrenom < out.Documents[j].NomPrenom
	})
	return out, nil
}

// setExigenceDocument met à jour une exigence sur un équipier
// la base locale n'est pas mise à jour
func (d DriverCampComplet) setExigenceDocument(params UpdateContrainteEquipierIn) error {
	if _, isKnow := d.contraintesEquipiers[params.IdContrainte]; !isKnow {
		return fmt.Errorf("La catégorie du document à fournir est inconnue (id %d)", params.IdContrainte)
	}

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

	// on supprime l'éventuelle contrainte actuelle pour l' équipier ...
	ct := rd.EquipierContrainte{IdContrainte: params.IdContrainte, IdEquipier: params.IdEquipier}
	err = ct.Delete(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// ... puis on inscrit la nouvelle si nécessaire
	if params.Demande != rd.OBNon {
		ct.Optionnel = params.Demande == rd.OBPeutEtre
		err = rd.InsertManyEquipierContraintes(tx, ct)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}

	err = tx.Commit()
	return err
}

func (d DriverCampComplet) creeDocumentEquipier(host string, idEquipier int64, params documents.ParamsNewDocument) (documents.PublicDocument, error) {
	return documents.CreeDocumentEquipier(d.Signing, d.DB, host, idEquipier, params)
}

func (d DriverCampComplet) downloadDocumentsEquipiers(onlyRequis bool) (*bytes.Buffer, error) {
	if err := d.loadDataDocumentsEquipiers(); err != nil {
		return nil, err
	}
	idsDocs, prefixes := d.analyseDocsRequis(onlyRequis)
	return d.packageDocs(idsDocs, prefixes)
}

// requiert d'avoir chargé les données documents
func (d DriverCampComplet) analyseDocsRequis(onlyRequis bool) ([]int64, map[int64]string) {
	criblePers := map[int64]rd.Set{} // id personne -> id contraintes
	for _, equipier := range d.camp.GetEquipe(nil) {
		idPersonne := equipier.GetPersonne().Id
		if onlyRequis {
			criblePers[idPersonne] = equipier.GetContraintes().AsIds().AsSet()
		} else {
			criblePers[idPersonne] = d.contraintesEquipiers.Ids().AsSet()
		}
	}
	var docsIds rd.Ids
	prefixes := map[int64]string{}
	for _, doc := range d.camp.Base.DocumentPersonnes {
		if criblePers[doc.IdPersonne][doc.IdContrainte] {
			docsIds = append(docsIds, doc.IdDocument)
			prefixes[doc.IdDocument] = (d.contraintesEquipiers[doc.IdContrainte].Nom + " " + d.camp.Base.Personnes[doc.IdPersonne].NomPrenom()).String()
		}
	}
	return docsIds, prefixes
}

// chercheSimilaires effectue le plus efficacement possible
// une recherche contre tous les profils connus
func (ct Controller) chercheSimilaires(in matching.PatternsSimilarite) ([]ResultatRecherche, error) {
	personnes, err := matching.SelectAllPatternSimilaires(ct.DB)
	if err != nil {
		return nil, err
	}

	scoreMax, res := matching.ChercheSimilaires(personnes, in)
	out := make([]ResultatRecherche, len(res))
	for index, p := range res {
		out[index] = ResultatRecherche{
			Id:            p.Personne.Id,
			Nom:           p.Personne.Nom,
			Prenom:        p.Personne.Prenom,
			DateNaissance: p.Personne.DateNaissance.String(),
			Pertinence:    uint8(p.Score * 100 / scoreMax),
		}
	}
	return out, nil
}

func (d DriverCampComplet) getEquipe(host string) ([]EquipierDirecteur, error) {
	pts := d.camp.GetEquipe(nil)
	out := make([]EquipierDirecteur, len(pts))
	cache := d.camp.Base.ResoudDocumentsPersonnes()
	for index, equipier := range pts {
		accesPers := equipier.GetPersonne()
		pers := accesPers.RawData()
		out[index] = FromPersonneEquipier(pers, equipier.RawData())
		out[index].IsSb = accesPers.IsSB(cache)
		s, err := shared.EncodeID(d.Signing, shared.OrEquipier, equipier.Id)
		if err != nil {
			return nil, err
		}
		out[index].LienFormulaire = shared.BuildUrl(host, path.Join(EndPointEquipier, s), nil)
	}
	return out, nil
}

type errorDirecteur string

func (e errorDirecteur) Error() string {
	return fmt.Sprintf("Le séjour a déjà un directeur : %s", string(e))
}

// Ne commit pas ni ne rollback, mais met à jour la base locale.
// Des contraintes de documents par défaut sont ajoutées.
func (d DriverCampComplet) creeEquipier(idPersonne int64, roles rd.Roles, tx *sql.Tx) (rd.Equipier, error) {
	if roles.Is(rd.RDirecteur) {
		// on vérifie qu'un directeur n'est pas déjà présent
		if dir, has := d.camp.GetDirecteur(); has {
			return rd.Equipier{}, errorDirecteur(dir.RawData().NomPrenom())
		}
	}
	equipier := rd.Equipier{
		IdPersonne: idPersonne,
		Roles:      roles,
		IdCamp:     d.camp.Id,
	}
	equipier, err := equipier.Insert(tx)
	if err != nil {
		return equipier, err
	}
	pers, err := rd.SelectPersonne(tx, idPersonne)
	if err != nil {
		return equipier, err
	}

	equipierContraintes, err := shared.AddEquipierDefautContraintes(tx, d.contraintesEquipiers, equipier)
	if err != nil {
		return equipier, err
	}
	d.camp.Base.Personnes[pers.Id] = pers
	d.camp.Base.Equipiers[equipier.Id] = equipier
	d.camp.Base.EquipierContraintes[equipier.Id] = equipierContraintes
	return equipier, nil
}

// rattacheEquipier ajoute un participant et met à jour la base locale.
func (d DriverCampComplet) rattacheEquipier(idPersonne int64, roles rd.Roles) (rd.Equipier, error) {
	tx, err := d.DB.Begin()
	if err != nil {
		return rd.Equipier{}, err
	}
	out, err := d.creeEquipier(idPersonne, roles, tx)
	if err != nil {
		return out, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

func (d DriverCampComplet) ajouteEquipierTmp(data matching.PatternsSimilarite, roles rd.Roles) (rd.Equipier, error) {
	newPers := rd.Personne{
		BasePersonne: rd.BasePersonne{
			Nom:           data.Nom,
			Prenom:        data.Prenom,
			Sexe:          data.Sexe,
			DateNaissance: data.DateNaissance,
			Mail:          data.Mail,
			NomJeuneFille: data.NomJeuneFille,
		},
		IsTemporaire: true,
	}
	tx, err := d.DB.Begin()
	if err != nil {
		return rd.Equipier{}, err
	}
	newPers, err = newPers.Insert(tx)
	if err != nil {
		return rd.Equipier{}, shared.Rollback(tx, err)
	}
	equipier, err := d.creeEquipier(newPers.Id, roles, tx)
	if err != nil {
		errFinale := shared.Rollback(tx, err)
		if errD, isDirecteur := err.(errorDirecteur); isDirecteur {
			// affiche uniquement l'erreur directeur
			errFinale = errD
		}
		return rd.Equipier{}, errFinale
	}
	err = tx.Commit()
	return equipier, err
}

func (d DriverCampComplet) modifieEquipier(eq EquipierDirecteur) error {
	if err := eq.Roles.Check(); err != nil {
		return err
	}
	if eq.Roles.Is(rd.RDirecteur) {
		// on vérifie qu'un directeur différent n'est pas déjà présent
		if dir, has := d.camp.GetDirecteurEquipier(); has && dir.Id != eq.Id {
			return errorDirecteur(dir.GetPersonne().RawData().NomPrenom())
		}
	}

	tx, err := d.DB.Begin()
	if err != nil {
		return err
	}
	equipier, err := rd.SelectEquipier(tx, eq.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	pers, err := rd.SelectPersonne(tx, equipier.IdPersonne)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	eq.ToPersonneEquipier(&pers.BasePersonne, &equipier)

	equipier, err = equipier.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	pers, err = pers.Update(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// on commit puis on met à jour la base locale
	err = tx.Commit()
	d.camp.Base.Equipiers[equipier.Id] = equipier
	d.camp.Base.Personnes[pers.Id] = pers
	return err
}

func (d DriverCampComplet) deleteEquipier(id int64) error {
	tx, err := d.DB.Begin()
	if err != nil {
		return err
	}
	equipier, err := rd.SelectEquipier(tx, id)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// on supprime les contraintes
	_, err = rd.DeleteEquipierContraintesByIdEquipiers(tx, id)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// puis l'équipier
	_, err = rd.DeleteEquipierById(tx, equipier.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// et enfin la personne sous-jacente, si besoin
	isTmp, idDocs, err := shared.DeletePersonne(tx, equipier.IdPersonne)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	// on commit puis on met à jour la base locale
	if err = tx.Commit(); err != nil {
		return err
	}

	delete(d.camp.Base.Equipiers, id)
	for _, idDoc := range idDocs {
		delete(d.camp.Base.Documents, idDoc)
		delete(d.camp.Base.DocumentPersonnes, idDoc)
	}
	if isTmp {
		delete(d.camp.Base.Personnes, equipier.IdPersonne)
	}
	return nil
}

func (d DriverCampComplet) exportListeEquipiers() (*bytes.Buffer, error) {
	e := d.camp.GetEquipe(nil)
	eqs := make(rd.Table, len(e))
	for index, part := range e {
		eqs[index] = part.AsItem()
	}
	return table.GenereListeEquipe(HeaderExportEquipiers, eqs, false)
}

func (d DriverCampComplet) genereMailInvitationEquipier(host string, equipier dm.AccesEquipier) (to, htmlBody, replyTo string, err error) {
	pers := equipier.GetPersonne().RawData()
	camp := equipier.GetCamp()
	cis, err := shared.EncodeID(d.Signing, shared.OrEquipier, equipier.Id)
	if err != nil {
		err = shared.FormatErr("Une erreur interne empêche le cryptage des informations.", err)
		return
	}
	link := shared.BuildUrl(host, path.Join(EndPointEquipier, cis), nil)
	direc, has := camp.GetDirecteur()
	directeur, replyTo := "", ""
	if has {
		directeur = direc.RawData().FPrenom()
		replyTo = direc.RawData().Mail.String()
	}
	html, err := mails.NewInviteEquipier(camp.RawData(), directeur, pers, link)
	if err != nil {
		err = shared.FormatErr("La création du mail a échoué.", err)
		return
	}
	return pers.Mail.String(), html, replyTo, nil
}

// inviteOneEquipier envoie un mail et met à jour le champ
// invitation (sur la base locale aussi)
func (d DriverCampComplet) inviteOneEquipier(host string, equipier dm.AccesEquipier, mailer mails.Mailer) error {
	to, html, replyTo, err := d.genereMailInvitationEquipier(host, equipier)
	if err != nil {
		return err
	}

	subject := fmt.Sprintf("[ACVE] Equipier - %s", d.camp.RawData().Label())
	err = mailer.SendMail(to, subject, html, nil, mails.CustomReplyTo(replyTo))
	if err != nil {
		return shared.FormatErr(fmt.Sprintf("L'envoi d'un mail d'invitation à %s a échoué.", to), err)
	}

	// si l'équipier a déjà rempli son formulaire, on ne veut pas "revenir en arrière" sur une nouvelle invitation
	newState := rd.Invite
	if equipier.RawData().InvitationEquipier == rd.Verifie {
		newState = rd.Verifie
	}
	row := d.DB.QueryRow("UPDATE equipiers SET invitation_equipier = $1 WHERE id = $2 RETURNING *", newState, equipier.Id)
	out, err := rd.ScanEquipier(row)
	if err != nil {
		return shared.FormatErr("L'invitation a bien été envoyée, mais la mise à jour de la base de données a échoué.", err)
	}
	d.camp.Base.Equipiers[equipier.Id] = out
	return nil
}

// inviteFormulaireEquipier envoie un mail et met à jour le champ
// invitation (sur la base locale aussi)
func (d DriverCampComplet) inviteFormulaireEquipier(host string, id int64) error {
	eq := d.camp.Base.NewEquipier(id)
	return d.inviteOneEquipier(host, eq, mails.NewMailer(d.SMTP))
}

// inviteFormulairesEquipiers envoie les mails et met à jour le champ invitation
// (aussi sur la base locale)
func (d DriverCampComplet) inviteFormulairesEquipiers(host string, onlyNew bool) error {
	pool, err := mails.NewPool(d.SMTP, nil)
	if err != nil {
		return err
	}
	defer pool.Close()
	var errsMails []string
	for _, equipier := range d.camp.GetEquipe(nil) {
		inv := equipier.RawData().InvitationEquipier
		if (onlyNew && inv == rd.NonInvite) || (!onlyNew && inv <= rd.Invite) {
			err := d.inviteOneEquipier(host, equipier, pool)
			if err != nil {
				// on enregistre l'erreur et on continue
				errsMails = append(errsMails, err.Error())
			}
		}
	}
	if len(errsMails) > 0 {
		err := "Des erreurs pendant l'envoi des mails ont été rencontrées : <br/>" + strings.Join(errsMails, "<br/>")
		return errors.New(err)
	}
	return nil
}