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, tipo_profissional, ativo)
VALUES ($1, $2, $3, $4, $5)
RETURNING id, email, senha_hash, role, tipo_profissional, ativo, criado_em, atualizado_em, regioes_permitidas
`

type CreateUsuarioParams struct {
	Email            string      `json:"email"`
	SenhaHash        string      `json:"senha_hash"`
	Role             string      `json:"role"`
	TipoProfissional pgtype.Text `json:"tipo_profissional"`
	Ativo            bool        `json:"ativo"`
}

func (q *Queries) CreateUsuario(ctx context.Context, arg CreateUsuarioParams) (Usuario, error) {
	row := q.db.QueryRow(ctx, createUsuario,
		arg.Email,
		arg.SenhaHash,
		arg.Role,
		arg.TipoProfissional,
		arg.Ativo,
	)
	var i Usuario
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.SenhaHash,
		&i.Role,
		&i.TipoProfissional,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.RegioesPermitidas,
	)
	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.tipo_profissional, u.ativo, u.criado_em, u.atualizado_em, u.regioes_permitidas,
       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"`
	TipoProfissional  pgtype.Text        `json:"tipo_profissional"`
	Ativo             bool               `json:"ativo"`
	CriadoEm          pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm      pgtype.Timestamptz `json:"atualizado_em"`
	RegioesPermitidas []string           `json:"regioes_permitidas"`
	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.TipoProfissional,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.RegioesPermitidas,
		&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.tipo_profissional, u.ativo, u.criado_em, u.atualizado_em, u.regioes_permitidas,
       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"`
	TipoProfissional  pgtype.Text        `json:"tipo_profissional"`
	Ativo             bool               `json:"ativo"`
	CriadoEm          pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm      pgtype.Timestamptz `json:"atualizado_em"`
	RegioesPermitidas []string           `json:"regioes_permitidas"`
	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.TipoProfissional,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.RegioesPermitidas,
		&i.Nome,
		&i.Whatsapp,
		&i.EmpresaID,
		&i.EmpresaNome,
	)
	return i, err
}

const listAllUsuarios = `-- name: ListAllUsuarios :many
SELECT u.id, u.email, u.role, u.tipo_profissional, u.ativo, u.criado_em, u.atualizado_em, u.regioes_permitidas,
       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
ORDER BY u.criado_em DESC
`

type ListAllUsuariosRow struct {
	ID                pgtype.UUID        `json:"id"`
	Email             string             `json:"email"`
	Role              string             `json:"role"`
	TipoProfissional  pgtype.Text        `json:"tipo_profissional"`
	Ativo             bool               `json:"ativo"`
	CriadoEm          pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm      pgtype.Timestamptz `json:"atualizado_em"`
	RegioesPermitidas []string           `json:"regioes_permitidas"`
	Nome              string             `json:"nome"`
	Whatsapp          string             `json:"whatsapp"`
	EmpresaID         pgtype.UUID        `json:"empresa_id"`
	EmpresaNome       pgtype.Text        `json:"empresa_nome"`
}

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.TipoProfissional,
			&i.Ativo,
			&i.CriadoEm,
			&i.AtualizadoEm,
			&i.RegioesPermitidas,
			&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 listUsuariosPending = `-- name: ListUsuariosPending :many
SELECT u.id, u.email, u.role, u.tipo_profissional, u.ativo, u.criado_em, u.regioes_permitidas,
       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
  AND $1::text = ANY(u.regioes_permitidas)
ORDER BY u.criado_em DESC
`

type ListUsuariosPendingRow struct {
	ID                pgtype.UUID        `json:"id"`
	Email             string             `json:"email"`
	Role              string             `json:"role"`
	TipoProfissional  pgtype.Text        `json:"tipo_profissional"`
	Ativo             bool               `json:"ativo"`
	CriadoEm          pgtype.Timestamptz `json:"criado_em"`
	RegioesPermitidas []string           `json:"regioes_permitidas"`
	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, dollar_1 string) ([]ListUsuariosPendingRow, error) {
	rows, err := q.db.Query(ctx, listUsuariosPending, dollar_1)
	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.TipoProfissional,
			&i.Ativo,
			&i.CriadoEm,
			&i.RegioesPermitidas,
			&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, tipo_profissional, ativo, criado_em, atualizado_em, regioes_permitidas
`

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.TipoProfissional,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.RegioesPermitidas,
	)
	return i, err
}

const updateUsuarioRegions = `-- name: UpdateUsuarioRegions :exec
UPDATE usuarios
SET regioes_permitidas = $2, atualizado_em = NOW()
WHERE id = $1
`

type UpdateUsuarioRegionsParams struct {
	ID                pgtype.UUID `json:"id"`
	RegioesPermitidas []string    `json:"regioes_permitidas"`
}

func (q *Queries) UpdateUsuarioRegions(ctx context.Context, arg UpdateUsuarioRegionsParams) error {
	_, err := q.db.Exec(ctx, updateUsuarioRegions, arg.ID, arg.RegioesPermitidas)
	return err
}

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

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.TipoProfissional,
		&i.Ativo,
		&i.CriadoEm,
		&i.AtualizadoEm,
		&i.RegioesPermitidas,
	)
	return i, err
}

const updateUsuarioSenha = `-- name: UpdateUsuarioSenha :exec
UPDATE usuarios
SET senha_hash = $2, atualizado_em = NOW()
WHERE id = $1
`

type UpdateUsuarioSenhaParams struct {
	ID        pgtype.UUID `json:"id"`
	SenhaHash string      `json:"senha_hash"`
}

func (q *Queries) UpdateUsuarioSenha(ctx context.Context, arg UpdateUsuarioSenhaParams) error {
	_, err := q.db.Exec(ctx, updateUsuarioSenha, arg.ID, arg.SenhaHash)
	return err
}