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

// Expose les fonctionnalités du formulaire d'inscription
// aux séjours ACVE.
package inscriptions

import (
	"errors"
	"fmt"
	"net/url"
	"path"
	"sort"
	"strings"
	"time"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/composites"
	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/benoitkugler/goACVE/server/shared"
)

// adresse de confirmation du mail
var PathValidMail = path.Join(UrlInscriptions, EndPointValidMail)

type Controller struct {
	shared.Controller
}

// Preinscription code le choix d'un responsable et des participants associés.
type Preinscription struct {
	IdResponsable int64
	IdsEnfants    rd.Ids
}

type CampSimple struct {
	Id        int64     `json:"id"`
	IdGroupe  int64     `json:"id_groupe"`
	Label     rd.String `json:"label"`
	Prix      rd.Euros  `json:"prix"`
	DateDebut rd.Date   `json:"date_debut"`
	DateFin   rd.Date   `json:"date_fin"`
	AgeMin    rd.Int    `json:"age_min"`
	AgeMax    rd.Int    `json:"age_max"`
}

func (c *CampSimple) From(camp rd.Camp) {
	c.Id = camp.Id
	c.Label = camp.Label()
	c.Prix = camp.Prix
	c.AgeMax = camp.AgeMax
	c.AgeMin = camp.AgeMin
	c.DateDebut = camp.DateDebut
	c.DateFin = camp.DateFin
}

type dataCamps struct {
	camps   rd.Camps
	groupes rd.Groupes
}

// triCamps différencie les camps simple ou non
func (d dataCamps) triCamps() ([]shared.Camp, map[int64]CampSimple) {
	out1 := make([]shared.Camp, 0, len(d.camps))
	out2 := make(map[int64]CampSimple)
	for _, camp := range d.camps {
		if camp.InscriptionSimple {
			var pCamp CampSimple
			pCamp.From(camp)
			out2[camp.Id] = pCamp
		} else {
			var pCamp shared.Camp
			pCamp.From(camp)
			out1 = append(out1, pCamp)
		}
	}
	sort.Slice(out1, func(i, j int) bool {
		return out1[i].Label < out1[j].Label
	})
	return out1, out2
}

// loadCamps renvoie les camps ouverts aux inscriptions et dont la date de fin n'est pas passée
func (ct Controller) loadCamps() (dataCamps, error) {
	rows, err := ct.DB.Query("SELECT * FROM camps WHERE ouvert = true")
	if err != nil {
		return dataCamps{}, err
	}
	camps, err := rd.ScanCamps(rows)
	if err != nil {
		return dataCamps{}, err
	}
	for id, camp := range camps {
		if camp.DateFin.Time().Before(time.Now()) {
			delete(camps, id)
		}
	}
	rows, err = ct.DB.Query("SELECT * FROM groupes WHERE id_camp = ANY($1)", camps.Ids().AsSQL())
	if err != nil {
		return dataCamps{}, err
	}
	groupes, err := rd.ScanGroupes(rows)
	if err != nil {
		return dataCamps{}, err
	}
	return dataCamps{camps: camps, groupes: groupes}, nil
}

// vérifie si le mail est le même
func (ct Controller) hasMailChanged(mail rd.String, idPersonne rd.IdentificationId) (bool, error) {
	personne, err := rd.SelectPersonne(ct.DB, idPersonne.Id)
	if err != nil {
		return false, shared.FormatErr("Impossible de consulter le profil du responsable.", err)
	}
	return personne.Mail.ToLower() != mail.ToLower(), nil
}

type candidatsPreinscription struct {
	responsables            []rd.Personne
	idsParticipantPersonnes rd.Ids // participants cumulés
}

// chercheMail renvoie les personnes ayant le mail fourni
func (ct Controller) chercheMail(mail string) (candidatsPreinscription, error) {
	mail = strings.TrimSpace(mail)
	if len(mail) <= 1 {
		return candidatsPreinscription{}, nil
	}
	rows, err := ct.DB.Query("SELECT * FROM personnes WHERE mail = $1", mail)
	if err != nil {
		return candidatsPreinscription{}, err
	}
	pers, err := rd.ScanPersonnes(rows)
	if err != nil {
		return candidatsPreinscription{}, err
	}
	var (
		ids rd.Ids
		out candidatsPreinscription
	)
	for id, pers := range pers {
		ids = append(ids, id)
		out.responsables = append(out.responsables, pers)
	}
	sort.Slice(out.responsables, func(i int, j int) bool {
		return out.responsables[i].NomPrenom() < out.responsables[j].NomPrenom()
	})
	rows, err = ct.DB.Query(`SELECT participants.id_personne FROM participants
		JOIN factures ON participants.id_facture = factures.id
		WHERE factures.id_personne = ANY($1)`, ids.AsSQL())
	if err != nil {
		return candidatsPreinscription{}, err
	}
	idsEnfants, err := rd.ScanIds(rows)
	if err != nil {
		return candidatsPreinscription{}, err
	}
	out.idsParticipantPersonnes = idsEnfants.AsSet().Keys() // unicité
	return out, nil
}

func (ct Controller) buildLiensPreinscription(cd candidatsPreinscription, origin string) ([]mails.TargetRespo, error) {
	baseUrl, err := url.Parse(origin)
	if err != nil {
		return nil, err
	}
	var out []mails.TargetRespo
	for _, resp := range cd.responsables {
		t := Preinscription{IdResponsable: resp.Id, IdsEnfants: cd.idsParticipantPersonnes}
		crypted, err := shared.Encode(ct.Signing, t)
		if err != nil {
			return nil, err
		}
		lien := shared.BuildUrl(baseUrl.Host, baseUrl.Path, map[string]string{"preinscription": crypted})
		out = append(out, mails.TargetRespo{Lien: lien, NomPrenom: resp.NomPrenom().String()})
	}
	return out, nil
}

// decodePreinscription parse le lien du mail et forme une inscription pré-remplie.
func (ct Controller) decodePreinscription(crypted string) (insc rd.Inscription, err error) {
	var pre Preinscription
	if err := shared.Decode(ct.Signing, crypted, &pre); err != nil {
		return insc, shared.FormatErr("Le lien d'inscription rapide que vous utilisez semble invalide.", err)
	}
	respo, err := rd.SelectPersonne(ct.DB, pre.IdResponsable)
	if err != nil {
		return insc, shared.FormatErr("Le responsable n'a pu être retrouvé.", err)
	}
	rows, err := ct.DB.Query("SELECT * FROM personnes WHERE id = ANY($1)", pre.IdsEnfants.AsSQL())
	if err != nil {
		return insc, shared.FormatErr("Les participants n'ont pu être retrouvés.", err)
	}
	parts, err := rd.ScanPersonnes(rows)
	if err != nil {
		return insc, shared.FormatErr("Les participants n'ont pu être retrouvés.", err)
	}

	insc.Responsable = respo.ToInscription()
	insc.Responsable.Lienid.Crypted, err = shared.EncodeID(ct.Signing, shared.OrPreIdentification, respo.Id)
	if err != nil {
		return insc, shared.FormatErr("Le cryptage des identifiants a échoué.", err)
	}

	for _, part := range parts {
		partInsc := part.ToParticipantInscription()
		partInsc.Lienid.Crypted, err = shared.EncodeID(ct.Signing, shared.OrPreIdentification, part.Id)
		if err != nil {
			return insc, shared.FormatErr("Le cryptage des identifiants a échoué.", err)
		}
		insc.Participants = append(insc.Participants, partInsc)
	}
	return insc, nil
}

func (ct Controller) decodeLienId(lienid *rd.IdentificationId) error {
	if lienid.Crypted != "" {
		lienId, err := shared.DecodeID(ct.Signing, lienid.Crypted, shared.OrPreIdentification)
		if err != nil {
			return shared.FormatErr("Le cryptage de la pré-identification semble incorrect.", err)
		}
		*lienid = rd.IdentificationId{Id: lienId, Valid: true}
	}
	return nil
}

func valideInscription(insc rd.Inscription) error {
	if insc.Responsable.Nom.TrimSpace() == "" {
		return errors.New("Merci de préciser votre nom.")
	}
	if insc.Responsable.Prenom.TrimSpace() == "" {
		return errors.New("Merci de préciser votre prénom.")
	}
	if insc.Responsable.DateNaissance.Time().IsZero() {
		return errors.New("Merci de fournir votre date de naissance.")
	}
	if len(insc.Participants) == 0 {
		return errors.New("Aucun participant n'a été choisi !")
	}
	age := rd.CalculeAge(insc.Responsable.DateNaissance, time.Time{}).Age()
	if age < 18 {
		return errors.New("Le responsable légal doit être majeur !")
	}
	return nil
}

// transforme l'inscription en dossier, l'enregistre et garde un log
// renvoie le dossier créé et son responsable
// `camps` et `groupes` doivent contenir les camps et groupes concernés par l'inscription
func (ct Controller) enregistreInscription(insc rd.Inscription, confirmed bool, data dataCamps) (rd.Facture, rd.Personne, error) {
	insc.DateHeure = rd.Time(time.Now())

	type identifiedPersonne struct {
		personne rd.Personne
		lienid   rd.IdentificationId
	}

	// on regroupe les personnes à identifier
	var allPers []identifiedPersonne
	ids := rd.NewSet()

	allPers = append(allPers, identifiedPersonne{personne: insc.Responsable.ToPersonne(), lienid: insc.Responsable.Lienid})
	ids.Add(insc.Responsable.Lienid.Id)
	for _, part := range insc.Participants {
		allPers = append(allPers, identifiedPersonne{personne: part.ToPersonne(), lienid: part.Lienid})
		ids.Add(part.Lienid.Id)
	}

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

	// on charge les personnes pour la comparaison
	rows, err := tx.Query("SELECT * FROM personnes WHERE id = ANY($1)", rd.Ids(ids.Keys()).AsSQL())
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}
	personnes, err := rd.ScanPersonnes(rows)
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}

	for i, personneAndId := range allPers {
		var personne rd.Personne
		if existante, isInBase := personnes[personneAndId.lienid.Id]; personneAndId.lienid.Valid && isInBase {
			// si l'inscription est préidentifiée, on fusionne automatiquement
			// l'inscription avec le profil
			existante.BasePersonne, _ = matching.Merge(personneAndId.personne.BasePersonne, existante.BasePersonne)
			personne, err = existante.Update(tx)
		} else {
			// sinon, on crée une nouvelle personne temporaire
			personneAndId.personne.IsTemporaire = true
			personne, err = personneAndId.personne.Insert(tx)
		}
		if err != nil {
			return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
		}
		allPers[i].personne = personne // on a besoin de l'id plus tard
	}
	responsablePersonne := allPers[0].personne // le responsable est en premier

	key, err := shared.GetNewKey(tx)
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}
	fac := rd.Facture{
		IdPersonne:        responsablePersonne.Id,
		Key:               rd.String(key),
		CopiesMails:       insc.CopiesMails,
		IsConfirmed:       confirmed,
		IsValidated:       false,
		PartageAdressesOK: insc.PartageAdressesOK,
	}
	fac, err = fac.Insert(tx)
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}

	// on garde une trace du moment d'inscription
	messageTime := rd.Message{
		IdFacture: fac.Id,
		Kind:      rd.MInscription,
		Created:   rd.Time(time.Now()),
	}
	_, err = messageTime.Insert(tx)
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}

	// on insert le message du formulaire
	if me := insc.Info.TrimSpace(); me != "" {
		message := rd.Message{
			IdFacture: fac.Id,
			Kind:      rd.MResponsable,
			Created:   rd.Time(time.Now().Add(time.Second)), // on s'assure que le message vient après le moment d'inscription
		}
		message, err = message.Insert(tx)
		if err != nil {
			return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
		}
		mMessage := rd.MessageMessage{IdMessage: message.Id, Contenu: me, GuardKind: rd.MResponsable}
		err = rd.InsertManyMessageMessages(tx, mMessage)
		if err != nil {
			return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
		}
	}

	// le choix attente/inscrit nécessite les participants
	participants, err := rd.SelectParticipantsByIdCamps(tx, data.camps.Ids()...)
	if err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}

	// on ajoute maintenant les participants
	for i, inscPart := range insc.Participants {
		personne := allPers[i+1].personne // personne créée ou mise à jour
		camp := data.camps[inscPart.IdCamp]

		campP := composites.NewCampParticipants(camp, participants)
		if campP.IsParticipantAlreadyHere(personne.Id) {
			_ = shared.Rollback(tx, nil)
			return rd.Facture{}, rd.Personne{}, fmt.Errorf("%s est déjà inscrit sur le séjour %s",
				personne.NomPrenom(), campP.Label())
		}

		campG := composites.NewCampGroupes(camp, data.groupes)

		statutAttente := campP.HintsAttente(personne.BasePersonne, false, personnes).Hint()
		participant := rd.Participant{
			IdCamp:       inscPart.IdCamp,
			IdPersonne:   personne.Id,
			IdFacture:    rd.NewOptionnalId(fac.Id),
			ListeAttente: rd.ListeAttente{Statut: statutAttente},
			Options:      inscPart.Options,
			OptionPrix:   inscPart.OptionsPrix,
			DateHeure:    rd.Time(time.Now()),
		}
		participant, err = participant.Insert(tx)
		if err != nil {
			return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
		}

		groupe, hasFound := campG.TrouveGroupe(inscPart.DateNaissance)
		if hasFound {
			// on ajoute automatiquement le nouveau participant au groupe
			lien := rd.GroupeParticipant{IdGroupe: groupe.Id, IdCamp: groupe.IdCamp, IdParticipant: participant.Id}
			err = rd.InsertManyGroupeParticipants(tx, lien)
			if err != nil {
				return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
			}
		}
	}

	// on garde un log de l'inscription brute
	if _, err = insc.Insert(tx); err != nil {
		return rd.Facture{}, rd.Personne{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return fac, responsablePersonne, err
}

// envoie un mail de demande de confirmation
func (ct Controller) verifieMail(host string, facture rd.Facture, responsable rd.Personne) error {
	cryptedId, err := shared.EncodeID(ct.Signing, shared.OrValidationMail, facture.Id)
	if err != nil {
		return shared.FormatErr("Le cryptage des identifiants a échoué.", err)
	}

	urlValide := shared.BuildUrl(host, PathValidMail, map[string]string{
		"crypted-id": cryptedId,
	})

	html, err := mails.NewValideMail(urlValide, mails.Contact{Prenom: responsable.FPrenom(), Sexe: responsable.Sexe})
	if err != nil {
		return shared.FormatErr("La création du mail a échoué.", err)
	}
	if err = mails.NewMailer(ct.SMTP).SendMail(string(responsable.Mail), "[ACVE] Vérification de l'adresse mail", html, nil, nil); err != nil {
		return shared.FormatErr("L'envoi du mail de vérification a échoué.", err)
	}
	return nil
}

func (ct Controller) confirmeInscription(cryptedId string) (rd.Facture, error) {
	idFacture, err := shared.DecodeID(ct.Signing, cryptedId, shared.OrValidationMail)
	if err != nil {
		return rd.Facture{}, err
	}
	row := ct.DB.QueryRow("UPDATE factures SET is_confirmed = true WHERE id = $1 RETURNING *", idFacture)
	facture, err := rd.ScanFacture(row)
	if err != nil {
		return rd.Facture{}, shared.FormatErr("La validation de l'adresse a échoué.", err)
	}
	return facture, nil
}

func (ct Controller) enregistreInscriptionSimple(insc InscriptionSimple, camp CampSimple) error {
	tx, err := ct.DB.Begin()
	if err != nil {
		return shared.FormatErr("Base de données injoinable.", err)
	}

	// on enregistre directement le participant (lié à une personne temporaire)
	personne := rd.Personne{
		BasePersonne: rd.BasePersonne{
			Nom:           insc.Nom,
			Prenom:        insc.Prenom,
			DateNaissance: insc.DateNaissance,
			Sexe:          insc.Sexe,
			Mail:          insc.Mail,
			Tels:          rd.Tels{insc.Tel},
		},
		IsTemporaire: true,
	}
	personne, err = personne.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	participant := rd.Participantsimple{
		IdCamp:     camp.Id,
		IdPersonne: personne.Id,
		Info:       insc.Info,
		DateHeure:  rd.Time(time.Now()),
	}
	participant, err = participant.Insert(tx)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	if err = tx.Commit(); err != nil {
		return shared.FormatErr("L'enregistrement de l'inscription a échoué.", err)
	}
	return nil
}