yunzer_go/server/controllers/user.go

package controllers

import (
	"encoding/json"
	"server/models"

	"github.com/beego/beego/v2/server/web"
)

type UserController struct {
	web.Controller
}

// GetAllUsers 获取所有用户
func (c *UserController) GetAllUsers() {
	tenantId, _ := c.GetInt("tenant_id", 0)
	users := models.GetAllUsers(tenantId)

	userList := make([]map[string]interface{}, 0)
	for _, user := range users {
		userList = append(userList, map[string]interface{}{
			"id":            user.Id,
			"username":      user.Username,
			"email":         user.Email,
			"avatar":        user.Avatar,
			"nickname":      user.Nickname,
			"tenant_id":     user.TenantId,
			"status":        user.Status,
			"role":          user.Role,
			"lastLoginTime": user.LastLoginTime,
		})
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取用户列表成功",
		"data":    userList,
	}
	c.ServeJSON()
}

// GetTenantUsers 获取指定租户下的所有用户（排除已删除的用户）
func (c *UserController) GetTenantUsers() {
	// 从URL参数获取租户ID
	tenantId, err := c.GetInt(":tenantId")
	if err != nil || tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法查询
	users, err := models.GetTenantUsers(tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 格式化返回数据
	userList := make([]map[string]interface{}, 0)
	for _, user := range users {
		userList = append(userList, map[string]interface{}{
			"id":              user.Id,
			"username":        user.Username,
			"email":           user.Email,
			"avatar":          user.Avatar,
			"nickname":        user.Nickname,
			"tenant_id":       user.TenantId,
			"status":          user.Status,
			"role":            user.Role,
			"department_id":   user.DepartmentId,
			"position_id":     user.PositionId,
			"last_login_time": user.LastLoginTime,
			"last_login_ip":   user.LastLoginIp,
		})
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取租户用户列表成功",
		"data":    userList,
	}
	c.ServeJSON()
}

// ChangePassword 修改用户密码
func (c *UserController) ChangePassword() {
	// 从URL获取用户ID
	userId, err := c.GetInt(":id")
	if err != nil || userId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var changeData struct {
		OldPassword string `json:"oldPassword"`
		NewPassword string `json:"newPassword"`
	}
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &changeData)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 校验参数
	if changeData.OldPassword == "" || changeData.NewPassword == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "旧密码和新密码不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 先获取用户信息
	user, err := models.GetUserInfo(userId, "", 0)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型方法修改密码
	err = models.ChangePassword(user.Username, changeData.OldPassword, changeData.NewPassword, user.TenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "密码修改成功",
			"data":    nil,
		}
	}
	c.ServeJSON()
}

// GetUserInfo 通过ID查询用户信息
func (c *UserController) GetUserInfo() {
	// 从URL获取用户ID
	userId, err := c.GetInt(":id")
	if err != nil || userId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法根据ID查询
	user, err := models.GetUserInfo(userId, "", 0)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "查询成功",
		"data": map[string]interface{}{
			"id":        user.Id,
			"username":  user.Username,
			"email":     user.Email,
			"avatar":    user.Avatar,
			"nickname":  user.Nickname,
			"tenant_id": user.TenantId,
			"role":      user.Role,
			"status":    user.Status,
		},
	}
	c.ServeJSON()
}

// AddUser 添加新用户
func (c *UserController) AddUser() {
	// 定义接收用户数据的结构体
	var userData struct {
		Username     string `json:"username"`
		Password     string `json:"password"`
		Email        string `json:"email"`
		Nickname     string `json:"nickname"`
		Avatar       string `json:"avatar"`
		TenantId     int    `json:"tenant_id"`
		Role         int    `json:"role"` // 角色ID
		DepartmentId int    `json:"department_id"`
		PositionId   int    `json:"position_id"`
	}

	// 解析请求体JSON数据
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &userData)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 校验必要参数
	if userData.Username == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户名不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if userData.Password == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "密码不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}
	if userData.TenantId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "租户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法添加用户（传递参数，接收新用户对象）
	newUser, err := models.AddUser(
		userData.Username,
		userData.Password,
		userData.Email,
		userData.Nickname,
		userData.Avatar,
		userData.TenantId,
		userData.Role,
		userData.DepartmentId,
		userData.PositionId,
	)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "添加用户失败: " + err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户添加成功",
			"data": map[string]interface{}{
				"id":        newUser.Id,
				"username":  newUser.Username,
				"email":     newUser.Email,
				"nickname":  newUser.Nickname,
				"avatar":    newUser.Avatar,
				"tenant_id": newUser.TenantId,
			},
		}
	}
	c.ServeJSON()
}

// EditUser 更新用户信息
func (c *UserController) EditUser() {
	// 定义接收更新数据的结构体
	var updateData struct {
		Id           int    `json:"id"`
		Username     string `json:"username"`
		Email        string `json:"email"`
		Nickname     string `json:"nickname"`
		Avatar       string `json:"avatar"`
		Status       string `json:"status"`
		Role         int    `json:"role"` // 角色ID
		DepartmentId int    `json:"department_id"`
		PositionId   int    `json:"position_id"`
	}

	// 解析请求体JSON
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &updateData)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 校验必要参数
	if updateData.Id == 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "用户ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法更新用户
	_, err = models.EditUser(
		updateData.Id,
		updateData.Username,
		updateData.Email,
		updateData.Nickname,
		updateData.Avatar,
		updateData.Status,
		updateData.Role,
		updateData.DepartmentId,
		updateData.PositionId,
	)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "更新用户失败: " + err.Error(),
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户更新成功",
		}
	}
	c.ServeJSON()
}

// DeleteUser 删除用户
func (c *UserController) DeleteUser() {
	// 从URL获取用户ID
	userId, err := c.GetInt(":id")
	if err != nil || userId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "无效的用户ID",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 先查询用户信息，检查是否为admin账号
	user, err := models.GetUserInfo(userId, "", 0)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "查询用户失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 禁止删除admin账号
	if user.Username == "admin" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "admin账号不允许删除",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 调用模型层方法删除用户
	err = models.DeleteUser(userId)

	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "删除用户失败: " + err.Error(),
			"data":    nil,
		}
	} else {
		c.Data["json"] = map[string]interface{}{
			"code":    0,
			"message": "用户删除成功",
			"data":    nil,
		}
	}
	c.ServeJSON()
}

// ResetPassword 重置用户密码（支持租户模式）
func (c *UserController) ResetPassword() {
	// 获取请求参数
	username := c.GetString("username")
	superPassword := c.GetString("superPassword")
	tenantId, _ := c.GetInt("tenant_id", 0)

	// 如果URL参数中没有租户ID，尝试从JSON请求体获取
	if tenantId == 0 {
		var resetData struct {
			Username      string `json:"username"`
			SuperPassword string `json:"superPassword"`
			TenantId      int    `json:"tenant_id"`
		}
		if err := json.Unmarshal(c.Ctx.Input.RequestBody, &resetData); err == nil {
			username = resetData.Username
			superPassword = resetData.SuperPassword
			tenantId = resetData.TenantId
		}
	}

	if tenantId <= 0 {
		c.Data["json"] = map[string]interface{}{"success": false, "message": "租户ID不能为空"}
		c.ServeJSON()
		return
	}

	// 调用模型方法
	err := models.ResetPassword(username, superPassword, tenantId)

	if err != nil {
		c.Data["json"] = map[string]interface{}{"success": false, "message": err.Error()}
	} else {
		c.Data["json"] = map[string]interface{}{"success": true, "message": "密码重置成功"}
	}

	c.ServeJSON()
}