271 lines
5.6 KiB
Go
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
|
|
}
|