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

package controllers

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"time"

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

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

// Ce fichier définit les différents actions
// liées au suivi d'un dossier.

// AjoutePaiement ajoute le paiement au dossier courant.
func (c *SuiviDossiers) AjoutePaiement(paiement rd.Paiement) {
	if c.Etat.FactureCurrent == nil {
		c.main.ShowError(errors.New("Aucun dossier courant !"))
		return
	}
	c.main.Controllers.Paiements.CreePaiement(paiement)
}

// ------------------- Communication ------------------------------------------

func (c *SuiviDossiers) EnvoiMessageCentre(fac dm.AccesFacture, contenu rd.String) {
	if !c.Onglet.ConfirmeMail(fac, rd.MCentre) {
		c.main.ShowStandard("Envoi annulé", false)
		return
	}

	params := apiserver.NotifieMessageIn{IdFacture: fac.Id, Contenu: contenu}

	job := func() (interface{}, error) {
		var out apiserver.NotifieMessageOut
		err := requete(apiserver.UrlNotifieMessagePerso, http.MethodPut, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.NotifieMessageOut)
		c.Base.Messages[out.Message.Id] = out.Message
		c.Base.MessageMessages[out.MessageMessage.IdMessage] = out.MessageMessage
		c.main.ShowStandard("Message envoyé avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Envoi du message...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) EditMessageCentre(idMessages rd.Ids, contenu rd.String) {
	params := apiserver.EditMessageIn{IdMessages: idMessages, Contenu: contenu}
	job := func() (interface{}, error) {
		var out apiserver.EditMessageOut
		err := requete(apiserver.UrlNotifieMessagePerso, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.EditMessageOut)
		c.Base.ApplyEditMessage(out)
		c.main.ShowStandard("Message(s) modifié(s) avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Modifications du message...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) ToggleMessageVu(idMessage int64, vu bool) {
	params := c.Base.Messages[idMessage]
	params.Vu = vu
	job := func() (interface{}, error) {
		var out rd.Message
		err := requete(apiserver.UrlMessages, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Message)
		c.Base.Messages[out.Id] = out
		c.main.ShowStandard("Message modifié avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Modifications du message...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) SupprimeMessages(idMessages rd.Ids) {
	if !c.Onglet.ConfirmeSupprimeMessages(len(idMessages)) {
		c.main.ShowStandard("Suppression annulée", false)
		return
	}

	job := func() (interface{}, error) {
		var out rd.Messages
		err := requete(apiserver.UrlDeleteMessages, http.MethodPost, idMessages, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Messages)
		for _, message := range out {
			c.Base.Messages[message.Id] = message
			delete(c.Base.MessageAttestations, message.Id)
			delete(c.Base.MessageDocuments, message.Id)
			delete(c.Base.MessageSondages, message.Id)
			delete(c.Base.MessagePlaceliberes, message.Id)
			delete(c.Base.MessageMessages, message.Id)
		}
		c.main.ShowStandard("Message(s) supprimé(s) avec succès.", false)
		c.Reset()
	}

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

func (c *SuiviDossiers) envoiSimpleMessage(fac dm.AccesFacture, messageKind rd.MessageKind) {
	if !c.Onglet.ConfirmeMail(fac, messageKind) {
		c.main.ShowStandard("Envoi annulé", false)
		return
	}

	params := apiserver.NotifieSimple{IdFacture: fac.Id, Kind: messageKind}

	job := func() (interface{}, error) {
		var out rd.Message
		err := requete(apiserver.UrlNotifieMessage, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Message)
		c.Base.Messages[out.Id] = out
		c.main.ShowStandard("Message envoyé avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Envoi du message...", true)
	c.main.Background.Run(job, onSuccess)
}

// EnvoiAccuseReception envoie un mail de notification de manière ASYNCHRONE
func (c *SuiviDossiers) EnvoiAccuseReception(fac dm.AccesFacture) {
	c.envoiSimpleMessage(fac, rd.MAccuseReception)
}

func (c *SuiviDossiers) EnvoiFacture(fac dm.AccesFacture) {
	c.envoiSimpleMessage(fac, rd.MFacture)
}

// EnvoiPlaceLiberee envoie un mail et modifie le rôle
func (c *SuiviDossiers) EnvoiPlaceLiberee(fac dm.AccesFacture, idParticipant int64, newStatut rd.StatutAttente) {
	if !c.Onglet.ConfirmeMail(fac, rd.MPlaceLiberee) {
		c.main.ShowStandard("Envoi annulé", false)
		return
	}

	msg := "Envoi d'un mail de notification..."
	if newStatut == rd.Inscrit {
		msg = "Passage en liste principale..."
	}
	params := apiserver.NotifiePlaceLibereeIn{
		IdParticipant: idParticipant,
		NewStatut:     newStatut,
	}
	job := func() (interface{}, error) {
		var out apiserver.NotifiePlaceLibereeOut
		err := requete(apiserver.UrlNotifiePlaceLiberee, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.NotifiePlaceLibereeOut)
		c.Base.Participants[out.Participant.Id] = out.Participant
		c.Base.Messages[out.Message.Id] = out.Message
		c.Base.MessagePlaceliberes[out.Details.IdMessage] = out.Details
		c.main.ShowStandard("Mail envoyé avec succès.", false)
		c.main.ResetAllControllers()
	}

	c.main.ShowStandard(msg, true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) envoiAttestation(fac dm.AccesFacture, kind rd.MessageKind) {
	if !c.Onglet.ConfirmeMail(fac, kind) {
		c.main.ShowStandard("Envoi annulé", false)
		return
	}

	params := apiserver.NotifieAttestationIn{IdFacture: fac.Id, Kind: kind}

	job := func() (interface{}, error) {
		var out apiserver.NotifieAttestationOut
		err := requete(apiserver.UrlNotifieAttestation, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.NotifieAttestationOut)
		c.Base.Messages[out.Message.Id] = out.Message
		c.Base.MessageAttestations[out.MessageAttestation.IdMessage] = out.MessageAttestation
		c.main.ShowStandard("Attestation envoyée avec succès.", false)
		c.Reset()
	}

	c.main.ShowStandard("Envoi du message...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) EnvoiAttestationPresence(fac dm.AccesFacture) {
	for _, part := range fac.GetDossiers(nil) {
		if time.Now().Before(part.GetPresence().To.Time()) {
			msg := fmt.Sprintf("%s n'a pas encore terminé son séjour.", part.GetPersonne().RawData().NomPrenom())
			c.main.ShowError(errors.New(msg)) // on continue quand même
			break
		}
	}
	c.envoiAttestation(fac, rd.MAttestationPresence)
}

func (c *SuiviDossiers) EnvoiFactureAcquittee(fac dm.AccesFacture) {
	bilan := fac.EtatFinancier(dm.CacheEtatFinancier{}, false)
	if !bilan.IsAcquitte() {
		msg := "Une facture acquittée est demandée, mais les paiements sont insuffisants."
		c.main.ShowError(errors.New(msg)) // on continue quand même
	}
	c.envoiAttestation(fac, rd.MFactureAcquittee)
}

type streamHandler struct {
	idsDossiers rd.Ids // dossiers concernés
	base        *dm.BaseLocale
	counter     int            // index du dossier courant
	errors      []DossierError // enregistre les erreurs

	onError func(int, string)
}

// permet de suivre l'envoi de plusieurs messages
type envoiMessagesHandler struct {
	streamHandler
	onSuccess func(int, apiserver.NotifieManyOut)
}

// permet de suivre l'envoi des documents
type envoiDocsHandler struct {
	streamHandler
	onSuccess func(int, apiserver.NotifieDocumentsOut)
}

// permet de suivre l'envoi des sondages
type envoiSondagesHandler struct {
	streamHandler
	onSuccess func(int, apiserver.NotifieSondagesOut)
}

// out est la cible (spécialisée), qui doit être un pointer
func (e *streamHandler) onWrite(p []byte, out interface{}) (succeed bool, nb int, err error) {
	tmp := apiserver.StreamOut{Data: out}
	err = json.Unmarshal(p, &tmp)
	if err != nil {
		// erreur inatendue (et non erreur sur l'envoi)
		return false, 0, err
	}

	if tmp.Error != "" {
		// erreur attendue
		fac := e.base.NewFacture(e.idsDossiers[e.counter])
		e.errors = append(e.errors, DossierError{
			Fac: fac.GetPersonne().RawData().NomPrenom().String(),
			Err: tmp.Error,
		})
		e.onError(e.counter, tmp.Error)
	}
	e.counter += 1 // on met a jour la progression
	return tmp.Error == "", len(p), nil
}

func (e *envoiMessagesHandler) Write(p []byte) (int, error) {
	var notif apiserver.NotifieManyOut
	ok, nb, err := e.onWrite(p, &notif)
	if err != nil || !ok {
		// erreur inatendue ou erreur déjà gérée
		return nb, err
	}
	e.onSuccess(e.counter, notif)
	return nb, err
}

func (e *envoiDocsHandler) Write(p []byte) (int, error) {
	var notif apiserver.NotifieDocumentsOut
	ok, nb, err := e.onWrite(p, &notif)
	if err != nil || !ok {
		// erreur inatendue ou erreur déjà gérée
		return nb, err
	}
	e.onSuccess(e.counter, notif)
	return nb, err
}

func (e *envoiSondagesHandler) Write(p []byte) (int, error) {
	var notif apiserver.NotifieSondagesOut
	ok, nb, err := e.onWrite(p, &notif)
	if err != nil || !ok {
		// erreur inatendue ou erreur déjà gérée
		return nb, err
	}
	e.onSuccess(e.counter, notif)
	return nb, err
}

// func (c *SuiviDossiers) FilterFactures(idCamp int64, factures rd.Table) rd.Ids {
// 	var filtredIds rd.Ids
// 	cache, _ := c.Base.ResoudParticipants()
// 	for _, ac := range factures {
// 		for _, part := range c.Base.NewFacture(ac.Id.Int64()).GetDossiers(cache) {
// 			if part.GetCamp().Id == idCamp && part.RawData().ListeAttente.IsInscrit() {
// 				filtredIds = append(filtredIds, ac.Id.Int64())
// 				break
// 			}
// 		}
// 	}
// 	return filtredIds
// }

// DossierError résume l'erreur rencontrée
// pendant l'envoi de messages
type DossierError struct {
	Fac, Err string
}

type GUIMonitor interface {
	OnSuccess(index int)
	OnError(index int, err string)
}

// SendMessagesSignals groupe deux fonctions qui doivent
// émetter un signal, depuis le thread secondaire (worker) vers
// le thread principal.
type SendMessagesSignals struct {
	OnError   func(index int, err string)
	OnSuccess func(index int, out apiserver.NotifieManyOut)
}

func (c *SuiviDossiers) OnSuccesNotifieMessage(out apiserver.NotifieManyOut) {
	c.Base.Messages[out.Message.Id] = out.Message
	c.Base.MessageMessages[out.MessageMessage.IdMessage] = out.MessageMessage
	c.Reset()
}

// EnvoiManyMessages (monitor est créé dans le thread principal)
func (c *SuiviDossiers) EnvoiManyMessages(contenu rd.String, idsDossiers rd.Ids,
	monitor SendMessagesSignals) ([]DossierError, error) {

	if len(idsDossiers) == 0 {
		return nil, errors.New("Aucun dossier !")
	}
	params := apiserver.NotifieManyIn{
		Contenu:     contenu,
		IdsFactures: idsDossiers,
	}

	writer := envoiMessagesHandler{
		streamHandler: streamHandler{
			idsDossiers: idsDossiers,
			base:        c.Base,
			onError:     monitor.OnError,
		},
		onSuccess: monitor.OnSuccess,
	}

	if err := requestMonitor(apiserver.UrlNotifieMessagePersos, http.MethodPost, params, &writer); err != nil {
		return nil, fmt.Errorf("Erreur pendant l'envoi des messages : %s", err)
	}
	return writer.errors, nil
}

type SendDocumentsSignals struct {
	OnError   func(index int, err string)
	OnSuccess func(index int, out apiserver.NotifieDocumentsOut)
}

// SelectionneFacturesDocuments sélectionne automatiquement les dossiers concernés.
func (c *SuiviDossiers) SelectionneFacturesDocuments(idCamp int64, resend bool) rd.Ids {
	var filtredIds rd.Ids
	cache, _ := c.Base.ResoudParticipants()
	alreadySent := c.Base.GetFacturesSendDocuments(idCamp)
	for _, fac := range c.Base.Factures {
		resendOk := (resend || !alreadySent[fac.Id])
		for _, part := range c.Base.NewFacture(fac.Id).GetDossiers(cache) {
			if resendOk && part.GetCamp().Id == idCamp && part.RawData().ListeAttente.IsInscrit() {
				filtredIds = append(filtredIds, fac.Id)
				break
			}
		}
	}
	return filtredIds
}

func (c *SuiviDossiers) OnSuccesNotifieDocuments(out apiserver.NotifieDocumentsOut) {
	c.Base.Messages[out.Message.Id] = out.Message
	c.Base.MessageDocuments[out.MessageCamp.IdMessage] = out.MessageCamp
	c.Reset()
}

// EnvoiDocumentsCamp envois les documents du camp donné aux factures données.
// `onError` et `onSuccess` sont exécutées dans le même thread
// à la fin de chaque envoi effectué sur le serveur.
func (c *SuiviDossiers) EnvoiDocumentsCamp(campId int64, idsDossiers rd.Ids,
	monitor SendDocumentsSignals) (facErrors []DossierError, err error) {
	camp := c.Base.Camps[campId]
	if len(idsDossiers) == 0 {
		return nil, fmt.Errorf("Aucun dossier n'est concerné par le <i>%s</i> !", camp.Label())
	}
	params := apiserver.NotifieDocumentsIn{
		IdCamp:      campId,
		IdsFactures: idsDossiers,
	}

	writer := envoiDocsHandler{
		streamHandler: streamHandler{
			idsDossiers: idsDossiers,
			base:        c.Base,
			onError:     monitor.OnError,
		},
		onSuccess: monitor.OnSuccess,
	}
	if err := requestMonitor(apiserver.UrlNotifieDocuments, http.MethodPost, params, &writer); err != nil {
		return nil, fmt.Errorf("Erreur pendant l'envoi des messages : %s", err)
	}
	return writer.errors, nil
}

type SendSondagesSignals struct {
	OnError   func(index int, err string)
	OnSuccess func(index int, out apiserver.NotifieSondagesOut)
}

func (c *SuiviDossiers) OnSuccesNotifieSondages(out apiserver.NotifieSondagesOut) {
	c.Base.Messages[out.Message.Id] = out.Message
	c.Base.MessageSondages[out.MessageSondage.IdMessage] = out.MessageSondage
	c.Reset()
}

// EnvoiSondages envois les sondages du camp donné aux factures données.
// `onError` et `onSuccess` sont exécutées dans le même thread
// à la fin de chaque envoi effectué sur le serveur.
func (c *SuiviDossiers) EnvoiSondages(campId int64, idsDossiers rd.Ids,
	monitor SendSondagesSignals) (facErrors []DossierError, err error) {
	camp := c.Base.Camps[campId]
	if len(idsDossiers) == 0 {
		return nil, fmt.Errorf("Aucun dossier n'est concerné par le <i>%s</i> !", camp.Label())
	}
	params := apiserver.NotifieDocumentsIn{
		IdCamp:      campId,
		IdsFactures: idsDossiers,
	}

	writer := envoiSondagesHandler{
		streamHandler: streamHandler{
			idsDossiers: idsDossiers,
			base:        c.Base,
			onError:     monitor.OnError,
		},
		onSuccess: monitor.OnSuccess,
	}
	if err := requestMonitor(apiserver.UrlNotifieSondages, http.MethodPost, params, &writer); err != nil {
		return nil, fmt.Errorf("Erreur pendant l'envoi des messages : %s", err)
	}
	return writer.errors, nil
}

type PseudoMessage struct {
	dm.PseudoMessage

	// Ids des messages envoyé en même temps
	// (ex: documents, message groupés, sondages)
	Groupe rd.Ids
}

type key struct {
	kind rd.MessageKind
	time rd.Time
}

type CacheGroupes map[int64]rd.Ids

func (ct *SuiviDossiers) NewCacheGroupes() CacheGroupes {
	return resoudGroupeMessages(ct.Base.Messages)
}

func (c CacheGroupes) PromoteMessages(messages []dm.PseudoMessage) []PseudoMessage {
	out := make([]PseudoMessage, len(messages))
	for i, m := range messages {
		var groupe rd.Ids
		if m.Kind != rd.MPaiement {
			groupe = c[m.Id]
		}
		out[i] = PseudoMessage{PseudoMessage: m, Groupe: groupe}
	}
	return out
}

// on évite un cout quadratique; pour éviter des faux positifs
// on se restreint à certains catégories
func resoudGroupeMessages(messages rd.Messages) CacheGroupes {
	groupes := map[key]rd.Ids{}
	for _, message := range messages {
		switch message.Kind {
		case rd.MSondage, rd.MDocuments, rd.MCentre:
		default:
			continue
		}
		key := key{kind: message.Kind, time: message.Created}
		groupes[key] = append(groupes[key], message.Id)
	}
	out := map[int64]rd.Ids{} // id message -> id messages
	for _, groupe := range groupes {
		// on enlève les groupes de longeur 1, qui ne sont donc pas vraiment des groupes
		if len(groupe) <= 1 {
			continue
		}
		for _, idMessage := range groupe {
			out[idMessage] = groupe
		}
	}
	return out
}