github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/rawdata/matching/similaires.go

// Implémente des outils de recherche et de fusion de profil
package matching

import (
	"strings"

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

// Ce fichier implémente un algorithme de comparaison
// champ par champ entre deux personnes (une entrante et une existante).
// Il est utilisé de façon automatique pour fusionner
// une inscription avec une personne déjà existante,
// et de façon semi-automatique sur le client pour rapprocher
// une personne temporaire d'une personne existante.

// IdentifieTarget est une union décrivant le résultat
// d'une identification ("vers un nouveau profil" ou "rapprochement")
type IdentifieTarget interface {
	isIdentifieTarget()
}

type NouveauProfil struct{}

func (NouveauProfil) isIdentifieTarget() {}

type Rattache struct {
	IdTarget      int64           // la personne à laquelle se rattacher
	Modifications rd.BasePersonne // le résultat de la fusion, à appliquer à la cible
}

func (Rattache) isIdentifieTarget() {}

// résultat d'une comparaison
type diff int

const (
	diffInZero    diff = iota // la valeur entrante est vide
	diffExistZero             // la valeur existante est vide
	diffEqual                 // les deux valeurs sont similaires
	diffConflict              // les deux valeurs sont vraiments différentes
)

func equalString(s1, s2 rd.String) diff {
	if s1 == "" {
		return diffInZero
	}
	if s2 == "" {
		return diffExistZero
	}
	ss1 := strings.ToLower(strings.Replace(RemoveAccents(string(s1)), " ", "", -1))
	ss2 := strings.ToLower(strings.Replace(RemoveAccents(string(s2)), " ", "", -1))
	if ss1 == ss2 {
		return diffEqual
	}
	return diffConflict
}

func equalTels(t1, t2 rd.Tels) diff {
	if len(t1) == 0 {
		return diffInZero
	}
	if len(t2) == 0 {
		return diffExistZero
	}
	s1, s2 := make(map[string]bool), make(map[string]bool)
	for _, t := range t1 {
		s1[rd.CondenseTel(t)] = true
	}
	for _, t := range t2 {
		t = rd.CondenseTel(t)
		if !s1[t] {
			return diffConflict
		}
		s2[t] = true
	}
	for t := range s1 {
		if !s2[t] {
			return diffConflict
		}
	}
	return diffEqual
}

func equalBool(in, out rd.Bool) diff {
	if !in {
		return diffInZero
	}
	if !out {
		return diffExistZero
	}
	if in == out {
		return diffEqual
	}
	return diffConflict
}

func equalDate(in, out rd.Date) diff {
	if in.Time().IsZero() {
		return diffInZero
	}
	if out.Time().IsZero() {
		return diffExistZero
	}
	if in.Equals(out) {
		return diffEqual
	}
	return diffConflict
}

func equalSexe(in, out rd.Sexe) diff {
	if in == "" {
		return diffInZero
	}
	if out == "" {
		return diffExistZero
	}
	if in == out {
		return diffEqual
	}
	return diffConflict
}

// Conflicts indique quels champs n'ont pu être automatiquement fusionnés
type Conflicts struct {
	Nom                  bool
	NomJeuneFille        bool
	Prenom               bool
	DateNaissance        bool
	VilleNaissance       bool
	DepartementNaissance bool
	Sexe                 bool
	Tels                 bool
	Mail                 bool
	Adresse              bool
	CodePostal           bool
	Ville                bool
	Pays                 bool
	SecuriteSociale      bool
	Profession           bool
	Etudiant             bool
	Fonctionnaire        bool
}

// renvoi l'index d'un tableau [entrant, existant] et un conflit (ou non)
// ce serait plus élégant avec des génériques
func (d diff) choose() (int, bool) {
	switch d {
	case diffInZero: // on garde l'existant
		return 1, false
	case diffExistZero: // on ecrase l'existant
		return 0, false
	case diffEqual: // on ecrase (c'est plus cohérent avec l'attente utilisateur)
		return 0, false
	case diffConflict: // on écrase et on alerte
		return 0, true
	default:
		panic("unknow diff type")
	}
}

func chooseString(entrant, existant rd.String) (rd.String, bool) {
	d := equalString(entrant, existant)
	i, b := d.choose()
	return [2]rd.String{entrant, existant}[i], b
}

func chooseTels(entrant, existant rd.Tels) (rd.Tels, bool) {
	d := equalTels(entrant, existant)
	i, b := d.choose()
	return [2]rd.Tels{entrant, existant}[i], b
}

func chooseBool(entrant, existant rd.Bool) (rd.Bool, bool) {
	d := equalBool(entrant, existant)
	i, b := d.choose()
	return [2]rd.Bool{entrant, existant}[i], b
}

func chooseDate(entrant, existant rd.Date) (rd.Date, bool) {
	d := equalDate(entrant, existant)
	i, b := d.choose()
	return [2]rd.Date{entrant, existant}[i], b
}

func chooseSexe(entrant, existant rd.Sexe) (rd.Sexe, bool) {
	d := equalSexe(entrant, existant)
	i, b := d.choose()
	return [2]rd.Sexe{entrant, existant}[i], b
}

func chooseDepartement(entrant, existant rd.Departement) (rd.Departement, bool) {
	d := equalString(rd.String(entrant), rd.String(existant)) // as strings
	i, b := d.choose()
	return [2]rd.Departement{entrant, existant}[i], b
}

// Merge compare champs par champs les deux personnes et renvoie
// le résultat de la fusion et un crible d'alerte
func Merge(entrant rd.BasePersonne, existant rd.BasePersonne) (merged rd.BasePersonne, conflicts Conflicts) {
	merged.Nom, conflicts.Nom = chooseString(entrant.Nom, existant.Nom)
	merged.NomJeuneFille, conflicts.NomJeuneFille = chooseString(entrant.NomJeuneFille, existant.NomJeuneFille)
	merged.Prenom, conflicts.Prenom = chooseString(entrant.Prenom, existant.Prenom)
	merged.DateNaissance, conflicts.DateNaissance = chooseDate(entrant.DateNaissance, existant.DateNaissance)
	merged.VilleNaissance, conflicts.VilleNaissance = chooseString(entrant.VilleNaissance, existant.VilleNaissance)
	merged.DepartementNaissance, conflicts.DepartementNaissance = chooseDepartement(entrant.DepartementNaissance, existant.DepartementNaissance)
	merged.Sexe, conflicts.Sexe = chooseSexe(entrant.Sexe, existant.Sexe)
	merged.Tels, conflicts.Tels = chooseTels(entrant.Tels, existant.Tels)
	merged.Mail, conflicts.Mail = chooseString(entrant.Mail, existant.Mail)
	merged.Adresse, conflicts.Adresse = chooseString(entrant.Adresse, existant.Adresse)
	merged.CodePostal, conflicts.CodePostal = chooseString(entrant.CodePostal, existant.CodePostal)
	merged.Ville, conflicts.Ville = chooseString(entrant.Ville, existant.Ville)
	merged.Pays, conflicts.Pays = chooseString(entrant.Pays, existant.Pays)
	merged.SecuriteSociale, conflicts.SecuriteSociale = chooseString(entrant.SecuriteSociale, existant.SecuriteSociale)
	merged.Profession, conflicts.Profession = chooseString(entrant.Profession, existant.Profession)
	merged.Etudiant, conflicts.Etudiant = chooseBool(entrant.Etudiant, existant.Etudiant)
	merged.Fonctionnaire, conflicts.Fonctionnaire = chooseBool(entrant.Fonctionnaire, existant.Fonctionnaire)
	return merged, conflicts
}