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 countRoles = `-- name: CountRoles :one
SELECT COUNT(*)
FROM sys_roles
`

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

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

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

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

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

const deleteRole = `-- name: DeleteRole :execrows
DELETE
FROM sys_roles
WHERE id = $1
`

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

const deleteRolePermissionByPermissionID = `-- name: DeleteRolePermissionByPermissionID :exec
DELETE
FROM sys_role_permission
WHERE permission_id = $1
`

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

const deleteRolePermissionsByRoleID = `-- name: DeleteRolePermissionsByRoleID :exec
DELETE
FROM sys_role_permission
WHERE role_id = $1
`

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

const deleteRolePermissionsByType = `-- name: DeleteRolePermissionsByType :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 DeleteRolePermissionsByTypeParams struct {
	RoleID int32 `json:"role_id"`
	Type   int16 `json:"type"`
}

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

const deleteUserRoleByRoleID = `-- name: DeleteUserRoleByRoleID :exec
DELETE
FROM sys_user_role
WHERE role_id = $1
`

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

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

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

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

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

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

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

func (q *Queries) ListAllRoles(ctx context.Context) ([]SysRole, error) {
	rows, err := q.db.Query(ctx, listAllRoles)
	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 listPermissionIDsByApiIDs = `-- name: ListPermissionIDsByApiIDs :many
SELECT permission_id
FROM sys_api_permission
WHERE api_id = ANY ($1::int[])
`

func (q *Queries) ListPermissionIDsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
	rows, err := q.db.Query(ctx, listPermissionIDsByApiIDs, 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 listPermissionIDsByMenuIDs = `-- name: ListPermissionIDsByMenuIDs :many
SELECT permission_id
FROM sys_menu_permission
WHERE menu_id = ANY ($1::int[])
`

func (q *Queries) ListPermissionIDsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
	rows, err := q.db.Query(ctx, listPermissionIDsByMenuIDs, 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 listRoleApis = `-- name: ListRoleApis :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 ListRoleApisRow struct {
	ID   int32  `json:"id"`
	Name string `json:"name"`
}

func (q *Queries) ListRoleApis(ctx context.Context, roleID int32) ([]ListRoleApisRow, error) {
	rows, err := q.db.Query(ctx, listRoleApis, roleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListRoleApisRow{}
	for rows.Next() {
		var i ListRoleApisRow
		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 listRoleMenus = `-- name: ListRoleMenus :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 ListRoleMenusRow struct {
	ID   int32  `json:"id"`
	Name string `json:"name"`
}

func (q *Queries) ListRoleMenus(ctx context.Context, roleID int32) ([]ListRoleMenusRow, error) {
	rows, err := q.db.Query(ctx, listRoleMenus, roleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListRoleMenusRow{}
	for rows.Next() {
		var i ListRoleMenusRow
		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 listRoles = `-- name: ListRoles :many
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
ORDER BY id
LIMIT $1 OFFSET $2
`

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

func (q *Queries) ListRoles(ctx context.Context, arg ListRolesParams) ([]SysRole, error) {
	rows, err := q.db.Query(ctx, listRoles, 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 updateRole = `-- name: UpdateRole :execrows
UPDATE sys_roles
SET name   = coalesce($1, name),
    status = coalesce($2, status)
WHERE id = $3
`

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

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