opms_backend/opms_admin/app/handler/user.go

package handler

import (
	"context"
	"dashoo.cn/opms_libary/myerrors"
	"strings"

	"github.com/gogf/gf/util/gvalid"

	"dashoo.cn/micro/app/model"
	"dashoo.cn/micro/app/service"

	"dashoo.cn/common_definition/comm_def"

	"github.com/gogf/gf/frame/g"
)

type UserHandler struct{}

// GetList 获取用户列表
func (h *UserHandler) GetList(ctx context.Context, req *model.SysUserSearchReq, rsp *comm_def.CommonMsg) error {
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}

	total, list, err := userService.GetUserList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list, "total": total}
	return nil
}

// Create 添加用户
func (h *UserHandler) Create(ctx context.Context, req *model.AddUserReq, rsp *comm_def.CommonMsg) error {
	// 参数校验
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return err
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		g.Log().Error(err)
		return err
	}
	err = userService.CreateUser(req)
	if err != nil {
		return err
	}
	return nil
}

// UpdateById 更新用户
func (h *UserHandler) UpdateById(ctx context.Context, req *model.EditUserReq, rsp *comm_def.CommonMsg) error {
	// 参数校验
	if req.Id == 0 {
		return myerrors.TipsError("请求参数不存在。")
	}
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return err
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		g.Log().Error(err)
		return err
	}
	err = userService.UpdateUser(req)
	if err != nil {
		return err
	}
	return nil
}

// GetUserInfo 获取用户实体信息
func (h *UserHandler) GetUserInfo(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	// 从上下文中获取用户
	userId := userService.GetCxtUserId()
	if req.Id != 0 {
		userId = int(req.Id)
	}

	data, err := userService.GetUserInfoById(userId)
	if err != nil {
		return err
	}
	// 获取用户权限 角色
	userRoles, err := userService.GetUserRoleIds(userId)
	if err != nil {
		return err
	}
	roleService, _ := service.NewRoleService(ctx)
	roleKeys, err := roleService.GetRoleKeys(userRoles)
	if err != nil {
		return err
	}
	permissions, err := roleService.GetRolesMenuPermissions(userRoles)
	if err != nil {
		return err
	}

	userPosts, err := userService.GetUserPostIds(userId)
	if err != nil {
		return err
	}
	postService, _ := service.NewPostService(ctx)
	postNames, err := postService.GetEntityNameByIds(userPosts)
	if err != nil {
		return err
	}
	data.PostName = strings.Join(postNames, ",")

	userGroups, err := userService.GetUserGroupIds(userId)
	if err != nil {
		return err
	}

	rsp.Data = g.Map{
		"entity":      data,
		"permissions": permissions,
		"roleKeys":    roleKeys,
		"roleIds":     userRoles,
		"postIds":     userPosts,
		"groupIds":    userGroups,
	}
	return nil
}

// GetEntityByUuId 根据UUID获取用户实体信息
//func (e *UserHandler) GetEntityByUuId(ctx context.Context, req *user_def.UuIdReq, rsp *comm_def.CommonMsg) error {
//	// 参数校验
//	if req.Uuid == "" {
//		return myerrors.TipsError("请求参数不存在。")
//	}
//	userService, err := service.NewUserService(ctx)
//	if err != nil {
//		return err
//	}
//	data, err := userService.GetEntityByUuId(req.Uuid)
//	if err != nil {
//		return err
//	}
//	rsp.Data = data
//	return nil
//}

// DeleteByIds 删除 支持批量删除
func (h *UserHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
	// 参数校验
	if len(req.Ids) == 0 {
		return myerrors.TipsError("请求参数不存在。")
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}

	err = userService.DeleteUserByIds(ctx, req.Ids)
	if err != nil {
		return err
	}
	return nil
}

// ResetPassword 密码重置（管理员进行操作）
func (h *UserHandler) ResetPassword(ctx context.Context, req *model.SysResetPwdReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return err
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	err = userService.ResetUserPwd(req)
	if err != nil {
		return err
	}
	return nil
}

// SetStatus 设置用户状态
func (h *UserHandler) SetStatus(ctx context.Context, req *model.SysUserStatusReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return err
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	err = userService.ChangeUserStatus(req)
	if err != nil {
		return err
	}
	return nil
}

// GetDataScope 获取某用户数据集合权限，返回Ids(用户Id列表)，返回-1表示无角色，返回-2表示有全部集合权限
func (h *RoleHandler) GetDataScope(ctx context.Context, nullParams interface{}, rsp *comm_def.CommonMsg) error {
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	ids, err := userService.GetDataScope(userService.GetCxtUserId())
	if err != nil {
		return err
	}
	rsp.Data = ids
	return err
}

// GetUserByDept 获取部门下所属用户
func (h *UserHandler) GetUserByDept(ctx context.Context, req *model.DeptIdReq, rsp *comm_def.CommonMsg) error {
	// 参数校验
	if req.DeptId == 0 {
		return myerrors.TipsError("请求参数不存在。")
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	var list interface{}
	if req.Include {
		req := &model.SysUserSearchReq{DeptId: req.DeptId}
		req.PageSize = 1000
		_, list, err = userService.GetUsersByDeptEx(req)
	} else {
		list, err = userService.GetUserByDept(req.DeptId)
	}
	if err != nil {
		return err
	}
	rsp.Data = list
	return nil
}

// GetUserByRole 获取角色关联用户
func (h *UserHandler) GetUserByRole(ctx context.Context, req *model.SysUserRoleReq, rsp *comm_def.CommonMsg) error {
	// 参数校验
	if req.RoleId == 0 {
		return myerrors.TipsError("请求参数不存在。")
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}

	list, err := userService.GetUserByRole(req.RoleId)
	if err != nil {
		return err
	}
	rsp.Data = list
	return nil
}

//// GetDictList 获取用户列表字典项（返回字典数据形式，一般用来绑定用户的下拉列表）
//func (e *UserHandler) GetDictList(ctx context.Context, req *user_def.DictSelectReq, rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.GetDictList request @ " + tenant)
//
//	service, err := user.NewService(tenant)
//	if flag, err, _, _ := myerrors.CheckError(err); flag {
//		return err
//	}
//
//	list, err := service.GetDict(req)
//	_, err, code, msg := myerrors.CheckError(err)
//	if err != nil {
//		return err
//	}
//	rsp.Code = code
//	rsp.Msg = msg
//	rsp.Data = list
//	return nil
//}
//
//// GetUsersDictByDepartment 获取当前部门下用户信息列表（返回字典数据形式，一般用来绑定用户的下拉列表）
//func (e *UserHandler) GetUsersDictByDepartment(ctx context.Context, req *user_def.DeptIdReq,
//	rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.GetUsersDictByDepartment request @ " + tenant)
//	service, err := user.NewService(tenant)
//	if err != nil {
//		g.Log().Error(err)
//		return myerrors.TipsError("系统异常，请重新尝试")
//	}
//	list, err := service.GetUsersDictByDepartment(req.DeptId)
//	_, err, code, msg := myerrors.CheckError(err)
//	if err != nil {
//		return err
//	}
//	rsp.Code = code
//	rsp.Msg = msg
//	rsp.Data = list
//	return nil
//}
//
//// GetProfile 获取用户信息
//func (e *UserHandler) GetProfile(ctx context.Context, numParams interface{}, rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.GetProfile request @ " + tenant)
//
//	service, err := user.NewService(tenant)
//	if flag, err, _, _ := myerrors.CheckError(err); flag {
//		return err
//	}
//	userInfo, err := micro_srv.GetUserInfo(ctx)
//	if err != nil {
//		return err
//	}
//	profile, err := service.GetProfile(int64(userInfo.Id))
//	_, err, code, msg := myerrors.CheckError(err)
//	if err != nil {
//		return err
//	}
//	rsp.Code = code
//	rsp.Msg = msg
//	rsp.Data = profile
//	return nil
//}
//
//// UpdateProfile 更新Profile
//func (e *UserHandler) UpdateProfile(ctx context.Context, req *user_def.EditProfileEntity, rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.UpdateProfile request @ " + tenant)
//	if req.Id == 0 {
//		return NoParamsErr
//	}
//	validErr := gvalid.CheckStruct(ctx, req, nil)
//	if validErr != nil {
//		return validErr.Current()
//	}
//	service, err := user.NewService(tenant)
//	if flag, err, _, _ := myerrors.CheckError(err); flag {
//		return err
//	}
//	userInfo, err := micro_srv.GetUserInfo(ctx)
//	if err != nil {
//		return err
//	}
//	err = service.UpdateProfile(&userInfo, req)
//	_, err, code, msg := myerrors.CheckError(err)
//	if err != nil {
//		return err
//	}
//	rsp.Code = code
//	rsp.Msg = msg
//	return nil
//}
//
//// SetAvatar 设置用户头像
//func (e *UserHandler) SetAvatar(ctx context.Context, req *user_def.AvatarReq, rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.SetAvatar request @ " + tenant)
//	if req.FileUrl == "" {
//		return NoParamsErr
//	}
//	service, err := user.NewService(tenant)
//	if err != nil {
//		g.Log().Error(err)
//		return myerrors.TipsError("系统异常，请重新尝试")
//	}
//	userInfo, err := micro_srv.GetUserInfo(ctx)
//	if err != nil {
//		return err
//	}
//	err = service.SetAvatar(&userInfo, req.FileUrl)
//	_, err, code, msg := myerrors.CheckError(err)
//	if err != nil {
//		return err
//	}
//	rsp.Code = code
//	rsp.Msg = msg
//	return nil
//}

// ChangePassword 用户修改密码
func (h *UserHandler) ChangePassword(ctx context.Context, req *model.SysUserResetPwdReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return err
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	err = userService.ProfileUpdatePwd(&model.ProfileUpdatePwdReq{
		UserId:      userService.GetCxtUserId(),
		OldPassword: req.OldPassword,
		NewPassword: req.NewPassword,
	})
	return err
}

//// GetUserByUserName 根据用户名获取用户信息
//func (e *UserHandler) GetUserByUserName(ctx context.Context, req *user_def.UserNameReq, rsp *comm_def.CommonMsg) error {
//	// 获取租户码
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	g.Log().Info("Received UserHandler.GetUserByUserName request @ " + tenant)
//	if req.UserName == "" {
//
//	}
//	service, err := user.NewService(tenant)
//	if err != nil {
//		g.Log().Error(err)
//		return myerrors.TipsError("系统异常，请重新尝试")
//	}
//
//	userEntity, err := service.GetUserByUserName(req.UserName)
//	_, err, code, msg := myerrors.CheckError(err)
//	rsp.Code = code
//	rsp.Msg = msg
//	rsp.Data = userEntity
//	return nil
//}
//
//func (e *UserHandler) SendResetPasswordEmail(ctx context.Context, req *user_def.UserNameReq, rsp *comm_def.CommonMsg) error {
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	service, err := user.NewService(tenant)
//	if err != nil {
//		g.Log().Error(err)
//		return myerrors.TipsError("系统异常，请重新尝试")
//	}
//	email, expired, err := service.SendResetPasswordEmail(req)
//	_, err, code, msg := myerrors.CheckError(err)
//	rsp.Code = code
//	rsp.Msg = msg
//	if err == nil {
//		rsp.Data = map[string]interface{}{
//			"email":   email,
//			"expired": expired,
//		}
//	}
//	return nil
//}
//
//func (e *UserHandler) ResetPasswordFromEmail(ctx context.Context, req *user.ResetPasswordFromEmailReq, rsp *comm_def.CommonMsg) error {
//	tenant, err := micro_srv.GetTenant(ctx)
//	if err != nil {
//		return err
//	}
//	service, err := user.NewService(tenant)
//	if err != nil {
//		g.Log().Error(err)
//		return myerrors.TipsError("系统异常，请重新尝试")
//	}
//	err = service.ResetPasswordFromEmail(ctx, req)
//	_, err, code, msg := myerrors.CheckError(err)
//	rsp.Code = code
//	rsp.Msg = msg
//	return nil
//}