github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/datamodel/search.go

package datamodel

import (
	"regexp"
	"sort"
	"strings"

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

// Fonctions de recherche rapide (par string)

func matchSearch(regexps []*regexp.Regexp, dataString string) bool {
	dataString = matching.RemoveAccents(dataString)
	for _, r := range regexps {
		if !r.MatchString(dataString) {
			return false
		}
	}
	return true
}

func prepareSearch(pattern string) (out []*regexp.Regexp, err error) {
	if pattern == "*" {
		return out, nil
	}

	for _, s := range strings.Split(pattern, " ") {
		if strings.TrimSpace(s) == "" {
			continue
		}
		r, err := regexp.Compile("(?i)" + matching.RemoveAccents(s))
		if err != nil {
			return out, err
		}
		out = append(out, r)
	}
	return out, nil
}

func personneToString(raw rd.Personne) string {
	return raw.NomPrenom().String()
}

func organismeToString(raw rd.Organisme) string {
	return raw.Nom.String()
}

func aideToString(raw rd.Aide, base *BaseLocale) string {
	part := base.Participants[raw.IdParticipant]
	struc := base.Structureaides[raw.IdStructureaide]
	return participantToString(part, base) + " " + structureaideToString(struc)
}

func campToString(raw rd.Camp) string {
	return string(raw.Nom) + " " + raw.DateDebut.String() + " " + raw.DateFin.String()
}

func groupeToString(raw rd.Groupe, base *BaseLocale) string {
	return string(raw.Nom) + " " + campToString(base.Camps[raw.IdCamp])
}

func participantToString(raw rd.Participant, base *BaseLocale) string {
	pers := base.Personnes[raw.IdPersonne]
	camp := base.Camps[raw.IdCamp]
	return personneToString(pers) + " " + string(camp.Nom) + " " + camp.DateDebut.String()
}

func structureaideToString(raw rd.Structureaide) string {
	return string(raw.Nom + " " + raw.Immatriculation)
}

func factureToString(raw rd.Facture, base *BaseLocale) string {
	pers := base.Personnes[raw.IdPersonne]
	return personneToString(pers)
}

func (b *BaseLocale) RechercheRapidePersonnes(withOrganismes bool, pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}

	for i, v := range b.Personnes {
		if !bool(v.IsTemporaire) && matchSearch(rs, personneToString(v)) {
			out = append(out, b.NewPersonne(i).AsItem(0))
		}
	}

	if !withOrganismes {
		return out
	}

	for i, o := range b.Organismes {
		if matchSearch(rs, organismeToString(o)) {
			out = append(out, b.NewOrganisme(i).AsItem())
		}
	}

	return
}

func (b *BaseLocale) RechercheRapideAides(pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}

	for i, v := range b.Aides {
		if matchSearch(rs, aideToString(v, b)) {
			out = append(out, b.NewAide(i).AsItem())
		}
	}
	return
}

func (b *BaseLocale) RechercheRapideCamps(pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}

	_, cache1 := b.ResoudParticipants()
	cache2 := b.ResoudParticipantsimples()
	for i, v := range b.Camps {
		if matchSearch(rs, campToString(v)) {
			out = append(out, b.NewCamp(i).AsItem(cache1, cache2))
		}
	}
	return
}

func (b *BaseLocale) RechercheRapideGroupes(pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}

	for i, v := range b.Groupes {
		if matchSearch(rs, groupeToString(v, b)) {
			out = append(out, b.NewGroupe(i).AsItem())
		}
	}
	return
}

// RechercheRapideParticipants ignore les équipiers et les participants simples
func (b *BaseLocale) RechercheRapideParticipants(pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}

	var tmp []rd.Participant
	for _, v := range b.Participants {
		if matchSearch(rs, participantToString(v, b)) {
			tmp = append(tmp, v)
		}
	}
	_, cache := b.ResoudParticipants()
	getDate := func(i int) int {
		return b.Camps[tmp[i].IdCamp].DateDebut.Time().Year()
	}
	hasDoss := func(i int) bool {
		return tmp[i].IdFacture.Valid
	}
	// Tri par date de participation
	sort.Slice(tmp, func(i, j int) bool { return getDate(i) > getDate(j) })
	// Participant libre d'abord
	sort.SliceStable(tmp, func(i, j int) bool { return !hasDoss(i) && hasDoss(j) })
	out = make(rd.Table, len(tmp))
	for index, rawPart := range tmp {
		out[index] = b.NewParticipant(rawPart.Id).AsItem(cache)
	}
	return out
}

func (b *BaseLocale) RechercheRapideStructureaides(pattern string) rd.Table {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return nil
	}

	var tmp []int64
	for i, v := range b.Structureaides {
		if matchSearch(rs, structureaideToString(v)) {
			tmp = append(tmp, i)
		}
	}

	// Tri par utilisations des structures
	frequences := make(map[int64]int, len(b.Structureaides))
	for _, aide := range b.Aides {
		frequences[aide.IdStructureaide] += 1
	}
	sort.Slice(tmp, func(i, j int) bool { return frequences[tmp[i]] > frequences[tmp[j]] })

	out := make(rd.Table, len(tmp))
	for index, idStructure := range tmp {
		out[index] = b.NewStructureaide(idStructure).AsItem()
	}
	return out
}

func (b *BaseLocale) RechercheRapideFactures(pattern string) (out rd.Table) {
	rs, err := prepareSearch(pattern)
	if err != nil {
		return
	}
	cache1, _ := b.ResoudParticipants()
	cache2 := b.ResoudMessages()
	cache3 := b.ResoudPaiements()
	for i, v := range b.Factures {
		if matchSearch(rs, factureToString(v, b)) {
			ac := b.NewFacture(i)
			out = append(out, ac.AsItem(cache1, cache2, cache3))
		}
	}
	return
}

// RechercheDetailleeChilds renvoie la liste filtrée, avec les champs Bold mis à jour
// `in` peut aussi être modifiée et devrait être ignorée après l'appel
func RechercheDetailleeChilds(in []rd.ItemChilds, pattern string, entete []rd.Header) (out []rd.ItemChilds) {
	rs, err := prepareSearch(pattern)
	if err != nil || len(rs) == 0 {
		return
	}
	// alloue un cache une fois pour toute
	cacheStrings := make([]string, len(entete))

	var groupeMatch, rowMatch bool
	for _, row := range in {
		groupeMatch = false // il suffit d'une seule ligne (parent ou enfant) qui match

		// on analyse le parent ...
		row.Item, rowMatch = checkItem(entete, row.Item, cacheStrings, rs)
		if rowMatch {
			groupeMatch = true
		}

		// ... puis les enfants
		for indexChild, itemChild := range row.Childs {
			row.Childs[indexChild], rowMatch = checkItem(entete, itemChild, cacheStrings, rs)
			if rowMatch {
				groupeMatch = true
			}
		}

		if groupeMatch {
			out = append(out, row)
		}
	}
	return out
}

func RechercheDetaillee(in rd.Table, pattern string, entete []rd.Header) rd.Table {
	// on transforme temporairement les Items en ItemChilds ...
	tmp := make([]rd.ItemChilds, len(in))
	for i, v := range in {
		tmp[i] = rd.ItemChilds{Item: v}
	}
	tmp = RechercheDetailleeChilds(tmp, pattern, entete)
	// ... et on reconvertit dans l'autre sens
	out := make(rd.Table, len(tmp))
	for i, v := range tmp {
		out[i] = v.Item
	}
	return out
}

// renvoie l'item avec les champs Bolds mis à jour, et `true` si l'item passe la recherche
func checkItem(entete []rd.Header, item rd.Item, cacheStrings []string, rs []*regexp.Regexp) (rd.Item, bool) {
	rowMatch := true

	// processe Data une seule fois
	for indexE, fieldE := range entete {
		cacheStrings[indexE] = matching.RemoveAccents(item.Fields.Data(fieldE.Field).String())
	}

	// init & reset
	item.Bolds = make(rd.B)

	for _, re := range rs {
		reFound := false
		for index, field := range entete {
			if re.MatchString(cacheStrings[index]) {
				reFound = true
				item.Bolds[field.Field] = true
			}
		}

		// toutes les regexps doivent matcher (au moins une case)
		if !reFound {
			rowMatch = false
			break
		}
	}

	return item, rowMatch
}

// ChercheSimilaires applique la recherche de similarité sur toutes
// la base
func (b *BaseLocale) ChercheSimilaires(in matching.PatternsSimilarite) rd.Table {
	pers := b.GetRawPersonnes()
	sm, res := matching.ChercheSimilaires(pers, in)
	out := make(rd.Table, len(res))
	for i, r := range res {
		ac := b.NewPersonne(r.Personne.Id)
		pertinence := float64(r.Score) / float64(sm)
		out[i] = ac.AsItem(pertinence)
	}
	return out
}