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

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

package generated

import (
	"context"

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

const createEscala = `-- name: CreateEscala :one
INSERT INTO agenda_escalas (
  agenda_id, profissional_id, data_hora_inicio, data_hora_fim, funcao_especifica
) VALUES (
  $1, $2, $3, $4, $5
)
RETURNING id, agenda_id, profissional_id, data_hora_inicio, data_hora_fim, funcao_especifica, criado_em, atualizado_em
`

type CreateEscalaParams struct {
	AgendaID         pgtype.UUID        `json:"agenda_id"`
	ProfissionalID   pgtype.UUID        `json:"profissional_id"`
	DataHoraInicio   pgtype.Timestamptz `json:"data_hora_inicio"`
	DataHoraFim      pgtype.Timestamptz `json:"data_hora_fim"`
	FuncaoEspecifica pgtype.Text        `json:"funcao_especifica"`
}

func (q *Queries) CreateEscala(ctx context.Context, arg CreateEscalaParams) (AgendaEscala, error) {
	row := q.db.QueryRow(ctx, createEscala,
		arg.AgendaID,
		arg.ProfissionalID,
		arg.DataHoraInicio,
		arg.DataHoraFim,
		arg.FuncaoEspecifica,
	)
	var i AgendaEscala
	err := row.Scan(
		&i.ID,
		&i.AgendaID,
		&i.ProfissionalID,
		&i.DataHoraInicio,
		&i.DataHoraFim,
		&i.FuncaoEspecifica,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const createMapa = `-- name: CreateMapa :one
INSERT INTO mapas_eventos (agenda_id, nome, imagem_url)
VALUES ($1, $2, $3)
RETURNING id, agenda_id, nome, imagem_url, criado_em
`

type CreateMapaParams struct {
	AgendaID  pgtype.UUID `json:"agenda_id"`
	Nome      pgtype.Text `json:"nome"`
	ImagemUrl pgtype.Text `json:"imagem_url"`
}

func (q *Queries) CreateMapa(ctx context.Context, arg CreateMapaParams) (MapasEvento, error) {
	row := q.db.QueryRow(ctx, createMapa, arg.AgendaID, arg.Nome, arg.ImagemUrl)
	var i MapasEvento
	err := row.Scan(
		&i.ID,
		&i.AgendaID,
		&i.Nome,
		&i.ImagemUrl,
		&i.CriadoEm,
	)
	return i, err
}

const deleteEscala = `-- name: DeleteEscala :exec
DELETE FROM agenda_escalas
WHERE id = $1
`

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

const deleteMapa = `-- name: DeleteMapa :exec
DELETE FROM mapas_eventos WHERE id = $1
`

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

const deleteMarcador = `-- name: DeleteMarcador :exec
DELETE FROM marcadores_mapa WHERE id = $1
`

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

const listEscalasByAgendaID = `-- name: ListEscalasByAgendaID :many
SELECT e.id, e.agenda_id, e.profissional_id, e.data_hora_inicio, e.data_hora_fim, e.funcao_especifica, e.criado_em, e.atualizado_em, p.nome as profissional_nome, p.avatar_url, p.whatsapp, f.nome as funcao_nome
FROM agenda_escalas e
JOIN cadastro_profissionais p ON e.profissional_id = p.id
LEFT JOIN funcoes_profissionais f ON p.funcao_profissional_id = f.id
WHERE e.agenda_id = $1
ORDER BY e.data_hora_inicio
`

type ListEscalasByAgendaIDRow struct {
	ID               pgtype.UUID        `json:"id"`
	AgendaID         pgtype.UUID        `json:"agenda_id"`
	ProfissionalID   pgtype.UUID        `json:"profissional_id"`
	DataHoraInicio   pgtype.Timestamptz `json:"data_hora_inicio"`
	DataHoraFim      pgtype.Timestamptz `json:"data_hora_fim"`
	FuncaoEspecifica pgtype.Text        `json:"funcao_especifica"`
	CriadoEm         pgtype.Timestamptz `json:"criado_em"`
	AtualizadoEm     pgtype.Timestamptz `json:"atualizado_em"`
	ProfissionalNome string             `json:"profissional_nome"`
	AvatarUrl        pgtype.Text        `json:"avatar_url"`
	Whatsapp         pgtype.Text        `json:"whatsapp"`
	FuncaoNome       pgtype.Text        `json:"funcao_nome"`
}

func (q *Queries) ListEscalasByAgendaID(ctx context.Context, agendaID pgtype.UUID) ([]ListEscalasByAgendaIDRow, error) {
	rows, err := q.db.Query(ctx, listEscalasByAgendaID, agendaID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListEscalasByAgendaIDRow
	for rows.Next() {
		var i ListEscalasByAgendaIDRow
		if err := rows.Scan(
			&i.ID,
			&i.AgendaID,
			&i.ProfissionalID,
			&i.DataHoraInicio,
			&i.DataHoraFim,
			&i.FuncaoEspecifica,
			&i.CriadoEm,
			&i.AtualizadoEm,
			&i.ProfissionalNome,
			&i.AvatarUrl,
			&i.Whatsapp,
			&i.FuncaoNome,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMapasByAgendaID = `-- name: ListMapasByAgendaID :many
SELECT id, agenda_id, nome, imagem_url, criado_em FROM mapas_eventos
WHERE agenda_id = $1
ORDER BY criado_em
`

func (q *Queries) ListMapasByAgendaID(ctx context.Context, agendaID pgtype.UUID) ([]MapasEvento, error) {
	rows, err := q.db.Query(ctx, listMapasByAgendaID, agendaID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []MapasEvento
	for rows.Next() {
		var i MapasEvento
		if err := rows.Scan(
			&i.ID,
			&i.AgendaID,
			&i.Nome,
			&i.ImagemUrl,
			&i.CriadoEm,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMarcadoresByMapaID = `-- name: ListMarcadoresByMapaID :many
SELECT m.id, m.mapa_id, m.profissional_id, m.pos_x, m.pos_y, m.rotulo, m.criado_em, p.nome as profissional_nome, p.avatar_url, f.nome as funcao_nome
FROM marcadores_mapa m
LEFT JOIN cadastro_profissionais p ON m.profissional_id = p.id
LEFT JOIN funcoes_profissionais f ON p.funcao_profissional_id = f.id
WHERE m.mapa_id = $1
`

type ListMarcadoresByMapaIDRow struct {
	ID               pgtype.UUID        `json:"id"`
	MapaID           pgtype.UUID        `json:"mapa_id"`
	ProfissionalID   pgtype.UUID        `json:"profissional_id"`
	PosX             pgtype.Numeric     `json:"pos_x"`
	PosY             pgtype.Numeric     `json:"pos_y"`
	Rotulo           pgtype.Text        `json:"rotulo"`
	CriadoEm         pgtype.Timestamptz `json:"criado_em"`
	ProfissionalNome pgtype.Text        `json:"profissional_nome"`
	AvatarUrl        pgtype.Text        `json:"avatar_url"`
	FuncaoNome       pgtype.Text        `json:"funcao_nome"`
}

func (q *Queries) ListMarcadoresByMapaID(ctx context.Context, mapaID pgtype.UUID) ([]ListMarcadoresByMapaIDRow, error) {
	rows, err := q.db.Query(ctx, listMarcadoresByMapaID, mapaID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListMarcadoresByMapaIDRow
	for rows.Next() {
		var i ListMarcadoresByMapaIDRow
		if err := rows.Scan(
			&i.ID,
			&i.MapaID,
			&i.ProfissionalID,
			&i.PosX,
			&i.PosY,
			&i.Rotulo,
			&i.CriadoEm,
			&i.ProfissionalNome,
			&i.AvatarUrl,
			&i.FuncaoNome,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateEscala = `-- name: UpdateEscala :one
UPDATE agenda_escalas
SET profissional_id = COALESCE($2, profissional_id),
    data_hora_inicio = COALESCE($3, data_hora_inicio),
    data_hora_fim = COALESCE($4, data_hora_fim),
    funcao_especifica = COALESCE($5, funcao_especifica),
    atualizado_em = NOW()
WHERE id = $1
RETURNING id, agenda_id, profissional_id, data_hora_inicio, data_hora_fim, funcao_especifica, criado_em, atualizado_em
`

type UpdateEscalaParams struct {
	ID               pgtype.UUID        `json:"id"`
	ProfissionalID   pgtype.UUID        `json:"profissional_id"`
	DataHoraInicio   pgtype.Timestamptz `json:"data_hora_inicio"`
	DataHoraFim      pgtype.Timestamptz `json:"data_hora_fim"`
	FuncaoEspecifica pgtype.Text        `json:"funcao_especifica"`
}

func (q *Queries) UpdateEscala(ctx context.Context, arg UpdateEscalaParams) (AgendaEscala, error) {
	row := q.db.QueryRow(ctx, updateEscala,
		arg.ID,
		arg.ProfissionalID,
		arg.DataHoraInicio,
		arg.DataHoraFim,
		arg.FuncaoEspecifica,
	)
	var i AgendaEscala
	err := row.Scan(
		&i.ID,
		&i.AgendaID,
		&i.ProfissionalID,
		&i.DataHoraInicio,
		&i.DataHoraFim,
		&i.FuncaoEspecifica,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const upsertMarcador = `-- name: UpsertMarcador :one
INSERT INTO marcadores_mapa (mapa_id, profissional_id, pos_x, pos_y, rotulo)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (id) DO UPDATE
SET pos_x = EXCLUDED.pos_x,
    pos_y = EXCLUDED.pos_y,
    rotulo = EXCLUDED.rotulo,
    profissional_id = EXCLUDED.profissional_id
RETURNING id, mapa_id, profissional_id, pos_x, pos_y, rotulo, criado_em
`

type UpsertMarcadorParams struct {
	MapaID         pgtype.UUID    `json:"mapa_id"`
	ProfissionalID pgtype.UUID    `json:"profissional_id"`
	PosX           pgtype.Numeric `json:"pos_x"`
	PosY           pgtype.Numeric `json:"pos_y"`
	Rotulo         pgtype.Text    `json:"rotulo"`
}

func (q *Queries) UpsertMarcador(ctx context.Context, arg UpsertMarcadorParams) (MarcadoresMapa, error) {
	row := q.db.QueryRow(ctx, upsertMarcador,
		arg.MapaID,
		arg.ProfissionalID,
		arg.PosX,
		arg.PosY,
		arg.Rotulo,
	)
	var i MarcadoresMapa
	err := row.Scan(
		&i.ID,
		&i.MapaID,
		&i.ProfissionalID,
		&i.PosX,
		&i.PosY,
		&i.Rotulo,
		&i.CriadoEm,
	)
	return i, err
}