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

package controllers

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

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

const (
	HistoriqueCamp rd.Field = iota
	HistoriqueAnnee
	HistoriqueRole
)

type ButtonsPersonnes struct {
	Creer, AfficherCriteres, AfficherDocuments, Supprimer EtatSideButton
}

type OngletPersonnes interface {
	baseOnglet

	ConfirmeSupprimePersonne(pers dm.AccesPersonne) bool
	ConfirmeSupprimeOrganisme(org dm.AccesOrganisme) bool
}

type EtatPersonnes struct {
	ItemCurrent           rd.IId // personne ou organisme
	Recherche             string
	CriteresTri           dm.CriteresTri
	CritereShowTemporaire rd.Bool
	CritereShowOrganismes rd.OptionnalBool // oui = orga seul, non = personnes seul, indif = tous
}

type Personnes struct {
	Onglet                 OngletPersonnes
	main                   *MainController
	Liste                  rd.Table
	Header                 []rd.Header
	Base                   *dm.BaseLocale
	Etat                   EtatPersonnes
	DeleteRight, EditRight bool // Droit de suppression, droit d'ajout/edition
}

func NewPersonnes(main *MainController, permission int) *Personnes {
	p := Personnes{main: main, Base: main.Base, DeleteRight: permission >= 4, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.PersonneNomPrenom, Label: "Nom"},
			{Field: dm.PersonneSexe, Label: "Sexe"},
			{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
			{Field: dm.PersonneMail, Label: "Adresse mail"},
			{Field: dm.PersonneAdresse, Label: "Adresse"},
			{Field: dm.PersonneCodePostal, Label: "Code postal"},
			{Field: dm.PersonneVille, Label: "Ville"},
			{Field: dm.PersonnePays, Label: "Pays"},
			{Field: dm.PersonneRangMembreAsso, Label: "Association"},
			{Field: dm.PersonneCotisation, Label: "Cotisation"},
		},
		Etat: EtatPersonnes{CriteresTri: dm.CriteresTri{Fields: []dm.Critere{{Field: dm.PersonneNomPrenom}}}},
	}
	p.resetData()
	return &p
}

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

	if c.Etat.CritereShowOrganismes != rd.OBOui {
		for id, p := range c.Base.Personnes {
			if c.Etat.CritereShowTemporaire == p.IsTemporaire {
				c.Liste = append(c.Liste, c.Base.NewPersonne(id).AsItem(0))
			}
		}
	}

	if c.Etat.CritereShowOrganismes != rd.OBNon {
		// on affiche aussi les organismes
		for id := range c.Base.Organismes {
			c.Liste = append(c.Liste, c.Base.NewOrganisme(id).AsItem())
		}
	}

	if search := strings.TrimSpace(c.Etat.Recherche); search != "" {
		c.Liste = dm.RechercheDetaillee(c.Liste, search, c.Header)
	}
	// besoin de déselectionner si absent de la Recherche :
	if c.Etat.ItemCurrent != nil && !HasId(c.Liste, c.Etat.ItemCurrent) {
		c.Etat.ItemCurrent = nil
	}
	dm.SortCriteres(c.Liste, c.Etat.CriteresTri)
}

func (c *Personnes) SideButtons() ButtonsPersonnes {
	bs := ButtonsPersonnes{
		AfficherCriteres:  ButtonActivated,
		AfficherDocuments: ButtonActivated,
	}
	if c.EditRight {
		bs.Creer = ButtonActivated
	}
	if c.DeleteRight {
		bs.Supprimer = ButtonPresent
		if c.Etat.ItemCurrent != nil {
			bs.Supprimer = ButtonActivated
		}
	}
	return bs
}

// GetStats renvoi les statistiques courantes
func (c *Personnes) GetStats() []Stat {
	var ph, pe, er, vp, as, ca, bu, nbTmp int
	for _, p := range c.Base.Personnes {
		if p.IsTemporaire {
			nbTmp += 1
			continue
		}
		if p.PubHiver {
			ph += 1
		}
		if p.PubEte {
			pe += 1
		}
		if p.EchoRocher {
			er += 1
		}
		if p.VersionPapier {
			vp += 1
		}
		switch p.RangMembreAsso {
		case "1":
			as += 1
		case "2":
			as += 1
			ca += 1
		case "3":
			as += 1
			ca += 1
			bu += 1
		}
	}
	return []Stat{
		{Label: "Nombre total de personnes", Value: fmt.Sprintf("%d (+ %d temporaires)", len(c.Base.Personnes)-nbTmp, nbTmp)},
		{Label: "Publicités Hiver / Eté", Value: fmt.Sprintf("%d / %d", ph, pe)},
		{Label: "Echo du Rocher (version papier)", Value: fmt.Sprintf("%d (%d)", er, vp)},
		{Label: "Membres Association / C.A. / Bureau", Value: fmt.Sprintf("%d / %d / %d", as, ca, bu)},
	}
}

// GetParentsEnfants renvoie les liens familliaux de la personne `id`,
// au sens des dossiers (responsable/participants)
func (c *Personnes) GetParentsEnfants(id rd.IdPersonne) (parents []dm.AccesPersonne, enfants []dm.AccesPersonne) {
	cache, _ := c.Base.ResoudParticipants()
	cribleEnfants, cribleParents := rd.NewSet(), rd.NewSet()
	for _, dossier := range c.Base.Factures {
		if dossier.IdPersonne == id.Int64() {
			// on ajoute les participants comme 'enfants'
			for _, part := range c.Base.NewFacture(dossier.Id).GetDossiers(cache) {
				cribleEnfants.Add(part.GetPersonne().Id)
			}
		}
	}
	for _, part := range c.Base.Participants {
		if part.IdPersonne == id.Int64() {
			// on ajoute le responsable du dossier comme parent
			if fac, has := c.Base.NewParticipant(part.Id).GetFacture(); has {
				cribleParents.Add(fac.GetPersonne().Id)
			}
		}
	}
	for i := range cribleParents {
		parents = append(parents, c.Base.NewPersonne(i))
	}
	for i := range cribleEnfants {
		enfants = append(enfants, c.Base.NewPersonne(i))
	}
	return
}

// GetHistorique renvoie l'historique (comme participant et équipier) de la personne donnée
func (c *Personnes) GetHistorique(idPersonne int64) rd.Table {
	var out rd.Table
	for _, part := range c.Base.Participants {
		if part.IdPersonne == idPersonne {
			camp := c.Base.NewParticipant(part.Id).GetCamp().RawData()
			fields := rd.F{
				HistoriqueCamp:  camp.Label(),
				HistoriqueAnnee: camp.Annee(),
				HistoriqueRole:  part.ListeAttente.String(),
			}
			out = append(out, rd.Item{Fields: fields})
		}
	}
	for _, part := range c.Base.Equipiers {
		if part.IdPersonne == idPersonne {
			camp := c.Base.NewParticipant(part.Id).GetCamp().RawData()
			fields := rd.F{
				HistoriqueCamp:  camp.Label(),
				HistoriqueAnnee: camp.Annee(),
				HistoriqueRole:  part.Roles,
			}
			out = append(out, rd.Item{Fields: fields})
		}
	}
	return out
}

// CreePersonne crée un nouveau profil sur le serveur
func (c *Personnes) CreePersonne(pers rd.Personne) {
	job := func() (interface{}, error) {
		var out rd.Personne
		err := requete(apiserver.UrlPersonnes, http.MethodPut, pers, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Personne)
		c.Base.Personnes[out.Id] = out
		c.Etat.ItemCurrent = rd.IdPersonne(out.Id)
		c.main.ShowStandard(fmt.Sprintf("Personne %s créée avec succès.", out.NomPrenom()), false)
		c.Reset()
	}
	c.main.ShowStandard("Création de la personne...", true)
	c.main.Background.Run(job, onSuccess)
}

// UpdatePersonne met à jour le profil transmis sur le serveur
func (c *Personnes) UpdatePersonne(pers rd.Personne) {
	job := func() (interface{}, error) {
		var out rd.Personne
		err := requete(apiserver.UrlPersonnes, http.MethodPost, pers, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Personne)
		c.Base.Personnes[out.Id] = out
		c.main.ShowStandard(fmt.Sprintf("Personne %s mise à jour avec succès.", out.NomPrenom()), false)
		c.main.ResetAllControllers()
	}

	c.main.ShowStandard("Mise à jour de la personne...", true)
	c.main.Background.Run(job, onSuccess)
}

// CreeOrganisme crée un nouveau profil sur le serveur
func (c *Personnes) CreeOrganisme(org rd.Organisme) {
	job := func() (interface{}, error) {
		var out rd.Organisme
		err := requete(apiserver.UrlOrganismes, http.MethodPut, org, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Organisme)
		c.Base.Organismes[out.Id] = out
		c.Etat.ItemCurrent = rd.IdOrganisme(out.Id)
		c.main.ShowStandard(fmt.Sprintf("Organisme %s créé avec succès.", out.Nom), false)
		c.Reset()
	}
	c.main.ShowStandard("Création de l'organisme...", true)
	c.main.Background.Run(job, onSuccess)
}

// UpdateOrganisme met à jour le profil transmis sur le serveur,
// de manière asynchrone.
func (c *Personnes) UpdateOrganisme(org rd.Organisme) {
	job := func() (interface{}, error) {
		var out rd.Organisme
		err := requete(apiserver.UrlOrganismes, http.MethodPost, org, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Organisme)
		c.Base.Organismes[out.Id] = out
		c.main.ShowStandard(fmt.Sprintf("Organisme %s mis à jour avec succès.", out.Nom), false)
		c.main.ResetAllControllers()
	}

	c.main.ShowStandard("Mise à jour de l' organisme...", true)
	c.main.Background.Run(job, onSuccess)
}

// checkSupprimePersonne vérifie que la personne donnée peut être supprimée
func (c *Personnes) checkSupprimePersonne(id int64) error {
	for _, doc := range c.Base.DocumentPersonnes {
		if doc.IdPersonne == id {
			return fmt.Errorf("Id %d présent dans le document %d!", id, doc.IdDocument)
		}
	}
	for _, donateur := range c.Base.DonDonateurs {
		if donateur.IdPersonne.Is(id) {
			return fmt.Errorf("Id %d présent dans le don %d !", id, donateur.IdDon)
		}
	}
	for _, part := range c.Base.Participants {
		if part.IdPersonne == id {
			return fmt.Errorf("Id %d présent dans le participant %d !", id, part.Id)
		}
	}
	for _, part := range c.Base.Participantsimples {
		if part.IdPersonne == id {
			return fmt.Errorf("Id %d présent dans le participant %d !", id, part.Id)
		}
	}
	for _, equipier := range c.Base.Equipiers {
		if equipier.IdPersonne == id {
			return fmt.Errorf("Id %d présent dans l'équipier %d !", id, equipier.Id)
		}
	}
	for _, fac := range c.Base.Factures {
		if fac.IdPersonne == id {
			return fmt.Errorf("Id %d présent dans la facture %d !", id, fac.Id)
		}
	}
	for _, contrainte := range c.Base.Contraintes {
		if contrainte.IdPersonne.Is(id) {
			return fmt.Errorf("Id %d présent dans la contrainte %d !", id, contrainte.Id)
		}
	}
	return nil
}

func (c *Personnes) supprimePersonne(id rd.IdPersonne) {
	idP := id.Int64()
	err := c.checkSupprimePersonne(idP)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	if !c.Onglet.ConfirmeSupprimePersonne(c.Base.NewPersonne(idP)) {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out rd.Personne
		err = requete(apiserver.UrlPersonnes, http.MethodDelete, IdAsParams(idP), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Personne)
		c.main.ShowStandard(fmt.Sprintf("Personne %s supprimée avec succès.", out.NomPrenom()), false)
		c.Etat.ItemCurrent = nil
		delete(c.Base.Personnes, out.Id)
		c.Reset()
	}

	c.main.ShowStandard("Suppression de la personne...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *Personnes) supprimeOrganisme(id rd.IdOrganisme) {
	idO := id.Int64()
	if !c.Onglet.ConfirmeSupprimeOrganisme(c.Base.NewOrganisme(idO)) {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteOrganismeOut
		err := requete(apiserver.UrlOrganismes, http.MethodDelete, IdAsParams(idO), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteOrganismeOut)
		c.main.ShowStandard(fmt.Sprintf("Organisme (id %d) supprimé avec succès.", out.Id), false)
		c.Etat.ItemCurrent = nil
		delete(c.Base.Organismes, out.Id)
		for _, idDon := range out.Dons {
			delete(c.Base.Dons, idDon)
			delete(c.Base.DonDonateurs, idDon)
		}
		c.Reset()
	}

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

// SupprimeItem supprime l'item courant, après vérification
func (c *Personnes) SupprimeItem() {
	switch item := c.Etat.ItemCurrent.(type) {
	case rd.IdPersonne:
		c.supprimePersonne(item)
	case rd.IdOrganisme:
		c.supprimeOrganisme(item)
	}
}

// SelectPersonne sélectionne la personne donnée, en remettant à zéro la recherche
// si nécessaire.
func (c *Personnes) SelectPersonne(item dm.PersonneOrganisme) {
	var id rd.IId
	switch item := item.(type) {
	case dm.AccesPersonne:
		if _, in := c.Base.Personnes[item.Id]; !in {
			c.main.ShowError(fmt.Errorf("La personne demandée (id %d) n'est pas dans la base !", item.Id))
			return
		}
		id = rd.IdPersonne(item.Id)
	case dm.AccesOrganisme:
		if _, in := c.Base.Organismes[item.Id]; !in {
			c.main.ShowError(fmt.Errorf("L'organisme demandé (id %d) n'est pas dans la base !", item.Id))
			return
		}
		id = rd.IdOrganisme(item.Id)
	default:
		return
	}

	c.Etat.ItemCurrent = id

	if !HasId(c.Liste, id) {
		c.Etat.Recherche = "" // affiche toutes les personnes
		c.Etat.CritereShowOrganismes = rd.OBPeutEtre
		c.resetData()
	}
	c.Onglet.GrabFocus()
	c.ResetRender()
}