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

package common

import (
	"fmt"

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

	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/therecipe/qt/core"

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

type Similaires struct {
	lists.Table

	base       *dm.BaseLocale
	candidat   matching.PatternsSimilarite
	inPersonne rd.BasePersonne

	btnNewPersonne *widgets.QPushButton
}

type OnIdentifie = func(target matching.IdentifieTarget)

func NewSimilaires(base *dm.BaseLocale, onIdentifie OnIdentifie) *Similaires {
	s := Similaires{Table: lists.Table{}, base: base}
	s.Headers = []rd.Header{
		{Field: dm.PersonnePertinence, Label: "Pertinence"},
		{Field: dm.PersonneNom, Label: "Nom"},
		{Field: dm.PersonnePrenom, Label: "Prénom"},
		{Field: dm.PersonneSexe, Label: "Sexe"},
		{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
		{Field: dm.PersonneNomJeuneFille, Label: "Nom de jeune fille"},
		{Field: dm.PersonneMail, Label: "Mail"},
	}
	s.OnSearch = s.onSearch

	s.RightHeader = widgets.NewQHBoxLayout()
	s.btnNewPersonne = basic.Button("Vers un nouveau profil")
	s.btnNewPersonne.SetObjectName(basic.ONAdd)
	s.btnNewPersonne.ConnectClicked(func(_ bool) { onIdentifie(matching.NouveauProfil{}) })
	s.RightHeader.AddWidget(s.btnNewPersonne, 1, 0)

	s.OnClick = func(acces rd.Item, _ int) {
		existant := s.base.NewPersonne(acces.Id.Int64())
		merged, conflicts := matching.Merge(s.inPersonne, existant.RawData().BasePersonne)
		if conflicts != (matching.Conflicts{}) { // sinon, aucun conflits, on fusionne directement
			dial := setupComparaison(s.inPersonne, existant.RawData().BasePersonne, &merged, conflicts)
			if dial.Exec() == 0 {
				return // on annule
			}
		}
		onIdentifie(matching.Rattache{IdTarget: existant.Id, Modifications: merged})
	}
	s.Init()
	return &s
}

func (s *Similaires) onSearch(pattern string) {
	var liste rd.Table
	if pattern == "" {
		liste = s.base.ChercheSimilaires(s.candidat)
	} else {
		liste = s.base.RechercheRapidePersonnes(false, pattern)
	}
	s.Table.Model().SetData(liste)
}

// SetData affiche les personnes similaires au profil `inPersonne`,
// ou rien pour une valeur nulle.
// Passer `isTemporaire == false` signifie que la personne est déjà
// référencée, et le bouton Nouveau profil est alors désactivé.
func (s *Similaires) SetData(inPersonne rd.BasePersonne, isTemporaire bool) {
	s.inPersonne = inPersonne
	s.candidat = matching.PatternsSimilarite{
		Nom:           inPersonne.Nom,
		Prenom:        inPersonne.Prenom,
		NomJeuneFille: inPersonne.NomJeuneFille,
		DateNaissance: inPersonne.DateNaissance,
		Sexe:          inPersonne.Sexe,
		Mail:          inPersonne.Mail,
	}
	var data rd.Table
	if s.candidat != (matching.PatternsSimilarite{}) {
		data = s.base.ChercheSimilaires(s.candidat)
	}
	s.Table.Model().SetData(data)

	// si la personne est déjà référencée, on désactive l'action
	// Nouveau profil, qui serait alors une no-op
	s.btnNewPersonne.SetEnabled(isTemporaire)
}

type comparateur struct {
	*widgets.QGridLayout
	WidgetsBasePersonne // fusion, modifiable

	av WidgetsBasePersonne // lecture seule
	ex WidgetsBasePersonne // lecture seule
}

type transferable interface {
	transfer()
	w1() widgets.QWidget_ITF
	w2() widgets.QWidget_ITF
}

type tfString struct {
	in, merged fields.String
}

func (t tfString) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfString) w1() widgets.QWidget_ITF { return t.in }
func (t tfString) w2() widgets.QWidget_ITF { return t.merged }

type tfBool struct {
	in, merged fields.Bool
}

func (t tfBool) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfBool) w1() widgets.QWidget_ITF { return t.in }
func (t tfBool) w2() widgets.QWidget_ITF { return t.merged }

type tfTels struct {
	in, merged fields.Tels
}

func (t tfTels) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfTels) w1() widgets.QWidget_ITF { return t.in }
func (t tfTels) w2() widgets.QWidget_ITF { return t.merged }

type tfDepartement struct {
	in, merged fields.Departement
}

func (t tfDepartement) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfDepartement) w1() widgets.QWidget_ITF { return t.in }
func (t tfDepartement) w2() widgets.QWidget_ITF { return t.merged }

type tfSexe struct {
	in, merged fields.Sexe
}

func (t tfSexe) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfSexe) w1() widgets.QWidget_ITF { return t.in }
func (t tfSexe) w2() widgets.QWidget_ITF { return t.merged }

type tfDate struct {
	in, merged fields.Date
}

func (t tfDate) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfDate) w1() widgets.QWidget_ITF { return t.in }
func (t tfDate) w2() widgets.QWidget_ITF { return t.merged }

type tfMultiLineString struct {
	in, merged fields.MultiLineString
}

func (t tfMultiLineString) transfer() {
	t.merged.SetData(t.in.GetData())
}
func (t tfMultiLineString) w1() widgets.QWidget_ITF { return t.in }
func (t tfMultiLineString) w2() widgets.QWidget_ITF { return t.merged }

func NewComparateur(arrivant, existant, merged rd.BasePersonne, conflicts matching.Conflicts, isRefEditable bool) *comparateur {
	f := comparateur{QGridLayout: widgets.NewQGridLayout2(), WidgetsBasePersonne: NewWidgetsBasePersonne(isRefEditable)}

	f.av = NewWidgetsBasePersonne(false)
	f.av.SetData(arrivant)
	f.ex = NewWidgetsBasePersonne(false)
	f.ex.SetData(existant)
	f.SetData(merged)

	row := 1
	lab := basic.Label("<b>Profil entrant</b>")
	lab.SetAlignment(core.Qt__AlignCenter)
	f.AddWidget2(lab, 0, 1, 0)
	lab2 := basic.Label("<b>Personne référencée</b>")
	lab2.SetAlignment(core.Qt__AlignCenter)
	f.AddWidget2(lab2, 0, 3, 0)
	lab3 := basic.Label("<b>Résultat de la fusion</b>")
	lab3.SetAlignment(core.Qt__AlignCenter)
	f.AddWidget2(lab3, 0, 5, 0)

	// on affiche que les champs avec des conflits
	setup := func(tfArrivant, tfExistant transferable, show bool, label string) {
		if !show {
			return
		}
		f.AddWidget2(basic.Label(label), row, 0, 0)

		f.AddWidget2(tfArrivant.w1(), row, 1, 0)
		f.AddWidget2(tfExistant.w1(), row, 3, 0)
		f.AddWidget2(tfArrivant.w2(), row, 5, 0) // w2() est le même pour arrivant ou existant

		if isRefEditable {
			btnArrivant := widgets.NewQToolButton(nil)
			btnArrivant.SetArrowType(core.Qt__RightArrow)
			btnArrivant.SetToolTip("Utiliser la valeur entrante")
			btnExistant := widgets.NewQToolButton(nil)
			btnExistant.SetArrowType(core.Qt__RightArrow)
			btnExistant.SetToolTip("Utiliser la valeur existante")

			btnArrivant.ConnectClicked(func(_ bool) { tfArrivant.transfer() })
			btnExistant.ConnectClicked(func(_ bool) { tfExistant.transfer() })

			f.AddWidget2(btnArrivant, row, 2, 0)
			f.AddWidget2(btnExistant, row, 4, 0)
		}
		row += 1
	}

	setup(tfString{in: f.av.nom, merged: f.nom}, tfString{in: f.ex.nom, merged: f.nom}, conflicts.Nom, "Nom")
	setup(tfString{in: f.av.prenom, merged: f.prenom}, tfString{in: f.ex.prenom, merged: f.prenom}, conflicts.Prenom, "Prénom")
	setup(tfSexe{in: f.av.sexe, merged: f.sexe}, tfSexe{in: f.ex.sexe, merged: f.sexe}, conflicts.Sexe, "Sexe")
	setup(tfDate{in: f.av.dateNaissance, merged: f.dateNaissance}, tfDate{in: f.ex.dateNaissance, merged: f.dateNaissance}, conflicts.DateNaissance, "Date de naissance")
	setup(tfTels{in: f.av.tels, merged: f.tels}, tfTels{in: f.ex.tels, merged: f.tels}, conflicts.Tels, "Tels.")
	setup(tfString{in: f.av.mail, merged: f.mail}, tfString{in: f.ex.mail, merged: f.mail}, conflicts.Mail, "Mail")
	setup(tfMultiLineString{in: f.av.adresse, merged: f.adresse}, tfMultiLineString{in: f.ex.adresse, merged: f.adresse}, conflicts.Adresse, "Adresse")
	setup(tfString{in: f.av.codePostal, merged: f.codePostal}, tfString{in: f.ex.codePostal, merged: f.codePostal}, conflicts.CodePostal, "Code postal")
	setup(tfString{in: f.av.ville, merged: f.ville}, tfString{in: f.ex.ville, merged: f.ville}, conflicts.Ville, "Ville")
	setup(tfString{in: f.av.pays, merged: f.pays}, tfString{in: f.ex.pays, merged: f.pays}, conflicts.Pays, "Pays")
	setup(tfString{in: f.av.nomJeuneFille, merged: f.nomJeuneFille}, tfString{in: f.ex.nomJeuneFille, merged: f.nomJeuneFille}, conflicts.NomJeuneFille, "Nom de jeune fille")
	setup(tfString{in: f.av.villeNaissance, merged: f.villeNaissance}, tfString{in: f.ex.villeNaissance, merged: f.villeNaissance}, conflicts.VilleNaissance, "Ville de naissance")
	setup(tfDepartement{in: f.av.departementNaissance, merged: f.departementNaissance}, tfDepartement{in: f.ex.departementNaissance, merged: f.departementNaissance}, conflicts.DepartementNaissance, "Département de naissance")
	setup(tfString{in: f.av.securiteSociale, merged: f.securiteSociale}, tfString{in: f.ex.securiteSociale, merged: f.securiteSociale}, conflicts.SecuriteSociale, "Sécurité sociale")
	setup(tfString{in: f.av.profession, merged: f.profession}, tfString{in: f.ex.profession, merged: f.profession}, conflicts.Profession, "Profession")
	setup(tfBool{in: f.av.etudiant, merged: f.etudiant}, tfBool{in: f.ex.etudiant, merged: f.etudiant}, conflicts.Etudiant, "Etudiant")
	setup(tfBool{in: f.av.fonctionnaire, merged: f.fonctionnaire}, tfBool{in: f.ex.fonctionnaire, merged: f.fonctionnaire}, conflicts.Fonctionnaire, "Fonctionnaire")

	return &f
}

func setupComparaison(arrivant, existant rd.BasePersonne, merged *rd.BasePersonne, conflicts matching.Conflicts) *widgets.QDialog {
	cp := basic.Dialog("Identification")

	comparateur := NewComparateur(arrivant, existant, *merged, conflicts, true)

	valid := basic.Button("Identifier")
	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(_ bool) {
		comparateur.GetData(merged)
		cp.Accept()
	})

	frame := basic.Frame()
	frame.SetLayout(comparateur)
	sc := widgets.NewQScrollArea(nil)
	sc.SetMaximumWidth(800)
	sc.SetMaximumHeight(850)
	sc.SetWidget(frame)
	sc.SetWidgetResizable(true)
	cp.SetMinimumWidth(750)
	label := basic.Label(`Les champs suivants présentent un <b>conflit</b> entre les deux personnes à rapprocher.<br/>
	Si vous le souhaitez, vous pouvez trancher en éditant la dernière colonne. Vous pouvez copier directement une valeur en utilisant les flêches.`)
	label.SetMaximumWidth(700)
	label.SetWordWrap(true)
	cp.Layout().AddWidget(label)
	cp.Layout().AddWidget(sc)
	cp.Layout().AddWidget(valid)
	return cp
}

func ChoixEviteDoublonsDocuments(docs []dm.AccesDocumentPersonne) (toSupp rd.Ids) {
	dialog := basic.Dialog2("Supprimer les doublons")
	label := basic.Label("Les documents de <i>la personne cible</i> concernent des catégories <b>déjà présentes</b>. <br/>" +
		"Les documents de la personne cible seront ajoutés à ceux déjà liés à la personne temporaires. <br/>" +
		"Pour <i>éviter les doublons</i>, vous pouvez <b>supprimer</b> un ou plusieurs documents parmi la liste suivante :")
	lay := widgets.NewQGridLayout2()
	var cbs []*widgets.QCheckBox
	valid := basic.Button("Supprimer")
	valid.ConnectClicked(func(_ bool) {
		dialog.Accept()
	})
	getToSupp := func() []int64 {
		var out []int64
		for index, cb := range cbs {
			if cb.IsChecked() {
				out = append(out, docs[index].Id)
			}
		}
		return out
	}
	updateButton := func(_ bool) {
		l := len(getToSupp())
		label := "Continuer sans supprimer de documents"
		name := basic.ONAction
		if l > 0 {
			label = fmt.Sprintf("Supprimer %d document(s)", l)
			name = basic.ONDelete
		}
		valid.SetText(label)
		valid.SetObjectName(name)
	}

	for index, doc := range docs {
		cb := widgets.NewQCheckBox(nil)
		cb.ConnectClicked(updateButton)
		cbs = append(cbs, cb)
		lay.AddWidget2(cb, index, 0, 0)
		lay.AddWidget2(basic.Label(fmt.Sprintf("%s (%s)", doc.RawData().NomClient, doc.GetContrainte().Nom)),
			index, 1, 0)
	}

	mainL := widgets.NewQVBoxLayout2(dialog)
	mainL.AddWidget(label, 1, 0)
	mainL.AddLayout(lay, 3)
	mainL.AddWidget(valid, 0, 0)
	if dialog.Exec() == 0 {
		return nil // annulation
	}
	return getToSupp()
}