github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/cont_personnes_export.go

package controllers

import (
	"errors"
	"fmt"
	"path/filepath"
	"regexp"
	"sort"
	"strings"

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

const (
	ExportDEFAULT ModeExport = iota
	ExportPUBLIPOSTAGE
	ExportMAILCHIMP
	ExportMAILS
	ExportPORTABLES
	ExportCOTISATIONS
)
const (
	RoleEquipe  = "_E"
	RoleInscrit = "_I"
	RoleAttente = "_A"

	LienResposEtParticipants = "part_resp" // participants + respos
	LienRespos               = "resp"      // respos uniquement
)

const (
	publiNbExemplaires = dm.LastField + 1 + iota // pour éviter le clash avec les champs Personnes
	publiAdresse
)

var (
	sizeAdresse   = 38
	reLinesBreak  = regexp.MustCompile("[\n\t\r\f\v]")
	reMailValide  = regexp.MustCompile(`\s*\S+@\S+\.\S+\s*`)
	reTelPortable = regexp.MustCompile(`^(\+33[67](\d{8})|33[67](\d{8})|0[67](\d{8}))\s*$`)

	HeadersPUBLIPOSTAGE = []rd.Header{
		{Label: "Num Client"},
		{Field: dm.PersonneSexe, Label: "Civilité"},
		{Field: dm.PersonneNom, Label: "nom"},
		{Field: dm.PersonnePrenom, Label: "Prénom"},
		{Label: "Société"},
		{Field: publiAdresse, Label: "Adresse 1"},
		{Field: publiAdresse + 1, Label: "Adresse 2"},
		{Field: publiAdresse + 2, Label: "Adresse 3"},
		{Field: dm.PersonneCodePostal, Label: "Code postal"},
		{Field: dm.PersonneVille, Label: "Ville"},
		{Field: publiNbExemplaires, Label: "Nombre d'exemplaires"},
		{Field: dm.PersonnePays, Label: "Pays"},
		{Label: "Message 1"},
		{Label: "Message 2"},
	}
	HeadersMAILCHIMP = rd.HeadersMails
	HeadersMAILS     = []rd.Header{
		{},
	}
	HeadersPORTABLES = []rd.Header{
		{},
	}
	HeadersCOTISATIONS = []rd.Header{
		{Field: 0, Label: "Personne"},
		{Field: 1, Label: "Membre ?"},
	}
)

func init() {
	for i, an := range rd.AnneesCotisations {
		HeadersCOTISATIONS = append(HeadersCOTISATIONS, rd.Header{
			Field: rd.Field(2 + i),
			Label: fmt.Sprintf("Cotisation %d", an),
		})
	}
}

type ModeExport int

// Description renvoie une explication détaillée.
func (m ModeExport) Description() string {
	switch m {
	case ExportDEFAULT:
		return "Les personnes et organismes sont séparées, sans traitement particulier."
	case ExportPUBLIPOSTAGE, ExportMAILCHIMP, ExportMAILS, ExportPORTABLES:
		return "Les contacts des organismes sont recoupés avec les personnes."
	case ExportCOTISATIONS:
		return "Les organismes sont ignorés."
	default:
		return ""
	}
}

type CritereRecherche struct {
	Personne    CriteresRecherchePersonne
	Participant CriteresRechercheParticipant
}

// CriteresRecherchePersonne représente une recherche détaillée
// Un critère zero est ignoré
type CriteresRecherchePersonne struct {
	Age           *[2]int // min max
	Departement   rd.Departement
	MembreAsso    rd.RangMembreAsso
	EchoRocher    rd.OptionnalBool
	Eonews        rd.OptionnalBool
	PubEte        rd.OptionnalBool
	PubHiver      rd.OptionnalBool
	VersionPapier rd.OptionnalBool
	HasDocument   rd.BuiltinContrainte
}

type CriteresRechercheParticipant struct {
	Annee            map[int]bool
	Periode          string
	Role             string // rd.Role or special value
	LiensResponsable string // valide pour un inscrit/attente
}

type CriteresRechercheDonateur struct {
	AnneeDon   int
	IsRemercie rd.OptionnalBool
}

// RecherchePersonnesByCriteres cherche d'abord dans les participants, puis dans les respos correspondants.
// Si demandé, les organismes sont aussi ajoutés.
func (c *Personnes) RecherchePersonnesByCriteres(criteres CritereRecherche) rd.Table {
	var finalRes rd.Table

	camps, personnes := c.Base.Camps, c.Base.Personnes
	cpa, cpe := criteres.Participant, criteres.Personne
	idsPersonnes := rd.NewSet() // besoin unicité des personnes

	critereCamp := func(idCamp int64) bool {
		match := true
		if len(cpa.Annee) > 0 {
			an := int(camps[idCamp].Annee())
			match = match && cpa.Annee[an]
		}
		if cpa.Periode != "" {
			match = match && cpa.Periode == camps[idCamp].Periode().String()
		}
		return match
	}

	// les personnes temporaires sont filtrées plus bas
	switch {
	case cpa.Role == RoleInscrit || cpa.Role == RoleAttente:
		// on cherche parmi les participants, on ignore les participants simples
		for _, part := range c.Base.Participants {
			isInscrit := part.ListeAttente.IsInscrit()
			matchRole := (cpa.Role == RoleInscrit) == isInscrit
			if matchRole && critereCamp(c.Base.NewParticipant(part.Id).GetCamp().Id) {
				if cpa.LiensResponsable != "" && part.IdFacture.IsNotNil() {
					// LiensResponsable demande forcément le reponsable
					idsPersonnes.Add(part.IdFacture.Int64)
				}
				if cpa.LiensResponsable != LienRespos {
					// le seul cas ou on ne met pas le participant
					idsPersonnes.Add(part.IdPersonne)
				}
			}
		}
	case cpa.Role != "":
		// on cherche parmi les équipiers
		for _, part := range c.Base.Equipiers {
			matchRole := cpa.Role == RoleEquipe || part.Roles.Is(rd.Role(cpa.Role))
			if matchRole && critereCamp(part.IdCamp) {
				idsPersonnes.Add(part.IdPersonne)
			}
		}
	default:
		// toutes les personnes, pas seulement les participants
		idsPersonnes = c.Base.Personnes.Ids().AsSet()
	}

	reDep, err := regexp.Compile("^" + string(cpe.Departement))
	cache := c.Base.ResoudDocumentsPersonnes()
	for idPers := range idsPersonnes { // on applique maintent le critère sur la personne
		pers, match := personnes[idPers], true
		if pers.IsTemporaire { // on ignore les profils non référencés
			continue
		}
		accesPers := c.Base.NewPersonne(pers.Id)
		if cpe.Age != nil {
			age := pers.Age()
			match = cpe.Age[0] <= age && age <= cpe.Age[1]
		}
		if err == nil && cpe.Departement != "" {
			cp := strings.ReplaceAll(string(pers.CodePostal), " ", "")
			match = match && reDep.MatchString(cp)
		}
		if cpe.MembreAsso != rd.RMANonMembre {
			match = match && pers.RangMembreAsso.AtLeast(cpe.MembreAsso)
		}
		if cpe.EchoRocher != 0 {
			match = match && cpe.EchoRocher.Bool() == bool(pers.EchoRocher)
		}
		if cpe.PubEte != 0 {
			match = match && cpe.PubEte.Bool() == bool(pers.PubEte)
		}
		if cpe.PubHiver != 0 {
			match = match && cpe.PubHiver.Bool() == bool(pers.PubHiver)
		}
		if cpe.Eonews != 0 {
			match = match && cpe.Eonews.Bool() == bool(pers.Eonews)
		}
		if cpe.VersionPapier != 0 {
			match = match && cpe.VersionPapier.Bool() == bool(pers.VersionPapier)
		}
		if cpe.HasDocument != "" {
			match = match && accesPers.HasDocument(cache, cpe.HasDocument)
		}
		if match {
			finalRes = append(finalRes, accesPers.AsItem(0))
		}
	}

	return finalRes
}

func (c *Personnes) RechercheDonateursByCriteres(cd CriteresRechercheDonateur) []dm.AccesPersonne {
	idsPersonnes := rd.NewSet()
	for _, don := range c.Base.Dons {
		match := true
		if cd.AnneeDon != 0 {
			match = cd.AnneeDon == don.DateReception.Time().Year()
		}
		if cd.IsRemercie != rd.OBPeutEtre {
			match = match && bool(don.Remercie) == cd.IsRemercie.Bool()
		}
		donateur := c.Base.DonDonateurs[don.Id]
		if match && donateur.IdPersonne.IsNotNil() {
			idsPersonnes[donateur.IdPersonne.Int64] = true
		}
	}
	res := make([]dm.AccesPersonne, 0, len(idsPersonnes))
	for id := range idsPersonnes {
		res = append(res, c.Base.NewPersonne(id))
	}
	return res
}

// EffaceListe remet à zéro l'état et enlève toutes les personnes
// de la liste courante.
func (c *Personnes) EffaceListe() {
	c.Etat = EtatPersonnes{}
	c.Liste = rd.Table{}
	c.ResetRender()
}

// AjouteToListe remet à zéro l'état et ajoute les personnes données
// à la liste courante.
func (c *Personnes) AjouteToListe(personnes rd.Table) {
	c.Etat = EtatPersonnes{}
	ids := map[rd.IId]rd.Item{} // unicité
	for _, item := range append(c.Liste, personnes...) {
		ids[item.Id] = item
	}
	c.Liste = make(rd.Table, 0, len(ids))
	for _, item := range ids {
		c.Liste = append(c.Liste, item)
	}
	c.ResetRender()
}

func (c *Personnes) AjouteOrganismesToListe() {
	t := make(rd.Table, 0, len(c.Base.Organismes))
	for id := range c.Base.Organismes {
		t = append(t, c.Base.NewOrganisme(id).AsItem())
	}
	c.AjouteToListe(t)
}

type itemExemplaires struct {
	item rd.Item        // une personne ou un organisme avec un contact propre
	exs  rd.Exemplaires // au moins 1
}

// identifie les personnes et les contacts d'organismes
func resoudContactOrganismes(liste rd.Table, base *dm.BaseLocale) []itemExemplaires {
	pers := make(map[rd.IdPersonne]itemExemplaires)
	var out []itemExemplaires
	for _, item := range liste {
		switch itemId := item.Id.(type) {
		case rd.IdPersonne:
			itemEx := pers[itemId]
			// on ajoute la personne propre aux exemplaires
			itemEx.item = item
			itemEx.exs = rd.Exemplaires{
				EchoRocher: itemEx.exs.EchoRocher + 1,
				PubEte:     itemEx.exs.PubEte + 1,
				PubHiver:   itemEx.exs.PubHiver + 1,
			}
			pers[itemId] = itemEx
		case rd.IdOrganisme:
			// on différencie suivant ContactPropre
			org := base.NewOrganisme(itemId.Int64()).RawData()
			if org.ContactPropre { // ligne propre
				out = append(out, itemExemplaires{item: item, exs: org.Exemplaires})
			} else { // on aggrège au contact
				idPers := rd.IdPersonne(org.IdContact.Int64)
				contact := pers[idPers]
				// les contacts n'étant pas aussi présent comme personne
				// doivent être ajouté ici
				contact.item = base.NewPersonne(idPers.Int64()).AsItem(0)
				contact.exs = rd.Exemplaires{
					EchoRocher: contact.exs.EchoRocher + org.Exemplaires.EchoRocher,
					PubEte:     contact.exs.PubEte + org.Exemplaires.PubEte,
					PubHiver:   contact.exs.PubHiver + org.Exemplaires.PubHiver,
				}
				pers[idPers] = contact
			}
		}
	}

	// on ajoute les personnes "augmentées"
	for _, itemEx := range pers {
		out = append(out, itemEx)
	}
	return out
}

// ValideExport vérifie et nettoie la liste actuelle et la renvoie.
// Les organismes sont résolus, en utilisant leur contact le cas échéant.
// Renvoie aussi le nombre de lignes invalides.
func (c *Personnes) ValideExport(mode ModeExport, option dm.OptionExport) (out rd.Table, invalides int) {
	switch mode {
	case ExportDEFAULT:
		out = c.Liste
	case ExportCOTISATIONS:
		var liste []dm.AccesPersonne
		for _, ac := range c.Liste {
			if id, ok := ac.Id.(rd.IdPersonne); ok {
				liste = append(liste, c.Base.NewPersonne(id.Int64()))
			}
		}
		if option == dm.MembresTriAlphabetique {
			sort.Slice(liste, func(i, j int) bool {
				return liste[i].RawData().Nom < liste[j].RawData().Nom
			})
		} else if option == dm.MembresTriCotisation {
			sort.Slice(liste, func(i, j int) bool {
				return liste[i].RawData().Cotisation.Sortable() < liste[j].RawData().Cotisation.Sortable()
			})
		}
		out = make(rd.Table, len(liste))
		for i, pers := range liste {
			out[i] = itemMembreCotisations(pers)
		}
	default:
		// on commence par recoupper les pers et les orgs.
		items := resoudContactOrganismes(c.Liste, c.Base)
		switch mode {
		case ExportPUBLIPOSTAGE:
			out = formatPublipostage(items, option)
		case ExportMAILCHIMP:
			uniq := make(map[string]rd.Item)
			for _, pers := range items {
				mail := pers.item.Fields.Data(dm.PersonneMail).String()
				if reMailValide.MatchString(mail) {
					uniq[mail] = pers.item
				} else {
					invalides += 1
				}
			}
			for _, mc := range uniq {
				out = append(out, mc)
			}
		case ExportMAILS:
			uniq := rd.StringSet{}
			for _, pers := range items {
				mail := pers.item.Fields.Data(dm.PersonneMail).String()
				if reMailValide.MatchString(mail) {
					uniq[mail] = true
				} else {
					invalides += 1
				}
			}
			for mail := range uniq {
				out = append(out, rd.Item{Fields: rd.F{0: rd.String(mail)}})
			}
		case ExportPORTABLES:
			uniq := rd.StringSet{}
			for _, pers := range items {
				tels, _ := pers.item.Fields.Data(dm.PersonneTels).(rd.Tels)
				for _, tel := range tels {
					tel = rd.CondenseTel(tel)
					if reTelPortable.MatchString(tel) {
						uniq[tel] = true
					} else {
						invalides += 1
					}
				}
			}
			for tel := range uniq {
				out = append(out, rd.Item{Fields: rd.F{0: rd.String(rd.FormatTel(tel))}})
			}
		}
	}
	return out, invalides
}

func splitString(s string, maxSize int) []string {
	s = reLinesBreak.ReplaceAllString(s, " ")
	mots := strings.Split(s, " ")
	var (
		currentRow string
		res        []string
	)
	for _, mot := range mots {
		if mot == "" {
			continue
		}
		nextSize := len(currentRow) + len(mot) + 1
		if nextSize <= maxSize {
			currentRow += mot + " "
		} else {
			res = append(res, currentRow)
			currentRow = mot
		}
	}
	res = append(res, currentRow)
	return res
}

func formatPublipostage(list []itemExemplaires, typeCom dm.OptionExport) rd.Table {
	out := make(rd.Table, len(list))
	for index, itemEx := range list {
		fields := itemEx.item.Fields
		// on ajoute les champs spéciaux
		switch typeCom {
		case dm.PubEte:
			fields[publiNbExemplaires] = rd.Int(itemEx.exs.PubEte)
		case dm.PubHiver:
			fields[publiNbExemplaires] = rd.Int(itemEx.exs.PubHiver)
		case dm.EchoRocher:
			fields[publiNbExemplaires] = rd.Int(itemEx.exs.EchoRocher)
		}

		ads := splitString(fields.Data(dm.PersonneAdresse).String(), sizeAdresse)
		for nbAd := 0; nbAd < 3; nbAd++ {
			var ad string
			if nbAd < len(ads) {
				ad = ads[nbAd]
			}
			fields[publiAdresse+rd.Field(nbAd)] = rd.String(ad)
		}

		out[index] = rd.Item{Fields: fields}
	}
	return out
}

// affiche le détails des cotisations
func itemMembreCotisations(personne dm.AccesPersonne) rd.Item {
	fields := rd.F{
		0: personne.RawData().NomPrenom(),
		1: personne.RawData().RangMembreAsso,
	}
	cots := personne.RawData().Cotisation.Map()
	for index, annee := range rd.AnneesCotisations {
		has := cots[annee]
		var s rd.String = "-"
		if has {
			s = "Ok"
		}
		fields[rd.Field(index+2)] = s
	}
	bolds := rd.B{0: true}
	return rd.Item{Fields: fields, Bolds: bolds}
}

// SaveExport enregistre l'export et renvoie le chemin.
func (c *Personnes) ExportAndSave(mode ModeExport, option dm.OptionExport) string {
	liste, _ := c.ValideExport(mode, option)
	var (
		path string
		err  error
	)
	switch mode {
	case ExportDEFAULT:
		path, err = table.ExportExcel(c.Header[0:9], liste, LocalFolder)
	case ExportPUBLIPOSTAGE:
		path, err = table.ExportExcel(HeadersPUBLIPOSTAGE, liste, LocalFolder)
	case ExportMAILCHIMP:
		path, err = table.ExportCsv(HeadersMAILCHIMP, liste, LocalFolder)
	case ExportMAILS:
		path, err = table.ExportCsv(HeadersMAILS, liste, LocalFolder)
	case ExportPORTABLES:
		path, err = table.ExportCsv(HeadersPORTABLES, liste, LocalFolder)
	case ExportCOTISATIONS:
		path, err = table.ExportExcel(HeadersCOTISATIONS, liste, LocalFolder)
	default:
		err = errors.New("Mode d'export inconnu !")
	}
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	path, err = filepath.Abs(path)
	if err != nil {
		c.main.ShowError(err)
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Export généré dans %s", path), false)
	return path
}