blog-server/internal/db/sqlc/sys_roles.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: sys_roles.sql

package sqlc

import (
	"context"
)

const countSysRoles = `-- name: CountSysRoles :one
SELECT COUNT(*)
FROM sys_roles
`

func (q *Queries) CountSysRoles(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, countSysRoles)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createSysRole = `-- name: CreateSysRole :exec
INSERT INTO sys_roles (name, code, status)
VALUES ($1, $2, $3)
`

type CreateSysRoleParams struct {
	Name   string `json:"name"`
	Code   string `json:"code"`
	Status int16  `json:"status"`
}

func (q *Queries) CreateSysRole(ctx context.Context, arg CreateSysRoleParams) error {
	_, err := q.db.Exec(ctx, createSysRole, arg.Name, arg.Code, arg.Status)
	return err
}

type CreateSysRolePermissionParams struct {
	RoleID       int32 `json:"role_id"`
	PermissionID int32 `json:"permission_id"`
}

const deleteSysRole = `-- name: DeleteSysRole :execrows
DELETE
FROM sys_roles
WHERE id = $1
`

func (q *Queries) DeleteSysRole(ctx context.Context, id int32) (int64, error) {
	result, err := q.db.Exec(ctx, deleteSysRole, id)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const deleteSysRolePermissionByPermissionID = `-- name: DeleteSysRolePermissionByPermissionID :exec
DELETE
FROM sys_role_permission
WHERE permission_id = $1
`

func (q *Queries) DeleteSysRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
	_, err := q.db.Exec(ctx, deleteSysRolePermissionByPermissionID, permissionID)
	return err
}

const deleteSysRolePermissionByRoleID = `-- name: DeleteSysRolePermissionByRoleID :exec
DELETE
FROM sys_role_permission
WHERE role_id = $1
`

func (q *Queries) DeleteSysRolePermissionByRoleID(ctx context.Context, roleID int32) error {
	_, err := q.db.Exec(ctx, deleteSysRolePermissionByRoleID, roleID)
	return err
}

const deleteSysRolePermissionByType = `-- name: DeleteSysRolePermissionByType :exec
DELETE
FROM sys_role_permission rp USING sys_permissions p
WHERE rp.permission_id = p.id
  AND rp.role_id = $1
  AND p."type" = $2
`

type DeleteSysRolePermissionByTypeParams struct {
	RoleID int32 `json:"role_id"`
	Type   int16 `json:"type"`
}

func (q *Queries) DeleteSysRolePermissionByType(ctx context.Context, arg DeleteSysRolePermissionByTypeParams) error {
	_, err := q.db.Exec(ctx, deleteSysRolePermissionByType, arg.RoleID, arg.Type)
	return err
}

const deleteSysUserRoleByRoleID = `-- name: DeleteSysUserRoleByRoleID :exec
DELETE
FROM sys_user_role
WHERE role_id = $1
`

func (q *Queries) DeleteSysUserRoleByRoleID(ctx context.Context, roleID int32) error {
	_, err := q.db.Exec(ctx, deleteSysUserRoleByRoleID, roleID)
	return err
}

const existsSysRoleCode = `-- name: ExistsSysRoleCode :one
SELECT EXISTS(SELECT 1
              FROM sys_roles
              WHERE code = $1
                AND (
                  $2::integer IS NULL
                      OR id <> $2::integer
                  ))
`

type ExistsSysRoleCodeParams struct {
	Code string `json:"code"`
	ID   *int32 `json:"id"`
}

func (q *Queries) ExistsSysRoleCode(ctx context.Context, arg ExistsSysRoleCodeParams) (bool, error) {
	row := q.db.QueryRow(ctx, existsSysRoleCode, arg.Code, arg.ID)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const getAllSysRoles = `-- name: GetAllSysRoles :many
SELECT id, name, code, status, created_at, updated_at
from sys_roles
`

func (q *Queries) GetAllSysRoles(ctx context.Context) ([]SysRole, error) {
	rows, err := q.db.Query(ctx, getAllSysRoles)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SysRole{}
	for rows.Next() {
		var i SysRole
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Code,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSysPermissionIdsByApiIDs = `-- name: GetSysPermissionIdsByApiIDs :many
SELECT permission_id
FROM sys_api_permission
WHERE api_id = ANY ($1::int[])
`

func (q *Queries) GetSysPermissionIdsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
	rows, err := q.db.Query(ctx, getSysPermissionIdsByApiIDs, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []int32{}
	for rows.Next() {
		var permission_id int32
		if err := rows.Scan(&permission_id); err != nil {
			return nil, err
		}
		items = append(items, permission_id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSysPermissionIdsByMenuIDs = `-- name: GetSysPermissionIdsByMenuIDs :many
SELECT permission_id
FROM sys_menu_permission
WHERE menu_id = ANY ($1::int[])
`

func (q *Queries) GetSysPermissionIdsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
	rows, err := q.db.Query(ctx, getSysPermissionIdsByMenuIDs, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []int32{}
	for rows.Next() {
		var permission_id int32
		if err := rows.Scan(&permission_id); err != nil {
			return nil, err
		}
		items = append(items, permission_id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSysRoleApis = `-- name: GetSysRoleApis :many
SELECT a.id, a."name"
FROM sys_role_permission rp
         JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
         JOIN sys_apis a ON a.id = ap.api_id
WHERE rp.role_id = $1
`

type GetSysRoleApisRow struct {
	ID   int32  `json:"id"`
	Name string `json:"name"`
}

func (q *Queries) GetSysRoleApis(ctx context.Context, roleID int32) ([]GetSysRoleApisRow, error) {
	rows, err := q.db.Query(ctx, getSysRoleApis, roleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetSysRoleApisRow{}
	for rows.Next() {
		var i GetSysRoleApisRow
		if err := rows.Scan(&i.ID, &i.Name); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSysRoleByID = `-- name: GetSysRoleByID :one
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
WHERE id = $1
`

func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error) {
	row := q.db.QueryRow(ctx, getSysRoleByID, id)
	var i SysRole
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Code,
		&i.Status,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getSysRoleMenus = `-- name: GetSysRoleMenus :many
SELECT m.id, m.name
FROM sys_role_permission rp
         JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
         JOIN sys_menus m ON m.id = mp.menu_id
WHERE rp.role_id = $1
`

type GetSysRoleMenusRow struct {
	ID   int32  `json:"id"`
	Name string `json:"name"`
}

func (q *Queries) GetSysRoleMenus(ctx context.Context, roleID int32) ([]GetSysRoleMenusRow, error) {
	rows, err := q.db.Query(ctx, getSysRoleMenus, roleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetSysRoleMenusRow{}
	for rows.Next() {
		var i GetSysRoleMenusRow
		if err := rows.Scan(&i.ID, &i.Name); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSysRoles = `-- name: ListSysRoles :many
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
ORDER BY id
LIMIT $1 OFFSET $2
`

type ListSysRolesParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]SysRole, error) {
	rows, err := q.db.Query(ctx, listSysRoles, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SysRole{}
	for rows.Next() {
		var i SysRole
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Code,
			&i.Status,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateSysRole = `-- name: UpdateSysRole :execrows
UPDATE sys_roles
SET name   = coalesce($1, name),
    status = coalesce($2, status)
WHERE id = $3
`

type UpdateSysRoleParams struct {
	Name   *string `json:"name"`
	Status *int16  `json:"status"`
	ID     int32   `json:"id"`
}

func (q *Queries) UpdateSysRole(ctx context.Context, arg UpdateSysRoleParams) (int64, error) {
	result, err := q.db.Exec(ctx, updateSysRole, arg.Name, arg.Status, arg.ID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}