gosora/common/settings.go

183 lines
4.2 KiB
Go

package common
import (
"database/sql"
"errors"
"strconv"
"strings"
"sync/atomic"
qgen "github.com/Azareal/Gosora/query_gen"
)
var SettingBox atomic.Value // An atomic value pointing to a SettingBox
// SettingMap is a map type specifically for holding the various settings admins set to toggle features on and off or to otherwise alter Gosora's behaviour from the Control Panel
type SettingMap map[string]interface{}
type SettingStore interface {
ParseSetting(name, content, typ, constraint string) string
BypassGet(name string) (*Setting, error)
BypassGetAll(name string) ([]*Setting, error)
}
type OptionLabel struct {
Label string
Value int
Selected bool
}
type Setting struct {
Name string
Content string
Type string
Constraint string
}
type SettingStmts struct {
getAll *sql.Stmt
get *sql.Stmt
update *sql.Stmt
}
var settingStmts SettingStmts
func init() {
SettingBox.Store(SettingMap(make(map[string]interface{})))
DbInits.Add(func(acc *qgen.Accumulator) error {
s := "settings"
settingStmts = SettingStmts{
getAll: acc.Select(s).Columns("name,content,type,constraints").Prepare(),
get: acc.Select(s).Columns("content,type,constraints").Where("name=?").Prepare(),
update: acc.Update(s).Set("content=?").Where("name=?").Prepare(),
}
return acc.FirstError()
})
}
func (s *Setting) Copy() (o *Setting) {
o = &Setting{Name: ""}
*o = *s
return o
}
func LoadSettings() error {
sBox := SettingMap(make(map[string]interface{}))
settings, err := sBox.BypassGetAll()
if err != nil {
return err
}
for _, s := range settings {
err = sBox.ParseSetting(s.Name, s.Content, s.Type, s.Constraint)
if err != nil {
return err
}
}
SettingBox.Store(sBox)
return nil
}
// TODO: Add better support for HTML attributes (html-attribute). E.g. Meta descriptions.
func (sBox SettingMap) ParseSetting(name, content, typ, constraint string) (err error) {
ssBox := map[string]interface{}(sBox)
switch typ {
case "bool":
ssBox[name] = (content == "1")
case "int":
ssBox[name], err = strconv.Atoi(content)
if err != nil {
return errors.New("You were supposed to enter an integer x.x")
}
case "int64":
ssBox[name], err = strconv.ParseInt(content, 10, 64)
if err != nil {
return errors.New("You were supposed to enter an integer x.x")
}
case "list":
cons := strings.Split(constraint, "-")
if len(cons) < 2 {
return errors.New("Invalid constraint! The second field wasn't set!")
}
con1, err := strconv.Atoi(cons[0])
con2, err2 := strconv.Atoi(cons[1])
if err != nil || err2 != nil {
return errors.New("Invalid contraint! The constraint field wasn't an integer!")
}
val, err := strconv.Atoi(content)
if err != nil {
return errors.New("Only integers are allowed in this setting x.x")
}
if val < con1 || val > con2 {
return errors.New("Only integers between a certain range are allowed in this setting")
}
ssBox[name] = val
default:
ssBox[name] = content
}
return nil
}
func (sBox SettingMap) BypassGet(name string) (*Setting, error) {
s := &Setting{Name: name}
err := settingStmts.get.QueryRow(name).Scan(&s.Content, &s.Type, &s.Constraint)
return s, err
}
func (sBox SettingMap) BypassGetAll() (settingList []*Setting, err error) {
rows, err := settingStmts.getAll.Query()
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
s := &Setting{Name: ""}
err := rows.Scan(&s.Name, &s.Content, &s.Type, &s.Constraint)
if err != nil {
return nil, err
}
settingList = append(settingList, s)
}
return settingList, rows.Err()
}
func (sBox SettingMap) Update(name, content string) RouteError {
s, err := sBox.BypassGet(name)
if err == ErrNoRows {
return FromError(err)
} else if err != nil {
return SysError(err.Error())
}
// TODO: Why is this here and not in a common function?
if s.Type == "bool" {
if content == "on" || content == "1" {
content = "1"
} else {
content = "0"
}
}
err = sBox.ParseSetting(name, content, s.Type, s.Constraint)
if err != nil {
return FromError(err)
}
// TODO: Make this a method or function?
_, err = settingStmts.update.Exec(content, name)
if err != nil {
return SysError(err.Error())
}
err = LoadSettings()
if err != nil {
return SysError(err.Error())
}
return nil
}