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

package db

import (
	"context"
	"time"

	"github.com/google/uuid"
)

const countSysUser = `-- name: CountSysUser :one
SELECT COUNT(*) FROM sys_user
WHERE status = 0
`

func (q *Queries) CountSysUser(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, countSysUser)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countSysUserCondition = `-- name: CountSysUserCondition :one
SELECT COUNT(*) FROM sys_user
WHERE (NOT $1::Boolean OR status = $2)
    AND (NOT $3::Boolean OR id = $4)
    AND ($5::text = '' OR username ILIKE '%' || $5 || '%')
    AND ($6::text = '' OR email ILIKE '%' || $6 || '%')
`

type CountSysUserConditionParams struct {
	IsStatus bool   `json:"is_status"`
	Status   int32  `json:"status"`
	IsID     bool   `json:"is_id"`
	ID       int32  `json:"id"`
	Username string `json:"username"`
	Email    string `json:"email"`
}

func (q *Queries) CountSysUserCondition(ctx context.Context, arg *CountSysUserConditionParams) (int64, error) {
	row := q.db.QueryRow(ctx, countSysUserCondition,
		arg.IsStatus,
		arg.Status,
		arg.IsID,
		arg.ID,
		arg.Username,
		arg.Email,
	)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createSysUser = `-- name: CreateSysUser :one
INSERT INTO sys_user (
    uuid, 
    email, 
    username, 
    hashed_password, 
    salt, 
    avatar, 
    gender, 
    department_id, 
    role_id, 
    status, 
    change_password_at, 
    created_at, 
    updated_at
) VALUES (
    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13
) RETURNING id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at
`

type CreateSysUserParams struct {
	Uuid             uuid.UUID `json:"uuid"`
	Email            string    `json:"email"`
	Username         string    `json:"username"`
	HashedPassword   []byte    `json:"hashed_password"`
	Salt             string    `json:"salt"`
	Avatar           string    `json:"avatar"`
	Gender           int32     `json:"gender"`
	DepartmentID     int32     `json:"department_id"`
	RoleID           int32     `json:"role_id"`
	Status           int32     `json:"status"`
	ChangePasswordAt time.Time `json:"change_password_at"`
	CreatedAt        time.Time `json:"created_at"`
	UpdatedAt        time.Time `json:"updated_at"`
}

func (q *Queries) CreateSysUser(ctx context.Context, arg *CreateSysUserParams) (*SysUser, error) {
	row := q.db.QueryRow(ctx, createSysUser,
		arg.Uuid,
		arg.Email,
		arg.Username,
		arg.HashedPassword,
		arg.Salt,
		arg.Avatar,
		arg.Gender,
		arg.DepartmentID,
		arg.RoleID,
		arg.Status,
		arg.ChangePasswordAt,
		arg.CreatedAt,
		arg.UpdatedAt,
	)
	var i SysUser
	err := row.Scan(
		&i.ID,
		&i.Uuid,
		&i.Email,
		&i.Username,
		&i.HashedPassword,
		&i.Salt,
		&i.Avatar,
		&i.Gender,
		&i.DepartmentID,
		&i.RoleID,
		&i.Status,
		&i.ChangePasswordAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const existsSysUser = `-- name: ExistsSysUser :one
SELECT EXISTS (
    SELECT 1 FROM sys_user
)
`

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

const getSysUser = `-- name: GetSysUser :one
SELECT id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at FROM sys_user
WHERE id = $1 LIMIT 1
`

func (q *Queries) GetSysUser(ctx context.Context, id int32) (*SysUser, error) {
	row := q.db.QueryRow(ctx, getSysUser, id)
	var i SysUser
	err := row.Scan(
		&i.ID,
		&i.Uuid,
		&i.Email,
		&i.Username,
		&i.HashedPassword,
		&i.Salt,
		&i.Avatar,
		&i.Gender,
		&i.DepartmentID,
		&i.RoleID,
		&i.Status,
		&i.ChangePasswordAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const getSysUserByEmail = `-- name: GetSysUserByEmail :one
SELECT id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at FROM sys_user
WHERE email = $1 LIMIT 1
`

func (q *Queries) GetSysUserByEmail(ctx context.Context, email string) (*SysUser, error) {
	row := q.db.QueryRow(ctx, getSysUserByEmail, email)
	var i SysUser
	err := row.Scan(
		&i.ID,
		&i.Uuid,
		&i.Email,
		&i.Username,
		&i.HashedPassword,
		&i.Salt,
		&i.Avatar,
		&i.Gender,
		&i.DepartmentID,
		&i.RoleID,
		&i.Status,
		&i.ChangePasswordAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}

const listSysUser = `-- name: ListSysUser :many
SELECT id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at FROM sys_user
WHERE status = 0
ORDER BY created_at DESC
`

func (q *Queries) ListSysUser(ctx context.Context) ([]*SysUser, error) {
	rows, err := q.db.Query(ctx, listSysUser)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*SysUser{}
	for rows.Next() {
		var i SysUser
		if err := rows.Scan(
			&i.ID,
			&i.Uuid,
			&i.Email,
			&i.Username,
			&i.HashedPassword,
			&i.Salt,
			&i.Avatar,
			&i.Gender,
			&i.DepartmentID,
			&i.RoleID,
			&i.Status,
			&i.ChangePasswordAt,
			&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 listSysUserByIds = `-- name: ListSysUserByIds :many
SELECT id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at FROM sys_user
WHERE id = ANY($1::int[])
`

func (q *Queries) ListSysUserByIds(ctx context.Context, dollar_1 []int32) ([]*SysUser, error) {
	rows, err := q.db.Query(ctx, listSysUserByIds, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*SysUser{}
	for rows.Next() {
		var i SysUser
		if err := rows.Scan(
			&i.ID,
			&i.Uuid,
			&i.Email,
			&i.Username,
			&i.HashedPassword,
			&i.Salt,
			&i.Avatar,
			&i.Gender,
			&i.DepartmentID,
			&i.RoleID,
			&i.Status,
			&i.ChangePasswordAt,
			&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 listSysUserCondition = `-- name: ListSysUserCondition :many
SELECT id,
       uuid,
       email,
       username,
       avatar,
       gender,
       department_id,
       role_id,
       status,
       change_password_at,
       created_at,
       updated_at,
       COALESCE((SELECT name FROM sys_department WHERE ID = sys_user.department_id), '') AS department_name,
       COALESCE((SELECT display_name
                 FROM sys_role
                 WHERE id = sys_user.role_id), '')                                       AS role_name
FROM sys_user
WHERE (NOT $1::Boolean OR sys_user.status = $2)
    AND (NOT $3::Boolean OR sys_user.id = $4)
    AND ($5::text = '' OR sys_user.username ILIKE '%' || $5 || '%')
    AND ($6::text = '' OR sys_user.email ILIKE '%' || $6 || '%')
ORDER BY created_at DESC
OFFSET $7
LIMIT $8
`

type ListSysUserConditionParams struct {
	IsStatus bool   `json:"is_status"`
	Status   int32  `json:"status"`
	IsID     bool   `json:"is_id"`
	ID       int32  `json:"id"`
	Username string `json:"username"`
	Email    string `json:"email"`
	Skip     int32  `json:"skip"`
	Size     int32  `json:"size"`
}

type ListSysUserConditionRow struct {
	ID               int32       `json:"id"`
	Uuid             uuid.UUID   `json:"uuid"`
	Email            string      `json:"email"`
	Username         string      `json:"username"`
	Avatar           string      `json:"avatar"`
	Gender           int32       `json:"gender"`
	DepartmentID     int32       `json:"department_id"`
	RoleID           int32       `json:"role_id"`
	Status           int32       `json:"status"`
	ChangePasswordAt time.Time   `json:"change_password_at"`
	CreatedAt        time.Time   `json:"created_at"`
	UpdatedAt        time.Time   `json:"updated_at"`
	DepartmentName   interface{} `json:"department_name"`
	RoleName         interface{} `json:"role_name"`
}

func (q *Queries) ListSysUserCondition(ctx context.Context, arg *ListSysUserConditionParams) ([]*ListSysUserConditionRow, error) {
	rows, err := q.db.Query(ctx, listSysUserCondition,
		arg.IsStatus,
		arg.Status,
		arg.IsID,
		arg.ID,
		arg.Username,
		arg.Email,
		arg.Skip,
		arg.Size,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*ListSysUserConditionRow{}
	for rows.Next() {
		var i ListSysUserConditionRow
		if err := rows.Scan(
			&i.ID,
			&i.Uuid,
			&i.Email,
			&i.Username,
			&i.Avatar,
			&i.Gender,
			&i.DepartmentID,
			&i.RoleID,
			&i.Status,
			&i.ChangePasswordAt,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.DepartmentName,
			&i.RoleName,
		); 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 :one
UPDATE sys_user
SET username           = $2,
    hashed_password    = $3,
    avatar             = $4,
    gender             = $5,
    department_id      = $6,
    role_id            = $7,
    status             = $8,
    change_password_at = $9,
    updated_at         = $10
WHERE id = $1
RETURNING id, uuid, email, username, hashed_password, salt, avatar, gender, department_id, role_id, status, change_password_at, created_at, updated_at
`

type UpdateSysUserParams struct {
	ID               int32     `json:"id"`
	Username         string    `json:"username"`
	HashedPassword   []byte    `json:"hashed_password"`
	Avatar           string    `json:"avatar"`
	Gender           int32     `json:"gender"`
	DepartmentID     int32     `json:"department_id"`
	RoleID           int32     `json:"role_id"`
	Status           int32     `json:"status"`
	ChangePasswordAt time.Time `json:"change_password_at"`
	UpdatedAt        time.Time `json:"updated_at"`
}

func (q *Queries) UpdateSysUser(ctx context.Context, arg *UpdateSysUserParams) (*SysUser, error) {
	row := q.db.QueryRow(ctx, updateSysUser,
		arg.ID,
		arg.Username,
		arg.HashedPassword,
		arg.Avatar,
		arg.Gender,
		arg.DepartmentID,
		arg.RoleID,
		arg.Status,
		arg.ChangePasswordAt,
		arg.UpdatedAt,
	)
	var i SysUser
	err := row.Scan(
		&i.ID,
		&i.Uuid,
		&i.Email,
		&i.Username,
		&i.HashedPassword,
		&i.Salt,
		&i.Avatar,
		&i.Gender,
		&i.DepartmentID,
		&i.RoleID,
		&i.Status,
		&i.ChangePasswordAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return &i, err
}