iotlcm/admin-svr/server/internal/logic/agent/agent_user.go

package agent

import (
	"context"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
)

type sAgentUser struct {
	*agentBase
}

func NewAgentUser() *sAgentUser {
	return &sAgentUser{
		agentBase: newAgentBase(),
	}
}

func init() {
	service.RegisterAgentUser(NewAgentUser())
}

// UserList 查询用户列表
func (s *sAgentUser) UserList(ctx context.Context, in *model.AgentUserListParam) (list []*model.AgentUserListModel, total int, err error) {
	deptId := contexts.GetDeptId(ctx)
	if deptId == 0 {
		return nil, 0, gerror.New("当前用户未绑定组织")
	}
	if in.Page <= 0 {
		in.Page = 1
	}
	if in.PageSize <= 0 {
		in.PageSize = 20
	}
	m := s.userModel(ctx).Where(dao.SysUser.Columns().DeptId, deptId)
	if in.UserName != "" {
		m = m.WhereLike(dao.SysUser.Columns().UserName, "%"+in.UserName+"%")
	}
	if in.NickName != "" {
		m = m.WhereLike(dao.SysUser.Columns().NickName, "%"+in.NickName+"%")
	}
	if in.Email != "" {
		m = m.WhereLike(dao.SysUser.Columns().Email, "%"+in.Email+"%")
	}
	if in.Phonenumber != "" {
		m = m.WhereLike(dao.SysUser.Columns().Phonenumber, "%"+in.Phonenumber+"%")
	}
	if in.Status != "" {
		m = m.Where(dao.SysUser.Columns().Status, in.Status)
	}
	if len(in.CreatedAt) == 2 {
		begin, end := gtime.NewFromStr(in.CreatedAt[0]), gtime.NewFromStr(in.CreatedAt[1])
		m = m.WhereBetween(dao.SysUser.Columns().CreatedAt, begin, end.EndOfDay())
	}
	total, err = m.Count()
	if err != nil {
		return nil, 0, err
	}
	var sysList []*model.SysUserListModel
	err = m.Order(dao.SysUser.Columns().UserId, "ASC").WithAll().Page(in.Page, in.PageSize).Scan(&sysList)
	if err != nil {
		return nil, 0, err
	}
	if err = s.fillRolesAndDefaultFlag(ctx, sysList); err != nil {
		return nil, 0, err
	}
	if err = gconv.Structs(sysList, &list); err != nil {
		return nil, 0, err
	}
	return list, total, nil
}

// UserView 查看用户详情
func (s *sAgentUser) UserView(ctx context.Context, userId int64) (res *model.AgentUserViewModel, err error) {
	sysUser, err := service.SysUser().GetUserById(ctx, userId)
	if err != nil {
		return nil, err
	}
	if sysUser == nil || sysUser.UserId == 0 {
		return nil, gerror.New("用户不存在")
	}
	if sysUser.DeptId != contexts.GetDeptId(ctx) {
		return nil, gerror.New("只能操作本级用户")
	}
	res = &model.AgentUserViewModel{}
	if err = gconv.Struct(sysUser, res); err != nil {
		return nil, err
	}
	res.IsDefaultUser, err = s.isDefaultUser(ctx, userId)
	if err != nil {
		return nil, err
	}
	return res, nil
}

// filterRoleIdsByDept 过滤角色ID，只保留本级及下一级角色
func (s *sAgentUser) filterRoleIdsByDept(ctx context.Context, deptId int64, roleIds []int64) (res []int64, err error) {
	if len(roleIds) == 0 {
		return roleIds, nil
	}
	var roles []*entity.SysRole
	err = s.roleModel(ctx).
		WhereIn(dao.SysRole.Columns().RoleId, roleIds).
		Where(dao.SysRole.Columns().DeptId, deptId).
		Where("is_pass", 0).
		Scan(&roles)
	if err != nil {
		return nil, err
	}
	for _, role := range roles {
		res = append(res, role.RoleId)
	}
	return res, nil
}

// fillRolesAndDefaultFlag 填充用户角色和默认标志
func (s *sAgentUser) fillRolesAndDefaultFlag(ctx context.Context, list []*model.SysUserListModel) error {
	if len(list) == 0 {
		return nil
	}
	userIds := make([]int64, 0, len(list))
	deptIds := make([]int64, 0, len(list))
	userById := make(map[int64]*model.SysUserListModel, len(list))
	for _, user := range list {
		userIds = append(userIds, user.UserId)
		deptIds = append(deptIds, user.DeptId)
		userById[user.UserId] = user
	}

	var userRoles []*entity.SysUserRole
	err := dao.SysUserRole.Ctx(ctx).
		WhereIn(dao.SysUserRole.Columns().UserId, userIds).
		Scan(&userRoles)
	if err != nil {
		return err
	}
	roleIds := make([]int64, 0, len(userRoles))
	userRoleMap := make(map[int64][]int64, len(userRoles))
	for _, userRole := range userRoles {
		roleIds = append(roleIds, userRole.RoleId)
		userRoleMap[userRole.UserId] = append(userRoleMap[userRole.UserId], userRole.RoleId)
	}
	if len(roleIds) > 0 {
		var roles []*entity.SysRole
		if err = s.roleModel(ctx).
			WhereIn(dao.SysRole.Columns().RoleId, roleIds).
			Scan(&roles); err != nil {
			return err
		}
		roleMap := make(map[int64]*entity.SysRole, len(roles))
		for _, role := range roles {
			roleMap[role.RoleId] = role
		}
		for _, userRole := range userRoles {
			role := roleMap[userRole.RoleId]
			user := userById[userRole.UserId]
			if role == nil || user == nil {
				continue
			}
			user.Roles = append(user.Roles, &model.SysRoleMiniModel{
				RoleId:    role.RoleId,
				RoleName:  role.RoleName,
				DataScope: role.DataScope,
			})
		}
	}

	var depts []*entity.SysDept
	if err = s.deptModel(ctx).
		WhereIn(dao.SysDept.Columns().DeptId, deptIds).
		Scan(&depts); err != nil {
		return err
	}
	deptRoleMap := make(map[int64]int64, len(depts))
	for _, dept := range depts {
		if dept.DeptRole > 0 {
			deptRoleMap[dept.DeptId] = dept.DeptRole
		}
	}
	for _, user := range list {
		deptRoleId := deptRoleMap[user.DeptId]
		if deptRoleId == 0 {
			continue
		}
		for _, roleId := range userRoleMap[user.UserId] {
			if roleId == deptRoleId {
				user.IsDefaultUser = true
				break
			}
		}
	}
	return nil
}

// isDefaultUser 判断用户是否为默认用户
func (s *sAgentUser) isDefaultUser(ctx context.Context, userId int64) (bool, error) {
	var user *entity.SysUser
	if err := s.userModel(ctx).
		Where(dao.SysUser.Columns().UserId, userId).
		Scan(&user); err != nil {
		return false, err
	}
	if user == nil || user.UserId == 0 {
		return false, gerror.New("用户不存在")
	}
	var dept *entity.SysDept
	if err := s.deptModel(ctx).
		Where(dao.SysDept.Columns().DeptId, user.DeptId).
		Scan(&dept); err != nil {
		return false, err
	}
	if dept == nil || dept.DeptRole == 0 {
		return false, nil
	}
	count, err := dao.SysUserRole.Ctx(ctx).
		Where(dao.SysUserRole.Columns().UserId, userId).
		Where(dao.SysUserRole.Columns().RoleId, dept.DeptRole).
		Count()
	return count > 0, err
}

// UserSave 新增/修改用户
func (s *sAgentUser) UserSave(ctx context.Context, in *model.SysUserAddModel) (res *model.AgentUserViewModel, err error) {
	user := contexts.GetUser(ctx)
	if user == nil {
		return nil, gerror.New("登录已过期")
	}
	in.TenantId = user.TenantId
	in.DeptId = user.DeptId
	in.UserType = consts.SysUserTypeSys
	if in.DeptId == 0 {
		return nil, gerror.New("当前用户未绑定组织")
	}
	if len(in.RoleIds) == 0 {
		return nil, gerror.New("请选择角色")
	}
	in.RoleIds, err = s.filterRoleIdsByDept(ctx, in.DeptId, in.RoleIds)
	if err != nil {
		return nil, err
	}
	if len(in.RoleIds) == 0 {
		return nil, gerror.New("请选择本级角色")
	}
	// 验证角色的DeptId和用户的deptId一致
	if err = s.ensureRoleDeptInScope(ctx, in.DeptId, in.RoleIds); err != nil {
		return nil, err
	}

	sysUser, err := service.SysUser().AddUser(ctx, in)
	if err != nil {
		return nil, err
	}
	res = &model.AgentUserViewModel{}
	if err = gconv.Struct(sysUser, res); err != nil {
		return nil, err
	}
	res.IsDefaultUser, err = s.isDefaultUser(ctx, res.UserId)
	if err != nil {
		return nil, err
	}
	return res, nil
}

// UserUpdate 更新用户
func (s *sAgentUser) UserUpdate(ctx context.Context, in *model.SysUserUpdateModel) (err error) {
	current, err := s.UserView(ctx, in.UserId)
	if err != nil {
		return err
	}
	currentDeptId := contexts.GetDeptId(ctx)
	if currentDeptId == 0 {
		return gerror.New("当前用户未绑定组织")
	}
	if current.DeptId != currentDeptId {
		return gerror.New("只能修改本级用户")
	}
	in.DeptId = &current.DeptId
	if len(in.RoleIds) == 0 {
		return gerror.New("请选择角色")
	}
	in.RoleIds, err = s.filterRoleIdsByDept(ctx, *in.DeptId, in.RoleIds)
	if err != nil {
		return err
	}
	if len(in.RoleIds) == 0 {
		return gerror.New("请选择本级角色")
	}
	userType := consts.SysUserTypeSys
	in.UserType = &userType
	// 验证角色的DeptId和用户的deptId一致
	if err = s.ensureRoleDeptInScope(ctx, *in.DeptId, in.RoleIds); err != nil {
		return err
	}
	return service.SysUser().UpdateUser(ctx, in)
}

// UserDelete 删除用户
func (s *sAgentUser) UserDelete(ctx context.Context, userIds []int64) (err error) {
	for _, userId := range userIds {
		if _, err = s.UserView(ctx, userId); err != nil {
			return err
		}
	}
	return service.SysUser().DeleteUser(ctx, userIds)
}

// UserResetPassword 重置用户密码
func (s *sAgentUser) UserResetPassword(ctx context.Context, userId int64, password string) (err error) {
	if _, err = s.UserView(ctx, userId); err != nil {
		return err
	}
	return service.SysUser().ResetPassword(ctx, userId, password)
}

// 验证角色部门和用户部门是否一致
func (s *sAgentUser) ensureRoleDeptInScope(ctx context.Context, deptId int64, roleIds []int64) (err error) {
	// 验证角色的DeptId和用户的deptId一致
	var roles []*entity.SysRole
	err = s.roleModel(ctx).
		WhereIn(dao.SysRole.Columns().RoleId, roleIds).
		Scan(&roles)
	if err != nil {
		return err
	}
	for _, role := range roles {
		if role.DeptId != deptId {
			return gerror.New("角色部门与用户部门不一致")
		}
	}
	return nil
}