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

package onglets

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"

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

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

	"github.com/therecipe/qt/gui"

	"github.com/therecipe/qt/core"

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

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

func (t *Personnes) Render() {
	t.liste.Model().SetData(t.controller.Liste)
	t.liste.SetSearch(t.controller.Etat.Recherche)
	t.showTemporaire.SetChecked(bool(t.controller.Etat.CritereShowTemporaire))
	t.showOrga.SetData(t.controller.Etat.CritereShowOrganismes)
	t.stats.SetData(t.controller.GetStats())
	if t.controller.Etat.ItemCurrent != nil {
		// on dirait que Qt a besoin d'abord de re-tracer la liste
		// avant de pouvoir sélectionner correctement la personne
		basic.Delay(func() {
			t.liste.SelectRow(t.controller.Etat.ItemCurrent)
		})
	}
}

func (t *Personnes) ConfirmeSupprimePersonne(pers dm.AccesPersonne) bool {
	return basic.Confirmation(
		fmt.Sprintf("Confirmez-vous la suppression de <b>%s</b> ? <br/>"+
			"Cette opération est irréversible.", pers.RawData().NomPrenom()),
		"Supprimer définitivement", basic.ONDelete)
}

func (t *Personnes) ConfirmeSupprimeOrganisme(org dm.AccesOrganisme) bool {
	return basic.Confirmation(
		fmt.Sprintf("Confirmez-vous la suppression de l'organisme <b>%s</b> ? <br/>"+
			"Cette opération est irréversible.", org.RawData().Nom),
		"Supprimer définitivement", basic.ONDelete)
}

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

	liste lists.Table
	stats common.Statistics

	showTemporaire *widgets.QCheckBox
	showOrga       fields.OptionnalBool
}

func newPersonnes(ct *controllers.Personnes) *Personnes {
	p := Personnes{QFrame: basic.Frame(), controller: ct}
	p.liste.Headers = ct.Header
	p.liste.Title = "Personnes/Organismes"
	p.liste.OnSearch = func(pattern string) {
		ct.Etat.Recherche = pattern
		ct.Reset()
	}
	p.liste.OnSort = func(field rd.Field, reverse bool) {
		ct.Etat.CriteresTri = ct.Etat.CriteresTri.AddCritere(field, reverse)
		ct.Reset()
	}
	p.liste.OnClick = func(acces rd.Item, _ int) {
		ct.Etat.ItemCurrent = acces.Id
		p.UpdateToolbar()
	}
	p.liste.OnDoubleClick = func(acces rd.Item, _ int) {
		switch id := acces.Id.(type) {
		case rd.IdPersonne:
			ac := ct.Base.NewPersonne(id.Int64())
			out, ok := editPersonne(ct.EditRight, ac.RawData())
			if !ok {
				return
			}
			ct.UpdatePersonne(out)
		case rd.IdOrganisme:
			ac := ct.Base.NewOrganisme(id.Int64())
			out, ok := editOrganisme(ct.Base, ct.EditRight, ac.RawData())
			if !ok {
				return
			}
			ct.UpdateOrganisme(out)
		}
	}
	p.liste.OnRightClick = func(acces rd.Item, pos *core.QPoint) {
		menu := widgets.NewQMenu(p.liste)
		switch id := acces.Id.(type) {
		case rd.IdOrganisme:
			raw := ct.Base.NewOrganisme(id.Int64()).RawData()
			if contact := raw.IdContact; contact.IsNotNil() {
				ac := menu.AddAction("Aller au contact...")
				ac.ConnectTriggered(func(_ bool) {
					ct.SelectPersonne(ct.Base.NewPersonne(contact.Int64))
				})
			}
			if contact := raw.IdContactDon; contact.IsNotNil() {
				ac := menu.AddAction("Aller au contact pour les dons...")
				ac.ConnectTriggered(func(_ bool) {
					ct.SelectPersonne(ct.Base.NewPersonne(contact.Int64))
				})
			}
		case rd.IdPersonne:
			parents, enfants := ct.GetParentsEnfants(id)
			ac := menu.AddAction2(basic.Icons.History, "Afficher l'historique...")
			ac.ConnectTriggered(func(_ bool) {
				p.afficherHistorique(id)
			})
			if len(parents) > 0 {
				menu.AddSection("Responsables")
				for _, parent := range parents {
					parent := parent
					ac := menu.AddAction(fmt.Sprintf("%s (%s)", parent.RawData().NomPrenom(), parent.RawData().DateNaissance))
					ac.ConnectTriggered(func(_ bool) {
						ct.SelectPersonne(parent)
					})
				}
			}
			if len(enfants) > 0 {
				menu.AddSection("Participants")
				for _, enfant := range enfants {
					enfant := enfant
					ac := menu.AddAction(fmt.Sprintf("%s (%s)", enfant.RawData().NomPrenom(), enfant.RawData().DateNaissance))
					ac.ConnectTriggered(func(_ bool) {
						ct.SelectPersonne(enfant)
					})
				}
			}
		default:
			return
		}
		p.liste.ShowContextMenu(menu, pos)
	}

	rightHeader := widgets.NewQHBoxLayout()

	p.showOrga = fields.NewOptionnalBool(true, "Organismes", "Personnes")
	p.showOrga.ConnectCurrentIndexChanged(func(int) {
		p.controller.Etat.CritereShowOrganismes = p.showOrga.GetData()
		p.controller.Reset()
	})

	p.showTemporaire = widgets.NewQCheckBox2("Afficher les personnes non référencées", nil)
	p.showTemporaire.ConnectClicked(func(checked bool) {
		p.controller.Etat.CritereShowTemporaire = rd.Bool(checked)
		p.controller.Reset()
	})
	export := basic.Button("Exporter...")
	export.SetObjectName(basic.ONAction)
	export.ConnectClicked(func(_ bool) {
		p.afficherExport()
	})

	rightHeader.AddWidget(p.showTemporaire, 1, core.Qt__AlignLeft)
	rightHeader.AddWidget(basic.Label("Catégorie :"), 1, 0)
	rightHeader.AddWidget(p.showOrga, 1, 0)
	rightHeader.AddWidget(export, 1, 0)
	p.liste.RightHeader = rightHeader

	p.liste.Init()
	p.liste.View.SetColumnWidth(0, 300)
	p.liste.View.SetColumnWidth(1, 50)
	p.liste.View.SetColumnWidth(3, 200)
	p.liste.View.SetColumnWidth(4, 200)
	p.liste.View.ConnectKeyPressEvent(func(event *gui.QKeyEvent) {
		if event.Matches(gui.QKeySequence__Copy) {
			item, ok := p.liste.CurrentData()
			if !ok {
				return
			}
			b, err := json.Marshal(ct.Base.Personnes[item.Id.Int64()])
			if err != nil {
				return
			}
			basic.Copy(string(b))
			return
		}
		p.liste.View.KeyPressEventDefault(event)
	})
	p.stats = common.NewStatistics(true)
	lay := widgets.NewQVBoxLayout2(p)
	lay.AddWidget(p.stats, 0, 0)
	lay.AddWidget(p.liste, 3, 0)
	return &p
}

func (t *Personnes) creerPersonne() {
	p, ok := editPersonne(true, rd.Personne{})
	if !ok {
		return
	}
	t.controller.CreePersonne(p)
}

func (t *Personnes) creerOrganisme() {
	p, ok := editOrganisme(t.controller.Base, true, rd.Organisme{})
	if !ok {
		return
	}
	t.controller.CreeOrganisme(p)
}

func (t *Personnes) afficherHistorique(id rd.IdPersonne) {
	data := t.controller.GetHistorique(id.Int64())
	np := t.controller.Base.NewPersonne(id.Int64()).RawData().NomPrenom()
	diag := basic.Dialog("Historique")
	diag.Layout().AddWidget(basic.Label(fmt.Sprintf("Historique de <b>%s</b>", np)))
	var list lists.Table
	list.Headers = []rd.Header{
		{Field: controllers.HistoriqueCamp, Label: "Camp"},
		{Field: controllers.HistoriqueAnnee, Label: "Année"},
		{Field: controllers.HistoriqueRole, Label: "Rôle"},
	}
	list.Placeholder = fmt.Sprintf("Aucune participation n'est enregistrée pour %s", np)
	list.ResizeToContents = true
	list.Init()
	list.Model().SetData(data)
	diag.Layout().AddWidget(list)
	diag.Show()
}

func (t *Personnes) afficherCriteres() {
	dial := newDialogCriteres(t.controller)
	dial.Show()
}

func (t *Personnes) afficherExport() {
	d := newExport(t.controller)
	d.update(true)
	d.Exec()
}

func (t *Personnes) afficherDocuments() {
	d := common.NewDocuments(t.controller.Main(), t.controller.EditRight, false)
	d.SetModal(true)
	d.Show()
	d.RenderDocuments()
}

func (t *Personnes) supprimer() { t.controller.SupprimeItem() }

func editPersonne(editable bool, personne rd.Personne) (rd.Personne, bool) {
	f := common.NewFichePersonne(editable)
	f.SetData(personne)
	det := common.NewDetails(&f, editable)
	det.ConnectKeyPressEvent(func(event *gui.QKeyEvent) {
		if event.Matches(gui.QKeySequence__Paste) {
			persJson := basic.Paste()
			var pers rd.Personne
			err := json.Unmarshal([]byte(persJson), &pers)
			if err != nil {
				return
			}
			f.SetCoordonnees(pers)
			return
		}
		det.KeyPressEventDefault(event)
	})

	basic.Delay(f.RemoveFocus)
	if det.Exec() == 0 {
		return rd.Personne{}, false
	}
	p := f.GetData()
	return p, true
}

func editOrganisme(b *dm.BaseLocale, editable bool, organisme rd.Organisme) (rd.Organisme, bool) {
	f := common.NewFicheOrganisme(b, editable)
	f.SetData(organisme)
	det := common.NewDetails(&f, editable)
	if det.Exec() == 0 {
		return rd.Organisme{}, false
	}
	p := f.GetData()
	return p, true
}

// --------------------- Fenêtre de recherche par critère --------------------------

type dialogCriteres struct {
	*widgets.QDialog

	ct       *controllers.Personnes
	liste    lists.Table
	labelRes *widgets.QLabel

	role           fields.Enum
	annee          fields.String
	periode        fields.Enum
	hasDocument    fields.CategorieDocument
	famille        fields.Enum
	ageMin         fields.Int
	ageMax         fields.Int
	departement    fields.Departement
	rangMembreAsso fields.RangMembreAsso
	echoRocher     fields.OptionnalBool
	eonews         fields.OptionnalBool
	pubEte         fields.OptionnalBool
	pubHiver       fields.OptionnalBool
	versionPapier  fields.OptionnalBool
}

func newDialogCriteres(ct *controllers.Personnes) dialogCriteres {
	d := dialogCriteres{QDialog: basic.Dialog2("Recherche par critères")}
	d.ct = ct

	roles := append([]fields.Choice{
		{Field: "", Label: "Indifférent"},
		{},
		{Field: controllers.RoleEquipe, Label: "Equipier"},
		{Field: controllers.RoleInscrit, Label: "Inscrit"},
		{Field: controllers.RoleAttente, Label: "En liste d'attente"},
		{}},
		fields.RoleEquipes...)
	d.role = fields.NewEnum(roles, true)
	d.annee = fields.NewString(true)
	periodes := []fields.Choice{
		{Field: "", Label: "Indifférent"},
		{},
		{Field: rd.PERIODES.AUTOMNE.String(), Label: "Automne"},
		{Field: rd.PERIODES.HIVER.String(), Label: "Hiver"},
		{Field: rd.PERIODES.PRINTEMPS.String(), Label: "Printemps"},
		{Field: rd.PERIODES.ETE.String(), Label: "Eté"},
	}
	d.periode = fields.NewEnum(periodes, true)
	d.hasDocument = fields.NewOptionnalCategorieDocument(ct.Base)

	d.famille = fields.NewEnum([]fields.Choice{
		{Field: "", Label: "Aucune modification"},
		{Field: controllers.LienResposEtParticipants, Label: "Ajouter les responsables"},
		{Field: controllers.LienRespos, Label: "Ne choisir que les responsables"},
	}, true)

	d.ageMin, d.ageMax = fields.NewInt(true), fields.NewInt(true)
	d.departement = fields.NewDepartement(true)
	d.rangMembreAsso = fields.NewRangMembreAsso(true, true)
	d.echoRocher = fields.NewOptionnalBool(true, "Oui", "Non")
	d.eonews = fields.NewOptionnalBool(true, "Oui", "Non")
	d.pubEte = fields.NewOptionnalBool(true, "Oui", "Non")
	d.pubHiver = fields.NewOptionnalBool(true, "Oui", "Non")
	d.versionPapier = fields.NewOptionnalBool(true, "Oui", "Non")

	f := widgets.NewQGroupBox2("Critères sur la participation", nil)
	f2 := widgets.NewQGroupBox2("Critères sur la personne", nil)

	d.role.ConnectCurrentIndexChanged(d.search)
	d.annee.ConnectTextChanged(func(string) { d.search(0) })
	d.periode.ConnectCurrentIndexChanged(d.search)
	d.hasDocument.ConnectCurrentIndexChanged(d.search)
	d.famille.ConnectCurrentIndexChanged(d.search)
	d.ageMin.ConnectValueChanged(d.search)
	d.ageMax.ConnectValueChanged(d.search)
	d.departement.ConnectTextChanged(func(string) { d.search(0) })
	d.rangMembreAsso.ConnectCurrentIndexChanged(d.search)
	d.echoRocher.ConnectCurrentIndexChanged(d.search)
	d.eonews.ConnectCurrentIndexChanged(d.search)
	d.pubEte.ConnectCurrentIndexChanged(d.search)
	d.pubHiver.ConnectCurrentIndexChanged(d.search)
	d.versionPapier.ConnectCurrentIndexChanged(d.search)

	d.labelRes = basic.Label("")
	d.labelRes.SetAlignment(core.Qt__AlignCenter)
	d.liste = lists.Table{
		Liste: lists.Liste{
			Headers: []rd.Header{
				{Field: dm.PersonneNomPrenom, Label: "Personne"},
				{Field: dm.PersonneMail, Label: "Mail"},
				{Field: dm.PersonneCodePostal, Label: "Code postal"},
			},
			MinWidth: 300,
			OnDelete: func(_ rd.Item, index int) { // sans confirmation
				d.liste.Model().SetData(controllers.RemoveItem(d.liste.Model().GetData(), index))
			},
		},
	}
	d.liste.Init()
	d.liste.HorizontalHeader().SetMinimumSectionSize(60)
	d.liste.HorizontalHeader().ResizeSection(0, 200)
	d.liste.HorizontalHeader().ResizeSection(1, 250)

	effaceListe := basic.Button("Effacer la liste principale")
	effaceListe.SetObjectName(basic.ONDelete)
	effaceListe.ConnectClicked(func(_ bool) {
		ct.EffaceListe()
	})
	ct.EffaceListe()

	ajouteOrga := basic.Button("Ajouter les organismes")
	ajouteOrga.SetObjectName(basic.ONAdd)
	ajouteOrga.SetToolTip("Ajouter les organismes à la liste principale.")
	ajouteOrga.ConnectClicked(func(_ bool) {
		ct.AjouteOrganismesToListe()
	})

	ajouteListe := basic.Button("Ajouter les résultats")
	ajouteListe.SetObjectName(basic.ONAdd)
	ajouteListe.SetToolTip("Ajouter ces résultats à la liste principale.")
	ajouteListe.ConnectClicked(func(_ bool) {
		ct.AjouteToListe(d.liste.Model().GetData())
	})

	mainLay := widgets.NewQVBoxLayout()

	lay := widgets.NewQFormLayout(f)
	lay.AddRow3("Rôle", d.role)
	lay.AddRow3("Année", d.annee)
	lay.AddRow3("Période", d.periode)
	lay.AddRow3("Document", d.hasDocument)
	mainLay.AddWidget(f, 2, 0)

	mainLay.AddSpacing(5)
	mainLay.AddWidget(d.famille, 1, 0)
	mainLay.AddSpacing(5)

	lay2 := widgets.NewQFormLayout(f2)
	layAge := widgets.NewQHBoxLayout()
	layAge.AddWidget(basic.Label("De"), 1, 0)
	layAge.AddWidget(d.ageMin, 3, 0)
	layAge.AddWidget(basic.Label("à"), 1, 0)
	layAge.AddWidget(d.ageMax, 3, 0)
	lay2.AddRow4("Age", layAge)
	lay2.AddRow3("Département", d.departement)
	lay2.AddRow3("Membre de l'association", d.rangMembreAsso)
	lay2.AddRow3("Echo du Rocher", d.echoRocher)
	lay2.AddRow3("éOnews", d.eonews)
	lay2.AddRow3("Pub. Eté", d.pubEte)
	lay2.AddRow3("Pub. Hiver", d.pubHiver)
	lay2.AddRow3("Version Papier", d.versionPapier)
	mainLay.AddWidget(f2, 2, 0)
	mainLay.AddSpacing(10)
	mainLay.AddWidget(d.labelRes, 1, 0)

	dialogLay := widgets.NewQGridLayout(d)
	dialogLay.AddLayout2(mainLay, 0, 0, 2, 1, 0)
	dialogLay.AddWidget3(d.liste, 0, 1, 1, 4, 0)
	dialogLay.AddWidget2(effaceListe, 1, 1, 0)
	dialogLay.AddWidget2(ajouteOrga, 1, 3, 0)
	dialogLay.AddWidget2(ajouteListe, 1, 4, 0)
	d.Resize(d.SizeHint())
	return d
}

// si invalide, renvoi nil
func parseAnnees(s string) map[int]bool {
	s = strings.TrimSpace(strings.ReplaceAll(s, " ", ""))
	if i, err := strconv.Atoi(s); err == nil {
		return map[int]bool{i: true}
	}
	out := map[int]bool{}
	parts := strings.Split(s, "-")
	if len(parts) == 2 {
		debut, err1 := strconv.Atoi(parts[0])
		fin, err2 := strconv.Atoi(parts[1])
		if err1 == nil && err2 == nil {
			for an := debut; an <= fin; an += 1 {
				out[an] = true
			}
			return out
		}
	}
	parts = strings.Split(s, ";")
	for _, p := range parts {
		an, err := strconv.Atoi(p)
		if err != nil {
			return nil
		}
		out[an] = true
	}
	return out
}

func (d dialogCriteres) getCriteres() controllers.CritereRecherche {
	cpa := controllers.CriteresRechercheParticipant{
		Role:             d.role.GetData(),
		Annee:            parseAnnees(string(d.annee.GetData())),
		Periode:          d.periode.GetData(),
		LiensResponsable: d.famille.GetData(),
	}
	var age *[2]int
	aMin, aMax := d.ageMin.GetData(), d.ageMax.GetData()
	if aMin > 0 && aMax > 0 && aMin <= aMax {
		t := [2]int{int(aMin), int(aMax)}
		age = &t
	}
	cpe := controllers.CriteresRecherchePersonne{
		Age:           age,
		Departement:   d.departement.GetData(),
		EchoRocher:    d.echoRocher.GetData(),
		Eonews:        d.eonews.GetData(),
		MembreAsso:    d.rangMembreAsso.GetData(),
		PubEte:        d.pubEte.GetData(),
		PubHiver:      d.pubHiver.GetData(),
		VersionPapier: d.versionPapier.GetData(),
		HasDocument:   d.hasDocument.GetData(),
	}
	return controllers.CritereRecherche{Personne: cpe, Participant: cpa}
}

func (d *dialogCriteres) search(_ int) {
	res := d.ct.RecherchePersonnesByCriteres(d.getCriteres())
	d.liste.Model().SetData(res)
	d.labelRes.SetText(fmt.Sprintf("<b>%d</b> résultat(s) (sur %d personnes)",
		len(res), len(d.ct.Base.Personnes)))
}

// ------------------------------- Export -------------------------------

type export struct {
	*widgets.QDialog

	mode        *widgets.QComboBox
	description *widgets.QLabel
	option      *widgets.QComboBox
	labelOption *widgets.QLabel
	preview     *widgets.QLabel

	controller *controllers.Personnes
}

func newExport(ct *controllers.Personnes) export {
	d := export{QDialog: basic.Dialog2("Exporter"), controller: ct}
	lay := widgets.NewQFormLayout(d)

	d.mode = widgets.NewQComboBox(nil)
	d.mode.AddItem("Liste excel", core.NewQVariant5(int(controllers.ExportDEFAULT)))
	d.mode.AddItem("Publipostage", core.NewQVariant5(int(controllers.ExportPUBLIPOSTAGE)))
	d.mode.AddItem("Mailchimp", core.NewQVariant5(int(controllers.ExportMAILCHIMP)))
	d.mode.AddItem("Mails", core.NewQVariant5(int(controllers.ExportMAILS)))
	d.mode.AddItem("Tels. portables", core.NewQVariant5(int(controllers.ExportPORTABLES)))
	d.mode.AddItem("Cotisations", core.NewQVariant5(int(controllers.ExportCOTISATIONS)))

	d.description = basic.Label("")

	d.option = widgets.NewQComboBox(nil)
	d.option.SetEnabled(false)

	d.labelOption = basic.Label("")

	d.preview = basic.Label("")

	d.mode.ConnectCurrentIndexChanged(func(_ int) {
		d.update(true)
	})
	d.option.ConnectCurrentIndexChanged(func(_ int) {
		d.update(false)
	})

	valid := basic.Button("Exporter")
	valid.ConnectClicked(func(_ bool) {
		d.export()
	})

	lay.AddRow3("Mode d'export", d.mode)
	lay.AddRow5(d.description)
	lay.AddRow(d.labelOption, d.option)
	lay.AddRow5(d.preview)
	lay.AddRow5(valid)
	return d
}

func (e export) setupOption(mode controllers.ModeExport) {
	e.option.Clear()
	switch mode {
	case controllers.ExportPUBLIPOSTAGE:
		e.option.AddItem("Aucun", core.NewQVariant5(0))
		e.option.AddItem("Pub. été", core.NewQVariant5(int(dm.PubEte)))
		e.option.AddItem("Pub. hiver", core.NewQVariant5(int(dm.PubHiver)))
		e.option.AddItem("Echo du rocher", core.NewQVariant5(int(dm.EchoRocher)))
		e.option.SetEnabled(true)
		e.labelOption.SetText("Type d'envoi (choix des exemplaires)")
	case controllers.ExportCOTISATIONS:
		e.option.AddItem("Alphabétique", core.NewQVariant5(int(dm.MembresTriAlphabetique)))
		e.option.AddItem("Par cotisations", core.NewQVariant5(int(dm.MembresTriCotisation)))
		e.option.SetEnabled(true)
		e.labelOption.SetText("Tri des membres")
	default:
		e.option.SetEnabled(false)
		e.labelOption.SetText("")
	}
}

func (e export) modeOption() (controllers.ModeExport, dm.OptionExport) {
	mode := controllers.ModeExport(e.mode.CurrentData(int(core.Qt__UserRole)).ToInt(nil))
	option := dm.OptionExport(e.option.CurrentData(int(core.Qt__UserRole)).ToInt(nil))
	return mode, option
}

func (e export) update(setupOption bool) {
	mode, _ := e.modeOption()
	e.description.SetText(mode.Description())
	if setupOption {
		e.setupOption(mode)
	}
	_, option := e.modeOption() // setupOption ré-initialise les options
	res, invalides := e.controller.ValideExport(mode, option)
	e.preview.SetText(fmt.Sprintf("<b>%d</b> éléments (<i>%d invalides</i>)", len(res), invalides))
}

func (e export) export() {
	mode, option := e.modeOption()
	path := e.controller.ExportAndSave(mode, option)
	basic.ShowFile(path)
	e.Accept()
}