nl-video-api/internal/dao/role.go

package dao

import (
	"context"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"nl-video-api/internal/model/entity"
)

// RoleDao 角色数据访问对象
type RoleDao struct{}

// TableName 获取表名
func (dao *RoleDao) TableName() string {
	return "nl_role"
}

// Create 创建角色
func (dao *RoleDao) Create(ctx context.Context, data *entity.Role) (int, error) {
	result, err := g.DB().Model(dao.TableName()).Ctx(ctx).Data(data).Insert()
	if err != nil {
		return 0, err
	}

	id, err := result.LastInsertId()
	if err != nil {
		return 0, err
	}

	return int(id), nil
}

// GetById 根据ID获取角色
func (dao *RoleDao) GetById(ctx context.Context, id int) (*entity.Role, error) {
	var role *entity.Role
	err := g.DB().Model(dao.TableName()).Ctx(ctx).Where("id = ? AND deleted_at = 0", id).Scan(&role)
	if err != nil {
		return nil, err
	}
	return role, nil
}

// GetByCode 根据角色编码获取角色
func (dao *RoleDao) GetByCode(ctx context.Context, code string) (*entity.Role, error) {
	var role *entity.Role
	err := g.DB().Model(dao.TableName()).Ctx(ctx).Where("code = ? AND deleted_at = 0", code).Scan(&role)
	if err != nil {
		return nil, err
	}
	return role, nil
}

// Update 更新角色
func (dao *RoleDao) Update(ctx context.Context, id int, data g.Map) error {
	data["updated_at"] = gtime.Now().Unix()
	_, err := g.DB().Model(dao.TableName()).Ctx(ctx).Where("id = ?", id).Data(data).Update()
	return err
}

// Delete 删除角色（软删除）
func (dao *RoleDao) Delete(ctx context.Context, id int) error {
	data := g.Map{
		"deleted_at": gtime.Now().Unix(),
		"updated_at": gtime.Now().Unix(),
	}
	_, err := g.DB().Model(dao.TableName()).Ctx(ctx).Where("id = ?", id).Data(data).Update()
	return err
}

// GetList 获取角色列表
func (dao *RoleDao) GetList(ctx context.Context, req *RoleListReq) ([]*entity.Role, int, error) {
	model := g.DB().Model(dao.TableName()).Ctx(ctx).Where("deleted_at = 0")

	// 条件筛选
	if req.Name != "" {
		model = model.WhereLike("name", "%"+req.Name+"%")
	}
	if req.Code != "" {
		model = model.WhereLike("code", "%"+req.Code+"%")
	}
	if req.Status >= 0 {
		model = model.Where("status = ?", req.Status)
	}
	if req.Level > 0 {
		model = model.Where("level = ?", req.Level)
	}

	// 获取总数
	total, err := model.Count()
	if err != nil {
		return nil, 0, err
	}

	// 分页和排序
	if req.Page > 0 && req.PageSize > 0 {
		offset := (req.Page - 1) * req.PageSize
		model = model.Limit(req.PageSize).Offset(offset)
	}

	model = model.OrderDesc("sort").OrderDesc("id")

	var roles []*entity.Role
	err = model.Scan(&roles)
	if err != nil {
		return nil, 0, err
	}

	return roles, total, nil
}

// GetAll 获取所有角色
func (dao *RoleDao) GetAll(ctx context.Context) ([]*entity.Role, error) {
	var roles []*entity.Role
	err := g.DB().Model(dao.TableName()).Ctx(ctx).
		Where("deleted_at = 0 AND status = 1").
		OrderDesc("sort").OrderDesc("id").
		Scan(&roles)
	return roles, err
}

// CheckCodeExists 检查角色编码是否存在
func (dao *RoleDao) CheckCodeExists(ctx context.Context, code string, excludeId int) (bool, error) {
	model := g.DB().Model(dao.TableName()).Ctx(ctx).Where("code = ? AND deleted_at = 0", code)
	if excludeId > 0 {
		model = model.Where("id != ?", excludeId)
	}

	count, err := model.Count()
	if err != nil {
		return false, err
	}

	return count > 0, nil
}

// GetRolesByIds 根据ID列表获取角色
func (dao *RoleDao) GetRolesByIds(ctx context.Context, ids []int) ([]*entity.Role, error) {
	if len(ids) == 0 {
		return []*entity.Role{}, nil
	}

	var roles []*entity.Role
	err := g.DB().Model(dao.TableName()).Ctx(ctx).
		Where("id IN (?) AND deleted_at = 0", ids).
		OrderDesc("sort").OrderDesc("id").
		Scan(&roles)
	return roles, err
}

// GetRolePermissions 获取角色的权限列表
func (dao *RoleDao) GetRolePermissions(ctx context.Context, roleId int) ([]*entity.Permission, error) {
	var permissions []*entity.Permission
	err := g.DB().Model("nl_permission p").Ctx(ctx).
		LeftJoin("nl_role_permission rp", "p.id = rp.permission_id").
		Where("rp.role_id = ? AND p.deleted_at = 0 AND p.status = 1", roleId).
		OrderAsc("p.sort").OrderAsc("p.id").
		Scan(&permissions)
	return permissions, err
}

// AssignPermissions 为角色分配权限
func (dao *RoleDao) AssignPermissions(ctx context.Context, roleId int, permissionIds []int) error {
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		// 先删除原有权限
		_, err := tx.Model("nl_role_permission").Ctx(ctx).Where("role_id = ?", roleId).Delete()
		if err != nil {
			return err
		}

		// 添加新权限
		if len(permissionIds) > 0 {
			data := make([]g.Map, 0, len(permissionIds))
			for _, permissionId := range permissionIds {
				data = append(data, g.Map{
					"role_id":       roleId,
					"permission_id": permissionId,
					"created_at":    gtime.Now().Unix(),
				})
			}
			_, err = tx.Model("nl_role_permission").Ctx(ctx).Data(data).Insert()
			if err != nil {
				return err
			}
		}

		return nil
	})
}

// RoleListReq 角色列表请求参数
type RoleListReq struct {
	Page     int    `json:"page" v:"min:1#页码最小为1"`
	PageSize int    `json:"page_size" v:"min:1,max:100#每页数量范围1-100"`
	Name     string `json:"name"`   // 角色名称
	Code     string `json:"code"`   // 角色编码
	Status   int    `json:"status"` // 状态：-1-全部，0-禁用，1-启用
	Level    int    `json:"level"`  // 角色等级
}