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

package sqlc

import (
	"context"
	"time"
)

const countMenus = `-- name: CountMenus :one
SELECT COUNT(*)
FROM sys_menus
`

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 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 CreateMenuParams struct {
	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"`
}

func (q *Queries) CreateMenu(ctx context.Context, arg CreateMenuParams) (int32, error) {
	row := q.db.QueryRow(ctx, createMenu,
		arg.Name,
		arg.Path,
		arg.Component,
		arg.Type,
		arg.Hidden,
		arg.Sort,
		arg.Status,
		arg.ParentID,
		arg.Icon,
	)
	var id int32
	err := row.Scan(&id)
	return id, err
}

const createMenuPermission = `-- name: CreateMenuPermission :exec
INSERT INTO sys_menu_permission (menu_id, permission_id)
VALUES ($1, $2)
`

type CreateMenuPermissionParams struct {
	MenuID       int32 `json:"menu_id"`
	PermissionID int32 `json:"permission_id"`
}

func (q *Queries) CreateMenuPermission(ctx context.Context, arg CreateMenuPermissionParams) error {
	_, err := q.db.Exec(ctx, createMenuPermission, arg.MenuID, arg.PermissionID)
	return err
}

const deleteMenu = `-- name: DeleteMenu :execrows
DELETE
FROM sys_menus
WHERE id = $1
`

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 deleteMenuPermission = `-- name: DeleteMenuPermission :exec
DELETE
FROM sys_menu_permission
WHERE menu_id = $1
`

func (q *Queries) DeleteMenuPermission(ctx context.Context, menuID int32) error {
	_, err := q.db.Exec(ctx, deleteMenuPermission, menuID)
	return err
}

const deletePermissionsByMenuID = `-- name: DeletePermissionsByMenuID :exec
DELETE
FROM sys_permissions
WHERE id IN (SELECT permission_id
             FROM sys_menu_permission
             WHERE menu_id = $1)
`

func (q *Queries) DeletePermissionsByMenuID(ctx context.Context, menuID int32) error {
	_, err := q.db.Exec(ctx, deletePermissionsByMenuID, menuID)
	return err
}

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) GetMenuByID(ctx context.Context, id int32) (SysMenu, error) {
	row := q.db.QueryRow(ctx, getMenuByID, id)
	var i SysMenu
	err := row.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,
	)
	return i, err
}

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 p.id = mp.permission_id
ORDER BY m.sort ASC,
         m.id ASC
`

type ListAllMenusRow 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) ListAllMenus(ctx context.Context) ([]ListAllMenusRow, error) {
	rows, err := q.db.Query(ctx, listAllMenus)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAllMenusRow{}
	for rows.Next() {
		var i ListAllMenusRow
		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 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),
    component = coalesce($3, component),
    type      = coalesce($4, type),
    hidden    = coalesce($5, hidden),
    sort      = coalesce($6, sort),
    status    = coalesce($7, status),
    icon = CASE WHEN $8::boolean THEN $9 ELSE icon END,
    parent_id = CASE WHEN $10::boolean THEN $11 ELSE parent_id END
WHERE id = $12
`

type UpdateMenuParams struct {
	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"`
	UpdateIcon     bool    `json:"update_icon"`
	Icon           *int32  `json:"icon"`
	UpdateParentID bool    `json:"update_parent_id"`
	ParentID       *int32  `json:"parent_id"`
	ID             int32   `json:"id"`
}

func (q *Queries) UpdateMenu(ctx context.Context, arg UpdateMenuParams) (int64, error) {
	result, err := q.db.Exec(ctx, updateMenu,
		arg.Name,
		arg.Path,
		arg.Component,
		arg.Type,
		arg.Hidden,
		arg.Sort,
		arg.Status,
		arg.UpdateIcon,
		arg.Icon,
		arg.UpdateParentID,
		arg.ParentID,
		arg.ID,
	)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const updateMenuPermissionCode = `-- name: UpdateMenuPermissionCode :exec
UPDATE sys_permissions p
SET code = coalesce($2, code)
FROM sys_menu_permission mp
WHERE p.id = mp.permission_id
  AND mp.menu_id = $1
`

type UpdateMenuPermissionCodeParams struct {
	MenuID int32   `json:"menu_id"`
	Code   *string `json:"code"`
}

func (q *Queries) UpdateMenuPermissionCode(ctx context.Context, arg UpdateMenuPermissionCodeParams) error {
	_, err := q.db.Exec(ctx, updateMenuPermissionCode, arg.MenuID, arg.Code)
	return err
}