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

package onglets

import (
	"fmt"
	"strings"

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

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

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

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

	"github.com/therecipe/qt/core"

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/benoitkugler/goACVE/client/GUI/common"
	"github.com/benoitkugler/goACVE/client/controllers"
	"github.com/therecipe/qt/widgets"

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

func (c *Camps) Render() {
	c.camps.table.Model().SetData(c.controller.ListeCamps)
	if c.controller.Etat.CampCurrent != nil {
		c.camps.table.SelectRow(c.controller.Etat.CampCurrent)
	}
	c.inscrits.Model().SetData(c.controller.ListeInscrits)
	c.attente.Model().SetData(c.controller.ListeAttente)
	if idParticipant := c.controller.Etat.IdParticipant; idParticipant != nil {
		c.inscrits.SelectRow(idParticipant) // pas très subtil
		c.attente.SelectRow(idParticipant)  // mais pourquoi pas
	}
	c.stats.SetData(c.controller.GetStats())
	c.updateToInscrits()

	// on affiche une fois au démarrage les notifications
	if c.IsActif() && !c.hasShownNotifications {
		inscrits, attentes := c.controller.CheckListeAttentes()
		if len(attentes) > 0 { // les notifs inscrits sont moins importantes
			c.hasShownNotifications = true
			c.notifieAttentesExt(inscrits, attentes)
		}
	}
}

func (c *Camps) updateToInscrits() {
	var enabledToInscrit bool
	if idPart, ok := c.controller.Etat.IdParticipant.(rd.IdParticipant); ok {
		isInscrit := c.controller.Base.NewParticipant(idPart.Int64()).RawData().ListeAttente.IsInscrit()
		enabledToInscrit = !isInscrit
	}
	c.toInscrits.SetEnabled(enabledToInscrit)
}

func (c *Camps) ConfirmeNotifPlaceLiberee(info string) (keep bool, notifie bool) {
	d := basic.Dialog("Passage en liste principale")
	d.Layout().AddWidget(basic.Label(info))
	btnEnvoi := basic.Button("Envoyer un message")
	btnEnvoi.ConnectClicked(func(_ bool) {
		notifie = true
		d.Accept()
	})
	btnNoEnvoi := basic.Button("Ne pas notifier")
	btnNoEnvoi.ConnectClicked(func(_ bool) {
		notifie = false
		d.Accept()
	})

	btns := basic.Frame()
	btnsL := widgets.NewQHBoxLayout2(btns)
	btnsL.AddStretch(2)
	btnsL.AddWidget(btnNoEnvoi, 1, 0)
	btnsL.AddWidget(btnEnvoi, 1, 0)
	d.Layout().AddWidget(btns)
	keep = d.Exec() > 0
	return keep, notifie
}

func (c *Camps) ConfirmeAjoutParticipant(camp dm.AccesCamp, personne rd.Personne, causes []string) bool {
	msg := fmt.Sprintf("Confirmez-vous l'ajout de %s au %s ?", personne.NomPrenom(), camp.RawData().Label())
	if len(causes) > 0 {
		for i, cause := range causes {
			causes[i] = fmt.Sprintf("<b>%s</b>", cause)
		}
		msg += fmt.Sprintf(`<br/>Certaines conditions ne sont pas remplies : <br/> 
		<b>%s</b> <br/><br/>`, strings.Join(causes, "<br/>"))
	}
	return basic.Confirmation(msg, "Ajouter", basic.ONAdd)
}

func (c *Camps) ConfirmeSupprimeParticipant(msg string) bool {
	return basic.Confirmation(msg, "Supprimer", basic.ONDelete)
}

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

	camps             listeCamps
	inscrits, attente lists.Table
	stats             common.Statistics
	toInscrits        *widgets.QPushButton

	hasShownNotifications bool
}

func newCamps(ct *controllers.Camps) *Camps {
	p := Camps{QFrame: basic.Frame(), controller: ct}
	p.camps = newListeCamps(ct)
	p.inscrits = lists.Table{
		Liste: lists.Liste{
			Headers: ct.HeaderInscrits,
			OnClick: func(acces rd.Item, _ int) {
				p.onClick(acces, true)
			},
			OnDoubleClick: func(acces rd.Item, _ int) {
				p.onDoubleClick(acces)
			},
			OnRightClick: func(acces rd.Item, pos *core.QPoint) {
				p.onRightClick(acces, p.inscrits.MapToGlobal(pos))
			},
			OnSort: func(field rd.Field, reverse bool) {
				lists.DefaultSort(p.inscrits, field, reverse)
			},
		},
	}
	p.inscrits.Init()

	p.toInscrits = basic.Button("Passer en liste principale")
	p.toInscrits.SetObjectName(basic.ONAction)
	p.toInscrits.ConnectClicked(func(_ bool) {
		part := ct.Etat.IdParticipant
		if part == nil {
			return
		}
		ct.MoveToInscrits(part)
	})
	p.toInscrits.SetEnabled(false)

	rH := widgets.NewQHBoxLayout()
	rH.AddWidget(p.toInscrits, 1, 0)
	p.attente = lists.Table{
		Liste: lists.Liste{
			Headers: ct.HeaderAttente,
			OnClick: func(acces rd.Item, _ int) {
				p.onClick(acces, false)
			},
			OnDoubleClick: func(acces rd.Item, _ int) {
				p.onDoubleClick(acces)
			},
			Title:       "Liste d'attente",
			RightHeader: rH,
			OnRightClick: func(acces rd.Item, pos *core.QPoint) {
				p.onRightClick(acces, p.attente.MapToGlobal(pos))
			},
			OnSort: func(field rd.Field, reverse bool) {
				lists.DefaultSort(p.attente, field, reverse)
			},
		},
	}
	p.attente.Init()

	p.stats = common.NewStatistics(true)
	lay := widgets.NewQGridLayout(p)
	lay.AddLayout2(p.camps, 0, 0, 4, 1, 0)
	lay.AddWidget2(p.stats, 0, 1, 0)
	lay.AddWidget2(p.inscrits, 1, 1, 0)
	lay.AddWidget2(p.attente, 3, 1, 0)
	lay.SetColumnStretch(1, 4)
	lay.SetRowStretch(1, 3)
	lay.SetRowStretch(3, 2)
	return &p
}

func (c *Camps) onClick(acces rd.Item, fromInscrits bool) {
	c.controller.Etat.IdParticipant = acces.Id
	c.UpdateToolbar()
	c.updateToInscrits()
	if fromInscrits {
		c.attente.View.ClearSelection()
	} else {
		c.inscrits.View.ClearSelection()
	}
}

func (c *Camps) onDoubleClick(acces rd.Item) {
	if _, isSimple := acces.Id.(rd.IdParticipantsimple); isSimple {
		ac := c.controller.Base.NewParticipantsimple(acces.Id.Int64())
		modif := EditParticipantsimple(c.controller.Base, c.controller.ParticipantsRight, ac.RawData(),
			rd.NewOptionnalId(ac.GetPersonne().Id),
			rd.NewOptionnalId(ac.GetCamp().Id))
		if modif != nil {
			c.controller.UpdateParticipantsimple(*modif)
		}
	} else {
		ac := c.controller.Base.NewParticipant(acces.Id.Int64())
		modif := EditParticipant(c.controller.Base, c.controller.ParticipantsRight, ac.RawData(),
			rd.NewOptionnalId(ac.GetPersonne().Id), ac.GetCamp().Id)
		if modif != nil {
			c.controller.UpdateParticipant(*modif)
		}
	}
}

func (c *Camps) onRightClick(acces rd.Item, pos *core.QPoint) {
	var part dm.Inscrit
	switch id := acces.Id.(type) {
	case rd.IdParticipantsimple:
		part = c.controller.Base.NewParticipantsimple(id.Int64())
	case rd.IdParticipant:
		part = c.controller.Base.NewParticipant(id.Int64())
	default:
		return
	}
	menu := widgets.NewQMenu(c)
	ac := menu.AddAction("Aller à la personne")
	ac.ConnectTriggered(func(_ bool) {
		c.controller.Main().Controllers.Personnes.SelectPersonne(part.GetPersonne())
	})

	fac, has := part.GetFacture()
	if has {
		ac := menu.AddAction("Aller au dossier")
		ac.ConnectTriggered(func(_ bool) {
			c.controller.Main().Controllers.SuiviDossiers.SelectFacture(fac)
		})
	}
	menu.Exec2(pos, nil)
}

func (c *Camps) creerParticipant() {
	idCamp := c.controller.Etat.CampCurrent
	if idCamp == nil {
		return
	}
	camp := c.controller.Base.NewCamp(idCamp.Int64())
	if camp.RawData().InscriptionSimple {
		part := CreeParticipantsimple(c.controller.Base, rd.NewOptionnalId(camp.Id))
		if part != nil {
			c.controller.CreeParticipantsimple(*part)
		}
	} else {
		part := CreeParticipant(c.controller.Base, idCamp.Int64())
		if part != nil {
			c.controller.CreeParticipant(*part)
		}
	}
}

func (c *Camps) supprimerParticipant() {
	c.controller.SupprimeParticipantCourant()
}

func (c *Camps) changerParticipant() {
	dial := lists.NewRechercheCamp(c.controller.Base)
	dial.Exec()
	if dial.Out == nil {
		return
	}
	c.controller.ChangeCamp(dial.Out.Int64())
}
func (c *Camps) exporterParticipants() {
	dial := basic.Dialog2("Exporter les participants")
	lay := widgets.NewQFormLayout(dial)
	bus := fields.NewBus(true)

	triGroupe := widgets.NewQCheckBox(nil)
	withAttente := widgets.NewQCheckBox(nil)
	valid := basic.Button("Exporter")
	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(_ bool) {
		dial.Accept()
	})

	lay.AddRow3("Filtrer les trajets en bus", bus)
	lay.AddRow3("Trier par groupe", triGroupe)
	lay.AddRow3("Inclure la liste d'attente", withAttente)
	lay.AddRow5(valid)
	if dial.Exec() == 0 {
		return
	}
	path := c.controller.ExportParticipants(bus.GetData(), triGroupe.IsChecked(), withAttente.IsChecked())
	basic.ShowFile(path)
}

func (c *Camps) notifieAttentes() {
	inscrits, attentes := c.controller.CheckListeAttentes()
	c.notifieAttentesExt(inscrits, attentes)
}

func (c *Camps) notifieAttentesExt(inscrits, attentes []controllers.DiagnosticListeAttente) {
	notifAttentes, notifInscrits := notifications.NewList(), notifications.NewList()

	setupList := func(liste []controllers.DiagnosticListeAttente, target notifications.List) {
		for _, row := range liste {
			row := row // closure in loop
			part := row.Participant.RawData()
			text := fmt.Sprintf("<i>%s</i> - <a href>%s</b>: %s --> <b>%s</b>",
				row.Participant.GetCamp().RawData().Label(), row.Participant.GetPersonne().RawData().NomPrenom(),
				part.ListeAttente.Statut, row.Hint)
			target.AddNotification(text, func() {
				c.controller.SelectParticipant(row.Participant)
			})
		}
	}

	// le setup peut être visuellement bloquant
	basic.Delay(func() { setupList(inscrits, notifInscrits) })
	basic.Delay(func() { setupList(attentes, notifAttentes) })

	d := basic.Dialog("Notifications sur les listes d'attentes")
	d.Layout().AddWidget(basic.Label(`Les listes suivantes indiquent les participants pour lesquels
le statut actuel n'est pas celui conseillé (<i>actuel</i> --> <i>conseillé</i>).`))

	d.Layout().AddWidget(basic.Label("Participants sur <b>liste d'attente</b> :"))
	if len(attentes) == 0 {
		d.Layout().AddWidget(basic.Label("Aucune notification pour les listes d'attentes. <br/>"))
	} else {
		d.Layout().AddWidget(notifAttentes)
	}

	d.Layout().AddWidget(basic.Label("Participants sur <b>liste principale</b> :"))
	if len(inscrits) == 0 {
		d.Layout().AddWidget(basic.Label("Aucune notification pour les listes d'inscrits."))
	} else {
		d.Layout().AddWidget(notifInscrits)
	}

	d.Show() // non modal
}

// CreeParticipant propose la création d'un participant.
// En cas d'annulation, out vaut `nil`
func CreeParticipant(base *dm.BaseLocale, idCamp int64) *rd.Participant {
	return EditParticipant(base, true, rd.Participant{}, rd.OptionnalId{}, idCamp)
}

// CreeParticipantsimple propose la création d'un participant à un séjour simple.
// En cas d'annulation, out vaut `nil`
func CreeParticipantsimple(base *dm.BaseLocale, idCamp rd.OptionnalId) *rd.Participantsimple {
	return EditParticipantsimple(base, true, rd.Participantsimple{}, rd.OptionnalId{}, idCamp)
}

func EditParticipant(base *dm.BaseLocale, editable bool, participant rd.Participant,
	idPersonne rd.OptionnalId, idCamp int64) *rd.Participant {
	d := common.NewFicheParticipant(base, editable, idCamp)
	d.SetData(participant, idPersonne)
	dialog := common.NewDetails(d, editable)
	if dialog.Exec() == 0 {
		return nil
	}
	part := d.GetData()
	return &part
}

func EditParticipantsimple(base *dm.BaseLocale, editable bool, participant rd.Participantsimple,
	idPersonne rd.OptionnalId, idCamp rd.OptionnalId) *rd.Participantsimple {
	d := common.NewFicheParticipantsimple(base, editable)
	d.ActiveCamp(idCamp.IsNil())
	d.SetData(participant, idPersonne, idCamp)
	dialog := common.NewDetails(&d, editable)
	if dialog.Exec() == 0 {
		return nil
	}
	part := d.GetData()
	return &part
}

// ---------------------------- Liste détaillée ----------------------------
type listeCamps struct {
	*widgets.QVBoxLayout
	table lists.Table

	controller *controllers.Camps
}

func newListeCamps(ct *controllers.Camps) listeCamps {
	l := listeCamps{QVBoxLayout: widgets.NewQVBoxLayout(), controller: ct}
	l.table.Headers = []rd.Header{
		{Field: dm.CampLabel, Label: ""},
	}
	l.table.HideHeaders = true
	l.table.MaxWidth = 200
	l.table.OnRightClick = func(acces rd.Item, pos *core.QPoint) {
		menu := widgets.NewQMenu(l.table)
		acCamp := l.controller.Base.NewCamp(acces.Id.Int64())
		if directeur, has := acCamp.GetDirecteur(); has {
			ac := menu.AddAction("Aller au directeur")
			ac.ConnectTriggered(func(_ bool) {
				l.controller.Main().Controllers.Personnes.SelectPersonne(directeur)
			})
			ac = menu.AddAction("Envoyer un mail au directeur...")
			ac.ConnectTriggered(func(_ bool) {
				to := string(directeur.RawData().Mail)
				m := common.NewMailLibre(to, "")
				if m.Exec() == 0 {
					return
				}
				ct.Main().NotifieDirecteur(to, m.Text.ToHtml())
			})
			menu.AddSeparator()
		}
		ac := menu.AddAction("Détails...")
		ac.ConnectTriggered(func(_ bool) {
			l.editCamp(acces.Id.Int64())
		})
		ac = menu.AddAction("Documents du camp...")
		ac.ConnectTriggered(func(_ bool) {
			l.showDocuments(acces.Id.Int64())
		})
		ac = menu.AddAction("Suivi financier")
		ac.ConnectTriggered(func(_ bool) {
			path := l.controller.ExportSuiviFinancier(acces.Id.Int64())
			basic.ShowFile(path)
		})
		l.table.ShowContextMenu(menu, pos)
	}
	l.table.OnClick = func(acces rd.Item, _ int) {
		l.controller.Etat.CampCurrent = acces.Id
		l.controller.Reset()
	}
	l.table.Init()
	l.table.View.(*widgets.QTableView).VerticalHeader().SetSectionResizeMode(widgets.QHeaderView__ResizeToContents)

	// camps terminés
	cb := widgets.NewQCheckBox2("Afficher les camps terminés", nil)
	cb.SetChecked(l.controller.Etat.ShowCampsTerminated)
	cb.ConnectClicked(func(checked bool) {
		l.controller.Etat.ShowCampsTerminated = checked
		l.controller.Reset()
	})

	l.AddWidget(l.table, 4, 0)
	l.AddWidget(cb, 0, 0)
	return l
}

func (l *listeCamps) editCamp(id int64) {
	up := EditCamp(l.controller.CampsRight, true, false, l.controller.Base.Camps[id])
	if up == nil {
		return
	}
	l.controller.UpdateCamp(*up)
}

func EditCamp(editable, minimalEdit, enableInscriptionSimple bool, camp rd.Camp) *rd.Camp {
	fiche := common.NewFicheCamp(editable, minimalEdit, enableInscriptionSimple)
	fiche.SetData(camp)
	det := common.NewDetails(&fiche, editable)
	if det.Exec() == 0 {
		return nil
	}
	camp = fiche.GetData()
	return &camp
}

func (l *listeCamps) showDocuments(id int64) {
	dial := basic.Dialog("Documents")
	ac := l.controller.Base.NewCamp(id)
	if ac.RawData().Envois.Locked {
		dial.Layout().AddWidget(basic.Label("Attention, l'envoi des documents est encore <b>verrouillé</b>. <br/>" +
			"<i>Le directeur lèvera ce verrou une fois les documents prêts.</i>"))
	}
	list := common.NewListePiecesJointes(l.controller.Main(),
		fmt.Sprintf("Document du %s", ac.RawData().Label()),
		controllers.GetDocuments(ac))
	dial.Layout().AddWidget(list)
	dial.Exec()
}