github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/GUI/onglets/suivi_dossiers_fil.go

package onglets

import (
	"errors"
	"fmt"
	"path/filepath"

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

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/benoitkugler/goACVE/client/GUI/fields"
	"github.com/benoitkugler/goACVE/client/GUI/messages"
	"github.com/benoitkugler/goACVE/client/controllers"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	"github.com/benoitkugler/goACVE/server/core/documents"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/widgets"
)

type fil struct {
	*widgets.QFrame

	msgList     *messages.List
	fold        *widgets.QAction
	showDeleted *widgets.QAction

	btnActions   *widgets.QPushButton
	btnDocuments *widgets.QPushButton

	ct *controllers.SuiviDossiers
}

func newFil(ct *controllers.SuiviDossiers) fil {
	f := fil{QFrame: basic.Frame(), ct: ct}
	f.SetObjectName("cadre")

	f.msgList = messages.NewList(ct)

	options := widgets.NewQMenu(f)
	f.fold = options.AddAction("Déplier/Replier")
	f.fold.SetCheckable(true)
	f.fold.SetChecked(false)
	f.fold.ConnectTriggered(func(checked bool) {
		f.msgList.ToogleContent(!checked)
	})
	f.showDeleted = options.AddAction("Afficher/masquer les messages supprimés")
	f.showDeleted.SetCheckable(true)
	f.showDeleted.SetChecked(true)
	f.showDeleted.ConnectTriggered(func(checked bool) {
		f.msgList.ShowDeleted(checked)
	})

	f.SetContextMenuPolicy(core.Qt__CustomContextMenu)
	f.ConnectCustomContextMenuRequested(func(pos *core.QPoint) {
		options.Exec2(f.QWidget_PTR().MapToGlobal(pos), nil)
	})

	f.btnActions = basic.Button("Actions...")
	f.btnActions.SetObjectName(basic.ONAction)
	actions := widgets.NewQMenu(nil)
	f.setupActions(actions)
	f.btnActions.SetMenu(actions)

	f.btnDocuments = basic.Button("Documents...")
	actionsDocs := widgets.NewQMenu(nil)
	f.setupActionsDocs(actionsDocs)
	f.btnDocuments.SetMenu(actionsDocs)

	importMail := basic.Button("Importer un message...")
	importMail.SetIcon(basic.Icons.Mails)
	importMail.SetToolTip("Ajoute un message du responsable dans le fil de discussion.")
	importMail.ConnectClicked(func(_ bool) { f.importMail() })

	layoutMsg := widgets.NewQGridLayout(f)
	layoutMsg.AddWidget2(basic.Label("Fil de discussion"), 0, 0, 0)
	layoutMsg.AddWidget2(importMail, 0, 1, 0)
	layoutMsg.AddWidget2(f.btnActions, 0, 2, 0)
	layoutMsg.AddWidget2(f.btnDocuments, 0, 3, 0)
	layoutMsg.AddWidget3(f.msgList, 1, 0, 1, 4, 0)
	layoutMsg.SetColumnStretch(0, 1)
	layoutMsg.SetRowStretch(1, 1)
	return f
}

func (f fil) setupActions(menu *widgets.QMenu) {
	menu.AddAction("Nouveau message...").ConnectTriggered(func(_ bool) { f.nouveauMessage() })
	menu.AddSeparator()
	menu.AddAction("Envoyer un accusé de réception").ConnectTriggered(func(_ bool) { f.envoiAccuse() })
	menu.AddAction("Déclarer un accompte...").ConnectTriggered(func(_ bool) { f.declareAccompte() })
	menu.AddAction("Envoyer la facture").ConnectTriggered(func(_ bool) { f.envoiFacture() })
	menu.AddAction("Déclarer un paiement...").ConnectTriggered(func(_ bool) { f.declarePaiement() })
	menu.AddSeparator()
	menu.AddAction("Envoyer les documents...").ConnectTriggered(func(_ bool) { f.envoiDocuments() })
	menu.AddSeparator()
	menu.AddAction("Envoyer une facture acquittée").ConnectTriggered(func(_ bool) { f.envoiFactureAc() })
	menu.AddAction("Envoyer une attestation de présence").ConnectTriggered(func(_ bool) { f.envoiAttestationPres() })
}

func (f fil) setupActionsDocs(menu *widgets.QMenu) {
	menu.AddAction("RIB").ConnectTriggered(func(_ bool) { f.exportRIB() })
	menu.AddSeparator()
	menu.AddAction("Facture").ConnectTriggered(func(_ bool) { f.exportFacture() })
	menu.AddAction("Attestation de présence").ConnectTriggered(func(_ bool) { f.exportAttestionPresence() })
}

func (f fil) setMessages(messages []dm.PseudoMessage) {
	cache := f.ct.NewCacheGroupes()
	f.msgList.SetData(cache.PromoteMessages(messages))
	f.msgList.ToogleContent(!f.fold.IsChecked())
	f.msgList.ShowDeleted(f.showDeleted.IsChecked())
}

func (f fil) enableActions(actif bool) {
	f.btnActions.SetEnabled(actif)
	f.btnDocuments.SetEnabled(actif)
}

func (f fil) facture() (dm.AccesFacture, bool) {
	id := f.ct.Etat.FactureCurrent
	if id == nil {
		return dm.AccesFacture{}, false
	}
	return f.ct.Base.NewFacture(id.Int64()), true
}

func (f fil) nouveauMessage() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	contenu, ok := messages.EditMessage("", true, 0)
	if !ok {
		return
	}
	f.ct.EnvoiMessageCentre(fac, contenu)
}
func (f fil) envoiAccuse() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	f.ct.EnvoiAccuseReception(fac)

}
func (f fil) declareAccompte() {
	f.createPaiement(true)
}
func (f fil) envoiFacture() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	if fac.EtatFinancier(dm.CacheEtatFinancier{}, false).IsAcquitte() {
		b := basic.Confirmation("Le paiement pour ce dossier est complet. Ne voulez-vous pas plutôt envoyer une <b>facture acquittée</b> ?", "Envoyer quand même", basic.ONAction)
		if !b {
			return
		}
	}
	f.ct.EnvoiFacture(fac)
}

func (f fil) declarePaiement() {
	f.createPaiement(false)
}

func (f fil) envoiDocuments() {
	fac, ok := f.facture()
	if !ok {
		return
	}

	var camps []dm.AccesCamp
	idsCamps, _ := fac.Camps(nil)
	for idCamp := range idsCamps {
		camps = append(camps, fac.Base.NewCamp(idCamp))
	}

	d := basic.Dialog2("Choix du séjour")
	choixCamp := fields.NewCamp(true, fac.Base, false)
	choixCamp.SetChoices(camps)

	valid := basic.Button("Envoyer")
	valid.SetEnabled(false)
	choixCamp.ConnectCurrentIndexChanged(func(_ int) {
		valid.SetEnabled(choixCamp.GetData() != nil)
	})

	if len(camps) > 0 { // choix par défaut
		choixCamp.SetData(rd.NewOptionnalId(camps[0].Id))
	}

	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(_ bool) {
		d.Accept()
	})

	layout := widgets.NewQFormLayout(d)
	layout.AddRow3("Séjour", choixCamp)
	layout.AddRow5(valid)

	if d.Exec() == 0 {
		f.ct.Main().ShowStandard("Envoi annulé.", false)
		return
	}

	streamEnvoiDocuments(f.ct, choixCamp.GetData().Id, rd.Ids{fac.Id})
}

func (f fil) envoiFactureAc() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	f.ct.EnvoiFactureAcquittee(fac)
}
func (f fil) envoiAttestationPres() {
	fac, ok := f.facture()
	if !ok {
		basic.ShowError(errors.New("Aucun dossier n'est sélectionné."))
		return
	}
	f.ct.EnvoiAttestationPresence(fac)
}

// ------------- documents ------------------------------

func (f fil) exportRIB() {
	path, err := filepath.Abs(documents.PathRIB)
	if err != nil {
		basic.ShowError(err)
		return
	}
	basic.ShowFile(path)
}

func choixDestinataire(fac dm.AccesFacture) (rd.Destinataire, bool) {
	ds := fac.ChoixDestinataires()
	if len(ds) == 1 {
		return ds[0], true
	}
	// on propose le choix du destinataire

	d := basic.Dialog2("Choix du destinataire")

	choix := widgets.NewQComboBox(nil)
	for i, dest := range ds {
		label := fmt.Sprintf("%s (%s)", dest.NomPrenom, dest.Ville)
		if i == 0 {
			label += " - Responsable"
		}
		choix.AddItem(label, core.NewQVariant())
	}
	choix.SetCurrentIndex(0)

	valid := basic.Button("Valider")
	valid.ConnectClicked(func(_ bool) {
		d.Accept()
	})

	lay := widgets.NewQFormLayout(d)
	lay.SetVerticalSpacing(10)
	lay.AddRow5(basic.Label("Vous pouvez choisir un <b>destinataire</b> différent du responsable pour l'entête du document :"))
	lay.AddRow3("Destinataire", choix)
	lay.AddRow5(valid)

	ok := d.Exec() > 0
	out := ds[choix.CurrentIndex()]
	return out, ok
}

func (f fil) exportFacture() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	dest, ok := choixDestinataire(fac)
	if !ok {
		return
	}
	meta := documents.Facture{
		Destinataire: dest,
		Bilan:        fac.EtatFinancier(dm.CacheEtatFinancier{}, false),
	}
	path := f.ct.Main().GenereExportDocument(meta)
	if path != "" {
		basic.ShowFile(path)
	}
}

func (f fil) exportAttestionPresence() {
	fac, ok := f.facture()
	if !ok {
		return
	}
	dest, ok := choixDestinataire(fac)
	if !ok {
		return
	}
	meta := documents.Presence{
		Destinataire: dest,
		// on ne sélectionne pas la liste d'attente
		Participants: fac.EtatFinancier(dm.CacheEtatFinancier{}, false).Participants,
	}
	path := f.ct.Main().GenereExportDocument(meta)
	if path != "" {
		basic.ShowFile(path)
	}
}

func (f fil) createPaiement(isAcompte bool) {
	fac, ok := f.facture()
	if !ok {
		return
	}
	paie := CreePaiement(f.ct.Base, rd.NewOptionnalId(fac.Id), InitialPaiement{
		IsAcompte: isAcompte,
		// par défaut, le responsable, mais peut changer
		LabelPayeur: fac.GetPersonne().RawData().NomPrenom().String(),
	})
	if paie == nil {
		return
	}
	f.SetEnabled(false)
	f.Repaint()
	f.ct.AjoutePaiement(*paie)
	f.SetEnabled(true)
}

func (f fil) importMail() {
	dial := basic.Dialog2("Importer un message")

	content := fields.NewMultiLineString(true, "Message...")
	content.SetMinimumHeight(300)
	idRespo := fields.NewBoutonIdFacture(true, f.ct.Base)
	hint := basic.Label(`<i>Astuce :</i> Pour importer un email depuis <b>Thunderbird</b>, utiliser <br/>
la suite de raccourci <b>Ctrl + U</b>, <b>Ctrl + A</b>, <b>Ctrl + C</b>, <b>Ctrl + W</b>, 
puis cliquer sur le bouton <i>Charger depuis le presse-papier</i> ci-dessous.`)
	importMa := basic.Button("Charger depuis le presse-papier")
	valid := basic.Button("Valider")
	valid.SetEnabled(false)

	// condition de validation
	setValidEnabled := func() {
		isValid := content.GetData().TrimSpace() != "" && idRespo.GetData() != nil
		valid.SetEnabled(isValid)
	}
	content.ConnectTextChanged(setValidEnabled)
	idRespo.DataChanged = setValidEnabled

	var imported importmail.Mail
	importMa.ConnectClicked(func(_ bool) {
		rawMail := basic.Paste()
		imp, id, err := f.ct.ImportMail(rawMail)
		if err != nil {
			f.ct.Main().ShowError(err)
			return
		}
		content.SetData(rd.String(imp.Content))
		idRespo.SetData(id.AsIId())
		imported = imp
		setValidEnabled() // modification "interne"
		f.ct.Main().ShowStandard("Mail importé", false)
	})

	valid.ConnectClicked(func(_ bool) {
		// utilise les valeurs utilisateur
		f.ct.CreateMessageResponsable(content.GetData(), idRespo.GetData().Int64(), imported)
		dial.Accept()
	})

	// initialise avec le dossier courant, s'il existe
	if fc := f.ct.Etat.FactureCurrent; fc != nil {
		idRespo.SetData(fc)
	}

	layout := widgets.NewQFormLayout(dial)
	layout.AddRow3("Dossier", idRespo)
	layout.AddRow3("Contenu", content)
	layout.AddRow5(hint)
	rowButtons := widgets.NewQHBoxLayout()
	rowButtons.AddWidget(importMa, 1, 0)
	rowButtons.AddStretch(2)
	rowButtons.AddWidget(valid, 1, 0)
	layout.AddRow6(rowButtons)
	dial.Exec()
}