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

package controllers

import (
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"path/filepath"
	"sort"
	"strconv"
	"strings"

	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"
	"github.com/benoitkugler/goACVE/server/core/utils/table"

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

type ButtonsEquipiers struct {
	Creer, Supprimer, Exporter EtatSideButton
}

type OngletEquipiers interface {
	baseOnglet

	ChoixEviteDoublonsDocuments(docs []dm.AccesDocumentPersonne) (toSupp rd.Ids)
	ConfirmeSupprimeEquipier(part rd.Personne) bool
}

type EtatEquipiers struct {
	EquipierCurrent rd.IId
	CritereCamp     *dm.AccesCamp
	// 0 pour tous, 1 pour temporaire, -1 pour référencés
	CritereTemporaire rd.OptionnalBool
	Recherche         string
}

// Equipiers permet de valider les équipiers temporaires,
// et d'accéder aux renseignements administratifs.
// Les documents sont accessibles via l'Onglet Personnes.
// Les documents temporaires ne sont pas accessibles directement.
type Equipiers struct {
	Onglet    OngletEquipiers
	main      *MainController
	Liste     rd.Table
	Header    []rd.Header
	Base      *dm.BaseLocale
	Etat      EtatEquipiers
	EditRight bool // Droit de modification et de validation
}

func NewEquipiers(main *MainController, permission int) *Equipiers {
	eq := Equipiers{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.EquipierCamp, Label: "Camp"},
			{Field: dm.PersonneNom, Label: "Nom"},
			{Field: dm.PersonnePrenom, Label: "Prénom"},
			{Field: dm.EquipierRoles, Label: "Rôle"},
			{Field: dm.PersonneSexe, Label: "Sexe"},
			{Field: dm.PersonneNomJeuneFille, Label: "Nom de jeune fille"},
			{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
			{Field: dm.PersonneVilleNaissance, Label: "Ville de naissance"},
			{Field: dm.PersonneDepartementNaissance, Label: "Département de naissance"},
			{Field: dm.EquipierDiplome, Label: "Diplôme"},
			{Field: dm.EquipierAppro, Label: "Approfondissement"},
			{Field: dm.PersonneSecuriteSociale, Label: "Sécurité sociale"},
			{Field: dm.PersonneProfession, Label: "Profession"},
			{Field: dm.PersonneEtudiant, Label: "Etudiant"},
			{Field: dm.PersonneFonctionnaire, Label: "Fonctionnaire"},
			{Field: dm.EquipierPresence, Label: "Présence"},
		}}
	eq.resetData()
	return &eq
}

func (c *Equipiers) resetData() {
	c.Liste = nil
	var equipiers []dm.AccesEquipier
	if c.Etat.CritereCamp != nil {
		equipiers = c.Etat.CritereCamp.GetEquipe(nil)
	} else {
		equipiers = make([]dm.AccesEquipier, 0, len(c.Base.Equipiers))
		for id := range c.Base.Equipiers {
			equipiers = append(equipiers, c.Base.NewEquipier(id))
		}
	}

	ct := c.Etat.CritereTemporaire
	for _, part := range equipiers {
		isTmp := bool(part.GetPersonne().RawData().IsTemporaire)
		if ct == 0 || (ct.Bool() && isTmp) || (!ct.Bool() && !isTmp) {
			c.Liste = append(c.Liste, part.AsItem())
		}
	}
	if strings.TrimSpace(c.Etat.Recherche) != "" {
		c.Liste = dm.RechercheDetaillee(c.Liste, c.Etat.Recherche, c.Header)
	}

	dm.SortBy(c.Liste, dm.PersonnePrenom, false)
	dm.SortStableBy(c.Liste, dm.PersonneNom, false)
	dm.SortStableBy(c.Liste, dm.EquipierCamp, false)

	hasEquipier := c.Etat.EquipierCurrent != nil
	// besoin de déselectionner si absent
	if hasEquipier && !HasId(c.Liste, c.Etat.EquipierCurrent) {
		c.Etat.EquipierCurrent = nil
	}
}

func (c *Equipiers) SideButtons() ButtonsEquipiers {
	var bs ButtonsEquipiers
	Etat := ButtonPresent
	if c.Etat.EquipierCurrent != nil {
		Etat = ButtonActivated
	}
	if c.EditRight {
		bs.Creer = ButtonActivated
		bs.Supprimer = Etat
	}
	bs.Exporter = ButtonPresent
	if len(c.Liste) > 0 {
		bs.Exporter = ButtonActivated
	}
	return bs
}

// GetStats renvoi les statistiques courantes
func (c *Equipiers) GetStats() []Stat {
	nbCampsCourants, nbPartTmps := len(c.Base.GetCamps(false, -1)), 0
	pers := rd.NewSet()
	nbEquipiers := len(c.Base.Equipiers)
	for _, p := range c.Base.Equipiers {
		pers.Add(p.IdPersonne)
		if c.Base.Personnes[p.IdPersonne].IsTemporaire {
			nbPartTmps += 1
		}
	}
	nbPersonnes := len(pers)
	return []Stat{
		{Label: "Nombre de camps en cours", Value: strconv.Itoa(nbCampsCourants)},
		{Label: "Nombre d'équipiers non référencés", Value: strconv.Itoa(nbPartTmps)},
		{Label: "Nombre total d'équipiers", Value: fmt.Sprintf("%d (%d participations)", nbPersonnes, nbEquipiers)},
	}
}

// UpdateEquipier met à jour le profil transmis sur le serveur.
// La modification des champs de la personne se fait via l'onglet "Personnes"
func (c *Equipiers) UpdateEquipier(equipier rd.Equipier) {
	// on empêche l'ajout d'un directeur
	if dir, has := c.Base.NewEquipier(equipier.Id).GetCamp().GetDirecteurEquipier(); has &&
		dir.Id != equipier.Id && equipier.Roles.Is(rd.RDirecteur) {
		c.main.ShowError(fmt.Errorf("Le séjour a déjà un directeur <i>%s</i>", dir.GetPersonne().RawData().NomPrenom()))
		return
	}

	c.main.ShowStandard("Mise à jour de l'équipier...", true)
	var out rd.Equipier
	if err := requete(apiserver.UrlEquipiers, http.MethodPost, equipier, &out); err != nil {
		c.main.ShowError(err)
		return
	}

	c.Base.Equipiers[out.Id] = out
	c.main.ShowStandard("Equipier mis à jour avec succès.", false)
	c.main.ResetAllControllers()
}

// CreateEquipier crée un nouvel `equipier`,
// ayant des champs idPersonne et idCamp valides
// Renvoie `true` si la modification a été lancée
func (c *Equipiers) CreateEquipier(equipier rd.Equipier) bool {
	personne := c.Base.Personnes[equipier.IdPersonne]
	camp := c.Base.Camps[equipier.IdCamp]
	if c.Base.IsEquipierAlreadyHere(equipier) {
		c.main.ShowError(fmt.Errorf("%s est déjà présent(e) au camp %s", personne.NomPrenom(),
			camp.Label()))
		return false
	}

	if dir, has := c.Base.NewCamp(camp.Id).GetDirecteurEquipier(); has && equipier.Roles.Is(rd.RDirecteur) {
		c.main.ShowError(fmt.Errorf("Le séjour a déjà un directeur <i>%s</i>", dir.GetPersonne().RawData().NomPrenom()))
		return false
	}

	job := func() (interface{}, error) {
		var out apiserver.CreateEquipierOut
		err := requete(apiserver.UrlEquipiers, http.MethodPut, equipier, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.CreateEquipierOut)
		c.Base.Equipiers[out.Equipier.Id] = out.Equipier
		c.Base.EquipierContraintes[out.Equipier.Id] = out.Contraintes
		c.main.ShowStandard("Equipier ajouté avec succès.", false)
		c.main.ResetAllControllers()
	}

	c.main.ShowStandard("Ajout de l'équipier en cours...", true)
	c.main.Background.Run(job, onSuccess)
	return true
}

// SupprimePersonne supprime l'équipier courant.
// S'il est temporaire, la personne et les documents liés sont aussi supprimés.
func (c *Equipiers) SupprimeEquipier() {
	if c.Etat.EquipierCurrent == nil {
		return
	}
	part := c.Base.NewEquipier(c.Etat.EquipierCurrent.Int64())
	acPers := part.GetPersonne()
	pers := acPers.RawData()

	if !c.Onglet.ConfirmeSupprimeEquipier(pers) {
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteEquipierOut
		err := requete(apiserver.UrlEquipiers, http.MethodDelete, IdAsParams(part.Id), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteEquipierOut)
		c.Etat.EquipierCurrent = nil
		for _, idDoc := range out.IdsDocuments {
			delete(c.Base.Documents, idDoc)
		}
		delete(c.Base.Equipiers, part.Id)
		delete(c.Base.Personnes, out.IdPersonne)
		c.main.ShowStandard(fmt.Sprintf("Equipier bien supprimé (ainsi que %d document(s) associé(s))", len(out.IdsDocuments)), false)
		c.main.ResetAllControllers()

	}

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

// IdentifieTmp identifie l'équipier courant avec la personne fournie.
// Si `cree` vaut `true`, la personne est créée.
func (c *Equipiers) IdentifieTmp(target matching.IdentifieTarget) {
	if c.Etat.EquipierCurrent == nil {
		return
	}
	equipier := c.Base.NewEquipier(c.Etat.EquipierCurrent.Int64())
	persTmp := equipier.GetPersonne()
	if !persTmp.RawData().IsTemporaire {
		c.main.ShowError(errors.New("Veuillez sélectionner un équipier temporaire !"))
		return
	}

	params := apiserver.IdentifiePersonneIn{IdPersonneTmp: persTmp.Id}
	switch target := target.(type) {
	case matching.NouveauProfil: // rien à transmettre
	case matching.Rattache:
		params.Rattache = true
		params.IdPersonneTarget = target.IdTarget
		params.Modifications = target.Modifications
	}

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

	// alerte pour les catégories de docs en double
	if params.Rattache {
		cache := c.Base.ResoudDocumentsPersonnes()

		// on calcule les catégories nouvelles
		idsContraintes := rd.NewSet()
		for _, doc := range persTmp.GetDocuments(cache) {
			idsContraintes.Add(doc.GetContrainte().Id)
		}

		// parmi les documents existants, on sélectionne ceux qui vont produire un doublon
		var filteredDocs []dm.AccesDocumentPersonne
		for _, doc := range c.Base.NewPersonne(params.IdPersonneTarget).GetDocuments(cache) {
			if idsContraintes.Has(doc.GetContrainte().Id) {
				filteredDocs = append(filteredDocs, doc)
			}
		}
		sort.Slice(filteredDocs, func(i, j int) bool {
			return filteredDocs[i].GetContrainte().Id < filteredDocs[j].GetContrainte().Id
		})

		if len(filteredDocs) > 0 {
			docsToSupp := c.Onglet.ChoixEviteDoublonsDocuments(filteredDocs)
			if docsToSupp == nil {
				c.main.ShowStandard("Identification annulée.", false)
				return
			}
			params.SupprimeDocuments = docsToSupp
		}
	}
	paramsFull := apiserver.IdentifieEquipierIn{
		IdEquipier:          equipier.Id,
		IdentifiePersonneIn: params,
	}
	job := func() (interface{}, error) {
		var out apiserver.IdentifieEquipierOut
		err := requete(apiserver.UrlIdentifieEquipier, http.MethodPut, paramsFull, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.IdentifieEquipierOut)
		c.Base.Equipiers[out.Equipier.Id] = out.Equipier
		c.Base.ApplyIdentifie(out.IdentifiePersonneOut)
		c.main.ShowStandard(fmt.Sprintf("Equipier identifié en %s", out.Personne.NomPrenom()), false)
		c.main.ResetAllControllers()
	}

	c.main.ShowStandard("Identification de l'équipier en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

// ExportEquipiers génère la liste des équpiers courant au format excel
// et renvoi le chemin du fichier créé.
func (c *Equipiers) ExportEquipiers() string {
	additionnalHeaders := []rd.Header{
		{Field: dm.PersonneMail, Label: "Adresse mail"},
		{Field: dm.PersonneTels, Label: "Téléphones"},
		{Field: dm.PersonneAdresse, Label: "Adresse"},
		{Field: dm.PersonneCodePostal, Label: "Code postal"},
		{Field: dm.PersonneVille, Label: "Ville"},
	}
	headers := append(c.Header, additionnalHeaders...)
	buf, err := table.GenereListeEquipe(headers, c.Liste, false)
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	path, err := filepath.Abs(filepath.Join(LocalFolder, "equipiers.xlsx"))
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	if err = ioutil.WriteFile(path, buf.Bytes(), 0666); err != nil {
		c.main.ShowError(fmt.Errorf("Impossible d'enregistrer le fichier : %s", err))
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Equipier exportés dans %s", path), false)
	return path
}