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

package inscriptions

import (
	"fmt"
	"net/http"
	"strconv"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/benoitkugler/goACVE/server/core/utils/mails"

	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/labstack/echo"
)

const (
	UrlInscriptions   = "/inscription"
	EndPointValidMail = "/valide-mail"
)

func isSimpleSejour(idS string, campsSimple map[int64]CampSimple) (out CampSimple, ok bool) {
	id, err := strconv.ParseInt(idS, 10, 64)
	if err != nil {
		return out, false // par défaut on renvoie sur la page classique.
	}
	out, ok = campsSimple[id]
	return
}

// FormulaireInscription affiche la page d'inscription,
// qui dépend du camp éventuellement présent dans l'url.
func (ct Controller) FormulaireInscription(c echo.Context) error {
	data, err := ct.loadCamps()
	_, campsSimple := data.triCamps()
	if err != nil {
		return shared.RedirectError(c, shared.FormatErr("La liste des camps n'a pu être résolue.", err))
	}

	// Formulaire complet par défaut
	// les données nécessaires sont chargées par
	// une requête client, gérée par `HandleLoadDataInscriptions`
	meta := MetaInscription{IsComplet: true}

	preselectedId := c.Param("preselected")
	if campSimple, ok := isSimpleSejour(preselectedId, campsSimple); ok {
		// Formulaire simplifié
		meta = MetaInscription{IsComplet: false, LabelCampSimple: campSimple.Label.String()}
	}
	return shared.HtmlWithPayload(c, "server/static/bv/inscription.html", meta)
}

// HandleLoadDataInscriptions décode la préinscription et renvoie les
// données des séjours.
func (ct Controller) HandleLoadDataInscriptions(c echo.Context) error {
	data, err := ct.loadCamps()
	camps, _ := data.triCamps()
	if err != nil {
		return fmt.Errorf("La liste des camps n'a pu être résolue. <br/>Détails : <i>%s</i>", err)
	}
	preselectedId := c.QueryParam("preselected")

	var initialInscription rd.Inscription
	crypted := c.QueryParam("preinscription")
	if crypted != "" {
		initialInscription, err = ct.decodePreinscription(crypted)
		if err != nil {
			return err
		}
	}

	initialInscription.PartageAdressesOK = true // OK par défaut

	out := DataInscription{
		Camps:              camps,
		PreselectCamp:      preselectedId,
		InitialInscription: initialInscription,
	}
	return c.JSON(200, out)
}

// CheckMail analyse l'adresse mail donnée et envoie
// un lien d'inscription rapide aux personnes concernées.
func (ct Controller) CheckMail(c echo.Context) error {
	type out struct {
		MailFound bool `json:"mail_found"`
	}

	mail := c.QueryParam("mail")
	candidats, err := ct.chercheMail(mail)
	if err != nil {
		return err
	}
	if mailFound := len(candidats.responsables) > 0; !mailFound {
		return c.JSON(200, out{MailFound: false})
	}

	targets, err := ct.buildLiensPreinscription(candidats, c.QueryParam("origin"))
	if err != nil {
		return err
	}

	html, err := mails.NewPreinscription(mail, targets)
	if err != nil {
		return err
	}
	if err = mails.NewMailer(ct.SMTP).SendMail(mail, "[ACVE] Inscription rapide", html, nil, nil); err != nil {
		return err
	}

	return c.JSON(200, out{MailFound: true})
}

// EnregistreInscriptionComplete vérifie l'inscription
// et valide le mail (soit directement, soit par lien de confirmation)
func (ct Controller) EnregistreInscriptionComplete(c echo.Context) error {
	facture, responsable, mailValidated, err := ct.enregistreInscriptionComplete(c)
	if err != nil {
		return err
	}

	var out EnregistreInscriptionOut
	out.CheckMail = !mailValidated
	if mailValidated {
		out.UrlEspacePerso = getUrlEspacePerso(facture, c.Request())
	} else {
		err = ct.verifieMail(c.Request().Host, facture, responsable)
		if err != nil {
			return err
		}
	}

	return c.JSON(200, out)
}

// RejoueInscriptionComplete enregristre l'inscription mais ne vérifie pas le mail
// Entre autre, aucun mail n'est envoyé.
func (ct Controller) RejoueInscriptionComplete(c echo.Context) error {
	_, _, _, err := ct.enregistreInscriptionComplete(c)
	if err != nil {
		return err
	}
	return c.JSON(200, "OK") // le client attend un corps JSON
}

func (ct Controller) enregistreInscriptionComplete(c echo.Context) (rd.Facture, rd.Personne, bool, error) {
	var insc rd.Inscription
	if err := c.Bind(&insc); err != nil {
		return rd.Facture{}, rd.Personne{}, false, shared.FormatErr("Les paramètres d'inscriptions ne semblent pas valides.", err)
	}

	if err := valideInscription(insc); err != nil {
		return rd.Facture{}, rd.Personne{}, false, err
	}

	if err := ct.decodeLienId(&insc.Responsable.Lienid); err != nil {
		return rd.Facture{}, rd.Personne{}, false, shared.FormatErr("Le cryptage de la pré-identification du responsable semble incorrect !", err)
	}

	data, err := ct.loadCamps()
	if err != nil {
		return rd.Facture{}, rd.Personne{}, false, shared.FormatErr("La liste des camps ouverts aux inscriptions n'a pu être consultée.", err)
	}
	for index, part := range insc.Participants {
		if _, in := data.camps[part.IdCamp]; !in {
			return rd.Facture{}, rd.Personne{}, false, fmt.Errorf("Le camp numéro %d n'est pas ouvert aux inscriptions !", part.IdCamp)
		}
		if err := ct.decodeLienId(&insc.Participants[index].Lienid); err != nil {
			return rd.Facture{}, rd.Personne{}, false, shared.FormatErr("Le cryptage de la pré-identification d'un participant semble incorrect !", err)
		}
	}

	mailValidated := false
	// on saute l'envoi d'un mail de vérification uniquement
	// pour les responsables pré-identifié dont l'adresse n'a pas changé
	if insc.Responsable.Lienid.Valid {
		hasChanged, err := ct.hasMailChanged(insc.Responsable.Mail, insc.Responsable.Lienid)
		if err != nil {
			return rd.Facture{}, rd.Personne{}, false, err
		}
		mailValidated = !hasChanged
	}

	// on enregistre dans tous les cas l'inscription
	facture, responsable, err := ct.enregistreInscription(insc, mailValidated, data)
	return facture, responsable, mailValidated, err
}

func getUrlEspacePerso(facture rd.Facture, req *http.Request) string {
	endpoint := facture.UrlEspacePerso("espace_perso/")
	return shared.BuildUrl(req.Host, endpoint, map[string]string{"show-hint": "ok"})
}

// ValideMail décrypte l'id de la facture et
// renvoie vers l'espace perso
func (ct Controller) ValideMail(c echo.Context) error {
	facture, err := ct.confirmeInscription(c.QueryParam("crypted-id"))
	if err != nil {
		return shared.RedirectError(c, err)
	}
	return c.Redirect(307, getUrlEspacePerso(facture, c.Request()))
}

// --------------- Formulaire simplifié -------------------------------------

// EnregistreInscriptionSimple enregistre une inscription sur un séjour simplifié.
func (ct Controller) EnregistreInscriptionSimple(c echo.Context) error {
	var insc InscriptionSimple
	if err := c.Bind(&insc); err != nil {
		return shared.FormatErr("Les paramètres d'inscriptions ne semblent pas valides !", err)
	}

	data, err := ct.loadCamps()
	_, campsSimple := data.triCamps()
	if err != nil {
		return shared.FormatErr("La liste des camps n'a pu être résolue.", err)
	}

	preselectedId := c.QueryParam("preselected")
	campSimple, ok := isSimpleSejour(preselectedId, campsSimple)
	if !ok {
		return fmt.Errorf("Le séjour demandé ne propose pas d'inscription simplifiée.")
	}

	err = ct.enregistreInscriptionSimple(insc, campSimple)
	if err != nil {
		return err
	}
	return c.NoContent(200)
}