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

package sqlc

import (
	"context"
	"time"
)

const clearSysUserRoles = `-- name: ClearSysUserRoles :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)
	return err
}

const countSysUsers = `-- name: CountSysUsers :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)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createSysUser = `-- name: CreateSysUser :exec
INSERT INTO sys_users (account, username, password_hash, status, avatar_id)
VALUES ($1, $2, $3, $4, $5)
`

type CreateSysUserParams 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) CreateSysUser(ctx context.Context, arg CreateSysUserParams) error {
	_, err := q.db.Exec(ctx, createSysUser,
		arg.Account,
		arg.Username,
		arg.PasswordHash,
		arg.Status,
		arg.AvatarID,
	)
	return err
}

type CreateSysUserRoleParams struct {
	UserID int32 `json:"user_id"`
	RoleID int32 `json:"role_id"`
}

const deleteSysUser = `-- name: DeleteSysUser :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)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const getActiveSysUserByID = `-- name: GetActiveSysUserByID :one
SELECT id, account, username, status
FROM sys_users
WHERE id = $1
  AND status = 1
`

type GetActiveSysUserByIDRow struct {
	ID       int32  `json:"id"`
	Account  string `json:"account"`
	Username string `json:"username"`
	Status   int16  `json:"status"`
}

// 场景：用户登录、获取个人信息、刷新 Token（严格校验 status = 1）
func (q *Queries) GetActiveSysUserByID(ctx context.Context, id int32) (GetActiveSysUserByIDRow, error) {
	row := q.db.QueryRow(ctx, getActiveSysUserByID, id)
	var i GetActiveSysUserByIDRow
	err := row.Scan(
		&i.ID,
		&i.Account,
		&i.Username,
		&i.Status,
	)
	return i, err
}

const getSysAdminMenus = `-- name: GetSysAdminMenus :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) GetSysAdminMenus(ctx context.Context) ([]SysMenu, error) {
	rows, err := q.db.Query(ctx, getSysAdminMenus)
	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 getSysAdminPermissions = `-- name: GetSysAdminPermissions :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)
	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 getSysUserApis = `-- name: GetSysUserApis :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 GetSysUserApisRow 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)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetSysUserApisRow{}
	for rows.Next() {
		var i GetSysUserApisRow
		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 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
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) GetSysUserMenus(ctx context.Context, id int32) ([]SysMenu, error) {
	rows, err := q.db.Query(ctx, getSysUserMenus, 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 getSysUserPermissions = `-- name: GetSysUserPermissions :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) GetSysUserPermissions(ctx context.Context, id int32) ([]*string, error) {
	rows, err := q.db.Query(ctx, getSysUserPermissions, 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 getSysUserRoles = `-- name: GetSysUserRoles :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)
	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 listSysUsers = `-- name: ListSysUsers :many
SELECT u.id,
       u.account,
       u.username,
       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 ($3::text = '' OR u.username ILIKE '%' || $3 || '%')
ORDER BY u.id
LIMIT $1 OFFSET $2
`

type ListSysUsersParams struct {
	Limit    int32  `json:"limit"`
	Offset   int32  `json:"offset"`
	Username string `json:"username"`
}

type ListSysUsersRow 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) ListSysUsers(ctx context.Context, arg ListSysUsersParams) ([]ListSysUsersRow, error) {
	rows, err := q.db.Query(ctx, listSysUsers, arg.Limit, arg.Offset, arg.Username)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListSysUsersRow{}
	for rows.Next() {
		var i ListSysUsersRow
		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 updateSysUser = `-- name: UpdateSysUser :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 UpdateSysUserParams 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) UpdateSysUser(ctx context.Context, arg UpdateSysUserParams) (int64, error) {
	result, err := q.db.Exec(ctx, updateSysUser,
		arg.Username,
		arg.Status,
		arg.UpdateAvatarID,
		arg.AvatarID,
		arg.ID,
	)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const updateSysUserPassword = `-- name: UpdateSysUserPassword :execrows
UPDATE sys_users
SET password_hash = $2
WHERE id = $1
`

type UpdateSysUserPasswordParams 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)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}