Files
Mediarr/user/user.go
T

271 lines
5.6 KiB
Go

package user
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
const (
maxFailedAttempts = 5
lockDuration = 15 * time.Minute
)
type User struct {
ID ident.UUID
Login string
Name string
Status string
AccountState string
MustChangePassword bool
CreatedAt int64
Groups []Group
}
type Group struct {
ID ident.UUID
Name string
Role string
}
type CreateUserParams struct {
Login string
Password string
Role string
}
func (s *Service) CreateUser(ctx context.Context, params CreateUserParams) (*User, error) {
display, key, err := normalizeLogin(params.Login)
if err != nil {
return nil, err
}
if err := validatePassword(params.Password); err != nil {
return nil, err
}
role := params.Role
if role == "" {
role = RoleMember
}
groupName, err := groupNameForRole(role)
if err != nil {
return nil, err
}
group, err := s.groupByName(ctx, groupName)
if err != nil {
return nil, err
}
passwordHash, err := HashPassword(params.Password)
if err != nil {
return nil, err
}
userID, err := ident.NewV7()
if err != nil {
return nil, err
}
now := time.Now().UnixMilli()
err = s.withTx(ctx, func(q *database.Queries) error {
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: userID,
Kind: "user",
Name: display,
Status: "active",
CreatedAt: now,
}); err != nil {
return err
}
if _, err := q.CreateAccount(ctx, database.CreateAccountParams{
PrincipalID: userID,
Login: display,
LoginKey: key,
PasswordHash: sql.NullString{
String: passwordHash,
Valid: true,
},
PasswordChangedAt: sql.NullInt64{
Int64: now,
Valid: true,
},
MustChangePassword: 0,
State: "active",
FailedAttempts: 0,
CreatedAt: now,
}); err != nil {
return err
}
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: group.ID,
MemberID: userID,
Role: "member",
CreatedAt: now,
})
return err
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrLoginTaken, display)
}
return nil, err
}
return s.loadUser(ctx, userID)
}
func (s *Service) Authenticate(ctx context.Context, login, password string) (*User, error) {
_, key, err := normalizeLogin(login)
if err != nil {
return nil, ErrInvalidCredentials
}
account, err := s.db.Queries.GetAccountByLoginKey(ctx, key)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrInvalidCredentials
}
return nil, err
}
principal, err := s.db.Queries.GetPrincipal(ctx, account.PrincipalID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrInvalidCredentials
}
return nil, err
}
if principal.Status != "active" {
return nil, ErrInvalidCredentials
}
now := time.Now().UnixMilli()
switch account.State {
case "disabled":
return nil, ErrAccountDisabled
case "locked":
if !account.LockedUntil.Valid || account.LockedUntil.Int64 > now {
return nil, ErrAccountLocked
}
if _, err := s.db.WriteQueries.UnlockAccount(ctx, account.PrincipalID); err != nil {
return nil, err
}
account.State = "active"
account.FailedAttempts = 0
account.LockedUntil = sql.NullInt64{}
}
if !account.PasswordHash.Valid {
return nil, ErrInvalidCredentials
}
valid, err := VerifyPassword(password, account.PasswordHash.String)
if err != nil {
return nil, ErrInvalidCredentials
}
if !valid {
updated, err := s.db.WriteQueries.RegisterFailedLogin(ctx, database.RegisterFailedLoginParams{
MaxAttempts: maxFailedAttempts,
LockedUntil: sql.NullInt64{
Int64: now + lockDuration.Milliseconds(),
Valid: true,
},
PrincipalID: account.PrincipalID,
})
if err != nil {
return nil, err
}
if updated.State == "locked" {
return nil, ErrAccountLocked
}
return nil, ErrInvalidCredentials
}
if _, err := s.db.WriteQueries.RecordLogin(ctx, database.RecordLoginParams{
LastLoginAt: sql.NullInt64{
Int64: now,
Valid: true,
},
PrincipalID: account.PrincipalID,
}); err != nil {
return nil, err
}
return s.loadUser(ctx, account.PrincipalID)
}
func (s *Service) SetPassword(ctx context.Context, principalID ident.UUID, password string) error {
if err := validatePassword(password); err != nil {
return err
}
passwordHash, err := HashPassword(password)
if err != nil {
return err
}
now := time.Now().UnixMilli()
_, err = s.db.WriteQueries.UpdatePassword(ctx, database.UpdatePasswordParams{
PasswordHash: sql.NullString{
String: passwordHash,
Valid: true,
},
PasswordChangedAt: sql.NullInt64{
Int64: now,
Valid: true,
},
PrincipalID: principalID,
})
return err
}
func (s *Service) loadUser(ctx context.Context, id ident.UUID) (*User, error) {
principal, err := s.db.Queries.GetPrincipal(ctx, id)
if err != nil {
return nil, err
}
login := principal.Name
accountState := "active"
mustChangePassword := false
account, err := s.db.Queries.GetAccount(ctx, id)
switch {
case err == nil:
login = account.Login
accountState = account.State
mustChangePassword = account.MustChangePassword != 0
case !errors.Is(err, sql.ErrNoRows):
return nil, err
}
groups, err := s.ListGroups(ctx, id)
if err != nil {
return nil, err
}
return &User{
ID: principal.ID,
Login: login,
Name: principal.Name,
Status: principal.Status,
AccountState: accountState,
MustChangePassword: mustChangePassword,
CreatedAt: principal.CreatedAt,
Groups: groups,
}, nil
}