fix: default values

cmd/root.go

@@ -123,6 +123,7 @@ user created with the credentials from options "username" and "password".`,
 			log.Fatal("Image resize workers count could not be < 1")
 		}
 		imgSvc := img.New(workersCount)
+		log.Println("after img.New")
 
 		var fileCache diskcache.Interface = diskcache.NewNoOp()
 		cacheDir, err := cmd.Flags().GetString("cache-dir")
@@ -133,9 +134,13 @@ user created with the credentials from options "username" and "password".`,
 			}
 			fileCache = diskcache.New(afero.NewOsFs(), cacheDir)
 		}
+		log.Println("after diskcache.New")
 
 		server := getRunParams(cmd.Flags(), d.store)
+		log.Println("after getRunParams")
+		log.Println(server.Log)
 		setupLog(server.Log)
+		log.Println("after setupLog")
 
 		root, err := filepath.Abs(server.Root)
 		checkErr(err)
@@ -165,6 +170,7 @@ user created with the credentials from options "username" and "password".`,
 			listener, err = net.Listen("tcp", adr)
 			checkErr(err)
 		}
+		log.Println("before make(chan)")
 
 		sigc := make(chan os.Signal, 1)
 		signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
@@ -175,6 +181,7 @@ user created with the credentials from options "username" and "password".`,
 			panic(err)
 		}
 
+		log.Println("before fbhttp.NewHandler)")
 		handler, err := fbhttp.NewHandler(imgSvc, fileCache, d.store, server, assetsFs)
 		checkErr(err)
 

cmd/utils.go

@@ -112,10 +112,12 @@ func openDB(path string, cfg pythonConfig) (pythonData, Closeable) {
 		data := pythonData{hadDB: true}
 		db, err := sql.OpenDB(path)
 		if err != nil {
-			data.store, err = sql.NewStorage(db)
-		} else {
 			log.Fatal("Fail to open database " + path)
 		}
+		data.store, err = sql.NewStorage(db)
+		if err != nil {
+			log.Fatal("Fail to create database storage for " + path)
+		}
 		return data, db
 	}
 	return openBoltDB(path, cfg)

storage/bolt/auth.go

@@ -1,6 +1,8 @@
 package bolt
 
 import (
+	"fmt"
+
 	"github.com/asdine/storm/v3"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
@@ -14,6 +16,7 @@ type authBackend struct {
 
 func (s authBackend) Get(t settings.AuthMethod) (auth.Auther, error) {
 	var auther auth.Auther
+	fmt.Println("ERROR: unknown auth method " + t)
 
 	switch t {
 	case auth.MethodJSONAuth:

storage/sql/auth.go

@@ -3,6 +3,7 @@ package sql
 import (
 	"database/sql"
 	"encoding/json"
+	"fmt"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
 	"github.com/filebrowser/filebrowser/v2/errors"
@@ -13,12 +14,6 @@ type authBackend struct {
 	db *sql.DB
 }
 
-func InitAuthTable(db *sql.DB) error {
-	sql := "create table if not exists appliction(key string primary key, value string)"
-	_, err := db.Exec(sql)
-	return err
-}
-
 func (s authBackend) Get(t settings.AuthMethod) (auth.Auther, error) {
 	var auther auth.Auther
 
@@ -32,6 +27,7 @@ func (s authBackend) Get(t settings.AuthMethod) (auth.Auther, error) {
 	case auth.MethodNoAuth:
 		auther = &auth.NoAuth{}
 	default:
+		fmt.Println("ERROR: unknown auth method " + t)
 		return nil, errors.ErrInvalidAuthMethod
 	}
 

storage/sql/settings.go

@@ -6,7 +6,10 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/filebrowser/filebrowser/v2/files"
+	"github.com/filebrowser/filebrowser/v2/rules"
 	"github.com/filebrowser/filebrowser/v2/settings"
+	"github.com/filebrowser/filebrowser/v2/users"
 )
 
 type settingsBackend struct {
@@ -26,7 +29,7 @@ func userDefaultsFromString(s string) settings.UserDefaults {
 	userDefaults := settings.UserDefaults{}
 	err := json.Unmarshal([]byte(s), &userDefaults)
 	if err != nil {
-		fmt.Printf("ERROR: fail to parse settings.UserDefaults")
+		fmt.Println("ERROR: Fail to parse settings.UserDefaults")
 	}
 	return userDefaults
 }
@@ -46,7 +49,7 @@ func brandingFromString(s string) settings.Branding {
 	branding := settings.Branding{}
 	err := json.Unmarshal([]byte(s), &branding)
 	if err != nil {
-		fmt.Printf("ERROR: fail to parse settings.Branding")
+		fmt.Println("ERROR: Fail to parse settings.Branding")
 	}
 	return branding
 }
@@ -54,7 +57,7 @@ func brandingFromString(s string) settings.Branding {
 func brandingToString(s settings.Branding) string {
 	data, err := json.Marshal(s)
 	if err != nil {
-		fmt.Printf("ERROR: fail to jsonify settings.Branding")
+		fmt.Println("ERROR: Fail to jsonify settings.Branding")
 		return ""
 	}
 	return string(data)
@@ -63,7 +66,7 @@ func brandingToString(s settings.Branding) string {
 func commandsToString(c map[string][]string) string {
 	data, err := json.Marshal(c)
 	if err != nil {
-		fmt.Printf("ERROR: fail to jsonify commands")
+		fmt.Println("ERROR: Fail to jsonify commands")
 		return ""
 	}
 	return string(data)
@@ -76,7 +79,7 @@ func commandsFromString(s string) map[string][]string {
 	c := map[string][]string{}
 	err := json.Unmarshal([]byte(s), &c)
 	if err != nil {
-		fmt.Printf("ERROR: fail to parse commands")
+		fmt.Println("ERROR: Fail to parse commands")
 	}
 	return c
 }
@@ -88,7 +91,7 @@ func stringsFromString(s string) []string {
 	c := []string{}
 	err := json.Unmarshal([]byte(s), &c)
 	if err != nil {
-		fmt.Printf("ERROR: fail to parse []string")
+		fmt.Println("ERROR: Fail to parse []string")
 	}
 	return c
 }
@@ -96,7 +99,7 @@ func stringsFromString(s string) []string {
 func stringsToString(c []string) string {
 	data, err := json.Marshal(c)
 	if err != nil {
-		fmt.Printf("ERROR: fail to jsonify strings")
+		fmt.Println("ERROR: Fail to jsonify strings")
 		return ""
 	}
 	return string(data)
@@ -138,11 +141,12 @@ func (s settingsBackend) Get() (*settings.Settings, error) {
 	}
 	key := ""
 	value := ""
-	settings1 := settings.Settings{}
+	settings1 := cloneSettings(defaultSettings)
 	for rows.Next() {
-		err = rows.Scan(key, value)
+		err = rows.Scan(&key, &value)
 		if err != nil {
-			fmt.Printf("ERROR: fail to query settings.Settings")
+			fmt.Println(err.Error())
+			fmt.Println("ERROR: Fail to query settings.Settings")
 		}
 		if key == "Key" {
 			settings1.Key = []byte(value)
@@ -162,8 +166,6 @@ func (s settingsBackend) Get() (*settings.Settings, error) {
 			settings1.Shell = stringsFromString(value)
 		} else if key == "Rules" {
 			settings1.Rules = rulesFromString(value)
-		} else {
-			fmt.Printf("ERROR: unknown settings key " + key)
 		}
 	}
 	return &settings1, nil
@@ -190,19 +192,91 @@ func (s settingsBackend) Save(ss *settings.Settings) error {
 	return nil
 }
 
+var defaultServer = settings.Server{
+	Port:                  "8080",
+	Log:                   "stdout",
+	EnableThumbnails:      false,
+	ResizePreview:         false,
+	EnableExec:            false,
+	TypeDetectionByHeader: false,
+}
+
+var defaultSettings = settings.Settings{
+	Key:              []byte(""),
+	Signup:           false,
+	CreateUserDir:    false,
+	UserHomeBasePath: "/users",
+	Defaults: settings.UserDefaults{
+		Scope:       ".",
+		Locale:      "en",
+		ViewMode:    "mosaic",
+		SingleClick: false,
+		Sorting: files.Sorting{
+			By:  "",
+			Asc: false,
+		},
+		Perm: users.Permissions{
+			Admin:    false,
+			Execute:  true,
+			Create:   true,
+			Rename:   true,
+			Modify:   true,
+			Delete:   true,
+			Share:    true,
+			Download: true,
+		},
+		Commands:     []string{},
+		HideDotfiles: false,
+		DateFormat:   false,
+	},
+	AuthMethod: "json",
+	Branding: settings.Branding{
+		Name:            "",
+		DisableExternal: false,
+		Files:           "",
+		Theme:           "",
+		Color:           "",
+	},
+	Commands: map[string][]string{},
+	Shell:    []string{},
+	Rules:    []rules.Rule{},
+}
+
+func cloneServer(server settings.Server) settings.Server {
+	data, err := json.Marshal(server)
+	if err != nil {
+		return settings.Server{}
+	}
+	s := settings.Server{}
+	json.Unmarshal(data, &s)
+	return s
+}
+
+func cloneSettings(s settings.Settings) settings.Settings {
+	data, err := json.Marshal(s)
+	if err != nil {
+		return settings.Settings{}
+	}
+	s1 := settings.Settings{}
+	json.Unmarshal(data, &s1)
+	return s1
+}
+
 func (s settingsBackend) GetServer() (*settings.Server, error) {
 	sql := "select key, value from settings"
 	rows, err := s.db.Query(sql)
 	if err != nil {
 		return nil, nil
 	}
+	server := cloneServer(defaultServer)
 	key := ""
 	value := ""
-	server := settings.Server{}
+
 	for rows.Next() {
-		err = rows.Scan(key, value)
+		err = rows.Scan(&key, &value)
 		if err != nil {
-			fmt.Printf("ERROR: fail to query settings.Settings")
+			fmt.Println(err.Error())
+			fmt.Println("ERROR: Fail to query settings.Settings")
 		}
 		if key == "Root" {
 			server.Root = value
@@ -260,7 +334,7 @@ func (s settingsBackend) SaveServer(ss *settings.Server) error {
 }
 
 func SetSetting(db *sql.DB, key string, value string) error {
-	sql := "select count(key) from settings"
+	sql := "select count(key) from settings where key = '" + key + "'"
 	count := 0
 	err := db.QueryRow(sql).Scan(&count)
 	if err != nil {
@@ -277,7 +351,6 @@ func GetSetting(db *sql.DB, key string) string {
 	value := ""
 	err := db.QueryRow(sql).Scan(&value)
 	if err != nil {
-		fmt.Printf("ERROR: " + err.Error())
 		return value
 	}
 	return value

storage/sql/share.go

@@ -29,11 +29,11 @@ func parseLink(row linkRecord) (*share.Link, error) {
 	expire := int64(0)
 	passwordhash := ""
 	token := ""
-	err := row.Scan(path, hash, userid, expire, passwordhash, token)
+	err := row.Scan(&path, &hash, &userid, &expire, &passwordhash, &token)
 	if err != nil {
 		s := "ERROR: Fail to parse record for share.Link"
 		err := errors.New(s)
-		fmt.Printf(s)
+		fmt.Println(s)
 		return nil, err
 	}
 	link := share.Link{}
@@ -59,7 +59,7 @@ func queryLinks(db *sql.DB, condition string) ([]*share.Link, error) {
 	for rows.Next() {
 		link, err := parseLink(rows)
 		if err != nil {
-			fmt.Printf("ERROR: Fail to parse record for share.Link")
+			fmt.Println("ERROR: Fail to parse record for share.Link")
 			continue
 		}
 		links = append(links, link)

storage/sql/sql.go

@@ -3,6 +3,7 @@ package sql
 import (
 	"database/sql"
 	"errors"
+	"fmt"
 	"strings"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
@@ -56,13 +57,25 @@ func NewStorage(db *sql.DB) (*storage.Storage, error) {
 
 	err := SetSetting(db, "version", "2")
 	if err != nil {
+		fmt.Println("ERROR: fail to set version")
 		return nil, err
 	}
 
-	return &storage.Storage{
+	// TODO: default
+	fmt.Println(GetSetting(db, "auther"))
+	if GetSetting(db, "auther") == "" {
+		err := SetSetting(db, "auther", "json")
+		if err != nil {
+			fmt.Println("ERROR: fail to set auther")
+			return nil, err
+		}
+	}
+
+	storage := &storage.Storage{
 		Auth:     authStore,
 		Users:    userStore,
 		Share:    shareStore,
 		Settings: settingsStore,
-	}, nil
+	}
+	return storage, nil
 }

storage/sql/users.go

@@ -95,7 +95,7 @@ func InitUserTable(db *sql.DB) error {
 }
 
 func (s usersBackend) Get(id interface{}) (*users.User, error) {
-	userId := id.(uint)
+	userID := id.(uint)
 	username := ""
 	password := ""
 	scope := ""
@@ -105,10 +105,10 @@ func (s usersBackend) Get(id interface{}) (*users.User, error) {
 	commands := ""
 	sorting := ""
 	rules := ""
-	sql := "select username, password, scope, lockpassword, viewmode, perm,commands,sorting,rules from users where id=" + strconv.Itoa(int(userId))
+	sql := "select username, password, scope, lockpassword, viewmode, perm,commands,sorting,rules from users where id=" + strconv.Itoa(int(userID))
-	s.db.QueryRow(sql).Scan(username, password, scope, lockpassword, viewmode, perm, commands, sorting, rules)
+	s.db.QueryRow(sql).Scan(&username, &password, &scope, &lockpassword, &viewmode, &perm, &commands, &sorting, &rules)
 	user := users.User{}
-	user.ID = userId
+	user.ID = userID
 	user.Username = username
 	user.Password = password
 	user.Scope = scope
@@ -139,9 +139,9 @@ func (s usersBackend) Gets() ([]*users.User, error) {
 		commands := ""
 		sorting := ""
 		rules := ""
-		err := rows.Scan(id, username, password, scope, lockpassword, viewmode, perm, commands, sorting, rules)
+		err := rows.Scan(&id, &username, &password, &scope, &lockpassword, &viewmode, &perm, &commands, &sorting, &rules)
 		if err != nil {
-			fmt.Printf("Fail to parse record for user.User")
+			fmt.Println("Fail to parse record for user.User")
 			continue
 		}
 		user := users.User{}