gosora/common/user_store.go

package common

import (
	"database/sql"
	"errors"
	"strconv"

	qgen "github.com/Azareal/Gosora/query_gen"
	"golang.org/x/crypto/bcrypt"
)

// TODO: Add the watchdog goroutine
// TODO: Add some sort of update method
var Users UserStore
var ErrAccountExists = errors.New("this username is already in use")
var ErrLongUsername = errors.New("this username is too long")

type UserStore interface {
	DirtyGet(id int) *User
	Get(id int) (*User, error)
	GetByName(name string) (*User, error)
	Exists(id int) bool
	GetOffset(offset, perPage int) ([]*User, error)
	Each(f func(*User) error) error
	//BulkGet(ids []int) ([]*User, error)
	BulkGetMap(ids []int) (map[int]*User, error)
	BypassGet(id int) (*User, error)
	Create(name string, password string, email string, group int, active bool) (int, error)
	Reload(id int) error
	Count() int

	SetCache(cache UserCache)
	GetCache() UserCache
}

type DefaultUserStore struct {
	cache UserCache

	get        *sql.Stmt
	getByName  *sql.Stmt
	getOffset  *sql.Stmt
	getAll *sql.Stmt
	exists     *sql.Stmt
	register   *sql.Stmt
	nameExists *sql.Stmt
	count      *sql.Stmt
}

// NewDefaultUserStore gives you a new instance of DefaultUserStore
func NewDefaultUserStore(cache UserCache) (*DefaultUserStore, error) {
	acc := qgen.NewAcc()
	if cache == nil {
		cache = NewNullUserCache()
	}
	u := "users"
	// TODO: Add an admin version of registerStmt with more flexibility?
	return &DefaultUserStore{
		cache:      cache,
		get:        acc.Select(u).Columns("name, group, active, is_super_admin, session, email, avatar, message, level, score, posts, liked, last_ip, temp_group, enable_embeds").Where("uid = ?").Prepare(),
		getByName:  acc.Select(u).Columns("uid, name, group, active, is_super_admin, session, email, avatar, message, level, score, posts, liked, last_ip, temp_group, enable_embeds").Where("name = ?").Prepare(),
		getOffset:  acc.Select(u).Columns("uid, name, group, active, is_super_admin, session, email, avatar, message, level, score, posts, liked, last_ip, temp_group, enable_embeds").Orderby("uid ASC").Limit("?,?").Prepare(),
		getAll:  acc.Select(u).Columns("uid, name, group, active, is_super_admin, session, email, avatar, message, level, score, posts, liked, last_ip, temp_group, enable_embeds").Prepare(),
		exists:     acc.Exists(u, "uid").Prepare(),
		register:   acc.Insert(u).Columns("name, email, password, salt, group, is_super_admin, session, active, message, createdAt, lastActiveAt, lastLiked, oldestItemLikedCreatedAt").Fields("?,?,?,?,?,0,'',?,'',UTC_TIMESTAMP(),UTC_TIMESTAMP(),UTC_TIMESTAMP(),UTC_TIMESTAMP()").Prepare(), // TODO: Implement user_count on users_groups here
		nameExists: acc.Exists(u, "name").Prepare(),
		count:      acc.Count(u).Prepare(),
	}, acc.FirstError()
}

func (s *DefaultUserStore) DirtyGet(id int) *User {
	user, err := s.Get(id)
	if err == nil {
		return user
	}
	/*if s.OutOfBounds(id) {
		return BlankUser()
	}*/
	return BlankUser()
}

// TODO: Log weird cache errors? Not just here but in every *Cache?
func (s *DefaultUserStore) Get(id int) (*User, error) {
	u, err := s.cache.Get(id)
	if err == nil {
		//log.Print("cached user")
		//log.Print(string(debug.Stack()))
		//log.Println("")
		return u, nil
	}
	//log.Print("uncached user")

	u = &User{ID: id, Loggedin: true}
	var embeds int
	err = s.get.QueryRow(id).Scan(&u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds)
	if err == nil {
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
		s.cache.Set(u)
	}
	return u, err
}

// TODO: Log weird cache errors? Not just here but in every *Cache?
// ! This bypasses the cache, use frugally
func (s *DefaultUserStore) GetByName(name string) (*User, error) {
	u := &User{Loggedin: true}
	var embeds int
	err := s.getByName.QueryRow(name).Scan(&u.ID, &u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds)
	if err == nil {
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
		s.cache.Set(u)
	}
	return u, err
}

// TODO: Optimise this, so we don't wind up hitting the database every-time for small gaps
// TODO: Make this a little more consistent with DefaultGroupStore's GetRange method
func (s *DefaultUserStore) GetOffset(offset, perPage int) (users []*User, err error) {
	rows, err := s.getOffset.Query(offset, perPage)
	if err != nil {
		return users, err
	}
	defer rows.Close()

	var embeds int
	for rows.Next() {
		u := &User{Loggedin: true}
		err := rows.Scan(&u.ID, &u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds)
		if err != nil {
			return nil, err
		}
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
		s.cache.Set(u)
		users = append(users, u)
	}
	return users, rows.Err()
}
func (s *DefaultUserStore) Each(f func(*User) error) error {
	rows, err := s.getAll.Query()
	if err != nil {
		return err
	}
	defer rows.Close()
	var embeds int
	for rows.Next() {
		u := new(User)
		if err := rows.Scan(&u.ID, &u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds); err != nil {
			return err
		}
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
		if err := f(u); err != nil {
			return err
		}
	}
	return rows.Err()
}

// TODO: Optimise the query to avoid preparing it on the spot? Maybe, use knowledge of the most common IN() parameter counts?
// TODO: ID of 0 should always error?
func (s *DefaultUserStore) BulkGetMap(ids []int) (list map[int]*User, err error) {
	idCount := len(ids)
	list = make(map[int]*User)
	if idCount == 0 {
		return list, nil
	}

	var stillHere []int
	sliceList := s.cache.BulkGet(ids)
	if len(sliceList) > 0 {
		for i, sliceItem := range sliceList {
			if sliceItem != nil {
				list[sliceItem.ID] = sliceItem
			} else {
				stillHere = append(stillHere, ids[i])
			}
		}
		ids = stillHere
	}

	// If every user is in the cache, then return immediately
	if len(ids) == 0 {
		return list, nil
	} else if len(ids) == 1 {
		user, err := s.Get(ids[0])
		if err != nil {
			return list, err
		}
		list[user.ID] = user
		return list, nil
	}

	// TODO: Add a function for the q stuff
	var q string
	idList := make([]interface{}, len(ids))
	for i, id := range ids {
		idList[i] = strconv.Itoa(id)
		q += "?,"
	}
	q = q[0 : len(q)-1]

	rows, err := qgen.NewAcc().Select("users").Columns("uid,name,group,active,is_super_admin,session,email,avatar,message,level,score,posts,liked,last_ip,temp_group,enable_embeds").Where("uid IN(" + q + ")").Query(idList...)
	if err != nil {
		return list, err
	}
	defer rows.Close()

	var embeds int
	for rows.Next() {
		u := &User{Loggedin: true}
		err := rows.Scan(&u.ID, &u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds)
		if err != nil {
			return list, err
		}
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
		s.cache.Set(u)
		list[u.ID] = u
	}
	if err = rows.Err(); err != nil {
		return list, err
	}

	// Did we miss any users?
	if idCount > len(list) {
		var sidList string
		for _, id := range ids {
			_, ok := list[id]
			if !ok {
				sidList += strconv.Itoa(id) + ","
			}
		}
		if sidList != "" {
			sidList = sidList[0 : len(sidList)-1]
			err = errors.New("Unable to find users with the following IDs: " + sidList)
		}
	}

	return list, err
}

func (s *DefaultUserStore) BypassGet(id int) (*User, error) {
	u := &User{ID: id, Loggedin: true}
	var embeds int
	err := s.get.QueryRow(id).Scan(&u.Name, &u.Group, &u.Active, &u.IsSuperAdmin, &u.Session, &u.Email, &u.RawAvatar, &u.Message, &u.Level, &u.Score, &u.Posts, &u.Liked, &u.LastIP, &u.TempGroup, &embeds)
	if err == nil {
		if embeds != -1 {
			u.ParseSettings = DefaultParseSettings.CopyPtr()
			u.ParseSettings.NoEmbed = embeds == 0
		}
		u.Init()
	}
	return u, err
}

func (s *DefaultUserStore) Reload(id int) error {
	u, err := s.BypassGet(id)
	if err != nil {
		s.cache.Remove(id)
		return err
	}
	_ = s.cache.Set(u)
	TopicListThaw.Thaw()
	return nil
}

func (s *DefaultUserStore) Exists(id int) bool {
	err := s.exists.QueryRow(id).Scan(&id)
	if err != nil && err != ErrNoRows {
		LogError(err)
	}
	return err != ErrNoRows
}

// TODO: Change active to a bool?
// TODO: Use unique keys for the usernames
func (s *DefaultUserStore) Create(name, password, email string, group int, active bool) (int, error) {
	// TODO: Strip spaces?

	// ? This number might be a little screwy with Unicode, but it's the only consistent thing we have, as Unicode characters can be any number of bytes in theory?
	if len(name) > Config.MaxUsernameLength {
		return 0, ErrLongUsername
	}

	// Is this name already taken..?
	err := s.nameExists.QueryRow(name).Scan(&name)
	if err != ErrNoRows {
		return 0, ErrAccountExists
	}
	salt, err := GenerateSafeString(SaltLength)
	if err != nil {
		return 0, err
	}
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password+salt), bcrypt.DefaultCost)
	if err != nil {
		return 0, err
	}

	res, err := s.register.Exec(name, email, string(hashedPassword), salt, group, active)
	if err != nil {
		return 0, err
	}
	lastID, err := res.LastInsertId()
	return int(lastID), err
}

// Count returns the total number of users registered on the forums
func (s *DefaultUserStore) Count() (count int) {
	return Countf(s.count)
}

func (s *DefaultUserStore) SetCache(cache UserCache) {
	s.cache = cache
}

// TODO: We're temporarily doing this so that you can do ucache != nil in getTopicUser. Refactor it.
func (s *DefaultUserStore) GetCache() UserCache {
	_, ok := s.cache.(*NullUserCache)
	if ok {
		return nil
	}
	return s.cache
}