532 lines
21 KiB
Go
532 lines
21 KiB
Go
// Package memory 提供 user-service 的测试用内存 repository。
|
||
package memory
|
||
|
||
import (
|
||
"context"
|
||
"sync"
|
||
|
||
"hyapp/pkg/xerr"
|
||
authdomain "hyapp/services/user-service/internal/domain/auth"
|
||
userdomain "hyapp/services/user-service/internal/domain/user"
|
||
)
|
||
|
||
// Repository 是 user-service 的测试用内存存储。
|
||
// 它不作为生产路径，只用于 service 和 transport 层单元测试。
|
||
type Repository struct {
|
||
// mu 保护所有索引，测试中 auth/user service 可能共享同一 repository。
|
||
mu sync.RWMutex
|
||
// users 保存 user_id -> User 主记录。
|
||
users map[int64]userdomain.User
|
||
// activeDisplayIndex 只保存当前可解析的展示短号。
|
||
activeDisplayIndex map[string]int64
|
||
// liveDisplayIndex 保存 active/held/reserved/blocked 等不能被新用户占用的短号。
|
||
liveDisplayIndex map[string]int64
|
||
// lastChangeAtMs 记录默认短号最近修改时间，用于冷却期测试。
|
||
lastChangeAtMs map[int64]int64
|
||
// passwordAccounts 保存 user_id -> PasswordAccount。
|
||
passwordAccounts map[int64]authdomain.PasswordAccount
|
||
// sessions 保存 session_id -> Session。
|
||
sessions map[string]authdomain.Session
|
||
// sessionByRefresh 保存 refresh_token_hash -> session_id。
|
||
sessionByRefresh map[string]string
|
||
// thirdParty 保存 provider:subject -> ThirdPartyIdentity。
|
||
thirdParty map[string]authdomain.ThirdPartyIdentity
|
||
// leases 保存 lease_id -> PrettyDisplayUserIDLease。
|
||
leases map[string]userdomain.PrettyDisplayUserIDLease
|
||
// activeLeaseByUser 保存 user_id -> active lease_id。
|
||
activeLeaseByUser map[int64]string
|
||
// activeLeaseByPretty 保存 pretty_display_id -> active lease_id。
|
||
activeLeaseByPretty map[string]string
|
||
// audits 保存登录审计，供测试断言。
|
||
audits []authdomain.LoginAudit
|
||
}
|
||
|
||
// NewRepository 创建空内存仓库。
|
||
func NewRepository() *Repository {
|
||
return &Repository{
|
||
users: make(map[int64]userdomain.User),
|
||
activeDisplayIndex: make(map[string]int64),
|
||
liveDisplayIndex: make(map[string]int64),
|
||
lastChangeAtMs: make(map[int64]int64),
|
||
passwordAccounts: make(map[int64]authdomain.PasswordAccount),
|
||
sessions: make(map[string]authdomain.Session),
|
||
sessionByRefresh: make(map[string]string),
|
||
thirdParty: make(map[string]authdomain.ThirdPartyIdentity),
|
||
leases: make(map[string]userdomain.PrettyDisplayUserIDLease),
|
||
activeLeaseByUser: make(map[int64]string),
|
||
activeLeaseByPretty: make(map[string]string),
|
||
}
|
||
}
|
||
|
||
// PutUser 写入用户主记录，测试可以用它准备数据。
|
||
func (r *Repository) PutUser(user userdomain.User) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
// 测试辅助写入也要规范化短号字段，避免 service 查询路径读到脏状态。
|
||
user = user.NormalizeDisplayUserIDState()
|
||
r.users[user.UserID] = user
|
||
if user.DefaultDisplayUserID != "" {
|
||
// 默认短号即使不 active，也需要占用 live index。
|
||
r.liveDisplayIndex[user.DefaultDisplayUserID] = user.UserID
|
||
}
|
||
if user.CurrentDisplayUserID != "" {
|
||
// 当前展示号可解析，也占用 live index。
|
||
r.activeDisplayIndex[user.CurrentDisplayUserID] = user.UserID
|
||
r.liveDisplayIndex[user.CurrentDisplayUserID] = user.UserID
|
||
}
|
||
}
|
||
|
||
// GetUser 查询单个用户。
|
||
func (r *Repository) GetUser(_ context.Context, userID int64) (userdomain.User, error) {
|
||
r.mu.RLock()
|
||
defer r.mu.RUnlock()
|
||
|
||
user, ok := r.users[userID]
|
||
if !ok {
|
||
// 内存实现使用领域错误，便于 service 测试不依赖存储细节。
|
||
return userdomain.User{}, xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
|
||
return user.NormalizeDisplayUserIDState(), nil
|
||
}
|
||
|
||
// BatchGetUsers 查询多个用户，缺失用户不会出现在返回 map 中。
|
||
func (r *Repository) BatchGetUsers(_ context.Context, userIDs []int64) (map[int64]userdomain.User, error) {
|
||
r.mu.RLock()
|
||
defer r.mu.RUnlock()
|
||
|
||
result := make(map[int64]userdomain.User, len(userIDs))
|
||
for _, userID := range userIDs {
|
||
if user, ok := r.users[userID]; ok {
|
||
// 缺失用户不出现在返回 map 中，保持与 MySQL 批量查询一致。
|
||
result[userID] = user.NormalizeDisplayUserIDState()
|
||
}
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// CreateUserWithIdentity 在同一临界区写入用户和 active display_user_id。
|
||
func (r *Repository) CreateUserWithIdentity(_ context.Context, user userdomain.User, identity userdomain.Identity) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
if _, exists := r.users[user.UserID]; exists {
|
||
// user_id 冲突代表发号器异常或测试构造重复。
|
||
return xerr.New(xerr.Conflict, "user_id already exists")
|
||
}
|
||
if _, exists := r.liveDisplayIndex[identity.DisplayUserID]; exists {
|
||
// active/held/reserved/blocked 短号都不能被新用户占用。
|
||
return xerr.New(xerr.DisplayUserIDExists, "display_user_id already exists")
|
||
}
|
||
|
||
// 用户和默认短号在同一临界区写入，模拟 MySQL 事务原子性。
|
||
user = user.NormalizeDisplayUserIDState()
|
||
user.DefaultDisplayUserID = identity.DisplayUserID
|
||
user.CurrentDisplayUserID = identity.DisplayUserID
|
||
user.CurrentDisplayUserIDKind = userdomain.DisplayUserIDKindDefault
|
||
r.users[user.UserID] = user
|
||
r.activeDisplayIndex[identity.DisplayUserID] = user.UserID
|
||
r.liveDisplayIndex[identity.DisplayUserID] = user.UserID
|
||
|
||
return nil
|
||
}
|
||
|
||
// GetUserIdentity 按 user_id 返回当前 active display_user_id。
|
||
func (r *Repository) GetUserIdentity(_ context.Context, userID int64) (userdomain.Identity, error) {
|
||
r.mu.RLock()
|
||
defer r.mu.RUnlock()
|
||
|
||
user, ok := r.users[userID]
|
||
if !ok {
|
||
// 查询身份时用户必须存在。
|
||
return userdomain.Identity{}, xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
user = user.NormalizeDisplayUserIDState()
|
||
if user.CurrentDisplayUserID == "" {
|
||
// 理论上 CreateUserWithIdentity 会保证短号存在，该分支保护脏测试数据。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDNotFound, "display_user_id not found")
|
||
}
|
||
|
||
return user.EffectiveIdentity(), nil
|
||
}
|
||
|
||
// ResolveDisplayUserID 只解析 active 短号归属。
|
||
func (r *Repository) ResolveDisplayUserID(_ context.Context, displayUserID string, nowMs int64) (userdomain.Identity, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
// 解析短号前先批量懒过期，模拟 MySQL 解析路径按输入触发恢复。
|
||
r.expireAllPrettyLocked(nowMs)
|
||
|
||
userID, ok := r.activeDisplayIndex[displayUserID]
|
||
if !ok {
|
||
// 过期靓号或不存在短号都返回 not found。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDNotFound, "display_user_id not found")
|
||
}
|
||
user := r.users[userID].NormalizeDisplayUserIDState()
|
||
|
||
return user.EffectiveIdentity(), nil
|
||
}
|
||
|
||
// ChangeDisplayUserID 原子维护旧短号释放、新短号激活和用户快照。
|
||
func (r *Repository) ChangeDisplayUserID(_ context.Context, command userdomain.DisplayUserIDChangeCommand) (userdomain.Identity, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
user, ok := r.users[command.UserID]
|
||
if !ok {
|
||
// 修改短号必须基于已有用户。
|
||
return userdomain.Identity{}, xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
user = user.NormalizeDisplayUserIDState()
|
||
if user.DisplayUserIDExpired(command.ChangedAtMs) {
|
||
// 修改默认短号前先恢复过期靓号，避免 held 默认号状态卡住。
|
||
if _, err := r.expirePrettyLocked(command.UserID, "", command.ChangedAtMs, command.RequestID); err != nil {
|
||
return userdomain.Identity{}, err
|
||
}
|
||
user = r.users[command.UserID].NormalizeDisplayUserIDState()
|
||
}
|
||
if user.CurrentDisplayUserIDKind == userdomain.DisplayUserIDKindPretty {
|
||
// 有 active 靓号时拒绝修改默认短号，避免过期恢复目标不清晰。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDPrettyActive, "pretty display_user_id is active")
|
||
}
|
||
if user.DefaultDisplayUserID == command.NewDisplayUserID {
|
||
// 修改为相同默认短号是幂等成功。
|
||
return user.EffectiveIdentity(), nil
|
||
}
|
||
if ownerID, exists := r.liveDisplayIndex[command.NewDisplayUserID]; exists && ownerID != command.UserID {
|
||
// 只要新短号被其他用户 live 占用，就不能修改。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDExists, "display_user_id already exists")
|
||
}
|
||
if lastChangedAt := r.lastChangeAtMs[command.UserID]; lastChangedAt > 0 && command.CooldownMs > 0 && command.ChangedAtMs-lastChangedAt < command.CooldownMs {
|
||
// 冷却期按最后一次默认短号修改时间计算。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDCooldown, "display_user_id change is cooling down")
|
||
}
|
||
|
||
// 旧默认短号释放，新默认短号成为 active/live。
|
||
delete(r.activeDisplayIndex, user.CurrentDisplayUserID)
|
||
delete(r.liveDisplayIndex, user.DefaultDisplayUserID)
|
||
r.activeDisplayIndex[command.NewDisplayUserID] = command.UserID
|
||
r.liveDisplayIndex[command.NewDisplayUserID] = command.UserID
|
||
user.DefaultDisplayUserID = command.NewDisplayUserID
|
||
user.CurrentDisplayUserID = command.NewDisplayUserID
|
||
user.CurrentDisplayUserIDKind = userdomain.DisplayUserIDKindDefault
|
||
user.CurrentDisplayUserIDExpiresAtMs = 0
|
||
user.UpdatedAtMs = command.ChangedAtMs
|
||
r.users[command.UserID] = user
|
||
r.lastChangeAtMs[command.UserID] = command.ChangedAtMs
|
||
|
||
return user.EffectiveIdentity(), nil
|
||
}
|
||
|
||
// ApplyPrettyDisplayUserID 原子创建靓号租约，并把默认短号从 active 变为 held。
|
||
func (r *Repository) ApplyPrettyDisplayUserID(_ context.Context, command userdomain.PrettyDisplayUserIDCommand) (userdomain.Identity, string, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
user, ok := r.users[command.UserID]
|
||
if !ok {
|
||
// 申请靓号必须基于已有用户。
|
||
return userdomain.Identity{}, "", xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
user = user.NormalizeDisplayUserIDState()
|
||
if user.DisplayUserIDExpired(command.NowMs) {
|
||
// 新申请前先恢复过期靓号。
|
||
if _, err := r.expirePrettyLocked(command.UserID, "", command.NowMs, command.RequestID); err != nil {
|
||
return userdomain.Identity{}, "", err
|
||
}
|
||
user = r.users[command.UserID].NormalizeDisplayUserIDState()
|
||
}
|
||
if user.CurrentDisplayUserIDKind == userdomain.DisplayUserIDKindPretty {
|
||
// 同一用户不能叠加 active 靓号。
|
||
return userdomain.Identity{}, "", xerr.New(xerr.DisplayUserIDPrettyActive, "pretty display_user_id is active")
|
||
}
|
||
if _, exists := r.liveDisplayIndex[command.PrettyDisplayID]; exists {
|
||
// 靓号只要被 live 占用就不可申请。
|
||
return userdomain.Identity{}, "", xerr.New(xerr.DisplayUserIDPrettyNotAvailable, "pretty display_user_id is not available")
|
||
}
|
||
|
||
// 默认短号从 active 变为 held，靓号成为 active。
|
||
expiresAtMs := command.NowMs + command.LeaseDurationMs
|
||
lease := userdomain.PrettyDisplayUserIDLease{
|
||
LeaseID: command.LeaseID,
|
||
DisplayUserID: command.PrettyDisplayID,
|
||
UserID: command.UserID,
|
||
Status: userdomain.PrettyLeaseStatusActive,
|
||
StartsAtMs: command.NowMs,
|
||
ExpiresAtMs: expiresAtMs,
|
||
PaymentReceiptID: command.PaymentReceiptID,
|
||
Source: command.Source,
|
||
CreatedAtMs: command.NowMs,
|
||
UpdatedAtMs: command.NowMs,
|
||
}
|
||
|
||
delete(r.activeDisplayIndex, user.CurrentDisplayUserID)
|
||
r.activeDisplayIndex[command.PrettyDisplayID] = command.UserID
|
||
r.liveDisplayIndex[command.PrettyDisplayID] = command.UserID
|
||
r.leases[command.LeaseID] = lease
|
||
r.activeLeaseByUser[command.UserID] = command.LeaseID
|
||
r.activeLeaseByPretty[command.PrettyDisplayID] = command.LeaseID
|
||
|
||
user.CurrentDisplayUserID = command.PrettyDisplayID
|
||
user.CurrentDisplayUserIDKind = userdomain.DisplayUserIDKindPretty
|
||
user.CurrentDisplayUserIDExpiresAtMs = expiresAtMs
|
||
user.UpdatedAtMs = command.NowMs
|
||
r.users[command.UserID] = user
|
||
|
||
return user.EffectiveIdentity(), command.LeaseID, nil
|
||
}
|
||
|
||
// ExpirePrettyDisplayUserID 恢复默认短号；重复过期返回当前默认身份，保证补偿任务可重试。
|
||
func (r *Repository) ExpirePrettyDisplayUserID(_ context.Context, command userdomain.ExpirePrettyDisplayUserIDCommand) (userdomain.Identity, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
// 过期恢复使用同一内部方法，保证懒过期、定时过期和测试路径一致。
|
||
return r.expirePrettyLocked(command.UserID, command.LeaseID, command.NowMs, command.RequestID)
|
||
}
|
||
|
||
// SetPassword 为已有用户首次写入密码身份。
|
||
func (r *Repository) SetPassword(_ context.Context, account authdomain.PasswordAccount) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
if _, exists := r.users[account.UserID]; !exists {
|
||
// 不能为不存在用户设置密码身份。
|
||
return xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
if _, exists := r.passwordAccounts[account.UserID]; exists {
|
||
// v1 只允许首次设置密码，不提供重置流程。
|
||
return xerr.New(xerr.PasswordAlreadySet, "password already set")
|
||
}
|
||
|
||
r.passwordAccounts[account.UserID] = account
|
||
return nil
|
||
}
|
||
|
||
// FindPasswordByDisplayUserID 先解析当前 active display_user_id，再读取用户密码身份。
|
||
func (r *Repository) FindPasswordByDisplayUserID(_ context.Context, displayUserID string, nowMs int64) (authdomain.PasswordAccount, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
r.expireAllPrettyLocked(nowMs)
|
||
|
||
userID, exists := r.activeDisplayIndex[displayUserID]
|
||
if !exists {
|
||
// 不存在、过期或 held 默认号都不能登录密码。
|
||
return authdomain.PasswordAccount{}, xerr.New(xerr.NotFound, "password account not found")
|
||
}
|
||
account, exists := r.passwordAccounts[userID]
|
||
if !exists {
|
||
// 未设置密码和用户不存在都向 service 层表现为 not found，再统一 AUTH_FAILED。
|
||
return authdomain.PasswordAccount{}, xerr.New(xerr.NotFound, "password account not found")
|
||
}
|
||
account.DisplayUserID = displayUserID
|
||
|
||
return account, nil
|
||
}
|
||
|
||
// CreateSession 创建新的 refresh session。
|
||
func (r *Repository) CreateSession(_ context.Context, session authdomain.Session) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
if _, exists := r.sessionByRefresh[session.RefreshTokenHash]; exists {
|
||
// refresh token hash 理论上全局唯一，冲突视为异常。
|
||
return xerr.New(xerr.Conflict, "refresh token hash already exists")
|
||
}
|
||
|
||
r.sessions[session.SessionID] = session
|
||
r.sessionByRefresh[session.RefreshTokenHash] = session.SessionID
|
||
return nil
|
||
}
|
||
|
||
// FindActiveSessionByRefreshHash 查找未过期且未吊销的 session。
|
||
func (r *Repository) FindActiveSessionByRefreshHash(_ context.Context, refreshTokenHash string, nowMs int64) (authdomain.Session, error) {
|
||
r.mu.RLock()
|
||
defer r.mu.RUnlock()
|
||
|
||
sessionID, exists := r.sessionByRefresh[refreshTokenHash]
|
||
if !exists {
|
||
// 找不到 refresh hash 按已吊销处理，避免暴露 token 是否曾存在。
|
||
return authdomain.Session{}, xerr.New(xerr.SessionRevoked, "session revoked")
|
||
}
|
||
|
||
session := r.sessions[sessionID]
|
||
if session.RevokedAtMs > 0 {
|
||
// 已吊销 session 不能继续 refresh。
|
||
return authdomain.Session{}, xerr.New(xerr.SessionRevoked, "session revoked")
|
||
}
|
||
if session.ExpiresAtMs <= nowMs {
|
||
// 过期 session 与吊销 session 使用不同 reason。
|
||
return authdomain.Session{}, xerr.New(xerr.SessionExpired, "session expired")
|
||
}
|
||
|
||
return session, nil
|
||
}
|
||
|
||
// ReplaceSession 原子吊销旧 session 并创建新 session。
|
||
func (r *Repository) ReplaceSession(_ context.Context, oldSessionID string, newSession authdomain.Session, revokedAtMs int64) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
oldSession, exists := r.sessions[oldSessionID]
|
||
if !exists || oldSession.RevokedAtMs > 0 {
|
||
// 旧 session 不存在或已吊销时不能轮换。
|
||
return xerr.New(xerr.SessionRevoked, "session revoked")
|
||
}
|
||
|
||
// 轮换必须在同一临界区吊销旧 session 并写入新 session。
|
||
oldSession.RevokedAtMs = revokedAtMs
|
||
oldSession.UpdatedAtMs = revokedAtMs
|
||
r.sessions[oldSessionID] = oldSession
|
||
r.sessions[newSession.SessionID] = newSession
|
||
r.sessionByRefresh[newSession.RefreshTokenHash] = newSession.SessionID
|
||
|
||
return nil
|
||
}
|
||
|
||
// RevokeSession 按 session_id 或 refresh token hash 吊销 session。
|
||
func (r *Repository) RevokeSession(_ context.Context, sessionID string, refreshTokenHash string, revokedAtMs int64) (bool, error) {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
if sessionID == "" {
|
||
// refresh token 登出先反查 session_id。
|
||
sessionID = r.sessionByRefresh[refreshTokenHash]
|
||
}
|
||
session, exists := r.sessions[sessionID]
|
||
if !exists {
|
||
// 未找到按 revoked 返回，保持幂等登出语义。
|
||
return false, xerr.New(xerr.SessionRevoked, "session revoked")
|
||
}
|
||
if session.RevokedAtMs > 0 {
|
||
// 已吊销再次登出返回 true，表示目标已经处于退出状态。
|
||
return true, nil
|
||
}
|
||
|
||
session.RevokedAtMs = revokedAtMs
|
||
session.UpdatedAtMs = revokedAtMs
|
||
r.sessions[sessionID] = session
|
||
|
||
return true, nil
|
||
}
|
||
|
||
// FindThirdPartyIdentity 查找 provider + subject 绑定。
|
||
func (r *Repository) FindThirdPartyIdentity(_ context.Context, provider string, providerSubject string) (authdomain.ThirdPartyIdentity, error) {
|
||
r.mu.RLock()
|
||
defer r.mu.RUnlock()
|
||
|
||
identity, exists := r.thirdParty[thirdPartyKey(provider, providerSubject)]
|
||
if !exists {
|
||
// provider + subject 未绑定时由 service 决定走注册。
|
||
return authdomain.ThirdPartyIdentity{}, xerr.New(xerr.NotFound, "third-party identity not found")
|
||
}
|
||
|
||
return identity, nil
|
||
}
|
||
|
||
// CreateThirdPartyUser 原子创建用户、默认短号、三方绑定和首个 session。
|
||
func (r *Repository) CreateThirdPartyUser(_ context.Context, user userdomain.User, identity userdomain.Identity, thirdParty authdomain.ThirdPartyIdentity, session authdomain.Session) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
key := thirdPartyKey(thirdParty.Provider, thirdParty.ProviderSubject)
|
||
if _, exists := r.thirdParty[key]; exists {
|
||
// 并发注册同一三方身份时返回冲突。
|
||
return xerr.New(xerr.Conflict, "third-party identity already exists")
|
||
}
|
||
if _, exists := r.liveDisplayIndex[identity.DisplayUserID]; exists {
|
||
// 默认短号冲突由 service 有限重试。
|
||
return xerr.New(xerr.DisplayUserIDExists, "display_user_id already exists")
|
||
}
|
||
if _, exists := r.users[user.UserID]; exists {
|
||
return xerr.New(xerr.Conflict, "user_id already exists")
|
||
}
|
||
|
||
user = user.NormalizeDisplayUserIDState()
|
||
// 用户、默认短号、三方绑定和首个 session 在同一临界区写入，模拟事务原子性。
|
||
user.DefaultDisplayUserID = identity.DisplayUserID
|
||
user.CurrentDisplayUserID = identity.DisplayUserID
|
||
user.CurrentDisplayUserIDKind = userdomain.DisplayUserIDKindDefault
|
||
r.users[user.UserID] = user
|
||
r.activeDisplayIndex[identity.DisplayUserID] = user.UserID
|
||
r.liveDisplayIndex[identity.DisplayUserID] = user.UserID
|
||
r.thirdParty[key] = thirdParty
|
||
r.sessions[session.SessionID] = session
|
||
r.sessionByRefresh[session.RefreshTokenHash] = session.SessionID
|
||
|
||
return nil
|
||
}
|
||
|
||
// RecordLoginAudit 记录登录审计，内存实现仅用于测试断言。
|
||
func (r *Repository) RecordLoginAudit(_ context.Context, audit authdomain.LoginAudit) error {
|
||
r.mu.Lock()
|
||
defer r.mu.Unlock()
|
||
|
||
r.audits = append(r.audits, audit)
|
||
return nil
|
||
}
|
||
|
||
func thirdPartyKey(provider string, providerSubject string) string {
|
||
// 三方绑定使用 provider + subject 作为唯一键。
|
||
return provider + ":" + providerSubject
|
||
}
|
||
|
||
func (r *Repository) expireAllPrettyLocked(nowMs int64) {
|
||
for userID, user := range r.users {
|
||
// 调用方已持有写锁；这里批量清理所有过期靓号。
|
||
user = user.NormalizeDisplayUserIDState()
|
||
if user.DisplayUserIDExpired(nowMs) {
|
||
_, _ = r.expirePrettyLocked(userID, "", nowMs, "lazy_expire")
|
||
}
|
||
}
|
||
}
|
||
|
||
func (r *Repository) expirePrettyLocked(userID int64, leaseID string, nowMs int64, _ string) (userdomain.Identity, error) {
|
||
user, ok := r.users[userID]
|
||
if !ok {
|
||
// 恢复过期靓号必须找到用户主记录。
|
||
return userdomain.Identity{}, xerr.New(xerr.NotFound, "user not found")
|
||
}
|
||
user = user.NormalizeDisplayUserIDState()
|
||
if user.CurrentDisplayUserIDKind != userdomain.DisplayUserIDKindPretty {
|
||
// 非 pretty 状态重复过期按幂等成功返回当前身份。
|
||
return user.EffectiveIdentity(), nil
|
||
}
|
||
if user.CurrentDisplayUserIDExpiresAtMs > nowMs {
|
||
// 未到期时拒绝恢复，防止提前释放用户购买的靓号。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDLeaseExpired, "pretty display_user_id lease is not expired")
|
||
}
|
||
|
||
activeLeaseID := r.activeLeaseByUser[userID]
|
||
if leaseID != "" && activeLeaseID != "" && activeLeaseID != leaseID {
|
||
// 指定 lease_id 不匹配当前 active lease 时拒绝，避免旧任务误释放新租约。
|
||
return userdomain.Identity{}, xerr.New(xerr.DisplayUserIDLeaseExpired, "pretty display_user_id lease is not active")
|
||
}
|
||
if activeLeaseID != "" {
|
||
// 租约记录标记 expired，并清理 active lease 索引。
|
||
lease := r.leases[activeLeaseID]
|
||
lease.Status = userdomain.PrettyLeaseStatusExpired
|
||
lease.UpdatedAtMs = nowMs
|
||
r.leases[activeLeaseID] = lease
|
||
delete(r.activeLeaseByPretty, lease.DisplayUserID)
|
||
delete(r.activeLeaseByUser, userID)
|
||
}
|
||
|
||
// 靓号释放，默认短号恢复为 active/live。
|
||
delete(r.activeDisplayIndex, user.CurrentDisplayUserID)
|
||
delete(r.liveDisplayIndex, user.CurrentDisplayUserID)
|
||
r.activeDisplayIndex[user.DefaultDisplayUserID] = userID
|
||
r.liveDisplayIndex[user.DefaultDisplayUserID] = userID
|
||
user.CurrentDisplayUserID = user.DefaultDisplayUserID
|
||
user.CurrentDisplayUserIDKind = userdomain.DisplayUserIDKindDefault
|
||
user.CurrentDisplayUserIDExpiresAtMs = 0
|
||
user.UpdatedAtMs = nowMs
|
||
r.users[userID] = user
|
||
|
||
return user.EffectiveIdentity(), nil
|
||
}
|