352 lines
8.9 KiB
Go
352 lines
8.9 KiB
Go
package user
|
|
|
|
import (
|
|
v1 "TrangleAgent/api/user/v1"
|
|
"TrangleAgent/internal/dao"
|
|
"TrangleAgent/internal/model"
|
|
"TrangleAgent/internal/model/entity"
|
|
"TrangleAgent/internal/service"
|
|
"context"
|
|
|
|
"github.com/gogf/gf/v2/errors/gcode"
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
)
|
|
|
|
type sUser struct{}
|
|
|
|
func New() *sUser {
|
|
return &sUser{}
|
|
}
|
|
|
|
func init() {
|
|
service.RegisterUser(New())
|
|
}
|
|
|
|
func (s *sUser) UserList(ctx context.Context, req *v1.UserListReq) (res *v1.UserListRes, err error) {
|
|
// 创建数据库查询模型
|
|
m := dao.Users.Ctx(ctx)
|
|
|
|
// 按照账号搜索
|
|
if req.Account != "" {
|
|
m = m.WhereLike(dao.Users.Columns().Account, "%"+req.Account+"%")
|
|
}
|
|
|
|
// 按照昵称搜索
|
|
if req.Nickname != "" {
|
|
m = m.WhereLike(dao.Users.Columns().Nickname, "%"+req.Nickname+"%")
|
|
}
|
|
|
|
// 查询总数
|
|
total, err := m.Count()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 分页处理
|
|
m = m.Page(req.Page, req.PageSize)
|
|
|
|
// 查询列表数据
|
|
var users []*model.User
|
|
err = m.Scan(&users)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 转换为视图参数
|
|
userViewList := make([]*model.UserViewParams, 0, len(users))
|
|
for _, user := range users {
|
|
userViewList = append(userViewList, &model.UserViewParams{
|
|
Id: user.Id,
|
|
Account: user.Account,
|
|
Nickname: user.Nickname,
|
|
Gender: user.Gender,
|
|
BirthDate: user.BirthDate,
|
|
UserType: user.UserType,
|
|
VipStartAt: user.VipStartAt,
|
|
VipEndAt: user.VipEndAt,
|
|
CreatedAt: user.CreatedAt,
|
|
})
|
|
}
|
|
|
|
res = &v1.UserListRes{
|
|
Users: userViewList,
|
|
}
|
|
|
|
// 设置分页信息
|
|
req.PageResult.Total = int(total)
|
|
req.PageResult.Page = req.Page
|
|
req.PageResult.PageSize = req.PageSize
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (s *sUser) UserView(ctx context.Context, req *v1.UserViewReq) (res *v1.UserViewRes, err error) {
|
|
// 创建数据库查询模型
|
|
m := dao.Users.Ctx(ctx)
|
|
|
|
// 根据账号查询
|
|
if req.Account != "" {
|
|
m = m.Where(dao.Users.Columns().Account, req.Account)
|
|
}
|
|
|
|
res = &v1.UserViewRes{}
|
|
err = m.Scan(&res.UserViewParams)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "查询用户信息失败")
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (s *sUser) UserUpdate(ctx context.Context, req *v1.UserUpdateReq) (res *v1.UserUpdateRes, err error) {
|
|
// 创建数据库查询模型
|
|
m := dao.Users.Ctx(ctx)
|
|
|
|
// 根据账号更新用户信息
|
|
_, err = m.Data(req).Where(dao.Users.Columns().Account, req.Account).Update()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "更新用户信息失败")
|
|
}
|
|
|
|
res = &v1.UserUpdateRes{}
|
|
// 获取更新后的用户信息
|
|
err = m.Where(dao.Users.Columns().Account, req.Account).Scan(&res)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "查询用户信息失败")
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (s *sUser) UserDelete(ctx context.Context, req *v1.UserDeleteReq) (res *v1.UserDeleteRes, err error) {
|
|
// 根据账号删除用户
|
|
_, err = dao.Users.Ctx(ctx).Where(dao.Users.Columns().Account, req.Account).Delete()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "删除用户失败")
|
|
}
|
|
|
|
res = &v1.UserDeleteRes{}
|
|
return res, nil
|
|
}
|
|
|
|
// RoleCreate 创建角色
|
|
func (s *sUser) RoleCreate(ctx context.Context, req *v1.RoleCreateReq) (res *v1.RoleCreateRes, err error) {
|
|
// 插入角色数据
|
|
data := &entity.RoleCards{
|
|
UserId: req.UserId,
|
|
DepartmentId: req.DepartmentId,
|
|
AgentName: req.AgentName,
|
|
CodeName: req.CodeName,
|
|
Gender: req.Gender,
|
|
ArcAbnormal: req.ArcAbnormal,
|
|
ArcReality: req.ArcReality,
|
|
ArcPosition: req.ArcPosition,
|
|
}
|
|
|
|
id, err := dao.RoleCards.Ctx(ctx).Data(data).InsertAndGetId()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "创建角色失败")
|
|
}
|
|
|
|
res = &v1.RoleCreateRes{
|
|
Id: uint64(id),
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// RoleUpdate 更新角色
|
|
func (s *sUser) RoleUpdate(ctx context.Context, req *v1.RoleUpdateReq) (res *v1.RoleUpdateRes, err error) {
|
|
// 更新角色数据
|
|
data := &entity.RoleCards{
|
|
DepartmentId: req.DepartmentId,
|
|
AgentName: req.AgentName,
|
|
CodeName: req.CodeName,
|
|
Gender: req.Gender,
|
|
ArcAbnormal: req.ArcAbnormal,
|
|
ArcReality: req.ArcReality,
|
|
ArcPosition: req.ArcPosition,
|
|
Commendation: req.Commendation,
|
|
Reprimand: req.Reprimand,
|
|
BlueTrack: req.BlueTrack,
|
|
YellowTrack: req.YellowTrack,
|
|
RedTrack: req.RedTrack,
|
|
}
|
|
|
|
_, err = dao.RoleCards.Ctx(ctx).Data(data).Where(dao.RoleCards.Columns().Id, req.Id).Update()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "更新角色失败")
|
|
}
|
|
|
|
res = &v1.RoleUpdateRes{
|
|
Id: req.Id,
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// RoleView 查看角色详情
|
|
func (s *sUser) RoleView(ctx context.Context, req *v1.RoleViewReq) (res *v1.RoleViewRes, err error) {
|
|
// 查询角色详情
|
|
var role entity.RoleCards
|
|
err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.Id).Scan(&role)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "查询角色详情失败")
|
|
}
|
|
|
|
res = &v1.RoleViewRes{
|
|
RoleViewParams: v1.RoleViewParams{
|
|
Id: role.Id,
|
|
UserId: role.UserId,
|
|
DepartmentId: role.DepartmentId,
|
|
Commendation: role.Commendation,
|
|
Reprimand: role.Reprimand,
|
|
BlueTrack: role.BlueTrack,
|
|
YellowTrack: role.YellowTrack,
|
|
RedTrack: role.RedTrack,
|
|
ArcAbnormal: role.ArcAbnormal,
|
|
ArcReality: role.ArcReality,
|
|
ArcPosition: role.ArcPosition,
|
|
AgentName: role.AgentName,
|
|
CodeName: role.CodeName,
|
|
Gender: role.Gender,
|
|
QaMeticulous: role.QaMeticulous,
|
|
QaDeception: role.QaDeception,
|
|
QaVigor: role.QaVigor,
|
|
QaEmpathy: role.QaEmpathy,
|
|
QaInitiative: role.QaInitiative,
|
|
QaResilience: role.QaResilience,
|
|
QaPresence: role.QaPresence,
|
|
QaProfessional: role.QaProfessional,
|
|
QaDiscretion: role.QaDiscretion,
|
|
},
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// RoleList 获取角色列表
|
|
func (s *sUser) RoleList(ctx context.Context, req *v1.RoleListReq) (res *v1.RoleListRes, err error) {
|
|
// 创建数据库查询模型
|
|
m := dao.RoleCards.Ctx(ctx)
|
|
|
|
// 根据用户ID查询
|
|
if req.UserId != 0 {
|
|
m = m.Where(dao.RoleCards.Columns().UserId, req.UserId)
|
|
}
|
|
|
|
// 根据部门ID查询
|
|
if req.DepartmentId != 0 {
|
|
m = m.Where(dao.RoleCards.Columns().DepartmentId, req.DepartmentId)
|
|
}
|
|
|
|
// 查询总数
|
|
total, err := m.Count()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 分页处理
|
|
m = m.Page(req.Page, req.PageSize)
|
|
|
|
// 查询列表数据
|
|
var roles []*entity.RoleCards
|
|
err = m.Scan(&roles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 转换为视图参数
|
|
roleViewList := make([]*v1.RoleViewParams, 0, len(roles))
|
|
for _, role := range roles {
|
|
roleViewList = append(roleViewList, &v1.RoleViewParams{
|
|
Id: role.Id,
|
|
UserId: role.UserId,
|
|
DepartmentId: role.DepartmentId,
|
|
Commendation: role.Commendation,
|
|
Reprimand: role.Reprimand,
|
|
BlueTrack: role.BlueTrack,
|
|
YellowTrack: role.YellowTrack,
|
|
RedTrack: role.RedTrack,
|
|
ArcAbnormal: role.ArcAbnormal,
|
|
ArcReality: role.ArcReality,
|
|
ArcPosition: role.ArcPosition,
|
|
AgentName: role.AgentName,
|
|
CodeName: role.CodeName,
|
|
Gender: role.Gender,
|
|
QaMeticulous: role.QaMeticulous,
|
|
QaDeception: role.QaDeception,
|
|
QaVigor: role.QaVigor,
|
|
QaEmpathy: role.QaEmpathy,
|
|
QaInitiative: role.QaInitiative,
|
|
QaResilience: role.QaResilience,
|
|
QaPresence: role.QaPresence,
|
|
QaProfessional: role.QaProfessional,
|
|
QaDiscretion: role.QaDiscretion,
|
|
})
|
|
}
|
|
|
|
res = &v1.RoleListRes{
|
|
List: roleViewList,
|
|
PageResult: req.PageResult, // 设置分页信息
|
|
}
|
|
|
|
// 设置分页信息
|
|
req.PageResult.Total = int(total)
|
|
req.PageResult.Page = req.Page
|
|
req.PageResult.PageSize = req.PageSize
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// RoleDelete 删除角色
|
|
func (s *sUser) RoleDelete(ctx context.Context, req *v1.RoleDeleteReq) (res *v1.RoleDeleteRes, err error) {
|
|
// 根据ID删除角色
|
|
_, err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.Id).Delete()
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "删除角色失败")
|
|
}
|
|
|
|
res = &v1.RoleDeleteRes{
|
|
Id: req.Id,
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// RolePermissionCheck 权限查询
|
|
func (s *sUser) RolePermissionCheck(ctx context.Context, req *v1.RolePermissionCheckReq) (res *v1.RolePermissionCheckRes, err error) {
|
|
// 查询角色信息
|
|
var role entity.RoleCards
|
|
err = dao.RoleCards.Ctx(ctx).Where(dao.RoleCards.Columns().Id, req.RoleId).Scan(&role)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "查询角色信息失败")
|
|
}
|
|
|
|
// 根据轨道类型获取对应的轨道值
|
|
var trackValue uint
|
|
switch req.TrackType {
|
|
case "blue":
|
|
trackValue = role.BlueTrack
|
|
case "yellow":
|
|
trackValue = role.YellowTrack
|
|
case "red":
|
|
trackValue = role.RedTrack
|
|
default:
|
|
return nil, gerror.NewCode(gcode.CodeInvalidParameter, "无效的轨道类型")
|
|
}
|
|
|
|
// 判断权限：如果角色的轨道值 >= 文件需要的值，则权限验证通过
|
|
if trackValue >= req.FileValue {
|
|
// 权限验证通过
|
|
res = &v1.RolePermissionCheckRes{
|
|
Code: 333,
|
|
Mes: "权限验证通过",
|
|
}
|
|
return
|
|
}
|
|
|
|
// 权限不足，返回错误
|
|
res = &v1.RolePermissionCheckRes{
|
|
Code: 403,
|
|
Mes: "权限不足",
|
|
}
|
|
return res, nil
|
|
}
|