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

// Expose les fonctionnalités du portail des directeurs
package directeurs

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"github.com/benoitkugler/goACVE/logs"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	cd "github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/benoitkugler/goACVE/server/core/rawdata/matching"
	"github.com/benoitkugler/goACVE/server/core/utils/joomeo"
	"github.com/benoitkugler/goACVE/server/core/utils/mails"
	"github.com/benoitkugler/goACVE/server/documents"
	"github.com/benoitkugler/goACVE/server/shared"
)

const (
	DeltaToken       = 48 * time.Hour
	EndPointEquipier = "/equipier"
)

const (
	noLoad        loadDataMode = iota // charge uniquement le camp
	loadInscrits                      // charge aussi les données nécessaires aux inscrits
	loadEquipiers                     // charge aussi les données nécessaires aux équipiers
)

const (
	DownloadAll              modeDownloadFicheSanitaire = "all"
	DownloadOne              modeDownloadFicheSanitaire = "one"
	DownloadAllInOneDocument modeDownloadFicheSanitaire = "all_in_one_document"
)

var (
	HeaderExportInscrits = []rd.Header{
		{Field: dm.PersonneNom, Label: "Nom"},
		{Field: dm.PersonnePrenom, Label: "Prénom"},
		{Field: dm.PersonneSexe, Label: "Sexe"},
		{Field: dm.ParticipantAgeDebutCamp, Label: "Age (début de camp)"},
		{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
		{Field: dm.ParticipantGroupe, Label: "Groupe"},
		{Field: dm.ParticipantAnimateur, Label: "Animateur"},
		{Field: dm.ParticipantBus, Label: "Navette"},
		{Field: dm.PersonneMail, Label: "Mail du participant"},
		{Field: dm.ParticipantOptionPrix, Label: "Option sur le prix"},
		{Field: dm.ParticipantMaterielSki, Label: "Matériel de ski"},
		{Field: dm.ParticipantMaterielSkiType, Label: "Loueur (matériel ski)"},
	}

	HeaderExportInscritsSimple = []rd.Header{
		{Field: dm.PersonneNom, Label: "Nom"},
		{Field: dm.PersonnePrenom, Label: "Prénom"},
		{Field: dm.ParticipantGroupe, Label: "Groupe"},
		{Field: dm.ParticipantAnimateur, Label: "Animateur"},
	}

	HeaderExportResponsables = []rd.Header{
		{Field: dm.ParticipantRespoNomPrenom, Label: "Responsable"},
		{Field: dm.ParticipantRespoMail, Label: "Mail"},
		{Field: dm.ParticipantRespoTels, Label: "Tel."},
		{Field: dm.ParticipantRespoAdresse, Label: "Adresse"},
		{Field: dm.ParticipantRespoCodePostal, Label: "Code postal"},
		{Field: dm.ParticipantRespoVille, Label: "Ville"},
		{Field: dm.ParticipantRespoPays, Label: "Pays"},
	}

	HeaderExportResponsablesSimple = []rd.Header{
		{Field: dm.ParticipantRespoNomPrenom, Label: "Responsable"},
		{Field: dm.ParticipantRespoTels, Label: "Tel."},
	}

	HeaderExportEquipiers = []rd.Header{
		{Field: dm.PersonneNom, Label: "Nom"},
		{Field: dm.PersonnePrenom, Label: "Prénom"},
		{Field: dm.EquipierRoles, Label: "Rôle"},
		{Field: dm.EquipierDiplome, Label: "Diplôme"},
		{Field: dm.EquipierAppro, Label: "Approfondissement"},
		{Field: dm.PersonneSexe, Label: "Sexe"},
		{Field: dm.PersonneNomJeuneFille, Label: "Nom de jeune fille"},
		{Field: dm.PersonneDateNaissance, Label: "Date de naissance"},
		{Field: dm.PersonneDepartementNaissance, Label: "Département de naissance"},
		{Field: dm.PersonneVilleNaissance, Label: "Ville de naissance"},
		{Field: dm.PersonneMail, Label: "Adresse mail"},
		{Field: dm.PersonneTels, Label: "Téléphones"},
		{Field: dm.PersonneAdresse, Label: "Adresse"},
		{Field: dm.PersonneCodePostal, Label: "Code postal"},
		{Field: dm.PersonneVille, Label: "Ville"},
		{Field: dm.PersonneSecuriteSociale, Label: "Securité sociale"},
		{Field: dm.PersonneProfession, Label: "Profession"},
		{Field: dm.PersonneEtudiant, Label: "Etudiant"},
		{Field: dm.PersonneFonctionnaire, Label: "Fonctionnaire"},
		{Field: dm.EquipierPresence, Label: "Présence au séjour"},
	}
)

type loadDataMode uint8

type export string

type details string

type listeVetements string

type formulaireEquipier string

type modeDownloadFicheSanitaire string

type Controller struct {
	shared.Controller

	joomeo               logs.Joomeo
	ContraintesEquipiers rd.Contraintes
	defaultListe         struct{ Ete, Hiver []rd.Vetement }
}

// NewController créé un controller et charge les ressources
func NewController(base shared.Controller, joomeo logs.Joomeo, ressourcesPath string) (Controller, error) {
	var out Controller
	out.Controller = base
	out.joomeo = joomeo

	b, err := ioutil.ReadFile(filepath.Join(ressourcesPath, "liste_vetements.json"))
	if err != nil {
		return out, fmt.Errorf("Impossible d'accéder aux listes de vêtements par défaut : %s", err)
	}
	if err = json.Unmarshal(b, &out.defaultListe); err != nil {
		return out, fmt.Errorf("Listes de vêtements par défaut corrompues : %s", err)
	}

	err = out.initBuiltinContraintes()
	return out, err
}

// initBuiltinContraintes charge une fois pour toute
// les contraintes possibles pour un document d'équipier
func (ct *Controller) initBuiltinContraintes() error {
	// toutes sauf le test nautique
	rows, err := ct.DB.Query("SELECT * FROM contraintes WHERE builtin <> '' AND builtin <> $1", rd.CTestNautique)
	if err != nil {
		return err
	}
	ct.ContraintesEquipiers, err = rd.ScanContraintes(rows)
	return err
}

type Pieces struct {
	Contraintes rd.Contraintes      `json:"contraintes,omitempty"` // contraintes possibles
	Documents   []EquipierDocuments `json:"documents,omitempty"`
}

// EquipierDocuments indique les contraintes et les documents présents
// pour un équipier.
type EquipierDocuments struct {
	Contraintes []rd.EquipierContrainte `json:"contraintes,omitempty"` // writable

	IdEquipier int64                                `json:"id_equipier,omitempty"`
	NomPrenom  string                               `json:"nom_prenom,omitempty"`
	Documents  map[int64][]documents.PublicDocument `json:"documents,omitempty"` // id contrainte -> document présents
}

type DetailsWritable struct {
	Nom             rd.String          `json:"nom,omitempty"`
	Lieu            rd.String          `json:"lieu,omitempty"`
	NbPlaces        rd.Int             `json:"nb_places,omitempty"`
	NeedEquilibreGF rd.Bool            `json:"need_equilibre_gf,omitempty"`
	MaterielSki     rd.MaterielSkiCamp `json:"materiel_ski,omitempty"`
}

type Details struct {
	DetailsWritable
	Bus       rd.BusCamp `json:"bus,omitempty"`
	DateDebut rd.Date    `json:"date_debut,omitempty"`
	DateFin   rd.Date    `json:"date_fin,omitempty"`
}

type JoomeoData struct {
	SpaceUrl          string                     `json:"space_url,omitempty"`
	Meta              joomeo.Album               `json:"meta,omitempty"`
	Contacts          []joomeo.ContactPermission `json:"contacts,omitempty"`
	MailsInscrits     []string                   `json:"mails_inscrits,omitempty"`
	MailsResponsables []string                   `json:"mails_responsables,omitempty"`
	MailsEquipiers    []string                   `json:"mails_equipiers,omitempty"`
}

func (ct Controller) getCamps() ([]shared.CampMeta, error) {
	camps, err := rd.SelectAllCamps(ct.DB)
	if err != nil {
		return nil, err
	}
	out := make([]shared.CampMeta, 0, len(camps))
	for _, camp := range camps {
		var c shared.Camp
		c.From(camp)
		out = append(out, c.CampMeta)
	}
	sort.Slice(out, func(i int, j int) bool {
		return out[i].Label < out[j].Label
	})
	return out, nil
}

// checkPassword renvoie "" si le mot de passe est faux,
// une erreur si la requête est mal formée,
// ou un token si tout va bien.
func (ct Controller) checkPassword(idCamp int64, password string) (camp rd.Camp, token string, err error) {
	camp, err = rd.SelectCamp(ct.DB, idCamp)
	if err != nil {
		return
	}
	if camp.Password == "" {
		err = errors.New("Le camp n'est pas protégé par un mot de passe. Contactez l'administrateur.")
		return
	}
	if string(camp.Password) != password {
		return
	}
	token, err = ct.creeToken(idCamp)
	return
}

func (ct Controller) newDriverShared(token string, camp rd.Camp) driverShared {
	base := dm.BaseLocale{
		Camps: rd.Camps{camp.Id: camp},
	}
	return driverShared{
		Controller: ct.Controller,
		joomeo:     ct.joomeo,
		camp:       base.NewCamp(camp.Id),
		token:      token,
	}
}

func (ct Controller) newDriverCampComplet(token string, camp rd.Camp) DriverCampComplet {
	return DriverCampComplet{
		driverShared:         ct.newDriverShared(token, camp),
		contraintesEquipiers: ct.ContraintesEquipiers,
	}
}

func loadData(d Driver, load loadDataMode) error {
	var err error
	switch load {
	case loadInscrits:
		err = d.loadDataInscrits()
	case loadEquipiers:
		err = d.loadDataEquipiers()
	}
	return err
}

// setupRequest s'occupe de l'identification et du chargement des données,
// pour tous les camps
func (ct Controller) setupRequest(req withBasicAuth, load loadDataMode) (Driver, error) {
	idCamp, token, err := ct.authentifie(req)
	if err != nil {
		return nil, err
	}
	camp, err := rd.SelectCamp(ct.DB, idCamp)
	if err != nil {
		return nil, err
	}
	var out Driver
	if camp.InscriptionSimple {
		out = DriverCampSimple{driverShared: ct.newDriverShared(token, camp)}
	} else {
		out = ct.newDriverCampComplet(token, camp)
	}
	err = loadData(out, load)
	return out, err
}

// setupRequest s'occupe de l'identification et du chargement des données,
// pour tous les camps complets uniquement
func (ct Controller) setupRequestComplet(req withBasicAuth, load loadDataMode) (DriverCampComplet, error) {
	idCamp, token, err := ct.authentifie(req)
	if err != nil {
		return DriverCampComplet{}, err
	}
	camp, err := rd.SelectCamp(ct.DB, idCamp)
	if err != nil {
		return DriverCampComplet{}, err
	}
	if camp.InscriptionSimple {
		return DriverCampComplet{}, fmt.Errorf("Le camp %s ne supporte pas l'opération demandée.", camp.Label())
	}
	out := ct.newDriverCampComplet(token, camp)
	err = loadData(out, load)
	return out, err
}

func (rc DriverCampComplet) compileDocs(host string, docs []dm.AccesDocumentPersonne) (map[int64][]documents.PublicDocument, error) {
	out := make(map[int64][]documents.PublicDocument)
	for _, doc := range docs {
		contrainte := doc.GetContrainte()
		pub, err := documents.PublieDocument(rc.Signing, host, doc.RawData())
		if err != nil {
			return nil, err
		}
		out[contrainte.Id] = append(out[contrainte.Id], pub)
	}
	return out, nil
}

func (d DriverCampComplet) packageDocs(idsDocs rd.Ids, prefixes map[int64]string) (*bytes.Buffer, error) {
	archive := cd.NewArchiveZip()
	if err := documents.LoadDocsAndAdd(d.DB, idsDocs, archive, prefixes); err != nil {
		return nil, err
	}
	return archive.Close()
}

func (d driverShared) getDetails() Details {
	rc := d.camp.RawData()
	return Details{
		DetailsWritable: DetailsWritable{
			Nom:             rc.Nom,
			Lieu:            rc.Lieu,
			NbPlaces:        rc.NbPlaces,
			NeedEquilibreGF: rc.NeedEquilibreGf,
			MaterielSki:     rc.Options.MaterielSki,
		},
		Bus:       rc.Options.Bus,
		DateDebut: rc.DateDebut,
		DateFin:   rc.DateFin,
	}
}

func (d driverShared) updateDetails(det DetailsWritable) error {
	if det.Nom == "" || det.Lieu == "" || det.NbPlaces == 0 {
		return errors.New("Merci de préciser nom, lieu et nombre de places !")
	}
	rc := d.camp.RawData()
	rc.Nom = det.Nom
	rc.Lieu = det.Lieu
	rc.NbPlaces = det.NbPlaces
	rc.NeedEquilibreGf = det.NeedEquilibreGF
	rc.Options.MaterielSki = det.MaterielSki

	rc, err := rc.Update(d.DB)
	if err != nil {
		return err
	}

	d.camp.Base.Camps[rc.Id] = rc
	return nil
}

// charge les documents du camp (lettre, pièces jointes bonus)
func (d DriverCampComplet) loadDocsCamp() error {
	rows, err := d.DB.Query(`SELECT documents.* FROM documents 
		JOIN document_camps ON document_camps.id_document = documents.id
		WHERE document_camps.id_camp = $1`, d.camp.Id)
	if err != nil {
		return shared.FormatErr("Le chargement des documents liés au camp a échoué", err)
	}
	docs, err := rd.ScanDocuments(rows)
	if err != nil {
		return shared.FormatErr("La lecture des documents liés au camp a échoué.", err)
	}

	liens, err := rd.SelectDocumentCampsByIdCamps(d.DB, d.camp.Id)
	if err != nil {
		return shared.FormatErr("La lecture des documents liés au camp a échoué.", err)
	}
	d.camp.Base.Documents = docs
	d.camp.Base.DocumentCamps = liens.ByIdDocument()
	return nil
}

// getBonusDocs charge les pièces jointes du camp et les partage
func (d DriverCampComplet) getBonusDocs(host string) ([]documents.PublicDocument, error) {
	if err := d.loadDocsCamp(); err != nil {
		return nil, err
	}
	pjs := d.camp.GetRegisteredDocuments(false, true)
	outDocs := make([]documents.PublicDocument, len(pjs))
	var err error
	for index, doc := range pjs {
		outDocs[index], err = documents.PublieDocument(d.Signing, host, doc)
		if err != nil {
			return nil, err
		}
	}
	return outDocs, nil
}

func (d DriverCampComplet) addBonusDoc(host string, fileName string, fileContent []byte) (pub documents.PublicDocument, err error) {
	if err = d.loadDocsCamp(); err != nil {
		return
	}
	tx, err := d.DB.Begin()
	if err != nil {
		return
	}

	document := rd.Document{
		Description:    "Document additionnel du " + d.camp.RawData().Label(),
		DateHeureModif: rd.Time(time.Now()),
	}
	document, err = document.Insert(tx)
	if err != nil {
		return pub, shared.Rollback(tx, err)
	}

	// on insert le lien
	lien := rd.DocumentCamp{
		IdCamp:     d.camp.Id,
		IdDocument: document.Id,
		IsLettre:   false,
	}
	err = rd.InsertManyDocumentCamps(tx, lien)
	if err != nil {
		return pub, shared.Rollback(tx, err)
	}

	// on insert le contenu
	document, err = documents.SaveDocument(tx, document.Id, fileContent, fileName, false)
	if err != nil {
		return pub, shared.Rollback(tx, err)
	}

	// puis on publie
	pub, err = documents.PublieDocument(d.Signing, host, document)
	if err != nil {
		return pub, shared.Rollback(tx, err)
	}
	d.camp.Base.Documents[document.Id] = document
	d.camp.Base.DocumentCamps[lien.IdDocument] = lien
	err = tx.Commit()
	return
}

func (d DriverCampComplet) updateEnvois(env rd.Envois) error {
	if env.Locked {
		return errors.New("La modification des préférences d'envois est désactivée tant que l'envoi est verrouillé.")
	}
	oldLocked := d.camp.RawData().Envois.Locked
	tx, err := d.DB.Begin()
	if err != nil {
		return err
	}
	row := tx.QueryRow("UPDATE camps SET envois = $1 WHERE id = $2 RETURNING *", env, d.camp.Id)
	camp, err := rd.ScanCamp(row)
	if err != nil {
		return shared.Rollback(tx, err)
	}
	d.camp.Base.Camps[camp.Id] = camp

	wasUnlocked := oldLocked && !camp.Envois.Locked
	if wasUnlocked { // on prévient par mail le centre d'inscription
		html, err := mails.NewNotifieEnvoiDocs(camp)
		if err != nil {
			return shared.Rollback(tx, err)
		}
		err = mails.NewMailer(d.SMTP).SendMail(rd.CoordonnesCentre.Mail, "[ACVE] Envois des documents", html, nil,
			nil)
		if err != nil {
			return shared.Rollback(tx, err)
		}
	}
	err = tx.Commit()
	return err
}

func (d DriverCampComplet) updateListeVetements(l rd.ListeVetements) error {
	row := d.DB.QueryRow("UPDATE camps SET liste_vetements = $1 WHERE id = $2 RETURNING *", l, d.camp.Id)
	camp, err := rd.ScanCamp(row)
	if err != nil {
		return err
	}
	d.camp.Base.Camps[camp.Id] = camp
	return nil
}

func (d DriverCampComplet) getLettreDirecteur(host string) (doc documents.PublicDocument, lettre rd.Lettredirecteur, err error) {
	if err = d.loadDocsCamp(); err != nil {
		return
	}
	letters := d.camp.GetRegisteredDocuments(true, false)
	if len(letters) > 0 {
		// il n'y a normalement qu'une seule lettre
		// sinon, on renvoie une lettre au hasard.
		doc, err = documents.PublieDocument(d.Signing, host, letters[0])
		if err != nil {
			return
		}
	}
	lettre, _, err = rd.SelectLettredirecteurByIdCamp(d.DB, d.camp.Id) // zero value si le camp n'a pas encore de lettre
	return
}

// reduitNom remplace les espaces par des _
func reduitNom(fullname string) string {
	parts := strings.Split(strings.ToLower(fullname), " ")
	for index, p := range parts {
		parts[index] = strings.Title(matching.RemoveAccents(strings.TrimSpace(p)))
	}
	return strings.Join(parts, "_")
}