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

package datamodel

import (
	"sort"
	"strings"
	"time"

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

// enregistre les liens indirectes de la base de données
type liens = map[int64][]int64

type LiensPersonneDocuments liens
type LiensAideDocuments liens
type LiensCampParticipants = rd.LiensCampParticipants
type LiensFactureParticipants = rd.LiensFactureParticipants
type LiensCampParticipantsimples liens
type LiensCampEquipiers liens
type LiensParticipantAides liens
type LiensFacturePaiements liens
type LiensFactureMessages liens

// NewBaseLocale initialise les maps.
func NewBaseLocale() BaseLocale {
	// à garder synchronisé
	return BaseLocale{
		Personnes:          make(rd.Personnes),
		Camps:              make(rd.Camps),
		Groupes:            make(rd.Groupes),
		Sondages:           make(rd.Sondages),
		Participants:       make(rd.Participants),
		Equipiers:          make(rd.Equipiers),
		Participantsimples: make(rd.Participantsimples),
		Structureaides:     make(rd.Structureaides),
		Aides:              make(rd.Aides),
		Organismes:         make(rd.Organismes),
		Dons:               make(rd.Dons),
		Contraintes:        make(rd.Contraintes),
		Documents:          make(rd.Documents),
		Paiements:          make(rd.Paiements),
		Factures:           make(rd.Factures),
		Messages:           make(rd.Messages),
		Links: rd.Links{
			EquipierContraintes: make(map[int64]rd.EquipierContraintes),
			ParticipantGroupe:   make(map[int64]rd.GroupeParticipant),
			ParticipantEquipier: make(map[int64]rd.ParticipantEquipier),
			GroupeContraintes:   make(map[int64]rd.GroupeContraintes),
			CampContraintes:     make(map[int64]rd.CampContraintes),
			DocumentPersonnes:   make(map[int64]rd.DocumentPersonne),
			DocumentAides:       make(map[int64]rd.DocumentAide),
			DocumentCamps:       make(map[int64]rd.DocumentCamp),
			MessageDocuments:    make(map[int64]rd.MessageDocument),
			MessageSondages:     make(map[int64]rd.MessageSondage),
			MessagePlaceliberes: make(map[int64]rd.MessagePlacelibere),
			MessageAttestations: make(map[int64]rd.MessageAttestation),
			MessageMessages:     make(map[int64]rd.MessageMessage),
			DonDonateurs:        make(map[int64]rd.DonDonateur),
		},
	}
}

// GetFacture renvoie la facture associé au participant ou au dossier
// Renvoie `false` sinon
func (b *BaseLocale) IdAsFacture(id rd.IId) (AccesFacture, bool) {
	switch id := id.(type) {
	case rd.IdFacture:
		return b.NewFacture(id.Int64()), true
	case rd.IdParticipant:
		return b.NewParticipant(id.Int64()).GetFacture()
	default:
		return AccesFacture{}, false
	}
}

func (b *BaseLocale) GetRawPersonnes() []rd.Personne {
	out := make([]rd.Personne, 0, len(b.Personnes))
	for _, p := range b.Personnes {
		out = append(out, p)
	}
	return out
}

// getDocuments renvoie tous les documents.
func (b *BaseLocale) getDocumentPersonnes() []AccesDocumentPersonne {
	out := make([]AccesDocumentPersonne, 0, len(b.DocumentPersonnes))
	for idDocument := range b.DocumentPersonnes {
		out = append(out, AccesDocumentPersonne{b.NewDocument(idDocument)})
	}
	return out
}

// getDocuments renvoie tous les documents.
func (b *BaseLocale) getDocumentAides() rd.Table {
	out := make(rd.Table, 0, len(b.DocumentAides))
	for idDocument := range b.DocumentAides {
		out = append(out, AccesDocumentAide{b.NewDocument(idDocument)}.AsItem())
	}
	return out
}

func (b *BaseLocale) GetAllDocuments(forAide bool) rd.Table {
	if forAide {
		return b.getDocumentAides()
	}
	return DocumentsPersonnesToAcces(b.getDocumentPersonnes())
}

func DocumentsPersonnesToAcces(in []AccesDocumentPersonne) rd.Table {
	out := make(rd.Table, len(in))
	for index, doc := range in {
		out[index] = doc.AsItem()
	}
	return out
}

// ResoudDocuments renvois les documents pour les personnes
func (b *BaseLocale) ResoudDocumentsPersonnes() LiensPersonneDocuments {
	forPersonnes := LiensPersonneDocuments{}
	for _, lien := range b.DocumentPersonnes {
		forPersonnes[lien.IdPersonne] = append(forPersonnes[lien.IdPersonne], lien.IdDocument)
	}
	return forPersonnes
}

// ResoudDocuments renvois les documents pour les personnes
func (b *BaseLocale) ResoudDocumentsAides() LiensAideDocuments {
	forAides := LiensAideDocuments{}
	for _, lien := range b.DocumentAides {
		forAides[lien.IdAide] = append(forAides[lien.IdAide], lien.IdDocument)
	}
	return forAides
}

// -------------------------------------- Camps --------------------------------------

// GetCamps renvoie une liste des camps. `is_terminated` vaut -1,0 ou 1
// pour Non, Ignoré, Oui respectivement.
// Si `only_open` est true, les camps non ouverts aux inscriptions
// ne sont pas sélectionnés.
// Les camps sont triés par date de début.
func (b *BaseLocale) GetCamps(onlyOpen bool, isTerminated rd.OptionnalBool) (out []AccesCamp) {
	for id, camp := range b.Camps {
		keep := true
		if onlyOpen {
			keep = keep && bool(camp.Ouvert)
		}
		switch isTerminated {
		case rd.OBNon:
			keep = keep && !camp.IsTerminated()
		case rd.OBOui:
			keep = keep && camp.IsTerminated()
		}
		if keep {
			out = append(out, b.NewCamp(id))
		}
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].RawData().DateDebut.Time().After(out[j].RawData().DateDebut.Time())
	})
	return
}

// IsParticipantAlreadyHere vérifie si le potentiel participant n'est pas déjà présent
// dans le camp.
func (b *BaseLocale) IsParticipantAlreadyHere(idPersonne, idCamp int64) bool {
	for _, part := range b.Participants {
		if part.IdPersonne == idPersonne && part.IdCamp == idCamp {
			return true
		}
	}
	return false
}

// IsParticipantsimpleAlreadyHere vérifie si le potentiel participant n'est pas déjà présent
// dans le camp.
func (b *BaseLocale) IsParticipantsimpleAlreadyHere(idPersonne, idCamp int64) bool {
	for _, part := range b.Participantsimples {
		if part.IdPersonne == idPersonne && part.IdCamp == idCamp {
			return true
		}
	}
	return false
}

// IsEquipierAlreadyHere vérifie si le potentiel équipier n'est pas déjà présent
// dans le camp.
func (b *BaseLocale) IsEquipierAlreadyHere(equipier rd.Equipier) bool {
	for _, part := range b.Equipiers {
		if part.IdPersonne == equipier.IdPersonne && part.IdCamp == equipier.IdCamp {
			return true
		}
	}
	return false
}

// ---------------------- Paiements et factures ----------------------

func (b BaseLocale) GetPayeursBanques() (payeurs []string, banques []string) {
	mapPayeurs, mapBanques := rd.StringSet{}, rd.StringSet{}
	for _, paiement := range b.Paiements {
		mapPayeurs[strings.TrimSpace(string(paiement.LabelPayeur))] = true
		mapBanques[strings.TrimSpace(string(paiement.NomBanque))] = true
	}
	for _, pers := range b.Personnes {
		if pers.Age() >= 18 && !pers.IsTemporaire {
			mapPayeurs[strings.TrimSpace(string(pers.Nom+" "+pers.Prenom))] = true
		}
	}
	delete(mapPayeurs, "")
	delete(mapBanques, "")
	return mapPayeurs.ToList(), mapBanques.ToList()
}

// ResoudInscritsPaiementsAides parcourt une fois les tables
// et renvoie les associations (comme ids):
// 	- facture -> paiements
//	- facture -> participants
//	- camp -> participants
// 	- participant -> aides

// ResoudParticipants parcourt la table des participants et renvois
// les associations facture -> participants, camp -> inscrits
func (b *BaseLocale) ResoudParticipants() (LiensFactureParticipants, LiensCampParticipants) {
	return b.Participants.Resoud()
}

// ResoudParticipantsimples parcourt la table des participants simples et renvois
// les associations camp -> inscrits
func (b *BaseLocale) ResoudParticipantsimples() LiensCampParticipantsimples {
	out := make(LiensCampParticipantsimples, len(b.Camps))
	for id, equipier := range b.Participantsimples {
		out[equipier.IdCamp] = append(out[equipier.IdCamp], id)
	}
	return out
}

// ResoudEquipiers parcourt la table des equipiers et renvois
// les associations camp -> inscrits
func (b *BaseLocale) ResoudEquipiers() LiensCampEquipiers {
	out := make(LiensCampEquipiers, len(b.Camps))
	for id, equipier := range b.Equipiers {
		out[equipier.IdCamp] = append(out[equipier.IdCamp], id)
	}
	return out
}

// ResoudAides parcourt la table des aides et renvois
// les associations participant -> aides
func (b *BaseLocale) ResoudAides() LiensParticipantAides {
	participantsToA := make(LiensParticipantAides, len(b.Participants))
	for id, aides := range b.Aides {
		participantsToA[aides.IdParticipant] = append(participantsToA[aides.IdParticipant], id)
	}
	return participantsToA
}

// ResoudAides parcourt la table des paiements et renvois
// les associations facture -> paiements
func (b *BaseLocale) ResoudPaiements() LiensFacturePaiements {
	facturesToPaie := make(LiensFacturePaiements, len(b.Factures))
	for id, paiement := range b.Paiements {
		facturesToPaie[paiement.IdFacture] = append(facturesToPaie[paiement.IdFacture], id)
	}
	return facturesToPaie
}

func (b *BaseLocale) ResoudMessages() LiensFactureMessages {
	out := make(LiensFactureMessages)
	for _, message := range b.Messages {
		out[message.IdFacture] = append(out[message.IdFacture], message.Id)
	}
	return out
}

type financesParticipant struct {
	participant   rd.Data
	bilanPrixCamp BilanPrixCamp
	bilanFacture  BilanFacture
}

const (
	FinancesPNomPrenom rd.Field = iota
	FinancesPPrixBase
	FinancesPPrixNet
	FinancesPTotalAides
	FinancesPEtatPaiement
)

func (p financesParticipant) AsItem() rd.Item {
	fields := rd.F{
		FinancesPNomPrenom:    p.participant,
		FinancesPPrixBase:     p.bilanPrixCamp.PrixBase,
		FinancesPPrixNet:      p.bilanPrixCamp.PrixNet(),
		FinancesPTotalAides:   p.bilanPrixCamp.TotalAides(),
		FinancesPEtatPaiement: p.bilanFacture.StatutPaiement(),
	}
	bgColors := rd.MapColors{FinancesPEtatPaiement: p.bilanFacture.StatutPaiement().Color()}
	return rd.Item{Fields: fields, BackgroundColors: bgColors}
}

// SuiviFinancier renvoie une liste de participants avec les infos financières.
// Renvoie aussi le total demandé et le total des aides extérieures
// Les aides et paiements invalides sont ignorés.
func (b *BaseLocale) SuiviFinancier(camp AccesCamp) (rd.Table, rd.Euros, rd.Euros) {
	var (
		out                      rd.Table
		totalAides, totalDemande rd.Euros
	)
	// Mise en cache pour éviter un cout quadratique
	cache := b.NewCacheEtatFinancier()
	_, cToParticipants := b.ResoudParticipants()
	for _, acPart := range camp.GetInscrits(cToParticipants) {
		bilanPrixCamp := acPart.EtatFinancier(cache.PAides, false)
		totalDemande += bilanPrixCamp.PrixNet()
		totalAides += bilanPrixCamp.TotalAides()

		fac, hasFacture := acPart.GetFacture()
		var bilanFacture BilanFacture
		if hasFacture {
			bilanFacture = fac.EtatFinancier(cache, false)
		}

		out = append(out, financesParticipant{
			participant:   acPart.GetPersonne().RawData().NomPrenom(),
			bilanPrixCamp: bilanPrixCamp,
			bilanFacture:  bilanFacture,
		}.AsItem())
	}
	return out, totalDemande, totalAides
}

// ------------------------------- Dons -------------------------------

// OptionsRecuFiscal implémente l'émission de reçus fiscaux,
// partagée entre le client et le serveur.
type OptionsRecuFiscal struct {
	Annee  int
	ReEmet bool // accepte les dons déjà émis en reçu fiscaux
}

type RecuFiscal struct {
	// Montant total
	Montant rd.Euros
	// Dans le cas de plusieurs dons, le mode est un des modes utilisés
	Mode rd.ModePaiment
	// Dans le cas de plusieurs dons, la date la plus récente est utilisée
	Date time.Time
}

type RecusFiscaux struct {
	Recus      map[int64]RecuFiscal
	IdsDons    rd.Ids
	NbAnnonyme int
}

// Select aggrège les dons et renvoie aussi le nombre de dons annonymes,
// et de dons annonymes de type HelloAsso
// Les dons collectifs sont ignorés.
func (o OptionsRecuFiscal) Select(dons rd.Dons, liens map[int64]rd.DonDonateur) (r RecusFiscaux) {
	r.Recus = map[int64]RecuFiscal{} // idDonateur -> recu
	for _, don := range dons {
		switch donateur := liens[don.Id].IId().(type) {
		case rd.IdOrganisme:
			// les dons collectifs ne sont pas concernés par les reçus fiscaux
		case nil:
			// don anonyme
			r.NbAnnonyme++
		case rd.IdPersonne:
			annneOk := don.DateReception.Time().Year() == o.Annee
			reEmetOk := o.ReEmet || don.RecuEmis.Time().IsZero()
			if !annneOk || !reEmetOk {
				continue
			}
			r.IdsDons = append(r.IdsDons, don.Id)
			rf := r.Recus[donateur.Int64()]
			rf.Montant += don.Valeur
			rf.Mode = don.ModePaiement
			if rf.Date.Before(don.DateReception.Time()) {
				rf.Date = don.DateReception.Time()
			}
			r.Recus[donateur.Int64()] = rf
		}
	}
	return r
}

// GetFacturesSendDocuments renvoie les dossiers ayant déjà reçu un message 'Document'
// pour le séjour donné.
func (b *BaseLocale) GetFacturesSendDocuments(idCamp int64) rd.Set {
	var ids rd.Ids
	for idMessage, complement := range b.MessageDocuments {
		if complement.IdCamp == idCamp {
			message := b.Messages[idMessage]
			ids = append(ids, message.IdFacture)
		}
	}
	// unicité :
	return ids.AsSet()
}

// ------------------------------- Cleanup -------------------------------

func (b *BaseLocale) ApplyIdentifie(out apiserver.IdentifiePersonneOut) {
	b.Personnes[out.Personne.Id] = out.Personne
	for _, doc := range out.Documents {
		b.DocumentPersonnes[doc.IdDocument] = doc
	}
	b.CleanupDocuments(out.DeletedDocs)
	delete(b.Personnes, out.DeletedPersonne)
}

func (b *BaseLocale) ApplyIdentifieDon(out apiserver.IdentifieDonOut) {
	b.Personnes[out.Personne.Id] = out.Personne
	b.Dons[out.Don.Id] = out.Don
	b.DonDonateurs[out.Donateur.IdDon] = out.Donateur
}

func (b *BaseLocale) ApplyEditMessage(out apiserver.EditMessageOut) {
	for _, m := range out.Messages {
		b.Messages[m.Id] = m
	}
	for _, m := range out.MessageMessages {
		b.MessageMessages[m.IdMessage] = m
	}
}

func (b *BaseLocale) ApplyCreateParticipant(out apiserver.CreateParticipantOut) {
	b.Participants[out.Participant.Id] = out.Participant
	if out.FoundGroupe {
		b.ParticipantGroupe[out.Participant.Id] = out.GroupeParticipant
	}
}

func (b *BaseLocale) ApplyFusionneFactures(out apiserver.FusionneFacturesOut) {
	for id, v := range out.Paiements {
		b.Paiements[id] = v
	}
	for id, v := range out.Participants {
		b.Participants[id] = v
	}
	for id, v := range out.Messages {
		b.Messages[id] = v
	}
	for id, v := range out.Sondages {
		b.Sondages[id] = v
	}
	delete(b.Factures, out.OldId)
}

func (b *BaseLocale) ApplyCreateDon(out apiserver.CreateDonIn) {
	b.Dons[out.Don.Id] = out.Don
	b.DonDonateurs[out.Don.Id] = out.Donateur
}

func (b *BaseLocale) CleanupParticipant(out apiserver.DeleteParticipantOut) {
	delete(b.Participants, out.IdParticipant)
	for _, aide := range out.IdsAides {
		delete(b.Aides, aide)
	}
	for _, doc := range out.IdsDocuments {
		delete(b.Documents, doc)
	}
	delete(b.Personnes, out.IdPersonne)
	delete(b.ParticipantGroupe, out.IdParticipant)
	for _, message := range out.IdsMessages {
		delete(b.MessagePlaceliberes, message)
		delete(b.Messages, message)
	}
}

// CleanupDocuments enlève les documents et leurs liens
func (b *BaseLocale) CleanupDocuments(ids rd.Ids) {
	for _, idDocument := range ids {
		delete(b.Documents, idDocument)
		delete(b.DocumentPersonnes, idDocument)
		delete(b.DocumentCamps, idDocument)
		delete(b.DocumentAides, idDocument)
	}
}

// DeleteFacture supprime aussi les messages associés
func (b *BaseLocale) DeleteFacture(id int64) {
	delete(b.Factures, id)
	for _, message := range b.Messages {
		if message.IdFacture == id {
			delete(b.Messages, message.Id)
			delete(b.MessageAttestations, message.Id)
			delete(b.MessageDocuments, message.Id)
			delete(b.MessageMessages, message.Id)
			delete(b.MessagePlaceliberes, message.Id)
			delete(b.MessageSondages, message.Id)
		}
	}
}