subtrack
95fa4fd6fd
build / build-and-test (push) Successful in 3m25s
- 设置 → 管理员：仅 id=1 的账户在“其他人”那一行看到「编辑」入口，自己那行不显示
- 新增编辑页 /settings/users/{id}/edit：可改用户名、显示名称，密码留空则不修改
- 重置密码后立即清除该账户的所有登录会话，强制对方用新密码重新登录；只改昵称/用户名不影响会话
- 服务端三重校验：非 id=1 拒绝、不能编辑自己、用户名 3-32 字符且唯一、密码 ≥6 位且两次一致
- 所有修改写入操作日志（旧用户名/昵称 → 新值，是否重置密码）
- 设置页根据当前账户显示不同提示：超管看到可编辑说明，其他人只看到“只有初始管理员可以修改”
数据库：无需变更（复用 users 表与 sessions 表）
测试：
- 新增单测 TestUpdateUserByAdmin：昵称更新、会话保留、改密后旧会话失效、新密码可登录旧密码失效、重名返回 ErrDuplicate、空用户名拒绝
- 功能验证 20 项：入口显示/隐藏、普通管理员与自我编辑被拒、改密踢下线、新旧密码、长度/一致性/重名校验、留空密码、日志记录
- 原有 119 项验收回归全绿；go vet / go test ./... 通过；版本号 1.4.0
305 lines
8.0 KiB
Go
305 lines
8.0 KiB
Go
package store
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"daili/internal/pw"
|
|
)
|
|
|
|
// User 管理员账户。
|
|
type User struct {
|
|
ID int64
|
|
Username string
|
|
DisplayName string
|
|
IsActive bool
|
|
Color string
|
|
CreatedAt string
|
|
LastLoginAt string
|
|
}
|
|
|
|
// AssigneePalette 是新建管理员时自动分配的颜色（区分度较高的深色系）。
|
|
var AssigneePalette = []string{
|
|
"#2F5D50", "#8C4A3C", "#3E5C8A", "#7A5AA6",
|
|
"#A66A1E", "#2C7A7B", "#8A3B5C", "#5B6B2F",
|
|
}
|
|
|
|
// NormalizeColor 校验并规范化 #RRGGBB；空值返回空。
|
|
func NormalizeColor(c string) (string, error) {
|
|
c = strings.TrimSpace(c)
|
|
if c == "" {
|
|
return "", nil
|
|
}
|
|
if len(c) != 7 || c[0] != '#' {
|
|
return "", errors.New("颜色格式应为 #RRGGBB")
|
|
}
|
|
for _, r := range c[1:] {
|
|
if !((r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || (r >= 'A' && r <= 'F')) {
|
|
return "", errors.New("颜色格式应为 #RRGGBB")
|
|
}
|
|
}
|
|
return strings.ToUpper(c), nil
|
|
}
|
|
|
|
func scanUser(row interface {
|
|
Scan(dest ...any) error
|
|
}) (*User, error) {
|
|
var u User
|
|
var active int
|
|
var last sql.NullString
|
|
if err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &active, &u.CreatedAt, &last, &u.Color); err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
u.IsActive = active == 1
|
|
u.LastLoginAt = last.String
|
|
return &u, nil
|
|
}
|
|
|
|
const userCols = `id, username, display_name, is_active, created_at, IFNULL(last_login_at,''), IFNULL(color,'')`
|
|
|
|
// CountUsers 返回账户数量。
|
|
func (db *DB) CountUsers() (int, error) {
|
|
var n int
|
|
err := db.sql.QueryRow(`SELECT COUNT(*) FROM users`).Scan(&n)
|
|
return n, err
|
|
}
|
|
|
|
// CreateUser 新建账户。
|
|
func (db *DB) CreateUser(username, displayName, password string) (*User, error) {
|
|
hash, err := pw.Hash(password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
now := nowStamp()
|
|
color := db.nextAssigneeColor()
|
|
res, err := db.sql.Exec(`INSERT INTO users(username, display_name, password_hash, is_active, color, created_at)
|
|
VALUES(?,?,?,1,?,?)`, username, displayName, hash, color, now)
|
|
if err != nil {
|
|
if isUnique(err) {
|
|
return nil, ErrDuplicate
|
|
}
|
|
return nil, err
|
|
}
|
|
id, _ := res.LastInsertId()
|
|
return &User{ID: id, Username: username, DisplayName: displayName, IsActive: true, Color: color, CreatedAt: now}, nil
|
|
}
|
|
|
|
// nextAssigneeColor 依据现有账户数循环取调色板，尽量不重复。
|
|
func (db *DB) nextAssigneeColor() string {
|
|
n, _ := db.CountUsers()
|
|
return AssigneePalette[n%len(AssigneePalette)]
|
|
}
|
|
|
|
// SetUserColor 设置管理员颜色（空字符串表示清除）。
|
|
func (db *DB) SetUserColor(userID int64, color string) error {
|
|
c, err := NormalizeColor(color)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
res, err := db.sql.Exec(`UPDATE users SET color=? WHERE id=?`, c, userID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n, _ := res.RowsAffected(); n == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetCustomerAssignee 把客户指派给某个打手；userID=0 表示取消指派。
|
|
func (db *DB) SetCustomerAssignee(customerID, userID int64) error {
|
|
var v any
|
|
if userID > 0 {
|
|
if _, err := db.UserByID(userID); err != nil {
|
|
return errors.New("打手不存在")
|
|
}
|
|
v = userID
|
|
}
|
|
res, err := db.sql.Exec(`UPDATE customers SET assignee_id=?, updated_at=? WHERE id=?`, v, nowStamp(), customerID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n, _ := res.RowsAffected(); n == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ActiveUsers 返回在用的管理员（打手候选）。
|
|
func (db *DB) ActiveUsers() ([]User, error) {
|
|
rows, err := db.sql.Query(`SELECT ` + userCols + ` FROM users WHERE is_active=1 ORDER BY id`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := []User{}
|
|
for rows.Next() {
|
|
u, err := scanUser(rows)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, *u)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// DeleteUserSessions 清除某个账户的全部登录会话。
|
|
func (db *DB) DeleteUserSessions(userID int64) error {
|
|
_, err := db.sql.Exec(`DELETE FROM sessions WHERE user_id=?`, userID)
|
|
return err
|
|
}
|
|
|
|
// UpdateUserByAdmin 由超管修改用户名/昵称，password 非空时同时重置密码。
|
|
// 重置密码会强制该账户下线。
|
|
func (db *DB) UpdateUserByAdmin(userID int64, username, displayName, password string) error {
|
|
username = strings.TrimSpace(username)
|
|
displayName = strings.TrimSpace(displayName)
|
|
if username == "" {
|
|
return errors.New("用户名不能为空")
|
|
}
|
|
hash := ""
|
|
if password != "" {
|
|
var err error
|
|
hash, err = pw.Hash(password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if _, err := db.sql.Exec(`UPDATE users SET username=?, display_name=? WHERE id=?`,
|
|
username, displayName, userID); err != nil {
|
|
if isUnique(err) {
|
|
return ErrDuplicate
|
|
}
|
|
return err
|
|
}
|
|
if hash != "" {
|
|
if _, err := db.sql.Exec(`UPDATE users SET password_hash=? WHERE id=?`, hash, userID); err != nil {
|
|
return err
|
|
}
|
|
if err := db.DeleteUserSessions(userID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Authenticate 校验用户名口令。
|
|
func (db *DB) Authenticate(username, password string) (*User, error) {
|
|
var hash string
|
|
var active int
|
|
var id int64
|
|
err := db.sql.QueryRow(`SELECT id, password_hash, is_active FROM users WHERE username=?`, username).
|
|
Scan(&id, &hash, &active)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
if active != 1 || !pw.Verify(password, hash) {
|
|
return nil, ErrNotFound
|
|
}
|
|
_, _ = db.sql.Exec(`UPDATE users SET last_login_at=? WHERE id=?`, nowStamp(), id)
|
|
return db.UserByID(id)
|
|
}
|
|
|
|
// UserByID 按 ID 取账户。
|
|
func (db *DB) UserByID(id int64) (*User, error) {
|
|
return scanUser(db.sql.QueryRow(`SELECT `+userCols+` FROM users WHERE id=?`, id))
|
|
}
|
|
|
|
// UserByUsername 按用户名取账户。
|
|
func (db *DB) UserByUsername(name string) (*User, error) {
|
|
return scanUser(db.sql.QueryRow(`SELECT `+userCols+` FROM users WHERE username=?`, name))
|
|
}
|
|
|
|
// ListUsers 列出账户。
|
|
func (db *DB) ListUsers() ([]User, error) {
|
|
rows, err := db.sql.Query(`SELECT ` + userCols + ` FROM users ORDER BY id`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []User
|
|
for rows.Next() {
|
|
u, err := scanUser(rows)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, *u)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// UpdatePassword 修改口令。
|
|
func (db *DB) UpdatePassword(userID int64, password string) error {
|
|
hash, err := pw.Hash(password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = db.sql.Exec(`UPDATE users SET password_hash=? WHERE id=?`, hash, userID)
|
|
return err
|
|
}
|
|
|
|
// SetUserActive 启用/停用账户。
|
|
func (db *DB) SetUserActive(userID int64, active bool) error {
|
|
v := 0
|
|
if active {
|
|
v = 1
|
|
}
|
|
_, err := db.sql.Exec(`UPDATE users SET is_active=? WHERE id=?`, v, userID)
|
|
return err
|
|
}
|
|
|
|
// ---------- 会话 ----------
|
|
|
|
// CreateSession 新建登录会话。
|
|
func (db *DB) CreateSession(token string, userID int64, ttl time.Duration, ip string) error {
|
|
now := time.Now()
|
|
_, err := db.sql.Exec(`INSERT INTO sessions(token,user_id,created_at,expires_at,ip) VALUES(?,?,?,?,?)`,
|
|
token, userID, now.Format("2006-01-02 15:04:05"), now.Add(ttl).Format("2006-01-02 15:04:05"), ip)
|
|
return err
|
|
}
|
|
|
|
// SessionUser 通过令牌取账户，过期则返回 ErrNotFound。
|
|
func (db *DB) SessionUser(token string) (*User, error) {
|
|
var userID int64
|
|
var expires string
|
|
err := db.sql.QueryRow(`SELECT user_id, expires_at FROM sessions WHERE token=?`, token).Scan(&userID, &expires)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
exp, err := time.ParseInLocation("2006-01-02 15:04:05", expires, time.Local)
|
|
if err != nil || exp.Before(time.Now()) {
|
|
_ = db.DeleteSession(token)
|
|
return nil, ErrNotFound
|
|
}
|
|
u, err := db.UserByID(userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !u.IsActive {
|
|
return nil, ErrNotFound
|
|
}
|
|
return u, nil
|
|
}
|
|
|
|
// DeleteSession 删除会话。
|
|
func (db *DB) DeleteSession(token string) error {
|
|
_, err := db.sql.Exec(`DELETE FROM sessions WHERE token=?`, token)
|
|
return err
|
|
}
|
|
|
|
// PurgeSessions 清理过期会话。
|
|
func (db *DB) PurgeSessions() {
|
|
_, _ = db.sql.Exec(`DELETE FROM sessions WHERE expires_at < ?`, nowStamp())
|
|
}
|