github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/directeurs/animateurs.go

package directeurs

import (
	"fmt"
	"sort"

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

// ------------------------------------ Animateurs de références ------------------------------------

func (rc DriverCampComplet) loadGroupeAnimateurs(idGroupe int64) (out LoadGroupeAnimateursOut, err error) {
	out.GroupeEquipiers, err = rd.SelectGroupeEquipiersByIdGroupes(rc.DB, idGroupe)
	if err != nil {
		return out, err
	}
	out.ParticipantEquipiers, err = rd.SelectParticipantEquipiersByIdGroupes(rc.DB, idGroupe)
	return out, err
}

func (rc DriverCampComplet) addGroupeAnimateurs(params AddGroupeAnimateursIn) error {
	if err := rc.checkGroupe(params.IdGroupe); err != nil {
		return err
	}
	ges := make(rd.GroupeEquipiers, len(params.IdEquipiers))
	for i, idEquipier := range params.IdEquipiers { // on complète les champs évidents
		ges[i] = rd.GroupeEquipier{
			IdCamp:     rc.camp.Id,
			IdGroupe:   params.IdGroupe,
			IdEquipier: idEquipier,
		}
	}
	tx, err := rc.DB.Begin()
	if err != nil {
		return err
	}
	err = rd.InsertManyGroupeEquipiers(tx, ges...)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}

func (rc DriverCampComplet) deleteGroupeAnimateur(params DeleteGroupeAnimateurIn) error {
	if err := rc.checkGroupe(params.IdGroupe); err != nil {
		return err
	}
	lien := rd.GroupeEquipier{
		IdCamp:     rc.camp.Id,
		IdEquipier: params.IdEquipier,
		IdGroupe:   params.IdGroupe,
	}
	err := lien.Delete(rc.DB)
	return err
}

func (rc DriverCampComplet) updateInscritsAnimateur(params UpdateInscritsAnimateurIn) (rd.ParticipantEquipiers, error) {
	if err := rc.checkGroupe(params.IdGroupe); err != nil {
		return nil, err
	}
	tx, err := rc.DB.Begin()
	if err != nil {
		return nil, err
	}
	// on supprime les animateurs éventuels
	_, err = rd.DeleteParticipantEquipiersByIdParticipants(tx, params.IdInscrits...)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	if params.IdAnimateur.IsNotNil() { // on attribue un nouveau
		liens := make(rd.ParticipantEquipiers, len(params.IdInscrits))
		for i, idInscrit := range params.IdInscrits {
			liens[i] = rd.ParticipantEquipier{
				IdEquipier:    params.IdAnimateur.Int64,
				IdParticipant: idInscrit,
				IdGroupe:      params.IdGroupe,
			}
		}
		err = rd.InsertManyParticipantEquipiers(tx, liens...)
		if err != nil {
			return nil, shared.Rollback(tx, err)
		}
	}
	out, err := rd.SelectParticipantEquipiersByIdGroupes(tx, params.IdGroupe)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}

// anims ne doit pas être vide
func computeAffectations(affectationCourantes rd.ParticipantEquipiers,
	inscrits composites.ParticipantPersonnes, anims composites.EquipierPersonnes, idGroupe int64) rd.ParticipantEquipiers {
	animToInsc := affectationCourantes.ByIdEquipier() // déjà affectés

	total := len(inscrits)       // inscrits à répartir
	for _, anim := range anims { // inscrits déjà existants
		total += len(animToInsc[anim.Equipier.Id])
	}
	// le nombre par groupe est d'environ (arrondi à l'inférieur)
	targetSize := total / len(anims)
	restant := total - targetSize*len(anims)

	// on répartit par anim
	var out rd.ParticipantEquipiers
	inscritsToAffect := inscrits
	for _, anim := range anims {
		if len(inscritsToAffect) == 0 {
			break // plus rien à faire
		}
		tailleCourante := len(animToInsc[anim.Equipier.Id])
		nbToAffect := targetSize - tailleCourante
		if restant > 0 {
			// on ajoute un inscrit en plus pour compenser l'erreur d'arrondi
			nbToAffect++
			restant--
		}
		if nbToAffect <= 0 {
			// on dépasse la taille recommandée -> pas d'affectation
			continue
		}
		if nbToAffect > len(inscritsToAffect) {
			nbToAffect = len(inscritsToAffect)
		}
		chunk := inscritsToAffect[0:nbToAffect] // extrait les inscrits
		inscritsToAffect = inscritsToAffect[nbToAffect:]
		for _, inscrit := range chunk {
			affectation := rd.ParticipantEquipier{IdEquipier: anim.Equipier.Id, IdParticipant: inscrit.Participant.Id, IdGroupe: idGroupe}
			out = append(out, affectation)
		}
	}

	return out
}

func (rc DriverCampComplet) autoRepartitionAnimateurs(idGroupe int64) (rd.ParticipantEquipiers, error) {
	data, err := rc.loadGroupeAnimateurs(idGroupe)
	if err != nil {
		return nil, err
	}
	// on récupère les participants du groupe
	rows, err := rc.DB.Query(`SELECT participants.*, personnes.* FROM participants
		JOIN personnes ON personnes.id = participants.id_personne
		JOIN groupe_participants ON groupe_participants.id_participant = participants.id
		WHERE groupe_participants.id_groupe = $1`, idGroupe)
	if err != nil {
		return nil, err
	}
	participants, err := composites.ScanParticipantPersonnes(rows)
	if err != nil {
		return nil, err
	}
	// on récupère les équipiers
	rows, err = rc.DB.Query(`SELECT equipiers.*, personnes.* FROM equipiers
		JOIN personnes ON personnes.id = equipiers.id_personne
		JOIN groupe_equipiers ON groupe_equipiers.id_equipier = equipiers.id
		WHERE groupe_equipiers.id_groupe = $1`, idGroupe)
	if err != nil {
		return nil, err
	}
	equipiers, err := composites.ScanEquipierPersonnes(rows)
	if err != nil {
		return nil, err
	}

	insctToAnim := data.ParticipantEquipiers.ByIdParticipant()

	// on commence par séparer F/G : participants ...
	var filles, gars composites.ParticipantPersonnes
	for _, part := range participants {
		if _, affected := insctToAnim[part.Participant.Id]; affected {
			continue
		}
		if !part.ListeAttente.IsInscrit() {
			continue // les participants en liste d'attente sont ignorés
		}
		if part.Sexe == rd.SFemme {
			filles = append(filles, part)
		} else {
			gars = append(gars, part)
		}

	}
	// ... et animateurs
	var fillesAnim, garsAnim composites.EquipierPersonnes
	for _, anim := range equipiers {
		if anim.Sexe == rd.SFemme {
			fillesAnim = append(fillesAnim, anim)
		} else {
			garsAnim = append(garsAnim, anim)
		}
	}
	// on gère les cas particuliers
	if len(equipiers) == 0 {
		return nil, fmt.Errorf("Aucun animateur n'est déclaré.")
	}
	if len(garsAnim) == 0 {
		if len(fillesAnim) >= 2 { // on peut partager
			cutoff := len(fillesAnim) / 2
			garsAnim = fillesAnim[0:cutoff]
			fillesAnim = fillesAnim[cutoff:]
		} else { // une seule animatrice, on regroupe tout les inscrits
			filles = append(filles, gars...)
		}
	} else if len(fillesAnim) == 0 { // pareil, inversé
		if len(garsAnim) >= 2 { // on peut partager
			cutoff := len(garsAnim) / 2
			fillesAnim = garsAnim[0:cutoff]
			garsAnim = garsAnim[cutoff:]
		} else { // un seul animateur, on regroupe tout les inscrits
			gars = append(gars, filles...)
		}
	}

	// on tri par age. Attention
	// dans le cas d'un groupe mixte (si manque d'anim), on veut regrouper les inscrits de même sexe
	sortInscrits := func(list composites.ParticipantPersonnes) {
		sort.Slice(list, func(i, j int) bool {
			return list[i].Personne.DateNaissance.Time().Before(list[j].Personne.DateNaissance.Time())
		})
		sort.SliceStable(list, func(i, j int) bool {
			return list[i].Sexe < list[j].Sexe
		})
	}
	sortInscrits(filles)
	sortInscrits(gars)

	// on trie aussi les anims par age pour affecter les inscrits les plus vieux aux anims les plus vieux
	sort.Slice(garsAnim, func(i, j int) bool {
		return garsAnim[i].Personne.DateNaissance.Time().Before(garsAnim[j].Personne.DateNaissance.Time())
	})
	sort.Slice(fillesAnim, func(i, j int) bool {
		return fillesAnim[i].Personne.DateNaissance.Time().Before(fillesAnim[j].Personne.DateNaissance.Time())
	})

	// on calcule les tailles de chaque petit groupe, en
	// prenant en compte les affectations existantes
	var allAffectations rd.ParticipantEquipiers
	if len(garsAnim) > 0 {
		allAffectations = append(allAffectations, computeAffectations(data.ParticipantEquipiers, gars, garsAnim, idGroupe)...)
	}
	if len(fillesAnim) > 0 {
		allAffectations = append(allAffectations, computeAffectations(data.ParticipantEquipiers, filles, fillesAnim, idGroupe)...)
	}

	tx, err := rc.DB.Begin()
	if err != nil {
		return nil, err
	}
	err = rd.InsertManyParticipantEquipiers(tx, allAffectations...)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	// on renvoie les affectations mises à jour
	out, err := rd.SelectParticipantEquipiersByIdGroupes(tx, idGroupe)
	if err != nil {
		return nil, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return out, err
}