511 lines
12 KiB
Go
511 lines
12 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: sys_users.sql
|
|
|
|
package sqlc
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
)
|
|
|
|
const clearUserRoles = `-- name: ClearUserRoles :exec
|
|
DELETE
|
|
FROM sys_user_role
|
|
WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) ClearUserRoles(ctx context.Context, userID int32) error {
|
|
_, err := q.db.Exec(ctx, clearUserRoles, userID)
|
|
return err
|
|
}
|
|
|
|
const countUsers = `-- name: CountUsers :one
|
|
SELECT COUNT(*)
|
|
FROM sys_users
|
|
WHERE ($1::text = '' OR username ILIKE '%' || $1 || '%')
|
|
`
|
|
|
|
func (q *Queries) CountUsers(ctx context.Context, username string) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countUsers, username)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createUser = `-- name: CreateUser :exec
|
|
INSERT INTO sys_users (account, username, password_hash, status, avatar_id)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
`
|
|
|
|
type CreateUserParams struct {
|
|
Account string `json:"account"`
|
|
Username string `json:"username"`
|
|
PasswordHash string `json:"password_hash"`
|
|
Status int16 `json:"status"`
|
|
AvatarID *int32 `json:"avatar_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) error {
|
|
_, err := q.db.Exec(ctx, createUser,
|
|
arg.Account,
|
|
arg.Username,
|
|
arg.PasswordHash,
|
|
arg.Status,
|
|
arg.AvatarID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
type CreateUserRoleParams struct {
|
|
UserID int32 `json:"user_id"`
|
|
RoleID int32 `json:"role_id"`
|
|
}
|
|
|
|
const deleteUser = `-- name: DeleteUser :execrows
|
|
DELETE
|
|
FROM sys_users
|
|
WHERE id = $1
|
|
AND id <> 1
|
|
`
|
|
|
|
func (q *Queries) DeleteUser(ctx context.Context, id int32) (int64, error) {
|
|
result, err := q.db.Exec(ctx, deleteUser, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const getUser = `-- name: GetUser :one
|
|
SELECT u.id,
|
|
u.account,
|
|
u.username,
|
|
u.password_hash,
|
|
u.status,
|
|
u.avatar_id,
|
|
f.file_url AS avatar_url,
|
|
u.token_version,
|
|
u.created_at,
|
|
u.updated_at
|
|
FROM sys_users u
|
|
LEFT JOIN files f ON u.avatar_id = f.id
|
|
WHERE u.id = $1
|
|
OR u.account = $2
|
|
`
|
|
|
|
type GetUserParams struct {
|
|
ID int32 `json:"id"`
|
|
Account string `json:"account"`
|
|
}
|
|
|
|
type GetUserRow struct {
|
|
ID int32 `json:"id"`
|
|
Account string `json:"account"`
|
|
Username string `json:"username"`
|
|
PasswordHash string `json:"password_hash"`
|
|
Status int16 `json:"status"`
|
|
AvatarID *int32 `json:"avatar_id"`
|
|
AvatarUrl *string `json:"avatar_url"`
|
|
TokenVersion int32 `json:"token_version"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UpdatedAt *time.Time `json:"updated_at"`
|
|
}
|
|
|
|
func (q *Queries) GetUser(ctx context.Context, arg GetUserParams) (GetUserRow, error) {
|
|
row := q.db.QueryRow(ctx, getUser, arg.ID, arg.Account)
|
|
var i GetUserRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Account,
|
|
&i.Username,
|
|
&i.PasswordHash,
|
|
&i.Status,
|
|
&i.AvatarID,
|
|
&i.AvatarUrl,
|
|
&i.TokenVersion,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserAuthState = `-- name: GetUserAuthState :one
|
|
SELECT status,
|
|
token_version
|
|
FROM sys_users
|
|
WHERE id = $1
|
|
`
|
|
|
|
type GetUserAuthStateRow struct {
|
|
Status int16 `json:"status"`
|
|
TokenVersion int32 `json:"token_version"`
|
|
}
|
|
|
|
func (q *Queries) GetUserAuthState(ctx context.Context, id int32) (GetUserAuthStateRow, error) {
|
|
row := q.db.QueryRow(ctx, getUserAuthState, id)
|
|
var i GetUserAuthStateRow
|
|
err := row.Scan(&i.Status, &i.TokenVersion)
|
|
return i, err
|
|
}
|
|
|
|
const incrementTokenVersionForAllUsers = `-- name: IncrementTokenVersionForAllUsers :exec
|
|
UPDATE sys_users
|
|
SET token_version = token_version + 1
|
|
`
|
|
|
|
func (q *Queries) IncrementTokenVersionForAllUsers(ctx context.Context) error {
|
|
_, err := q.db.Exec(ctx, incrementTokenVersionForAllUsers)
|
|
return err
|
|
}
|
|
|
|
const incrementUserTokenVersion = `-- name: IncrementUserTokenVersion :exec
|
|
UPDATE sys_users
|
|
SET token_version = token_version + 1
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) IncrementUserTokenVersion(ctx context.Context, id int32) error {
|
|
_, err := q.db.Exec(ctx, incrementUserTokenVersion, id)
|
|
return err
|
|
}
|
|
|
|
const listAdminMenus = `-- name: ListAdminMenus :many
|
|
SELECT id, name, path, component, type, hidden, sort, status, parent_id, icon, created_at, updated_at
|
|
FROM sys_menus
|
|
WHERE status = 1
|
|
AND type <> 2
|
|
ORDER BY sort, id
|
|
`
|
|
|
|
func (q *Queries) ListAdminMenus(ctx context.Context) ([]SysMenu, error) {
|
|
rows, err := q.db.Query(ctx, listAdminMenus)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []SysMenu{}
|
|
for rows.Next() {
|
|
var i SysMenu
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Path,
|
|
&i.Component,
|
|
&i.Type,
|
|
&i.Hidden,
|
|
&i.Sort,
|
|
&i.Status,
|
|
&i.ParentID,
|
|
&i.Icon,
|
|
&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 listAdminPermissionCodes = `-- name: ListAdminPermissionCodes :many
|
|
SELECT code
|
|
FROM sys_permissions
|
|
WHERE type = 0
|
|
`
|
|
|
|
func (q *Queries) ListAdminPermissionCodes(ctx context.Context) ([]*string, error) {
|
|
rows, err := q.db.Query(ctx, listAdminPermissionCodes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []*string{}
|
|
for rows.Next() {
|
|
var code *string
|
|
if err := rows.Scan(&code); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, code)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listUserApis = `-- name: ListUserApis :many
|
|
SELECT DISTINCT a.id,
|
|
a.PATH,
|
|
a.METHOD
|
|
FROM sys_users u
|
|
JOIN sys_user_role ur ON u.id = ur.user_id
|
|
JOIN sys_roles r ON r.id = ur.role_id
|
|
JOIN sys_role_permission rp ON rp.role_id = r.id
|
|
JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
|
|
JOIN sys_apis a ON a.id = ap.api_id
|
|
WHERE u.id = $1
|
|
AND u.status = 1
|
|
AND r.status = 1
|
|
`
|
|
|
|
type ListUserApisRow struct {
|
|
ID int32 `json:"id"`
|
|
Path string `json:"path"`
|
|
Method string `json:"method"`
|
|
}
|
|
|
|
func (q *Queries) ListUserApis(ctx context.Context, id int32) ([]ListUserApisRow, error) {
|
|
rows, err := q.db.Query(ctx, listUserApis, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListUserApisRow{}
|
|
for rows.Next() {
|
|
var i ListUserApisRow
|
|
if err := rows.Scan(&i.ID, &i.Path, &i.Method); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listUserMenus = `-- name: ListUserMenus :many
|
|
SELECT DISTINCT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at
|
|
FROM sys_users u
|
|
JOIN sys_user_role ur ON ur.user_id = u.id
|
|
JOIN sys_roles r ON r.id = ur.role_id
|
|
JOIN sys_role_permission rp ON rp.role_id = r.id
|
|
JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
|
|
JOIN sys_menus m ON m.id = mp.menu_id
|
|
WHERE u.id = $1
|
|
AND u.status = 1
|
|
AND r.status = 1
|
|
AND m.status = 1
|
|
AND m.type <> 2
|
|
ORDER BY m.sort, m.id
|
|
`
|
|
|
|
func (q *Queries) ListUserMenus(ctx context.Context, id int32) ([]SysMenu, error) {
|
|
rows, err := q.db.Query(ctx, listUserMenus, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []SysMenu{}
|
|
for rows.Next() {
|
|
var i SysMenu
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Path,
|
|
&i.Component,
|
|
&i.Type,
|
|
&i.Hidden,
|
|
&i.Sort,
|
|
&i.Status,
|
|
&i.ParentID,
|
|
&i.Icon,
|
|
&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 listUserPermissionCodes = `-- name: ListUserPermissionCodes :many
|
|
SELECT DISTINCT p.code
|
|
FROM sys_users u
|
|
JOIN sys_user_role ur ON u.id = ur.user_id
|
|
JOIN sys_roles r on r.id = ur.role_id
|
|
JOIN sys_role_permission rp ON rp.role_id = r.id
|
|
JOIN sys_permissions p ON p.id = rp.permission_id
|
|
JOIN sys_menu_permission mp ON mp.permission_id = p.id
|
|
JOIN sys_menus m ON m.id = mp.menu_id
|
|
WHERE u.id = $1
|
|
AND u.status = 1
|
|
AND r.status = 1
|
|
AND m.status = 1
|
|
AND p."type" = 0
|
|
`
|
|
|
|
func (q *Queries) ListUserPermissionCodes(ctx context.Context, id int32) ([]*string, error) {
|
|
rows, err := q.db.Query(ctx, listUserPermissionCodes, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []*string{}
|
|
for rows.Next() {
|
|
var code *string
|
|
if err := rows.Scan(&code); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, code)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listUserRoles = `-- name: ListUserRoles :many
|
|
SELECT r.id, r.name, r.code, r.status, r.created_at, r.updated_at
|
|
FROM sys_roles r
|
|
JOIN sys_user_role ur ON r.id = ur.role_id
|
|
WHERE ur.user_id = $1
|
|
`
|
|
|
|
func (q *Queries) ListUserRoles(ctx context.Context, userID int32) ([]SysRole, error) {
|
|
rows, err := q.db.Query(ctx, listUserRoles, userID)
|
|
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 listUsers = `-- name: ListUsers :many
|
|
SELECT u.id,
|
|
u.account,
|
|
u.username,
|
|
u.status,
|
|
u.avatar_id,
|
|
f.file_url AS avatar_url,
|
|
u.created_at,
|
|
u.updated_at
|
|
FROM sys_users u
|
|
LEFT JOIN files f ON u.avatar_id = f.id
|
|
WHERE ($3::text = '' OR u.username ILIKE '%' || $3 || '%')
|
|
ORDER BY u.id
|
|
LIMIT $1 OFFSET $2
|
|
`
|
|
|
|
type ListUsersParams struct {
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
Username string `json:"username"`
|
|
}
|
|
|
|
type ListUsersRow struct {
|
|
ID int32 `json:"id"`
|
|
Account string `json:"account"`
|
|
Username string `json:"username"`
|
|
Status int16 `json:"status"`
|
|
AvatarID *int32 `json:"avatar_id"`
|
|
AvatarUrl *string `json:"avatar_url"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UpdatedAt *time.Time `json:"updated_at"`
|
|
}
|
|
|
|
func (q *Queries) ListUsers(ctx context.Context, arg ListUsersParams) ([]ListUsersRow, error) {
|
|
rows, err := q.db.Query(ctx, listUsers, arg.Limit, arg.Offset, arg.Username)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListUsersRow{}
|
|
for rows.Next() {
|
|
var i ListUsersRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Account,
|
|
&i.Username,
|
|
&i.Status,
|
|
&i.AvatarID,
|
|
&i.AvatarUrl,
|
|
&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 updateUser = `-- name: UpdateUser :execrows
|
|
UPDATE sys_users
|
|
SET username = coalesce($1, username),
|
|
status = coalesce($2, status),
|
|
avatar_id = CASE WHEN $3::boolean THEN $4 ELSE avatar_id END
|
|
WHERE id = $5
|
|
`
|
|
|
|
type UpdateUserParams struct {
|
|
Username *string `json:"username"`
|
|
Status *int16 `json:"status"`
|
|
UpdateAvatarID bool `json:"update_avatar_id"`
|
|
AvatarID *int32 `json:"avatar_id"`
|
|
ID int32 `json:"id"`
|
|
}
|
|
|
|
func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateUser,
|
|
arg.Username,
|
|
arg.Status,
|
|
arg.UpdateAvatarID,
|
|
arg.AvatarID,
|
|
arg.ID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const updateUserPassword = `-- name: UpdateUserPassword :execrows
|
|
UPDATE sys_users
|
|
SET password_hash = $2
|
|
WHERE id = $1
|
|
`
|
|
|
|
type UpdateUserPasswordParams struct {
|
|
ID int32 `json:"id"`
|
|
PasswordHash string `json:"password_hash"`
|
|
}
|
|
|
|
func (q *Queries) UpdateUserPassword(ctx context.Context, arg UpdateUserPasswordParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateUserPassword, arg.ID, arg.PasswordHash)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|