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

package fields

import (
	"fmt"
	"sort"
	"strconv"

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

	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/widgets"
)

var (
	departements     []string
	modePaiements    []Choice
	sexes            []Choice
	diplomes         []Choice
	appros           []Choice
	rangMembreAssos  []Choice
	RoleEquipes      []Choice
	buss             []Choice
	materielSkiNeeds []Choice
	materielSkiModes []Choice
	schemaPaiements  []Choice
	semaines         []Choice
	statutAttente    = []ChoiceInt{
		{Field: int(rd.Inscrit), Label: rd.StatutAttenteLabels[rd.Inscrit]},
		{}, // séparateur
		{Field: int(rd.AttenteReponse), Label: rd.StatutAttenteLabels[rd.AttenteReponse]},
		{Field: int(rd.Attente), Label: rd.StatutAttenteLabels[rd.Attente]},
		{}, // séparateur
		{Field: int(rd.Refuse), Label: rd.StatutAttenteLabels[rd.Refuse]},
	}
)

func sortLabelSlice(l []Choice) {
	sort.Slice(l, func(i, j int) bool {
		return l[i].Label < l[j].Label
	})
}

func sortFieldSlice(l []Choice) {
	sort.Slice(l, func(i, j int) bool {
		return l[i].Field < l[j].Field
	})
}

func init() {
	for key, nom := range rd.DEPARTEMENTS {
		prop1 := fmt.Sprintf("%s - %s", nom, string(key))
		prop2 := fmt.Sprintf("%s - %s", string(key), nom)
		departements = append(departements, prop1, prop2)
	}
	for key, value := range rd.ModePaimentLabels {
		modePaiements = append(modePaiements, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.SexeLabels {
		sexes = append(sexes, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.DiplomeLabels {
		diplomes = append(diplomes, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.ApprofondissementLabels {
		appros = append(appros, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.RangMembreAssoLabels {
		rangMembreAssos = append(rangMembreAssos, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.RoleLabels {
		RoleEquipes = append(RoleEquipes, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.BusLabels {
		buss = append(buss, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.MaterielSkiNeed {
		materielSkiNeeds = append(materielSkiNeeds, Choice{Field: key, Label: value.String()})
	}
	for key, value := range rd.MaterielSkiModes {
		materielSkiModes = append(materielSkiModes, Choice{Field: key, Label: value})
	}
	for key, value := range rd.SchemaPaiementLabels {
		schemaPaiements = append(schemaPaiements, Choice{Field: string(key), Label: value})
	}
	for key, value := range rd.SemaineLabels {
		semaines = append(semaines, Choice{Field: string(key), Label: value})
	}
	sort.Strings(departements)
	sortLabelSlice(modePaiements)
	sortLabelSlice(sexes)
	sortLabelSlice(diplomes)
	sortFieldSlice(appros)
	sortFieldSlice(rangMembreAssos)
	sortLabelSlice(RoleEquipes)
	sortLabelSlice(buss)
	sortFieldSlice(materielSkiNeeds)
	sortFieldSlice(materielSkiModes)
	sortLabelSlice(schemaPaiements)
	sortFieldSlice(semaines)
}

type Choice = struct {
	Field string
	Label string
}

type ChoiceInt = struct {
	Field int
	Label string
}

type MultiLineString struct {
	*widgets.QPlainTextEdit
}

func NewMultiLineString(editable bool, placeholder string) MultiLineString {
	w := MultiLineString{widgets.NewQPlainTextEdit(nil)}
	w.SetPlaceholderText(placeholder)
	w.SetMinimumWidth(100)
	w.SetMinimumHeight(50)
	w.SetReadOnly(!editable)
	return w
}

func (f MultiLineString) GetData() rd.String {
	return rd.String(f.ToPlainText()).TrimSpace()
}

func (f MultiLineString) SetData(data rd.String) {
	f.SetPlainText(string(data))
}

type String struct {
	*widgets.QLineEdit
}

func NewString2(editable bool, maxLength uint, completions []string) String {
	w := String{widgets.NewQLineEdit(nil)}
	if maxLength > 0 {
		w.SetMaxLength(int(maxLength))
	}
	if completions != nil {
		c := widgets.NewQCompleter3(completions, nil)
		c.SetCaseSensitivity(core.Qt__CaseInsensitive)
		w.SetCompleter(c)
	}
	w.SetReadOnly(!editable)
	return w
}

func NewString(editable bool) String {
	return NewString2(editable, 0, nil)
}

func (f String) GetData() rd.String {
	return rd.String(f.Text())
}

func (f String) SetData(data rd.String) {
	f.SetText(string(data))
}

type Enum struct {
	*widgets.QComboBox
}

func NewEnum(items []Choice, editable bool) Enum {
	w := Enum{widgets.NewQComboBox(nil)}
	w.setChoice(items)
	w.SetEnabled(editable)
	return w
}

func (w Enum) setChoice(items []Choice) {
	currentItem := w.GetData()
	w.Clear()
	for _, item := range items {
		if item.Label == "" {
			w.InsertSeparator(w.Count())
		} else {
			w.AddItem(item.Label, core.NewQVariant15(item.Field))
		}
	}
	w.SetData(currentItem)
}

func (w Enum) GetData() string {
	return w.CurrentData(int(core.Qt__UserRole)).ToString()
}

func (w Enum) SetData(data string) {
	index := w.FindData(core.NewQVariant15(data), int(core.Qt__UserRole), core.Qt__MatchExactly)
	w.SetCurrentIndex(index)
}

type enumInt struct {
	*widgets.QComboBox
}

func newEnumInt(items []ChoiceInt, editable bool) enumInt {
	w := enumInt{widgets.NewQComboBox(nil)}
	w.setChoice(items)
	w.SetEnabled(editable)
	return w
}

func (w enumInt) setChoice(items []ChoiceInt) {
	currentItem := w.GetData()
	w.Clear()
	for _, item := range items {
		if item.Label == "" {
			w.InsertSeparator(w.Count())
		} else {
			w.AddItem(item.Label, core.NewQVariant5(item.Field))
		}
	}
	w.SetData(currentItem)
}

func (w enumInt) GetData() int {
	var ok bool
	out := w.CurrentData(int(core.Qt__UserRole)).ToInt(&ok)
	if !ok {
		out = 0
	}
	return out
}

func (w enumInt) SetData(data int) {
	index := w.FindData(core.NewQVariant5(data), int(core.Qt__UserRole), core.Qt__MatchExactly)
	w.SetCurrentIndex(index)
}

type Departement String

func NewDepartement(editable bool) Departement {
	return Departement(NewString2(editable, 0, departements))
}

func (f Departement) GetData() rd.Departement {
	return rd.Departement(String(f).GetData())
}

func (f Departement) SetData(data rd.Departement) {
	String(f).SetData(rd.String(data))
}

type ModePaiment Enum

func NewModePaiment(editable bool) ModePaiment {
	return ModePaiment(NewEnum(modePaiements, editable))
}

func (f ModePaiment) GetData() rd.ModePaiment {
	return rd.ModePaiment(Enum(f).GetData())
}

func (f ModePaiment) SetData(data rd.ModePaiment) {
	Enum(f).SetData(string(data))
}

type Sexe Enum

func NewSexe(editable bool) Sexe {
	return Sexe(NewEnum(sexes, editable))
}

func (f Sexe) GetData() rd.Sexe {
	return rd.Sexe(Enum(f).GetData())
}

func (f Sexe) SetData(data rd.Sexe) {
	Enum(f).SetData(string(data))
}

type CategorieDocument Enum

func getChoixCategorieDocument(base *dm.BaseLocale) []Choice {
	var fields []Choice
	for _, contrainte := range base.Contraintes {
		if contrainte.Builtin != "" {
			fields = append(fields, Choice{Field: string(contrainte.Builtin), Label: contrainte.Nom.String()})
		}
	}
	sortLabelSlice(fields)
	return fields
}

func NewCategorieDocument(base *dm.BaseLocale, editable bool) CategorieDocument {
	fields := getChoixCategorieDocument(base)
	return CategorieDocument(NewEnum(fields, editable))
}

// NewOptionnalCategorieDocument ajoute un champ "Indifférent" et
// se restreint aux personnes.
func NewOptionnalCategorieDocument(base *dm.BaseLocale) CategorieDocument {
	fields := append([]Choice{{
		Field: "",
		Label: "Indifférent",
	}}, getChoixCategorieDocument(base)...)
	return CategorieDocument(NewEnum(fields, true))
}

func (f CategorieDocument) GetData() rd.BuiltinContrainte {
	return rd.BuiltinContrainte(Enum(f).GetData())
}

func (f CategorieDocument) SetData(data rd.BuiltinContrainte) {
	Enum(f).SetData(string(data))
}

type Diplome Enum

func NewDiplome(editable bool) Diplome {
	return Diplome(NewEnum(diplomes, editable))
}

func (f Diplome) GetData() rd.Diplome {
	return rd.Diplome(Enum(f).GetData())
}

func (f Diplome) SetData(data rd.Diplome) {
	Enum(f).SetData(string(data))
}

type Approfondissement Enum

func NewApprofondissement(editable bool) Approfondissement {
	return Approfondissement(NewEnum(appros, editable))
}

func (f Approfondissement) GetData() rd.Approfondissement {
	return rd.Approfondissement(Enum(f).GetData())
}

func (f Approfondissement) SetData(data rd.Approfondissement) {
	Enum(f).SetData(string(data))
}

type RangMembreAsso Enum

func NewRangMembreAsso(editable bool, showIndifferent bool) RangMembreAsso {
	var choices []Choice
	if showIndifferent {
		for _, v := range rangMembreAssos {
			if rd.RangMembreAsso(v.Field) == rd.RMANonMembre {
				v.Label = "Indifférent"
			}
			choices = append(choices, v)
		}
	} else {
		choices = rangMembreAssos
	}
	return RangMembreAsso(NewEnum(choices, editable))
}

func (f RangMembreAsso) GetData() rd.RangMembreAsso {
	return rd.RangMembreAsso(Enum(f).GetData())
}

func (f RangMembreAsso) SetData(data rd.RangMembreAsso) {
	Enum(f).SetData(string(data))
}

type StatutAttente enumInt

func NewStatutAttente(editable bool) StatutAttente {
	return StatutAttente(newEnumInt(statutAttente, editable))
}

func (f StatutAttente) GetData() rd.StatutAttente {
	return rd.StatutAttente(enumInt(f).GetData())
}

func (f StatutAttente) SetData(data rd.StatutAttente) {
	enumInt(f).SetData(int(data))
}

type Bus Enum

func NewBus(editable bool) Bus {
	return Bus(NewEnum(buss, editable))
}

func (f Bus) GetData() rd.Bus {
	return rd.Bus(Enum(f).GetData())
}

func (f Bus) SetData(data rd.Bus) {
	Enum(f).SetData(string(data))
}

type materielSkiNeed Enum

func newMaterielSkiNeed(editable bool) materielSkiNeed {
	return materielSkiNeed(NewEnum(materielSkiNeeds, editable))
}

func (f materielSkiNeed) GetData() string {
	return Enum(f).GetData()
}

func (f materielSkiNeed) SetData(data string) {
	Enum(f).SetData(data)
}

type materielSkiMode Enum

func newMaterielSkiMode(editable bool) materielSkiMode {
	return materielSkiMode(NewEnum(materielSkiModes, editable))
}

func (f materielSkiMode) GetData() string {
	return Enum(f).GetData()
}

func (f materielSkiMode) SetData(data string) {
	Enum(f).SetData(data)
}

type SchemaPaiement Enum

func NewSchemaPaiement(editable bool) SchemaPaiement {
	return SchemaPaiement(NewEnum(schemaPaiements, editable))
}

func (f SchemaPaiement) GetData() rd.SchemaPaiement {
	return rd.SchemaPaiement(Enum(f).GetData())
}

func (f SchemaPaiement) SetData(data rd.SchemaPaiement) {
	Enum(f).SetData(string(data))
}

type Semaine Enum

func NewSemaine(editable bool) Semaine {
	return Semaine(NewEnum(semaines, editable))
}

func (f Semaine) GetData() rd.Semaine {
	return rd.Semaine(Enum(f).GetData())
}

func (f Semaine) SetData(data rd.Semaine) {
	Enum(f).SetData(string(data))
}

type ChoixStatut struct {
	*widgets.QComboBox
}

func NewChoixStatut(editable bool) ChoixStatut {
	c := ChoixStatut{widgets.NewQComboBox(nil)}
	c.SetEnabled(editable)
	return c
}
func (f *ChoixStatut) SetChoix(choices []rd.PrixParStatut) {
	current := f.GetData()
	f.Clear()
	f.AddItem("", core.NewQVariant7(0))
	for _, statut := range choices {
		f.AddItem(string(statut.Statut), core.NewQVariant7(statut.Id))
	}
	f.SetData(current)
}

func (f ChoixStatut) GetData() int64 {
	var err bool
	return f.CurrentData(int(core.Qt__UserRole)).ToLongLong(&err)
}

func (f ChoixStatut) SetData(data int64) {
	in := f.FindData(core.NewQVariant7(data), int(core.Qt__UserRole), core.Qt__MatchExactly)
	f.SetCurrentIndex(in)
}

type Camp struct {
	Enum
	base           *dm.BaseLocale
	showNull       bool
	showTerminated bool
}

func NewCamp(editable bool, base *dm.BaseLocale, showNull bool) Camp {
	c := Camp{Enum: NewEnum(nil, editable), base: base, showNull: showNull}
	return c
}

func (f Camp) SetChoices(camps []dm.AccesCamp) {
	var offset int
	if f.showNull {
		offset = 1
	}
	items := make([]Choice, len(camps)+offset)
	if f.showNull {
		items[0] = Choice{Field: "", Label: "Indifférent"}
	}
	for index, c := range camps {
		items[index+offset].Label = c.RawData().Label().String()
		items[index+offset].Field = strconv.Itoa(int(c.Id))
	}
	f.setChoice(items)
}

func (f *Camp) Update() {
	var isTerminated rd.OptionnalBool
	if !f.showTerminated {
		isTerminated = rd.OBNon
	}
	camps := f.base.GetCamps(false, isTerminated)
	f.SetChoices(camps)
}

func (f *Camp) ShowTerminated(show bool) {
	f.showTerminated = show
	f.Update()
}

func (f Camp) GetData() *dm.AccesCamp {
	s := f.Enum.GetData()
	id, err := strconv.Atoi(s)
	if err != nil {
		return nil
	}
	ac := f.base.NewCamp(int64(id))
	return &ac
}

func (f Camp) SetData(data rd.OptionnalId) {
	field := ""
	if data.Valid {
		field = strconv.Itoa(int(data.Int64))
	}
	f.Enum.SetData(field)
}

// Year propose le choix parmis un nombre
// fixe d'année, ou indifférent.
type Year enumInt

func NewYear() Year { return Year(newEnumInt(nil, true)) }

func (f Year) SetYears(years []int) {
	items := make([]ChoiceInt, len(years)+1)
	items[0] = ChoiceInt{Label: "Indifférent"}
	for i, year := range years {
		items[i+1] = ChoiceInt{Label: fmt.Sprintf("%d", year), Field: year}
	}
	enumInt(f).setChoice(items)
}

func (f Year) GetData() int {
	return enumInt(f).GetData()
}

func (f Year) SetData(data int) {
	enumInt(f).SetData(data)
}