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

package controllers

import (
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"path/filepath"
	"sort"
	"strings"
	"time"

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

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

const (
	Indifferent CritereAttente = ""
	// n'affiche pas les dossiers uniquement composé d'inscrits
	MasquerNoAttente CritereAttente = "need_attente"
	// n'affiche pas les dossiers uniquement composé d'attentes
	MasquerOnlyAttente CritereAttente = "need_inscrit"
)

// SuiviDossiers implémentes des fonctionnalités de communication avec les familles.
type SuiviDossiers struct {
	Onglet    OngletSuiviDossiers
	main      *MainController
	Base      *dm.BaseLocale
	Etat      EtatSuiviDossiers
	EditRight bool // Droit de suppression/ajout/edition
	Liste     rd.Table
	Header    []rd.Header
}

type ButtonsSuiviDossiers struct {
	Creer, Supprimer, EnvoiDocuments, Alertes EtatSideButton
}

type OngletSuiviDossiers interface {
	baseOnglet

	ShowPreviewFacture(fac dm.AccesFacture)

	ConfirmeSupprimeFacture(html string) bool
	// PrevisualiseMail(mail mails.MailRenderer, pjs []mails.PieceJointe, to string) (mailHtml string)
	ConfirmeMail(fac dm.AccesFacture, messageKind rd.MessageKind) bool
	ConfirmeSupprimeMessages(nb int) bool
}

type CritereAttente string

type EtatSuiviDossiers struct {
	FactureCurrent rd.IId         // uniquement dossier
	MessageCurrent rd.OptionnalId // message affiché
	Recherche      string
	CriteresTri    dm.CriteresTri
	CritereCamp    rd.OptionnalId
	CritereAcquite rd.Completion
	CritereAttente CritereAttente
}

func NewSuiviDossiers(main *MainController, permission int) *SuiviDossiers {
	s := SuiviDossiers{main: main, Base: main.Base, EditRight: permission >= 2,
		Header: []rd.Header{
			{Field: dm.PersonneNomPrenom, Label: "Responsable"},
			{Field: dm.FactureParticipants, Label: "Participants"},
			{Field: dm.FactureCamps, Label: "Camps"},
		}}
	s.resetData()
	return &s
}

func (c *SuiviDossiers) resetData() {
	cache := c.Base.NewCacheEtatFinancier()
	cache2 := c.Base.ResoudMessages()
	c.Liste = nil
	for id, rawFac := range c.Base.Factures {
		// on n'affiche uniquement les dossiers validés (et non les nouvelles inscriptions)
		if !rawFac.IsValidated {
			continue
		}

		acFac := c.Base.NewFacture(id)
		match := true
		if c.Etat.CritereCamp.IsNotNil() {
			camps, _ := acFac.Camps(cache.FParticipants)
			match = match && camps[c.Etat.CritereCamp.Int64]
		}
		if c.Etat.CritereAcquite != 0 {
			bilan := acFac.EtatFinancier(cache, false)
			match = match && (c.Etat.CritereAcquite == bilan.StatutPaiement())
		}
		var hasAtLeastOneAttente, hasAtLeastOneInscrit bool
		for _, part := range acFac.GetDossiers(cache.FParticipants) {
			if part.RawData().ListeAttente.IsInscrit() {
				hasAtLeastOneInscrit = true
			} else {
				hasAtLeastOneAttente = true
			}
		}
		switch c.Etat.CritereAttente {
		case MasquerNoAttente:
			match = match && hasAtLeastOneAttente
		case MasquerOnlyAttente:
			match = match && hasAtLeastOneInscrit
		}

		if match {
			c.Liste = append(c.Liste, acFac.AsItem(cache.FParticipants, cache2, cache.FPaiements))
		}
	}

	if strings.TrimSpace(c.Etat.Recherche) != "" {
		// on enlève les camp de la recherche pour éviter les faux positifs
		// (ex Grand)
		c.Liste = dm.RechercheDetaillee(c.Liste, c.Etat.Recherche, c.Header[0:2])
	}

	// besoin de déselectionner si absent de la Recherche :
	if c.Etat.FactureCurrent != nil && !HasId(c.Liste, c.Etat.FactureCurrent) {
		c.Etat.FactureCurrent = nil
	}

	dateDernierCamp := func(fac rd.Item) time.Time {
		camps, _ := c.Base.NewFacture(fac.Id.Int64()).Camps(cache.FParticipants)
		var last time.Time
		for idCamp := range camps {
			if dateDebut := c.Base.Camps[idCamp].DateDebut.Time(); last.Before(dateDebut) {
				last = dateDebut
			}
		}
		return last
	}

	// on tri systématiquement par date de séjour, avant
	// de considérer les critères utilisateurs
	sort.Slice(c.Liste, func(i, j int) bool {
		di := dateDernierCamp(c.Liste[i])
		dj := dateDernierCamp(c.Liste[j])
		return di.After(dj) // plus récent en haut
	})
	// s'il n'y a pas de critère, c'est un tri par Id, à éviter
	if len(c.Etat.CriteresTri.Fields) > 0 {
		dm.SortCriteres(c.Liste, c.Etat.CriteresTri)
	}
}

func (c *SuiviDossiers) SideButtons() ButtonsSuiviDossiers {
	bs := ButtonsSuiviDossiers{}
	isActif := ButtonActivated
	if c.Etat.FactureCurrent == nil {
		isActif = ButtonPresent
	}
	if c.EditRight {
		bs.Supprimer = isActif
		bs.Creer = ButtonActivated
		bs.EnvoiDocuments = ButtonActivated
	}
	bs.Alertes = ButtonActivated
	return bs
}

func (c *SuiviDossiers) CreeFacture(idResponsable int64, participants rd.Table) {
	currentsFac := c.Base.Factures
	idParts := make(rd.Ids, 0, len(participants))
	// on vérifie que les participants ne sont pas déjà "attribués"
	for _, partItem := range participants {
		part := c.Base.NewParticipant(partItem.Id.Int64())
		if idF := part.RawData().IdFacture; idF.IsNotNil() {
			if _, isIn := currentsFac[idF.Int64]; isIn {
				c.main.ShowError(fmt.Errorf("Le participant %s (%s) est déjà associé à une facture !",
					part.GetPersonne().RawData().NomPrenom(), part.GetCamp().RawData().Label()))
				return
			}
		}
		idParts = append(idParts, part.Id)
	}

	params := apiserver.CreateFactureIn{IdResponsable: idResponsable, IdParticipants: idParts}
	c.main.ShowStandard("Création du dossier...", true)
	var out apiserver.CreateFactureOut
	err := requete(apiserver.UrlFactures, http.MethodPut, params, &out)
	if err != nil {
		c.main.ShowError(err)
		return
	}

	c.Base.Factures[out.Facture.Id] = out.Facture
	for _, part := range out.Participants {
		c.Base.Participants[part.Id] = part
	}
	c.Base.Messages[out.Message.Id] = out.Message
	c.Etat.FactureCurrent = rd.IdFacture(out.Facture.Id)
	c.main.ShowStandard("Dossier créé avec succès.", false)
	c.main.ResetAllControllers()
	c.ResetRender()
}

// UpdateFacture met à jour de manière synchrone la facture donnée.
func (c *SuiviDossiers) UpdateFacture(fac rd.Facture) *rd.Facture {
	c.main.ShowStandard("Mise à jour du dossier...", true)
	out := new(rd.Facture)
	err := requete(apiserver.UrlFactures, http.MethodPost, fac, out)
	if err != nil {
		c.main.ShowError(err)
		return nil
	}
	c.Base.Factures[out.Id] = *out
	c.main.ShowStandard("Dossier mis à jour avec succès.", false)
	c.Reset()
	return out
}

// SupprimeFacture supprime la facture courante sur le serveur, après confirmation.
func (c *SuiviDossiers) SupprimeFacture() {
	if c.Etat.FactureCurrent == nil {
		return
	}
	fac := c.Base.NewFacture(c.Etat.FactureCurrent.Int64())
	paiements, participants := fac.GetPaiements(nil, true), fac.GetDossiers(nil)
	msg := fmt.Sprintf("Confirmez-vous la suppression du dossier %s ? <br/>", fac.GetPersonne().RawData().NomPrenom())
	if len(paiements) > 1 {
		msg += fmt.Sprintf("<i>%d</i> paiements associés seront <b>supprimés</b>!<br/>", len(paiements))
	} else if len(paiements) == 1 {
		msg += "un paiement associé sera <b>supprimé</b>!<br/>"
	}
	if len(participants) > 1 {
		msg += fmt.Sprintf("%d participants sont liés à ce dossier et seront déliés (mais non supprimés). <br/>", len(participants))
	} else if len(participants) == 1 {
		msg += "un participant est lié à ce dossier et sera délié (mais non supprimé). <br/>"

	}
	msg += "Attention, l'espace personnel associé sera <b>détruit</b> !"

	if !c.Onglet.ConfirmeSupprimeFacture(msg) {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out apiserver.DeleteFactureOut
		err := requete(apiserver.UrlFactures, http.MethodDelete, IdAsParams(fac.Id), &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.DeleteFactureOut)
		for _, idPaiement := range out.DeletedPaiements {
			delete(c.Base.Paiements, idPaiement)
		}
		for id, part := range out.Participants {
			c.Base.Participants[id] = part
		}
		c.Base.DeleteFacture(fac.Id)
		msg = fmt.Sprintf("Facture bien supprimée.")
		if L := len(out.DeletedPaiements); L > 0 {
			msg += fmt.Sprintf(" %d paiement(s) lié(s) aussi supprimé(s).", L)
		}
		c.main.ShowStandard(msg, false)
		c.main.ResetAllControllers()
	}

	c.Etat.FactureCurrent = nil
	c.main.ShowStandard("Suppression du dossier en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

// AjouteParticipant ajoute le participant à la facture courante.
func (c *SuiviDossiers) AjouteParticipant(participant dm.AccesParticipant) *dm.AccesParticipant {
	if c.Etat.FactureCurrent == nil {
		return nil
	}

	raw := participant.RawData()
	if !raw.IdFacture.IsNil() {
		c.main.ShowError(fmt.Errorf("Le participant %s (%s) est déjà lié à un dossier !",
			participant.GetPersonne().RawData().NomPrenom(), participant.GetCamp().RawData().Label()))
		return nil
	}
	idFac := c.Etat.FactureCurrent.Int64()
	raw.IdFacture = rd.NewOptionnalId(idFac)
	return c.main.Controllers.Camps.UpdateParticipant(raw)
}

// UpdateParticipant est synchrone
func (c *SuiviDossiers) UpdateParticipant(participant rd.Participant) {
	c.main.Controllers.Camps.UpdateParticipant(participant)
}

// RetireParticipant enlève le participant donné de la facture courante, de manière SYNCHRONE.
// Si `supprime` vaut true, le participant est supprimé.
func (c *SuiviDossiers) RetireParticipant(participant dm.AccesParticipant, supprime bool) {
	if supprime {
		c.main.Controllers.Camps.SupprimeParticipant(participant, true)
		return
	}
	raw := participant.RawData()
	raw.IdFacture = rd.OptionnalId{}
	c.main.Controllers.Camps.UpdateParticipant(raw)
}

// AjouteAide est synchrone. Gère l'erreur et renvoi nil.
func (c *SuiviDossiers) AjouteAide(aide rd.Aide) *rd.Aide {
	created, err := JobCreeAide(aide)
	if err != nil {
		c.main.ShowError(err)
		return nil
	}
	c.Base.Aides[created.Id] = created
	return &created
}

// UpdateAide est synchrone
func (c *SuiviDossiers) UpdateAide(aide rd.Aide) {
	c.main.Controllers.Aides.UpdateAide(aide)
}

// SupprimeAide est asynchrone
func (c *SuiviDossiers) SupprimeAide(aide int64) {
	c.main.Controllers.Aides.SupprimeAide(aide)
}

// SelectFacture sélectionne la facture donnée. Si nécessaire,
// remet à zéro les critères.
func (c *SuiviDossiers) SelectFacture(fac dm.AccesFacture) {
	if _, isIn := c.Base.Factures[fac.Id]; !isIn {
		c.main.ShowError(fmt.Errorf("Le dossier demandé (id %d) n'est pas présent dans la base !", fac.Id))
		return
	}

	c.Etat.FactureCurrent = rd.IdFacture(fac.Id)
	if !HasId(c.Liste, c.Etat.FactureCurrent) { // restreint l'affichage pour des raisons de performances
		pers := fac.GetPersonne().RawData()
		c.Etat.Recherche = pers.NomPrenom().String()
		c.Etat.CritereAcquite = 0
		c.Etat.CritereCamp = rd.NullId()
		c.resetData()
	}
	c.Onglet.GrabFocus()
	c.ResetRender()
}

// GenereExportDocument génère la facture au format .pdf, l'enregistre dans local,
// et renvoie le chemin.
// Les aides et paiements invalides ne sont pas affichés.
func (m *MainController) GenereExportDocument(meta documents.DynamicDocument) string {
	b, err := meta.Generate()
	if err != nil {
		m.ShowError(fmt.Errorf("Erreur pendant la génération du document : %s", err))
		return ""
	}
	path, err := filepath.Abs(filepath.Join(LocalFolder, meta.FileName()))
	if err != nil {
		m.ShowError(fmt.Errorf("Impossible d'enregistrer le document: %s", err))
		return ""
	}
	if err = ioutil.WriteFile(path, b, 0666); err != nil {
		m.ShowError(fmt.Errorf("Impossible d'enregistrer le document: %s", err))
		return ""
	}
	m.ShowStandard(fmt.Sprintf("Document généré dans %s", path), false)
	return path
}

func (c *SuiviDossiers) RenderAttestation() string {
	id := c.Etat.FactureCurrent
	if id == nil {
		c.main.ShowError(errors.New("Aucun dossier courant !"))
		return ""
	}
	fac := c.Base.NewFacture(id.Int64())
	meta := documents.Presence{
		Destinataire: fac.GetPersonne().RawData().ToDestinataire(),
		// on ne sélectionne pas la liste d'attente
		Participants: fac.EtatFinancier(dm.CacheEtatFinancier{}, false).Participants,
	}
	path := c.Main().GenereExportDocument(meta)
	return path
}

func (c *SuiviDossiers) HasNotifications() bool {
	a, f := c.Notifications()
	return len(a)+len(f) > 0
}

// Notifications renvoie les messages non lus et les aides déclarées
// sur les espaces persos.
func (c *SuiviDossiers) Notifications() ([]dm.AccesAide, []dm.AccesFacture) {
	var aides []dm.AccesAide
	for _, aide := range c.Base.Aides {
		if !aide.Valide {
			aides = append(aides, c.Base.NewAide(aide.Id))
		}
	}
	sort.Slice(aides, func(i, j int) bool { // force l'idempotance
		return aides[i].Id < aides[j].Id
	})
	sort.SliceStable(aides, func(i, j int) bool {
		di := aides[i].GetParticipant().GetCamp().RawData().DateDebut.Time()
		dj := aides[j].GetParticipant().GetCamp().RawData().DateDebut.Time()
		return di.After(dj) // camp les plus récent au début
	})
	idsFactures := rd.NewSet()
	factureToMessage := map[int64]rd.Message{} // on garde le message concerné pour trier
	for _, message := range c.Base.Messages {
		if message.Kind == rd.MResponsable && !message.Vu {
			// on ajoute le dossier correspondant
			idsFactures.Add(message.IdFacture)
			// si deux nouveaux messages appartiennent au même dossier,
			// on utilise le plus récent pour trier
			// dans la plupart des cas, currentMessage est zéro, et la condition est vraie
			if currentMessage := factureToMessage[message.Id]; message.Created.Time().After(currentMessage.Created.Time()) {
				factureToMessage[message.Id] = message
			}
		}
	}
	var factures []dm.AccesFacture
	for id := range idsFactures {
		factures = append(factures, c.Base.NewFacture(id))
	}
	sort.Slice(factures, func(i, j int) bool { // force l'idempotance
		return factures[i].Id < factures[j].Id
	})
	sort.SliceStable(factures, func(i, j int) bool {
		di := factureToMessage[factures[i].Id].Created.Time()
		dj := factureToMessage[factures[j].Id].Created.Time()
		return di.After(dj)
	})
	return aides, factures
}

// ImportMail extrait de la source du mail un Message
// L'expéditeur détermine le dossier
func (c *SuiviDossiers) ImportMail(source string) (importmail.Mail, rd.OptionnalId, error) {
	mail, err := importmail.NewMail(source)
	if err != nil {
		err = fmt.Errorf("Impossible de décoder l'email. Détails : <br/> <i>%v</i>", err)
		return mail, rd.NullId(), err
	}
	candidats := rd.NewSet()
	// on cherche l'adresse mail dans les responsables
	for idFacture := range c.Base.Factures {
		fac := c.Base.NewFacture(idFacture)
		if fac.GetPersonne().RawData().Mail.ToLower() == mail.From {
			candidats.Add(idFacture)
		}
	}
	// puis, si besoin, dans les mails en copie
	if len(candidats) == 0 {
		for _, fac := range c.Base.Factures {
			for _, mailCopie := range fac.CopiesMails {
				if strings.TrimSpace(strings.ToLower(mailCopie)) == mail.From {
					candidats.Add(fac.Id)
				}
			}
		}
	}
	// choix du plus récent
	cache1, cache2 := c.Base.ResoudMessages(), c.Base.ResoudPaiements()
	ids := candidats.Keys()
	sort.Slice(ids, func(i, j int) bool {
		fi, fj := c.Base.NewFacture(ids[i]), c.Base.NewFacture(ids[j])
		lastI, lastJ := fi.GetEtat(cache1, cache2).LastModified(), fj.GetEtat(cache1, cache2).LastModified()
		return lastI.Time().Before(lastJ.Time())
	})
	var idHint rd.OptionnalId
	if L := len(ids); L > 0 {
		idHint = rd.NewOptionnalId(ids[L-1])
	}
	return mail, idHint, nil
}

func (c *SuiviDossiers) CreateMessageResponsable(content rd.String, idRespo int64, imported importmail.Mail) {
	imported.Content = content.String()
	if imported.Received.IsZero() { // absent du mail -> on utilise la date courante (à modifier ?)
		imported.Received = time.Now()
	}
	message, contenu := imported.AsMessage(idRespo)
	params := apiserver.CreateMessageMessage{Message: message, MessageMessage: contenu}
	job := func() (interface{}, error) {
		var out apiserver.CreateMessageMessage
		err := requete(apiserver.UrlMessages, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.CreateMessageMessage)
		c.Base.Messages[out.Message.Id] = out.Message
		c.Base.MessageMessages[out.MessageMessage.IdMessage] = out.MessageMessage
		c.main.ShowStandard("Message ajouté avec succès.", false)
		c.Reset()
	}
	c.main.ShowStandard("Ajout du message en cours...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) FusionneDossiers(params apiserver.FusionneFacturesIn) {
	job := func() (interface{}, error) {
		var out apiserver.FusionneFacturesOut
		err := requete(apiserver.UrlFacturesFusion, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.FusionneFacturesOut)
		c.Base.ApplyFusionneFactures(out)
		c.main.ShowStandard("Dossier fusionné avec succés.", false)
		c.main.ResetAllControllers()
	}
	c.main.ShowStandard("Fusion du dossier...", true)
	c.main.Background.Run(job, onSuccess)
}