github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/main.go

// Ce package expose l'objet de contrôle abstrait,
// responsable du lancement, du chargement de la base,
// et du lien entre les interfaces.
// Il est destiné à ettayer une application graphique.
package controllers

import (
	"bytes"
	"errors"
	"flag"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"os"
	"path"

	"github.com/benoitkugler/goACVE/logs"

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

const (
	// Relative path to local folder. May be used for temporary documents.
	LocalFolder        = "local/"
	LogginSettingsPath = LocalFolder + "init.json"
	BasePath           = LocalFolder + "DB.json"

	endPoint = "/ACVEGestion/api"

	urlRejoueInscription = "__rejoue_inscription" // cas spécial hors API
)

var (
	hostLocal   *url.URL
	hostDistant *url.URL
)

var (
	Server ServerURL // Si vide, désactive les requêtes serveur

	DebugModules = rd.Modules{
		Personnes:     4,
		Camps:         3,
		Inscriptions:  3,
		SuiviCamps:    3,
		SuiviDossiers: 3,
		Paiements:     3,
		Aides:         3,
		Equipiers:     3,
		Dons:          3,
	}
)

func init() {
	var err error
	hostLocal, err = url.Parse("http://localhost:1323")
	if err != nil {
		log.Fatal(err)
	}
	hostDistant, err = url.Parse("https://acve.fr")
	if err != nil {
		log.Fatal(err)
	}
}

type ServerURL struct {
	actif, local bool
}

func (s ServerURL) host() *url.URL {
	if s.local {
		return hostLocal
	}
	return hostDistant
}

func (s ServerURL) Host() string {
	return s.host().String()
}

// cas spécial pour rejouer l'inscription
func (s ServerURL) ApiURL(endpoint string) string {
	if !s.actif {
		return ""
	}

	if endpoint == urlRejoueInscription { // special case
		return s.EndpointURL("/inscription/api/no-check-mail")
	}

	fullpath := path.Join(endPoint, endpoint)
	return s.EndpointURL(fullpath)
}

func (s ServerURL) EndpointURL(endpoint string) string {
	u := *s.host()
	u.Path = endpoint
	return u.String()
}

type controllerPool struct {
	Personnes     *Personnes
	Aides         *Aides
	Camps         *Camps
	SuiviCamps    *SuiviCamps
	SuiviDossiers *SuiviDossiers
	Equipiers     *Equipiers
	Dons          *Dons
	Inscriptions  *Inscriptions
	Paiements     *Paiements
}

type MainController struct {
	logsJoomeo  logs.Joomeo // accés direct : dev ou prod
	Controllers controllerPool
	Base        *dm.BaseLocale
	ShowError   func(err error)
	// Has to be thread safe
	ShowStandard func(msg string, wait bool)
	Background   Background
}

func (c *MainController) ResetAllControllers() {
	c.Controllers.Personnes.Reset()
	c.Controllers.Aides.Reset()
	c.Controllers.Camps.Reset()
	c.Controllers.SuiviCamps.Reset()
	c.Controllers.SuiviDossiers.Reset()
	c.Controllers.Equipiers.Reset()
	c.Controllers.Dons.Reset()
	c.Controllers.Inscriptions.Reset()
	c.Controllers.Paiements.Reset()
}

func (c MainController) LogsJoomeo() logs.Joomeo {
	return c.logsJoomeo
}

// -------------------------------------------------------------------------------------------
// ---------------------------------------- Lancement ----------------------------------------
// -------------------------------------------------------------------------------------------

func (c *MainController) parseCommandLine() bool {
	local := flag.Bool("local", false, "utilise le serveur local, en version développement")
	debug := flag.Bool("debug", false, "saute la vérification des mises à jour, l'authentification et le chargement de la base distante. Implique -local")

	flag.Parse()
	Server.actif = true
	if *debug { // debug -> local
		*local = true
	}
	// l'accès à Joomeo ne passe pas par le serveur
	if *local {
		Server.local = true
		c.logsJoomeo = logs.JoomeoDev
	} else {
		c.logsJoomeo = logs.JoomeoProd
	}
	return *debug
}

func (c *MainController) checkLocalFolder() error {
	_, err := os.Stat(LocalFolder)
	if err == nil {
		return nil
	}
	if err = os.Mkdir(LocalFolder, 0777); err != nil {
		return fmt.Errorf("Impossible de créer le dossier de travail : %s", err)
	}
	return nil
}

func (c *MainController) InitControllers(modules rd.Modules) {
	c.Controllers.Personnes = NewPersonnes(c, modules.Personnes)
	c.Controllers.Aides = NewAides(c, modules.Aides)
	c.Controllers.Camps = NewCamps(c, modules.Camps)
	c.Controllers.SuiviCamps = NewSuiviCamps(c, modules.SuiviCamps)
	c.Controllers.SuiviDossiers = NewSuiviDossiers(c, modules.SuiviDossiers)
	c.Controllers.Equipiers = NewEquipiers(c, modules.Equipiers)
	c.Controllers.Dons = NewDons(c, modules.Dons)
	c.Controllers.Inscriptions = NewInscriptions(c, modules.Inscriptions)
	c.Controllers.Paiements = NewPaiements(c, modules.Paiements)
}

func (c MainController) saveBaseToDisk() error {
	f, err := os.Create(BasePath)
	if err != nil {
		return fmt.Errorf("Impossible d'<b>enregistrer</b> les données sur le disque : <br/> <i>%s</i>", err)
	}
	defer f.Close()
	if err = dm.MarshalBaseLocale(c.Base, f); err != nil {
		return fmt.Errorf("Impossible d'<b>enregistrer</b> les données sur le disque : <br/> <i>%s</i>", err)
	}
	return nil
}

// LoadBaseFromDisk charge et décode la sauvegarde du disque, au format .json
// Le pointer `Base` est mis à jour.
// En cas d'erreur, les dictionnaires de la base sont quand même initialisés.
func (c *MainController) LoadBaseFromDisk() error {
	*c.Base = dm.NewBaseLocale()
	f, err := os.Open(BasePath)
	if err != nil {
		return fmt.Errorf("Impossible de <b>charger</b> les données depuis le <b>disque</b> : <br/> <i>%s</i>", err)
	}
	defer f.Close()
	base, err := dm.UnMarshalBaseLocale(f)
	if err != nil {
		return fmt.Errorf("Impossible de <b>décrypter</b> les données du <b>disque</b> : <br/> <i>%s</i>", err)
	}
	*c.Base = base
	c.ResetAllControllers()
	c.ShowStandard("Données bien chargées depuis le disque.", false)
	return nil
}

// LoadBaseFromServer requiert la base local sur le serveur, au format .json.gz
// La réponse est décompressée et décodée.
// Met à jour les controllers et enregistre sur le disque en cas de succès.
func (c *MainController) LoadBaseFromServer(progressMonitor func(i uint8)) {
	if progressMonitor == nil {
		c.ShowError(errors.New("Fonction de suivi non fournie !"))
		return
	}
	buf := new(bytes.Buffer)
	err := requestDownload(apiserver.UrlDB, http.MethodGet, nil, progressMonitor, buf)
	if err != nil {
		c.ShowError(fmt.Errorf("Impossible de <b>charger</b> la base depuis le <b>serveur</b>. <br/> %s", err))
		return
	}
	base, err := dm.DecompressUnMarshalBaseLocale(buf)
	if err != nil {
		c.ShowError(fmt.Errorf("Impossible de <b>décrypter</b> les données du <b>serveur</b>. <br/> %s", err))
		return
	}
	*c.Base = base
	c.ResetAllControllers()

	// enregistre sur le disque
	err = c.saveBaseToDisk()
	if err != nil {
		c.ShowError(err)
		return
	}

	c.ShowStandard("Données mises à jour depuis le serveur et enregistrées sur le disque.", false)
}

// LoadPartialBaseFromServer demande le hash de la base au serveur,
// le compare avec la base courante, et télécharge les différences,
// Met à jour les controllers et enregistre sur le disque en cas de succès.
func (c *MainController) LoadPartialBaseFromServer(progressMonitor func(i uint8)) {
	if progressMonitor == nil {
		c.ShowError(errors.New("Fonction de suivi non fournie !"))
		return
	}
	rep, err := requeteResponseMultipart(apiserver.UrlDB, http.MethodPut, nil)
	if err != nil {
		c.ShowError(fmt.Errorf("Impossible de <b>charger</b> les données de hash depuis le <b>serveur</b>. <br/> %s", err))
		return
	}
	serverHash, err := dm.NewBaseHash(rep[apiserver.DBHashHeaderJSONKey], rep[apiserver.DBHashBinaryKey])
	if err != nil {
		c.ShowError(fmt.Errorf("Impossible de <b>décrypter</b> les données de hash du <b>serveur</b>. <br/> %s", err))
		return
	}
	clientHash, err := c.Base.Hash()
	if err != nil {
		c.ShowError(fmt.Errorf("Impossible de former le <b>hash</b> des données <b>locales</b>. <br/> %s", err))
		return
	}

	diffs := clientHash.Compare(serverHash)
	nbModified, nbDeleted := diffs.Total()
	if nbModified+nbDeleted == 0 { // rien à faire, base déjà à jour
		c.ShowStandard("Les données locales sont déjà à jour.", false)
		return
	}

	var partialBase dm.BaseLocale
	if nbModified > 0 { // on demande les différences au serveur
		c.ShowStandard(fmt.Sprintf("Téléchargement des %d différences (suppressions: %d)", nbModified, nbDeleted), true)

		buf := new(bytes.Buffer)
		err := requestDownload(apiserver.UrlDB, http.MethodPost, diffs.Modified, progressMonitor, buf)
		if err != nil {
			c.ShowError(fmt.Errorf("Impossible de <b>charger</b> la base (partielle) depuis le <b>serveur</b>. <br/> %s", err))
			return
		}
		partialBase, err = dm.DecompressUnMarshalBaseLocale(buf)
		if err != nil {
			c.ShowError(fmt.Errorf("Impossible de <b>décrypter</b> les données (partielles) du <b>serveur</b>. <br/> %s", err))
			return
		}
	}

	c.Base.MergeFrom(partialBase, diffs.Deleted)
	c.ResetAllControllers()

	// enregistre sur le disque
	err = c.saveBaseToDisk()
	if err != nil {
		c.ShowError(err)
		return
	}

	c.ShowStandard("Données bien mises à jour et enregistrées sur le disque.", false)
}