github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/cont_inscriptions.go

package controllers

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

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"
)

type ButtonsInscriptions struct {
	Supprimer, Valider, LoadLog EtatSideButton
}

type ChoixEnvoi int

const (
	NoEnvoi ChoixEnvoi = iota
	Envoi
	EnvoiEtBascule
)

type OngletInscriptions interface {
	baseOnglet

	ConfirmeSupprimeDossier(facture dm.AccesFacture) bool
	ConfirmeValideMailInvalide(msg string) bool
	DemandeEnvoiAccuseReception(respo rd.Personne) ChoixEnvoi
}

type EtatInscriptions struct {
	InscriptionCurrent rd.IId
	Recherche          string
	CritereIsFolded    bool // si true InscriptionCurrent sera le responsable
	CriteresTri        dm.CriteresTri
}

// Inscriptions permet de valider les nouvelles inscriptions.
type Inscriptions struct {
	Onglet    OngletInscriptions
	main      *MainController
	Liste     []rd.ItemChilds
	Header    []rd.Header
	Base      *dm.BaseLocale
	Etat      EtatInscriptions
	EditRight bool // Droit de modification et de validation, droit de "dé-validation"
}

func NewInscriptions(main *MainController, permission int) *Inscriptions {
	insc := Inscriptions{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.PersonneIdentifie, Label: "Authentifié"},
			{Field: dm.PersonneNomPrenom, Label: "Personne"},
			{Field: dm.InscriptionDateHeure, Label: "Moment d'inscription"},
			{Field: dm.ParticipantCamp, Label: "Camp"},
			{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
			{Field: dm.PersonneSexe, Label: "Sexe"},
		},
	}
	insc.resetData()
	return &insc
}

func (c *Inscriptions) resetData() {
	c.Liste = nil

	cache, cache4 := c.Base.ResoudParticipants()
	cache2 := c.Base.ResoudMessages()
	cache3 := c.Base.ResoudPaiements()
	// les "inscriptions" sont les facture non validées...
	for _, insc := range c.Base.Factures {
		if !insc.IsValidated {
			c.Liste = append(c.Liste, c.Base.NewFacture(insc.Id).AsItemChilds(cache, cache2, cache3, cache4))
		}
	}
	// ... et les participants simples temporaires
	for id := range c.Base.Participantsimples {
		if ac := c.Base.NewParticipantsimple(id); ac.GetPersonne().RawData().IsTemporaire {
			c.Liste = append(c.Liste, ac.AsItemChilds())
		}
	}

	if strings.TrimSpace(c.Etat.Recherche) != "" {
		c.Liste = dm.RechercheDetailleeChilds(c.Liste, c.Etat.Recherche, c.Header)
	}

	dm.SortCriteresChilds(c.Liste, c.Etat.CriteresTri)

	if c.Etat.InscriptionCurrent == nil { // fastpath
		return
	}

	// on vérifie que l'inscription courante est dans la liste à afficher
	// (en prenant en compte l'affichage ou non des "enfants")
	var found bool
	for _, insc := range c.Liste {
		if insc.Id == c.Etat.InscriptionCurrent {
			found = true
			break
		}
		if c.Etat.CritereIsFolded {
			continue
		}

		// on regarde dans les enfants
		for _, part := range insc.Childs {
			if part.Id == c.Etat.InscriptionCurrent {
				found = true
				break
			}
		}
	}
	if !found {
		c.Etat.InscriptionCurrent = nil
	}
}

func (c *Inscriptions) SideButtons() ButtonsInscriptions {
	var bs ButtonsInscriptions
	if c.EditRight {
		bs.Supprimer = ButtonPresent
		if c.Etat.InscriptionCurrent != nil {
			bs.Supprimer = ButtonActivated
		}

		bs.Valider = ButtonPresent
		if c.isInscriptionValidable() {
			bs.Valider = ButtonActivated
		}
	}
	bs.LoadLog = ButtonActivated
	return bs
}

// AsAcces construit un accès à partir de `id` (participant, participantsimple ou facture)
func (c *Inscriptions) AsAcces(id rd.IId) dm.Personne {
	switch id := id.(type) {
	case rd.IdParticipantsimple:
		return c.Base.NewParticipantsimple(id.Int64())
	case rd.IdParticipant:
		return c.Base.NewParticipant(id.Int64())
	case rd.IdFacture:
		return c.Base.NewFacture(id.Int64())
	default:
		return nil
	}
}

func (c *Inscriptions) isInscriptionValidable() bool {
	facture, has := c.Base.IdAsFacture(c.Etat.InscriptionCurrent)
	if !has {
		return false
	}
	if facture.RawData().IsValidated { // déjà validé, ne devrait pas arriver
		return false
	}
	if facture.GetPersonne().RawData().IsTemporaire {
		return false
	}

	parts := facture.GetDossiers(nil)
	if len(parts) == 0 { // aucune inscription, autant ne pas la valider
		return false
	}
	for _, part := range parts {
		if part.GetPersonne().RawData().IsTemporaire {
			return false
		}
	}
	return true
}

// CurrentInfo renvoie le message (éventuel) de l'inscription courante
func (c *Inscriptions) CurrentInfo() string {
	switch id := c.Etat.InscriptionCurrent.(type) {
	case rd.IdParticipantsimple:
		return c.Base.NewParticipantsimple(id.Int64()).RawData().Info.TrimSpace().String()
	case rd.IdFacture:
		// on rassemble les messages (probablement 1 ou 0, mais l'espace perso a pu déjà être utilisé)
		return c.Base.NewFacture(id.Int64()).GetEtat(nil, nil).Info()
	case rd.IdParticipant:
		// on se ramène au dossier
		fac, ok := c.Base.NewParticipant(id.Int64()).GetFacture()
		if !ok {
			return ""
		}
		return fac.GetEtat(nil, nil).Info()
	default:
		return ""
	}
}

// GetStats renvoi les statistiques courantes
func (c *Inscriptions) GetStats() []Stat {
	nbCurrent := 0
	for _, insc := range c.Base.Factures {
		if !insc.IsValidated {
			nbCurrent += 1
		}
	}
	return []Stat{
		{Label: "Nombre d'inscriptions en cours", Value: strconv.Itoa(nbCurrent)},
	}
}

// SupprimeInscription supprime le groupe d'inscription courante
// après confirmation
func (c *Inscriptions) SupprimeInscription() {
	if c.Etat.InscriptionCurrent == nil {
		return
	}
	if idSimple, ok := c.Etat.InscriptionCurrent.(rd.IdParticipantsimple); ok {
		// on supprime le participant et la personne temporaire
		c.main.Controllers.Camps.supprimeParticipantsimple(c.Base.NewParticipantsimple(idSimple.Int64()))
		return
	}

	facture, ok := c.Base.IdAsFacture(c.Etat.InscriptionCurrent)
	if !ok {
		return
	}

	if keep := c.Onglet.ConfirmeSupprimeDossier(facture); !keep {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteInscriptionOut
		err := requete(apiserver.UrlInscriptions, http.MethodDelete, IdAsParams(facture.Id), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteInscriptionOut)
		c.Etat.InscriptionCurrent = nil
		c.Base.DeleteFacture(facture.Id)
		if out.IdResponsable >= 0 {
			delete(c.Base.Personnes, out.IdResponsable)
		}
		for _, idPaiement := range out.IdsPaiements {
			delete(c.Base.Paiements, idPaiement)
		}
		c.Base.CleanupDocuments(out.IdsDocuments)
		for _, part := range out.Participants {
			c.Base.CleanupParticipant(part)
		}

		c.main.ShowStandard("Inscription supprimée avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Suppression de l'inscription en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

type jwc struct {
	job       func() (interface{}, error)
	onSuccess func(_out interface{})
}

func (c *Inscriptions) setupJobIdentResponsable(argsPers apiserver.IdentifiePersonneIn, id rd.IdFacture) jwc {
	argsPers.IdPersonneTmp = c.Base.NewFacture(id.Int64()).GetPersonne().Id
	params := apiserver.IdentifieResponsableIn{
		IdFacture:           id.Int64(),
		IdentifiePersonneIn: argsPers,
	}

	job := func() (interface{}, error) {
		var out apiserver.IdentifieResponsableOut
		err := requete(apiserver.UrlIdentifieResponsable, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.IdentifieResponsableOut)
		c.Base.Factures[out.Facture.Id] = out.Facture
		c.Base.ApplyIdentifie(out.IdentifiePersonneOut)
		c.main.ShowStandard("Identification effectuée.", false)
		c.main.ResetAllControllers()
	}
	return jwc{job: job, onSuccess: onSuccess}
}

func (c *Inscriptions) setupJobIdentParticipant(argsPers apiserver.IdentifiePersonneIn, id rd.IdParticipant) (jwc, bool) {
	part := c.Base.NewParticipant(id.Int64())
	argsPers.IdPersonneTmp = part.GetPersonne().Id
	params := apiserver.IdentifieParticipantIn{
		IdParticipant:       id.Int64(),
		IdentifiePersonneIn: argsPers,
	}

	if argsPers.Rattache { // on vérifie que la personne target n'est pas déjà dans le séjour
		if camp := part.GetCamp(); c.Base.IsParticipantAlreadyHere(argsPers.IdPersonneTarget, camp.Id) {
			c.main.ShowError(fmt.Errorf("%s est déjà sur le séjour %s", argsPers.Modifications.NomPrenom(), camp.RawData().Label()))
			return jwc{}, false
		}
	}

	job := func() (interface{}, error) {
		var out apiserver.IdentifieParticipantOut
		err := requete(apiserver.UrlIdentifieParticipant, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.IdentifieParticipantOut)
		c.Base.Participants[out.Participant.Id] = out.Participant
		c.Base.ApplyIdentifie(out.IdentifiePersonneOut)
		c.main.ShowStandard("Identification effectuée.", false)
		c.main.ResetAllControllers()
	}
	return jwc{job: job, onSuccess: onSuccess}, true
}

func (c *Inscriptions) setupJobIdentParticipantsimple(argsPers apiserver.IdentifiePersonneIn, id rd.IdParticipantsimple) (jwc, bool) {
	part := c.Base.NewParticipantsimple(id.Int64())
	argsPers.IdPersonneTmp = part.GetPersonne().Id
	params := apiserver.IdentifieParticipantsimpleIn{
		IdParticipantsimple: id.Int64(),
		IdentifiePersonneIn: argsPers,
	}

	if argsPers.Rattache { // on vérifie que la personne target n'est pas déjà dans le séjour
		if camp := part.GetCamp(); c.Base.IsParticipantsimpleAlreadyHere(argsPers.IdPersonneTarget, camp.Id) {
			c.main.ShowError(fmt.Errorf("%s est déjà sur le séjour %s", argsPers.Modifications.NomPrenom(), camp.RawData().Label()))
			return jwc{}, false
		}
	}

	job := func() (interface{}, error) {
		var out apiserver.IdentifieParticipantsimpleOut
		err := requete(apiserver.UrlIdentifieParticipantsimple, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.IdentifieParticipantsimpleOut)
		c.Base.Participantsimples[out.Participantsimple.Id] = out.Participantsimple
		c.Base.ApplyIdentifie(out.IdentifiePersonneOut)
		c.main.ShowStandard("Identification effectuée et mail de confirmation envoyé.", false)
		c.main.ResetAllControllers()
	}
	return jwc{job: job, onSuccess: onSuccess}, true
}

// Identifie identifie l'inscription courante contre la personne donnée.
func (c *Inscriptions) Identifie(target matching.IdentifieTarget) {
	// IdPersonneTmp est complété plus tard
	var argsPers apiserver.IdentifiePersonneIn
	switch target := target.(type) {
	case matching.NouveauProfil:
	// rien à transmettre
	case matching.Rattache:
		argsPers.Rattache = true
		argsPers.IdPersonneTarget = target.IdTarget
		argsPers.Modifications = target.Modifications
	}
	// normalement aucun acteur d'une inscription n'upload de documents
	// donc il n'y a pas besoin de check les doublons

	var (
		js jwc
		ok bool
	)

	switch id := c.Etat.InscriptionCurrent.(type) {
	case rd.IdParticipantsimple:
		js, ok = c.setupJobIdentParticipantsimple(argsPers, id)
	case rd.IdFacture:
		js, ok = c.setupJobIdentResponsable(argsPers, id), true
	case rd.IdParticipant:
		js, ok = c.setupJobIdentParticipant(argsPers, id)
	default:
		c.main.ShowError(errors.New("Veuillez sélectionner une inscription !"))
	}
	if !ok {
		return
	}

	message := "Validation en tant que nouveau profil ..."
	if argsPers.Rattache {
		message = fmt.Sprintf("Identification à %s en cours...", argsPers.Modifications.NomPrenom())
	}
	c.main.ShowStandard(message, true)
	c.main.Background.Run(js.job, js.onSuccess)
}

// Valide valide le groupe d'inscription courant, de manière synchrone,
// puis propose l'envoi d'un accusé de réception.
func (c *Inscriptions) Valide() {
	facture, ok := c.Base.IdAsFacture(c.Etat.InscriptionCurrent)
	if !ok {
		c.main.ShowError(errors.New("Veuillez sélectionnez une inscription !"))
		return
	}

	if !facture.RawData().IsConfirmed {
		pers := facture.GetPersonne().RawData()
		msg := fmt.Sprintf("Attention, l'adresse <b>mail</b> de l'inscription n'a <b>pas été validée</b> par le responsable. <br/>"+
			"<i>A moins d'être sur que l'adresse <b>%s</b> soit valide, il est déconseillé de valider cette inscription.</i>", pers.Mail)
		keep := c.Onglet.ConfirmeValideMailInvalide(msg)
		if !keep {
			return
		}
	}

	c.main.ShowStandard("Validation de l'inscription en cours...", true)
	var out rd.Facture
	err := requete(apiserver.UrlValideInscriptions, http.MethodPost, IdAsParams(facture.Id), &out)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	c.Base.Factures[out.Id] = out
	c.main.ShowStandard("Inscription validée", false)
	c.main.ResetAllControllers()
	envoiAR := c.Onglet.DemandeEnvoiAccuseReception(facture.GetPersonne().RawData())
	if envoiAR == NoEnvoi {
		return
	}
	c.main.Controllers.SuiviDossiers.EnvoiAccuseReception(facture)
	if envoiAR == EnvoiEtBascule {
		c.main.Controllers.SuiviDossiers.SelectFacture(facture)
	}
}

func (c *Inscriptions) LoadLogInscriptions() rd.Inscriptions {
	var out rd.Inscriptions
	err := requete(apiserver.UrlInscriptions, http.MethodGet, nil, &out)
	if err != nil {
		c.main.ShowError(err)
		return nil
	}
	return out
}

// RejouerInscription envoie une requête sur l'url d'inscription publique
// La base locale doit être raffraichie pour prendre en compte le résultat
func (c *Inscriptions) RejouerInscription(insc rd.Inscription) bool {
	c.main.ShowStandard("Envoi de l'inscription...", true)

	err := requete(urlRejoueInscription, http.MethodPost, insc, new(string)) // dismiss the body
	if err != nil {
		c.main.ShowError(err)
		return false
	}
	c.main.ShowStandard("Inscription déclenchée.", false)
	return true
}