pronounsfu/backend/db/user.go

321 lines
7.7 KiB
Go

package db
import (
"context"
"regexp"
"time"
"codeberg.org/u1f320/pronouns.cc/backend/db/queries"
"emperror.dev/errors"
"github.com/bwmarrin/discordgo"
"github.com/jackc/pgconn"
"github.com/jackc/pgtype"
"github.com/jackc/pgx/v4"
"github.com/rs/xid"
)
type User struct {
ID xid.ID
Username string
DisplayName *string
Bio *string
AvatarURLs []string `db:"avatar_urls"`
Links []string
Names []FieldEntry
Pronouns []PronounEntry
Discord *string
DiscordUsername *string
MaxInvites int
DeletedAt *time.Time
SelfDelete *bool
DeleteReason *string
}
// usernames must match this regex
var usernameRegex = regexp.MustCompile(`^[\w-.]{2,40}$`)
const (
ErrUserNotFound = errors.Sentinel("user not found")
ErrUsernameTaken = errors.Sentinel("username is already taken")
ErrInvalidUsername = errors.Sentinel("username contains invalid characters")
ErrUsernameTooShort = errors.Sentinel("username is too short")
ErrUsernameTooLong = errors.Sentinel("username is too long")
)
const (
MaxUsernameLength = 40
MaxDisplayNameLength = 100
MaxUserBioLength = 1000
MaxUserLinksLength = 25
MaxLinkLength = 256
)
// CreateUser creates a user with the given username.
func (db *DB) CreateUser(ctx context.Context, tx pgx.Tx, username string) (u User, err error) {
// check if the username is valid
// if not, return an error depending on what failed
if !usernameRegex.MatchString(username) {
if len(username) < 2 {
return u, ErrUsernameTooShort
} else if len(username) > 40 {
return u, ErrUsernameTooLong
}
return u, ErrInvalidUsername
}
sql, args, err := sq.Insert("users").Columns("id", "username").Values(xid.New(), username).Suffix("RETURNING id").ToSql()
if err != nil {
return u, errors.Wrap(err, "building sql")
}
var id xid.ID
err = tx.QueryRow(ctx, sql, args...).Scan(&id)
if err != nil {
pge := &pgconn.PgError{}
if errors.As(err, &pge) {
// unique constraint violation
if pge.Code == "23505" {
return u, ErrUsernameTaken
}
}
return u, errors.Cause(err)
}
return db.getUser(ctx, tx, id)
}
// DiscordUser fetches a user by Discord user ID.
func (db *DB) DiscordUser(ctx context.Context, discordID string) (u User, err error) {
sql, args, err := sq.Select("id").From("users").Where("discord = ?", discordID).ToSql()
if err != nil {
return u, errors.Wrap(err, "building sql")
}
var id xid.ID
err = db.QueryRow(ctx, sql, args...).Scan(&id)
if err != nil {
if errors.Cause(err) == pgx.ErrNoRows {
return u, ErrUserNotFound
}
return u, errors.Wrap(err, "executing id query")
}
return db.getUser(ctx, db, id)
}
func (u *User) UpdateFromDiscord(ctx context.Context, db querier, du *discordgo.User) error {
sql, args, err := sq.Update("users").
Set("discord", du.ID).
Set("discord_username", du.String()).
Where("id = ?", u.ID).
ToSql()
if err != nil {
return errors.Wrap(err, "building sql")
}
_, err = db.Exec(ctx, sql, args...)
if err != nil {
return errors.Wrap(err, "executing query")
}
u.Discord = &du.ID
username := du.String()
u.DiscordUsername = &username
return nil
}
func (db *DB) getUser(ctx context.Context, q querier, id xid.ID) (u User, err error) {
qu, err := queries.NewQuerier(q).GetUserByID(ctx, id.String())
if err != nil {
if errors.Cause(err) == pgx.ErrNoRows {
return u, ErrUserNotFound
}
return u, errors.Wrap(err, "getting user from database")
}
var deletedAt *time.Time
if qu.DeletedAt.Status == pgtype.Present {
deletedAt = &qu.DeletedAt.Time
}
u = User{
ID: id,
Username: qu.Username,
DisplayName: qu.DisplayName,
Bio: qu.Bio,
AvatarURLs: qu.AvatarUrls,
Names: fieldEntriesFromDB(qu.Names),
Pronouns: pronounsFromDB(qu.Pronouns),
Links: qu.Links,
Discord: qu.Discord,
DiscordUsername: qu.DiscordUsername,
MaxInvites: int(qu.MaxInvites),
DeletedAt: deletedAt,
SelfDelete: qu.SelfDelete,
DeleteReason: qu.DeleteReason,
}
return u, nil
}
// User gets a user by ID.
func (db *DB) User(ctx context.Context, id xid.ID) (u User, err error) {
return db.getUser(ctx, db, id)
}
// Username gets a user by username.
func (db *DB) Username(ctx context.Context, name string) (u User, err error) {
qu, err := db.q.GetUserByUsername(ctx, name)
if err != nil {
if errors.Cause(err) == pgx.ErrNoRows {
return u, ErrUserNotFound
}
return u, errors.Wrap(err, "getting user from db")
}
id, err := xid.FromString(qu.ID)
if err != nil {
return u, errors.Wrap(err, "parsing ID")
}
u = User{
ID: id,
Username: qu.Username,
DisplayName: qu.DisplayName,
Bio: qu.Bio,
AvatarURLs: qu.AvatarUrls,
Names: fieldEntriesFromDB(qu.Names),
Pronouns: pronounsFromDB(qu.Pronouns),
Links: qu.Links,
Discord: qu.Discord,
DiscordUsername: qu.DiscordUsername,
MaxInvites: int(qu.MaxInvites),
}
return u, nil
}
// UsernameTaken checks if the given username is already taken.
func (db *DB) UsernameTaken(ctx context.Context, username string) (valid, taken bool, err error) {
if !usernameRegex.MatchString(username) {
return false, false, nil
}
err = db.QueryRow(ctx, "select exists (select id from users where username = $1)", username).Scan(&taken)
return true, taken, err
}
// UpdateUsername validates the given username, then updates the given user's name to it if valid.
func (db *DB) UpdateUsername(ctx context.Context, tx pgx.Tx, id xid.ID, newName string) error {
if !usernameRegex.MatchString(newName) {
return ErrInvalidUsername
}
sql, args, err := sq.Update("users").Set("username", newName).Where("id = ?", id).ToSql()
if err != nil {
return errors.Wrap(err, "building sql")
}
_, err = db.Exec(ctx, sql, args...)
if err != nil {
pge := &pgconn.PgError{}
if errors.As(err, &pge) {
// unique constraint violation
if pge.Code == "23505" {
return ErrUsernameTaken
}
}
return errors.Wrap(err, "executing query")
}
return nil
}
func (db *DB) UpdateUser(
ctx context.Context,
tx pgx.Tx, id xid.ID,
displayName, bio *string,
links *[]string,
avatarURLs []string,
) (u User, err error) {
if displayName == nil && bio == nil && links == nil && avatarURLs == nil {
return db.getUser(ctx, tx, id)
}
builder := sq.Update("users").Where("id = ?", id)
if displayName != nil {
if *displayName == "" {
builder = builder.Set("display_name", nil)
} else {
builder = builder.Set("display_name", *displayName)
}
}
if bio != nil {
if *bio == "" {
builder = builder.Set("bio", nil)
} else {
builder = builder.Set("bio", *bio)
}
}
if links != nil {
if len(*links) == 0 {
builder = builder.Set("links", nil)
} else {
builder = builder.Set("links", *links)
}
}
if avatarURLs != nil {
if len(avatarURLs) == 0 {
builder = builder.Set("avatar_urls", nil)
} else {
builder = builder.Set("avatar_urls", avatarURLs)
}
}
sql, args, err := builder.ToSql()
if err != nil {
return u, errors.Wrap(err, "building sql")
}
_, err = tx.Exec(ctx, sql, args...)
if err != nil {
return u, errors.Wrap(err, "executing sql")
}
u, err = db.getUser(ctx, tx, id)
if err != nil {
return u, errors.Wrap(err, "getting updated user")
}
return u, nil
}
func (db *DB) DeleteUser(ctx context.Context, q querier, id xid.ID, selfDelete bool, reason string) error {
builder := sq.Update("users").Set("deleted_at", time.Now().UTC()).Set("self_delete", selfDelete).Where("id = ?", id)
if !selfDelete {
builder = builder.Set("delete_reason", reason)
}
sql, args, err := builder.ToSql()
if err != nil {
return errors.Wrap(err, "building sql")
}
_, err = q.Exec(ctx, sql, args...)
if err != nil {
return errors.Wrap(err, "executing query")
}
return nil
}