perms-system-server/internal/model/userrole/sysUserRoleModel.go

package userrole

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

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

var _ SysUserRoleModel = (*customSysUserRoleModel)(nil)

type (
	SysUserRoleModel interface {
		sysUserRoleModel
		FindRoleIdsByUserId(ctx context.Context, userId int64) ([]int64, error)
		FindRoleIdsByUserIdForProduct(ctx context.Context, userId int64, productCode string) ([]int64, error)
		FindUserIdsByRoleId(ctx context.Context, roleId int64) ([]int64, error)
		DeleteByRoleIdTx(ctx context.Context, session sqlx.Session, roleId int64) error
		DeleteByUserIdForProductTx(ctx context.Context, session sqlx.Session, userId int64, productCode string) error
		DeleteByUserIdAndRoleIdsTx(ctx context.Context, session sqlx.Session, userId int64, roleIds []int64) error
	}

	customSysUserRoleModel struct {
		*defaultSysUserRoleModel
	}
)

func NewSysUserRoleModel(conn sqlx.SqlConn, c cache.CacheConf, cachePrefix string, opts ...cache.Option) SysUserRoleModel {
	return &customSysUserRoleModel{
		defaultSysUserRoleModel: newSysUserRoleModel(conn, c, cachePrefix, opts...),
	}
}

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

func (m *customSysUserRoleModel) FindRoleIdsByUserIdForProduct(ctx context.Context, userId int64, productCode string) ([]int64, error) {
	var ids []int64
	query := fmt.Sprintf("SELECT ur.`roleId` FROM %s ur INNER JOIN `sys_role` r ON ur.`roleId` = r.`id` WHERE ur.`userId` = ? AND r.`productCode` = ? AND r.`status` = 1", m.table)
	if err := m.QueryRowsNoCacheCtx(ctx, &ids, query, userId, productCode); err != nil {
		return nil, err
	}
	return ids, nil
}

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

func (m *customSysUserRoleModel) buildCacheKeys(list []*SysUserRole) []string {
	keys := make([]string, 0, len(list)*2)
	for _, data := range list {
		keys = append(keys,
			fmt.Sprintf("%s%v", cacheSysUserRoleIdPrefix, data.Id),
			fmt.Sprintf("%s%v:%v", cacheSysUserRoleUserIdRoleIdPrefix, data.UserId, data.RoleId),
		)
	}
	return keys
}

func (m *customSysUserRoleModel) DeleteByRoleIdTx(ctx context.Context, session sqlx.Session, roleId int64) error {
	var list []*SysUserRole
	findQuery := fmt.Sprintf("SELECT %s FROM %s WHERE `roleId` = ?", sysUserRoleRows, m.table)
	if err := m.QueryRowsNoCacheCtx(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 *customSysUserRoleModel) DeleteByUserIdForProductTx(ctx context.Context, session sqlx.Session, userId int64, productCode string) error {
	var list []*SysUserRole
	findQuery := fmt.Sprintf("SELECT %s FROM %s WHERE `userId` = ? AND `roleId` IN (SELECT `id` FROM `sys_role` WHERE `productCode` = ?)", sysUserRoleRows, m.table)
	if err := m.QueryRowsNoCacheCtx(ctx, &list, findQuery, userId, productCode); 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 `userId` = ? AND `roleId` IN (SELECT `id` FROM `sys_role` WHERE `productCode` = ?)", m.table)
		return session.ExecCtx(ctx, query, userId, productCode)
	}, keys...)
	return err
}

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

	var list []*SysUserRole
	findQuery := fmt.Sprintf("SELECT %s FROM %s WHERE `userId` = ? AND `roleId` IN (%s)", sysUserRoleRows, m.table, inClause)
	if err := m.QueryRowsNoCacheCtx(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 `userId` = ? AND `roleId` IN (%s)", m.table, inClause)
		return session.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}