perms-system-server/internal/model/roleperm/sysRolePermModel.go

package roleperm

import (
	"context"
	"database/sql"
	"fmt"
	"strings"

	"github.com/zeromicro/go-zero/core/stores/cache"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

var _ SysRolePermModel = (*customSysRolePermModel)(nil)

type (
	SysRolePermModel interface {
		sysRolePermModel
		FindPermIdsByRoleId(ctx context.Context, roleId int64) ([]int64, error)
		FindPermIdsByRoleIds(ctx context.Context, roleIds []int64) ([]int64, error)
		DeleteByRoleIdTx(ctx context.Context, session sqlx.Session, roleId int64) error
		DeleteByRoleIdAndPermIdsTx(ctx context.Context, session sqlx.Session, roleId int64, permIds []int64) error
	}

	customSysRolePermModel struct {
		*defaultSysRolePermModel
	}
)

func NewSysRolePermModel(conn sqlx.SqlConn, c cache.CacheConf, cachePrefix string, opts ...cache.Option) SysRolePermModel {
	return &customSysRolePermModel{
		defaultSysRolePermModel: newSysRolePermModel(conn, c, cachePrefix, opts...),
	}
}

func (m *customSysRolePermModel) FindPermIdsByRoleId(ctx context.Context, roleId int64) ([]int64, error) {
	var ids []int64
	query := fmt.Sprintf("SELECT `permId` FROM %s WHERE `roleId` = ?", m.table)
	if err := m.QueryRowsNoCacheCtx(ctx, &ids, query, roleId); err != nil {
		return nil, err
	}
	return ids, nil
}

func (m *customSysRolePermModel) FindPermIdsByRoleIds(ctx context.Context, roleIds []int64) ([]int64, error) {
	if len(roleIds) == 0 {
		return nil, nil
	}
	placeholders := make([]string, len(roleIds))
	args := make([]interface{}, len(roleIds))
	for i, id := range roleIds {
		placeholders[i] = "?"
		args[i] = id
	}
	var ids []int64
	query := fmt.Sprintf("SELECT DISTINCT `permId` FROM %s WHERE `roleId` IN (%s)", m.table, strings.Join(placeholders, ","))
	if err := m.QueryRowsNoCacheCtx(ctx, &ids, query, args...); err != nil {
		return nil, err
	}
	return ids, nil
}

func (m *customSysRolePermModel) buildCacheKeys(list []*SysRolePerm) []string {
	keys := make([]string, 0, len(list)*2)
	for _, data := range list {
		keys = append(keys,
			fmt.Sprintf("%s%v", cacheSysRolePermIdPrefix, data.Id),
			fmt.Sprintf("%s%v:%v", cacheSysRolePermRoleIdPermIdPrefix, data.RoleId, data.PermId),
		)
	}
	return keys
}

func (m *customSysRolePermModel) DeleteByRoleIdTx(ctx context.Context, session sqlx.Session, roleId int64) error {
	var list []*SysRolePerm
	findQuery := fmt.Sprintf("SELECT %s FROM %s WHERE `roleId` = ? FOR UPDATE", sysRolePermRows, m.table)
	if err := session.QueryRowsCtx(ctx, &list, findQuery, roleId); err != nil {
		return err
	}
	if len(list) == 0 {
		return nil
	}
	keys := m.buildCacheKeys(list)
	_, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (sql.Result, error) {
		query := fmt.Sprintf("DELETE FROM %s WHERE `roleId` = ?", m.table)
		return session.ExecCtx(ctx, query, roleId)
	}, keys...)
	return err
}

func (m *customSysRolePermModel) DeleteByRoleIdAndPermIdsTx(ctx context.Context, session sqlx.Session, roleId int64, permIds []int64) error {
	if len(permIds) == 0 {
		return nil
	}
	placeholders := make([]string, len(permIds))
	args := make([]interface{}, 0, len(permIds)+1)
	args = append(args, roleId)
	for i, id := range permIds {
		placeholders[i] = "?"
		args = append(args, id)
	}
	inClause := strings.Join(placeholders, ",")

	var list []*SysRolePerm
	findQuery := fmt.Sprintf("SELECT %s FROM %s WHERE `roleId` = ? AND `permId` IN (%s) FOR UPDATE", sysRolePermRows, m.table, inClause)
	if err := session.QueryRowsCtx(ctx, &list, findQuery, args...); err != nil {
		return err
	}
	if len(list) == 0 {
		return nil
	}
	keys := m.buildCacheKeys(list)
	_, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (sql.Result, error) {
		query := fmt.Sprintf("DELETE FROM %s WHERE `roleId` = ? AND `permId` IN (%s)", m.table, inClause)
		return session.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}