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

package controllers

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"sort"
	"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"
	"github.com/benoitkugler/goACVE/server/core/utils/table"
)

var headerDonateursCoords = []rd.Header{
	{Field: dm.DonDonateurAdresse, Label: "Adresse"},
	{Field: dm.DonDonateurCodePostal, Label: "Code postal"},
	{Field: dm.DonDonateurVille, Label: "Ville"},
	{Field: dm.DonDonateurPays, Label: "Pays"},
	{Field: dm.DonDonateurMail, Label: "Mail"},
	{Field: dm.DonDonateurTels, Label: "Tels."},
}

const (
	DonsCourants = "courants"
	DonsTous     = "tous"
	DonsAnnee    = "annee"
)

type ButtonsDons struct {
	Creer, Supprimer, EditerRecus, ExporterListe, ImportHelloasso EtatSideButton
}

type OngletDons interface {
	baseOnglet

	ConfirmeForceRecuFiscal(don dm.AccesDon) bool
}

type EtatDons struct {
	DonCurrent   rd.IId
	Recherche    string
	CritereEmis  rd.OptionnalBool
	CritereAnnee int
	// Sélection du donateur
	// Oui: uniquement organismes, Non: uniquement personne, Indiff: tous
	CritereOrganismes rd.OptionnalBool
}

type Dons struct {
	Onglet    OngletDons
	main      *MainController
	Liste     rd.Table
	Header    []rd.Header
	Base      *dm.BaseLocale
	Etat      EtatDons
	EditRight bool // Droit d'ajout/edition/suppression
}

func NewDons(main *MainController, permission int) *Dons {
	return &Dons{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.DonDonateur, Label: "Donateur"},
			{Field: dm.DonValeur, Label: "Valeur"},
			{Field: dm.DonModePaiement, Label: "Mode de paiement"},
			{Field: dm.DonDateReception, Label: "Date de réception"},
			{Field: dm.DonRemercie, Label: "Remercié ?"},
			{Field: dm.DonRecuEmis, Label: "Reçu fiscal émis le"},
			{Field: dm.DonDetails, Label: "Détails"},
			{Field: dm.DonAffectation, Label: "Affectation"},
		}}
}

func (c *Dons) resetData() {
	c.Liste = make(rd.Table, 0, len(c.Base.Dons))
	cEmis, cDonateur, cAnnee := c.Etat.CritereEmis, c.Etat.CritereOrganismes, c.Etat.CritereAnnee
	for id, don := range c.Base.Dons {
		match := cEmis == 0 || don.RecuEmis.Time().IsZero() != cEmis.Bool()
		match = match && cAnnee == 0 || don.DateReception.Time().Year() == cAnnee
		_, isDonateurOrga := c.Base.DonDonateurs[id].IId().(rd.IdOrganisme)
		match = match && (cDonateur == rd.OBPeutEtre || cDonateur.Bool() == isDonateurOrga)
		if match {
			c.Liste = append(c.Liste, c.Base.NewDon(id).AsItem())
		}
	}

	if search := strings.TrimSpace(c.Etat.Recherche); search != "" {
		c.Liste = dm.RechercheDetaillee(c.Liste, search, c.Header)
	}

	sort.Slice(c.Liste, func(i, j int) bool {
		return c.Liste[i].Id.Int64() < c.Liste[j].Id.Int64()
	})
	dm.SortStableBy(c.Liste, dm.DonDateReception, true)

	// besoin de déselectionner si absent des critères :
	if c.Etat.DonCurrent != nil && !HasId(c.Liste, c.Etat.DonCurrent) {
		c.Etat.DonCurrent = nil
	}
}

// GetStats renvoi le total des dons, pour les personnes et pour les organismes
// pour le critère courant.
func (c *Dons) GetStats() []Stat {
	var totalOrga, totalPers rd.Euros
	for _, p := range c.Liste {
		idDon := p.Id.Int64()
		don := c.Base.Dons[idDon]
		switch c.Base.DonDonateurs[idDon].IId().(type) {
		case rd.IdOrganisme:
			totalOrga += don.Valeur
		case rd.IdPersonne:
			totalPers += don.Valeur
		}
	}
	return []Stat{
		{Label: "Montant total pour les personnes", Value: totalPers.String()},
		{Label: "Montant total pour les organismes", Value: totalOrga.String()},
	}
}

func (c *Dons) PossibleYears() []int {
	tmp := map[int]bool{}
	for _, don := range c.Base.Dons {
		tmp[don.DateReception.Time().Year()] = true
	}
	delete(tmp, 0) // si une date est vide
	var out []int
	for y := range tmp {
		out = append(out, y)
	}
	sort.Ints(out)
	return out
}

func (c *Dons) SideButtons() ButtonsDons {
	bs := ButtonsDons{}
	if c.EditRight {
		bs.Creer = ButtonActivated
		EtatButton := ButtonPresent
		if c.Etat.DonCurrent != nil {
			EtatButton = ButtonActivated
		}
		bs.Supprimer = EtatButton
		bs.EditerRecus = ButtonActivated
		bs.ImportHelloasso = ButtonActivated
	}
	bs.ExporterListe = ButtonActivated
	return bs
}

// CreeDon enregistre le nouveau don sur le serveur
func (c *Dons) CreeDon(don apiserver.CreateDonIn) {
	job := func() (interface{}, error) {
		var out apiserver.CreateDonIn
		err := requete(apiserver.UrlDons, http.MethodPut, don, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.CreateDonIn)
		c.Base.ApplyCreateDon(out)
		c.main.ShowStandard("Don enregistré avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Création du don...", true)
	c.main.Background.Run(job, onSuccess)
}

// UpdateDon met à jour les profils transmis sur le serveur
func (c *Dons) UpdateDon(don apiserver.CreateDonIn) {
	job := func() (interface{}, error) {
		var out apiserver.CreateDonIn
		err := requete(apiserver.UrlDons, http.MethodPost, don, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.CreateDonIn)
		c.Base.ApplyCreateDon(out)
		c.main.ShowStandard("Don mis à jour avec succès.", false)
		c.Reset()
	}

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

// SupprimeDon supprime le don courant, sans demander de confirmation
func (c *Dons) SupprimeDon() {
	if c.Etat.DonCurrent == nil {
		c.main.ShowError(errors.New("Aucun don courant !"))
		return
	}
	idDon := c.Etat.DonCurrent.Int64()
	job := func() (interface{}, error) {
		var out rd.Don
		err := requete(apiserver.UrlDons, http.MethodDelete, IdAsParams(idDon), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Don)
		c.Etat.DonCurrent = nil
		delete(c.Base.Dons, idDon)
		delete(c.Base.DonDonateurs, idDon)
		c.main.ShowStandard(fmt.Sprintf("Don (id %d) supprimé avec succès.", out.Id), false)
		c.Reset()
	}

	c.main.ShowStandard("Suppression du don...", true)
	c.main.Background.Run(job, onSuccess)
}

// ExporteListe enregistre la liste courante des dons au format Excel,
// et renvoie le chemin du document.
func (c *Dons) ExporteListe(avecCoordonnees bool) string {
	if len(c.Liste) == 0 {
		c.main.ShowError(errors.New("Aucun don à exporter."))
		return ""
	}
	var total rd.Euros
	for _, item := range c.Liste { // filtre annonyme + total
		d := c.Base.Dons[item.Id.Int64()]
		total += d.Valeur
	}
	headers := c.Header
	if avecCoordonnees {
		headers = append(headers, headerDonateursCoords...)
	}
	path, err := table.EnregistreDons(headers, c.Liste, total, LocalFolder)
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Liste des dons enregistré dans %s", path), false)
	return path
}

// EditeRecusFiscaux lance l'édition des reçus fiscaux et des étiquettes, de manière SYNCHRONE.
func (c *Dons) EditeRecusFiscaux(params dm.OptionsRecuFiscal) string {
	c.main.ShowStandard("Edition du reçu fiscal...", true)
	resp, err := requeteResponseMultipart(apiserver.UrlRecuFiscal, http.MethodPost, params)
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	jsonData, archive := resp[apiserver.RecusFiscauxJSONKey], resp[apiserver.RecusFiscauxZIPKey]
	var dons rd.Dons
	if err = json.Unmarshal(jsonData, &dons); err != nil {
		c.main.ShowError(err)
		return ""
	}
	for id, don := range dons {
		c.Base.Dons[id] = don
	}
	path := c.main.SaveFile(archive, "recus_fiscaux_ACVE.zip")
	if path != "" {
		c.main.ShowStandard(fmt.Sprintf("Reçus fiscaux enregistrés : %s", path), false)
	}
	return path
}

type DonsImported []apiserver.DonDonateur

var HeaderDonImported = []rd.Header{
	{Field: dm.DonDonateur, Label: "Donateur"},
	{Field: dm.DonDateReception, Label: "Effectué le"},
	{Field: dm.DonValeur, Label: "Montant"},
	{Field: dm.LastField + 1, Label: "ID HelloAsso"},
}

// on identifie les dons par leur index dans une slice
func donDonateurToItem(d apiserver.DonDonateur, i int) rd.Item {
	fields := rd.F{
		dm.DonDonateur:      d.Donateur.NomPrenom(),
		dm.DonValeur:        d.Don.Valeur,
		dm.DonDateReception: d.Don.DateReception,
		dm.LastField + 1:    rd.String(d.Don.Infos.IdPaiementHelloAsso),
	}
	return rd.Item{Id: rd.Id(i), Fields: fields}
}

func (ds DonsImported) Table() rd.Table {
	table := make(rd.Table, len(ds))
	for i, d := range ds {
		table[i] = donDonateurToItem(d, i)
	}
	return table
}

// ChargeDonsHelloasso charge et renvoie les dons
// de l'API HelloAsso.
func (c *Dons) ChargeDonsHelloasso() DonsImported {
	var out DonsImported
	err := requete(apiserver.UrlDonsHelloasso, http.MethodGet, nil, &out)
	if err != nil {
		c.main.ShowError(err)
	} else if len(out) == 0 {
		c.main.ShowError(errors.New("Aucun nouveau don à importer."))
	}
	return out
}

// IdentifieDonHelloasso crée un nouveau don et identifie son donateur,
// en créant si demandé un nouveau profil, de manière asynchrone.
func (c *Dons) IdentifieDonHelloasso(don apiserver.DonDonateur, target matching.IdentifieTarget) {
	params := apiserver.IdentifieDonIn{Don: don.Don}
	switch target := target.(type) {
	case matching.NouveauProfil:
		params.Rattache = false
		params.Modifications = don.Donateur
	case matching.Rattache:
		params.Rattache = true
		params.Modifications = target.Modifications
		params.IdPersonneTarget = target.IdTarget
	}
	job := func() (interface{}, error) {
		var out apiserver.IdentifieDonOut
		err := requete(apiserver.UrlDonsHelloasso, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.IdentifieDonOut)
		c.Base.ApplyIdentifieDon(out)
		c.Etat.DonCurrent = rd.Id(out.Don.Id)
		c.main.ShowStandard("Don importé avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Import du don...", true)
	c.main.Background.Run(job, onSuccess)
}