github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/GUI/onglets/paiements.go

package onglets

import (
	"fmt"
	"time"

	"github.com/benoitkugler/goACVE/server/core/documents"

	"github.com/benoitkugler/goACVE/client/GUI/fields"

	"github.com/benoitkugler/goACVE/client/GUI/lists"
	"github.com/therecipe/qt/core"

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/benoitkugler/goACVE/client/controllers"
	"github.com/therecipe/qt/widgets"

	"github.com/benoitkugler/goACVE/client/GUI/common"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

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

const valeurDefautAcompte = 45

func (p *Paiements) Render() {
	p.paiements.Model().SetData(p.controller.ListePaiements)
	p.factures.Model().SetData(p.controller.ListeFactures)
	if p.controller.Etat.PaiementCurrent != nil {
		p.paiements.SelectRow(p.controller.Etat.PaiementCurrent)
	}
	cFac, cB := p.controller.Etat.CriterePaiementFacture, p.controller.Etat.CriterePaiementBordereau
	var lab string
	if cFac.IsNotNil() {
		fac := p.controller.Base.NewFacture(cFac.Int64)
		lab = "Dossier " + fac.GetPersonne().RawData().NomPrenom().String()
	}
	if !cB.Time().IsZero() {
		lab += " Emis le " + cB.String()
	}
	if lab == "" {
		lab = "Aucun critère"
	}
	p.resets.SetChecked(lab != "")
	p.resets.SetText(lab)
	p.resets.SetEnabled(lab != "")

	p.critereValide.SetData(p.controller.Etat.CriterePaiementValide)
	p.critereAcquite.SetData(p.controller.Etat.CritereFactureAcquittee)
	p.critereCamp.SetData(p.controller.Etat.CritereFactureCamp)
}

func (p *Paiements) ConfirmeSupprimePaiement(toSupp dm.AccesPaiement) bool {
	_, camps := toSupp.GetFacture().Camps(nil)
	msg := "Etes-vous sur de vouloir supprimer ce paiement ?<br/>" +
		fmt.Sprintf("Il est lié au dossier de <b>%s</b> (%s)",
			toSupp.GetFacture().GetPersonne().RawData().NomPrenom(),
			camps)
	return basic.Confirmation(msg, "Supprimer", basic.ONDelete)
}

func (p *Paiements) ConfirmeExportPaiements(alreadyExported []rd.Paiement, nb int) (keep bool, simpleHeader bool, marque bool) {
	msg := fmt.Sprintf("Vous êtes sur le point d'exporter <b>%d</b> paiement(s).", nb)
	if len(alreadyExported) > 0 {
		msg += "<br/>Les paiements suivants ont déjà été émis en bordereau : <br/>"
		for _, p := range alreadyExported {
			s1, s2 := p.Description()
			msg += fmt.Sprintf("%s de <b>%s</b><br/>", s1, s2)
		}
	}
	header := widgets.NewQCheckBox2("Colonnes simplifiées", nil)
	m := widgets.NewQCheckBox2("Marquer comme émis", nil)
	valid := basic.Button("Exporter")
	valid.SetObjectName(basic.ONAction)
	dial := basic.Dialog("Exporter les paiements")
	valid.ConnectClicked(func(_ bool) {
		dial.Accept()
	})
	s := widgets.NewQScrollArea(nil)
	lab := basic.Label(msg)
	s.SetWidget(lab)
	s.SetMinimumSize2(450, 150)
	dial.Layout().AddWidget(s)
	dial.Layout().AddWidget(header)
	dial.Layout().AddWidget(m)
	dial.Layout().AddWidget(valid)

	return dial.Exec() > 0, header.IsChecked(), m.IsChecked()
}

type Paiements struct {
	*widgets.QFrame
	controller *controllers.Paiements
	parent     *widgets.QTabWidget
	toolbar    *widgets.QToolBar

	paiements lists.Table
	factures  lists.Table

	critereValide  fields.OptionnalBool
	resets         *widgets.QPushButton
	critereCamp    *fields.BoutonId
	critereAcquite fields.OptionnalBool
}

func newPaiements(ct *controllers.Paiements) *Paiements {
	p := Paiements{QFrame: basic.Frame(), controller: ct}
	p.paiements = lists.Table{
		Liste: lists.Liste{
			Headers: ct.HeaderPaiements,
			OnClick: func(acces rd.Item, _ int) {
				ct.Etat.PaiementCurrent = acces.Id
				p.UpdateToolbar()
			},
			OnDoubleClick: func(acces rd.Item, index int) {
				p.edit(acces)
			},
			OnRightClick: func(acces rd.Item, pos *core.QPoint) {
				acPaie := ct.Base.NewPaiement(acces.Id.Int64())
				menu := widgets.NewQMenu(p.paiements)
				fac := acPaie.GetFacture()
				ac := menu.AddAction("Aller à la facture")
				ac.ConnectTriggered(func(_ bool) {
					p.factures.SelectRow(rd.IdFacture(fac.Id))
				})
				ac = menu.AddAction("Afficher les paiements émis avec")
				ac.ConnectTriggered(func(_ bool) {
					ct.Etat.CriterePaiementBordereau = acPaie.RawData().InBordereau
					ct.Reset()
				})
				p.paiements.ShowContextMenu(menu, pos)
			},
			OnSort: func(field rd.Field, reverse bool) {
				lists.DefaultSort(p.paiements, field, reverse)
			},
		},
	}
	p.resets = basic.Button("")
	p.resets.SetCheckable(true)
	p.resets.ConnectClicked(func(checked bool) {
		if !checked {
			ct.Etat.CriterePaiementFacture = rd.OptionnalId{}
			ct.Etat.CriterePaiementBordereau = rd.Time{}
			ct.Reset()
		}
	})
	p.critereValide = fields.NewOptionnalBool(true, "Valide", "Invalide")
	p.critereValide.ConnectCurrentIndexChanged(func(_ int) {
		ct.Etat.CriterePaiementValide = p.critereValide.GetData()
		ct.Reset()
	})

	rh := widgets.NewQHBoxLayout()
	rh.AddWidget(basic.Label("Etat :"), 1, 0)
	rh.AddWidget(p.critereValide, 1, 0)
	rh.AddWidget(p.resets, 0, 0)
	p.paiements.RightHeader = rh
	p.paiements.Init()

	p.factures = lists.Table{
		Liste: lists.Liste{
			Headers: ct.HeaderFactures,
			OnRightClick: func(acces rd.Item, pos *core.QPoint) {
				menu := widgets.NewQMenu(p.factures)
				ac := menu.AddAction("Sélectionner les paiements associés")
				ac.ConnectTriggered(func(_ bool) {
					ct.Etat.CriterePaiementFacture = rd.NewOptionnalId(acces.Id.Int64())
					ct.Reset()
				})
				ac = menu.AddAction("Aller au responsable")
				ac.ConnectTriggered(func(_ bool) {
					pers := ct.Base.NewFacture(acces.Id.Int64()).GetPersonne()
					ct.Main().Controllers.Personnes.SelectPersonne(pers)
				})
				p.factures.ShowContextMenu(menu, pos)
			},
			OnDoubleClick: func(acces rd.Item, index int) {
				ac := ct.Base.NewFacture(acces.Id.Int64())
				meta := documents.Facture{
					Destinataire: ac.GetPersonne().RawData().ToDestinataire(),
					Bilan:        ac.EtatFinancier(dm.CacheEtatFinancier{}, true),
				}
				path := ct.Main().GenereExportDocument(meta)
				if path != "" {
					basic.ShowFile(path)
				}
			},
			OnSort: func(field rd.Field, reverse bool) {
				lists.DefaultSort(p.factures, field, reverse)
			},
		},
	}
	p.factures.Init()
	p.factures.HorizontalHeader().SetMinimumSectionSize(180)
	p.critereCamp = fields.NewBoutonIdCamp(true, ct.Base)
	p.critereCamp.DataChanged = func() {
		ct.Etat.CritereFactureCamp = p.critereCamp.GetData()
		ct.Reset()
	}
	tb := widgets.NewQToolButton(nil)
	tb.SetIcon(basic.Icons.Delete)
	tb.ConnectClicked(func(_ bool) {
		p.critereCamp.SetData(nil)
		ct.Etat.CritereFactureCamp = nil
		ct.Reset()
	})
	p.critereAcquite = fields.NewOptionnalBool(true, "Acquitté", "Non acquitté")
	p.critereAcquite.ConnectCurrentIndexChanged(func(_ int) {
		ct.Etat.CritereFactureAcquittee = p.critereAcquite.GetData()
		ct.Reset()
	})
	lay := widgets.NewQGridLayout(p)
	lay.AddWidget3(p.paiements, 0, 0, 1, 4, 0)
	lay.AddWidget2(basic.Label("Etat :"), 1, 0, 0)
	lay.AddWidget2(p.critereAcquite, 1, 1, 0)
	lay.AddWidget2(basic.Label("Camp :"), 2, 0, 0)
	lay.AddWidget2(p.critereCamp, 2, 1, 0)
	lay.AddWidget2(tb, 2, 2, core.Qt__AlignLeft)
	lay.AddWidget3(p.factures, 1, 3, 3, 1, 0)
	lay.SetRowStretch(0, 3)
	lay.SetRowStretch(3, 2)
	return &p
}

func (p *Paiements) cree() {
	paie := CreePaiement(p.controller.Base, rd.OptionnalId{}, InitialPaiement{})
	if paie != nil {
		p.controller.CreePaiement(*paie)
	}
}

func (p *Paiements) creeFromVirement() {
	d := basic.Dialog2("Ajouter un virement")
	entry := fields.NewInt(true)
	valid := basic.Button("Ajouter...")
	valid.SetObjectName(basic.ONAdd)
	valid.ConnectClicked(func(_ bool) {
		d.Accept()
	})
	layout := widgets.NewQFormLayout(d)
	layout.AddRow5(basic.Label("<i>Recopier le numéro du virement (ACVE: XXXXXX)<i>"))
	layout.AddRow3("Numéro", entry)
	layout.AddRow5(valid)
	basic.Delay(entry.SelectAll)
	if d.Exec() == 0 {
		return
	}

	fac, ok := p.controller.IdentifieVirement(int(entry.GetData()))
	if !ok {
		return
	}
	paie := CreePaiement(p.controller.Base, rd.NewOptionnalId(fac.Id), InitialPaiement{
		IsAcompte: false, IsVirement: true, LabelPayeur: fac.GetPersonne().RawData().NomPrenom().String(),
	})
	if paie != nil {
		p.controller.CreePaiement(*paie)
	}
}

func (p *Paiements) supprimer() {
	p.controller.SupprimePaiement()
}

func (p *Paiements) exportBordereau() {
	path := p.controller.ExportPaiements(p.paiements.Selection())
	if path != "" {
		basic.ShowFile(path)
	}
}

func (p *Paiements) edit(acces rd.Item) {
	paie := p.controller.Base.Paiements[acces.Id.Int64()]
	modif := EditPaiement(p.controller.Base, p.controller.EditRight, paie, rd.NewOptionnalId(paie.IdFacture))
	if modif != nil {
		p.controller.UpdatePaiement(*modif)
	}
}

func EditPaiement(base *dm.BaseLocale, editable bool, paiement rd.Paiement, idFacture rd.OptionnalId) *rd.Paiement {
	fiche := common.NewFichePaiement(base, editable)
	fiche.SetData(paiement, idFacture)
	det := common.NewDetails(&fiche, editable)
	if det.Exec() == 0 {
		return nil
	}
	paie := fiche.GetData()
	return &paie
}

// InitialPaiement regroupe les champs
// qu'on peut pré-remplir lors de l'ajout d'un paiement.
type InitialPaiement struct {
	IsAcompte   bool
	IsVirement  bool
	LabelPayeur string
}

func (ip InitialPaiement) Instancie() rd.Paiement {
	now := time.Now()
	paiement := rd.Paiement{
		IsAcompte:     rd.Bool(ip.IsAcompte),
		DateReglement: rd.Time(now),
		LabelPayeur:   rd.String(ip.LabelPayeur),
	}
	if ip.IsVirement {
		paiement.ModePaiement = rd.MPVirement
	}
	if ip.IsAcompte {
		paiement.Valeur = valeurDefautAcompte
	}
	return paiement
}

func CreePaiement(base *dm.BaseLocale, idFacture rd.OptionnalId, options InitialPaiement) *rd.Paiement {
	initialPaiement := options.Instancie()
	return EditPaiement(base, true, initialPaiement, idFacture)
}