github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/main_loggin.go (about)

     1  package controllers
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"log"
     8  	"net/http"
     9  
    10  	"github.com/benoitkugler/goACVE/server/core/apiserver"
    11  	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
    12  	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
    13  )
    14  
    15  type logginSettings struct {
    16  	Autolog         map[int64]string
    17  	LastPermissions rd.Modules
    18  }
    19  
    20  type MainApp interface {
    21  	MonitorLoadDB(c *MainController)
    22  }
    23  
    24  type Launcher interface {
    25  	ShowError(err error)
    26  	InitRessources()
    27  
    28  	ShowUpdate(controller *MainController) LoadMode
    29  
    30  	ShowChangelog()
    31  
    32  	InitLoggin(controller *MainController)
    33  	ShowLogginError(cause string) (loadLocal bool)
    34  
    35  	// empty keep means quit
    36  	SetUsersAndChoose([]rd.ClientUser, map[int64]string) (userId int64, password string, mods *rd.Modules, keep LoadMode)
    37  }
    38  
    39  type LoadMode int8
    40  
    41  const (
    42  	Quit LoadMode = iota
    43  	LoadLocal
    44  	LoadRemote
    45  )
    46  
    47  // StartLoggin se charge des opérations d'identification et chargement des données
    48  func (c *MainController) StartLoggin(l Launcher) (rd.Modules, LoadMode) {
    49  	c.Base = &dm.BaseLocale{}
    50  	debugMode := c.parseCommandLine()
    51  
    52  	if err := c.checkLocalFolder(); err != nil {
    53  		l.ShowError(err)
    54  		return rd.Modules{}, Quit
    55  	}
    56  
    57  	l.InitRessources()
    58  
    59  	modules, load := DebugModules, LoadLocal
    60  
    61  	// mode debug : on démarre directement en mode local
    62  	// mais avec le serveur actif
    63  	if debugMode {
    64  		return modules, load
    65  	}
    66  
    67  	defer func() { // on désactive les modifications en cas de chargement local
    68  		if load == LoadLocal {
    69  			Server.actif = false
    70  			modules = modules.ToReadOnly()
    71  		}
    72  	}()
    73  
    74  	settings := c.loadLogginSettings()
    75  	modules = settings.LastPermissions
    76  
    77  	switch l.ShowUpdate(c) { // vérification des mises à jour
    78  	case LoadLocal: // un problème de connection
    79  		return modules, LoadLocal
    80  	case Quit: // problème ou mise à jour trouvée
    81  		return modules, Quit
    82  	}
    83  
    84  	if isNewlyUpdated() {
    85  		l.ShowChangelog()
    86  		setNewlyUpdated(false)
    87  	}
    88  
    89  	l.InitLoggin(c)
    90  	users, err := c.loadUsers()
    91  	if err != nil {
    92  		cause := fmt.Sprintf("Le chargement des utilisateurs depuis le serveur a échoué : <br/> <i>%s</i>", err)
    93  		if l.ShowLogginError(cause) {
    94  			return modules, LoadLocal
    95  		}
    96  		return modules, Quit
    97  
    98  	} else {
    99  		chosenId, password, mods, keep := l.SetUsersAndChoose(users, settings.Autolog)
   100  		switch keep {
   101  		case Quit:
   102  			return modules, Quit
   103  		case LoadRemote:
   104  			settings.LastPermissions = *mods
   105  			c.updateLogginSettings(settings, chosenId, password)
   106  			modules = *mods
   107  			load = LoadRemote
   108  		case LoadLocal: // erreur de chargement
   109  			return modules, LoadLocal
   110  		}
   111  	}
   112  
   113  	return modules, load
   114  }
   115  
   116  // loadUsers requiert les utilisateurs du logiciel
   117  // au serveur et les renvoi.
   118  func (c *MainController) loadUsers() ([]rd.ClientUser, error) {
   119  	var users []rd.ClientUser
   120  	err := requete(apiserver.UrlUsers, http.MethodGet, nil, &users)
   121  	return users, err
   122  }
   123  
   124  func (c *MainController) loadLogginSettings() logginSettings {
   125  	b, err := ioutil.ReadFile(LogginSettingsPath)
   126  	var l logginSettings
   127  	if err == nil {
   128  		err = json.Unmarshal(b, &l)
   129  		if err != nil {
   130  			log.Printf("Lecture du fichier de loggin impossible : %s", err)
   131  		}
   132  	}
   133  	return l
   134  }
   135  
   136  // CheckPassword renvoie true si le mot de passe est bon.
   137  // Le cas échéant, la partie graphique peut se lancer,
   138  // puis charger la base de données.
   139  func (c MainController) CheckPassword(userId int64, password string) (*rd.Modules, error) {
   140  	var rep apiserver.OutputLoggin
   141  	err := requete(apiserver.UrlUsers, http.MethodPost,
   142  		apiserver.ParamsLoggin{Id: userId, Password: password}, &rep)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	if !rep.Valid {
   147  		return nil, nil
   148  	}
   149  	return &rep.User.Modules, nil
   150  }
   151  
   152  func (c MainController) updateLogginSettings(current logginSettings, userId int64, password string) {
   153  	if password != "" {
   154  		if current.Autolog == nil {
   155  			current.Autolog = make(map[int64]string)
   156  		}
   157  		current.Autolog[userId] = password
   158  	}
   159  	b, err := json.Marshal(current)
   160  	if err != nil {
   161  		log.Printf("Erreur dans l'encodage du fichier de loggin : %s", err)
   162  	}
   163  	err = ioutil.WriteFile(LogginSettingsPath, b, 0666)
   164  	if err != nil {
   165  		log.Printf("Erreur dans l'enregistrement du fichier de loggin : %s", err)
   166  	}
   167  }