gosora/common/user.go

/*
*
*    Gosora User File
*    Copyright Azareal 2017 - 2020
*
 */
package common

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

    //"log"

    qgen "github.com/Azareal/Gosora/query_gen"
    "github.com/go-sql-driver/mysql"
)

// TODO: Replace any literals with this
var BanGroup = 4

// TODO: Use something else as the guest avatar, maybe a question mark of some sort?
// GuestUser is an instance of user which holds guest data to avoid having to initialise a guest every time
var GuestUser = User{ID: 0, Name: "Guest", Link: "#", Group: 6, Perms: GuestPerms, CreatedAt: StartTime} // BuildAvatar is done in site.go to make sure it's done after init
var ErrNoTempGroup = errors.New("We couldn't find a temporary group for this user")

type User struct {
    ID           int
    Link         string
    Name         string
    Email        string
    Group        int
    Active       bool
    IsMod        bool
    IsSuperMod   bool
    IsAdmin      bool
    IsSuperAdmin bool
    IsBanned     bool
    Perms        Perms
    PluginPerms  map[string]bool
    Session      string
    //AuthToken    string
    Loggedin    bool
    RawAvatar   string
    Avatar      string
    MicroAvatar string
    Message     string
    // TODO: Implement something like this for profiles?
    //URLPrefix   string // Move this to another table? Create a user lite?
    //URLName     string
    Tag       string
    Level     int
    Score     int
    Posts     int
    Liked     int
    CreatedAt time.Time
    LastIP    string // ! This part of the UserCache data might fall out of date
    LastAgent int    // ! Temporary hack for http push, don't use
    TempGroup int

    ParseSettings *ParseSettings
    Privacy       UserPrivacy
}

type UserPrivacy struct {
    ShowComments int  // 0 = default, 1 = public, 2 = registered, 3 = friends, 4 = self, 5 = disabled / unused
    AllowMessage int  // 0 = default, 1 = registered, 2 = friends, 3 = mods, 4 = disabled / unused
    NoPresence   bool // false = default, true = true
}

func (u *User) WebSockets() *WsJSONUser {
    groupID := u.Group
    if u.TempGroup != 0 {
        groupID = u.TempGroup
    }
    // TODO: Do we want to leak the user's permissions? Users will probably be able to see their status from the group tags, but still
    return &WsJSONUser{u.ID, u.Link, u.Name, groupID, u.IsMod, u.Avatar, u.MicroAvatar, u.Level, u.Score, u.Liked}
}

// Use struct tags to avoid having to define this? It really depends on the circumstances, sometimes we want the whole thing, sometimes... not.
type WsJSONUser struct {
    ID          int
    Link        string
    Name        string
    Group       int // Be sure to mask with TempGroup
    IsMod       bool
    Avatar      string
    MicroAvatar string
    Level       int
    Score       int
    Liked       int
}

func (u *User) Me() *MeUser {
    groupID := u.Group
    if u.TempGroup != 0 {
        groupID = u.TempGroup
    }
    return &MeUser{u.ID, u.Link, u.Name, groupID, u.Active, u.IsMod, u.IsSuperMod, u.IsAdmin, u.IsBanned, u.Session, u.Avatar, u.MicroAvatar, u.Tag, u.Level, u.Score, u.Liked}
}

// For when users need to see their own data, I've omitted some redundancies and less useful items, so we don't wind up sending them on every request
type MeUser struct {
    ID         int
    Link       string
    Name       string
    Group      int
    Active     bool
    IsMod      bool
    IsSuperMod bool
    IsAdmin    bool
    IsBanned   bool

    // TODO: Implement these as copies (might already be the case for Perms, but we'll want to look at it's definition anyway)
    //Perms       Perms
    //PluginPerms map[string]bool

    S           string // Session
    Avatar      string
    MicroAvatar string
    Tag         string
    Level       int
    Score       int
    Liked       int
}

type UserStmts struct {
    activate    *sql.Stmt
    changeGroup *sql.Stmt
    delete      *sql.Stmt
    setAvatar   *sql.Stmt
    setName     *sql.Stmt
    update      *sql.Stmt

    // TODO: Split these into a sub-struct
    incScore         *sql.Stmt
    incPosts         *sql.Stmt
    incBigposts      *sql.Stmt
    incMegaposts     *sql.Stmt
    incPostStats     *sql.Stmt
    incBigpostStats  *sql.Stmt
    incMegapostStats *sql.Stmt
    incLiked         *sql.Stmt
    incTopics        *sql.Stmt
    updateLevel      *sql.Stmt
    resetStats       *sql.Stmt
    setStats         *sql.Stmt

    decLiked      *sql.Stmt
    updateLastIP  *sql.Stmt
    updatePrivacy *sql.Stmt

    setPassword *sql.Stmt

    scheduleAvatarResize *sql.Stmt

    deletePosts            *sql.Stmt
    deleteProfilePosts     *sql.Stmt
    deleteReplyPosts       *sql.Stmt
    getLikedRepliesOfTopic *sql.Stmt
    getAttachmentsOfTopic  *sql.Stmt
    getAttachmentsOfTopic2 *sql.Stmt
    getRepliesOfTopic      *sql.Stmt
}

var userStmts UserStmts

func init() {
    DbInits.Add(func(acc *qgen.Accumulator) error {
        u, w := "users", "uid=?"
        set := func(s string) *sql.Stmt {
            return acc.Update(u).Set(s).Where(w).Prepare()
        }
        userStmts = UserStmts{
            activate:    set("active=1"),
            changeGroup: set("group=?"), // TODO: Implement user_count for users_groups here
            delete:      acc.Delete(u).Where(w).Prepare(),
            setAvatar:   set("avatar=?"),
            setName:     set("name=?"),
            update:      set("name=?,email=?,group=?"), // TODO: Implement user_count for users_groups on things which use this

            // Stat Statements
            // TODO: Do +0 to avoid having as many statements?
            incScore:         set("score=score+?"),
            incPosts:         set("posts=posts+?"),
            incBigposts:      set("posts=posts+?,bigposts=bigposts+?"),
            incMegaposts:     set("posts=posts+?,bigposts=bigposts+?,megaposts=megaposts+?"),
            incPostStats:     set("posts=posts+?,score=score+?,level=?"),
            incBigpostStats:  set("posts=posts+?,bigposts=bigposts+?,score=score+?,level=?"),
            incMegapostStats: set("posts=posts+?,bigposts=bigposts+?,megaposts=megaposts+?,score=score+?,level=?"),
            incTopics:        set("topics=topics+?"),
            updateLevel:      set("level=?"),
            resetStats:       set("score=0,posts=0,bigposts=0,megaposts=0,topics=0,level=0"),
            setStats:         set("score=?,posts=?,bigposts=?,megaposts=?,topics=?,level=?"),

            incLiked: set("liked=liked+?,lastLiked=UTC_TIMESTAMP()"),
            decLiked: set("liked=liked-?"),
            //recalcLastLiked: acc...
            updateLastIP:  set("last_ip=?"),
            updatePrivacy: set("profile_comments=?,enable_embeds=?"),

            setPassword: set("password=?,salt=?"),

            scheduleAvatarResize: acc.Insert("users_avatar_queue").Columns("uid").Fields("?").Prepare(),

            // Delete All Posts Statements
            deletePosts:            acc.Select("topics").Columns("tid,parentID,postCount,poll").Where("createdBy=?").Prepare(),
            deleteProfilePosts:     acc.Select("users_replies").Columns("rid,uid").Where("createdBy=?").Prepare(),
            deleteReplyPosts:       acc.Select("replies").Columns("rid,tid").Where("createdBy=?").Prepare(),
            getLikedRepliesOfTopic: acc.Select("replies").Columns("rid").Where("tid=? AND likeCount>0").Prepare(),
            getAttachmentsOfTopic:  acc.Select("attachments").Columns("attachID").Where("originID=? AND originTable='topics'").Prepare(),
            getAttachmentsOfTopic2: acc.Select("attachments").Columns("attachID").Where("extra=? AND originTable='replies'").Prepare(),
            getRepliesOfTopic:      acc.Select("replies").Columns("words").Where("createdBy!=? AND tid=?").Prepare(),
        }
        return acc.FirstError()
    })
}

func (u *User) Init() {
    // TODO: Let admins configure the minimum default?
    if u.Privacy.ShowComments < 1 {
        u.Privacy.ShowComments = 1
    }
    u.Avatar, u.MicroAvatar = BuildAvatar(u.ID, u.RawAvatar)
    u.Link = BuildProfileURL(NameToSlug(u.Name), u.ID)
    u.Tag = Groups.DirtyGet(u.Group).Tag
    u.InitPerms()
}

// TODO: Refactor this idiom into something shorter, maybe with a NullUserCache when one isn't set?
func (u *User) CacheRemove() {
    if uc := Users.GetCache(); uc != nil {
        uc.Remove(u.ID)
    }
    TopicListThaw.Thaw()
}

func (u *User) Ban(dur time.Duration, issuedBy int) error {
    return u.ScheduleGroupUpdate(BanGroup, issuedBy, dur)
}

func (u *User) Unban() error {
    return u.RevertGroupUpdate()
}

func (u *User) deleteScheduleGroupTx(tx *sql.Tx) error {
    deleteScheduleGroupStmt, e := qgen.Builder.SimpleDeleteTx(tx, "users_groups_scheduler", "uid=?")
    if e != nil {
        return e
    }
    _, e = deleteScheduleGroupStmt.Exec(u.ID)
    return e
}

func (u *User) setTempGroupTx(tx *sql.Tx, tempGroup int) error {
    setTempGroupStmt, e := qgen.Builder.SimpleUpdateTx(tx, "users", "temp_group=?", "uid=?")
    if e != nil {
        return e
    }
    _, e = setTempGroupStmt.Exec(tempGroup, u.ID)
    return e
}

// Make this more stateless?
func (u *User) ScheduleGroupUpdate(gid, issuedBy int, dur time.Duration) error {
    var temp bool
    if dur.Nanoseconds() != 0 {
        temp = true
    }
    revertAt := time.Now().Add(dur)

    tx, e := qgen.Builder.Begin()
    if e != nil {
        return e
    }
    defer tx.Rollback()

    e = u.deleteScheduleGroupTx(tx)
    if e != nil {
        return e
    }

    createScheduleGroupTx, e := qgen.Builder.SimpleInsertTx(tx, "users_groups_scheduler", "uid,set_group,issued_by,issued_at,revert_at,temporary", "?,?,?,UTC_TIMESTAMP(),?,?")
    if e != nil {
        return e
    }
    _, e = createScheduleGroupTx.Exec(u.ID, gid, issuedBy, revertAt, temp)
    if e != nil {
        return e
    }

    e = u.setTempGroupTx(tx, gid)
    if e != nil {
        return e
    }
    e = tx.Commit()

    u.CacheRemove()
    return e
}

func (u *User) RevertGroupUpdate() error {
    tx, e := qgen.Builder.Begin()
    if e != nil {
        return e
    }
    defer tx.Rollback()

    e = u.deleteScheduleGroupTx(tx)
    if e != nil {
        return e
    }

    e = u.setTempGroupTx(tx, 0)
    if e != nil {
        return e
    }
    e = tx.Commit()

    u.CacheRemove()
    return e
}

// TODO: Use a transaction here
// ? - Add a Deactivate method? Not really needed, if someone's been bad you could do a ban, I guess it might be useful, if someone says that email x isn't actually owned by the user in question?
func (u *User) Activate() (e error) {
    _, e = userStmts.activate.Exec(u.ID)
    if e != nil {
        return e
    }
    _, e = userStmts.changeGroup.Exec(Config.DefaultGroup, u.ID)
    u.CacheRemove()
    return e
}

// TODO: Write tests for this
// TODO: Delete this user's content too?
// TODO: Expose this to the admin?
func (u *User) Delete() error {
    _, e := userStmts.delete.Exec(u.ID)
    u.CacheRemove()
    return e
}

// TODO: dismiss-event
func (u *User) DeletePosts() error {
    rows, err := userStmts.deletePosts.Query(u.ID)
    if err != nil {
        return err
    }
    defer rows.Close()
    defer TopicListThaw.Thaw()
    defer u.CacheRemove()

    updatedForums := make(map[int]int) // forum[count]
    tc := Topics.GetCache()
    umap := make(map[int]struct{})
    for rows.Next() {
        var tid, parentID, postCount, poll int
        err := rows.Scan(&tid, &parentID, &postCount, &poll)
        if err != nil {
            return err
        }
        // TODO: Clear reply cache too
        _, err = topicStmts.delete.Exec(tid)
        if tc != nil {
            tc.Remove(tid)
        }
        if err != nil {
            return err
        }
        updatedForums[parentID] = updatedForums[parentID] + 1

        _, err = topicStmts.deleteLikesForTopic.Exec(tid)
        if err != nil {
            return err
        }
        err = handleTopicAttachments(tid)
        if err != nil {
            return err
        }
        if postCount > 1 {
            err = handleLikedTopicReplies(tid)
            if err != nil {
                return err
            }
            err = handleTopicReplies(umap, u.ID, tid)
            if err != nil {
                return err
            }
            _, err = topicStmts.deleteReplies.Exec(tid)
            if err != nil {
                return err
            }
        }
        err = Subscriptions.DeleteResource(tid, "topic")
        if err != nil {
            return err
        }
        _, err = topicStmts.deleteActivity.Exec(tid)
        if err != nil {
            return err
        }
        if poll > 0 {
            err = (&Poll{ID: poll}).Delete()
            if err != nil {
                return err
            }
        }
    }
    if err = rows.Err(); err != nil {
        return err
    }
    err = u.ResetPostStats()
    if err != nil {
        return err
    }
    for uid, _ := range umap {
        err = (&User{ID: uid}).RecalcPostStats()
        if err != nil {
            return err
        }
    }
    for fid, count := range updatedForums {
        err := Forums.RemoveTopics(fid, count)
        if err != nil && err != ErrNoRows {
            return err
        }
    }

    rows, err = userStmts.deleteProfilePosts.Query(u.ID)
    if err != nil {
        return err
    }
    defer rows.Close()

    for rows.Next() {
        var rid, uid int
        err := rows.Scan(&rid, &uid)
        if err != nil {
            return err
        }
        _, err = profileReplyStmts.delete.Exec(rid)
        if err != nil {
            return err
        }
        // TODO: Optimise this
        // TODO: dismiss-event
        err = Activity.DeleteByParamsExtra("reply", uid, "user", strconv.Itoa(rid))
        if err != nil {
            return err
        }
    }
    if err = rows.Err(); err != nil {
        return err
    }

    rows, err = userStmts.deleteReplyPosts.Query(u.ID)
    if err != nil {
        return err
    }
    defer rows.Close()

    rc := Rstore.GetCache()
    for rows.Next() {
        var rid, tid int
        err := rows.Scan(&rid, &tid)
        if err != nil {
            return err
        }
        _, err = replyStmts.delete.Exec(rid)
        if err != nil {
            return err
        }
        // TODO: Move this bit to *Topic
        _, err = replyStmts.removeRepliesFromTopic.Exec(1, tid)
        if err != nil {
            return err
        }
        _, err = replyStmts.updateTopicReplies.Exec(tid)
        if err != nil {
            return err
        }
        _, err = replyStmts.updateTopicReplies2.Exec(tid)
        if tc != nil {
            tc.Remove(tid)
        }
        _ = rc.Remove(rid)
        if err != nil {
            return err
        }

        _, err = replyStmts.deleteLikesForReply.Exec(rid)
        if err != nil {
            return err
        }
        err = Activity.DeleteByParamsExtra("reply", tid, "topic", strconv.Itoa(rid))
        if err != nil {
            return err
        }
        _, err = replyStmts.deleteActivitySubs.Exec(rid)
        if err != nil {
            return err
        }
        _, err = replyStmts.deleteActivity.Exec(rid)
        if err != nil {
            return err
        }
        // TODO: Restructure alerts so we can delete the "x replied to topic" ones too.
    }
    return rows.Err()
}

func (u *User) bindStmt(stmt *sql.Stmt, params ...interface{}) (e error) {
    params = append(params, u.ID)
    _, e = stmt.Exec(params...)
    u.CacheRemove()
    return e
}

func (u *User) ChangeName(name string) error {
    return u.bindStmt(userStmts.setName, name)
}

func (u *User) ChangeAvatar(avatar string) error {
    return u.bindStmt(userStmts.setAvatar, avatar)
}

// TODO: Abstract this with an interface so we can scale this with an actual dedicated queue in a real cluster
func (u *User) ScheduleAvatarResize() (e error) {
    _, e = userStmts.scheduleAvatarResize.Exec(u.ID)
    if e != nil {
        // TODO: Do a more generic check so that we're not as tied to MySQL
        me, ok := e.(*mysql.MySQLError)
        if !ok {
            return e
        }
        // If it's just telling us that the item already exists in the database, then we can ignore it, as it doesn't matter if it's this call or another which schedules the item in the queue
        if me.Number != 1062 {
            return e
        }
    }
    return nil
}

func (u *User) ChangeGroup(group int) error {
    return u.bindStmt(userStmts.changeGroup, group)
}

func (u *User) GetIP() string {
    spl := strings.Split(u.LastIP, "-")
    return spl[len(spl)-1]
}

// ! Only updates the database not the *User for safety reasons
func (u *User) UpdateIP(ip string) error {
    _, e := userStmts.updateLastIP.Exec(ip, u.ID)
    if uc := Users.GetCache(); uc != nil {
        uc.Remove(u.ID)
    }
    return e
}

//var ErrMalformedInteger = errors.New("malformed integer")
var ErrProfileCommentsOutOfBounds = errors.New("profile_comments must be an integer between -1 and 4")
var ErrEnableEmbedsOutOfBounds = errors.New("enable_embeds must be -1, 0 or 1")

/*func (u *User) UpdatePrivacyS(sProfileComments, sEnableEmbeds string) error {
    return u.UpdatePrivacy(profileComments, enableEmbeds)
}*/

func (u *User) UpdatePrivacy(profileComments, enableEmbeds int) error {
    if profileComments < -1 || profileComments > 4 {
        return ErrProfileCommentsOutOfBounds
    }
    if enableEmbeds < -1 || enableEmbeds > 1 {
        return ErrEnableEmbedsOutOfBounds
    }
    _, e := userStmts.updatePrivacy.Exec(profileComments, enableEmbeds, u.ID)
    if uc := Users.GetCache(); uc != nil {
        uc.Remove(u.ID)
    }
    return e
}

func (u *User) Update(name, email string, group int) (err error) {
    return u.bindStmt(userStmts.update, name, email, group)
}

func (u *User) IncreasePostStats(wcount int, topic bool) (err error) {
    baseScore := 1
    if topic {
        _, err = userStmts.incTopics.Exec(1, u.ID)
        if err != nil {
            return err
        }
        baseScore = 2
    }

    settings := SettingBox.Load().(SettingMap)
    var mod, level int
    if wcount >= settings["megapost_min_words"].(int) {
        mod = 4
        level = GetLevel(u.Score + baseScore + mod)
        _, err = userStmts.incMegapostStats.Exec(1, 1, 1, baseScore+mod, level, u.ID)
    } else if wcount >= settings["bigpost_min_words"].(int) {
        mod = 1
        level = GetLevel(u.Score + baseScore + mod)
        _, err = userStmts.incBigpostStats.Exec(1, 1, baseScore+mod, level, u.ID)
    } else {
        level = GetLevel(u.Score + baseScore + mod)
        _, err = userStmts.incPostStats.Exec(1, baseScore+mod, level, u.ID)
    }
    if err != nil {
        return err
    }
    err = GroupPromotions.PromoteIfEligible(u, level, u.Posts+1, u.CreatedAt)
    u.CacheRemove()
    return err
}

func (u *User) countf(stmt *sql.Stmt) (count int) {
    e := stmt.QueryRow().Scan(&count)
    if e != nil {
        LogError(e)
    }
    return count
}

func (u *User) RecalcPostStats() error {
    var score int
    tcount := Topics.CountUser(u.ID)
    rcount := Rstore.CountUser(u.ID)
    //log.Print("tcount:", tcount)
    //log.Print("rcount:", rcount)
    score += tcount * 2
    score += rcount

    var tmega, tbig, rmega, rbig int
    if tcount > 0 {
        tmega = Topics.CountMegaUser(u.ID)
        score += tmega * 3
        tbig := Topics.CountBigUser(u.ID)
        score += tbig
    }
    if rcount > 0 {
        rmega = Rstore.CountMegaUser(u.ID)
        score += rmega * 3
        rbig = Rstore.CountBigUser(u.ID)
        score += rbig
    }

    _, err := userStmts.setStats.Exec(score, tcount+rcount, tbig+rbig, tmega+rmega, tcount, GetLevel(score), u.ID)
    u.CacheRemove()
    return err
}

func (u *User) DecreasePostStats(wcount int, topic bool) (err error) {
    baseScore := -1
    if topic {
        _, err = userStmts.incTopics.Exec(-1, u.ID)
        if err != nil {
            return err
        }
        baseScore = -2
    }

    // TODO: Use a transaction to prevent level desyncs?
    var mod int
    settings := SettingBox.Load().(SettingMap)
    if wcount >= settings["megapost_min_words"].(int) {
        mod = 4
        _, err = userStmts.incMegapostStats.Exec(-1, -1, -1, baseScore-mod, GetLevel(u.Score-baseScore-mod), u.ID)
    } else if wcount >= settings["bigpost_min_words"].(int) {
        mod = 1
        _, err = userStmts.incBigpostStats.Exec(-1, -1, baseScore-mod, GetLevel(u.Score-baseScore-mod), u.ID)
    } else {
        _, err = userStmts.incPostStats.Exec(-1, baseScore-mod, GetLevel(u.Score-baseScore-mod), u.ID)
    }
    u.CacheRemove()
    return err
}

func (u *User) ResetPostStats() error {
    _, err := userStmts.resetStats.Exec(u.ID)
    u.CacheRemove()
    return err
}

// Copy gives you a non-pointer concurrency safe copy of the user
func (u *User) Copy() User {
    return *u
}

// TODO: Write unit tests for this
func (u *User) InitPerms() {
    if u.TempGroup != 0 {
        u.Group = u.TempGroup
    }

    group := Groups.DirtyGet(u.Group)
    if u.IsSuperAdmin {
        u.Perms = AllPerms
        u.PluginPerms = AllPluginPerms
    } else {
        u.Perms = group.Perms
        u.PluginPerms = group.PluginPerms
    }
    /*if len(group.CanSee) == 0 {
        panic("should not be zero")
    }*/

    u.IsAdmin = u.IsSuperAdmin || group.IsAdmin
    u.IsSuperMod = u.IsAdmin || group.IsMod
    u.IsMod = u.IsSuperMod
    u.IsBanned = group.IsBanned
    if u.IsBanned && u.IsSuperMod {
        u.IsBanned = false
    }
}

// TODO: Write unit tests for this
func InitPerms2(group int, superAdmin bool, tempGroup int) (perms *Perms, admin, superMod, banned bool) {
    if tempGroup != 0 {
        group = tempGroup
    }

    g := Groups.DirtyGet(group)
    if superAdmin {
        perms = &AllPerms
    } else {
        perms = &g.Perms
    }

    admin = superAdmin || g.IsAdmin
    superMod = admin || g.IsMod
    banned = g.IsBanned
    if banned && superMod {
        banned = false
    }
    return perms, admin, superMod, banned
}

// TODO: Write tests
// TODO: Implement and use this
// TODO: Implement friends
func PrivacyAllowMessage(pu, u *User) (canMsg bool) {
    switch pu.Privacy.AllowMessage {
    case 4: // Unused
        canMsg = false
    case 3: // mods
        canMsg = u.IsSuperMod
    //case 2: // friends
    case 1: // registered
        canMsg = true
    default: // 0
        canMsg = true
    }
    return canMsg
}

// TODO: Implement friend system
func PrivacyCommentsShow(pu, u *User) (showComments bool) {
    switch pu.Privacy.ShowComments {
    case 5: // Unused
        showComments = false
    case 4: // Self
        showComments = u.ID == pu.ID
    case 3: // friends
        showComments = u.ID == pu.ID
    case 2: // registered
        showComments = u.Loggedin
    case 1: // public
        showComments = true
    default: // 0
        showComments = true
    }
    return showComments
}

var guestAvatar GuestAvatar

type GuestAvatar struct {
    Normal string
    Micro  string
}

func buildNoavatar(uid, width int) string {
    if !Config.DisableNoavatarRange {
        // TODO: Find a faster algorithm
        l := func(max int) {
            for uid > max {
                uid -= max
            }
        }
        l(50000)
        l(5000)
        l(500)
        l(50)
        l(10)
    }
    if !Config.DisableDefaultNoavatar && uid < 11 {
        /*if uid < 6 {
            if width == 200 {
                return noavatarCache200Avif[uid]
            } else if width == 48 {
                return noavatarCache48Avif[uid]
            }
            return StaticFiles.Prefix + "n" + strconv.Itoa(uid) + "-" + strconv.Itoa(width) + ".avif?i=0"
        } else */if width == 200 {
            return noavatarCache200[uid]
        } else if width == 48 {
            return noavatarCache48[uid]
        }
        return StaticFiles.Prefix + "n" + strconv.Itoa(uid) + "-" + strconv.Itoa(width) + ".png?i=0"
    }
    // ? - Add a prefix setting to make this faster?
    return strings.Replace(strings.Replace(Config.Noavatar, "{id}", strconv.Itoa(uid), 1), "{width}", strconv.Itoa(width), 1)
}

// ? - Make this part of *User?
// TODO: Write tests for this
func BuildAvatar(uid int, avatar string) (normalAvatar, microAvatar string) {
    if avatar == "" {
        if uid == 0 {
            return guestAvatar.Normal, guestAvatar.Micro
        }
        return buildNoavatar(uid, 200), buildNoavatar(uid, 48)
    }
    if avatar[0] == '.' {
        if avatar[1] == '.' {
            normalAvatar = Config.AvatarResBase + "avatar_" + strconv.Itoa(uid) + "_tmp" + avatar[1:]
            return normalAvatar, normalAvatar
        }
        normalAvatar = Config.AvatarResBase + "avatar_" + strconv.Itoa(uid) + avatar
        return normalAvatar, normalAvatar
    }
    return avatar, avatar
}

// TODO: Move this to *User
func SetPassword(uid int, password string) error {
    hashedPassword, salt, err := GeneratePassword(password)
    if err != nil {
        return err
    }
    _, err = userStmts.setPassword.Exec(hashedPassword, salt, uid)
    return err
}

// TODO: Write units tests for this
func wordsToScore(wcount int, topic bool) (score int) {
    if topic {
        score = 2
    } else {
        score = 1
    }
    settings := SettingBox.Load().(SettingMap)
    if wcount >= settings["megapost_min_words"].(int) {
        score += 4
    } else if wcount >= settings["bigpost_min_words"].(int) {
        score++
    }
    return score
}

// For use in tests and to help generate dummy users for forums which don't have last posters
func BlankUser() *User {
    return new(User)
}

// TODO: Write unit tests for this
func BuildProfileURL(slug string, uid int) string {
    if slug == "" || !Config.BuildSlugs {
        return "/user/" + strconv.Itoa(uid)
    }
    return "/user/" + slug + "." + strconv.Itoa(uid)
}

func BuildProfileURLSb(sb *strings.Builder, slug string, uid int) {
    if slug == "" || !Config.BuildSlugs {
        sb.Grow(6 + 1)
        sb.WriteString("/user/")
        sb.WriteString(strconv.Itoa(uid))
        return
    }
    sb.Grow(7 + 1 + len(slug))
    sb.WriteString("/user/")
    sb.WriteString(slug)
    sb.WriteRune('.')
    sb.WriteString(strconv.Itoa(uid))
}