MiFaZhan
769 lines
23 KiB
Go
769 lines
23 KiB
Go
// package system
|
|
// @Link https://github.com/xiujiecn/xiu-admin
|
|
// @Copyright Copyright (c) 2025 LiXiujie
|
|
// @Author Lxj <li@example.com>
|
|
// @License https://github.com/xiujiecn/xiu-admin/blob/master/LICENSE
|
|
package system
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"slices"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/consts"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/dao"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/library/contexts"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/library/event"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/library/xgorm/handler"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/model"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/model/do"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/model/entity"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/model/request"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/internal/service"
|
|
"git.5iot.com/iotlcm-public/iotlcm-app/utility"
|
|
|
|
"github.com/gogf/gf/v2/database/gdb"
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"github.com/gogf/gf/v2/util/gconv"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type sSysUser struct {
|
|
}
|
|
|
|
func NewSysUser() *sSysUser {
|
|
return &sSysUser{}
|
|
}
|
|
|
|
func init() {
|
|
service.RegisterSysUser(NewSysUser())
|
|
}
|
|
|
|
func (l *sSysUser) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
|
|
if len(option) == 0 {
|
|
option = append(option, &handler.Option{
|
|
FilterTenant: true,
|
|
FilterAuth: true,
|
|
})
|
|
}
|
|
return handler.Model(dao.SysUser.Ctx(ctx), option...)
|
|
}
|
|
|
|
// 根据用户名获取用户信息，不验证当前租户
|
|
func (l *sSysUser) GetUserByUsername(ctx context.Context, username string, tenantId string) (user *entity.SysUser, err error) {
|
|
var data *entity.SysUser
|
|
err = dao.SysUser.Ctx(ctx).Where(dao.SysUser.Columns().UserName, username).Where(dao.SysUser.Columns().TenantId, tenantId).Scan(&data)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
return nil, err
|
|
}
|
|
if data == nil {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
if data.Status == consts.SysUserStatusDisable {
|
|
return nil, gerror.NewCode(consts.CodeUserDisabled, "账号已禁用")
|
|
}
|
|
if data.Status == consts.SysUserStatusLocked {
|
|
return nil, gerror.NewCode(consts.CodeUserLocked, "账号已锁定")
|
|
}
|
|
if data.Status == consts.SysUserStatusExpired {
|
|
return nil, gerror.NewCode(consts.CodeUserExpired, "账号已过期")
|
|
}
|
|
if data.Status == consts.SysUserStatusDeleted {
|
|
return nil, gerror.NewCode(consts.CodeUserDeleted, "账号已删除")
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
// 根据邮箱获取用户信息，不验证当前租户
|
|
func (l *sSysUser) GetUserByEmail(ctx context.Context, email string, tenantId string) (user *entity.SysUser, err error) {
|
|
err = dao.SysUser.Ctx(ctx).Where(dao.SysUser.Columns().Email, email).Where(dao.SysUser.Columns().TenantId, tenantId).Scan(&user)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
return nil, err
|
|
}
|
|
if user == nil {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
if user.Status == consts.SysUserStatusDisable {
|
|
return nil, gerror.NewCode(consts.CodeUserDisabled, "账号已禁用")
|
|
}
|
|
if user.Status == consts.SysUserStatusLocked {
|
|
return nil, gerror.NewCode(consts.CodeUserLocked, "账号已锁定")
|
|
}
|
|
if user.Status == consts.SysUserStatusExpired {
|
|
return nil, gerror.NewCode(consts.CodeUserExpired, "账号已过期")
|
|
}
|
|
if user.Status == consts.SysUserStatusDeleted {
|
|
return nil, gerror.NewCode(consts.CodeUserDeleted, "账号已删除")
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
// 根据手机号获取用户信息,不验证当前租户
|
|
func (l *sSysUser) GetUserByPhone(ctx context.Context, phone string, tenantId string) (user *entity.SysUser, err error) {
|
|
err = dao.SysUser.Ctx(ctx).Where(dao.SysUser.Columns().Phonenumber, phone).Where(dao.SysUser.Columns().TenantId, tenantId).Scan(&user)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
return nil, err
|
|
}
|
|
if user == nil {
|
|
return nil, gerror.NewCode(consts.CodeUserNotFound, "账号不存在")
|
|
}
|
|
if user.Status == consts.SysUserStatusDisable {
|
|
return nil, gerror.NewCode(consts.CodeUserDisabled, "账号已禁用")
|
|
}
|
|
if user.Status == consts.SysUserStatusLocked {
|
|
return nil, gerror.NewCode(consts.CodeUserLocked, "账号已锁定")
|
|
}
|
|
if user.Status == consts.SysUserStatusExpired {
|
|
return nil, gerror.NewCode(consts.CodeUserExpired, "账号已过期")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 根据用户名和密码获取用户信息
|
|
func (l *sSysUser) GetUserByUsernameAndPassword(ctx context.Context, tenantId string, username string, password string) (user *entity.SysUser, err error) {
|
|
// 判断用户名是否存在
|
|
user, err = l.GetUserByUsername(ctx, username, tenantId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// 判断密码是否正确
|
|
password = utility.PasswordEncrypt(password, user.Salt)
|
|
if password != user.Password {
|
|
g.Log().Errorf(ctx, "密码错误: username:%s, password:%s, user:%+v", username, password, user)
|
|
return nil, gerror.NewCode(consts.CodeUserPasswordError, "密码错误")
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
// 根据用户ID获取用户信息
|
|
func (l *sSysUser) GetUserById(ctx context.Context, id int64) (user *model.SysUserViewModel, err error) {
|
|
err = l.Model(ctx).WithAll().Where(dao.SysUser.Columns().UserId, id).Scan(&user)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// 获取用户角色
|
|
userRoles := make([]*entity.SysUserRole, 0)
|
|
err = dao.SysUserRole.Ctx(ctx).Where(dao.SysUserRole.Columns().UserId, id).Scan(&userRoles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
roleIds := make([]int64, 0)
|
|
for _, userRole := range userRoles {
|
|
roleIds = append(roleIds, userRole.RoleId)
|
|
}
|
|
roles := make([]*entity.SysRole, 0)
|
|
err = dao.SysRole.Ctx(ctx).WhereIn(dao.SysRole.Columns().RoleId, roleIds).Scan(&roles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
user.Roles = make([]*model.SysRoleMiniModel, 0)
|
|
for _, role := range roles {
|
|
mini := &model.SysRoleMiniModel{}
|
|
gconv.Struct(role, mini)
|
|
user.Roles = append(user.Roles, mini)
|
|
}
|
|
// 获取用户岗位
|
|
userPosts := make([]*entity.SysUserPost, 0)
|
|
err = dao.SysUserPost.Ctx(ctx).Where(dao.SysUserPost.Columns().UserId, id).Scan(&userPosts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
postIds := make([]int64, 0)
|
|
for _, userPost := range userPosts {
|
|
postIds = append(postIds, userPost.PostId)
|
|
}
|
|
posts := make([]*entity.SysPost, 0)
|
|
err = dao.SysPost.Ctx(ctx).WhereIn(dao.SysPost.Columns().PostId, postIds).Scan(&posts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
user.Posts = make([]*model.SysPostMiniModel, 0)
|
|
for _, post := range posts {
|
|
mini := &model.SysPostMiniModel{}
|
|
gconv.Struct(post, mini)
|
|
user.Posts = append(user.Posts, mini)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取用户列表
|
|
func (l *sSysUser) List(ctx context.Context, page *request.PageInfo, query *model.UserListParam) (items []*model.SysUserListModel, total int, err error) {
|
|
deptIds := make([]int64, 0)
|
|
if query.DeptId != 0 {
|
|
deptIds = append(deptIds, query.DeptId)
|
|
subDeptIds, err := service.SysDept().GetDeptIdsByParentId(ctx, query.DeptId)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
deptIds = append(deptIds, subDeptIds...)
|
|
}
|
|
g.Log().Infof(ctx, "sSysUser.List 获取部门列表: deptIds:%+v", deptIds)
|
|
// 实现分页查询逻辑
|
|
var users []*model.SysUserListModel
|
|
m := l.Model(ctx)
|
|
if query.UserId != 0 {
|
|
m = m.Where(dao.SysUser.Columns().UserId, query.UserId)
|
|
}
|
|
if len(deptIds) > 0 {
|
|
m = m.WhereIn(dao.SysUser.Columns().DeptId, deptIds)
|
|
}
|
|
if query.UserName != "" {
|
|
m = m.WhereLike(dao.SysUser.Columns().UserName, "%"+query.UserName+"%")
|
|
}
|
|
if query.NickName != "" {
|
|
m = m.WhereLike(dao.SysUser.Columns().NickName, "%"+query.NickName+"%")
|
|
}
|
|
if query.Email != "" {
|
|
m = m.WhereLike(dao.SysUser.Columns().Email, "%"+query.Email+"%")
|
|
}
|
|
if query.Phonenumber != "" {
|
|
m = m.WhereLike(dao.SysUser.Columns().Phonenumber, "%"+query.Phonenumber+"%")
|
|
}
|
|
if query.Status != "" {
|
|
m = m.Where(dao.SysUser.Columns().Status, query.Status)
|
|
}
|
|
if len(query.CreatedAt) == 2 {
|
|
begin, end := gtime.NewFromStr(query.CreatedAt[0]), gtime.NewFromStr(query.CreatedAt[1])
|
|
m = m.WhereBetween(dao.SysUser.Columns().CreatedAt, begin, end.EndOfDay())
|
|
}
|
|
if len(query.DeptIdList) > 0 {
|
|
m = m.WhereIn(dao.SysUser.Columns().DeptId, query.DeptIdList)
|
|
}
|
|
total, err = m.Count()
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
err = m.WithAll().Page(page.Page, page.PageSize).Scan(&users)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
// g.Log().Infof(ctx, "获取用户列表成功: total:%d, users:%+v", total, users)
|
|
return users, total, nil
|
|
}
|
|
|
|
// 新增用户
|
|
func (l *sSysUser) AddUser(ctx context.Context, req *model.SysUserAddModel) (data *model.SysUserViewModel, err error) {
|
|
// 获取当前登录用户的租户
|
|
if req.TenantId == "" {
|
|
req.TenantId = contexts.GetTenantId(ctx)
|
|
}
|
|
// 判断部门是否存在
|
|
dept, err := service.SysDept().GetDeptById(ctx, req.DeptId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if dept == nil || dept.TenantId != req.TenantId {
|
|
return nil, gerror.NewCode(consts.CodeDeptNotFound, "部门不存在")
|
|
}
|
|
|
|
// 判断用户名是否存在（在当前租户下）
|
|
var user *entity.SysUser
|
|
err = dao.SysUser.Ctx(ctx).Where(dao.SysUser.Columns().UserName, req.UserName).Where(dao.SysUser.Columns().TenantId, req.TenantId).Scan(&user)
|
|
if err != nil {
|
|
if err != gorm.ErrRecordNotFound {
|
|
return nil, err
|
|
}
|
|
}
|
|
if user != nil {
|
|
return nil, gerror.NewCode(consts.CodeUserExists, "用户名已存在")
|
|
}
|
|
// // 判断邮箱是否存在
|
|
// user, err = l.GetUserByEmail(ctx, req.Email)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// if user != nil {
|
|
// return nil, gerror.NewCode(consts.CodeEmailExists, "邮箱已存在")
|
|
// }
|
|
// // 判断手机号是否存在
|
|
// user, err = l.GetUserByPhone(ctx, req.Phone)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// if user != nil {
|
|
// return nil, gerror.NewCode(consts.CodePhoneExists, "手机号已存在")
|
|
// }
|
|
|
|
// 随机生成5位字符
|
|
salt := utility.RandomString(5)
|
|
password := utility.PasswordEncrypt(req.Password, salt)
|
|
|
|
dataInsert := do.SysUser{}
|
|
gconv.Struct(req, &dataInsert)
|
|
dataInsert.Password = password
|
|
dataInsert.Salt = salt
|
|
dataInsert.CreatedDept = contexts.GetDeptId(ctx)
|
|
dataInsert.CreatedBy = contexts.GetUserId(ctx)
|
|
dataInsert.CreatedAt = gtime.Now()
|
|
dataInsert.UpdatedBy = contexts.GetUserId(ctx)
|
|
dataInsert.UpdatedAt = gtime.Now()
|
|
dataInsert.TenantId = req.TenantId
|
|
result, err := dao.SysUser.Ctx(ctx).Data(dataInsert).Insert()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
userId, err := result.LastInsertId()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
data, err = l.GetUserById(ctx, userId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// 新增用户角色
|
|
d := make([]*do.SysUserRole, 0, len(req.RoleIds))
|
|
if len(req.RoleIds) > 0 {
|
|
for _, roleId := range req.RoleIds {
|
|
d = append(d, &do.SysUserRole{
|
|
UserId: userId,
|
|
RoleId: roleId,
|
|
})
|
|
}
|
|
_, err = dao.SysUserRole.Ctx(ctx).Data(d).Insert()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
// 新增用户岗位
|
|
if len(req.PostIds) > 0 {
|
|
postData := make([]*do.SysUserPost, 0, len(req.PostIds))
|
|
for _, postId := range req.PostIds {
|
|
postData = append(postData, &do.SysUserPost{
|
|
UserId: userId,
|
|
PostId: postId,
|
|
})
|
|
}
|
|
_, err = dao.SysUserPost.Ctx(ctx).Data(postData).Insert()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func (l *sSysUser) Profile(ctx context.Context) (user *model.UserProfileModel, err error) {
|
|
|
|
u, err := l.GetUserById(ctx, contexts.GetUserId(ctx))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
companyInfo := service.SysDept().GetParentCompanyInfo(ctx, u.DeptId)
|
|
return &model.UserProfileModel{
|
|
SysUserViewModel: *u,
|
|
CompanyInfo: &model.SysDeptMiniModel{
|
|
DeptId: companyInfo.DeptId,
|
|
DeptName: companyInfo.DeptName,
|
|
ParentId: companyInfo.ParentId,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (l *sSysUser) UpdateCurrentUser(ctx context.Context, req *model.UpdateCurrentUserModel) (user *model.SysUserViewModel, err error) {
|
|
userId := contexts.GetUserId(ctx)
|
|
data := do.SysUser{}
|
|
gconv.Struct(req, &data)
|
|
data.UserId = nil
|
|
_, err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, userId).Data(data).OmitEmpty().Update()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
user, err = l.GetUserById(ctx, userId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
event.EventsInstance().Emit(ctx, consts.EventKeyUserUpdate, userId)
|
|
return user, nil
|
|
}
|
|
|
|
func (l *sSysUser) UpdateCurrentUserPassword(ctx context.Context, req *model.UpdateCurrentUserPasswordModel) (err error) {
|
|
userId := contexts.GetUserId(ctx)
|
|
var user *entity.SysUser
|
|
err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, userId).Scan(&user)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if user == nil {
|
|
return gerror.NewCode(consts.CodeUserNotFound, "用户不存在")
|
|
}
|
|
|
|
oldPassword := utility.PasswordEncrypt(req.OldPassword, user.Salt)
|
|
if oldPassword != user.Password {
|
|
return gerror.NewCode(consts.CodeUserPasswordError, "旧密码错误")
|
|
}
|
|
salt := utility.RandomString(5)
|
|
password := utility.PasswordEncrypt(req.NewPassword, salt)
|
|
data := do.SysUser{
|
|
Password: password,
|
|
Salt: salt,
|
|
UpdatedBy: userId,
|
|
UpdatedAt: gtime.Now(),
|
|
}
|
|
_, err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, userId).Data(data).OmitEmpty().Update()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (l *sSysUser) UpdateUser(ctx context.Context, req *model.SysUserUpdateModel) (err error) {
|
|
currUserId := contexts.GetUserId(ctx)
|
|
req.UpdatedAt = gtime.Now()
|
|
req.UpdatedBy = &currUserId
|
|
data := do.SysUser{}
|
|
gconv.Struct(req, &data)
|
|
data.UserId = nil
|
|
_, err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, req.UserId).Data(data).OmitNil().Update()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// 用户角色
|
|
urList := make([]*entity.SysUserRole, 0)
|
|
err = dao.SysUserRole.Ctx(ctx).Where(dao.SysUserRole.Columns().UserId, req.UserId).Scan(&urList)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// 计算删除和新增的角色
|
|
delRoleIds := make([]int64, 0)
|
|
addRoleIds := make([]int64, 0)
|
|
hasRoleId := false
|
|
for _, ur := range urList {
|
|
hasRoleId = false
|
|
for _, roleId := range req.RoleIds {
|
|
if ur.RoleId == roleId {
|
|
hasRoleId = true
|
|
break
|
|
}
|
|
}
|
|
if !hasRoleId {
|
|
delRoleIds = append(delRoleIds, ur.RoleId)
|
|
}
|
|
}
|
|
for _, roleId := range req.RoleIds {
|
|
hasRoleId = false
|
|
for _, ur := range urList {
|
|
if ur.RoleId == roleId {
|
|
hasRoleId = true
|
|
break
|
|
}
|
|
}
|
|
if !hasRoleId {
|
|
addRoleIds = append(addRoleIds, roleId)
|
|
}
|
|
}
|
|
// 删除多余的角色
|
|
if len(delRoleIds) > 0 {
|
|
_, err = dao.SysUserRole.Ctx(ctx).Where(dao.SysUserRole.Columns().UserId, req.UserId).WhereIn(dao.SysUserRole.Columns().RoleId, delRoleIds).Delete()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// 新增角色
|
|
d := make([]*do.SysUserRole, 0, len(addRoleIds))
|
|
if len(addRoleIds) > 0 {
|
|
for _, roleId := range addRoleIds {
|
|
d = append(d, &do.SysUserRole{
|
|
UserId: req.UserId,
|
|
RoleId: roleId,
|
|
})
|
|
}
|
|
_, err = dao.SysUserRole.Ctx(ctx).Data(d).Insert()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// 查询用户岗位
|
|
upList := make([]*entity.SysUserPost, 0)
|
|
err = dao.SysUserPost.Ctx(ctx).Where(dao.SysUserPost.Columns().UserId, req.UserId).Scan(&upList)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// 计算删除和新增的岗位
|
|
delPostIds := make([]int64, 0)
|
|
addPostIds := make([]int64, 0)
|
|
hasPostId := false
|
|
for _, up := range upList {
|
|
hasPostId = false
|
|
for _, postId := range req.PostIds {
|
|
if up.PostId == postId {
|
|
hasPostId = true
|
|
break
|
|
}
|
|
}
|
|
if !hasPostId {
|
|
delPostIds = append(delPostIds, up.PostId)
|
|
}
|
|
}
|
|
for _, postId := range req.PostIds {
|
|
hasPostId = false
|
|
for _, up := range upList {
|
|
if up.PostId == postId {
|
|
hasPostId = true
|
|
break
|
|
}
|
|
}
|
|
if !hasPostId {
|
|
addPostIds = append(addPostIds, postId)
|
|
}
|
|
}
|
|
// 删除多余岗位
|
|
if len(delPostIds) > 0 {
|
|
_, err = dao.SysUserPost.Ctx(ctx).Where(dao.SysUserPost.Columns().UserId, req.UserId).WhereIn(dao.SysUserPost.Columns().PostId, delPostIds).Delete()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// 新增岗位
|
|
postData := make([]*do.SysUserPost, 0, len(addPostIds))
|
|
if len(addPostIds) > 0 {
|
|
for _, postId := range addPostIds {
|
|
postData = append(postData, &do.SysUserPost{
|
|
UserId: req.UserId,
|
|
PostId: postId,
|
|
})
|
|
}
|
|
_, err = dao.SysUserPost.Ctx(ctx).Data(postData).Insert()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
event.EventsInstance().Emit(ctx, consts.EventKeyUserUpdate, req.UserId)
|
|
return nil
|
|
}
|
|
|
|
func (l *sSysUser) DeleteUser(ctx context.Context, userIds []int64) (err error) {
|
|
if len(userIds) == 0 {
|
|
g.Log().Warningf(ctx, "sSysUser.DeleteUser 用户ID列表不能为空. userIds: %v", userIds)
|
|
return errors.New("用户ID列表不能为空")
|
|
}
|
|
currUserId := contexts.GetUserId(ctx)
|
|
if slices.Contains(userIds, 1) {
|
|
g.Log().Warningf(ctx, "sSysUser.DeleteUser 不能删除超级管理员. userIds: %v", userIds)
|
|
return errors.New("不能删除超级管理员")
|
|
}
|
|
if slices.Contains(userIds, currUserId) {
|
|
g.Log().Warningf(ctx, "sSysUser.DeleteUser 不能删除当前用户. userIds: %v, currUserId: %d", userIds, currUserId)
|
|
return errors.New("不能删除当前用户")
|
|
}
|
|
isAdminUserIds, err := service.SysTenant().IsTenantAdmin(ctx, userIds)
|
|
if err != nil {
|
|
g.Log().Errorf(ctx, "sSysUser.DeleteUser IsTenantAdmin err: %v, userIds: %v", err, userIds)
|
|
return err
|
|
}
|
|
if len(isAdminUserIds) > 0 {
|
|
g.Log().Warningf(ctx, "sSysUser.DeleteUser 不能删除租户管理员. isAdminUserIds: %v, userIds: %v", isAdminUserIds, userIds)
|
|
return errors.New(fmt.Sprintf("不能删除租户管理员ID: %v", isAdminUserIds))
|
|
}
|
|
|
|
data := do.SysUser{
|
|
DeletedAt: gtime.Now(),
|
|
DeletedBy: currUserId,
|
|
}
|
|
_, err = l.Model(ctx).WhereIn(dao.SysUser.Columns().UserId, userIds).Data(data).OmitEmpty().Update()
|
|
if err != nil {
|
|
g.Log().Errorf(ctx, "sSysUser.DeleteUser Update err: %v, userIds: %v", err, userIds)
|
|
return err
|
|
}
|
|
|
|
// 删除用户绑定关系
|
|
_, err = dao.SysSocial.Ctx(ctx).WhereIn(dao.SysSocial.Columns().UserId, userIds).Delete()
|
|
if err != nil {
|
|
g.Log().Errorf(ctx, "sSysUser.DeleteUser SysSocial.Ctx(ctx).Delete err: %v, userIds: %v", err, userIds)
|
|
return err
|
|
}
|
|
|
|
event.EventsInstance().Emit(ctx, consts.EventKeyUserDelete, userIds)
|
|
return nil
|
|
}
|
|
|
|
func (l *sSysUser) ResetPassword(ctx context.Context, userId int64, password string) (err error) {
|
|
currUserId := contexts.GetUserId(ctx)
|
|
salt := utility.RandomString(5)
|
|
password = utility.PasswordEncrypt(password, salt)
|
|
data := do.SysUser{
|
|
Password: password,
|
|
Salt: salt,
|
|
UpdatedBy: currUserId,
|
|
UpdatedAt: gtime.Now(),
|
|
}
|
|
_, err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, userId).Data(data).OmitEmpty().Update()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
event.EventsInstance().Emit(ctx, consts.EventKeyUserUpdate, userId)
|
|
return nil
|
|
}
|
|
|
|
func (l *sSysUser) UpdateLoginInfo(ctx context.Context, userId int64, loginIp string) (err error) {
|
|
data := do.SysUser{
|
|
LoginIp: loginIp,
|
|
LoginDate: gtime.Now(),
|
|
}
|
|
_, err = dao.SysUser.Ctx(ctx).Where(dao.SysUser.Columns().UserId, userId).Data(data).Update()
|
|
if err != nil {
|
|
g.Log().Errorf(ctx, "sSysUser.UpdateLoginInfo err: %v, userId: %d, loginIp: %s", err, userId, loginIp)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 获取用户角色ID列表
|
|
func (l *sSysUser) GetUserRoleIds(ctx context.Context, userId int64) (roleIds []int64, err error) {
|
|
urList := make([]*entity.SysUserRole, 0)
|
|
err = dao.SysUserRole.Ctx(ctx).Where(dao.SysUserRole.Columns().UserId, userId).Scan(&urList)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, ur := range urList {
|
|
roleIds = append(roleIds, ur.RoleId)
|
|
}
|
|
return roleIds, nil
|
|
}
|
|
|
|
// 获取用户岗位ID列表
|
|
func (l *sSysUser) GetUserPostIds(ctx context.Context, userId int64) (postIds []int64, err error) {
|
|
upList := make([]*entity.SysUserPost, 0)
|
|
err = dao.SysUserPost.Ctx(ctx).Where(dao.SysUserPost.Columns().UserId, userId).Scan(&upList)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, up := range upList {
|
|
postIds = append(postIds, up.PostId)
|
|
}
|
|
return postIds, nil
|
|
}
|
|
|
|
func (l *sSysUser) Register(ctx context.Context, param *model.SysUserRegisterModel) (err error) {
|
|
// 验证验证码
|
|
err = service.SysCaptcha().VerifyCaptcha(ctx, param.CaptchaID, param.CaptchaValue)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 检查是否开启用户注册功能
|
|
registerConfig := &model.SysConfigViewModel{}
|
|
mod := dao.SysConfig.Ctx(ctx)
|
|
mod = mod.Where(dao.SysConfig.Columns().ConfigKey, "sys.account.registerUser")
|
|
mod = mod.Where(dao.SysConfig.Columns().TenantId, param.TenantId)
|
|
err = mod.Scan(®isterConfig)
|
|
if err != nil {
|
|
return gerror.New("请联系管理员开启用户注册功能")
|
|
}
|
|
if registerConfig == nil || registerConfig.ConfigValue != "true" {
|
|
return gerror.New("请联系管理员开启用户注册功能")
|
|
}
|
|
|
|
// 获取租户信息
|
|
tenant, err := service.SysTenant().View(ctx, &model.SysTenantViewParam{
|
|
TenantId: param.TenantId,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if tenant == nil {
|
|
return gerror.New("租户无效")
|
|
}
|
|
|
|
// 获取租户的默认注册组织ID
|
|
config := &model.SysConfigViewModel{}
|
|
mod = dao.SysConfig.Ctx(ctx)
|
|
mod = mod.Where(dao.SysConfig.Columns().ConfigKey, consts.ConfigKeyTenantDefaultRegisterDeptId)
|
|
mod = mod.Where(dao.SysConfig.Columns().TenantId, param.TenantId)
|
|
err = mod.Scan(&config)
|
|
if err != nil {
|
|
return gerror.New("该租户不允许自主注册")
|
|
}
|
|
if config == nil || config.ConfigValue == "" {
|
|
return gerror.New("该租户不允许自主注册")
|
|
}
|
|
|
|
// 验证用户名是否存在
|
|
mod1 := dao.SysUser.Ctx(ctx)
|
|
mod1 = mod1.Where(dao.SysUser.Columns().UserName, param.UserName)
|
|
mod1 = mod1.Where(dao.SysUser.Columns().TenantId, param.TenantId)
|
|
total, err := mod1.Count()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if total > 0 {
|
|
return gerror.New("用户名已存在")
|
|
}
|
|
// 随机生成5位字符
|
|
salt := utility.RandomString(5)
|
|
password := utility.PasswordEncrypt(param.Password, salt)
|
|
|
|
newUser := do.SysUser{
|
|
UserName: param.UserName,
|
|
NickName: "",
|
|
Password: password,
|
|
Salt: salt,
|
|
TenantId: param.TenantId,
|
|
DeptId: gconv.Int64(config.ConfigValue),
|
|
Status: consts.SysDeptStatusNormal,
|
|
CreatedBy: 0,
|
|
CreatedAt: gtime.Now(),
|
|
UpdatedBy: 0,
|
|
UpdatedAt: gtime.Now(),
|
|
}
|
|
|
|
userId, err := l.Model(ctx).Data(newUser).InsertAndGetId()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
//配置角色
|
|
// 新增用户角色
|
|
mod = dao.SysConfig.Ctx(ctx)
|
|
mod = mod.Where(dao.SysConfig.Columns().ConfigKey, consts.ConfigKeyTenantDefaultRegisterRoleId)
|
|
mod = mod.Where(dao.SysConfig.Columns().TenantId, param.TenantId)
|
|
err = mod.Scan(&config)
|
|
if err != nil {
|
|
g.Log().Error(ctx, "获取租户的默认角色失败", err)
|
|
}
|
|
if config != nil && config.ConfigValue != "" {
|
|
roleId := gconv.Int64(config.ConfigValue)
|
|
data := do.SysUserRole{
|
|
UserId: userId,
|
|
RoleId: roleId,
|
|
}
|
|
_, err = dao.SysUserRole.Ctx(ctx).Data(data).Insert()
|
|
if err != nil {
|
|
g.Log().Error(ctx, "获取租户的默认角色失败", err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Status 更新用户状态
|
|
func (l *sSysUser) Status(ctx context.Context, param *model.SysUserStatusParam) (err error) {
|
|
data := do.SysUser{
|
|
Status: param.Status,
|
|
}
|
|
_, err = l.Model(ctx).Where(dao.SysUser.Columns().UserId, param.UserId).Data(data).OmitEmpty().Update()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 批量查询用户迷你信息
|
|
func (l *sSysUser) BatchGetUserMiniInfo(ctx context.Context, userIds []int64) (users []*model.SysUserMiniModel, err error) {
|
|
err = dao.SysUser.Ctx(ctx).WhereIn(dao.SysUser.Columns().UserId, userIds).Scan(&users)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return users, nil
|
|
}
|