photum/backend/internal/db/generated/usuarios.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: usuarios.sql

package generated

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const createUsuario = `-- name: CreateUsuario :one
INSERT INTO usuarios (email, senha_hash, role, ativo)
VALUES ($1, $2, $3, false)
RETURNING id, email, senha_hash, role, ativo, criado_em, atualizado_em
`

type CreateUsuarioParams struct {
	Email     string `json:"email"`
	SenhaHash string `json:"senha_hash"`
	Role      string `json:"role"`
}

func (q *Queries) CreateUsuario(ctx context.Context, arg CreateUsuarioParams) (Usuario, error) {
	row := q.db.QueryRow(ctx, createUsuario, arg.Email, arg.SenhaHash, arg.Role)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const deleteUsuario = `-- name: DeleteUsuario :exec
DELETE FROM usuarios
WHERE id = $1
`

func (q *Queries) DeleteUsuario(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteUsuario, id)
	return err
}

const getUsuarioByEmail = `-- name: GetUsuarioByEmail :one
SELECT id, email, senha_hash, role, ativo, criado_em, atualizado_em FROM usuarios
WHERE email = $1 LIMIT 1
`

func (q *Queries) GetUsuarioByEmail(ctx context.Context, email string) (Usuario, error) {
	row := q.db.QueryRow(ctx, getUsuarioByEmail, email)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const getUsuarioByID = `-- name: GetUsuarioByID :one
SELECT id, email, senha_hash, role, ativo, criado_em, atualizado_em FROM usuarios
WHERE id = $1 LIMIT 1
`

func (q *Queries) GetUsuarioByID(ctx context.Context, id pgtype.UUID) (Usuario, error) {
	row := q.db.QueryRow(ctx, getUsuarioByID, id)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const listAllUsuarios = `-- name: ListAllUsuarios :many
SELECT id, email, role, ativo, criado_em, atualizado_em
FROM usuarios
ORDER BY criado_em DESC
`

type ListAllUsuariosRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	Role         string             `json:"role"`
	Ativo        bool               `json:"ativo"`
	CriadoEm     pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm pgtype.Timestamptz `json:"atualizado_em"`
}

func (q *Queries) ListAllUsuarios(ctx context.Context) ([]ListAllUsuariosRow, error) {
	rows, err := q.db.Query(ctx, listAllUsuarios)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListAllUsuariosRow
	for rows.Next() {
		var i ListAllUsuariosRow
		if err := rows.Scan(
			&i.ID,
			&i.Email,
			&i.Role,
			&i.Ativo,
			&i.CriadoEm,
			&i.AtualizadoEm,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listUsuariosPending = `-- name: ListUsuariosPending :many
SELECT u.id, u.email, u.role, u.ativo, u.criado_em,
       cp.nome, cp.whatsapp
FROM usuarios u
LEFT JOIN cadastro_profissionais cp ON u.id = cp.usuario_id
WHERE u.ativo = false
ORDER BY u.criado_em DESC
`

type ListUsuariosPendingRow struct {
	ID       pgtype.UUID        `json:"id"`
	Email    string             `json:"email"`
	Role     string             `json:"role"`
	Ativo    bool               `json:"ativo"`
	CriadoEm pgtype.Timestamptz `json:"criado_em"`
	Nome     pgtype.Text        `json:"nome"`
	Whatsapp pgtype.Text        `json:"whatsapp"`
}

func (q *Queries) ListUsuariosPending(ctx context.Context) ([]ListUsuariosPendingRow, error) {
	rows, err := q.db.Query(ctx, listUsuariosPending)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListUsuariosPendingRow
	for rows.Next() {
		var i ListUsuariosPendingRow
		if err := rows.Scan(
			&i.ID,
			&i.Email,
			&i.Role,
			&i.Ativo,
			&i.CriadoEm,
			&i.Nome,
			&i.Whatsapp,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateUsuarioAtivo = `-- name: UpdateUsuarioAtivo :one
UPDATE usuarios
SET ativo = $2, atualizado_em = NOW()
WHERE id = $1
RETURNING id, email, senha_hash, role, ativo, criado_em, atualizado_em
`

type UpdateUsuarioAtivoParams struct {
	ID    pgtype.UUID `json:"id"`
	Ativo bool        `json:"ativo"`
}

func (q *Queries) UpdateUsuarioAtivo(ctx context.Context, arg UpdateUsuarioAtivoParams) (Usuario, error) {
	row := q.db.QueryRow(ctx, updateUsuarioAtivo, arg.ID, arg.Ativo)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const updateUsuarioRole = `-- name: UpdateUsuarioRole :one
UPDATE usuarios
SET role = $2, atualizado_em = NOW()
WHERE id = $1
RETURNING id, email, senha_hash, role, ativo, criado_em, atualizado_em
`

type UpdateUsuarioRoleParams struct {
	ID   pgtype.UUID `json:"id"`
	Role string      `json:"role"`
}

func (q *Queries) UpdateUsuarioRole(ctx context.Context, arg UpdateUsuarioRoleParams) (Usuario, error) {
	row := q.db.QueryRow(ctx, updateUsuarioRole, arg.ID, arg.Role)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}