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 createCadastroCliente = `-- name: CreateCadastroCliente :one
INSERT INTO cadastro_clientes (usuario_id, empresa_id, nome, telefone)
VALUES ($1, $2, $3, $4)
RETURNING id, usuario_id, empresa_id, nome, telefone, criado_em, atualizado_em
`

type CreateCadastroClienteParams struct {
	UsuarioID pgtype.UUID `json:"usuario_id"`
	EmpresaID pgtype.UUID `json:"empresa_id"`
	Nome      pgtype.Text `json:"nome"`
	Telefone  pgtype.Text `json:"telefone"`
}

func (q *Queries) CreateCadastroCliente(ctx context.Context, arg CreateCadastroClienteParams) (CadastroCliente, error) {
	row := q.db.QueryRow(ctx, createCadastroCliente,
		arg.UsuarioID,
		arg.EmpresaID,
		arg.Nome,
		arg.Telefone,
	)
	var i CadastroCliente
	err := row.Scan(
		&i.ID,
		&i.UsuarioID,
		&i.EmpresaID,
		&i.Nome,
		&i.Telefone,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

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 u.id, u.email, u.senha_hash, u.role, u.ativo, u.criado_em, u.atualizado_em,
       COALESCE(cp.nome, cc.nome, '') as nome,
       COALESCE(cp.whatsapp, cc.telefone, '') as whatsapp,
       e.id as empresa_id,
       e.nome as empresa_nome
FROM usuarios u
LEFT JOIN cadastro_profissionais cp ON u.id = cp.usuario_id
LEFT JOIN cadastro_clientes cc ON u.id = cc.usuario_id
LEFT JOIN empresas e ON cc.empresa_id = e.id
WHERE u.email = $1 LIMIT 1
`

type GetUsuarioByEmailRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	SenhaHash    string             `json:"senha_hash"`
	Role         string             `json:"role"`
	Ativo        bool               `json:"ativo"`
	CriadoEm     pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm pgtype.Timestamptz `json:"atualizado_em"`
	Nome         string             `json:"nome"`
	Whatsapp     string             `json:"whatsapp"`
	EmpresaID    pgtype.UUID        `json:"empresa_id"`
	EmpresaNome  pgtype.Text        `json:"empresa_nome"`
}

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

const getUsuarioByID = `-- name: GetUsuarioByID :one
SELECT u.id, u.email, u.senha_hash, u.role, u.ativo, u.criado_em, u.atualizado_em,
       COALESCE(cp.nome, cc.nome, '') as nome,
       COALESCE(cp.whatsapp, cc.telefone, '') as whatsapp,
       e.id as empresa_id,
       e.nome as empresa_nome
FROM usuarios u
LEFT JOIN cadastro_profissionais cp ON u.id = cp.usuario_id
LEFT JOIN cadastro_clientes cc ON u.id = cc.usuario_id
LEFT JOIN empresas e ON cc.empresa_id = e.id
WHERE u.id = $1 LIMIT 1
`

type GetUsuarioByIDRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	SenhaHash    string             `json:"senha_hash"`
	Role         string             `json:"role"`
	Ativo        bool               `json:"ativo"`
	CriadoEm     pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm pgtype.Timestamptz `json:"atualizado_em"`
	Nome         string             `json:"nome"`
	Whatsapp     string             `json:"whatsapp"`
	EmpresaID    pgtype.UUID        `json:"empresa_id"`
	EmpresaNome  pgtype.Text        `json:"empresa_nome"`
}

func (q *Queries) GetUsuarioByID(ctx context.Context, id pgtype.UUID) (GetUsuarioByIDRow, error) {
	row := q.db.QueryRow(ctx, getUsuarioByID, id)
	var i GetUsuarioByIDRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.Nome,
		&i.Whatsapp,
		&i.EmpresaID,
		&i.EmpresaNome,
	)
	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,
       COALESCE(cp.nome, cc.nome, '') as nome,
       COALESCE(cp.whatsapp, cc.telefone, '') as whatsapp,
       e.id as empresa_id,
       e.nome as empresa_nome
FROM usuarios u
LEFT JOIN cadastro_profissionais cp ON u.id = cp.usuario_id
LEFT JOIN cadastro_clientes cc ON u.id = cc.usuario_id
LEFT JOIN empresas e ON cc.empresa_id = e.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        string             `json:"nome"`
	Whatsapp    string             `json:"whatsapp"`
	EmpresaID   pgtype.UUID        `json:"empresa_id"`
	EmpresaNome pgtype.Text        `json:"empresa_nome"`
}

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,
			&i.EmpresaID,
			&i.EmpresaNome,
		); 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
}