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

package onglets

import (
	"errors"
	"fmt"
	"strconv"
	"strings"

	"github.com/benoitkugler/goACVE/client/GUI/onglets/notifications"

	"github.com/benoitkugler/goACVE/client/GUI/messages"
	"github.com/benoitkugler/goACVE/server/core/apiserver"

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

	"github.com/benoitkugler/goACVE/client/GUI/fields"
	"github.com/benoitkugler/goACVE/client/GUI/lists"

	"github.com/benoitkugler/goACVE/client/GUI/common"

	"github.com/benoitkugler/goACVE/client/GUI/basic"

	"github.com/therecipe/qt/core"

	"github.com/therecipe/qt/widgets"

	"github.com/benoitkugler/goACVE/client/controllers"
)

func (t *SuiviDossiers) Render() {
	t.dossiers.Model().SetData(t.controller.Liste)
	t.dossiers.SetSearch(t.controller.Etat.Recherche)
	t.updateSelection()

	t.acquite.SetData(t.controller.Etat.CritereAcquite)
	t.attente.SetData(string(t.controller.Etat.CritereAttente))
	t.camp.Update()
	t.camp.SetData(t.controller.Etat.CritereCamp)

	// on affiche une fois au démarrage les notifications
	if t.IsActif() && !t.hasShownNotifications {
		if t.controller.HasNotifications() {
			t.hasShownNotifications = true
			t.showNotifications()
		}
	}
}

func (t *SuiviDossiers) updateSelection() {
	if current := t.controller.Etat.FactureCurrent; current != nil {
		t.dossiers.SelectRow(current)
		t.fil.setMessages(t.controller.Base.NewFacture(current.Int64()).GetEtat(nil, nil).PseudoMessages(dm.POVCentre))
		t.fil.enableActions(true)
	} else {
		t.fil.setMessages(nil)
		t.fil.enableActions(false)
	}
}

func (t *SuiviDossiers) ConfirmeSupprimeFacture(html string) bool {
	return basic.Confirmation(html, "Supprimer", basic.ONDelete)
}

func (t *SuiviDossiers) ConfirmeMail(fac dm.AccesFacture, messageKind rd.MessageKind) bool {
	adresses := []string{fac.GetPersonne().RawData().Mail.String()}
	for _, adresse := range fac.RawData().CopiesMails {
		adresses = append(adresses, adresse)
	}
	message := fmt.Sprintf("Confirmez-vous l'envoi d'un mail <i>%s</i> à <br/> <b>%s</b> ? ", messageKind,
		strings.Join(adresses, ", "))
	return basic.Confirmation(message, "Envoyer", basic.ONAction)
}

func (t *SuiviDossiers) ConfirmeSupprimeMessages(nb int) bool {
	message := "Confirmez-vous la suppression du message ?"
	if nb > 1 {
		message = fmt.Sprintf("Confirmez-vous la suppression de %d messages ?", nb)
	}
	message += "<br/> Attention, cette opération est <b>irréversible</b>."
	return basic.Confirmation(message, "Supprimer", basic.ONDelete)
}

func (t *SuiviDossiers) ShowPreviewFacture(fac dm.AccesFacture) {
	d := basic.Dialog("Bilan financier")
	facHtml := basic.Label(fac.Description())
	facHtml.ConnectLinkActivated(func(link string) {
		id, err := strconv.Atoi(link)
		if err != nil {
			return
		}
		d.Reject()
		t.controller.Main().Controllers.Paiements.SelectPaiement(int64(id))
	})
	d.Layout().AddWidget(facHtml)
	d.Exec()
}

type SuiviDossiers struct {
	*widgets.QFrame
	controller *controllers.SuiviDossiers
	parent     *widgets.QTabWidget
	toolbar    *widgets.QToolBar

	dossiers lists.Table
	acquite  fields.Completion
	attente  fields.Enum
	camp     fields.Camp
	fil      fil

	hasShownNotifications bool
}

func newSuiviDossiers(ct *controllers.SuiviDossiers) *SuiviDossiers {
	p := SuiviDossiers{QFrame: basic.Frame(), controller: ct}

	p.dossiers = lists.Table{
		Liste: lists.Liste{
			SingleSelection: true,
			Headers:         ct.Header,
			Title:           "Dossiers",
			OnClick: func(acces rd.Item, _ int) {
				ct.Etat.FactureCurrent = acces.Id
				// on ne reset pas complètement pour éviter de perdre le click
				// ce qui empèche le double clic
				p.updateSelection()
				p.UpdateToolbar()
			},
			OnDoubleClick: func(acces rd.Item, _ int) {
				// dossier courant
				p.editDossier()
			},
			OnSearch: func(pattern string) {
				ct.Etat.Recherche = pattern
				ct.Reset()
			},
			OnSort: func(field rd.Field, reverse bool) {
				ct.Etat.CriteresTri = ct.Etat.CriteresTri.AddCritere(field, reverse)
				ct.Reset()
			},
			OnRightClick: func(acces rd.Item, pos *core.QPoint) {
				fac := ct.Base.NewFacture(acces.Id.Int64())
				menu := widgets.NewQMenu(p.dossiers)
				menu.AddAction("Afficher les paiements...").ConnectTriggered(func(_ bool) {
					p.ShowPreviewFacture(fac)
				})
				menu.AddSeparator()
				menu.AddAction("Copier le lien vers l'espace de suivi").ConnectTriggered(func(_ bool) {
					url := fac.RawData().UrlEspacePerso("/espace_perso")
					url = controllers.Server.EndpointURL(url)
					basic.Copy(url)
					ct.Main().ShowStandard("Lien : "+url, false)
				})
				menu.AddAction("Copier le label de virement").ConnectTriggered(func(_ bool) {
					label := fac.LabelVirement()
					basic.Copy(label)
					ct.Main().ShowStandard("Label du virement : "+label, false)
				})

				menu.AddSeparator()
				menu.AddAction("Aller au responsable").ConnectTriggered(func(_ bool) {
					ct.Main().Controllers.Personnes.SelectPersonne(fac.GetPersonne())
				})
				menu.AddSeparator()
				for _, doss := range fac.GetDossiers(nil) {
					resp, doss := doss.GetPersonne(), doss
					menu.AddAction("Aller au participant " + resp.RawData().NomPrenom().String()).ConnectTriggered(func(_ bool) {
						ct.Main().Controllers.Camps.SelectParticipant(doss)
					})
				}
				menu.AddSeparator()
				menu.AddAction("Fusionner vers ...").ConnectTriggered(func(bool) {
					p.fusionneDossier(fac)
				})
				p.dossiers.ShowContextMenu(menu, pos)
			},
		},
	}
	p.dossiers.Init()
	p.dossiers.HorizontalHeader().SetMinimumSectionSize(300)

	p.acquite = fields.NewCompletion(true)
	p.acquite.ConnectCurrentIndexChanged(func(_ int) {
		ct.Etat.CritereAcquite = p.acquite.GetData()
		ct.Reset()
	})
	p.attente = fields.NewEnum([]fields.Choice{
		{Field: string(controllers.Indifferent), Label: "Tous"},
		{Field: string(controllers.MasquerNoAttente), Label: "Avec participants en attente"},
		{Field: string(controllers.MasquerOnlyAttente), Label: "Avec participants inscrits"},
	}, true)
	p.attente.ConnectCurrentIndexChanged(func(_ int) {
		ct.Etat.CritereAttente = controllers.CritereAttente(p.attente.GetData())
		ct.Reset()
	})
	p.camp = fields.NewCamp(true, ct.Base, true)
	p.camp.ShowTerminated(false)
	p.camp.ConnectActivated(func(_ int) {
		var optId rd.OptionnalId
		if p.camp.GetData() != nil {
			optId = rd.NewOptionnalId(p.camp.GetData().Id)
		}
		ct.Etat.CritereCamp = optId
		ct.Reset()
	})
	showTerminated := widgets.NewQCheckBox2("Afficher les camps terminés", nil)
	showTerminated.ConnectClicked(func(checked bool) {
		p.camp.ShowTerminated(checked)
	})

	// options
	options := widgets.NewQFormLayout(nil)
	options.AddRow3("Choix du camp :", p.camp)
	options.AddRow5(showTerminated)
	options.AddRow3("Liste d'attente :", p.attente)
	options.AddRow3("Etat du règlement :", p.acquite)

	// bandeau du haut
	haut := widgets.NewQHBoxLayout()
	haut.AddWidget(p.dossiers, 3, 0)
	haut.AddLayout(options, 1)

	// fil de discussion
	p.fil = newFil(ct)
	p.fil.msgList.OnMessageGroupe = p.onMessageGroupe

	// final
	lay := widgets.NewQVBoxLayout2(p)
	lay.AddLayout(haut, 2)
	lay.AddWidget(p.fil, 3, 0)
	return &p
}

func (t *SuiviDossiers) creer() {
	dial := basic.Dialog2("Créer un dossier")

	choixRespo := fields.NewBoutonIdPersonne(true, t.controller.Base, false)

	listeP := lists.Table{
		Liste: lists.Liste{
			Headers:   lists.HeadersRechercheParticipants,
			Title:     "Participants à lier au dossier",
			MinHeight: 200,
		},
		HideHeaders: true,
	}
	listeP.OnAdd = func() {
		dial := lists.NewRechercheParticipant(t.controller.Base)
		dial.Exec()
		if dial.Out != nil {
			participant := t.controller.Base.NewParticipant(dial.Out.Int64())
			listeP.Model().SetData(append(listeP.Model().GetData(), participant.AsItem(nil)))
		}
	}
	listeP.OnDelete = func(_ rd.Item, index int) {
		listeP.Model().SetData(controllers.RemoveItem(listeP.Model().GetData(), index))
	}
	listeP.Init()

	valid := basic.Button("Créer le dossier")
	valid.SetObjectName(basic.ONAdd)
	valid.ConnectClicked(func(_ bool) {
		if choixRespo.GetData() == nil {
			basic.ShowError(errors.New("Veuillez choisir un <b>responsable</b> pour le dossier !"))
			return
		}
		dial.Accept()
	})
	lay := widgets.NewQFormLayout(dial)

	lay.AddRow(basic.Label("<b>Choix du responsable :</b>"), choixRespo)
	lay.AddRow5(listeP)
	lay.AddRow5(valid)

	if dial.Exec() == 0 {
		return
	}
	t.SetEnabled(false)
	t.controller.CreeFacture(choixRespo.GetData().Int64(), listeP.Model().GetData())
	t.SetEnabled(true)
}

func (t *SuiviDossiers) supprimer() {
	t.controller.SupprimeFacture()
}

func (t *SuiviDossiers) onMessageGroupe(idMessages rd.Ids) {
	idFactures := rd.NewSet()
	for _, idMessage := range idMessages {
		idFactures.Add(t.controller.Base.Messages[idMessage].IdFacture)
	}
	t.writeStreamMessages(idFactures.Keys())
}

func (t *SuiviDossiers) writeStreamMessages(idFactures rd.Ids) {
	contenu, keep := messages.EditMessage("", true, len(idFactures))
	if !keep {
		t.controller.Main().ShowStandard("Envoi annulé", false)
		return
	}

	dialog := messages.NewMonitor(len(idFactures))
	sender := common.NewMailsSender(nil)
	// mise en place des callbacks
	sender.Monitor.OnError = dialog.OnError
	sender.Monitor.OnSuccess = func(index int, out apiserver.NotifieManyOut) {
		t.controller.OnSuccesNotifieMessage(out)
		dialog.OnSuccess(index)
	}
	sender.OnFinished = dialog.ShowBilan

	job := func(monitor controllers.SendMessagesSignals) ([]controllers.DossierError, error) {
		return t.controller.EnvoiManyMessages(contenu, idFactures, monitor)
	}
	sender.SetupLaunch(job)
}

func (t *SuiviDossiers) envoiManyMessages() {
	ids := messages.SelectFactures(t.controller)
	if len(ids) == 0 {
		t.controller.Main().ShowStandard("Envoi annulé", false)
		return
	}
	t.writeStreamMessages(ids)
}

func (t *SuiviDossiers) envoiDocumentsCamp() {
	idCamp, resend, keep := messages.SelectCamp(t.controller.Base)
	if !keep {
		t.controller.Main().ShowStandard("Envoi annulé", false)
		return
	}

	ids := t.controller.SelectionneFacturesDocuments(idCamp, resend)
	if len(ids) == 0 {
		basic.ShowError(errors.New("Il n'y a aucun message à envoyer."))
		return
	}
	streamEnvoiDocuments(t.controller, idCamp, ids)
}

func streamEnvoiDocuments(ct *controllers.SuiviDossiers, idCamp int64, idsFactures rd.Ids) {
	// on vérifie que les envois ne sont pas verrouillés
	if err := ct.Base.NewCamp(idCamp).RawData().CheckEnvoisLock(); err != nil {
		basic.ShowError(err)
		return
	}

	dialog := messages.NewMonitor(len(idsFactures))
	sender := common.NewDocumentsSender(nil)
	// mise en place des callbacks
	sender.Monitor.OnError = dialog.OnError
	sender.Monitor.OnSuccess = func(index int, out apiserver.NotifieDocumentsOut) {
		ct.OnSuccesNotifieDocuments(out)
		dialog.OnSuccess(index)
	}
	sender.OnFinished = dialog.ShowBilan

	job := func(monitor controllers.SendDocumentsSignals) ([]controllers.DossierError, error) {
		return ct.EnvoiDocumentsCamp(idCamp, idsFactures, monitor)
	}
	sender.SetupLaunch(job)
}

func (t *SuiviDossiers) editDossier() {
	det := NewDetailsDossier(t.controller, common.MainWindow.StatusBar())
	det.Exec()
}

func (t *SuiviDossiers) fusionneDossier(fac dm.AccesFacture) {
	dial := basic.Dialog2("Fusionner deux dossiers")

	idTarget := fields.NewBoutonIdFacture(true, t.controller.Base)

	notifie := fields.NewBool(true)
	notifie.SetData(true) // cochée par défaut

	valid := basic.Button("Fusionner")
	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(bool) { dial.Accept() })

	valid.SetEnabled(false)
	idTarget.DataChanged = func() {
		valid.SetEnabled(idTarget.GetData() != nil)
	}

	lay := widgets.NewQFormLayout(dial)
	lay.AddRow3("Dossier vers lequel fusionner:", idTarget)
	lay.AddRow3("Notifier par mail", notifie)
	lay.AddRow5(valid)

	dial.SetMinimumWidth(500)
	if dial.Exec() == 0 {
		t.controller.Main().ShowStandard("Fusion annulée", false)
		return
	}
	params := apiserver.FusionneFacturesIn{
		From:    fac.Id,
		To:      idTarget.GetData().Int64(),
		Notifie: bool(notifie.GetData()),
	}
	t.controller.FusionneDossiers(params)
}

// ----------------------------- Alertes nouveaux messages / aides -----------------------------

func (t *SuiviDossiers) showNotifications() {
	aides, factures := t.controller.Notifications()

	d := basic.Dialog("Notifications")
	listAides := notifications.NewList()
	listFactures := notifications.NewList()
	for _, aide := range aides {
		aide := aide // variable in closure
		listAides.AddNotification(aide.Label(), func() {
			t.controller.Main().Controllers.Aides.SelectAide(aide)
		})
	}

	for _, facture := range factures {
		facture := facture // variable in closure
		isInscription := !facture.RawData().IsValidated
		label := facture.GetPersonne().RawData().NomPrenom().String()
		onLink := func() {
			t.controller.SelectFacture(facture)
		}
		if isInscription {
			label = "<i>(Nouvelle inscription)</i> " + label
			onLink = nil // on désactive le goTo
		}
		listFactures.AddNotification(label, onLink)
	}

	d.SetMinimumWidth(600)

	d.Layout().AddWidget(basic.Label(fmt.Sprintf("<b>Nouveaux messages (%d) :</b>", len(factures))))
	if len(factures) == 0 {
		d.Layout().AddWidget(basic.Label("<i>Aucun message en attente.</i>"))
	} else {
		d.Layout().AddWidget(listFactures)
	}

	d.Layout().AddWidget(basic.Label(fmt.Sprintf("<b>Aides déclarées et non vérifiées (%d) :</b>", len(aides))))
	if len(aides) == 0 {
		d.Layout().AddWidget(basic.Label("<i>Aucune aide en attente.</i>"))
	} else {
		d.Layout().AddWidget(listAides)
	}

	d.Show()
}

// ---------------------------------------------------------------------------------------------
// --------------------- Fiche de détails : facture + participants + aides ---------------------
// ---------------------------------------------------------------------------------------------

type widgetParticipant struct {
	*widgets.QFrame

	deleteButton *widgets.QPushButton
	label        *widgets.QLabel
	boutonOption *fields.OptionsFinanceParticipant
	aides        lists.Table
	editable     bool

	onDeleteAide      func(a rd.Item) bool
	onAjouteAide      func()
	onChangeOptions   func(rd.Remises, rd.OptionPrixParticipant)
	onGoToParticipant func(id int64)
}

func newWidgetParticipant(editable bool) *widgetParticipant {
	w := widgetParticipant{QFrame: basic.Frame(), editable: editable}
	w.SetObjectName("participant")
	lay := widgets.NewQGridLayout(w)
	w.label = basic.Label("")
	w.label.SetTextFormat(core.Qt__RichText)
	w.label.ConnectLinkActivated(func(link string) {
		if id, err := strconv.Atoi(link); err == nil {
			w.onGoToParticipant(int64(id))
		}
	})

	w.boutonOption = fields.NewOptionsFinanceParticipant(editable, "", nil, rd.Plage{})
	w.boutonOption.DataChanged = func() {
		w.onChangeOptions(w.boutonOption.GetData())
	}

	w.deleteButton = basic.Button("Supprimer")
	w.deleteButton.SetIcon(basic.Icons.Delete)
	w.deleteButton.SetObjectName(basic.ONDelete)
	w.deleteButton.SetEnabled(editable)

	w.aides = lists.Table{
		Liste: lists.Liste{
			Headers: []rd.Header{
				{Field: dm.AideStructure, Label: "Organisme"},
				{Field: dm.AideMontant, Label: "Montant"},
				{Field: dm.AideValide, Label: "Valide"},
			},
			MaxWidth:    600,
			MinHeight:   110,
			Placeholder: "Aucune aide n'est déclarée.",
		},
		ResizeToContents: true,
	}
	if editable {
		w.aides.OnAdd = func() {
			w.onAjouteAide() // variable a setup
		}
		w.aides.OnDelete = func(acces rd.Item, index int) {
			mustDelete := w.onDeleteAide(acces)
			if mustDelete {
				w.aides.Model().SetData(controllers.RemoveItem(w.aides.Model().GetData(), index))
			}
		}
	}
	w.aides.Init()

	w.label.SetWordWrap(true)
	w.label.SetMaximumWidth(400)
	lay.AddWidget2(w.label, 0, 0, 0)
	lay.AddWidget2(w.boutonOption, 1, 0, 0)
	lay.AddWidget2(w.deleteButton, 2, 0, 0)
	lay.AddWidget3(w.aides, 0, 1, 3, 2, 0)
	return &w
}

// met à jour les widgets
func (w *widgetParticipant) render(part dm.AccesParticipant) {
	camp := part.GetCamp().RawData()

	// label
	w.label.SetText(fmt.Sprintf("<i><a href='%d'>%s au %s</a></i>", part.Id, part.GetPersonne().RawData().NomPrenom(),
		camp.Label()))
	style := "padding: 2px;"
	if !part.RawData().ListeAttente.IsInscrit() {
		style += "background-color : " + dm.CouleurListeAttente.AHex()
	}
	w.label.SetStyleSheet(style)

	// options financières
	w.boutonOption.OptionPrixParticipant = fields.NewOptionPrixParticipant(w.editable, camp.OptionPrix.Active, camp.OptionPrix.Statut,
		rd.Plage{From: camp.DateDebut, To: camp.DateFin})
	w.boutonOption.SetData(part.RawData().Remises, part.RawData().OptionPrix)

	// aides
	partAides := part.GetAides(nil)
	data := make([]rd.Item, len(partAides))
	for index, aide := range partAides {
		data[index] = aide.AsItem()
	}
	w.aides.Model().SetData(data)
}

type DetailsDossier struct {
	*widgets.QDialog
	acces dm.AccesFacture

	ct           *controllers.SuiviDossiers
	statusBar    *widgets.QStatusBar
	scroll       *widgets.QScrollArea
	ficheFacture *common.FicheFacture
}

func NewDetailsDossier(ct *controllers.SuiviDossiers, mainStatusBar *widgets.QStatusBar) DetailsDossier {
	d := DetailsDossier{QDialog: basic.Dialog2("Détails du dossier"), ct: ct}
	lay := widgets.NewQGridLayout(d)
	idFac := ct.Etat.FactureCurrent
	if idFac == nil {
		lay.AddWidget2(basic.Label("Aucun dossier courant !"), 0, 0, 0)
		return d
	}
	d.acces = ct.Base.NewFacture(idFac.Int64())

	fac := common.NewFicheFacture(ct.Base, ct.EditRight)
	fac.SetLayout()
	fac.SetData(d.acces.RawData(), rd.NewOptionnalId(d.acces.GetPersonne().Id))
	d.ficheFacture = &fac

	valid := basic.ButtonEnregistrer()
	valid.ConnectClicked(func(_ bool) {
		if err := fac.Valid(); err != nil {
			basic.ShowError(err)
			return
		}
		d.UpdateFacture(fac.GetData())
	})
	d.scroll = widgets.NewQScrollArea(nil)
	d.scroll.SetMinimumHeight(500)

	ajoutPart := basic.Button("Ajouter un participant")
	ajoutPart.SetObjectName(basic.ONAction)
	ajoutPart.ConnectClicked(func(_ bool) { d.AjouteParticipant() })

	d.drawParticipants()

	valid.SetEnabled(ct.EditRight)
	ajoutPart.SetEnabled(ct.EditRight)

	d.SetMinimumWidth(800)
	lay.AddWidget3(fac, 0, 0, 2, 1, 0)
	lay.AddWidget2(valid, 2, 0, 0)
	lay.AddWidget2(basic.Label("Participants :"), 0, 1, 0)
	lay.AddWidget2(ajoutPart, 0, 3, 0)
	lay.AddWidget3(d.scroll, 1, 1, 2, 3, 0)

	lay.SetRowStretch(0, 1)
	lay.SetRowStretch(1, 4)
	lay.SetRowStretch(2, 4)
	lay.SetColumnStretch(0, 2)
	lay.SetColumnStretch(1, 3)

	d.statusBar = widgets.NewQStatusBar(nil)
	mainStatusBar.ConnectMessageChanged(func(message string) {
		d.statusBar.ShowMessage(message, 4000)
		d.statusBar.Repaint()
	})
	lay.AddWidget3(d.statusBar, 3, 0, 1, 4, 0)
	return d
}

func (d *DetailsDossier) drawParticipants() {
	parts := d.acces.GetDossiers(nil)
	f := basic.Frame()
	pLay := widgets.NewQFormLayout(f)
	for _, part := range parts {
		part := part // attention aux closures dans les boucles
		wPart := newWidgetParticipant(d.ct.EditRight)
		wPart.onDeleteAide = d.DeleteAide
		wPart.onAjouteAide = func() { d.AjouteAide(part) }
		wPart.onChangeOptions = func(remises rd.Remises, options rd.OptionPrixParticipant) {
			d.UpdateOptionsParticipant(part.RawData(), remises, options)
		}
		wPart.onGoToParticipant = func(id int64) {
			d.Close()
			d.ct.Main().ShowStandard("Modifications sur le dossier annulées.", false)
			d.ct.Main().Controllers.Camps.SelectParticipant(d.ct.Base.NewParticipant(id))
		}

		wPart.render(part)
		pLay.AddRow5(wPart)
		wPart.deleteButton.ConnectClicked(func(_ bool) { d.DeleteParticipant(part) })
	}
	d.scroll.SetWidget(f)
}

func (d *DetailsDossier) AjouteParticipant() {
	dial := lists.NewRechercheParticipant(d.ct.Base)
	dial.Exec()
	if dial.Out == nil {
		d.statusBar.ShowMessage("Ajout d'un participant annulé.", 3000)
		return
	}
	d.SetEnabled(false)
	defer d.SetEnabled(true)
	d.ct.AjouteParticipant(d.ct.Base.NewParticipant(dial.Out.Int64()))
	d.drawParticipants()
}

func (d *DetailsDossier) UpdateOptionsParticipant(part rd.Participant, remises rd.Remises, options rd.OptionPrixParticipant) {
	d.SetEnabled(false)
	defer d.SetEnabled(true)
	part.Remises = remises
	part.OptionPrix = options
	d.ct.UpdateParticipant(part)
	d.drawParticipants()
}

func (d *DetailsDossier) DeleteParticipant(part dm.AccesParticipant) {
	conf := basic.Dialog2("Confirmation")
	label := basic.Label(fmt.Sprintf(`Confirmez-vous la <b>suppression</b> de <b>%s</b> (%s) ?
		<br><br> 
		<i>Vous pouvez supprimer la participation ou seulement enlever le participant du dossier.</i>
		`, part.GetPersonne().RawData().NomPrenom(), part.GetCamp().RawData().Label()))

	buttonEnleve := basic.Button("Retirer du dossier")
	buttonEnleve.SetObjectName(basic.ONAction)
	buttonSupprime := basic.Button("Supprimer")
	buttonSupprime.SetObjectName(basic.ONDelete)

	var fullSupp bool
	buttonEnleve.ConnectClicked(func(_ bool) {
		conf.Accept()
	})
	buttonSupprime.ConnectClicked(func(_ bool) {
		fullSupp = true
		conf.Accept()
	})

	lay := widgets.NewQGridLayout(conf)
	lay.AddWidget3(label, 0, 0, 1, 3, 0)
	lay.AddWidget2(buttonSupprime, 1, 0, 0)
	lay.AddWidget2(buttonEnleve, 1, 2, 0)

	if conf.Exec() == 0 {
		d.statusBar.ShowMessage("Suppression annulée.", 3000)
		return
	}
	d.SetEnabled(false)
	defer d.SetEnabled(true)
	d.ct.RetireParticipant(part, fullSupp)
	d.drawParticipants()
}

func (d *DetailsDossier) DeleteAide(aide rd.Item) bool {
	dial := basic.Dialog("Confirmation")
	valid := basic.Button("Confirmer la suppression")
	valid.SetObjectName(basic.ONDelete)
	valid.ConnectClicked(func(_ bool) {
		dial.Accept()
	})
	dial.Layout().AddWidget(basic.Label("Etes-vous sur de vouloir supprimer l'aide ?"))
	dial.Layout().AddWidget(valid)
	if dial.Exec() == 0 {
		return false
	}
	d.ct.SupprimeAide(aide.Id.Int64())
	return true
}

func (d *DetailsDossier) AjouteAide(part dm.AccesParticipant) {
	aide := CreeAide(d.ct.Base, rd.NewOptionnalId(part.Id))
	if aide == nil {
		d.statusBar.ShowMessage("Ajout d'une aide annulé.", 3000)
		return
	}
	d.SetEnabled(false)
	defer d.SetEnabled(true)
	d.statusBar.ShowMessage("Ajout de l'aide...", 0)
	created := d.ct.AjouteAide(*aide)
	if created != nil {
		d.statusBar.ShowMessage("Aide ajoutée avec succès.", 5000)
		d.drawParticipants()
	}
}

func (d *DetailsDossier) UpdateFacture(rf rd.Facture) {
	d.SetEnabled(false)
	defer d.SetEnabled(true)
	d.Repaint()
	out := d.ct.UpdateFacture(rf)
	if out != nil {
		d.ficheFacture.SetData(rf, rd.NewOptionnalId(rf.IdPersonne))
	}
}