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

package composites

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

// CampParticipants ajoute les participants (inscrits et liste d'attente)
// à un séjour (complet)
type CampParticipants struct {
	rd.Camp
	Participants []rd.Participant
}

// NewCampParticipants sélectionne les participant dans un dictionnaire possiblement
// plus vaste
func NewCampParticipants(camp rd.Camp, participants rd.Participants) CampParticipants {
	var out []rd.Participant
	for _, participant := range participants {
		if participant.IdCamp == camp.Id {
			out = append(out, participant)
		}
	}
	return CampParticipants{Camp: camp, Participants: out}
}

// RestePlace renvoie `true` si l'ajout de zéro ou un inscrit
// ne dépasse pas le nombre de places autorisées (nombre de places - places réservées)
func (c CampParticipants) RestePlace(isCurrentInscrit bool) rd.StatutAttente {
	places := c.Camp.NbPlaces - c.Camp.NbPlacesReservees
	var actuelles rd.Int
	for _, part := range c.Participants {
		if part.ListeAttente.IsInscrit() {
			actuelles += 1
		}
	}
	if isCurrentInscrit { // on décompte le participant actuel
		actuelles--
	}
	if places > actuelles {
		return rd.Inscrit
	}
	return rd.Attente
}

// sexeInscrits renvoie le nombre de garçons/filles inscrits
// `personnes` doit contenir les personnes liées aux participants
func (c CampParticipants) sexeInscrits(personnes rd.Personnes) (nbGarcons, nbFilles int) {
	for _, part := range c.Participants {
		if part.ListeAttente.Statut != rd.Inscrit {
			continue
		}
		switch personnes[part.IdPersonne].Sexe {
		case rd.SHomme:
			nbGarcons += 1
		case rd.SFemme:
			nbFilles += 1
		}
	}
	return nbGarcons, nbFilles
}

// KeepEquilibreGF renvoie `true` si l'ajout de zéro ou un participant du sexe donné
// ne dépasse pas le quota G/F ou si le camp ne demande pas d'équilibre.
func (c CampParticipants) KeepEquilibreGF(s rd.Sexe, isCurrentInscrit bool, personnes rd.Personnes) rd.StatutAttente {
	if !c.Camp.NeedEquilibreGf {
		return rd.Inscrit
	}
	nbGarcons, nbFilles := c.sexeInscrits(personnes)
	var ok bool
	switch s {
	case rd.SHomme:
		if isCurrentInscrit { // on décompte le participant déjà inscrit
			nbGarcons--
		}
		nbGarcons++
		ok = nbGarcons <= int(c.Camp.NbPlaces*2/3)
	case rd.SFemme:
		if isCurrentInscrit { // on décompte le participant déjà inscrit
			nbFilles--
		}
		nbFilles++
		ok = nbFilles <= int(c.Camp.NbPlaces*2/3)
	default: // en l'absence d'info, on considère que l'équilibre n'est pas dérangé
		ok = true
	}
	if ok {
		return rd.Inscrit
	}
	return rd.Attente
}

// HintsAttente vérifie les conditions de liste d'attente
// `personnes` doit contenir les personnes déjà inscrites
func (c CampParticipants) HintsAttente(pers rd.BasePersonne, isCurrentInscrit bool, personnes rd.Personnes) rd.HintsAttente {
	statusMin, statusMax := c.Camp.HasAgeValide(pers)
	return rd.HintsAttente{
		AgeMin:      statusMin,
		AgeMax:      statusMax,
		Place:       c.RestePlace(isCurrentInscrit),
		EquilibreGF: c.KeepEquilibreGF(pers.Sexe, isCurrentInscrit, personnes),
	}
}

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

// CampParticipants ajoute les groupes à un séjour (complet)
type CampGroupes struct {
	rd.Camp
	Groupes []rd.Groupe
}

// NewCampGroupes sélectionne les groupes du camp, parmi un dictionnaire
// possiblement plus important
func NewCampGroupes(camp rd.Camp, groupes rd.Groupes) CampGroupes {
	var out []rd.Groupe
	for _, g := range groupes {
		if g.IdCamp == camp.Id {
			out = append(out, g)
		}
	}
	return CampGroupes{Camp: camp, Groupes: out}
}

// TrouveGroupe cherche parmis les groupes possibles celui qui pourrait convenir.
// Normalement, les groupes respectent un invariant de continuité sur les plages,
// imposé par le frontend.
// Si plusieurs pouvait convenir, un seul est renvoyé, de façon arbitraire.
func (c CampGroupes) TrouveGroupe(dateNaissance rd.Date) (rd.Groupe, bool) {
	for _, g := range c.Groupes {
		if g.Plage.Contains(dateNaissance.Time()) {
			return g, true
		}
	}
	// on a trouvé aucun groupe
	return rd.Groupe{}, false
}