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

package onglets

import (
	"fmt"
	"strings"

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

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

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

	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	"github.com/benoitkugler/goACVE/server/core/utils/joomeo"

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/benoitkugler/goACVE/client/GUI/fields"
	"github.com/benoitkugler/goACVE/client/GUI/lists"
	"github.com/benoitkugler/goACVE/client/controllers"
	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/widgets"
)

const stylePreview = `<style>
td, th {
    padding: 2px;
    text-align: center;
}

table{
    border-width: 1px;
    border-color: #000000;
    border-style: solid;
    border-collapse: collapse;
    margin: 0px;
}
</style>`

func (s *SuiviCamps) Render() {
	s.camps.Model().SetData(s.controller.Liste)
	if s.controller.Etat.CampCurrent != nil {
		s.camps.SelectRow(s.controller.Etat.CampCurrent)
	}
	s.ignoreClosed.SetChecked(s.controller.Etat.CritereIgnoreClosed)
	s.terminated.SetData(s.controller.Etat.CritereTerminated)
}

func (s *SuiviCamps) ConfirmeSetupAlbumJoomeo(alreayLinked []string) bool {
	msg := "Les camps suivants sont déja liés à cet album : <br/>"
	msg += strings.Join(alreayLinked, "<br/>")
	msg += "Etes-vous sur de vouloir lier le camp à cet album ?"
	return basic.Confirmation(msg, "Lier", basic.ONAction)
}

func (s *SuiviCamps) ConfirmeAjoutDirecteurJoomeo(msg string) rd.OptionnalBool {
	dial := basic.Dialog2("Ajout d'un contact")
	var out rd.OptionnalBool
	mail := basic.Button("Ajouter et envoyer un mail")
	mail.SetObjectName(basic.ONAction)
	mail.ConnectClicked(func(_ bool) {
		out = rd.OBOui
		dial.Accept()
	})
	noMail := basic.Button("Ajouter")
	noMail.SetObjectName(basic.ONAdd)
	noMail.ConnectClicked(func(_ bool) {
		out = rd.OBNon
		dial.Accept()
	})

	lay := widgets.NewQGridLayout(dial)
	lay.AddWidget3(basic.Label(msg), 0, 0, 1, 3, 0)
	lay.AddWidget2(noMail, 1, 0, 0)
	lay.AddWidget2(mail, 1, 2, 0)
	dial.Exec()
	return out
}

func (s *SuiviCamps) ConfirmeSupprimeCamp(camp dm.AccesCamp) bool {
	dia := basic.Dialog("Suppression")
	dia.Layout().AddWidget(basic.Label(fmt.Sprintf("Confirmez-vous la suppression du séjour <b>%s</b> ? <br/>"+
		"Cette opération est irréversible.", camp.RawData().Label())))
	valid := basic.Button("Supprimer définitivement")
	valid.SetObjectName(basic.ONDelete)
	valid.ConnectClicked(func(_ bool) {
		dia.Accept()
	})
	dia.Layout().AddWidget(valid)
	return dia.Exec() > 0
}

func (s *SuiviCamps) ProposePasswordDirecteur(camp dm.AccesCamp, password string) bool {
	msg := fmt.Sprintf(`Afin de simplifier la vie des directeurs, vous pouvez attribuer au séjour %s
		un <b>mot de passe propre au directeur</b>. <br/>
		Il pourra ainsi n'en retenir qu'<i>un seul</i> pour tous ses séjours. <br/>
		Souhaitez-vous utiliser le mot de passe %s ?
	`, camp.RawData().Label(), password)
	return basic.Confirmation(msg, "Utiliser ce mot de passe", basic.ONAdd)
}

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

	camps        lists.Table
	ignoreClosed fields.Bool
	terminated   fields.OptionnalBool
}

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

	p.ignoreClosed = fields.NewBool(true)
	p.ignoreClosed.ConnectClicked(func(_ bool) {
		ct.Etat.CritereIgnoreClosed = p.ignoreClosed.IsChecked()
		ct.Reset()
	})
	p.terminated = fields.NewOptionnalBool(true, "Terminés", "En cours")
	p.terminated.ConnectCurrentIndexChanged(func(_ int) {
		ct.Etat.CritereTerminated = p.terminated.GetData()
		ct.Reset()
	})
	rh := widgets.NewQHBoxLayout()
	rh.AddWidget(basic.Label("Masquer les camps fermés aux inscriptions"), 0, 0)
	rh.AddWidget(p.ignoreClosed, 0, core.Qt__AlignLeft)
	rh.AddWidget(basic.Label("Etat :"), 0, core.Qt__AlignRight)
	rh.AddWidget(p.terminated, 0, 0)
	p.camps = lists.Table{
		Liste: lists.Liste{
			Headers: ct.Header,
			Title:   "Séjours",
			OnDoubleClick: func(acces rd.Item, _ int) {
				p.editCamp(acces)
			},
			OnClick: func(acces rd.Item, _ int) {
				ct.Etat.CampCurrent = acces.Id
				p.UpdateToolbar()
			},
			OnRightClick: p.showContextMenu,
			OnSort: func(field rd.Field, reverse bool) {
				lists.DefaultSort(p.camps, field, reverse)
			},
			RightHeader: rh,
		},
	}
	p.camps.Init()
	p.camps.View.SetItemDelegate(lists.NewDelegateSuviCamps())
	p.camps.HorizontalHeader().SetMinimumSectionSize(150)

	lay := widgets.NewQVBoxLayout2(p)
	lay.AddWidget(p.camps, 2, 0)
	return &p
}

func (s *SuiviCamps) showContextMenu(acces rd.Item, pos *core.QPoint) {
	camp := s.controller.Base.NewCamp(acces.Id.Int64())
	menu := widgets.NewQMenu(s.camps)
	ac := menu.AddAction("Copier le lien vers le formulaire d'inscription")
	ac.ConnectTriggered(func(_ bool) {
		lien := s.controller.LienInscription(acces.Id.Int64())
		basic.Copy(lien)
	})

	if directeur, has := camp.GetDirecteur(); has {
		ac = menu.AddAction("Aller au directeur")
		ac.ConnectTriggered(func(_ bool) {
			s.controller.Main().Controllers.Personnes.SelectPersonne(directeur)
		})
	} else {
		ac = menu.AddAction("Ajouter un directeur...")
		ac.ConnectTriggered(func(_ bool) {
			dial := lists.NewRecherchePersonne(s.controller.Base, false)
			dial.Exec()
			if dial.Out == nil {
				return
			}
			s.controller.AjouteDirecteur(camp, dial.Out.Int64())
		})
	}
	menu.AddSeparator()
	ac = menu.AddAction("Suivi financier")
	ac.ConnectTriggered(func(_ bool) {
		path := s.controller.ExportSuiviFinancierParticipants(camp)
		basic.ShowFile(path)
	})
	ac = menu.AddAction("Nombre de nuitées")
	ac.ConnectTriggered(func(_ bool) {
		nbEnfants, nbAdultes := s.controller.CalculeNuitees(camp)
		dial := basic.Dialog("Nuitées")
		dial.Layout().AddWidget(basic.Label(fmt.Sprintf("Nuitées pour le séjour <i>%s</i> : <b>%d</b> adulte(s) et <b>%d</b> enfant(s).",
			camp.RawData().Label(), nbAdultes, nbEnfants)))
		dial.Exec()
	})
	if s.controller.EditRight {
		menu.AddSeparator()
		ac = menu.AddAction("Envoyer un sondage")
		ac.ConnectTriggered(func(_ bool) {
			s.inviteSondage(camp)
		})
		ac.SetEnabled(bool(!camp.RawData().InscriptionSimple))
	}

	s.camps.ShowContextMenu(menu, pos)
}

func (s *SuiviCamps) creer() {
	var importFrom rd.OptionnalId // zero pour non import
	if s.controller.Etat.CampCurrent != nil {
		dial := basic.Dialog2("Importation")
		camp := s.controller.Base.NewCamp(s.controller.Etat.CampCurrent.Int64())
		lab := basic.Label(fmt.Sprintf("Voulez-vous <b>importer</b> le camp courant (%s) comme nouveau camp ?", camp.RawData().Label()))
		oui := basic.Button("Importer")
		oui.ConnectClicked(func(_ bool) {
			importFrom.Valid = true // a compléter
			dial.Accept()
		})
		oui.SetObjectName(basic.ONAction)
		non := basic.Button("Créer un camp vierge")
		non.ConnectClicked(func(_ bool) {
			dial.Accept()
		})
		non.SetObjectName(basic.ONAdd)
		lay := widgets.NewQGridLayout(dial)
		lay.AddWidget3(lab, 0, 0, 1, 3, 0)
		lay.AddWidget2(non, 1, 0, core.Qt__AlignLeft)
		lay.AddWidget2(oui, 1, 2, core.Qt__AlignRight)
		if dial.Exec() == 0 {
			return
		}
	}
	var camp rd.Camp
	if importFrom.Valid {
		toImport := s.controller.ImportCampFrom()
		camp = toImport.Camp // l'id de camp est invalide
		importFrom = toImport.CopyLettreFrom
	}
	up := EditCamp(true, false, true, camp)
	if up == nil {
		return
	}
	s.controller.CreeCamp(apiserver.CreateCampIn{Camp: *up, CopyLettreFrom: importFrom})
}

func (s SuiviCamps) supprimer() {
	s.controller.SupprimeCamp()
}

func (s *SuiviCamps) bilanFinancier() {
	bilans := s.controller.BilansFinanciers(s.camps.Selection())
	html := stylePreview + "<table>" + "<tr>"
	for _, h := range controllers.HeadersBilanFinancier {
		html += "<th>" + h.Label + "</th>"
	}
	html += "</tr>"
	for _, bilan := range bilans {
		html += rd.Html(bilan, controllers.HeadersBilanFinancier)
	}
	html += "</table>"
	dial := basic.Dialog("Bilan des camps")
	sc := widgets.NewQScrollArea(nil)
	sc.SetWidget(basic.Label(html))
	sc.SetMinimumSize2(1000, 250)
	valid := basic.Button("Exporter")
	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(_ bool) {
		path := s.controller.ExportBilanCamps(bilans)
		basic.ShowFile(path)
		dial.Accept()
	})
	dial.Layout().AddWidget(sc)
	dial.Layout().AddWidget(valid)
	dial.Exec()
}

func (s *SuiviCamps) editCamp(acces rd.Item) {
	up := EditCamp(s.controller.EditRight, false, false, s.controller.Base.Camps[acces.Id.Int64()])
	if up == nil {
		return
	}
	s.controller.UpdateCamp(*up)
}

func (s *SuiviCamps) afficherJoomeo() {
	if s.controller.Etat.CampCurrent == nil {
		return
	}
	dial := NewPanelJooemo(s.controller)
	dial.showAndLoad()
	s.controller.CloseJoomeoApi()
}

func (s *SuiviCamps) inviteSondage(camp dm.AccesCamp) {
	idFactures := s.controller.SelectFacturesByCamp(camp.Id)
	if len(idFactures) == 0 {
		basic.ShowError(fmt.Errorf("Aucun dossier n'est inscrit sur le séjour %s", camp.RawData().Label()))
		return
	}

	keep := basic.Confirmation(fmt.Sprintf("Confirmez-vous l'envoi de %d message(s) ?", len(idFactures)),
		"Envoyer", basic.ONAction)
	if !keep {
		s.controller.Main().ShowStandard("Envoi annulé", false)
		return
	}

	ct := s.controller.Main().Controllers.SuiviDossiers
	dialog := messages.NewMonitor(len(idFactures))
	sender := common.NewSondagesSender(nil)
	// mise en place des callbacks
	sender.Monitor.OnError = dialog.OnError
	sender.Monitor.OnSuccess = func(index int, out apiserver.NotifieSondagesOut) {
		ct.OnSuccesNotifieSondages(out)
		dialog.OnSuccess(index)
	}
	sender.OnFinished = dialog.ShowBilan

	job := func(monitor controllers.SendSondagesSignals) ([]controllers.DossierError, error) {
		return ct.EnvoiSondages(camp.Id, idFactures, monitor)
	}
	sender.SetupLaunch(job)
}

func (s *SuiviCamps) openSondages() {
	u := s.controller.UrlSondages()
	s.controller.Main().ShowStandard(fmt.Sprintf("Ouverture de %s ...", u), false)
	basic.OpenURL(u)
}

// ---------------------------------- Joomeo ----------------------------------

type PanelJoomeo struct {
	*widgets.QDialog

	controller   *controllers.SuiviCamps
	stBar        *widgets.QStatusBar
	tree         lists.Tree
	labelAlbum   *widgets.QLabel
	albums       map[string]joomeo.Album
	contacts     map[string]joomeo.Contact
	addDirButton *widgets.QPushButton
	removeButton *widgets.QPushButton
}

func NewPanelJooemo(ct *controllers.SuiviCamps) *PanelJoomeo {
	p := PanelJoomeo{QDialog: basic.Dialog2("Interface Joomeo"), controller: ct}
	camp := ct.Base.NewCamp(p.controller.Etat.CampCurrent.Int64()) // nil already checked
	attribue := basic.Button("Lier au camp")
	attribue.SetEnabled(false)
	attribue.SetObjectName(basic.ONAction)
	attribue.ConnectClicked(p.linkAlbum)

	p.removeButton = basic.Button("Délier du camp")
	p.removeButton.SetObjectName(basic.ONDelete)
	p.removeButton.ConnectClicked(p.removeAlbum)

	p.tree = lists.Tree{
		Liste: lists.Liste{
			Headers: []rd.Header{
				{Field: joomeo.FLabel, Label: "Nom"},
				{Field: joomeo.FDate, Label: "Dernière modification"},
				{Field: joomeo.FNbFiles, Label: "Nombre de photos"},
			},
			Placeholder: "Aucun album Joomeo.",
			MinHeight:   300,
			MinWidth:    500,
			OnClick: func(acces rd.Item, _ int) {
				_, ok := acces.Id.(joomeo.AlbumId)
				attribue.SetEnabled(ok)
			},
		},
	}
	p.tree.Init()
	p.tree.FoldButton.ConnectClicked(p.tree.Fold)

	p.labelAlbum = basic.Label("")
	p.addDirButton = basic.Button("Ajouter le directeur aux contacts")
	p.addDirButton.SetObjectName(basic.ONAdd)
	p.addDirButton.SetEnabled(false)
	p.addDirButton.ConnectClicked(p.ajouteDirecteur)

	lay := widgets.NewQGridLayout(p)

	lay.AddWidget3(basic.Label(fmt.Sprintf("<b>Camp %s</b>", camp.RawData().Label())), 0, 1, 1, 2, 0)
	lay.AddWidget2(basic.Label("Album Jooemo lié :"), 1, 1, 0)
	lay.AddWidget2(p.labelAlbum, 1, 2, 0)
	lay.AddWidget3(p.addDirButton, 3, 1, 1, 2, 0)
	lay.AddWidget3(p.removeButton, 4, 1, 1, 2, 0)
	lay.AddWidget3(p.tree, 0, 0, 4, 1, 0)
	lay.AddWidget2(attribue, 4, 0, 0)
	p.stBar = widgets.NewQStatusBar(nil)
	common.MainWindow.StatusBar().ConnectMessageChanged(func(message string) {
		p.stBar.ShowMessage(message, 0)
	})
	lay.AddWidget3(p.stBar, 5, 0, 1, 3, 0)
	return &p
}

func (p *PanelJoomeo) showAndLoad() {
	p.SetEnabled(false)
	p.stBar.ShowMessage("Chargement des informations Joomeo...", 0)
	basic.Delay(func() {
		var folder []rd.ItemChilds
		folder, p.albums, p.contacts = p.controller.GetAlbumsContactsJoomeo()
		p.tree.Model().SetData(folder)
		p.update()
		p.SetEnabled(true)
		p.stBar.ShowMessage("Informations chargées", 3000)
	})
	p.Exec()
}

func (p *PanelJoomeo) update() {
	camp := p.controller.Base.NewCamp(p.controller.Etat.CampCurrent.Int64())
	alb, has := p.albums[string(camp.RawData().JoomeoAlbumId)]
	lab := alb.Label
	if !has {
		lab = "<i>Aucun</i>"
	}
	p.labelAlbum.SetText(lab)
	p.addDirButton.SetEnabled(has)
	p.removeButton.SetEnabled(has)
}

func (p *PanelJoomeo) linkAlbum(_ bool) {
	p.SetEnabled(false)
	if item, ok := p.tree.CurrentData(); ok {
		if albumId, ok := item.Id.(joomeo.AlbumId); ok {
			p.controller.SetupAlbumJoomeo(albumId.JoomeoId)
		}
	}
	p.SetEnabled(true)
	p.update()
}

func (p *PanelJoomeo) removeAlbum(_ bool) {
	p.SetEnabled(false)
	p.controller.RemoveAlbumJoomeo()
	p.SetEnabled(true)
	p.update()
}

func (p *PanelJoomeo) ajouteDirecteur(_ bool) {
	p.SetEnabled(false)
	p.controller.AjouteDirecteurJoomeo(p.albums)
	p.SetEnabled(true)
}