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

package datamodel

import (
	"math"

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

const (
	// zero est utile pour ignorer une colonne
	_ rd.Field = iota

	// partagé avec les organismes
	PersonneNom
	PersonnePrenom
	PersonneSexe
	PersonneAge
	PersonneDateNaissance
	PersonneRangMembreAsso
	PersonneCotisation

	PersonneTels // concrete type rd.Tels
	PersonneMail
	PersonneAdresse
	PersonneCodePostal
	PersonneVille
	PersonnePays

	PersonneCommune // codepostal + ville

	PersonneNomPrenom
	PersonneTelsLines
	PersonneVersionPapier
	PersonnePubHiver
	PersonnePubEte
	PersonneEchoRocher
	PersonneQuotientFamilial
	PersonneVilleNaissance
	PersonneDepartementNaissance
	PersonneNomJeuneFille
	PersonneProfession
	PersonneEtudiant
	PersonneFonctionnaire
	PersonneSecuriteSociale
	PersonneEonews
	PersonnePertinence
	PersonneIdentifie

	CampLieu
	CampNom
	CampPrix
	CampNbPlaces
	CampPassword
	CampOuvert
	CampNbPlacesReservees
	CampIdJs
	CampAnnee
	CampDateDebut
	CampDateFin
	CampPeriode
	CampRemplissage
	CampLabel
	CampJoomeoAlbumId

	GroupeLabel

	AideValeur
	AideValide
	AideMontant
	AideNbJoursMax
	AideStructure
	AideCamp
	AideAnnee
	AideNomPrenom

	StructureaideNom
	StructureaideImmatriculation
	StructureaideAdresse
	StructureaideCodePostal
	StructureaideVille
	StructureaideTelephone
	StructureaideInfo

	DonValeur
	DonModePaiement
	DonDateReception
	DonRemercie
	DonRecuEmis
	DonDetails
	DonAffectation
	DonDonateur
	// coordonnées du donateur
	DonDonateurTels
	DonDonateurMail
	DonDonateurAdresse
	DonDonateurCodePostal
	DonDonateurVille
	DonDonateurPays

	DocumentCategorie
	DocumentTaille
	DocumentNomClient
	DocumentDescription
	DocumentDateHeureModif
	DocumentNomPrenom

	PaiementIsAcompte
	PaiementIsRemboursement
	PaiementLabelPayeur
	PaiementNomBanque
	PaiementModePaiement
	PaiementNumero
	PaiementValeur
	PaiementDateReglement
	PaiementDetails
	PaiementInBordereau

	FactureCamps
	FactureParticipants

	ParticipantCamp
	ParticipantGroupe
	ParticipantAnimateur
	ParticipantBus
	ParticipantMaterielSki
	ParticipantMaterielSkiType
	ParticipantAgeDebutCamp
	ParticipantRaisonAttente
	ParticipantRespoNom
	ParticipantRespoPrenom
	ParticipantRespoNomPrenom
	ParticipantRespoMail
	ParticipantRespoTels
	ParticipantRespoTelsLines
	ParticipantRespoAdresse
	ParticipantRespoCodePostal
	ParticipantRespoVille
	ParticipantRespoCommune // Ville + Code postal
	ParticipantRespoPays
	ParticipantEtat
	ParticipantOptionPrix // requis par les directeurs

	EquipierCamp
	EquipierRoles
	EquipierPresence
	EquipierDiplome
	EquipierAppro

	InscriptionDateHeure

	LastField
)

// La couleur du text interpole de vert à rouge,
// en fonction de la `pertinence`.
func (ac AccesPersonne) AsItem(pertinence float64) rd.Item {
	raw := ac.RawData()
	fields := rd.F{
		PersonneNom:       rd.String(raw.Nom.ToUpper()),
		PersonnePrenom:    rd.String(rd.FormatPrenom(raw.Prenom)),
		PersonneNomPrenom: raw.NomPrenom(),
		PersonneSexe:      raw.Sexe.String(),

		PersonneTels:       raw.Tels,
		PersonneTelsLines:  raw.Tels.StringLines(),
		PersonneMail:       raw.Mail,
		PersonneAdresse:    raw.Adresse,
		PersonneCodePostal: raw.CodePostal,
		PersonneVille:      raw.Ville,
		PersonnePays:       raw.Pays,
		PersonneCommune:    raw.CodePostal + " - " + raw.Ville,

		PersonneVersionPapier:        raw.VersionPapier.String(),
		PersonnePubHiver:             raw.PubHiver.String(),
		PersonnePubEte:               raw.PubEte.String(),
		PersonneEchoRocher:           raw.EchoRocher.String(),
		PersonneRangMembreAsso:       raw.RangMembreAsso,
		PersonneQuotientFamilial:     raw.QuotientFamilial,
		PersonneVilleNaissance:       raw.VilleNaissance,
		PersonneDepartementNaissance: raw.DepartementNaissance,
		PersonneNomJeuneFille:        raw.NomJeuneFille,
		PersonneDateNaissance:        raw.DateNaissance,
		PersonneProfession:           raw.Profession,
		PersonneEtudiant:             raw.Etudiant.String(),
		PersonneFonctionnaire:        raw.Fonctionnaire.String(),
		PersonneSecuriteSociale:      rd.FormatSecuriteSocial(raw.SecuriteSociale),
		PersonneCotisation:           raw.Cotisation,
		PersonneEonews:               raw.Eonews.String(),
		PersonneAge:                  rd.Int(raw.Age()),
		PersonnePertinence:           rd.Pourcent(int(pertinence * 100)),
		PersonneIdentifie:            (!raw.IsTemporaire).String(),
	}

	var textColor rd.Color
	if pertinence != 0 {
		greenLevel := uint8(math.Floor(pertinence * 160))
		textColor = rd.RGBA{R: 255 - greenLevel, G: greenLevel, B: 15, A: 255}
	}

	idColor := rd.Complete.Color()
	if raw.IsTemporaire {
		idColor = rd.NonCommencee.Color()
	}
	bgColors := rd.MapColors{PersonneIdentifie: idColor}
	return rd.Item{Id: rd.IdPersonne(ac.Id), Fields: fields, TextColors: rd.ConstantColor{Color: textColor}, BackgroundColors: bgColors}
}

// La couleur de fond dépend de la période du séjour
func (ac AccesCamp) AsItem(cache1 LiensCampParticipants, cache2 LiensCampParticipantsimples) rd.Item {
	raw := ac.RawData()
	bgColor := raw.ColorPeriode()
	fields := rd.F{
		CampLieu:              raw.Lieu,
		CampNom:               raw.Nom,
		CampPrix:              raw.Prix,
		CampNbPlaces:          raw.NbPlaces,
		CampPassword:          raw.Password,
		CampOuvert:            raw.Ouvert.String(),
		CampNbPlacesReservees: raw.NbPlacesReservees,
		CampIdJs:              raw.NumeroJS,
		CampAnnee:             raw.Annee(),
		CampDateDebut:         raw.DateDebut,
		CampDateFin:           raw.DateFin,
		CampPeriode:           raw.Periode(),
		CampRemplissage:       rd.Int(ac.Remplissage(cache1, cache2)),
		CampLabel:             raw.Label(),
		CampJoomeoAlbumId:     raw.JoomeoAlbumId,
	}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields, BackgroundColors: rd.ConstantColor{Color: bgColor}}
}

func (ac AccesGroupe) AsItem() rd.Item {
	fields := rd.F{GroupeLabel: ac.Label()}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesAide) AsItem() rd.Item {
	raw := ac.RawData()
	camp := ac.GetParticipant().GetCamp()
	fields := rd.F{
		AideValeur:     raw.Valeur,
		AideValide:     raw.Valide.String(),
		AideMontant:    raw.Montant(),
		AideNbJoursMax: raw.NbJoursMax,
		AideStructure:  ac.GetStructureaide().RawData().Nom,
		AideCamp:       camp.RawData().Nom,
		AideAnnee:      camp.RawData().Annee(),
		AideNomPrenom:  ac.GetParticipant().GetPersonne().RawData().NomPrenom(),
	}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesStructureaide) AsItem() rd.Item {
	raw := ac.RawData()
	fields := rd.F{
		StructureaideNom:             raw.Nom,
		StructureaideImmatriculation: raw.Immatriculation,
		StructureaideAdresse:         raw.Adresse,
		StructureaideCodePostal:      raw.CodePostal,
		StructureaideVille:           raw.Ville,
		StructureaideTelephone:       raw.Telephone,
		StructureaideInfo:            raw.Info,
	}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesDon) AsItem() rd.Item {
	raw := ac.RawData()
	var (
		donateurLabel rd.String
		donateurCoord rd.Coordonnees
	)
	switch donateur := ac.GetDonateur().(type) {
	case AccesPersonne:
		donateurLabel = donateur.RawData().NomPrenom()
		donateurCoord = donateur.CoordonneesDons()
	case AccesOrganisme:
		donateurLabel = donateur.RawData().Nom
		donateurCoord = donateur.CoordonneesDons()
	default:
		donateurLabel = "Don anonyme"
	}

	fields := rd.F{
		DonValeur:             raw.Valeur,
		DonModePaiement:       raw.ModePaiement.String(),
		DonDateReception:      raw.DateReception,
		DonRemercie:           raw.Remercie.String(),
		DonRecuEmis:           raw.RecuEmis,
		DonDetails:            raw.Details,
		DonAffectation:        raw.Affectation,
		DonDonateur:           donateurLabel,
		DonDonateurTels:       donateurCoord.Tels,
		DonDonateurMail:       donateurCoord.Mail,
		DonDonateurAdresse:    donateurCoord.Adresse,
		DonDonateurCodePostal: donateurCoord.CodePostal,
		DonDonateurVille:      donateurCoord.Ville,
		DonDonateurPays:       donateurCoord.Pays,
	}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesDocumentPersonne) AsItem() rd.Item {
	base := ac.AccesDocument.baseItem()
	base.Fields[DocumentCategorie] = ac.GetContrainte().Nom
	base.Fields[DocumentNomPrenom] = ac.GetProprietaire().RawData().NomPrenom()
	return base
}

func (ac AccesDocumentAide) AsItem() rd.Item {
	base := ac.AccesDocument.baseItem()
	base.Fields[DocumentCategorie] = nil
	base.Fields[DocumentNomPrenom] = ac.GetAide().GetParticipant().GetPersonne().RawData().NomPrenom()
	return base
}

func (ac AccesDocument) baseItem() rd.Item {
	raw := ac.RawData()
	fields := rd.F{
		DocumentTaille:         raw.Taille,
		DocumentNomClient:      raw.NomClient,
		DocumentDescription:    raw.Description,
		DocumentDateHeureModif: raw.DateHeureModif,
	}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesPaiement) AsItem() rd.Item {
	raw := ac.RawData()
	fields := rd.F{
		PaiementIsAcompte:       raw.IsAcompte.String(),
		PaiementIsRemboursement: raw.IsRemboursement.String(),
		PaiementLabelPayeur:     raw.LabelPayeur,
		PaiementNomBanque:       raw.NomBanque,
		PaiementModePaiement:    raw.ModePaiement.String(),
		PaiementNumero:          raw.Numero,
		PaiementValeur:          raw.Valeur,
		PaiementDateReglement:   raw.DateReglement,
		PaiementDetails:         raw.Details,
		PaiementInBordereau:     raw.InBordereau,
	}
	var color rd.Color
	if raw.IsInvalide {
		color = CouleurPaiementInvalide
	} else if !raw.InBordereau.Time().IsZero() {
		color = CouleurPaiementBordereau
	}
	colors := rd.ConstantColor{Color: color}
	return rd.Item{Id: rd.Id(ac.Id), Fields: fields, BackgroundColors: colors}
}

func (ac AccesFacture) AsItem(cache1 LiensFactureParticipants, cache2 LiensFactureMessages, cache3 LiensFacturePaiements) rd.Item {
	_, camps := ac.Camps(cache1)

	fields := rd.F{
		PersonneIdentifie:    (!ac.GetPersonne().RawData().IsTemporaire).String(),
		PersonneNomPrenom:    ac.GetPersonne().RawData().NomPrenom(),
		PersonneMail:         ac.GetPersonne().RawData().Mail,
		FactureCamps:         rd.String(camps),
		FactureParticipants:  rd.String(ac.participants(cache1)),
		ParticipantCamp:      nil,
		InscriptionDateHeure: ac.GetEtat(cache2, cache3).InscriptionDateHeure(),
	}

	bgColor := rd.ConstantColor{Color: CouleurResponsable}
	return rd.Item{Id: rd.IdFacture(ac.Id), Fields: fields, BackgroundColors: bgColor}
}

func (ac AccesParticipant) bgColor() rd.Color {
	pers := ac.GetPersonne().RawData()
	if pers.IsTemporaire {
		return CouleurParticipantTmp
	}

	// on affiche l'âge invalide uniquement sur la liste d'attente
	if !ac.RawData().ListeAttente.IsInscrit() && !ac.IsAgeValide() {
		return CouleurAgeInvalide
	}
	switch ac.RawData().ListeAttente.Statut {
	case rd.AttenteReponse:
		return CouleurAttenteReponse
	case rd.Attente:
		return CouleurListeAttente
	}

	return nil
}

// AsItem accède aussi aux champx d'un éventuel responsable
func (ac AccesParticipant) AsItem(cache rd.LiensCampParticipants) rd.Item {
	personne := ac.GetPersonne()
	// on commence par les champs de la personne associée
	fields := personne.AsItem(0).Fields

	raw := ac.RawData()

	// on ajoute ceux du participant ...
	fields[ParticipantCamp] = ac.GetCamp().RawData().Label()
	groupe, _ := ac.GetGroupe()
	fields[ParticipantGroupe] = groupe.Nom // vide si aucun groupe
	animateur, _ := ac.GetAnimateur()
	fields[ParticipantAnimateur] = rd.String(animateur.Personne.FPrenom()) // vide si aucun groupe
	fields[ParticipantBus] = raw.Options.Bus.String()
	fields[ParticipantMaterielSki] = raw.Options.MaterielSki.String()
	fields[ParticipantMaterielSkiType] = rd.String(raw.Options.MaterielSki.Need)
	fields[ParticipantAgeDebutCamp] = ac.AgeDebutCamp()
	fields[ParticipantRaisonAttente] = ac.HintsAttente(cache)
	fields[ParticipantEtat] = nil
	fields[ParticipantOptionPrix] = ac.AsParticipantCamp().AsOptionParticipantCamp().Description()

	// ... puis ceux du responsable
	var respoFields rd.F
	if fac, hasFacture := ac.GetFacture(); hasFacture {
		respoFields = fac.GetPersonne().AsItem(0).Fields
	}
	fields[ParticipantRespoNom] = respoFields[PersonneNom]
	fields[ParticipantRespoPrenom] = respoFields[PersonnePrenom]
	fields[ParticipantRespoNomPrenom] = respoFields[PersonneNomPrenom]
	fields[ParticipantRespoMail] = respoFields[PersonneMail]
	fields[ParticipantRespoTels] = respoFields[PersonneTels]
	fields[ParticipantRespoTelsLines] = respoFields[PersonneTelsLines]
	fields[ParticipantRespoAdresse] = respoFields[PersonneAdresse]
	fields[ParticipantRespoCodePostal] = respoFields[PersonneCodePostal]
	fields[ParticipantRespoVille] = respoFields[PersonneVille]
	fields[ParticipantRespoCommune] = respoFields[PersonneCommune]
	fields[ParticipantRespoPays] = respoFields[PersonnePays]

	var fgColor rd.Colors
	if ac.HasAnniversaire() {
		fgColor = rd.ConstantColor{Color: CouleurAnniversaire}
	}

	var bgColor rd.Colors
	if colorbg := ac.bgColor(); colorbg != nil {
		bgColor = rd.ConstantColor{Color: colorbg}
	} else {
		bgColorM := rd.MapColors{}
		switch personne.RawData().Sexe {
		case "M":
			bgColorM[PersonneSexe] = CouleurGarcon
		case "F":
			bgColorM[PersonneSexe] = CouleurFille
		}
		bgColorM[ParticipantGroupe] = rd.HexColor(groupe.Couleur)
		bgColor = bgColorM
	}
	return rd.Item{Id: rd.IdParticipant(ac.Id), Fields: fields, BackgroundColors: bgColor, TextColors: fgColor}
}

func (ac AccesParticipantsimple) AsItem() rd.Item {
	// on commence par les champs de la personne associée
	fields := ac.GetPersonne().AsItem(0).Fields

	raw := ac.RawData()

	// on ajoute ceux du participant ...
	fields[ParticipantCamp] = ac.GetCamp().RawData().Label()
	fields[ParticipantAgeDebutCamp] = ac.AgeDebutCamp()
	fields[InscriptionDateHeure] = raw.DateHeure
	return rd.Item{Id: rd.IdParticipantsimple(ac.Id), Fields: fields}
}

func (ac AccesEquipier) AsItem() rd.Item {
	// on commence par les champs de la personne associée
	fields := ac.GetPersonne().AsItem(0).Fields

	raw := ac.RawData()
	fields[EquipierCamp] = ac.GetCamp().RawData().Label()
	fields[EquipierRoles] = raw.Roles
	fields[EquipierDiplome] = raw.Diplome.String()
	fields[EquipierAppro] = raw.Appro.String()
	fields[EquipierPresence] = ac.GetPresence()

	return rd.Item{Id: rd.Id(ac.Id), Fields: fields}
}

func (ac AccesOrganisme) AsItem() rd.Item {
	raw := ac.RawData()
	fields := rd.F{
		PersonneNom:        raw.Nom,
		PersonneNomPrenom:  raw.Nom,
		PersonneTels:       raw.Contact.Tels,
		PersonneMail:       raw.Contact.Mail,
		PersonneAdresse:    raw.Contact.Adresse,
		PersonneCodePostal: raw.Contact.CodePostal,
		PersonneVille:      raw.Contact.Ville,
		PersonnePays:       raw.Contact.Pays,
	}
	return rd.Item{Id: rd.IdOrganisme(ac.Id), Fields: fields}
}