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

package app

import (
	"fmt"
	"sort"
	"time"

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

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

type Launcher struct {
	*widgets.QDialog

	Controller *controllers.MainController
	users      *widgets.QScrollArea
}

func (l Launcher) ShowError(err error) {
	basic.ShowError(err)
}

func (l Launcher) InitRessources() {
	InitRessources()
}

func (l Launcher) ShowUpdate(ct *controllers.MainController) controllers.LoadMode {
	dial := initUpdateMonitor()
	var out controllers.LoadMode
	basic.Delay(func() {
		restart, err := ct.CheckUpdate(dial.monitor)
		if err != nil {
			keep := ShowStartupError("Mise à jour impossible", fmt.Sprintf("Erreur pendant la mise à jour : %s", err))
			if keep {
				out = controllers.LoadLocal
				dial.Accept()
				return
			}
			out = controllers.Quit
			dial.Accept()
			return
		}
		if !restart {
			out = controllers.LoadRemote
			dial.Accept()
			return
		}
		dial.showSuccesUpdate()
		if err := ct.Restart(); err != nil {
			l.ShowError(fmt.Errorf("Le redémarrage semble impossible : %s. <br/> "+
				"Le logiciel va quitter. Veuillez redémarrer manuellement.", err))
		}
		out = controllers.Quit
		dial.Accept()
	})
	dial.Exec()
	time.Sleep(100 * time.Millisecond)
	return out
}

func (l Launcher) ShowChangelog() {
	showChangelog()
}

func (l *Launcher) InitLoggin(controller *controllers.MainController) {
	l.QDialog = basic.Dialog("Connexion")
	setupShortcuts(l, controller, false)
	title := basic.Label("Bienvenue sur le client ACVE !")
	title.SetObjectName("loggin-title")
	title.SetAlignment(core.Qt__AlignCenter)
	l.users = widgets.NewQScrollArea(nil)
	l.users.SetAlignment(core.Qt__AlignCenter)
	l.users.SetWidget(basic.Label("<i>Chargement des utilisateurs...</i>"))
	l.users.SetMinimumHeight(200)
	l.users.SetMinimumWidth(900)
	l.Layout().AddWidget(title)
	l.Layout().AddWidget(l.users)
	l.SetModal(true)
	l.Show()
}

func (l Launcher) ShowLogginError(cause string) bool {
	return ShowStartupError("Erreur de connexion", cause)
}

func ShowStartupError(title, cause string) (loadLocal bool) {
	di := basic.Dialog2(title)
	msg := fmt.Sprintf(`<b>%s</b><br/><br/>
		Vous pouvez démarrer en mode <b>hors-connexion</b> (accès en lecture seule aux dernières
		données sauvegardées sur le disque) ou vérifier votre connexion et <b>redémarrer</b>.`, cause)

	goOffline := basic.Button("Continuer hors-connexion")
	goOffline.SetObjectName(basic.ONAction)
	goOffline.ConnectClicked(func(_ bool) {
		di.Accept()
	})

	quit := basic.Button("Quitter")
	quit.ConnectClicked(func(_ bool) {
		di.Reject()
	})

	lay := widgets.NewQGridLayout(di)
	lab := basic.Label(msg)
	lab.SetWordWrap(true)
	lab.SetMinimumWidth(800)
	lay.AddWidget3(lab, 0, 0, 1, 3, 0)
	lay.AddWidget2(goOffline, 1, 0, 0)
	lay.AddWidget2(quit, 1, 2, 0)
	return di.Exec() > 0
}

func (l *Launcher) SetUsersAndChoose(users []rd.ClientUser, autologs map[int64]string) (userId int64, password string, mods *rd.Modules, keep controllers.LoadMode) {
	f := basic.Frame()
	layUs := widgets.NewQHBoxLayout2(f)
	sort.Slice(users, func(i, j int) bool {
		return users[i].Label > users[j].Label
	})
	sort.SliceStable(users, func(i, j int) bool {
		return users[i].IsAdmin || !users[j].IsAdmin
	})
	for _, us := range users {
		us := us
		b := widgets.NewQToolButton(nil)
		b.SetToolButtonStyle(core.Qt__ToolButtonTextUnderIcon)
		b.SetText(us.Label)
		b.SetIcon(basic.Icons.User)
		b.SetIconSize(core.NewQSize2(100, 50))
		b.SetObjectName("user")
		b.ConnectClicked(func(_ bool) {
			password, mods, keep = l.onClick(us.Id, autologs[us.Id])
			userId = us.Id
			if keep >= 0 {
				l.Accept()
			}
		})
		b.SetProperty("admin", core.NewQVariant9(us.IsAdmin))
		layUs.AddWidget(b, 1, 0)
	}
	l.SetMinimumWidth(1000)
	l.users.SetWidget(f)
	if l.Exec() == 0 {
		keep = controllers.Quit
	}
	return
}

func (l *Launcher) onClick(userId int64, autologPassword string) (outPassword string, outModules *rd.Modules, keep controllers.LoadMode) {
	f := newPasswordForm(userId, l.Controller)
	f.password.SetText(autologPassword)
	f.autolog.SetChecked(true)
	if autologPassword != "" {
		basic.Delay(f.loggin)
	}
	if f.Exec() == 0 {
		return "", &rd.Modules{}, -1
	}

	if f.outError != nil {
		if ShowStartupError("Connexion impossible", fmt.Sprintf("La vérification du mot de passe a échoué : <br/><i>%s</i>", f.outError)) {
			keep = controllers.LoadLocal
		}
		return
	}
	outModules, keep = f.outModules, controllers.LoadRemote
	if f.autolog.IsChecked() {
		outPassword = f.password.Text()
	}
	return
}

type passwordForm struct {
	*widgets.QDialog

	controller *controllers.MainController
	userId     int64

	valid    *widgets.QPushButton
	password *widgets.QLineEdit
	retour   *widgets.QLabel
	autolog  *widgets.QCheckBox

	outModules *rd.Modules
	outError   error
}

func newPasswordForm(userId int64, ct *controllers.MainController) *passwordForm {
	p := passwordForm{QDialog: basic.Dialog("Authentification"), controller: ct, userId: userId}
	p.SetWindowFlag(core.Qt__WindowMinMaxButtonsHint, false)
	p.password = widgets.NewQLineEdit(nil)
	p.password.SetPlaceholderText("Mot de passe...")
	p.password.SetFocus2()
	p.retour = basic.Label(".")
	p.retour.SetFixedHeight(40)
	p.retour.SetObjectName("loggin-retour")
	p.retour.SetAlignment(core.Qt__AlignCenter)
	p.autolog = widgets.NewQCheckBox2("Se connecter automatiquement", nil)
	p.valid = basic.Button("Se connecter")
	p.valid.SetObjectName(basic.ONAction)
	p.valid.SetFixedHeight(30)
	p.valid.ConnectClicked(func(_ bool) {
		p.loggin()
	})
	p.valid.SetObjectName(basic.ONAction)

	p.Layout().SetContentsMargins(15, 15, 15, 15)
	p.Layout().AddWidget(basic.Label("Merci de renseigner votre <b>mot de passe</b> :"))
	p.Layout().AddWidget(p.password)
	p.Layout().AddWidget(p.autolog)
	p.Layout().AddWidget(p.retour)
	p.Layout().AddWidget(p.valid)
	return &p
}

func (p *passwordForm) loggin() {
	p.valid.SetEnabled(false)
	p.valid.SetText("Vérification du mot de passe...")
	p.outModules, p.outError = p.controller.CheckPassword(p.userId, p.password.Text())
	p.valid.SetText("Se connecter")
	p.valid.SetEnabled(true)
	if p.outError == nil {
		if p.outModules == nil {
			p.retour.SetText("Mot de passe incorrect.")
		} else {
			p.Accept()
		}
	} else {
		p.Accept()
	}
}