github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/cont_suivi_camps.go

package controllers

import (
	"errors"
	"fmt"
	"net/http"
	"path"
	"sort"
	"strconv"
	"strings"

	"github.com/benoitkugler/goACVE/logs"

	"github.com/benoitkugler/goACVE/server/core/documents"

	"github.com/benoitkugler/goACVE/server/core/utils/joomeo"
	"github.com/benoitkugler/goACVE/server/core/utils/table"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
)

const (
	EndpointInscription = "/inscription/"

	complementDefaut = "<i>Indispensable:</i> tout linge doit être <b>marqué</b> (étiquette cousue ou stylo indélébile)."
)

const (
	bfNom rd.Field = iota
	bfDirecteur
	bfLieu
	bfDuree
	bfAnimation
	bfTechnique
	bfInscrits
	bfPrixBase
	bfRemisesSpeciales
	bfRemisesPourcent
	bfTotalAides
	bfTotalDemande
	bfTotal
)

var (
	HeadersBilanFinancier = []rd.Header{
		{Field: bfNom, Label: "Camp"},
		{Field: bfDirecteur, Label: "Directeur"},
		{Field: bfLieu, Label: "Lieu"},
		{Field: bfDuree, Label: "Durée (jours)"},
		{Field: bfAnimation, Label: "Animateurs"},
		{Field: bfTechnique, Label: "Equipe technique"},
		{Field: bfInscrits, Label: "Inscrits"},
		{Field: bfPrixBase, Label: "Prix (sans option)"},
		{Field: bfRemisesSpeciales, Label: "Réductions spéciales"},
		{Field: bfRemisesPourcent, Label: "Réductions équipiers / enfants"},
		{Field: bfTotalAides, Label: "Aides extérieures (CAFs, CE, etc...)"},
		{Field: bfTotalDemande, Label: "Montant demandé"},
		{Field: bfTotal, Label: "Budget total"},
	}
)

type ButtonsSuiviCamps struct {
	Creer, Supprimer, AfficherJoomeo, BilanFinancier, LienSondages EtatSideButton
}

type OngletSuiviCamps interface {
	baseOnglet

	ConfirmeAjoutDirecteurJoomeo(msg string) rd.OptionnalBool // 0 : annule, Non : Confirme,  Oui: Confirme + mail
	ConfirmeSetupAlbumJoomeo(alreadyLinked []string) bool
	ConfirmeSupprimeCamp(camp dm.AccesCamp) bool
	ProposePasswordDirecteur(camp dm.AccesCamp, password string) bool
}

type EtatSuiviCamps struct {
	CampCurrent         rd.IId
	CritereIgnoreClosed bool             // seulement camps ouverts
	CritereTerminated   rd.OptionnalBool // non terminés, les deux, terminés)
}

// SuiviCamps implémente une gestion des camps comme administrateur.
type SuiviCamps struct {
	Onglet    OngletSuiviCamps
	main      *MainController
	Liste     rd.Table
	Header    []rd.Header
	Base      *dm.BaseLocale
	Etat      EtatSuiviCamps
	apiJoomeo *joomeo.ApiJoomeo
	EditRight bool // Droit d'édition/ajout/suppression de camps
}

func NewSuiviCamps(main *MainController, permission int) *SuiviCamps {
	s := SuiviCamps{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.CampNom, Label: "Nom"},
			{Field: dm.CampAnnee, Label: "Année"},
			{Field: dm.CampPeriode, Label: "Période"},
			{Field: dm.CampLieu, Label: "Lieu"},
			{Field: dm.CampRemplissage, Label: "Remplissage"},
			{Field: dm.CampOuvert, Label: "Inscriptions ouvertes"},
			{Field: dm.CampIdJs, Label: "N° Jeunesse et Sport"},
			{Field: dm.CampJoomeoAlbumId, Label: "Identifiant Joomeo"},
		}}
	s.resetData()
	return &s
}

func (c *SuiviCamps) resetData() {
	c.Liste = make(rd.Table, 0, len(c.Base.Camps))
	_, cache1 := c.Base.ResoudParticipants()
	cache2 := c.Base.ResoudParticipantsimples()
	for _, camp := range c.Base.GetCamps(c.Etat.CritereIgnoreClosed, c.Etat.CritereTerminated) {
		c.Liste = append(c.Liste, camp.AsItem(cache1, cache2))
	}

	if c.Etat.CampCurrent != nil && !HasId(c.Liste, c.Etat.CampCurrent) {
		c.Etat.CampCurrent = nil
	}
}

func (c *SuiviCamps) SideButtons() ButtonsSuiviCamps {
	bs := ButtonsSuiviCamps{}
	EtatButton := ButtonPresent
	if c.Etat.CampCurrent != nil {
		EtatButton = ButtonActivated
	}
	if c.EditRight {
		bs.Creer = ButtonActivated
		bs.Supprimer = EtatButton
		bs.AfficherJoomeo = EtatButton
	}
	bs.BilanFinancier = ButtonActivated
	bs.LienSondages = ButtonActivated
	return bs
}

func bilanFinancierCamp(camp dm.AccesCamp, cache1 dm.LiensCampEquipiers,
	cache2 dm.LiensCampParticipants, cache3 dm.LiensCampParticipantsimples,
	cacheAide dm.LiensParticipantAides) rd.Item {
	nomDirecteur := ""
	if dir, has := camp.GetDirecteur(); has {
		nomDirecteur = dir.RawData().NomPrenom().String()
	}
	equipe, nbAnim := camp.GetEquipe(cache1), 0
	for _, part := range equipe {
		if part.RawData().Roles.IsAuPair() {
			nbAnim += 1
		}
	}
	rawCamp := camp.RawData()
	remisesPourcent := make(map[rd.Pourcent]int)
	var remisesSpeciales, totalAides, totalDemande rd.Euros
	for _, part := range camp.GetInscrits(cache2) {
		detailsPrix := part.EtatFinancier(cacheAide, false)
		rem := part.RawData().Remises
		remisesSpeciales += rem.ReducSpeciale
		remPourcent := rem.Pourcent()
		if remPourcent > 0 {
			remisesPourcent[remPourcent] += 1
		}
		totalAides += detailsPrix.TotalAides()
		totalDemande += detailsPrix.PrixNet()
	}
	var remsStr []string
	for rem, nb := range remisesPourcent {
		remsStr = append(remsStr, fmt.Sprintf("de %d %%: %d", rem, nb))
	}
	fields := rd.F{
		bfNom:              rawCamp.Nom,
		bfLieu:             rawCamp.Lieu,
		bfDirecteur:        rd.String(nomDirecteur),
		bfDuree:            rd.Int(rawCamp.Duree()),
		bfInscrits:         rd.Int(camp.GetNbInscrits(cache2, cache3)),
		bfAnimation:        rd.Int(nbAnim),
		bfTechnique:        rd.Int(len(equipe) - nbAnim),
		bfPrixBase:         rawCamp.Prix,
		bfRemisesSpeciales: remisesSpeciales,
		bfTotalAides:       totalAides,
		bfTotalDemande:     totalDemande,
		bfTotal:            totalDemande + totalAides,
		bfRemisesPourcent:  rd.String(strings.Join(remsStr, "; ")),
	}
	bolds := rd.B{bfNom: true, bfDirecteur: true, bfLieu: true}
	colors := rd.MapColors{bfNom: rd.HexColor("#D9D9D9"), bfDirecteur: rd.HexColor("#D9D9D9"), bfLieu: rd.HexColor("#D9D9D9")}
	return rd.Item{Fields: fields, Bolds: bolds, BackgroundColors: colors}
}

func (c *SuiviCamps) BilansFinanciers(camps []int64) map[int64]rd.Item {
	out := make(map[int64]rd.Item, len(camps))
	cacheAide := c.Base.ResoudAides()
	cache1 := c.Base.ResoudEquipiers()
	_, cache2 := c.Base.ResoudParticipants()
	cache3 := c.Base.ResoudParticipantsimples()
	for _, campId := range camps {
		camp := c.Base.NewCamp(campId)
		bilan := bilanFinancierCamp(camp, cache1, cache2, cache3, cacheAide)
		out[camp.Id] = bilan
	}
	return out
}

// CreeCamp ajoute le camp sur le serveur.
// Le champ complément de la liste de vêtements est
// pré-rempli.
func (c *SuiviCamps) CreeCamp(params apiserver.CreateCampIn) {
	// défaut, en respectant un éventuel import
	params.Camp.Envois.Locked = true
	params.Camp.Envois.LettreDirecteur = true
	if params.Camp.ListeVetements.Complement != "" {
		params.Camp.ListeVetements.Complement = complementDefaut
	}

	job := func() (interface{}, error) {
		var out rd.Camp
		err := requete(apiserver.UrlCamps, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Camp)
		c.Base.Camps[out.Id] = out
		c.main.ShowStandard(fmt.Sprintf("Camp %s créé avec succès.", out.Label()), false)
		c.Reset()
	}

	c.main.ShowStandard("Création du camp...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviCamps) UpdateCamp(camp rd.Camp) {
	c.main.Controllers.Camps.UpdateCamp(camp)
}

// ImportCamp copie les champs pertinents pour
// un nouveau camp, à partir du camp courant
func (c *SuiviCamps) ImportCampFrom() apiserver.CreateCampIn {
	if c.Etat.CampCurrent == nil {
		return apiserver.CreateCampIn{}
	}
	oldCamp := c.Base.Camps[c.Etat.CampCurrent.Int64()] // copie
	oldCamp.Id, oldCamp.Ouvert = -1, false
	oldCamp.NumeroJS, oldCamp.JoomeoAlbumId = "", ""

	return apiserver.CreateCampIn{Camp: oldCamp, CopyLettreFrom: rd.NewOptionnalId(c.Etat.CampCurrent.Int64())}
}

// AjouteDirecteur inscrit une personne avec le rôle de directeur
func (c *SuiviCamps) AjouteDirecteur(camp dm.AccesCamp, idDirecteur int64) {
	if dir, has := camp.GetDirecteur(); has {
		c.main.ShowError(fmt.Errorf("Le camp %s possède déjà un directeur (<i>%s</i>). \n Veuillez d'abord le supprimer.",
			camp.RawData().Label(), dir.RawData().NomPrenom()))
		return
	}
	part := rd.Equipier{Roles: rd.RDirecteur.AsRoles(), IdPersonne: idDirecteur, IdCamp: camp.Id}
	jobLaunched := c.main.Controllers.Equipiers.CreateEquipier(part)
	if !jobLaunched {
		return
	}
	// on propose d'utiliser un mot de passe lié au directeur
	// afin de lui simplifier la vie
	proposition := logs.PasswordDir.Password(idDirecteur)
	changePass := c.Onglet.ProposePasswordDirecteur(camp, proposition)
	if !changePass {
		return
	}
	newCamp := camp.RawData()
	newCamp.Password = rd.String(proposition)
	c.UpdateCamp(newCamp)
}

func (c *SuiviCamps) ExportBilanCamps(bilan map[int64]rd.Item) string {
	liste := make(rd.Table, 0, len(bilan))
	for _, camp := range bilan {
		liste = append(liste, camp)
	}
	filePath, err := table.EnregistreBilanCamps(HeadersBilanFinancier, liste, LocalFolder)
	if err != nil {
		c.main.ShowError(fmt.Errorf("Impossible d'enregistrer le bilan : %s", err))
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Bilan exporté : %s", filePath), false)
	return filePath
}

// LienInscription renvoie un lien pré-selectionnant le camp
// sur le formulaire d'inscription.
func (c *SuiviCamps) LienInscription(idCamp int64) string {
	idCampS := strconv.FormatInt(idCamp, 10)
	lien := Server.EndpointURL(path.Join(EndpointInscription, idCampS))
	c.main.ShowStandard("Lien : "+lien, false)
	return lien
}

// ExportSuiviFinancierParticipants génère et enregistre une liste des participants / état facture
func (c *SuiviCamps) ExportSuiviFinancierParticipants(camp dm.AccesCamp) string {
	parts, totalDemande, totalAides := c.Base.SuiviFinancier(camp)
	filePath, err := table.EnregistreSuiviFinancierCamp(documents.HeadersSuiviParticipants, parts, totalDemande,
		totalAides, camp.RawData().Label().String(), LocalFolder)
	if err != nil {
		c.main.ShowError(fmt.Errorf("Impossible d'enregistrer l'export : %s", err))
		return ""
	}
	c.main.ShowStandard(fmt.Sprintf("Suivi financier exporté : %s", filePath), false)
	return filePath
}

// ---------------------------------------------------------------------------
// ---------------------------------- Joomeo ---------------------------------
// ---------------------------------------------------------------------------

func (c *SuiviCamps) getJoomeoApi() (*joomeo.ApiJoomeo, error) {
	if c.apiJoomeo == nil {
		apiJoomeo, err := joomeo.InitApi(c.main.logsJoomeo)
		if err != nil {
			return nil, err
		}
		c.apiJoomeo = apiJoomeo
	}
	return c.apiJoomeo, nil
}

// CloseJoomeoApi termine la connexion.
func (c *SuiviCamps) CloseJoomeoApi() {
	if c.apiJoomeo != nil {
		c.apiJoomeo.Kill()
		c.apiJoomeo = nil
	}
}

// GetAlbumsContactsJoomeo renvoie les albums et contacts Joomeo
func (c *SuiviCamps) GetAlbumsContactsJoomeo() ([]rd.ItemChilds, map[string]joomeo.Album, map[string]joomeo.Contact) {
	api, err := c.getJoomeoApi()
	if err != nil {
		c.main.ShowError(err)
		return nil, nil, nil
	}
	folders, albums, contacts, err := api.GetAlbumsContacts()
	if err != nil {
		c.main.ShowError(err)
		return nil, nil, nil
	}
	out := make([]rd.ItemChilds, 0, len(folders))
	for _, fol := range folders {
		out = append(out, fol.AsItem())
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].Fields.Data(joomeo.FLabel).Sortable() < out[j].Fields.Data(joomeo.FLabel).Sortable()
	})
	return out, albums, contacts
}

// SetupAlbumJoomeo attribue l'album donné au camp courant,
// après vérification. Synchrone
func (c *SuiviCamps) SetupAlbumJoomeo(albumId string) {
	if c.Etat.CampCurrent == nil {
		c.main.ShowError(errors.New("Aucun camp courant !"))
		return
	}
	var already []string
	for _, camp := range c.Base.Camps {
		if string(camp.JoomeoAlbumId) == albumId {
			already = append(already, camp.Label().String())
		}
	}
	if len(already) > 0 {
		if !c.Onglet.ConfirmeSetupAlbumJoomeo(already) {
			return
		}
	}
	current := c.Base.Camps[c.Etat.CampCurrent.Int64()]
	current.JoomeoAlbumId = rd.String(albumId)
	c.main.ShowStandard("Ajout de l'album Joomeo...", true)
	out, err := updateCamp(current)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	c.main.ShowStandard("Album Joomeo ajouté.", false)
	c.Base.Camps[out.Id] = out
	c.Reset()
}

func (c *SuiviCamps) RemoveAlbumJoomeo() {
	if c.Etat.CampCurrent == nil {
		c.main.ShowError(errors.New("Aucun camp courant !"))
		return
	}
	current := c.Base.Camps[c.Etat.CampCurrent.Int64()]
	current.JoomeoAlbumId = ""
	c.main.ShowStandard("Retrait de l'album Joomeo...", true)
	out, err := updateCamp(current)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	c.main.ShowStandard("Album Joomeo retiré.", false)
	c.Base.Camps[out.Id] = out
	c.Reset()
}

// AjouteDirecteurJoomeo ajoute le directeur du camp courant comme contact Joomeo
func (c *SuiviCamps) AjouteDirecteurJoomeo(albums map[string]joomeo.Album) {
	if c.Etat.CampCurrent == nil {
		c.main.ShowError(errors.New("Aucun camp courant !"))
		return
	}
	camp := c.Base.NewCamp(c.Etat.CampCurrent.Int64())
	rawCamp := camp.RawData()
	directeur, has := camp.GetDirecteur()
	if !has {
		c.main.ShowError(fmt.Errorf("<i>Aucun directeur</i> n'est enregistré sur le séjour %s!", rawCamp.Label()))
		return
	}
	rawDirecteur := directeur.RawData()
	albumid := string(rawCamp.JoomeoAlbumId)
	if albumid == "" {
		c.main.ShowError(fmt.Errorf("Aucun album Joomeo n'est associé au %s !", rawCamp.Label()))
		return
	}
	msg := fmt.Sprintf("Confirmer l'ajout de <b>%s</b> comme uploader sur l'album <i>%s</i> ?",
		rawDirecteur.Mail, albums[albumid].Label)
	rep := c.Onglet.ConfirmeAjoutDirecteurJoomeo(msg)
	if rep == 0 {
		c.main.ShowStandard("Ajout annulé", false)
		return
	}
	envoi_mail := rep == rd.OBOui

	api, err := c.getJoomeoApi()
	if err != nil {
		c.main.ShowError(err)
		return
	}
	contact, err := api.AjouteDirecteur(albumid, string(rawDirecteur.Mail), envoi_mail)
	if err != nil {
		c.main.ShowError(err)
		return
	}
	c.main.ShowStandard(fmt.Sprintf("Directeur ajouté. Login : %s, password : %s",
		contact.Login, contact.Password), false)

	if err = api.EleveSuperContact(contact.ContactId); err != nil {
		c.main.ShowError(fmt.Errorf("Le directeur a bien été ajouté comme <b>contact</b>. "+
			"En revanche, l'attribution du <b>droit de suppression</b> a échoué. <br/> <i>Détails : %s</i>", err))
		return
	}
	c.main.ShowStandard("Le directeur a maintenant le droit de suppression des fichiers pour son album.", false)
}

// ------------------------------ suppression sécurisée d'un camp ------------------------------

// renvoie `nil` si le camp peut être supprimé,
// en considérant les tables participants, equipiers, participants simples
func (c *SuiviCamps) checkSupprimeCamp(idCamp int64) error {
	for id := range c.Base.Participants {
		if ac := c.Base.NewParticipant(id); ac.GetCamp().Id == idCamp {
			return fmt.Errorf("Le participant %s est lié au camp à supprimer.", ac.GetPersonne().RawData().NomPrenom())
		}
	}
	for id := range c.Base.Participantsimples {
		if ac := c.Base.NewParticipantsimple(id); ac.GetCamp().Id == idCamp {
			return fmt.Errorf("Le participant %s est lié au camp à supprimer.", ac.GetPersonne().RawData().NomPrenom())
		}
	}
	for id := range c.Base.Equipiers {
		if ac := c.Base.NewEquipier(id); ac.GetCamp().Id == idCamp {
			return fmt.Errorf("L'équipier %s est lié au camp à supprimer.", ac.GetPersonne().RawData().NomPrenom())
		}
	}
	return nil
}

// SupprimeCamp vérifie que le camp courant n'est pas utilisé et le supprime.
func (c *SuiviCamps) SupprimeCamp() {
	camp := c.Etat.CampCurrent
	if camp == nil {
		return // ne devrait pas arriver si le GUI est correct
	}
	err := c.checkSupprimeCamp(camp.Int64())
	if err != nil {
		c.main.ShowError(err)
		return
	}
	if !c.Onglet.ConfirmeSupprimeCamp(c.Base.NewCamp(camp.Int64())) {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteCampOut
		err = requete(apiserver.UrlCamps, http.MethodDelete, IdAsParams(camp.Int64()), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteCampOut)
		delete(c.Base.Camps, camp.Int64())
		for _, idDoc := range out.IdsDocuments {
			delete(c.Base.Documents, idDoc)
			delete(c.Base.DocumentCamps, idDoc)
		}
		for _, idGroupe := range out.IdsGroupes {
			delete(c.Base.Groupes, idGroupe)
			delete(c.Base.GroupeContraintes, idGroupe)
		}
		c.Etat.CampCurrent = nil
		c.main.ShowStandard("Camp supprimé avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Suppression du camp...", true)
	c.main.Background.Run(job, onSuccess)
}

// CalculeNuitees renvoie le nombre de nuitées pour le séjour donné,
// en séparant les adultes des enfants.
// Un séjour proposant une option journée renvoie `0` enfants
func (c SuiviCamps) CalculeNuitees(camp dm.AccesCamp) (nbEnfants, nbAdultes int) {
	var all []interface {
		GetPresence() rd.Plage
		AgeDebutCamp() rd.AgeDate
	}
	for _, part := range camp.GetEquipe(nil) {
		all = append(all, part)
	}
	if camp.RawData().OptionPrix.Active != rd.OptionsPrix.JOUR {
		// dans ce cas, il n'y a pas de nuitées
		for _, part := range camp.GetInscrits(nil) {
			all = append(all, part)
		}
	}
	for _, part := range camp.GetParticipantsimples(nil) {
		all = append(all, part)
	}

	for _, part := range all {
		days := part.GetPresence().NbJours()
		nuitees := 0
		if days >= 1 {
			nuitees = days - 1 // car days inclut le départ et l'arrivée
		}
		age := part.AgeDebutCamp().Age()
		if age >= 13 {
			nbAdultes += nuitees
		} else {
			nbEnfants += nuitees
		}
	}
	return
}

func (c *SuiviCamps) SelectFacturesByCamp(idCamp int64) rd.Ids {
	var filtredIds rd.Ids
	cache, _ := c.Base.ResoudParticipants()
	for _, fac := range c.Base.Factures {
		camps, _ := c.Base.NewFacture(fac.Id).Camps(cache)
		if camps[idCamp] {
			filtredIds = append(filtredIds, fac.Id)
		}
	}
	return filtredIds
}

func (s *SuiviCamps) UrlSondages() string {
	endpoint := "/sondages/" + logs.KeyAdminSondages
	return Server.EndpointURL(endpoint)
}