yunzer_go/server/controllers/role.go

package controllers

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

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

type RoleController struct {
	web.Controller
}

// GetAllRoles 获取所有角色
// 根据当前登录用户的 tenant_id 和 userType 过滤角色
// @router /api/roles [get]
func (c *RoleController) GetAllRoles() {
	// 从JWT中获取租户ID和用户类型
	tenantIdData := c.Ctx.Input.GetData("tenantId")
	userTypeData := c.Ctx.Input.GetData("userType")

	tenantId := 0
	if tenantIdData != nil {
		if tid, ok := tenantIdData.(int); ok {
			tenantId = tid
		}
	}

	// 如果请求参数中有 tenant_id，优先使用请求参数
	if requestTenantId, err := c.GetInt("tenant_id"); err == nil && requestTenantId > 0 {
		tenantId = requestTenantId
	}

	userType := "user" // 默认为平台用户
	if userTypeData != nil {
		if ut, ok := userTypeData.(string); ok {
			userType = ut
		}
	}

	roles, err := models.GetAllRoles(tenantId, userType)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	roleList := make([]map[string]interface{}, 0)
	for _, role := range roles {
		roleList = append(roleList, map[string]interface{}{
			"roleId":      role.RoleId,
			"tenantId":    role.TenantId,
			"default":     role.Default,
			"roleCode":    role.RoleCode,
			"roleName":    role.RoleName,
			"description": role.Description,
			"status":      role.Status,
			"sortOrder":   role.SortOrder,
			"createTime":  role.CreateTime,
			"updateTime":  role.UpdateTime,
			"createBy":    role.CreateBy,
			"updateBy":    role.UpdateBy,
		})
	}

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

// GetRoleById 根据ID获取角色详情
// @router /api/roles/:id [get]
func (c *RoleController) GetRoleById() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	role, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色详情失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 确保 menuIds 是数组，即使为空
	menuIds := role.MenuIds
	if menuIds == nil {
		menuIds = []int{}
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "获取角色详情成功",
		"data": map[string]interface{}{
			"roleId":      role.RoleId,
			"tenantId":    role.TenantId,
			"roleCode":    role.RoleCode,
			"roleName":    role.RoleName,
			"description": role.Description,
			"menuIds":     menuIds,
			"status":      role.Status,
			"sortOrder":   role.SortOrder,
			"createTime":  role.CreateTime,
			"updateTime":  role.UpdateTime,
			"createBy":    role.CreateBy,
			"updateBy":    role.UpdateBy,
		},
	}
	c.ServeJSON()
}

// 根据租户ID获取角色列表
// @router /api/roles/tenant/:tenantId [get]
func (c *RoleController) GetRoleByTenantId() {
	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
	}
	roles, err := models.GetRoleByTenantId(tenantId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取角色列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 获取当前登录用户类型（从JWT中间件获取）
	userType, _ := c.Ctx.Input.GetData("userType").(string)
	isEmployee := userType == "employee"

	// 转换为前端需要的格式，确保包含 tenantId 和 default 字段
	// 如果是租户登录（employee），过滤掉 default=1 的角色
	roleList := make([]map[string]interface{}, 0)
	for _, role := range roles {
		// 如果是租户登录，且角色的 default=1，则跳过（不显示）
		if isEmployee && role.Default == 1 {
			continue
		}

		roleList = append(roleList, map[string]interface{}{
			"roleId":      role.RoleId,
			"tenantId":    role.TenantId,
			"default":     role.Default,
			"roleCode":    role.RoleCode,
			"roleName":    role.RoleName,
			"description": role.Description,
			"status":      role.Status,
			"sortOrder":   role.SortOrder,
			"createTime":  role.CreateTime,
			"updateTime":  role.UpdateTime,
			"createBy":    role.CreateBy,
			"updateBy":    role.UpdateBy,
		})
	}

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

// CreateRole 创建角色
// @router /api/roles [post]
func (c *RoleController) CreateRole() {
	var role models.Role
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &role); err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "参数解析失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if role.RoleCode == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色代码不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	if role.RoleName == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色名称不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 如果请求中没有 tenant_id，从JWT中获取
	if role.TenantId == 0 {
		if tenantIdData := c.Ctx.Input.GetData("tenantId"); tenantIdData != nil {
			if tid, ok := tenantIdData.(int); ok && tid > 0 {
				role.TenantId = tid
			}
		}
	}

	// 获取当前用户名（用于记录创建操作）
	if username, ok := c.Ctx.Input.GetData("username").(string); ok && username != "" {
		role.CreateBy = username
		role.UpdateBy = username
	}

	// 检查角色代码是否已存在
	existingRole, err := models.GetRoleByCode(role.RoleCode)
	if err == nil && existingRole != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色代码已存在",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 设置默认值
	if role.Status == 0 {
		role.Status = 1
	}

	err = models.CreateRole(&role)
	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{}{
			"roleId": role.RoleId,
		},
	}
	c.ServeJSON()
}

// UpdateRole 更新角色
// @router /api/roles/:id [put]
func (c *RoleController) UpdateRole() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 检查角色是否存在
	existingRole, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色不存在: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	var role models.Role
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &role); err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "参数解析失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 如果更新了角色代码，检查是否重复
	if role.RoleCode != "" && role.RoleCode != existingRole.RoleCode {
		codeRole, err := models.GetRoleByCode(role.RoleCode)
		if err == nil && codeRole != nil && codeRole.RoleId != roleId {
			c.Data["json"] = map[string]interface{}{
				"code":    1,
				"message": "角色代码已存在",
				"data":    nil,
			}
			c.ServeJSON()
			return
		}
	}

	// 设置角色ID
	role.RoleId = roleId

	// 如果请求中没有 tenant_id，从JWT中获取
	if role.TenantId == 0 {
		if tenantIdData := c.Ctx.Input.GetData("tenantId"); tenantIdData != nil {
			if tid, ok := tenantIdData.(int); ok && tid > 0 {
				role.TenantId = tid
			}
		}
	}

	// 获取当前用户名（用于记录更新操作）
	if username, ok := c.Ctx.Input.GetData("username").(string); ok && username != "" {
		role.UpdateBy = username
	}

	err = models.UpdateRole(&role)
	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":    nil,
	}
	c.ServeJSON()
}

// DeleteRole 删除角色（软删除）
// @router /api/roles/:id [delete]
func (c *RoleController) DeleteRole() {
	roleId, err := c.GetInt(":id")
	if err != nil || roleId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色ID无效",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 检查是否为系统默认角色，不允许删除
	role, err := models.GetRoleById(roleId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "角色不存在: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 系统默认角色不允许删除
	if role.RoleCode == "system_admin" || role.RoleCode == "admin" || role.RoleCode == "user" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "系统默认角色不允许删除",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 获取当前用户名（用于记录删除操作）
	updateBy := "system"
	if username, ok := c.Ctx.Input.GetData("username").(string); ok && username != "" {
		updateBy = username
	}

	err = models.DeleteRole(roleId, updateBy)
	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":    nil,
	}
	c.ServeJSON()
}