beggin/blog-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 统一sql命名、函数命名

Browse Source
This commit is contained in:
21 Guns
2026-08-02 12:02:04 +08:00
parent d39342ce5f
commit 0e674e9d56
68 changed files with 1985 additions and 1720 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
internal/db/sqlc/copyfrom.go
View File

@@ -42,13 +42,13 @@ func (q *Queries) CreatePostTag(ctx context.Context, arg []CreatePostTagParams)
return q.db.CopyFrom(ctx, []string{"post_tag"}, []string{"post_id", "tag_id"}, &iteratorForCreatePostTag{rows: arg})
}
// iteratorForCreateSysRolePermission implements pgx.CopyFromSource.
type iteratorForCreateSysRolePermission struct {
rows []CreateSysRolePermissionParams
// iteratorForCreateRolePermission implements pgx.CopyFromSource.
type iteratorForCreateRolePermission struct {
rows []CreateRolePermissionParams
skippedFirstNextCall bool
}
func (r *iteratorForCreateSysRolePermission) Next() bool {
func (r *iteratorForCreateRolePermission) Next() bool {
if len(r.rows) == 0 {
return false
}
@@ -60,28 +60,28 @@ func (r *iteratorForCreateSysRolePermission) Next() bool {
return len(r.rows) > 0
}
func (r iteratorForCreateSysRolePermission) Values() ([]interface{}, error) {
func (r iteratorForCreateRolePermission) Values() ([]interface{}, error) {
return []interface{}{
r.rows[0].RoleID,
r.rows[0].PermissionID,
}, nil
}
func (r iteratorForCreateSysRolePermission) Err() error {
func (r iteratorForCreateRolePermission) Err() error {
return nil
}
func (q *Queries) CreateSysRolePermission(ctx context.Context, arg []CreateSysRolePermissionParams) (int64, error) {
return q.db.CopyFrom(ctx, []string{"sys_role_permission"}, []string{"role_id", "permission_id"}, &iteratorForCreateSysRolePermission{rows: arg})
func (q *Queries) CreateRolePermission(ctx context.Context, arg []CreateRolePermissionParams) (int64, error) {
return q.db.CopyFrom(ctx, []string{"sys_role_permission"}, []string{"role_id", "permission_id"}, &iteratorForCreateRolePermission{rows: arg})
}
// iteratorForCreateSysUserRole implements pgx.CopyFromSource.
type iteratorForCreateSysUserRole struct {
rows []CreateSysUserRoleParams
// iteratorForCreateUserRole implements pgx.CopyFromSource.
type iteratorForCreateUserRole struct {
rows []CreateUserRoleParams
skippedFirstNextCall bool
}
func (r *iteratorForCreateSysUserRole) Next() bool {
func (r *iteratorForCreateUserRole) Next() bool {
if len(r.rows) == 0 {
return false
}
@@ -93,17 +93,17 @@ func (r *iteratorForCreateSysUserRole) Next() bool {
return len(r.rows) > 0
}
func (r iteratorForCreateSysUserRole) Values() ([]interface{}, error) {
func (r iteratorForCreateUserRole) Values() ([]interface{}, error) {
return []interface{}{
r.rows[0].UserID,
r.rows[0].RoleID,
}, nil
}
func (r iteratorForCreateSysUserRole) Err() error {
func (r iteratorForCreateUserRole) Err() error {
return nil
}
func (q *Queries) CreateSysUserRole(ctx context.Context, arg []CreateSysUserRoleParams) (int64, error) {
return q.db.CopyFrom(ctx, []string{"sys_user_role"}, []string{"user_id", "role_id"}, &iteratorForCreateSysUserRole{rows: arg})
func (q *Queries) CreateUserRole(ctx context.Context, arg []CreateUserRoleParams) (int64, error) {
return q.db.CopyFrom(ctx, []string{"sys_user_role"}, []string{"user_id", "role_id"}, &iteratorForCreateUserRole{rows: arg})
}

26
internal/db/sqlc/files.sql.go
View File

@@ -22,8 +22,9 @@ func (q *Queries) CountFiles(ctx context.Context) (int64, error) {
}
const createFile = `-- name: CreateFile :one
INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size)
VALUES ($1, $2, $3, $4, $5, $6) RETURNING id,file_path,file_name
INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size, file_url)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id,file_url,file_name
`
type CreateFileParams struct {
@@ -33,11 +34,12 @@ type CreateFileParams struct {
FolderName string `json:"folder_name"`
MimeType string `json:"mime_type"`
FileSize int64 `json:"file_size"`
FileUrl string `json:"file_url"`
}
type CreateFileRow struct {
ID int32 `json:"id"`
FilePath string `json:"file_path"`
FileUrl string `json:"file_url"`
FileName string `json:"file_name"`
}
@@ -49,26 +51,27 @@ func (q *Queries) CreateFile(ctx context.Context, arg CreateFileParams) (CreateF
arg.FolderName,
arg.MimeType,
arg.FileSize,
arg.FileUrl,
)
var i CreateFileRow
err := row.Scan(&i.ID, &i.FilePath, &i.FileName)
err := row.Scan(&i.ID, &i.FileUrl, &i.FileName)
return i, err
}
const getFiles = `-- name: GetFiles :many
SELECT id, file_name, file_path, original_name, folder_name, mime_type, file_size, created_at, updated_at
const listFiles = `-- name: ListFiles :many
SELECT id, file_name, file_path, file_url, original_name, folder_name, mime_type, file_size, created_at, updated_at
FROM files
ORDER BY id LIMIT $1
OFFSET $2
ORDER BY id
LIMIT $1 OFFSET $2
`
type GetFilesParams struct {
type ListFilesParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
func (q *Queries) GetFiles(ctx context.Context, arg GetFilesParams) ([]File, error) {
rows, err := q.db.Query(ctx, getFiles, arg.Limit, arg.Offset)
func (q *Queries) ListFiles(ctx context.Context, arg ListFilesParams) ([]File, error) {
rows, err := q.db.Query(ctx, listFiles, arg.Limit, arg.Offset)
if err != nil {
return nil, err
}
@@ -80,6 +83,7 @@ func (q *Queries) GetFiles(ctx context.Context, arg GetFilesParams) ([]File, err
&i.ID,
&i.FileName,
&i.FilePath,
&i.FileUrl,
&i.OriginalName,
&i.FolderName,
&i.MimeType,

2
internal/db/sqlc/models.go
View File

@@ -29,6 +29,8 @@ type File struct {
FileName string `json:"file_name"`
// 文件路径 带path /xxx/xxx.jpg
FilePath string `json:"file_path"`
// 完整路径
FileUrl string `json:"file_url"`
// 原始文件名
OriginalName string `json:"original_name"`
// 文件夹名称

24
internal/db/sqlc/post.sql.go
View File

@@ -83,9 +83,9 @@ func (q *Queries) DeletePost(ctx context.Context, id int32) (int64, error) {
return result.RowsAffected(), nil
}
const getPostById = `-- name: GetPostById :one
const getPostByID = `-- name: GetPostByID :one
SELECT p.id, p.title, p.cover_id, p.slug, p.content, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
f.file_path AS cover,
f.file_url AS cover,
c.name AS category_name,
c.id AS category_id,
COALESCE(
@@ -99,13 +99,13 @@ FROM posts p
LEFT JOIN post_tag pt ON pt.post_id = p.id
WHERE p.id = $1
GROUP BY p.id,
f.file_path,
f.file_url,
c.name,
c.id
LIMIT 1
`
type GetPostByIdRow struct {
type GetPostByIDRow struct {
ID int32 `json:"id"`
Title string `json:"title"`
CoverID *int32 `json:"cover_id"`
@@ -123,9 +123,9 @@ type GetPostByIdRow struct {
Tags interface{} `json:"tags"`
}
func (q *Queries) GetPostById(ctx context.Context, id int32) (GetPostByIdRow, error) {
row := q.db.QueryRow(ctx, getPostById, id)
var i GetPostByIdRow
func (q *Queries) GetPostByID(ctx context.Context, id int32) (GetPostByIDRow, error) {
row := q.db.QueryRow(ctx, getPostByID, id)
var i GetPostByIDRow
err := row.Scan(
&i.ID,
&i.Title,
@@ -149,7 +149,7 @@ func (q *Queries) GetPostById(ctx context.Context, id int32) (GetPostByIdRow, er
const getPublicPostBySlug = `-- name: GetPublicPostBySlug :one
SELECT p.id, p.title, p.cover_id, p.slug, p.content, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
f.file_path AS cover,
f.file_url AS cover,
COALESCE(ps.view, 0) AS view
FROM posts p
LEFT JOIN files f ON f.id = p.cover_id
@@ -312,7 +312,7 @@ WITH paginated_posts AS (
LIMIT $1 OFFSET $2
)
SELECT p.id, p.title, p.cover_id, p.slug, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
f.file_path AS cover,
f.file_url AS cover,
c.name AS category_name,
c.id AS category_id,
COALESCE(ps.view, 0) AS view,
@@ -344,7 +344,7 @@ GROUP BY p.id,
p.published_at,
p.created_at,
p.updated_at,
f.file_path,
f.file_url,
c.name,
c.id,
ps.view
@@ -427,7 +427,7 @@ WITH paginated_posts AS (
ORDER BY sort DESC, published_at DESC, id DESC
LIMIT $1 OFFSET $2)
SELECT p.id, p.title, p.cover_id, p.slug, p.summary, p.sort, p.published_at,
f.file_path AS cover,
f.file_url AS cover,
c.name AS category_name,
c.id AS category_id,
COALESCE(ps.view, 0) AS view,
@@ -456,7 +456,7 @@ GROUP BY p.id,
p.summary,
p.sort,
p.published_at,
f.file_path,
f.file_url,
c.name,
c.id,
ps.view

121
internal/db/sqlc/sys_apis.sql.go
View File

@@ -9,32 +9,34 @@ import (
"context"
)
const countSysApis = `-- name: CountSysApis :one
const countApis = `-- name: CountApis :one
SELECT COUNT(*)
FROM sys_apis
WHERE ($1::text = '' OR group_name ILIKE '%' || $1 || '%')
AND ($2::text = '' OR method = $2)
WHERE ($1::text = '' OR name ILIKE '%' || $1 || '%')
AND ($2::text = '' OR group_name ILIKE '%' || $2 || '%')
AND ($3::text = '' OR method = $3)
`
type CountSysApisParams struct {
type CountApisParams struct {
Name string `json:"name"`
GroupName string `json:"group_name"`
Method string `json:"method"`
}
func (q *Queries) CountSysApis(ctx context.Context, arg CountSysApisParams) (int64, error) {
row := q.db.QueryRow(ctx, countSysApis, arg.GroupName, arg.Method)
func (q *Queries) CountApis(ctx context.Context, arg CountApisParams) (int64, error) {
row := q.db.QueryRow(ctx, countApis, arg.Name, arg.GroupName, arg.Method)
var count int64
err := row.Scan(&count)
return count, err
}
const createSysApi = `-- name: CreateSysApi :one
const createApi = `-- name: CreateApi :one
INSERT INTO sys_apis (name, group_name, method, path, sort)
VALUES ($1, $2, $3, $4, $5)
RETURNING id
`
type CreateSysApiParams struct {
type CreateApiParams struct {
Name string `json:"name"`
GroupName string `json:"group_name"`
Method string `json:"method"`
@@ -42,8 +44,8 @@ type CreateSysApiParams struct {
Sort *int32 `json:"sort"`
}
func (q *Queries) CreateSysApi(ctx context.Context, arg CreateSysApiParams) (int32, error) {
row := q.db.QueryRow(ctx, createSysApi,
func (q *Queries) CreateApi(ctx context.Context, arg CreateApiParams) (int32, error) {
row := q.db.QueryRow(ctx, createApi,
arg.Name,
arg.GroupName,
arg.Method,
@@ -55,54 +57,76 @@ func (q *Queries) CreateSysApi(ctx context.Context, arg CreateSysApiParams) (int
return id, err
}
const createSysApiPermission = `-- name: CreateSysApiPermission :exec
const createApiPermission = `-- name: CreateApiPermission :exec
INSERT INTO sys_api_permission (api_id, permission_id)
VALUES ($1, $2)
`
type CreateSysApiPermissionParams struct {
type CreateApiPermissionParams struct {
ApiID int32 `json:"api_id"`
PermissionID int32 `json:"permission_id"`
}
func (q *Queries) CreateSysApiPermission(ctx context.Context, arg CreateSysApiPermissionParams) error {
_, err := q.db.Exec(ctx, createSysApiPermission, arg.ApiID, arg.PermissionID)
func (q *Queries) CreateApiPermission(ctx context.Context, arg CreateApiPermissionParams) error {
_, err := q.db.Exec(ctx, createApiPermission, arg.ApiID, arg.PermissionID)
return err
}
const deleteSysApi = `-- name: DeleteSysApi :execrows
const deleteApi = `-- name: DeleteApi :execrows
DELETE
FROM sys_apis
WHERE id = $1
`
func (q *Queries) DeleteSysApi(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteSysApi, id)
func (q *Queries) DeleteApi(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteApi, id)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteSysApiPermission = `-- name: DeleteSysApiPermission :exec
const deleteApiPermission = `-- name: DeleteApiPermission :exec
DELETE
FROM sys_api_permission
WHERE api_id = $1
`
func (q *Queries) DeleteSysApiPermission(ctx context.Context, apiID int32) error {
_, err := q.db.Exec(ctx, deleteSysApiPermission, apiID)
func (q *Queries) DeleteApiPermission(ctx context.Context, apiID int32) error {
_, err := q.db.Exec(ctx, deleteApiPermission, apiID)
return err
}
const getAllSysApis = `-- name: GetAllSysApis :many
const getApiByID = `-- name: GetApiByID :one
SELECT id, group_name, name, method, path, sort, created_at, updated_at
FROM sys_apis
WHERE id = $1
`
func (q *Queries) GetApiByID(ctx context.Context, id int32) (SysApi, error) {
row := q.db.QueryRow(ctx, getApiByID, id)
var i SysApi
err := row.Scan(
&i.ID,
&i.GroupName,
&i.Name,
&i.Method,
&i.Path,
&i.Sort,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const listAllApis = `-- name: ListAllApis :many
SELECT id, group_name, name, method, path, sort, created_at, updated_at
FROM sys_apis
ORDER BY sort ASC
`
func (q *Queries) GetAllSysApis(ctx context.Context) ([]SysApi, error) {
rows, err := q.db.Query(ctx, getAllSysApis)
func (q *Queries) ListAllApis(ctx context.Context) ([]SysApi, error) {
rows, err := q.db.Query(ctx, listAllApis)
if err != nil {
return nil, err
}
@@ -130,35 +154,13 @@ func (q *Queries) GetAllSysApis(ctx context.Context) ([]SysApi, error) {
return items, nil
}
const getSysApiByID = `-- name: GetSysApiByID :one
SELECT id, group_name, name, method, path, sort, created_at, updated_at
FROM sys_apis
WHERE id = $1
`
func (q *Queries) GetSysApiByID(ctx context.Context, id int32) (SysApi, error) {
row := q.db.QueryRow(ctx, getSysApiByID, id)
var i SysApi
err := row.Scan(
&i.ID,
&i.GroupName,
&i.Name,
&i.Method,
&i.Path,
&i.Sort,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getSysApiGroupNames = `-- name: GetSysApiGroupNames :many
const listApiGroups = `-- name: ListApiGroups :many
SELECT DISTINCT group_name
FROM sys_apis
`
func (q *Queries) GetSysApiGroupNames(ctx context.Context) ([]string, error) {
rows, err := q.db.Query(ctx, getSysApiGroupNames)
func (q *Queries) ListApiGroups(ctx context.Context) ([]string, error) {
rows, err := q.db.Query(ctx, listApiGroups)
if err != nil {
return nil, err
}
@@ -177,26 +179,29 @@ func (q *Queries) GetSysApiGroupNames(ctx context.Context) ([]string, error) {
return items, nil
}
const getSysApis = `-- name: GetSysApis :many
const listApis = `-- name: ListApis :many
SELECT id, group_name, name, method, path, sort, created_at, updated_at
FROM sys_apis
WHERE ($3::text = '' OR group_name ILIKE '%' || $3 || '%')
AND ($4::text = '' OR method = $4)
WHERE ($3::text = '' OR name ILIKE '%' || $3 || '%')
AND ($4::text = '' OR group_name ILIKE '%' || $4 || '%')
AND ($5::text = '' OR method = $5)
ORDER BY id
LIMIT $1 OFFSET $2
`
type GetSysApisParams struct {
type ListApisParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
Name string `json:"name"`
GroupName string `json:"group_name"`
Method string `json:"method"`
}
func (q *Queries) GetSysApis(ctx context.Context, arg GetSysApisParams) ([]SysApi, error) {
rows, err := q.db.Query(ctx, getSysApis,
func (q *Queries) ListApis(ctx context.Context, arg ListApisParams) ([]SysApi, error) {
rows, err := q.db.Query(ctx, listApis,
arg.Limit,
arg.Offset,
arg.Name,
arg.GroupName,
arg.Method,
)
@@ -227,7 +232,7 @@ func (q *Queries) GetSysApis(ctx context.Context, arg GetSysApisParams) ([]SysAp
return items, nil
}
const updateSysApi = `-- name: UpdateSysApi :execrows
const updateApi = `-- name: UpdateApi :execrows
UPDATE sys_apis
SET name = $2,
method = $3,
@@ -237,7 +242,7 @@ SET name = $2,
WHERE id = $1
`
type UpdateSysApiParams struct {
type UpdateApiParams struct {
ID int32 `json:"id"`
Name string `json:"name"`
Method string `json:"method"`
@@ -246,8 +251,8 @@ type UpdateSysApiParams struct {
GroupName string `json:"group_name"`
}
func (q *Queries) UpdateSysApi(ctx context.Context, arg UpdateSysApiParams) (int64, error) {
result, err := q.db.Exec(ctx, updateSysApi,
func (q *Queries) UpdateApi(ctx context.Context, arg UpdateApiParams) (int64, error) {
result, err := q.db.Exec(ctx, updateApi,
arg.ID,
arg.Name,
arg.Method,

212
internal/db/sqlc/sys_menus.sql.go
View File

@@ -10,25 +10,25 @@ import (
"time"
)
const countSysMenus = `-- name: CountSysMenus :one
const countMenus = `-- name: CountMenus :one
SELECT COUNT(*)
FROM sys_menus
`
func (q *Queries) CountSysMenus(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, countSysMenus)
func (q *Queries) CountMenus(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, countMenus)
var count int64
err := row.Scan(&count)
return count, err
}
const createSysMenu = `-- name: CreateSysMenu :one
const createMenu = `-- name: CreateMenu :one
INSERT INTO sys_menus (name, path, component, type, hidden, sort, status, parent_id, icon)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING id
`
type CreateSysMenuParams struct {
type CreateMenuParams struct {
Name string `json:"name"`
Path *string `json:"path"`
Component *string `json:"component"`
@@ -40,8 +40,8 @@ type CreateSysMenuParams struct {
Icon *int32 `json:"icon"`
}
func (q *Queries) CreateSysMenu(ctx context.Context, arg CreateSysMenuParams) (int32, error) {
row := q.db.QueryRow(ctx, createSysMenu,
func (q *Queries) CreateMenu(ctx context.Context, arg CreateMenuParams) (int32, error) {
row := q.db.QueryRow(ctx, createMenu,
arg.Name,
arg.Path,
arg.Component,
@@ -57,47 +57,47 @@ func (q *Queries) CreateSysMenu(ctx context.Context, arg CreateSysMenuParams) (i
return id, err
}
const createSysMenuPermission = `-- name: CreateSysMenuPermission :exec
const createMenuPermission = `-- name: CreateMenuPermission :exec
INSERT INTO sys_menu_permission (menu_id, permission_id)
VALUES ($1, $2)
`
type CreateSysMenuPermissionParams struct {
type CreateMenuPermissionParams struct {
MenuID int32 `json:"menu_id"`
PermissionID int32 `json:"permission_id"`
}
func (q *Queries) CreateSysMenuPermission(ctx context.Context, arg CreateSysMenuPermissionParams) error {
_, err := q.db.Exec(ctx, createSysMenuPermission, arg.MenuID, arg.PermissionID)
func (q *Queries) CreateMenuPermission(ctx context.Context, arg CreateMenuPermissionParams) error {
_, err := q.db.Exec(ctx, createMenuPermission, arg.MenuID, arg.PermissionID)
return err
}
const deleteSysMenu = `-- name: DeleteSysMenu :execrows
const deleteMenu = `-- name: DeleteMenu :execrows
DELETE
FROM sys_menus
WHERE id = $1
`
func (q *Queries) DeleteSysMenu(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteSysMenu, id)
func (q *Queries) DeleteMenu(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteMenu, id)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteSysMenuPermission = `-- name: DeleteSysMenuPermission :exec
const deleteMenuPermission = `-- name: DeleteMenuPermission :exec
DELETE
FROM sys_menu_permission
WHERE menu_id = $1
`
func (q *Queries) DeleteSysMenuPermission(ctx context.Context, menuID int32) error {
_, err := q.db.Exec(ctx, deleteSysMenuPermission, menuID)
func (q *Queries) DeleteMenuPermission(ctx context.Context, menuID int32) error {
_, err := q.db.Exec(ctx, deleteMenuPermission, menuID)
return err
}
const deleteSysPermissionByMenuID = `-- name: DeleteSysPermissionByMenuID :exec
const deletePermissionsByMenuID = `-- name: DeletePermissionsByMenuID :exec
DELETE
FROM sys_permissions
WHERE id IN (SELECT permission_id
@@ -105,79 +105,19 @@ WHERE id IN (SELECT permission_id
WHERE menu_id = $1)
`
func (q *Queries) DeleteSysPermissionByMenuID(ctx context.Context, menuID int32) error {
_, err := q.db.Exec(ctx, deleteSysPermissionByMenuID, menuID)
func (q *Queries) DeletePermissionsByMenuID(ctx context.Context, menuID int32) error {
_, err := q.db.Exec(ctx, deletePermissionsByMenuID, menuID)
return err
}
const getAllSysMenus = `-- name: GetAllSysMenus :many
SELECT 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,
p.code AS permission_code
FROM sys_menus m
LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
LEFT JOIN sys_permissions p ON p.id = mp.permission_id
ORDER BY m.sort ASC,
m.id ASC
`
type GetAllSysMenusRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
Path *string `json:"path"`
Component *string `json:"component"`
Type int16 `json:"type"`
Hidden *bool `json:"hidden"`
Sort *int32 `json:"sort"`
Status int16 `json:"status"`
ParentID *int32 `json:"parent_id"`
Icon *int32 `json:"icon"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
PermissionCode *string `json:"permission_code"`
}
func (q *Queries) GetAllSysMenus(ctx context.Context) ([]GetAllSysMenusRow, error) {
rows, err := q.db.Query(ctx, getAllSysMenus)
if err != nil {
return nil, err
}
defer rows.Close()
items := []GetAllSysMenusRow{}
for rows.Next() {
var i GetAllSysMenusRow
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,
&i.PermissionCode,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSysMenuByID = `-- name: GetSysMenuByID :one
const getMenuByID = `-- name: GetMenuByID :one
SELECT id, name, path, component, type, hidden, sort, status, parent_id, icon, created_at, updated_at
FROM sys_menus
WHERE id = $1
`
func (q *Queries) GetSysMenuByID(ctx context.Context, id int32) (SysMenu, error) {
row := q.db.QueryRow(ctx, getSysMenuByID, id)
func (q *Queries) GetMenuByID(ctx context.Context, id int32) (SysMenu, error) {
row := q.db.QueryRow(ctx, getMenuByID, id)
var i SysMenu
err := row.Scan(
&i.ID,
@@ -196,21 +136,17 @@ func (q *Queries) GetSysMenuByID(ctx context.Context, id int32) (SysMenu, error)
return i, err
}
const listSysMenus = `-- name: ListSysMenus :many
SELECT 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, p.code AS permission_code
const listAllMenus = `-- name: ListAllMenus :many
SELECT 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,
p.code AS permission_code
FROM sys_menus m
LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
LEFT JOIN sys_permissions p ON mp.permission_id = p.id
ORDER BY m.id
LIMIT $1 OFFSET $2
LEFT JOIN sys_permissions p ON p.id = mp.permission_id
ORDER BY m.sort ASC,
m.id ASC
`
type ListSysMenusParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
type ListSysMenusRow struct {
type ListAllMenusRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
Path *string `json:"path"`
@@ -226,15 +162,15 @@ type ListSysMenusRow struct {
PermissionCode *string `json:"permission_code"`
}
func (q *Queries) ListSysMenus(ctx context.Context, arg ListSysMenusParams) ([]ListSysMenusRow, error) {
rows, err := q.db.Query(ctx, listSysMenus, arg.Limit, arg.Offset)
func (q *Queries) ListAllMenus(ctx context.Context) ([]ListAllMenusRow, error) {
rows, err := q.db.Query(ctx, listAllMenus)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListSysMenusRow{}
items := []ListAllMenusRow{}
for rows.Next() {
var i ListSysMenusRow
var i ListAllMenusRow
if err := rows.Scan(
&i.ID,
&i.Name,
@@ -260,7 +196,71 @@ func (q *Queries) ListSysMenus(ctx context.Context, arg ListSysMenusParams) ([]L
return items, nil
}
const updateSysMenu = `-- name: UpdateSysMenu :execrows
const listMenus = `-- name: ListMenus :many
SELECT 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, p.code AS permission_code
FROM sys_menus m
LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
LEFT JOIN sys_permissions p ON mp.permission_id = p.id
ORDER BY m.id
LIMIT $1 OFFSET $2
`
type ListMenusParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
}
type ListMenusRow struct {
ID int32 `json:"id"`
Name string `json:"name"`
Path *string `json:"path"`
Component *string `json:"component"`
Type int16 `json:"type"`
Hidden *bool `json:"hidden"`
Sort *int32 `json:"sort"`
Status int16 `json:"status"`
ParentID *int32 `json:"parent_id"`
Icon *int32 `json:"icon"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
PermissionCode *string `json:"permission_code"`
}
func (q *Queries) ListMenus(ctx context.Context, arg ListMenusParams) ([]ListMenusRow, error) {
rows, err := q.db.Query(ctx, listMenus, arg.Limit, arg.Offset)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListMenusRow{}
for rows.Next() {
var i ListMenusRow
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,
&i.PermissionCode,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const updateMenu = `-- name: UpdateMenu :execrows
UPDATE sys_menus
SET name = coalesce($1, name),
path = coalesce($2, path),
@@ -274,7 +274,7 @@ SET name = coalesce($1, name),
WHERE id = $12
`
type UpdateSysMenuParams struct {
type UpdateMenuParams struct {
Name *string `json:"name"`
Path *string `json:"path"`
Component *string `json:"component"`
@@ -289,8 +289,8 @@ type UpdateSysMenuParams struct {
ID int32 `json:"id"`
}
func (q *Queries) UpdateSysMenu(ctx context.Context, arg UpdateSysMenuParams) (int64, error) {
result, err := q.db.Exec(ctx, updateSysMenu,
func (q *Queries) UpdateMenu(ctx context.Context, arg UpdateMenuParams) (int64, error) {
result, err := q.db.Exec(ctx, updateMenu,
arg.Name,
arg.Path,
arg.Component,
@@ -310,7 +310,7 @@ func (q *Queries) UpdateSysMenu(ctx context.Context, arg UpdateSysMenuParams) (i
return result.RowsAffected(), nil
}
const updateSysMenuPermissionCode = `-- name: UpdateSysMenuPermissionCode :exec
const updateMenuPermissionCode = `-- name: UpdateMenuPermissionCode :exec
UPDATE sys_permissions p
SET code = coalesce($2, code)
FROM sys_menu_permission mp
@@ -318,12 +318,12 @@ WHERE p.id = mp.permission_id
AND mp.menu_id = $1
`
type UpdateSysMenuPermissionCodeParams struct {
type UpdateMenuPermissionCodeParams struct {
MenuID int32 `json:"menu_id"`
Code *string `json:"code"`
}
func (q *Queries) UpdateSysMenuPermissionCode(ctx context.Context, arg UpdateSysMenuPermissionCodeParams) error {
_, err := q.db.Exec(ctx, updateSysMenuPermissionCode, arg.MenuID, arg.Code)
func (q *Queries) UpdateMenuPermissionCode(ctx context.Context, arg UpdateMenuPermissionCodeParams) error {
_, err := q.db.Exec(ctx, updateMenuPermissionCode, arg.MenuID, arg.Code)
return err
}

34
internal/db/sqlc/sys_permissions.sql.go
View File

@@ -9,72 +9,72 @@ import (
"context"
)
const createSysPermission = `-- name: CreateSysPermission :one
const createPermission = `-- name: CreatePermission :one
INSERT INTO sys_permissions(type,code)
VALUES ($1,$2) RETURNING id
`
type CreateSysPermissionParams struct {
type CreatePermissionParams struct {
Type int16 `json:"type"`
Code *string `json:"code"`
}
func (q *Queries) CreateSysPermission(ctx context.Context, arg CreateSysPermissionParams) (int32, error) {
row := q.db.QueryRow(ctx, createSysPermission, arg.Type, arg.Code)
func (q *Queries) CreatePermission(ctx context.Context, arg CreatePermissionParams) (int32, error) {
row := q.db.QueryRow(ctx, createPermission, arg.Type, arg.Code)
var id int32
err := row.Scan(&id)
return id, err
}
const deleteSysPermission = `-- name: DeleteSysPermission :exec
const deletePermission = `-- name: DeletePermission :exec
DELETE
FROM sys_permissions
WHERE id = $1
`
func (q *Queries) DeleteSysPermission(ctx context.Context, id int32) error {
_, err := q.db.Exec(ctx, deleteSysPermission, id)
func (q *Queries) DeletePermission(ctx context.Context, id int32) error {
_, err := q.db.Exec(ctx, deletePermission, id)
return err
}
const getSysPermissionIDBySysApiID = `-- name: GetSysPermissionIDBySysApiID :one
const getPermissionIDBySysApiID = `-- name: GetPermissionIDBySysApiID :one
SELECT permission_id
FROM sys_api_permission
WHERE api_id = $1
`
func (q *Queries) GetSysPermissionIDBySysApiID(ctx context.Context, apiID int32) (int32, error) {
row := q.db.QueryRow(ctx, getSysPermissionIDBySysApiID, apiID)
func (q *Queries) GetPermissionIDBySysApiID(ctx context.Context, apiID int32) (int32, error) {
row := q.db.QueryRow(ctx, getPermissionIDBySysApiID, apiID)
var permission_id int32
err := row.Scan(&permission_id)
return permission_id, err
}
const getSysPermissionIDBySysMenuID = `-- name: GetSysPermissionIDBySysMenuID :one
const getPermissionIDBySysMenuID = `-- name: GetPermissionIDBySysMenuID :one
SELECT permission_id
FROM sys_menu_permission
WHERE menu_id = $1
`
func (q *Queries) GetSysPermissionIDBySysMenuID(ctx context.Context, menuID int32) (int32, error) {
row := q.db.QueryRow(ctx, getSysPermissionIDBySysMenuID, menuID)
func (q *Queries) GetPermissionIDBySysMenuID(ctx context.Context, menuID int32) (int32, error) {
row := q.db.QueryRow(ctx, getPermissionIDBySysMenuID, menuID)
var permission_id int32
err := row.Scan(&permission_id)
return permission_id, err
}
const updateSysPermission = `-- name: UpdateSysPermission :exec
const updatePermission = `-- name: UpdatePermission :exec
UPDATE sys_permissions
SET code = $2
WHERE id = $1
`
type UpdateSysPermissionParams struct {
type UpdatePermissionParams struct {
ID int32 `json:"id"`
Code *string `json:"code"`
}
func (q *Queries) UpdateSysPermission(ctx context.Context, arg UpdateSysPermissionParams) error {
_, err := q.db.Exec(ctx, updateSysPermission, arg.ID, arg.Code)
func (q *Queries) UpdatePermission(ctx context.Context, arg UpdatePermissionParams) error {
_, err := q.db.Exec(ctx, updatePermission, arg.ID, arg.Code)
return err
}

392
internal/db/sqlc/sys_roles.sql.go
View File

@@ -9,76 +9,76 @@ import (
"context"
)
const countSysRoles = `-- name: CountSysRoles :one
const countRoles = `-- name: CountRoles :one
SELECT COUNT(*)
FROM sys_roles
`
func (q *Queries) CountSysRoles(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, countSysRoles)
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 createSysRole = `-- name: CreateSysRole :exec
const createRole = `-- name: CreateRole :exec
INSERT INTO sys_roles (name, code, status)
VALUES ($1, $2, $3)
`
type CreateSysRoleParams struct {
type CreateRoleParams 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)
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 CreateSysRolePermissionParams struct {
type CreateRolePermissionParams struct {
RoleID int32 `json:"role_id"`
PermissionID int32 `json:"permission_id"`
}
const deleteSysRole = `-- name: DeleteSysRole :execrows
const deleteRole = `-- name: DeleteRole :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)
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 deleteSysRolePermissionByPermissionID = `-- name: DeleteSysRolePermissionByPermissionID :exec
const deleteRolePermissionByPermissionID = `-- name: DeleteRolePermissionByPermissionID :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)
func (q *Queries) DeleteRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
_, err := q.db.Exec(ctx, deleteRolePermissionByPermissionID, permissionID)
return err
}
const deleteSysRolePermissionByRoleID = `-- name: DeleteSysRolePermissionByRoleID :exec
const deleteRolePermissionsByRoleID = `-- name: DeleteRolePermissionsByRoleID :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)
func (q *Queries) DeleteRolePermissionsByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteRolePermissionsByRoleID, roleID)
return err
}
const deleteSysRolePermissionByType = `-- name: DeleteSysRolePermissionByType :exec
const deleteRolePermissionsByType = `-- name: DeleteRolePermissionsByType :exec
DELETE
FROM sys_role_permission rp USING sys_permissions p
WHERE rp.permission_id = p.id
@@ -86,28 +86,28 @@ WHERE rp.permission_id = p.id
AND p."type" = $2
`
type DeleteSysRolePermissionByTypeParams struct {
type DeleteRolePermissionsByTypeParams 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)
func (q *Queries) DeleteRolePermissionsByType(ctx context.Context, arg DeleteRolePermissionsByTypeParams) error {
_, err := q.db.Exec(ctx, deleteRolePermissionsByType, arg.RoleID, arg.Type)
return err
}
const deleteSysUserRoleByRoleID = `-- name: DeleteSysUserRoleByRoleID :exec
const deleteUserRoleByRoleID = `-- name: DeleteUserRoleByRoleID :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)
func (q *Queries) DeleteUserRoleByRoleID(ctx context.Context, roleID int32) error {
_, err := q.db.Exec(ctx, deleteUserRoleByRoleID, roleID)
return err
}
const existsSysRoleCode = `-- name: ExistsSysRoleCode :one
const existsRoleCode = `-- name: ExistsRoleCode :one
SELECT EXISTS(SELECT 1
FROM sys_roles
WHERE code = $1
@@ -117,143 +117,26 @@ SELECT EXISTS(SELECT 1
))
`
type ExistsSysRoleCodeParams struct {
type ExistsRoleCodeParams 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)
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 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
const getRoleByID = `-- name: GetRoleByID :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)
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,
@@ -266,53 +149,13 @@ func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error)
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
const listAllRoles = `-- name: ListAllRoles :many
SELECT id, name, code, status, created_at, updated_at
FROM sys_roles
ORDER BY id
LIMIT $1 OFFSET $2
from sys_roles
`
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)
func (q *Queries) ListAllRoles(ctx context.Context) ([]SysRole, error) {
rows, err := q.db.Query(ctx, listAllRoles)
if err != nil {
return nil, err
}
@@ -338,21 +181,178 @@ func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]S
return items, nil
}
const updateSysRole = `-- name: UpdateSysRole :execrows
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 UpdateSysRoleParams struct {
type UpdateRoleParams 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)
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
}

282
internal/db/sqlc/sys_users.sql.go
View File

@@ -10,36 +10,36 @@ import (
"time"
)
const clearSysUserRoles = `-- name: ClearSysUserRoles :exec
const clearUserRoles = `-- name: ClearUserRoles :exec
DELETE
FROM sys_user_role
WHERE user_id = $1
`
func (q *Queries) ClearSysUserRoles(ctx context.Context, userID int32) error {
_, err := q.db.Exec(ctx, clearSysUserRoles, userID)
func (q *Queries) ClearUserRoles(ctx context.Context, userID int32) error {
_, err := q.db.Exec(ctx, clearUserRoles, userID)
return err
}
const countSysUsers = `-- name: CountSysUsers :one
const countUsers = `-- name: CountUsers :one
SELECT COUNT(*)
FROM sys_users
WHERE ($1::text = '' OR username ILIKE '%' || $1 || '%')
`
func (q *Queries) CountSysUsers(ctx context.Context, username string) (int64, error) {
row := q.db.QueryRow(ctx, countSysUsers, username)
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 createSysUser = `-- name: CreateSysUser :exec
const createUser = `-- name: CreateUser :exec
INSERT INTO sys_users (account, username, password_hash, status, avatar_id)
VALUES ($1, $2, $3, $4, $5)
`
type CreateSysUserParams struct {
type CreateUserParams struct {
Account string `json:"account"`
Username string `json:"username"`
PasswordHash string `json:"password_hash"`
@@ -47,8 +47,8 @@ type CreateSysUserParams struct {
AvatarID *int32 `json:"avatar_id"`
}
func (q *Queries) CreateSysUser(ctx context.Context, arg CreateSysUserParams) error {
_, err := q.db.Exec(ctx, createSysUser,
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) error {
_, err := q.db.Exec(ctx, createUser,
arg.Account,
arg.Username,
arg.PasswordHash,
@@ -58,34 +58,34 @@ func (q *Queries) CreateSysUser(ctx context.Context, arg CreateSysUserParams) er
return err
}
type CreateSysUserRoleParams struct {
type CreateUserRoleParams struct {
UserID int32 `json:"user_id"`
RoleID int32 `json:"role_id"`
}
const deleteSysUser = `-- name: DeleteSysUser :execrows
const deleteUser = `-- name: DeleteUser :execrows
DELETE
FROM sys_users
WHERE id = $1
AND id <> 1
`
func (q *Queries) DeleteSysUser(ctx context.Context, id int32) (int64, error) {
result, err := q.db.Exec(ctx, deleteSysUser, id)
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 getActiveSysUserByID = `-- name: GetActiveSysUserByID :one
const getActiveUserByID = `-- name: GetActiveUserByID :one
SELECT id, account, username, status
FROM sys_users
WHERE id = $1
AND status = 1
`
type GetActiveSysUserByIDRow struct {
type GetActiveUserByIDRow struct {
ID int32 `json:"id"`
Account string `json:"account"`
Username string `json:"username"`
@@ -93,9 +93,9 @@ type GetActiveSysUserByIDRow struct {
}
// 场景：用户登录、获取个人信息、刷新 Token（严格校验 status = 1）
func (q *Queries) GetActiveSysUserByID(ctx context.Context, id int32) (GetActiveSysUserByIDRow, error) {
row := q.db.QueryRow(ctx, getActiveSysUserByID, id)
var i GetActiveSysUserByIDRow
func (q *Queries) GetActiveUserByID(ctx context.Context, id int32) (GetActiveUserByIDRow, error) {
row := q.db.QueryRow(ctx, getActiveUserByID, id)
var i GetActiveUserByIDRow
err := row.Scan(
&i.ID,
&i.Account,
@@ -105,7 +105,92 @@ func (q *Queries) GetActiveSysUserByID(ctx context.Context, id int32) (GetActive
return i, err
}
const getSysAdminMenus = `-- name: GetSysAdminMenus :many
const getUserByAccount = `-- name: GetUserByAccount :one
SELECT u.id,
u.account,
u.username,
u.password_hash,
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 u.account = $1
`
type GetUserByAccountRow 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"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
}
func (q *Queries) GetUserByAccount(ctx context.Context, account string) (GetUserByAccountRow, error) {
row := q.db.QueryRow(ctx, getUserByAccount, account)
var i GetUserByAccountRow
err := row.Scan(
&i.ID,
&i.Account,
&i.Username,
&i.PasswordHash,
&i.Status,
&i.AvatarID,
&i.AvatarUrl,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getUserByID = `-- name: GetUserByID :one
SELECT u.id,
u.account,
u.username,
u.avatar_id,
u.status,
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 u.id = $1
`
type GetUserByIDRow struct {
ID int32 `json:"id"`
Account string `json:"account"`
Username string `json:"username"`
AvatarID *int32 `json:"avatar_id"`
Status int16 `json:"status"`
AvatarUrl *string `json:"avatar_url"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
}
func (q *Queries) GetUserByID(ctx context.Context, id int32) (GetUserByIDRow, error) {
row := q.db.QueryRow(ctx, getUserByID, id)
var i GetUserByIDRow
err := row.Scan(
&i.ID,
&i.Account,
&i.Username,
&i.AvatarID,
&i.Status,
&i.AvatarUrl,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, 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
@@ -113,8 +198,8 @@ WHERE status = 1
ORDER BY sort, id
`
func (q *Queries) GetSysAdminMenus(ctx context.Context) ([]SysMenu, error) {
rows, err := q.db.Query(ctx, getSysAdminMenus)
func (q *Queries) ListAdminMenus(ctx context.Context) ([]SysMenu, error) {
rows, err := q.db.Query(ctx, listAdminMenus)
if err != nil {
return nil, err
}
@@ -146,14 +231,14 @@ func (q *Queries) GetSysAdminMenus(ctx context.Context) ([]SysMenu, error) {
return items, nil
}
const getSysAdminPermissions = `-- name: GetSysAdminPermissions :many
const listAdminPermissionCodes = `-- name: ListAdminPermissionCodes :many
SELECT code
FROM sys_permissions
WHERE type = 0
`
func (q *Queries) GetSysAdminPermissions(ctx context.Context) ([]*string, error) {
rows, err := q.db.Query(ctx, getSysAdminPermissions)
func (q *Queries) ListAdminPermissionCodes(ctx context.Context) ([]*string, error) {
rows, err := q.db.Query(ctx, listAdminPermissionCodes)
if err != nil {
return nil, err
}
@@ -172,7 +257,7 @@ func (q *Queries) GetSysAdminPermissions(ctx context.Context) ([]*string, error)
return items, nil
}
const getSysUserApis = `-- name: GetSysUserApis :many
const listUserApis = `-- name: ListUserApis :many
SELECT DISTINCT a.id,
a.PATH,
a.METHOD
@@ -187,21 +272,21 @@ WHERE u.id = $1
AND r.status = 1
`
type GetSysUserApisRow struct {
type ListUserApisRow struct {
ID int32 `json:"id"`
Path string `json:"path"`
Method string `json:"method"`
}
func (q *Queries) GetSysUserApis(ctx context.Context, id int32) ([]GetSysUserApisRow, error) {
rows, err := q.db.Query(ctx, getSysUserApis, id)
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 := []GetSysUserApisRow{}
items := []ListUserApisRow{}
for rows.Next() {
var i GetSysUserApisRow
var i ListUserApisRow
if err := rows.Scan(&i.ID, &i.Path, &i.Method); err != nil {
return nil, err
}
@@ -213,92 +298,7 @@ func (q *Queries) GetSysUserApis(ctx context.Context, id int32) ([]GetSysUserApi
return items, nil
}
const getSysUserByAccount = `-- name: GetSysUserByAccount :one
SELECT u.id,
u.account,
u.username,
u.password_hash,
u.status,
u.avatar_id,
f.file_path AS avatar_url,
u.created_at,
u.updated_at
FROM sys_users u
LEFT JOIN files f ON u.avatar_id = f.id
WHERE u.account = $1
`
type GetSysUserByAccountRow 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"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
}
func (q *Queries) GetSysUserByAccount(ctx context.Context, account string) (GetSysUserByAccountRow, error) {
row := q.db.QueryRow(ctx, getSysUserByAccount, account)
var i GetSysUserByAccountRow
err := row.Scan(
&i.ID,
&i.Account,
&i.Username,
&i.PasswordHash,
&i.Status,
&i.AvatarID,
&i.AvatarUrl,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getSysUserByID = `-- name: GetSysUserByID :one
SELECT u.id,
u.account,
u.username,
u.avatar_id,
u.status,
f.file_path AS avatar_url,
u.created_at,
u.updated_at
FROM sys_users u
LEFT JOIN files f ON u.avatar_id = f.id
WHERE u.id = $1
`
type GetSysUserByIDRow struct {
ID int32 `json:"id"`
Account string `json:"account"`
Username string `json:"username"`
AvatarID *int32 `json:"avatar_id"`
Status int16 `json:"status"`
AvatarUrl *string `json:"avatar_url"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt *time.Time `json:"updated_at"`
}
func (q *Queries) GetSysUserByID(ctx context.Context, id int32) (GetSysUserByIDRow, error) {
row := q.db.QueryRow(ctx, getSysUserByID, id)
var i GetSysUserByIDRow
err := row.Scan(
&i.ID,
&i.Account,
&i.Username,
&i.AvatarID,
&i.Status,
&i.AvatarUrl,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getSysUserMenus = `-- name: GetSysUserMenus :many
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
@@ -314,8 +314,8 @@ WHERE u.id = $1
ORDER BY m.sort, m.id
`
func (q *Queries) GetSysUserMenus(ctx context.Context, id int32) ([]SysMenu, error) {
rows, err := q.db.Query(ctx, getSysUserMenus, 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
}
@@ -347,7 +347,7 @@ func (q *Queries) GetSysUserMenus(ctx context.Context, id int32) ([]SysMenu, err
return items, nil
}
const getSysUserPermissions = `-- name: GetSysUserPermissions :many
const listUserPermissionCodes = `-- name: ListUserPermissionCodes :many
SELECT DISTINCT p.code
FROM sys_users u
JOIN sys_user_role ur ON u.id = ur.user_id
@@ -363,8 +363,8 @@ WHERE u.id = $1
AND p."type" = 0
`
func (q *Queries) GetSysUserPermissions(ctx context.Context, id int32) ([]*string, error) {
rows, err := q.db.Query(ctx, getSysUserPermissions, id)
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
}
@@ -383,15 +383,15 @@ func (q *Queries) GetSysUserPermissions(ctx context.Context, id int32) ([]*strin
return items, nil
}
const getSysUserRoles = `-- name: GetSysUserRoles :many
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) GetSysUserRoles(ctx context.Context, userID int32) ([]SysRole, error) {
rows, err := q.db.Query(ctx, getSysUserRoles, userID)
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
}
@@ -417,13 +417,13 @@ func (q *Queries) GetSysUserRoles(ctx context.Context, userID int32) ([]SysRole,
return items, nil
}
const listSysUsers = `-- name: ListSysUsers :many
const listUsers = `-- name: ListUsers :many
SELECT u.id,
u.account,
u.username,
u.status,
u.avatar_id,
f.file_path AS avatar_url,
f.file_url AS avatar_url,
u.created_at,
u.updated_at
FROM sys_users u
@@ -433,13 +433,13 @@ ORDER BY u.id
LIMIT $1 OFFSET $2
`
type ListSysUsersParams struct {
type ListUsersParams struct {
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
Username string `json:"username"`
}
type ListSysUsersRow struct {
type ListUsersRow struct {
ID int32 `json:"id"`
Account string `json:"account"`
Username string `json:"username"`
@@ -450,15 +450,15 @@ type ListSysUsersRow struct {
UpdatedAt *time.Time `json:"updated_at"`
}
func (q *Queries) ListSysUsers(ctx context.Context, arg ListSysUsersParams) ([]ListSysUsersRow, error) {
rows, err := q.db.Query(ctx, listSysUsers, arg.Limit, arg.Offset, arg.Username)
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 := []ListSysUsersRow{}
items := []ListUsersRow{}
for rows.Next() {
var i ListSysUsersRow
var i ListUsersRow
if err := rows.Scan(
&i.ID,
&i.Account,
@@ -479,7 +479,7 @@ func (q *Queries) ListSysUsers(ctx context.Context, arg ListSysUsersParams) ([]L
return items, nil
}
const updateSysUser = `-- name: UpdateSysUser :execrows
const updateUser = `-- name: UpdateUser :execrows
UPDATE sys_users
SET username = coalesce($1, username),
status = coalesce($2, status),
@@ -487,7 +487,7 @@ SET username = coalesce($1, username),
WHERE id = $5
`
type UpdateSysUserParams struct {
type UpdateUserParams struct {
Username *string `json:"username"`
Status *int16 `json:"status"`
UpdateAvatarID bool `json:"update_avatar_id"`
@@ -495,8 +495,8 @@ type UpdateSysUserParams struct {
ID int32 `json:"id"`
}
func (q *Queries) UpdateSysUser(ctx context.Context, arg UpdateSysUserParams) (int64, error) {
result, err := q.db.Exec(ctx, updateSysUser,
func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) (int64, error) {
result, err := q.db.Exec(ctx, updateUser,
arg.Username,
arg.Status,
arg.UpdateAvatarID,
@@ -509,19 +509,19 @@ func (q *Queries) UpdateSysUser(ctx context.Context, arg UpdateSysUserParams) (i
return result.RowsAffected(), nil
}
const updateSysUserPassword = `-- name: UpdateSysUserPassword :execrows
const updateUserPassword = `-- name: UpdateUserPassword :execrows
UPDATE sys_users
SET password_hash = $2
WHERE id = $1
`
type UpdateSysUserPasswordParams struct {
type UpdateUserPasswordParams struct {
ID int32 `json:"id"`
PasswordHash string `json:"password_hash"`
}
func (q *Queries) UpdateSysUserPassword(ctx context.Context, arg UpdateSysUserPasswordParams) (int64, error) {
result, err := q.db.Exec(ctx, updateSysUserPassword, arg.ID, arg.PasswordHash)
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
}