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

package composites

import (
	"fmt"

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

// ValeurEffective renvoie :
// 	- le montant dans le cas d'une aide absolue
// 	- le montant fois le nombre de jours (en prenant en compte une éventuelle limite) sinon
// Si `withRemise` vaut true les remises (%) sont appliquées.
func (a AideParticipantCamp) ValeurEffective(withRemise bool) rd.Euros {
	val := a.Aide.Valeur
	nbJours := a.ParticipantCamp.AsOptionParticipantCamp().NbJours()
	if a.Aide.ParJour {
		limite := a.Aide.NbJoursMax
		if limite > 0 && limite < nbJours {
			nbJours = limite
		}
		val = val * rd.Euros(nbJours)
	}
	if withRemise {
		val = val.Remise(a.Participant.Remises.Pourcent())
	}
	return val
}

type AideComplet struct {
	AideStructureaide
	ParticipantCamp
}

func (a AideComplet) Description() string {
	aide := a.ParticipantCamp.WithAide(a.Aide)
	return fmt.Sprintf("%s : %s", a.Structureaide.Nom, aide.ValeurEffective(false))
}

// c'est celui du participant, ou sinon celui du responsable
func (p ParticipantFacturePersonne) getQuotientFamilial() rd.Int {
	qfPart := p.Participant.OptionPrix.QuotientFamilial
	if qfPart != 0 {
		return qfPart
	}
	if p.Participant.IdFacture.IsNil() {
		return 0
	}
	return p.FacturePersonne.Personne.QuotientFamilial
}

// StatutPrix renvoi la catégorie de prix du participant
// Une catégorie avec un Id vide équivaut à l'absence de catégorie
func (p OptionParticipantCamp) StatutPrix() rd.PrixParStatut {
	s := p.OptionPrix.Statut
	if s == 0 {
		return rd.PrixParStatut{}
	}
	campOption := p.Camp.OptionPrix
	if campOption.Active != rd.OptionsPrix.STATUT {
		return rd.PrixParStatut{}
	}
	for _, info := range campOption.Statut {
		if info.Id == s {
			return info
		}
	}
	return rd.PrixParStatut{}
}

type ParticipantComplet struct {
	ParticipantCamp
	FacturePersonne
}

func (p ParticipantComplet) AsFacture() ParticipantFacturePersonne {
	return ParticipantFacturePersonne{Participant: p.Participant, FacturePersonne: p.FacturePersonne}
}

func (p ParticipantCamp) WithAide(aide rd.Aide) AideParticipantCamp {
	return AideParticipantCamp{Aide: aide, ParticipantCamp: p}
}

func getIndexQF(qf rd.Int) int {
	n := len(rd.QuotientFamilial)
	for i := 0; i < n-1; i++ {
		q1, q2 := rd.QuotientFamilial[i], rd.QuotientFamilial[i+1]
		if q1 < qf && qf <= q2 {
			return i
		}
	}
	return n - 1
}

// Renvoie le prix du camp, en prenant en compte une éventuelle option.
// Renvoi aussi une description de l'éventuelle option.
func (p ParticipantComplet) prixCampBase() (rd.Euros, string) {
	desc := p.AsOptionParticipantCamp().Description().String()

	quotientFamilial := p.AsFacture().getQuotientFamilial()
	optionPrixParticipant := p.Participant.OptionPrix
	optionPrixCamp := p.Camp.OptionPrix
	optionActive := optionPrixCamp.Active
	var prix rd.Euros = -1
	switch optionActive {
	case rd.OptionsPrix.SEMAINE:
		semaine := optionPrixParticipant.Semaine
		prixSem := optionPrixCamp.Semaine
		if semaine == rd.SSe1 {
			prix = prixSem.Prix1
		} else if semaine == rd.SSe2 {
			prix = prixSem.Prix2
		}
	case rd.OptionsPrix.STATUT:
		statutInfo := p.AsOptionParticipantCamp().StatutPrix()
		if statutInfo.Id != 0 {
			prix = statutInfo.Prix
		}
	case rd.OptionsPrix.QUOTIENT_FAMILIAL:
		qf := optionPrixParticipant.QuotientFamilial
		if qf == 0 {
			qf = quotientFamilial
		}
		if qf > 0 {
			qfCamp := optionPrixCamp.QuotientFamilial
			prix = qfCamp[getIndexQF(qf)]
		}
	case rd.OptionsPrix.JOUR:
		nbJours := p.ParticipantCamp.AsOptionParticipantCamp().NbJours()
		prixJours := optionPrixCamp.Jour
		if nbJours == 0 { // invalide -> camp entier
			break
		}
		if int(nbJours) <= len(prixJours) {
			prix = prixJours[nbJours-1]
		}
	}
	if prix == -1 {
		prix = p.Camp.Prix
	}
	return prix, desc
}

type resolvedAide struct {
	Description string
	Montant     rd.Euros
	Valide      bool
}

// BilanPrixCamp regroupe les infos relative
// au coût d'un séjour pour un participant.
type BilanPrixCamp struct {
	Aides   []resolvedAide
	Remises rd.Remises

	// prix du camp (option comprise)
	PrixBase        rd.Euros
	DescriptionPrix string
}

// PrixSansRemises renvoie le prix du séjour si on applique les aides (extérieures)
// mais pas les remises.
func (b BilanPrixCamp) PrixSansRemises() rd.Euros {
	p := b.PrixBase - b.TotalAides()
	if p < 0 {
		p = 0
	}
	return p
}

// PrixSansAide renvoie le prix du séjour en appliquant les remises,
// mais pas les aides.
func (b BilanPrixCamp) PrixSansAide() rd.Euros {
	return b.PrixBase.Remise(b.Remises.ReducEquipiers+b.Remises.ReducEnfants) - b.Remises.ReducSpeciale
}

func (b BilanPrixCamp) TotalAides() rd.Euros {
	var out rd.Euros
	for _, aide := range b.Aides {
		if aide.Valide {
			out += aide.Montant
		}
	}
	return out
}

func (b BilanPrixCamp) PrixNet() rd.Euros {
	p := b.PrixSansRemises().Remise(b.Remises.Pourcent()) - b.Remises.ReducSpeciale
	if p < 0 {
		p = 0
	}
	return p
}

// EtatFinancier calcule le prix du sejour pour le participant,
// en prenant en compte les options, les remises et les aides.
// Si `withAidesInvalides` vaut `false`, les aides non validées ne sont pas renvoyées.
// `aides` n'est pas filtrée
func (p ParticipantComplet) EtatFinancier(aides []AideStructureaide, withAidesInvalides bool) BilanPrixCamp {
	var out BilanPrixCamp
	out.PrixBase, out.DescriptionPrix = p.prixCampBase()
	out.Remises = p.Participant.Remises
	for _, aide := range aides {
		va := p.WithAide(aide.Aide).ValeurEffective(false)
		dumped := resolvedAide{
			Description: AideComplet{AideStructureaide: aide, ParticipantCamp: p.ParticipantCamp}.Description(),
			Montant:     va,
			Valide:      bool(aide.Aide.Valide),
		}
		if withAidesInvalides || dumped.Valide {
			out.Aides = append(out.Aides, dumped)
		}
	}
	return out
}

// ByFacture associe à chaque facture ses paiements (cout linéaire)
func (ps PaiementFactures) ByFacture() map[int64]PaiementFactures {
	out := map[int64]PaiementFactures{}
	for _, pf := range ps {
		out[pf.IdFacture] = append(out[pf.IdFacture], pf)
	}
	return out
}