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

package directeurs

import (
	"bytes"
	"errors"
	"fmt"
	"time"

	"github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
	"github.com/lib/pq"
)

func (rc DriverCampComplet) loadContraintes(host string) (map[int64]ContrainteComplete, error) {
	cts, err := rc.fetchContraintes()
	if err != nil {
		return nil, err
	}
	var idsDocs rd.Ids
	for _, contrainte := range cts {
		if idDoc := contrainte.IdDocument; idDoc.IsNotNil() {
			idsDocs = append(idsDocs, idDoc.Int64)
		}
	}
	// on ajoute les documents
	rows, err := rc.DB.Query("SELECT * FROM documents WHERE id = ANY($1)", idsDocs.AsSQL())
	if err != nil {
		return nil, err
	}
	docs, err := rd.ScanDocuments(rows)
	if err != nil {
		return nil, err
	}
	out := make(map[int64]ContrainteComplete, len(cts))
	for id, contrainte := range cts {
		ctC := ContrainteComplete{Contrainte: contrainte}
		if idDoc := contrainte.IdDocument; idDoc.IsNotNil() {
			ctC.Document, err = documents.PublieDocument(rc.Signing, host, docs[idDoc.Int64])
			if err != nil {
				return nil, err
			}
		}
		out[id] = ctC
	}
	return out, nil
}

// renvoie les contraintes builtin et les contraintes perso, pour les participants, sans leurs documents
func (rc DriverCampComplet) fetchContraintes() (rd.Contraintes, error) {
	// on charge l'équipe pour trouver le directeur
	if err := rc.loadDataEquipiers(); err != nil {
		return nil, err
	}
	builtins := []string{string(rd.CTestNautique)}
	rows, err := rc.DB.Query("SELECT * FROM contraintes WHERE builtin = ANY($1)", pq.StringArray(builtins))
	if err != nil {
		return nil, err
	}
	contraintes, err := rd.ScanContraintes(rows)
	if err != nil {
		return nil, err
	}

	dir, has := rc.camp.GetDirecteur()
	if !has {
		return contraintes, err
	}
	// on ajoute les contraintes perso
	contraintesPerso, err := rd.SelectContraintesByIdPersonnes(rc.DB, dir.Id)
	for k, v := range contraintesPerso { // fusion
		contraintes[k] = v
	}
	return contraintes, err

}

func (rc DriverCampComplet) createContrainte(contrainte rd.Contrainte) error {
	// on charge l'équipe pour trouver le directeur
	if err := rc.loadDataEquipiers(); err != nil {
		return err
	}
	dir, has := rc.camp.GetDirecteur()
	if !has {
		return fmt.Errorf("Un directeur est requis pour ajouter une demande de document personnalisée.")
	}
	// on attache la contrainte au directeur
	contrainte.IdPersonne = rd.NewOptionnalId(dir.Id)
	_, err := contrainte.Insert(rc.DB)
	return err
}

func (rc DriverCampComplet) updateContrainte(modif rd.Contrainte) (rd.Contrainte, error) {
	// on charge l'équipe pour trouver le directeur
	if err := rc.loadDataEquipiers(); err != nil {
		return modif, err
	}
	dir, has := rc.camp.GetDirecteur()
	if !has {
		return modif, fmt.Errorf("Un directeur est requis pour modifier une demande de document personnalisée.")
	}
	contrainte, err := rd.SelectContrainte(rc.DB, modif.Id)
	if err != nil {
		return modif, err
	}
	if contrainte.Builtin != "" {
		return modif, fmt.Errorf("Cette contrainte est prédéfinie.")
	}
	if !contrainte.IdPersonne.Is(dir.Id) {
		return contrainte, errors.New("Cette contrainte ne vous appartient pas.")
	}
	contrainte.Nom = modif.Nom
	contrainte.Description = modif.Description
	contrainte.MaxDocs = modif.MaxDocs
	return contrainte.Update(rc.DB)
}

// crée les métas données d'un document à remplir
func (rc DriverCampComplet) lieDocument(host string, idContrainte int64) (documents.PublicDocument, error) {
	// on charge l'équipe pour trouver le directeur
	if err := rc.loadDataEquipiers(); err != nil {
		return documents.PublicDocument{}, err
	}
	dir, has := rc.camp.GetDirecteur()
	if !has {
		return documents.PublicDocument{}, fmt.Errorf("Un directeur est requis pour modifier une demande de document personnalisée.")
	}

	tx, err := rc.DB.Begin()
	if err != nil {
		return documents.PublicDocument{}, err
	}

	contrainte, err := rd.SelectContrainte(tx, idContrainte)
	if err != nil {
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}
	if contrainte.IdDocument.IsNotNil() {
		err = errors.New("Un document est déjà lié à cette contrainte.")
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}
	if !contrainte.IdPersonne.Is(dir.Id) {
		err = errors.New("Cette contrainte ne vous appartient pas.")
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}

	document := rd.Document{Description: "Document à remplir", DateHeureModif: rd.Time(time.Now())}
	document, err = document.Insert(tx)
	if err != nil {
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}

	contrainte.IdDocument = rd.NewOptionnalId(document.Id)
	contrainte, err = contrainte.Update(tx)
	if err != nil {
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}

	public, err := documents.PublieDocument(rc.Signing, host, document)
	if err != nil {
		return documents.PublicDocument{}, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return public, err
}

// supprime une contrainte personnalisée et tous les documents associés
// et retourne le nombre de documents concernés
func (rc DriverCampComplet) deleteContrainte(id int64) (int, error) {
	// on vérifie le propriétaire
	if err := rc.loadDataEquipiers(); err != nil {
		return 0, err
	}
	dir, has := rc.camp.GetDirecteur()
	if !has { // entre autre la contrainte ne peut appartenir au directeur
		return 0, errors.New("La demande de document ne vous appartient pas.")
	}
	contrainte, err := rd.SelectContrainte(rc.DB, id)
	if err != nil {
		return 0, err
	}
	if !contrainte.IdPersonne.Is(dir.Id) || contrainte.Builtin != "" { // bizarre mais on préfère être safe
		return 0, errors.New("La demande de document ne vous appartient pas.")
	}

	tx, err := rc.DB.Begin()
	if err != nil {
		return 0, err
	}

	// lien groupes
	_, err = rd.DeleteGroupeContraintesByIdContraintes(tx, id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	// lien documents
	rows, err := tx.Query("DELETE FROM document_personnes WHERE id_contrainte = $1 RETURNING id_document", id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	docIds, err := rd.ScanIds(rows)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	// contenu
	_, err = rd.DeleteContenuDocumentsByIdDocuments(tx, docIds...)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	// document eux mêmes
	_, err = rd.DeleteDocumentsByIds(tx, docIds...)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}

	// finalement la contrainte elle-même
	_, err = rd.DeleteContrainteById(tx, contrainte.Id)
	if err != nil {
		return 0, shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return len(docIds), err
}

// remplace les contraintes actuelles des groupes du camp par celles données
func (rc DriverCampComplet) updateGroupesContraintes(contraintes DemandeContraintesIn) error {
	groupes, _, _, err := loadGroupes(rc.DB, rc.camp.Id)
	if err != nil {
		return err
	}
	// on vérifie l'origine des groupes
	for _, cont := range contraintes.GroupeContraintes {
		if _, in := groupes[cont.IdGroupe]; !in {
			return fmt.Errorf("Le groupe %d n'est pas lié au séjour.", cont.IdGroupe)
		}
	}
	for i := range contraintes.CampContraintes {
		contraintes.CampContraintes[i].IdCamp = rc.camp.Id
	}

	tx, err := rc.DB.Begin()
	if err != nil {
		return err
	}

	// on supprime les contraintes existantes ...
	_, err = rd.DeleteGroupeContraintesByIdGroupes(tx, groupes.Ids()...)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	_, err = rd.DeleteCampContraintesByIdCamps(tx, rc.camp.Id)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	// ... et on ajoute les nouvelles
	err = rd.InsertManyGroupeContraintes(tx, contraintes.GroupeContraintes...)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = rd.InsertManyCampContraintes(tx, contraintes.CampContraintes...)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	err = tx.Commit()
	return err
}

func resoudContraintes(part datamodel.AccesParticipant) rd.Set {
	cts := rd.NewSet()
	// on regroupe les ids des contraintes
	for _, campContrainte := range part.Base.CampContraintes[part.RawData().IdCamp] {
		cts.Add(campContrainte.IdContrainte)
	}
	groupe, hasGroupe := part.GetGroupe()
	if hasGroupe {
		for _, campContrainte := range part.Base.GroupeContraintes[groupe.Id] {
			cts.Add(campContrainte.IdContrainte)
		}
	}
	return cts
}

// renvoie le nombre de participants (du camp courant)
// ayant mis un ligne un document pour la contrainte donnée
func (rc DriverCampComplet) previewDocsContrainte(idContrainte int64) PreviewDocumentsParticipantsOut {
	participants := append(rc.camp.GetInscrits(nil), rc.camp.GetAttente(nil)...)

	cache := rc.camp.Base.ResoudDocumentsPersonnes()
	var out PreviewDocumentsParticipantsOut
	for _, part := range participants {
		cts := resoudContraintes(part)
		if !cts.Has(idContrainte) {
			// on ignore les documents non exigés
			continue
		}
		out.NbDemandes++
		for _, doc := range part.GetPersonne().GetDocuments(cache) {
			// on ne garde que les docs concerné
			if idContrainte == doc.GetContrainte().Id {
				out.NbRecus++
				break
			}
		}
	}
	return out
}

// renvoie les documents des participants (de tous les groupes) correspondant à la contrainte
// ou, si elle est est nulle, à toutes les contraintes appliquées aux groupes
func (rc DriverCampComplet) downloadDocsParticipants(idContrainte rd.OptionnalId) (*bytes.Buffer, error) {
	participants := append(rc.camp.GetInscrits(nil), rc.camp.GetAttente(nil)...)
	datamodel.TriParticipants(participants, true)

	cache := rc.camp.Base.ResoudDocumentsPersonnes()
	var idsDocs rd.Ids
	prefixes := map[int64]string{}
	for _, part := range participants {
		cts := resoudContraintes(part)
		if idContrainte.Valid && !cts.Has(idContrainte.Int64) {
			// on ignore les documents non exigés
			continue
		}
		personne := part.GetPersonne()
		for _, doc := range personne.GetDocuments(cache) {
			docCId := doc.GetContrainte().Id
			// si la contrainte demandée est non nulle, on ne garde que les docs concerné
			// si la contrainte est nulle, on renvoie tous les documents exigés
			if idContrainte.Is(docCId) || (idContrainte.IsNil() && cts.Has(docCId)) {
				idsDocs = append(idsDocs, doc.Id)
				prefixes[doc.Id] = (doc.GetContrainte().Nom + " " + personne.RawData().NomPrenom()).String()
			}
		}

	}
	return rc.packageDocs(idsDocs.AsSet().Keys(), prefixes)
}