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

package controllers

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

	"errors"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	"github.com/benoitkugler/goACVE/server/core/utils/table"

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

type ButtonsAides struct {
	Creer, AfficherStructures, Supprimer, Documents, Exporter EtatSideButton
}

type OngletAides interface {
	baseOnglet

	ConfirmeSupprimeAide(dm.AccesAide) bool
	ConfirmeSupprimeStructureaide(msg string) bool
}

type EtatAides struct {
	AideCurrent   rd.IId
	Recherche     string
	CritereCamp   rd.OptionnalId
	CritereValide rd.OptionnalBool
}

type Aides struct {
	Onglet    OngletAides
	main      *MainController
	Liste     rd.Table
	Header    []rd.Header
	Base      *dm.BaseLocale
	Etat      EtatAides
	EditRight bool // Droit d'édition/ajout/suppression
}

func NewAides(main *MainController, permission int) *Aides {
	a := Aides{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.AideStructure, Label: "Organisme"},
			{Field: dm.AideNomPrenom, Label: "Participant"},
			{Field: dm.AideCamp, Label: "Camp"},
			{Field: dm.AideValide, Label: "Valide"},
			{Field: dm.AideMontant, Label: "Montant"},
			{Field: dm.AideNbJoursMax, Label: "Limite"},
			{Field: dm.AideAnnee, Label: "Année"},
		}}
	a.resetData()
	return &a
}

func (c *Aides) resetData() {
	c.Liste = make(rd.Table, 0, len(c.Base.Aides))
	cValide, cCamp := c.Etat.CritereValide, c.Etat.CritereCamp
	for id, aide := range c.Base.Aides {
		ac := c.Base.NewAide(id)
		match := cValide == 0 || cValide.Bool() == bool(aide.Valide)                        // critère de validité
		match = match && (cCamp.IsNil() || cCamp.Int64 == ac.GetParticipant().GetCamp().Id) // critère de camp
		if match {
			c.Liste = append(c.Liste, ac.AsItem())
		}
	}
	if strings.TrimSpace(c.Etat.Recherche) != "" {
		c.Liste = dm.RechercheDetaillee(c.Liste, c.Etat.Recherche, c.Header)
	}

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

func (c *Aides) SideButtons() ButtonsAides {
	bs := ButtonsAides{}
	bs.Documents = ButtonActivated
	bs.AfficherStructures = ButtonActivated
	bs.Exporter = ButtonPresent
	if len(c.Liste) > 0 {
		bs.Exporter = ButtonActivated
	}
	if c.EditRight {
		bs.Creer = ButtonActivated
		if c.Etat.AideCurrent != nil {
			bs.Supprimer = ButtonActivated
		} else {
			bs.Supprimer = ButtonPresent
		}
	}
	return bs
}

// StatsAides renvoi les statistiques courantes
func (c *Aides) GetStats() []Stat {
	return []Stat{
		{Label: "Nombre d'aides", Value: strconv.Itoa(len(c.Base.Aides))},
		{Label: "Nombre d'organismes", Value: strconv.Itoa(len(c.Base.Structureaides))},
	}
}

// JobCreeAide demande au serveur l'ajout de l'aide.
// Peut être utilisé de manière synchrone.
// Sinon, préférer `CreeAide`
func JobCreeAide(aide rd.Aide) (rd.Aide, error) {
	var out rd.Aide
	err := requete(apiserver.UrlAides, http.MethodPut, aide, &out)
	return out, err
}

// CreeAide crée une nouvelle aide de manière asynchrone, sur le serveur
func (c *Aides) CreeAide(aide rd.Aide) {
	job := func() (interface{}, error) {
		return JobCreeAide(aide)
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Aide)
		c.Base.Aides[out.Id] = out
		c.main.ShowStandard("Aide ajoutée avec succès.", false)
		c.Reset()
	}
	c.main.ShowStandard("Création de l'aide...", true)
	c.main.Background.Run(job, onSuccess)
}

// UpdateAide met à jour de manière synchrone l'aide transmise sur le serveur
func (c *Aides) UpdateAide(aide rd.Aide) {
	job := func() (interface{}, error) {
		var out rd.Aide
		err := requete(apiserver.UrlAides, http.MethodPost, aide, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Aide)
		c.Base.Aides[out.Id] = out
		c.main.ShowStandard("Aide mise à jour avec succès.", false)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Mise à jour de l'aide...", true)
	c.main.Background.Run(job, onSuccess)
}

// SupprimeAide supprime l'aide de manière asynchrone, sans confirmation
func (c *Aides) SupprimeAide(idAide int64) {
	job := func() (interface{}, error) {
		var out []int64
		err := requete(apiserver.UrlAides, http.MethodDelete, IdAsParams(idAide), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.([]int64)
		delete(c.Base.Aides, idAide)
		msg := "Aide supprimée avec succès."
		for _, idDoc := range out {
			delete(c.Base.Documents, idDoc)
		}
		if len(out) > 0 {
			msg += " %d document(s) associés supprimés."
		}
		c.main.ShowStandard(msg, false)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Suppression de l'aide...", true)
	c.main.Background.Run(job, onSuccess)
}

// SupprimeAideCourante supprime l'aide courante, après confirmation
func (c *Aides) SupprimeAideCourante() {
	if c.Etat.AideCurrent == nil {
		return
	}
	idAide := c.Etat.AideCurrent.Int64()
	if !c.Onglet.ConfirmeSupprimeAide(c.Base.NewAide(idAide)) {
		c.main.ShowStandard("Suppression annulée.", false)
		return
	}

	c.Etat.AideCurrent = nil
	c.SupprimeAide(idAide)
}

// -------------------------- Structures --------------------------

// CreeStructureaide crée une nouvelle structure sur le serveur, SYNCHRONE
func (c *Aides) CreeStructureaide(strucAide rd.Structureaide) (dm.AccesStructureaide, bool) {
	c.main.ShowStandard("Création de la structure d'aide...", true)
	var out rd.Structureaide
	err := requete(apiserver.UrlStructureaides, http.MethodPut, strucAide, &out)
	if err != nil {
		c.main.ShowError(err)
		return dm.AccesStructureaide{}, false
	}
	c.Base.Structureaides[out.Id] = out
	c.main.ShowStandard("Structure ajoutée avec succès.", false)
	c.Reset()
	return c.Base.NewStructureaide(out.Id), true
}

// UpdateStructureaide met à jour la structure transmise sur le serveur
func (c *Aides) UpdateStructureaide(structAide rd.Structureaide) {
	job := func() (interface{}, error) {
		var out rd.Structureaide
		err := requete(apiserver.UrlStructureaides, http.MethodPost, structAide, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Structureaide)
		c.Base.Structureaides[out.Id] = out
		c.main.ShowStandard("Structure mise à jour avec succès.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Mise à jour de la structure d'aide...", true)
	c.main.Background.Run(job, onSuccess)
}

// SupprimeStructureaide supprime la structure, après confirmation
func (c *Aides) SupprimeStructureaide(idStructure int64) bool {
	var nbAides int
	for _, aide := range c.Base.Aides {
		if aide.IdStructureaide == idStructure {
			nbAides += 1
		}
	}
	msg := "Voulez-vous vraiment <b>supprimer</b> la structure ?"
	if nbAides > 0 {
		msg += fmt.Sprintf("<br/>Attention, <b>%d</b> aides liées seront supprimées !", nbAides)
	}
	if !c.Onglet.ConfirmeSupprimeStructureaide(msg) {
		c.main.ShowStandard("Suppression annulée", false)
		return false
	}

	var out apiserver.DeleteStructureaideOut
	err := requete(apiserver.UrlStructureaides, http.MethodDelete, IdAsParams(idStructure), &out)
	if err != nil {
		c.main.ShowError(err)
		return false
	}
	delete(c.Base.Structureaides, idStructure)
	msg = "Structure supprimée avec succès."
	for _, idAide := range out.IdsAides {
		delete(c.Base.Aides, idAide)
	}
	c.Base.CleanupDocuments(out.IdsDocuments)
	if L := len(out.IdsAides); L > 0 {
		msg += fmt.Sprintf(" %d aides(s) associées supprimées.", L)
	}
	c.main.ShowStandard(msg, false)
	c.main.ResetAllControllers()
	return true
}

func (c *Aides) ExportAides() string {
	if len(c.Liste) == 0 {
		c.main.ShowError(errors.New("Aucune aide choisie !"))
		return ""
	}
	path, err := table.GenereListeAides(c.Header, c.Liste, LocalFolder)
	if err != nil {
		c.main.ShowError(fmt.Errorf("Impossible de générer la liste des aides : %s", err))
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Liste générée dans %s", path), false)
	return path
}

// SelectAide sélectionne l'aide donnée, en remettant à zéro la recherche
// si nécessaire.
func (c *Aides) SelectAide(aide dm.AccesAide) {
	if _, in := c.Base.Aides[aide.Id]; !in {
		c.main.ShowError(fmt.Errorf("L'aide demandée (id %d) n'est pas dans la base !", aide.Id))
		return
	}
	c.Etat.AideCurrent = rd.Id(aide.Id)

	if !HasId(c.Liste, rd.Id(aide.Id)) {
		c.Etat = EtatAides{} // remet à zéro les critères
		c.resetData()
	}
	c.Onglet.GrabFocus()
	c.ResetRender()
}