Files
yunzerwebsiteallinone/go/services/identity_account.go
T
2026-11-16 17:22:50 +08:00

330 lines
9.0 KiB
Go

package services
import (
"errors"
"fmt"
"math/rand"
"regexp"
"strings"
"sync"
"time"
"server/models"
"server/pkg/passwordutil"
authsvc "server/services/auth"
"github.com/google/uuid"
)
var mobileRegexp = regexp.MustCompile(`^1[3-9]\d{9}$`)
type identityCodeItem struct {
Code string
ExpiredAt time.Time
IssuedAt time.Time
}
var identityCodeStore sync.Map
func identityCodeKey(purpose, phone string) string {
return strings.TrimSpace(purpose) + "|" + strings.TrimSpace(phone)
}
func IsMobile(phone string) bool {
return mobileRegexp.MatchString(strings.TrimSpace(phone))
}
func findIdentityByMobile(phone string) *models.AuthIdentity {
if !IsMobile(phone) {
return nil
}
var m models.AuthIdentity
if err := models.Orm.QueryTable(new(models.AuthIdentity)).
Filter("mobile", strings.TrimSpace(phone)).
Filter("delete_time__isnull", true).
One(&m); err != nil {
return nil
}
return &m
}
func SendIdentityCode(purpose, phone string) error {
phone = strings.TrimSpace(phone)
if !IsMobile(phone) {
return errors.New("请输入正确的手机号")
}
if purpose != "register" && purpose != "reset" {
return errors.New("参数错误")
}
existed := findIdentityByMobile(phone)
if purpose == "register" && existed != nil {
return errors.New("该手机号已注册,请直接登录或找回密码")
}
if purpose == "reset" && existed == nil {
return errors.New("该手机号尚未注册")
}
if v, ok := identityCodeStore.Load(identityCodeKey(purpose, phone)); ok {
if item, ok := v.(identityCodeItem); ok && time.Since(item.IssuedAt) < 60*time.Second {
return errors.New("验证码发送过于频繁,请稍后再试")
}
}
if _, _, err := getDefaultSystemSMSConfig(); err != nil {
return errors.New("短信服务未配置,请联系平台管理员")
}
code := fmt.Sprintf("%06d", rand.Intn(1000000)) //nolint:gosec // 验证码场景可接受
content := "验证码:" + code + ",5分钟内有效。为保护账号安全,请勿泄露给他人。"
if err := enqueueSMSTaskForLogin(0, phone, content, code); err != nil {
return errors.New("短信发送失败,请稍后重试")
}
now := time.Now()
identityCodeStore.Store(identityCodeKey(purpose, phone), identityCodeItem{
Code: code,
ExpiredAt: now.Add(5 * time.Minute),
IssuedAt: now,
})
return nil
}
func VerifyIdentityCode(purpose, phone, code string) error {
phone = strings.TrimSpace(phone)
code = strings.TrimSpace(code)
if code == "" {
return errors.New("请输入验证码")
}
key := identityCodeKey(purpose, phone)
v, ok := identityCodeStore.Load(key)
if !ok {
return errors.New("请先获取验证码")
}
item, ok := v.(identityCodeItem)
if !ok {
return errors.New("验证码状态异常,请重新获取")
}
if time.Now().After(item.ExpiredAt) {
identityCodeStore.Delete(key)
return errors.New("验证码已过期,请重新获取")
}
if item.Code != code {
return errors.New("验证码错误")
}
identityCodeStore.Delete(key)
return nil
}
type RegisterIdentityInput struct {
Phone string
Code string
Password string
Confirm string
Nickname string
TenantCode string
}
type RegisterIdentityResult struct {
IdentityID uint64
JoinedTid uint64
Warning string
}
func RegisterIdentity(in RegisterIdentityInput) (*RegisterIdentityResult, error) {
phone := strings.TrimSpace(in.Phone)
if !IsMobile(phone) {
return nil, errors.New("请输入正确的手机号")
}
if err := VerifyIdentityCode("register", phone, in.Code); err != nil {
return nil, err
}
if len(strings.TrimSpace(in.Password)) < 6 {
return nil, errors.New("密码长度不能少于6个字符")
}
if in.Password != in.Confirm {
return nil, errors.New("两次输入的密码不一致")
}
if findIdentityByMobile(phone) != nil {
return nil, errors.New("该手机号已注册,请直接登录")
}
hashed, err := passwordutil.Hash(strings.TrimSpace(in.Password))
if err != nil {
return nil, errors.New("密码处理失败")
}
nickname := strings.TrimSpace(in.Nickname)
if nickname == "" {
nickname = "用户" + phone[len(phone)-4:]
}
tenantCode := strings.TrimSpace(in.TenantCode)
var tenant *models.SystemTenant
if tenantCode != "" {
t := new(models.SystemTenant)
err := models.Orm.QueryTable(new(models.SystemTenant)).
Filter("tenant_code", tenantCode).
Filter("status", 1).
Filter("delete_time__isnull", true).
One(t)
if err != nil {
return nil, errors.New("企业编码不存在,请确认后重试")
}
if check, err := CheckTenantUserQuota(t.ID, 0); err == nil && !check.Allowed {
return nil, fmt.Errorf("该企业用户数已达上限(%d/%d),请联系企业管理员", check.Used, check.Quota)
}
tenant = t
}
identity := &models.AuthIdentity{
UnionID: strings.ReplaceAll(uuid.NewString(), "-", ""),
PasswordAlgo: passwordutil.AlgoOf(hashed),
Status: models.AuthIdentityStatusEnabled,
}
identity.Mobile = &phone
identity.Nickname = &nickname
identity.PasswordHash = &hashed
id, err := models.Orm.Insert(identity)
if err != nil {
return nil, errors.New("注册失败,请稍后重试")
}
identity.ID = uint64(id)
result := &RegisterIdentityResult{IdentityID: identity.ID}
if tenant != nil {
warn := joinTenantAfterRegister(identity, tenant, nickname, phone, hashed)
if warn != "" {
result.Warning = warn
} else {
result.JoinedTid = tenant.ID
}
}
return result, nil
}
func joinTenantAfterRegister(identity *models.AuthIdentity, tenant *models.SystemTenant, nickname, phone, passwordHash string) string {
var dup models.SystemTenantUser
if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", tenant.ID).
Filter("account", phone).
Filter("delete_time__isnull", true).
One(&dup); err == nil && dup.Uid != identity.ID {
return "注册成功,但企业内账号已被占用,请联系企业管理员邀请你加入"
}
phoneStr := phone
nameStr := nickname
hashStr := passwordHash
if _, err := BindTenantUser(
tenant.ID, identity.ID,
&phoneStr, &nameStr, &phoneStr, nil,
nil, nil, &hashStr,
1, 1, nil,
); err != nil {
return "注册成功,但加入企业失败,请联系企业管理员邀请你加入"
}
groupID := uint64(0)
if roleID, err := models.GetTenantUserRole(); err == nil && roleID > 0 {
groupID = roleID
_, _ = models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", tenant.ID).
Filter("uid", identity.ID).
Update(map[string]interface{}{"group_id": roleID})
}
if err := authsvc.SyncTenantUser(authsvc.SyncTenantUserInput{
Tid: tenant.ID,
Account: phoneStr,
Name: nameStr,
Phone: phoneStr,
PasswordHash: passwordHash,
GroupID: groupID,
Status: 1,
IsDefault: 1,
}); err != nil {
return "注册成功,企业绑定已建立,但认证中心同步失败,请联系管理员"
}
return ""
}
func ResetIdentityPasswordByMobile(phone, code, newPassword, confirm string) error {
phone = strings.TrimSpace(phone)
if !IsMobile(phone) {
return errors.New("请输入正确的手机号")
}
if err := VerifyIdentityCode("reset", phone, code); err != nil {
return err
}
if len(strings.TrimSpace(newPassword)) < 6 {
return errors.New("密码长度不能少于6个字符")
}
if newPassword != confirm {
return errors.New("两次输入的密码不一致")
}
identity := findIdentityByMobile(phone)
if identity == nil {
return errors.New("该手机号尚未注册")
}
return applyIdentityPassword(identity, newPassword)
}
func ChangeIdentityPassword(identityID uint64, oldPassword, newPassword, confirm string) error {
oldPassword = strings.TrimSpace(oldPassword)
newPassword = strings.TrimSpace(newPassword)
if identityID == 0 {
return errors.New("登录已失效,请重新登录")
}
if oldPassword == "" {
return errors.New("请输入当前密码")
}
if len(newPassword) < 6 {
return errors.New("新密码长度不能少于6个字符")
}
if newPassword != strings.TrimSpace(confirm) {
return errors.New("两次输入的新密码不一致")
}
if newPassword == oldPassword {
return errors.New("新密码不能与当前密码相同")
}
var identity models.AuthIdentity
if err := models.Orm.QueryTable(new(models.AuthIdentity)).
Filter("id", identityID).
One(&identity); err != nil {
return errors.New("账号不存在")
}
if identity.Status == models.AuthIdentityStatusDisabled {
return errors.New("账号已禁用,无法修改密码")
}
if identity.PasswordHash == nil || !passwordutil.Verify(*identity.PasswordHash, oldPassword) {
return errors.New("当前密码不正确")
}
return applyIdentityPassword(&identity, newPassword)
}
func mirrorPasswordToTenantRows(identityID uint64, passwordHash string) {
var binds []models.AuthTenantUser
if _, err := models.Orm.QueryTable(new(models.AuthTenantUser)).
Filter("identity_id", identityID).
Filter("delete_time__isnull", true).
All(&binds); err != nil {
return
}
for _, b := range binds {
_, _ = models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("tid", b.Tid).
Filter("uid", identityID).
Update(map[string]interface{}{"password": passwordHash})
}
}