752 lines
17 KiB
Go
752 lines
17 KiB
Go
package controller
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
"knowledge/api/dao"
|
|
"knowledge/api/dto"
|
|
"knowledge/api/model"
|
|
"knowledge/api/requests"
|
|
"knowledge/api/responses"
|
|
"knowledge/api/service"
|
|
"knowledge/config"
|
|
"knowledge/global"
|
|
"knowledge/utils"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type AdminUser struct{}
|
|
|
|
// Login 登陆
|
|
func (r *AdminUser) Login(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.Login
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
// 验证验证码
|
|
if config.C.Env == "prod" {
|
|
isValid := utils.VerifyCaptcha(req.CaptchaId, req.Captcha)
|
|
if !isValid {
|
|
// 验证码错误
|
|
responses.FailWithMessage("验证码错误", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 登陆
|
|
adminUserService := service.AdminUserService{}
|
|
token, err := adminUserService.Login(req)
|
|
if err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
responses.OkWithData(token, c)
|
|
}
|
|
|
|
// GetAdminUserPage 获取列表-分页
|
|
func (r *AdminUser) GetAdminUserPage(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.GetAdminUserPage
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
if req.Page == 0 {
|
|
req.Page = 1
|
|
}
|
|
|
|
if req.PageSize == 0 {
|
|
req.PageSize = 20
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
adminUser, total, err := adminUserDao.GetAdminUserPageSearch(req, req.Page, req.PageSize)
|
|
if err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 处理返回值
|
|
g := dto.GetAdminUserListDto(adminUser)
|
|
|
|
result := make(map[string]interface{})
|
|
result["page"] = req.Page
|
|
result["page_size"] = req.PageSize
|
|
result["total"] = total
|
|
result["data"] = g
|
|
responses.OkWithData(result, c)
|
|
}
|
|
|
|
// GetAdminUser 用户详情
|
|
func (r *AdminUser) GetAdminUser(c *gin.Context) {
|
|
id := c.Param("user_id")
|
|
if id == "" {
|
|
responses.FailWithMessage("缺少参数", c)
|
|
return
|
|
}
|
|
|
|
// 将 id 转换为 int64 类型
|
|
userId, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
// 获取用户详情
|
|
AdminUserDao := dao.AdminUserDao{}
|
|
adminUser, err := AdminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
// 处理返回值
|
|
result := dto.GetAdminUserDto(adminUser)
|
|
|
|
responses.OkWithData(result, c)
|
|
}
|
|
|
|
// AddAdminUser 新增
|
|
func (r *AdminUser) AddAdminUser(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.AddAdminUser
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginAdminUser.IsAdmin == 0 {
|
|
responses.FailWithMessage("非管理员用户不可添加", c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 检测账号名
|
|
maps := make(map[string]interface{})
|
|
maps["access"] = req.Access
|
|
maps["is_deleted"] = 0
|
|
res, _ := adminUserDao.GetAdminUser(maps)
|
|
if res != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("账号名重复", c)
|
|
return
|
|
}
|
|
|
|
// 检测手机号
|
|
maps = make(map[string]interface{})
|
|
maps["phone"] = req.Phone
|
|
maps["is_deleted"] = 0
|
|
res, _ = adminUserDao.GetAdminUser(maps)
|
|
if res != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("手机号重复", c)
|
|
return
|
|
}
|
|
|
|
// 处理密码
|
|
salt := uuid.New().String()
|
|
password := md5.Sum([]byte(req.Password + salt))
|
|
// 将哈希值转换为16进制字符串
|
|
passwordString := hex.EncodeToString(password[:])
|
|
|
|
// 新增用户
|
|
AdminUserModel := &model.AdminUser{
|
|
Access: req.Access,
|
|
Password: passwordString,
|
|
Salt: salt,
|
|
NickName: req.NickName,
|
|
IsAdmin: req.IsAdmin,
|
|
Status: *req.Status,
|
|
IsDeleted: *req.IsDeleted,
|
|
IsDisabled: *req.IsDisabled,
|
|
Phone: req.Phone,
|
|
Avatar: utils.RemoveOssDomain(req.Avatar),
|
|
Sex: req.Sex,
|
|
Email: req.Email,
|
|
}
|
|
|
|
_, err = adminUserDao.AddAdminUser(tx, AdminUserModel)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("新增失败", c)
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// PutAdminUser 修改用户
|
|
func (r *AdminUser) PutAdminUser(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.PutAdminUser
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
id := c.Param("user_id")
|
|
if id == "" {
|
|
responses.FailWithMessage("缺少参数", c)
|
|
return
|
|
}
|
|
|
|
// 将 id 转换为 int64 类型
|
|
userId, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginUserId == userId && req.IsDisabled == 1 {
|
|
responses.FailWithMessage("不可把自己置为禁用", c)
|
|
return
|
|
}
|
|
|
|
if loginUserId == userId && req.IsDeleted == 1 {
|
|
responses.FailWithMessage("不可把自己置为删除", c)
|
|
return
|
|
}
|
|
|
|
if loginUserId != userId && loginAdminUser.IsAdmin != 1 {
|
|
responses.FailWithMessage("非管理员用户只可修改自己数据", c)
|
|
return
|
|
}
|
|
|
|
// 获取需修改用户数据
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil && adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if req.Access != adminUser.Access {
|
|
// 检测账号名
|
|
maps := make(map[string]interface{})
|
|
maps["access"] = req.Access
|
|
maps["is_deleted"] = 0
|
|
res, _ := adminUserDao.GetAdminUser(maps)
|
|
if res != nil {
|
|
responses.FailWithMessage("账号名重复", c)
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
if req.Phone != adminUser.Phone {
|
|
// 检测手机号
|
|
maps := make(map[string]interface{})
|
|
maps["phone"] = req.Phone
|
|
maps["is_deleted"] = 0
|
|
res, _ := adminUserDao.GetAdminUser(maps)
|
|
if res != nil {
|
|
responses.FailWithMessage("手机号重复", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
data := make(map[string]interface{})
|
|
data["access"] = req.Access
|
|
data["is_deleted"] = req.IsDeleted
|
|
data["is_disabled"] = req.IsDisabled
|
|
data["nick_name"] = req.NickName
|
|
data["is_admin"] = req.IsAdmin
|
|
data["phone"] = req.Phone
|
|
data["avatar"] = req.Avatar
|
|
data["sex"] = req.Sex
|
|
data["email"] = req.Email
|
|
err = adminUserDao.EditAdminUserById(tx, userId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("修改失败", c)
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// PutAdminUserStatus 修改状态
|
|
func (r *AdminUser) PutAdminUserStatus(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.PutAdminUserStatus
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
id := c.Param("user_id")
|
|
if id == "" {
|
|
responses.FailWithMessage("缺少参数", c)
|
|
return
|
|
}
|
|
|
|
// 将 id 转换为 int64 类型
|
|
userId, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginUserId == userId {
|
|
responses.FailWithMessage("非法操作，请勿修改自己", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginAdminUser.IsAdmin != 1 {
|
|
responses.FailWithMessage("非管理员用户不可操作", c)
|
|
return
|
|
}
|
|
|
|
// 获取需修改用户数据
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil && adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if adminUser.Status == req.Status {
|
|
responses.Ok(c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
data := make(map[string]interface{})
|
|
data["status"] = req.Status
|
|
err = adminUserDao.EditAdminUserById(tx, userId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("修改失败", c)
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// PutUserDisabled 修改禁用状态
|
|
func (r *AdminUser) PutAdminUserDisabled(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.PutAdminUserDisabled
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
id := c.Param("user_id")
|
|
if id == "" {
|
|
responses.FailWithMessage("缺少参数", c)
|
|
return
|
|
}
|
|
|
|
// 将 id 转换为 int64 类型
|
|
userId, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginUserId == userId {
|
|
responses.FailWithMessage("非法操作，请勿修改自己", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginAdminUser.IsAdmin != 1 {
|
|
responses.FailWithMessage("非管理员用户不可操作", c)
|
|
return
|
|
}
|
|
|
|
// 获取需修改用户数据
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil && adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if adminUser.IsDisabled == req.IsDisabled {
|
|
responses.Ok(c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
data := make(map[string]interface{})
|
|
data["is_disabled"] = req.IsDisabled
|
|
err = adminUserDao.EditAdminUserById(tx, userId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("修改失败", c)
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// PutAdminUserPassword 修改用户密码
|
|
func (r *AdminUser) PutAdminUserPassword(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.PutAdminUserPassword
|
|
if err := c.ShouldBind(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginAdminUser.IsAdmin != 1 {
|
|
responses.FailWithMessage("非管理员用户只可修改自己数据", c)
|
|
return
|
|
}
|
|
|
|
// 获取需修改用户数据
|
|
userId, err := strconv.ParseInt(req.UserId, 10, 64)
|
|
if err != nil {
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
// 加密旧密码
|
|
newPassword := md5.Sum([]byte(req.NewPassword + adminUser.Salt))
|
|
// 将哈希值转换为16进制字符串
|
|
newPasswordString := hex.EncodeToString(newPassword[:])
|
|
|
|
// 检测密码是否相同
|
|
if adminUser.Password == newPasswordString {
|
|
responses.FailWithMessage("新密码请不要和原密码相同", c)
|
|
return
|
|
}
|
|
|
|
// 检测旧密码是否正确
|
|
// 检测用户密码
|
|
password := md5.Sum([]byte(req.Password + adminUser.Salt))
|
|
// 将哈希值转换为16进制字符串
|
|
passwordString := hex.EncodeToString(password[:])
|
|
|
|
if passwordString != adminUser.Password {
|
|
responses.FailWithMessage("原密码错误，请重新输入", c)
|
|
return
|
|
}
|
|
|
|
// 密码校验
|
|
if len(req.NewPassword) < 8 {
|
|
responses.FailWithMessage("密码小于8位数", c)
|
|
return
|
|
}
|
|
|
|
num := `[0-9]{1}`
|
|
a_z := `[a-z]{1}`
|
|
A_Z := `[A-Z]{1}`
|
|
symbol := `[!@#.~$%^&*()+|_]{1}`
|
|
if b, err := regexp.MatchString(num, req.NewPassword); !b || err != nil {
|
|
responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
|
|
return
|
|
}
|
|
if b, err := regexp.MatchString(a_z, req.NewPassword); !b || err != nil {
|
|
responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
|
|
return
|
|
}
|
|
if b, err := regexp.MatchString(A_Z, req.NewPassword); !b || err != nil {
|
|
responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
|
|
return
|
|
}
|
|
if b, err := regexp.MatchString(symbol, req.NewPassword); !b || err != nil {
|
|
responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
data := make(map[string]interface{})
|
|
data["password"] = newPasswordString
|
|
err = adminUserDao.EditAdminUserById(tx, userId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("修改失败", c)
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// LoginOut 退出登陆
|
|
func (b *AdminUser) LoginOut(c *gin.Context) {
|
|
userId := c.GetInt64("UserId")
|
|
if userId == 0 {
|
|
responses.FailWithMessage("用户错误", c)
|
|
return
|
|
}
|
|
|
|
// 获取用户信息
|
|
adminUserDao := dao.AdminUserDao{}
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
// token加入黑名单
|
|
authorization := c.Request.Header.Get("Authorization")
|
|
if authorization == "" || !strings.HasPrefix(authorization, "Bearer ") {
|
|
responses.FailWithMessage("退出登陆失败", c)
|
|
return
|
|
}
|
|
|
|
// 去除Bearer
|
|
authorization = authorization[7:] // 截取字符
|
|
|
|
// 增加缓存
|
|
_, err = global.Redis.Set(c, "jwt_black_"+authorization, time.Now().Unix(), 60*time.Second).Result()
|
|
if err != nil {
|
|
responses.FailWithMessage("退出登陆失败", c)
|
|
return
|
|
}
|
|
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// DeleteAdminUser 删除用户-批量
|
|
func (r *AdminUser) DeleteAdminUser(c *gin.Context) {
|
|
adminUserRequest := requests.AdminUserRequest{}
|
|
req := adminUserRequest.DeleteAdminUser
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 参数验证
|
|
if err := global.Validate.Struct(req); err != nil {
|
|
responses.FailWithMessage(utils.Translate(err), c)
|
|
return
|
|
}
|
|
|
|
// 获取当前登陆用户数据
|
|
loginUserId := c.GetInt64("UserId")
|
|
if loginUserId == 0 {
|
|
responses.FailWithMessage("数据错误", c)
|
|
return
|
|
}
|
|
|
|
adminUserDao := dao.AdminUserDao{}
|
|
loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
|
|
if err != nil && loginAdminUser == nil {
|
|
responses.FailWithMessage("用户数据错误", c)
|
|
return
|
|
}
|
|
|
|
if loginAdminUser.IsAdmin != 1 {
|
|
responses.FailWithMessage("非管理员用户不可操作", c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
for _, id := range req.UserIds {
|
|
userId, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.Fail(c)
|
|
return
|
|
}
|
|
|
|
if userId == loginUserId {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("不可把自己删除", c)
|
|
return
|
|
}
|
|
|
|
// 检测删除用户
|
|
adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
|
|
if err != nil || adminUser == nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("删除失败", c)
|
|
return
|
|
}
|
|
|
|
// 删除用户
|
|
data := make(map[string]interface{})
|
|
data["is_deleted"] = 1
|
|
err = adminUserDao.EditAdminUserById(tx, userId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("修改失败", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
responses.Ok(c)
|
|
}
|