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

package directeurs

import (
	"database/sql"
	"errors"
	"fmt"
	"time"

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

var defaultGroupeFrom = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)

const defaultPlageLength = 2 * 365 * 24 * time.Hour // 2ans

// charge et renvoie les groupes du séjour, ainsi que les assocation de contraintes
func loadGroupes(db rd.DB, idCamp int64) (rd.Groupes, rd.CampContraintes, rd.GroupeContraintes, error) {
	groupes, err := rd.SelectGroupesByIdCamps(db, idCamp)
	if err != nil {
		return nil, nil, nil, err
	}
	groupeContraintes, err := rd.SelectGroupeContraintesByIdGroupes(db, groupes.Ids()...)
	if err != nil {
		return nil, nil, nil, err
	}
	campContraintes, err := rd.SelectCampContraintesByIdCamps(db, idCamp)
	if err != nil {
		return nil, nil, nil, err
	}
	return groupes, campContraintes, groupeContraintes, nil
}

func (rc DriverCampComplet) createGroupe(newGroupe rd.Groupe) (rd.Groupe, error) {
	newGroupe.Nom = newGroupe.Nom.TrimSpace()
	if newGroupe.Nom == "" {
		return rd.Groupe{}, errors.New("Merci de nommer le groupe à créer.")
	}

	groupes, _, _, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return rd.Groupe{}, err
	}

	// on crée vraiment un nouveau groupe, en allongant la plage de date
	var lastDate time.Time
	for _, g := range groupes {
		if g.Plage.To.Time().After(lastDate) {
			lastDate = g.Plage.To.Time()
		}
	}
	if lastDate.IsZero() {
		lastDate = defaultGroupeFrom
	}
	lastDate = lastDate.Add(24 * time.Hour)
	newGroupe.IdCamp = rc.camp.Id
	newGroupe.Plage = rd.Plage{From: rd.Date(lastDate), To: rd.Date(lastDate.Add(defaultPlageLength))} // 2 ans

	return newGroupe.Insert(rc.DB)
}

func (rc DriverCampComplet) updateGroupe(groupe rd.Groupe) (rd.Groupe, error) {
	if groupe.IdCamp != rc.camp.Id {
		return rd.Groupe{}, fmt.Errorf("Le camp associé à ce groupe n'est pas valide (%d)", groupe.IdCamp)
	}

	// un groupe modifié par l'utilisateur a forcément un nom
	groupe.Nom = groupe.Nom.TrimSpace()
	if groupe.Nom == "" {
		return rd.Groupe{}, errors.New("Merci de nommer ce groupe.")
	}

	return groupe.Update(rc.DB)
}

func (rc DriverCampComplet) checkGroupe(idGroupe int64) error {
	groupes, _, _, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return shared.FormatErr("Impossible de vérifier l'origine du groupe.", err)
	}
	if _, inSejour := groupes[idGroupe]; !inSejour {
		return fmt.Errorf("Ce groupe (id %d) n'est pas lié au séjour !", idGroupe)
	}
	return nil
}

func (rc DriverCampComplet) deleteGroupe(idGroupe int64) error {
	if err := rc.checkGroupe(idGroupe); err != nil {
		return err
	}

	tx, err := rc.DB.Begin()
	if err != nil {
		return err
	}
	// on supprime les liens
	_, err = rd.DeleteGroupeContraintesByIdGroupes(tx, idGroupe)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = rd.DeleteGroupeParticipantsByIdGroupes(tx, idGroupe)
	if err != nil {
		return shared.Rollback(tx, err)
	}

	_, err = rd.DeleteGroupeById(tx, idGroupe)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}

// met à jour les appartenances de chaque groupe , en une seule requête
// ne commit pas , ne rollback pas;
// si la liste est vide, ne fait rien
func updateIdGroupes(tx *sql.Tx, participants []groupeUpdate, idCamp int64) error {
	if len(participants) == 0 {
		return nil
	}

	var (
		idsParticipants rd.Ids
		gps             rd.GroupeParticipants
	)
	for _, part := range participants {
		idsParticipants = append(idsParticipants, part.idParticipant)
		if part.idGroupe.Valid {
			gps = append(gps, rd.GroupeParticipant{
				IdCamp:        idCamp,
				Manuel:        false,
				IdParticipant: part.idParticipant,
				IdGroupe:      part.idGroupe.Int64,
			})
		}
	}

	// on commencer par supprimer les affectations courantes ...
	_, err := rd.DeleteGroupeParticipantsByIdParticipants(tx, idsParticipants...)
	if err != nil {
		return err
	}

	// ... puis on ajoute les nouvelles
	err = rd.InsertManyGroupeParticipants(tx, gps...)
	return err
}

type groupeUpdate struct {
	idParticipant int64
	idGroupe      rd.OptionnalId
}

// updatePlages modifie les plages des groupes donnés et met à jour les participants
// Si `erase` vaut `false`, les participants en mode manuel ne sont pas modifiés
// Renvoie le nombre de participants modifiés.
func (rc DriverCampComplet) updatePlages(groupes rd.Groupes, erase bool) (int, error) {
	tx, err := rc.DB.Begin()
	if err != nil {
		return 0, err
	}
	// on commence par modifier les plages
	for _, groupe := range groupes {
		_, err := tx.Exec("UPDATE groupes SET plage = $1 WHERE id = $2", groupe.Plage, groupe.Id)
		if err != nil {
			return 0, shared.Rollback(tx, err)
		}
	}

	// puis on s'assure d'avoir tous les groupes (mis à jour)
	groupes, _, _, err = loadGroupes(tx, rc.camp.Id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	// rc.camp.Base.Groupes = groupes
	camp := composites.NewCampGroupes(rc.camp.RawData(), groupes)

	// on calcule les nouvelles affectations

	// on commence par charger les participants propres du camp ...
	participants, err := rd.SelectParticipantsByIdCamps(tx, rc.camp.Id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	// ... les affectations courantes ...
	tmp, err := rd.SelectGroupeParticipantsByIdGroupes(tx, groupes.Ids()...)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	participantGroupe := tmp.ByIdParticipant()
	// ... et les personnes pour les dates de naissance
	rows, err := tx.Query(`SELECT personnes.* FROM personnes 
		JOIN participants ON participants.id_personne = personnes.id
		WHERE participants.id = ANY($1)`, participants.Ids().AsSQL())
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	personnes, err := rd.ScanPersonnes(rows)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	var modifications []groupeUpdate
	for _, part := range participants {
		currentGroupe, has := participantGroupe[part.Id]
		if !erase && has && currentGroupe.Manuel {
			// le participant a déjà un groupe attribué manuellement :
			// on n'y touche pas
			continue
		}
		var currentIdGroupe, targetIdGroupe rd.OptionnalId
		if has {
			currentIdGroupe = rd.NewOptionnalId(currentGroupe.IdGroupe)
		}

		groupe, found := camp.TrouveGroupe(personnes[part.IdPersonne].DateNaissance)
		if found {
			targetIdGroupe = rd.NewOptionnalId(groupe.Id)
		}
		if currentIdGroupe == targetIdGroupe {
			// le participant est déjà dans le bon groupe (au sens large):
			// on ne fait rien. C'est plus logique pour l'utilisateur
			continue
		}
		modifications = append(modifications, groupeUpdate{idParticipant: part.Id, idGroupe: targetIdGroupe})
	}

	err = updateIdGroupes(tx, modifications, camp.Id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return len(modifications), err
}