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

package controllers

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"

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

	"github.com/benoitkugler/goACVE/server/core/utils/mails"

	"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)
}

func (c *SuiviDossiers) RenderAttestation() string {
	fac := c.Etat.FactureCurrent
	if fac == nil {
		c.main.ShowError(errors.New("Aucun dossier courant !"))
		return ""
	}
	b, err := documents.NewPresence(*fac).Render(nil)
	if err != nil {
		c.main.ShowError(fmt.Errorf("Impossible de générer l'attestation : %s", err))
		return ""
	}
	path := filepath.Join(LocalFolder, "attestation.pdf")
	if err = ioutil.WriteFile(path, b, os.ModePerm); err != nil {
		c.main.ShowError(fmt.Errorf("Impossible d'enregistrer l'attestation : %s", err))
		return ""
	}
	return path
}

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

func (c *SuiviDossiers) envoiSimpleMessage(fac dm.AccesFacture, messageKind rd.MessageKind) {
	message := rd.Message{
		IdFacture: fac.Id,
		Kind:      messageKind,
	}
	params := apiserver.NotifieMessageIn{Message: message}

	job := func() (interface{}, error) {
		var out apiserver.NotifieMessageOut
		err := Requete(apiserver.UrlNotifieMessages, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(apiserver.NotifieMessageOut)
		c.Base.Messages[out.Message.Id] = out.Message
		c.main.ShowStandard("Message envoyé avec succès.", false)
		c.Reset()
	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard("Envoi du message...", true)
	c.main.Background.Run(job, onSuccess)
}

// EnvoiAccuseReception affiche la prévisualisation
// de l'accusé de réception, puis transmet l'envoi au serveur (asynchrone).
func (c *SuiviDossiers) EnvoiAccuseReception(fac dm.AccesFacture, withRIB bool) {
	var detParts []mails.DetailsParticipant
	for _, part := range fac.GetDossiers() {
		detParts = append(detParts, part.GetDetailsMails())
	}
	var (
		labelVirement string
		pjs           []mails.PieceJointe
	)
	if withRIB {
		labelVirement = fac.LabelVirement()
		pjs = []mails.PieceJointe{documents.RIB{}}
	}
	dest, to := fac.GetDestinataire()
	pm := mails.NewParamsAccuseReception(detParts, fac.UrlEspacePerso(), labelVirement, fac.NeedAcompte(),
		mails.Contact{NomPrenom: dest.NomPrenom, Sexe: dest.Sexe})

	mailHtml := c.Onglet.PrevisualiseMail(pm, pjs, to)
	if mailHtml == "" {
		c.main.ShowStandard("Envoi de l'accusé de réception annulé", false)
		return
	}

	params := apiserver.ParamsEnvoiAccuseReception{
		Facture: fac.RawData(),
		Html:    mailHtml,
		WithRIB: withRIB,
		To:      to,
		Ccs:     fac.RawData().CopiesMails,
	}
	job := func() (interface{}, error) {
		var out rd.Facture
		err := Requete(apiserver.UrlMailsAccuseReception, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Facture)
		c.Base.Factures[out.Id] = out
		c.main.ShowStandard("Accusé de réception envoyé avec succès.", false)
		c.Reset()

	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard("Envoi de l'accusé de réception...", true)
	c.main.Background.Run(job, onSuccess)
}

// EnvoiFacture génère et envoie un mail avec une facture en pièce jointe (asynchrone)
// Si isRappel vaut `true`, le mail est simplifié.
func (c *SuiviDossiers) EnvoiFacture(fac dm.AccesFacture, isRappel bool) {
	var detParts []mails.DetailsParticipant
	for _, part := range fac.GetDossiers() {
		if part.RawData().Role.IsInscrit() {
			detParts = append(detParts, part.GetDetailsMails())
		}
	}
	if len(detParts) == 0 {
		c.main.ShowError(errors.New("Aucun participant n'est en liste principale !"))
		return
	}
	dest, to := fac.GetDestinataire()
	pm := mails.NewMetaFacture(detParts,
		mails.Contact{
			NomPrenom: dest.NomPrenom,
			Sexe:      dest.Sexe,
		}, isRappel)

	pjs := []mails.PieceJointe{documents.NewFacture(fac)}
	mailHtml := c.Onglet.PrevisualiseMail(pm, pjs, to)
	if mailHtml == "" {
		c.main.ShowStandard("Envoi de la facture annulé", false)
		return
	}
	params := apiserver.ParamsEnvoiFacture{
		Facture: fac.RawData(),
		Html:    mailHtml,
		To:      to,
		Ccs:     fac.RawData().CopiesMails,
	}
	job := func() (interface{}, error) {
		var out rd.Facture
		err := Requete(apiserver.UrlMailsFacture, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Facture)
		c.Base.Factures[out.Id] = out
		c.main.ShowStandard("Facture envoyée avec succès.", false)
		c.Reset()

	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard("Envoi de la facture...", true)
	c.main.Background.Run(job, onSuccess)
}

// EnvoiPlaceLiberee envoie un mail et modifie le rôle
func (c *SuiviDossiers) EnvoiPlaceLiberee(fac dm.AccesFacture, idParticipant int64, newRole rd.Role) {
	dest, to := fac.GetDestinataire()
	part := c.Base.NewParticipant(idParticipant)
	mailPart, mailContact := part.GetDetailsMails().Participant, mails.Contact{
		NomPrenom: dest.NomPrenom,
		Sexe:      dest.Sexe,
	}
	var pm mails.MailRenderer = mails.NewParamsPlaceLiberee(mailPart, mailContact)
	if newRole == rd.RoleInscrit {
		pm = mails.NewParamsConfirmePlaceLiberee(mailPart, mailContact)
	}
	mailHtml := c.Onglet.PrevisualiseMail(pm, nil, to)
	if mailHtml == "" {
		c.main.ShowStandard("Modification et notification annulées.", false)
		return
	}

	msg := "Envoi d'un mail de notification..."
	if newRole == rd.RoleInscrit {
		msg = "Passage en liste principale..."
	}
	params := apiserver.ParamsEnvoiAttenteToInscrits{
		IdFacture:     fac.Id,
		Html:          mailHtml,
		To:            to,
		Ccs:           fac.RawData().CopiesMails,
		IdParticipant: idParticipant,
		NewRole:       newRole,
	}
	job := func() (interface{}, error) {
		var out rd.Participant
		err := Requete(apiserver.UrlMailsToInscrits, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Participant)
		c.Base.Participants[out.Id] = out
		c.main.ShowStandard("Mail envoyé avec succès.", false)
		c.main.ResetAllControllers()

	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard(msg, true)
	c.main.Background.Run(job, onSuccess)
}

// EnvoiAttestations envoi les documents demandés par le champ `Attestations`
// de la facture
func (c *SuiviDossiers) EnvoiAttestations(fac dm.AccesFacture) {
	at := fac.RawData().Attestations
	if !at.Facture && !at.Presence {
		c.main.ShowError(errors.New("Aucune attestation n'est demandée pour ce dossier !"))
		return
	}
	bilan := fac.EtatFinancier(false)
	dest, to := fac.GetDestinataire()
	if at.Facture && !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
	}
	withFacture := at.Facture && bilan.IsAcquitte()
	withPresence := at.Presence
	if !withFacture && !withPresence {
		return
	}

	metaMails := mails.NewParamsAttestations(withPresence, withFacture, mails.Contact{
		NomPrenom: dest.NomPrenom,
		Sexe:      dest.Sexe,
	})

	var pjs []mails.PieceJointe
	metaFacture := documents.NewFacture(fac)
	metaPresence := documents.NewPresence(fac)
	if withFacture {
		pjs = append(pjs, metaFacture)
	}
	if withPresence {
		pjs = append(pjs, metaPresence)
	}
	mailHtml := c.Onglet.PrevisualiseMail(metaMails, pjs, to)
	if mailHtml == "" {
		c.main.ShowStandard("Envoi des attestations annulé.", false)
		return
	}

	params := apiserver.ParamsEnvoiAttestations{
		Facture:      fac.RawData(),
		Html:         mailHtml,
		To:           to,
		Ccs:          fac.RawData().CopiesMails,
		WithFacture:  withFacture,
		WithPresence: withPresence,
	}
	job := func() (interface{}, error) {
		var out rd.Facture
		err := Requete(apiserver.UrlMailsAttestations, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(rd.Facture)
		c.Base.Factures[out.Id] = out
		c.main.ShowStandard("Attestation(s) envoyée(s) avec succès.", false)
		c.Reset()

	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard("Envoi des attestations...", true)
	c.main.Background.Run(job, onSuccess)
}

func (c *SuiviDossiers) EnvoiRIB(fac dm.AccesFacture) {
	dest, to := fac.GetDestinataire()
	metaMails := mails.NewParamsEnvoiRIB(mails.Contact{
		NomPrenom: dest.NomPrenom,
		Sexe:      dest.Sexe,
	})

	pjs := []mails.PieceJointe{documents.RIB{}}

	mailHtml := c.Onglet.PrevisualiseMail(metaMails, pjs, to)
	if mailHtml == "" {
		c.main.ShowStandard("Envoi du RIB annulé.", false)
		return
	}

	params := apiserver.ParamsEnvoiRIB{
		Html: mailHtml,
		To:   to,
		Ccs:  fac.RawData().CopiesMails,
	}
	job := func() (interface{}, error) {
		var out string
		err := Requete(apiserver.UrlMailsRIB, http.MethodPost, params, &out)
		return out, err
	}
	onSuccess := func(_out interface{}) {
		out := _out.(string)
		c.main.ShowStandard(out, false)
		c.Reset()
	}
	if !c.main.Background.EnsureFree() {
		return
	}
	c.main.ShowStandard("Envoi du RIB...", true)
	c.main.Background.Run(job, onSuccess)
}

type envoiDocsHandler struct {
	onError   func(int, string)
	onSuccess func(int, rd.Facture)

	counter int
}

func (e *envoiDocsHandler) Write(p []byte) (int, error) {
	outFac := new(rd.Facture)
	if err := json.Unmarshal(p, outFac); err != nil {
		outErr := new(string)
		if err = json.Unmarshal(p, outErr); err != nil {
			return 0, err
		} else {
			e.onError(e.counter, *outErr)
		}
	} else {
		e.onSuccess(e.counter, *outFac)
	}
	e.counter += 1
	return len(p), nil
}

func (c *SuiviDossiers) FilterFactures(campId int64, factures rd.Table) []int64 {
	var filtredIds []int64
	for _, ac := range factures {
		f := ac.(dm.AccesFacture)
		isConcerned := false
		for _, doss := range f.GetDossiers() {
			if doss.GetCamp().Id == campId {
				isConcerned = true
			}
		}
		if isConcerned {
			filtredIds = append(filtredIds, f.Id)
		}
	}
	return filtredIds
}

type FacError struct {
	Fac, Err string
}

// EnvoiDocuments 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) EnvoiDocuments(campId int64, messagePerso string, filtredIds []int64, onError func(index int, err string),
	onSuccess func(index int, out rd.Facture)) (facErrors []FacError, err error) {
	camp := c.Base.Camps[campId]
	if len(filtredIds) == 0 {
		return nil, fmt.Errorf("Aucun dossier n'est concerné par le <i>%s</i> !", camp.Label())
	}
	params := apiserver.ParamsEnvoiDocuments{
		IdCamp:       campId,
		IdsFactures:  filtredIds,
		MessagePerso: messagePerso,
	}
	facErrors = []FacError{}
	writer := envoiDocsHandler{
		onError: func(i int, s string) {
			fac := c.Base.NewFacture(filtredIds[i])
			facErrors = append(facErrors, FacError{
				Fac: fac.GetResponsable().RawData().NomPrenom(),
				Err: s,
			})
			onError(i, s)
		},
		onSuccess: func(i int, facture rd.Facture) {
			onSuccess(i, facture)
		},
	}
	if err := RequestMonitor(apiserver.UrlMailsDocuments, http.MethodPost, params, &writer); err != nil {
		return nil, fmt.Errorf("Impossible de lancer l'envoi des mails : %s", err)
	}
	return facErrors, nil
}