227 lines
5.8 KiB
Go
227 lines
5.8 KiB
Go
package util
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/boltdb/bolt"
|
|
"log"
|
|
"time"
|
|
)
|
|
|
|
type Model struct {
|
|
// Bucket Names
|
|
mc_bucket string
|
|
mc_users_bucket string
|
|
mc_config_bucket string
|
|
web_bucket string
|
|
web_users_bucket string
|
|
|
|
// Key prefixes
|
|
user_prefix string
|
|
config_feature_prefix string
|
|
|
|
db *bolt.DB
|
|
}
|
|
|
|
func InitializeModel() *Model {
|
|
var err error
|
|
ret := new(Model)
|
|
ret.mc_bucket = "mc"
|
|
ret.mc_users_bucket = "mc_users"
|
|
ret.mc_config_bucket = "mc_config"
|
|
ret.web_bucket = "web"
|
|
ret.web_users_bucket = "web_users"
|
|
ret.user_prefix = "user_"
|
|
ret.config_feature_prefix = "feature_"
|
|
|
|
ret.db, err = bolt.Open("mc_man.db", 0600, nil)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (m *Model) closeDatabase() {
|
|
m.db.Close()
|
|
}
|
|
|
|
/* Web Server Stuff */
|
|
func (m *Model) getWebUser(username string) WebUser {
|
|
var ret WebUser
|
|
m.db.View(func(tx *bolt.Tx) error {
|
|
if web_b := tx.Bucket([]byte(m.web_bucket)); web_b != nil {
|
|
if web_u_b := web_b.Bucket([]byte(m.web_users_bucket)); web_u_b != nil {
|
|
user_key := m.user_prefix + username
|
|
if ub := web_u_b.Bucket([]byte(user_key)); ub != nil {
|
|
ret_uname := string(ub.Get([]byte("username")))
|
|
ret_pass := string(ub.Get([]byte("password")))
|
|
ret = WebUser{Username: ret_uname, Password: ret_pass}
|
|
return nil
|
|
} else {
|
|
return errors.New("Invalid User")
|
|
}
|
|
}
|
|
}
|
|
return errors.New("No Web Users")
|
|
})
|
|
return ret
|
|
}
|
|
|
|
func (m *Model) updateWebUser(u *WebUser) {
|
|
fmt.Printf("BOLT: Adding Web User %s\n", u.Username)
|
|
m.db.Update(func(tx *bolt.Tx) error {
|
|
web_b, err := tx.CreateBucketIfNotExists([]byte(m.web_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
web_u_b, err := web_b.CreateBucketIfNotExists([]byte(m.web_users_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
user_key := m.user_prefix + u.Username
|
|
ub, uberr := web_u_b.CreateBucketIfNotExists([]byte(user_key))
|
|
if uberr != nil {
|
|
return uberr
|
|
}
|
|
addStringPairToBucket(ub, "username", u.Username)
|
|
addStringPairToBucket(ub, "password", u.Password)
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (m *Model) mcSaveFeature(opt string, enabled bool) {
|
|
err := m.db.Update(func(tx *bolt.Tx) error {
|
|
b, err := tx.CreateBucketIfNotExists([]byte(m.mc_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
bc, err := b.CreateBucketIfNotExists([]byte(m.mc_config_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
addBooleanPairToBucket(bc, m.config_feature_prefix+opt, enabled)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
fmt.Printf("Save Feature Error: %s", err)
|
|
}
|
|
}
|
|
|
|
func (m *Model) mcFeatureIsEnabled(opt string) bool {
|
|
ret := false
|
|
m.db.View(func(tx *bolt.Tx) error {
|
|
lookingfor := []byte(opt)
|
|
b := tx.Bucket([]byte(m.mc_bucket))
|
|
if b != nil {
|
|
bc := b.Bucket([]byte(m.mc_config_bucket))
|
|
c := bc.Cursor()
|
|
srch_prefix := []byte(m.config_feature_prefix + opt)
|
|
fmt.Printf("%s:%s=> ", string(m.mc_config_bucket), string(srch_prefix))
|
|
for k, v := c.Seek(srch_prefix); bytes.HasPrefix(k, srch_prefix); k, v = c.Next() {
|
|
// k should be the feature name, v is whether it is enabled or not
|
|
fmt.Printf("%s == %s => ", string(k), string(lookingfor))
|
|
if bytes.Equal(k, lookingfor) {
|
|
ret = bytes.Equal(v, []byte("true"))
|
|
if ret {
|
|
fmt.Printf("It's On!\n")
|
|
} else {
|
|
fmt.Printf("It's Off!\n")
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
return errors.New("Feature Not Found")
|
|
})
|
|
return ret
|
|
}
|
|
|
|
/* Minecraft Config Stuff */
|
|
func (m *Model) getMcUsers() []MCUser {
|
|
var ret []MCUser
|
|
m.db.View(func(tx *bolt.Tx) error {
|
|
b := tx.Bucket([]byte(m.mc_users_bucket))
|
|
c := b.Cursor()
|
|
srch_prefix := []byte(m.user_prefix)
|
|
for k, _ := c.Seek(srch_prefix); bytes.HasPrefix(k, srch_prefix); k, _ = c.Next() {
|
|
if user_bucket := b.Bucket(k); user_bucket != nil {
|
|
if us_name := user_bucket.Get([]byte("name")); us_name != nil {
|
|
new_user := NewMCUser(string(us_name))
|
|
new_user.IsOp = bytes.Equal(user_bucket.Get([]byte("op")), []byte("true"))
|
|
new_user.Home = string(user_bucket.Get([]byte("home")))
|
|
new_user.Porch = string(user_bucket.Get([]byte("porch")))
|
|
new_user.Quota, _ = time.ParseDuration(string(user_bucket.Get([]byte("quota"))))
|
|
new_user.quotaUsed, _ = time.ParseDuration(string(user_bucket.Get([]byte("quota_used"))))
|
|
ret = append(ret, *new_user)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
return ret
|
|
}
|
|
|
|
// updateMcUser adds or updates a user
|
|
func (m *Model) updateMcUser(u *MCUser) {
|
|
fmt.Printf("BOLT: Adding User %s\n", u.Name)
|
|
m.db.Update(func(tx *bolt.Tx) error {
|
|
mc_b, err := tx.CreateBucketIfNotExists([]byte(m.mc_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
mc_u_b, err := mc_b.CreateBucketIfNotExists([]byte(m.mc_users_bucket))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
user_key := m.user_prefix + u.Name
|
|
ub, uberr := mc_u_b.CreateBucketIfNotExists([]byte(user_key))
|
|
if uberr != nil {
|
|
return uberr
|
|
}
|
|
addStringPairToBucket(ub, "name", u.Name)
|
|
addBooleanPairToBucket(ub, "op", u.IsOp)
|
|
addStringPairToBucket(ub, "home", u.Home)
|
|
addStringPairToBucket(ub, "porch", u.Porch)
|
|
addDurationPairToBucket(ub, "quota", u.Quota)
|
|
addDurationPairToBucket(ub, "quotaused", u.quotaUsed)
|
|
addTimePairToBucket(ub, "logintime", u.loginTime)
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func addStringPairToBucket(b *bolt.Bucket, k, v string) error {
|
|
if err := b.Put([]byte(k), []byte(v)); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addBooleanPairToBucket(b *bolt.Bucket, k string, v bool) error {
|
|
write_v := "true"
|
|
if !v {
|
|
write_v = "false"
|
|
}
|
|
if err := b.Put([]byte(k), []byte(write_v)); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addDurationPairToBucket(b *bolt.Bucket, k string, v time.Duration) error {
|
|
write_v := v.String()
|
|
if err := b.Put([]byte(k), []byte(write_v)); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addTimePairToBucket(b *bolt.Bucket, k string, v time.Time) error {
|
|
if err := b.Put([]byte(k), []byte(v.String())); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|