// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: sys_menu.sql

package db

import (
	"context"
	"time"
)

const allSysMenu = `-- name: AllSysMenu :many
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at FROM sys_menu
WHERE status = 0
ORDER BY sort DESC
`

func (q *Queries) AllSysMenu(ctx context.Context) ([]*SysMenu, error) {
	rows, err := q.db.Query(ctx, allSysMenu)
	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.DisplayName,
			&i.Url,
			&i.Type,
			&i.ParentID,
			&i.ParentPath,
			&i.Avatar,
			&i.Style,
			&i.Visible,
			&i.IsList,
			&i.Status,
			&i.Sort,
			&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 createSysMenu = `-- name: CreateSysMenu :one
INSERT INTO sys_menu (
    name, 
    display_name, 
    url, 
    type, 
    parent_id, 
    parent_path, 
    avatar, 
    style, 
    visible, 
    is_list, 
    status, 
    sort, 
    created_at, 
    updated_at
) VALUES (
    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14
) RETURNING id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at
`

type CreateSysMenuParams struct {
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	Url         string    `json:"url"`
	Type        string    `json:"type"`
	ParentID    int32     `json:"parent_id"`
	ParentPath  string    `json:"parent_path"`
	Avatar      string    `json:"avatar"`
	Style       string    `json:"style"`
	Visible     bool      `json:"visible"`
	IsList      bool      `json:"is_list"`
	Status      int32     `json:"status"`
	Sort        int32     `json:"sort"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

func (q *Queries) CreateSysMenu(ctx context.Context, arg *CreateSysMenuParams) (*SysMenu, error) {
	row := q.db.QueryRow(ctx, createSysMenu,
		arg.Name,
		arg.DisplayName,
		arg.Url,
		arg.Type,
		arg.ParentID,
		arg.ParentPath,
		arg.Avatar,
		arg.Style,
		arg.Visible,
		arg.IsList,
		arg.Status,
		arg.Sort,
		arg.CreatedAt,
		arg.UpdatedAt,
	)
	var i SysMenu
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.DisplayName,
		&i.Url,
		&i.Type,
		&i.ParentID,
		&i.ParentPath,
		&i.Avatar,
		&i.Style,
		&i.Visible,
		&i.IsList,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const existsMenu = `-- name: ExistsMenu :one
SELECT EXISTS (
    SELECT 1 FROM sys_menu
)
`

func (q *Queries) ExistsMenu(ctx context.Context) (bool, error) {
	row := q.db.QueryRow(ctx, existsMenu)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const getSysMenu = `-- name: GetSysMenu :one
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at FROM sys_menu
WHERE id = $1 LIMIT 1
`

func (q *Queries) GetSysMenu(ctx context.Context, id int32) (*SysMenu, error) {
	row := q.db.QueryRow(ctx, getSysMenu, id)
	var i SysMenu
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.DisplayName,
		&i.Url,
		&i.Type,
		&i.ParentID,
		&i.ParentPath,
		&i.Avatar,
		&i.Style,
		&i.Visible,
		&i.IsList,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const getSysMenuByUrl = `-- name: GetSysMenuByUrl :one
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at FROM sys_menu
WHERE url = $1 LIMIT 1
`

func (q *Queries) GetSysMenuByUrl(ctx context.Context, url string) (*SysMenu, error) {
	row := q.db.QueryRow(ctx, getSysMenuByUrl, url)
	var i SysMenu
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.DisplayName,
		&i.Url,
		&i.Type,
		&i.ParentID,
		&i.ParentPath,
		&i.Avatar,
		&i.Style,
		&i.Visible,
		&i.IsList,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const listSysMenuByRoleID = `-- name: ListSysMenuByRoleID :many
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at FROM sys_menu
WHERE id IN (SELECT menu_id
            FROM sys_role_menu
            WHERE role_id = $1)
`

func (q *Queries) ListSysMenuByRoleID(ctx context.Context, roleID int32) ([]*SysMenu, error) {
	rows, err := q.db.Query(ctx, listSysMenuByRoleID, roleID)
	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.DisplayName,
			&i.Url,
			&i.Type,
			&i.ParentID,
			&i.ParentPath,
			&i.Avatar,
			&i.Style,
			&i.Visible,
			&i.IsList,
			&i.Status,
			&i.Sort,
			&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 listSysMenuIDByRoleID = `-- name: ListSysMenuIDByRoleID :many
SELECT menu_id
FROM sys_role_menu
WHERE role_id = $1
`

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

const recursiveSysMenus = `-- name: RecursiveSysMenus :many
WITH RECURSIVE dist AS (SELECT sys_menu.id, sys_menu.name, sys_menu.display_name, sys_menu.url, sys_menu.type, sys_menu.parent_id, sys_menu.parent_path, sys_menu.avatar, sys_menu.style, sys_menu.visible, sys_menu.is_list, sys_menu.status, sys_menu.sort, sys_menu.created_at, sys_menu.updated_at
                        FROM sys_menu
                        WHERE status = 0
                          AND is_list = true
                        UNION ALL
                        SELECT sys_menu.id, sys_menu.name, sys_menu.display_name, sys_menu.url, sys_menu.type, sys_menu.parent_id, sys_menu.parent_path, sys_menu.avatar, sys_menu.style, sys_menu.visible, sys_menu.is_list, sys_menu.status, sys_menu.sort, sys_menu.created_at, sys_menu.updated_at
                        FROM sys_menu,
                             dist
                        WHERE sys_menu.id = dist.parent_id)
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at
FROM dist
ORDER BY dist.sort DESC, dist.id ASC
`

type RecursiveSysMenusRow struct {
	ID          int32     `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	Url         string    `json:"url"`
	Type        string    `json:"type"`
	ParentID    int32     `json:"parent_id"`
	ParentPath  string    `json:"parent_path"`
	Avatar      string    `json:"avatar"`
	Style       string    `json:"style"`
	Visible     bool      `json:"visible"`
	IsList      bool      `json:"is_list"`
	Status      int32     `json:"status"`
	Sort        int32     `json:"sort"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

func (q *Queries) RecursiveSysMenus(ctx context.Context) ([]*RecursiveSysMenusRow, error) {
	rows, err := q.db.Query(ctx, recursiveSysMenus)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*RecursiveSysMenusRow{}
	for rows.Next() {
		var i RecursiveSysMenusRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.DisplayName,
			&i.Url,
			&i.Type,
			&i.ParentID,
			&i.ParentPath,
			&i.Avatar,
			&i.Style,
			&i.Visible,
			&i.IsList,
			&i.Status,
			&i.Sort,
			&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 recursiveSysMenusByRoleID = `-- name: RecursiveSysMenusByRoleID :many
WITH RECURSIVE dist AS (SELECT sys_menu.id, sys_menu.name, sys_menu.display_name, sys_menu.url, sys_menu.type, sys_menu.parent_id, sys_menu.parent_path, sys_menu.avatar, sys_menu.style, sys_menu.visible, sys_menu.is_list, sys_menu.status, sys_menu.sort, sys_menu.created_at, sys_menu.updated_at
                        FROM sys_menu
                        WHERE status = 0
                          AND is_list = true
                          AND id IN (SELECT menu_id
                                     FROM sys_role_menu
                                     WHERE role_id = $1)
                        UNION ALL
                        SELECT sys_menu.id, sys_menu.name, sys_menu.display_name, sys_menu.url, sys_menu.type, sys_menu.parent_id, sys_menu.parent_path, sys_menu.avatar, sys_menu.style, sys_menu.visible, sys_menu.is_list, sys_menu.status, sys_menu.sort, sys_menu.created_at, sys_menu.updated_at
                        FROM sys_menu,
                             dist
                        WHERE sys_menu.id = dist.parent_id)
SELECT id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at
FROM dist
ORDER BY dist.sort DESC, dist.id ASC
`

type RecursiveSysMenusByRoleIDRow struct {
	ID          int32     `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	Url         string    `json:"url"`
	Type        string    `json:"type"`
	ParentID    int32     `json:"parent_id"`
	ParentPath  string    `json:"parent_path"`
	Avatar      string    `json:"avatar"`
	Style       string    `json:"style"`
	Visible     bool      `json:"visible"`
	IsList      bool      `json:"is_list"`
	Status      int32     `json:"status"`
	Sort        int32     `json:"sort"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

func (q *Queries) RecursiveSysMenusByRoleID(ctx context.Context, roleID int32) ([]*RecursiveSysMenusByRoleIDRow, error) {
	rows, err := q.db.Query(ctx, recursiveSysMenusByRoleID, roleID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*RecursiveSysMenusByRoleIDRow{}
	for rows.Next() {
		var i RecursiveSysMenusByRoleIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.DisplayName,
			&i.Url,
			&i.Type,
			&i.ParentID,
			&i.ParentPath,
			&i.Avatar,
			&i.Style,
			&i.Visible,
			&i.IsList,
			&i.Status,
			&i.Sort,
			&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 updateSysMenu = `-- name: UpdateSysMenu :one
UPDATE sys_menu
SET name         = $2,
    display_name = $3,
    url          = $4,
    type         = $5,
    parent_id    = $6,
    parent_path  = $7,
    avatar       = $8,
    style        = $9,
    visible      = $10,
    is_list      = $11,
    status       = $12,
    sort		     = $13,
    updated_at   = $14
WHERE id = $1
RETURNING id, name, display_name, url, type, parent_id, parent_path, avatar, style, visible, is_list, status, sort, created_at, updated_at
`

type UpdateSysMenuParams struct {
	ID          int32     `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	Url         string    `json:"url"`
	Type        string    `json:"type"`
	ParentID    int32     `json:"parent_id"`
	ParentPath  string    `json:"parent_path"`
	Avatar      string    `json:"avatar"`
	Style       string    `json:"style"`
	Visible     bool      `json:"visible"`
	IsList      bool      `json:"is_list"`
	Status      int32     `json:"status"`
	Sort        int32     `json:"sort"`
	UpdatedAt   time.Time `json:"updated_at"`
}

func (q *Queries) UpdateSysMenu(ctx context.Context, arg *UpdateSysMenuParams) (*SysMenu, error) {
	row := q.db.QueryRow(ctx, updateSysMenu,
		arg.ID,
		arg.Name,
		arg.DisplayName,
		arg.Url,
		arg.Type,
		arg.ParentID,
		arg.ParentPath,
		arg.Avatar,
		arg.Style,
		arg.Visible,
		arg.IsList,
		arg.Status,
		arg.Sort,
		arg.UpdatedAt,
	)
	var i SysMenu
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.DisplayName,
		&i.Url,
		&i.Type,
		&i.ParentID,
		&i.ParentPath,
		&i.Avatar,
		&i.Style,
		&i.Visible,
		&i.IsList,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}