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

package controllers

import (
	"errors"
	"fmt"
	"net/http"
	"sort"

	"github.com/benoitkugler/goACVE/logs"

	"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"
)

var (
	headersBordereauSimple = []rd.Header{
		{Field: dm.PaiementLabelPayeur, Label: "Payé par"},
		{Field: dm.PaiementValeur, Label: "Montant"},
		{Field: dm.PaiementNumero, Label: "Numéro"},
		{Field: dm.PaiementNomBanque, Label: "Banque"},
		{Field: dm.PaiementDateReglement, Label: "Ajouté le"},
		{Field: dm.PaiementDetails, Label: "Détails"},
	}
)

type ButtonsPaiements struct {
	Cree, Supprimer, ExportBordereau EtatSideButton
}

type OngletPaiements interface {
	baseOnglet

	ConfirmeSupprimePaiement(dm.AccesPaiement) bool
	ConfirmeExportPaiements(alreadyExported []rd.Paiement, nb int) (keep bool, simpleHeader bool, marque bool)
}

type EtatPaiements struct {
	PaiementCurrent          rd.IId
	CriterePaiementValide    rd.OptionnalBool
	CriterePaiementBordereau rd.Time
	CriterePaiementFacture   rd.OptionnalId
	CritereFactureCamp       rd.IId
	CritereFactureAcquittee  rd.OptionnalBool
}

type Paiements struct {
	Onglet          OngletPaiements
	main            *MainController
	ListePaiements  rd.Table
	ListeFactures   rd.Table
	HeaderPaiements []rd.Header
	HeaderFactures  []rd.Header
	Base            *dm.BaseLocale
	Etat            EtatPaiements

	// Droit d'édition/ajout/suppression de paiements
	// Droit d'invalidation d'un paiement
	EditRight, InvalideRight bool
}

func NewPaiements(main *MainController, permission int) *Paiements {
	p := Paiements{main: main, Base: main.Base, EditRight: permission >= 2,
		InvalideRight: permission >= 3,
		HeaderPaiements: []rd.Header{
			{Field: dm.PaiementLabelPayeur, Label: "Payé par"},
			{Field: dm.PaiementValeur, Label: "Montant"},
			{Field: dm.PaiementModePaiement, Label: "Mode de paiement"},
			{Field: dm.PaiementNumero, Label: "Numéro"},
			{Field: dm.PaiementNomBanque, Label: "Banque"},
			{Field: dm.PaiementDateReglement, Label: "Ajouté le"},
			{Field: dm.PaiementDetails, Label: "Détails"},
			{Field: dm.PaiementInBordereau, Label: "Bordereau au"},
			{Field: dm.PaiementIsAcompte, Label: "Acompte ?"},
			{Field: dm.PaiementIsRemboursement, Label: "Remboursement ?"},
		},
		HeaderFactures: []rd.Header{
			{Field: dm.PersonneNomPrenom, Label: "Responsable"},
			{Field: dm.FactureCamps, Label: "Camps"},
		},
	}
	p.resetData()
	return &p
}

func (c *Paiements) resetData() {
	c.ListePaiements = nil
	cValide := c.Etat.CriterePaiementValide
	cBordereau := c.Etat.CriterePaiementBordereau
	cFacture := c.Etat.CriterePaiementFacture
	for id, paiement := range c.Base.Paiements {
		match := cValide == 0 || cValide.Bool() != bool(paiement.IsInvalide)
		match = match && (cFacture.IsNil() || cFacture.Int64 == paiement.IdFacture)
		match = match && (cBordereau.Time().IsZero() || paiement.InBordereau == cBordereau)
		if match {
			c.ListePaiements = append(c.ListePaiements, c.Base.NewPaiement(id).AsItem())
		}
	}
	sort.Slice(c.ListePaiements, func(i, j int) bool { // déterminisme
		return c.ListePaiements[i].Id.Int64() < c.ListePaiements[j].Id.Int64()
	})
	dm.SortStableBy(c.ListePaiements, dm.PaiementDateReglement, true)

	// besoin de déselectionner si absent des camps affichés
	if c.Etat.PaiementCurrent != nil && !HasId(c.ListePaiements, c.Etat.PaiementCurrent) {
		c.Etat.PaiementCurrent = nil
	}

	c.ListeFactures = nil
	cCamp := c.Etat.CritereFactureCamp
	cAcquittee := c.Etat.CritereFactureAcquittee
	cache := c.Base.NewCacheEtatFinancier() // mise en cache
	cache2 := c.Base.ResoudMessages()
	for id := range c.Base.Factures {
		acFac := c.Base.NewFacture(id)
		match := true
		if cCamp != nil {
			match = false
			for _, part := range acFac.GetDossiers(cache.FParticipants) {
				if part.GetCamp().Id == cCamp.Int64() {
					match = true
					break
				}
			}
		}
		if cAcquittee != 0 {
			bilan := acFac.EtatFinancier(cache, false)
			match = match && cAcquittee.Bool() == bilan.IsAcquitte()
		}
		if match {
			c.ListeFactures = append(c.ListeFactures, acFac.AsItem(cache.FParticipants, cache2, cache.FPaiements))
		}
	}
	sort.Slice(c.ListeFactures, func(i, j int) bool { // déterminisme
		return c.ListeFactures[i].Id.Int64() < c.ListeFactures[j].Id.Int64()
	})
	dm.SortStableBy(c.ListeFactures, dm.PersonneNomPrenom, false)
}

func (c *Paiements) SideButtons() ButtonsPaiements {
	bs := ButtonsPaiements{}
	if c.EditRight {
		bs.Cree = ButtonActivated
		bs.Supprimer = ButtonPresent
		if c.Etat.PaiementCurrent != nil {
			bs.Supprimer = ButtonActivated
		}
	}
	bs.ExportBordereau = ButtonActivated
	return bs
}

// CreePaiement crée un nouveau paiement sur le serveur,
// de manière SYNCHRONE.
func (c *Paiements) CreePaiement(paiement rd.Paiement) {
	c.main.ShowStandard("Ajout du paiement...", true)
	out := new(rd.Paiement)
	err := requete(apiserver.UrlPaiements, http.MethodPut, paiement, out)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	c.Base.Paiements[out.Id] = *out
	c.main.ShowStandard("Paiement ajouté avec succès.", false)
	c.main.ResetAllControllers()
}

// UpdatePaiement met à jour les paiement transmis sur le serveur
func (c *Paiements) UpdatePaiement(paiement rd.Paiement) {
	job := func() (interface{}, error) {
		var out rd.Paiement
		err := requete(apiserver.UrlPaiements, http.MethodPost, paiement, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Paiement)
		c.Base.Paiements[out.Id] = out
		c.main.ShowStandard("Paiements mis à jour avec succès.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Mise à jour des paiements...", true)
	c.main.Background.Run(job, onSuccess)
}

// SupprimePaiement supprime le paiement courant, après confirmation
func (c *Paiements) SupprimePaiement() {
	if c.Etat.PaiementCurrent == nil {
		return
	}
	idPaiement := c.Etat.PaiementCurrent.Int64()
	if !c.Onglet.ConfirmeSupprimePaiement(c.Base.NewPaiement(idPaiement)) {
		c.main.ShowStandard("Suppression annulée.", false)
		return
	}

	job := func() (interface{}, error) {
		var out rd.Paiement
		err := requete(apiserver.UrlPaiements, http.MethodDelete, IdAsParams(idPaiement), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Paiement)
		c.main.ShowStandard(fmt.Sprintf("Paiement (%d) supprimé avec succès.", out.Id), false)
		c.Etat.PaiementCurrent = nil
		delete(c.Base.Paiements, out.Id)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Suppression du paiement...", true)
	c.main.Background.Run(job, onSuccess)
}

// marque les paiements comme émis (aysnchrone)
func (c *Paiements) marqueAsBordereau(ids rd.Ids) {
	job := func() (interface{}, error) {
		var out rd.Paiements
		err := requete(apiserver.UrlPaiementsBordereau, http.MethodPost, ids, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Paiements)
		for _, paiement := range out {
			c.Base.Paiements[paiement.Id] = paiement
		}
		c.main.ShowStandard("Paiements bien marqués en bordereau.", false)
		c.main.ResetAllControllers()

	}
	c.main.ShowStandard("Mise à jour des paiements...", true)
	c.main.Background.Run(job, onSuccess)
}

// ExportPaiements demande confirmation, puis génère une liste des paiements
// transmis. Lance éventuellement en arrière plan le marquage en bordereau.
// Renvoie le chemin du fichier créé.
func (c *Paiements) ExportPaiements(ids []int64) string {
	if len(ids) == 0 {
		c.main.ShowError(errors.New("Veuillez sélectionner des paiements !"))
		return ""
	}
	var (
		alreadyExported []rd.Paiement
		items           rd.Table
		total           rd.Euros
	)
	for _, id := range ids {
		acPaie := c.Base.NewPaiement(id)
		rawPaie := acPaie.RawData()
		total += rawPaie.Valeur
		if !rawPaie.InBordereau.Time().IsZero() {
			alreadyExported = append(alreadyExported, rawPaie)
		}
		items = append(items, acPaie.AsItem())
	}
	keep, simpleHeader, marque := c.Onglet.ConfirmeExportPaiements(alreadyExported, len(ids))
	if !keep {
		c.main.ShowStandard("Export annulé.", false)
		return ""
	}
	headers := c.HeaderPaiements
	if simpleHeader {
		headers = headersBordereauSimple
	}
	path, err := table.EnregistreListePaiements(headers, items, total, LocalFolder)
	if err != nil {
		c.main.ShowError(fmt.Errorf("L'export des paiements a échoué : %s", err))
		return ""
	}
	if marque {
		c.marqueAsBordereau(ids)
	}
	c.main.ShowStandard("Paiements exportés dans "+path, false)
	return path
}

// SelectPaiement sélectionne le paiement donné, en remettant à zéro les filtres si nécessaire.
func (c *Paiements) SelectPaiement(id int64) {
	if _, in := c.Base.Paiements[id]; !in {
		c.main.ShowError(fmt.Errorf("Le paiement demandé (id %d) n'est pas dans la base !", id))
		return
	}
	c.Etat.PaiementCurrent = rd.Id(id)

	if !HasId(c.ListePaiements, rd.Id(id)) { // affiche toutes les personnes
		c.Etat.CriterePaiementBordereau = rd.Time{}
		c.Etat.CriterePaiementFacture = rd.OptionnalId{}
		c.Etat.CriterePaiementValide = 0
		c.resetData()
	}
	c.Onglet.GrabFocus()
	c.ResetRender()
}

// IdentifieVirement décode le label donné et renvoie le dossier correspondant.
func (c *Paiements) IdentifieVirement(label int) (dm.AccesFacture, bool) {
	id, err := logs.LabelVirement.Parse(label)
	if err != nil {
		c.main.ShowError(err)
		return dm.AccesFacture{}, false
	}
	// le label peut passer le test du décryptage mais être quand même invalide
	if _, ok := c.Base.Factures[id]; !ok {
		c.main.ShowError(fmt.Errorf("Le dossier (id %d) n'existe pas.", id))
		return dm.AccesFacture{}, false
	}
	return c.Base.NewFacture(id), true
}