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

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

package generated

import (
	"context"

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

const createConviteDiario = `-- name: CreateConviteDiario :one
INSERT INTO convites_diarios (
    profissional_id, data, status, regiao
) VALUES (
    $1, $2, $3, $4
)
RETURNING id, profissional_id, data, status, motivo_rejeicao, regiao, criado_em, atualizado_em
`

type CreateConviteDiarioParams struct {
	ProfissionalID pgtype.UUID `json:"profissional_id"`
	Data           pgtype.Date `json:"data"`
	Status         pgtype.Text `json:"status"`
	Regiao         pgtype.Text `json:"regiao"`
}

func (q *Queries) CreateConviteDiario(ctx context.Context, arg CreateConviteDiarioParams) (ConvitesDiario, error) {
	row := q.db.QueryRow(ctx, createConviteDiario,
		arg.ProfissionalID,
		arg.Data,
		arg.Status,
		arg.Regiao,
	)
	var i ConvitesDiario
	err := row.Scan(
		&i.ID,
		&i.ProfissionalID,
		&i.Data,
		&i.Status,
		&i.MotivoRejeicao,
		&i.Regiao,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const deleteConvite = `-- name: DeleteConvite :exec
DELETE FROM convites_diarios
WHERE id = $1
`

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

const getConviteByProfissionalAndDate = `-- name: GetConviteByProfissionalAndDate :one
SELECT id, profissional_id, data, status, motivo_rejeicao, regiao, criado_em, atualizado_em FROM convites_diarios
WHERE profissional_id = $1 AND data = $2
`

type GetConviteByProfissionalAndDateParams struct {
	ProfissionalID pgtype.UUID `json:"profissional_id"`
	Data           pgtype.Date `json:"data"`
}

func (q *Queries) GetConviteByProfissionalAndDate(ctx context.Context, arg GetConviteByProfissionalAndDateParams) (ConvitesDiario, error) {
	row := q.db.QueryRow(ctx, getConviteByProfissionalAndDate, arg.ProfissionalID, arg.Data)
	var i ConvitesDiario
	err := row.Scan(
		&i.ID,
		&i.ProfissionalID,
		&i.Data,
		&i.Status,
		&i.MotivoRejeicao,
		&i.Regiao,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}

const getConvitesByDateAndRegion = `-- name: GetConvitesByDateAndRegion :many
SELECT id, profissional_id, data, status, motivo_rejeicao, regiao, criado_em, atualizado_em FROM convites_diarios
WHERE data = $1 AND regiao = $2
`

type GetConvitesByDateAndRegionParams struct {
	Data   pgtype.Date `json:"data"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) GetConvitesByDateAndRegion(ctx context.Context, arg GetConvitesByDateAndRegionParams) ([]ConvitesDiario, error) {
	rows, err := q.db.Query(ctx, getConvitesByDateAndRegion, arg.Data, arg.Regiao)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ConvitesDiario
	for rows.Next() {
		var i ConvitesDiario
		if err := rows.Scan(
			&i.ID,
			&i.ProfissionalID,
			&i.Data,
			&i.Status,
			&i.MotivoRejeicao,
			&i.Regiao,
			&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 getConvitesByProfissional = `-- name: GetConvitesByProfissional :many
SELECT id, profissional_id, data, status, motivo_rejeicao, regiao, criado_em, atualizado_em FROM convites_diarios
WHERE profissional_id = $1
ORDER BY data ASC
`

func (q *Queries) GetConvitesByProfissional(ctx context.Context, profissionalID pgtype.UUID) ([]ConvitesDiario, error) {
	rows, err := q.db.Query(ctx, getConvitesByProfissional, profissionalID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ConvitesDiario
	for rows.Next() {
		var i ConvitesDiario
		if err := rows.Scan(
			&i.ID,
			&i.ProfissionalID,
			&i.Data,
			&i.Status,
			&i.MotivoRejeicao,
			&i.Regiao,
			&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 updateConviteStatus = `-- name: UpdateConviteStatus :one
UPDATE convites_diarios
SET status = $2, motivo_rejeicao = $3, atualizado_em = NOW()
WHERE id = $1
RETURNING id, profissional_id, data, status, motivo_rejeicao, regiao, criado_em, atualizado_em
`

type UpdateConviteStatusParams struct {
	ID             pgtype.UUID `json:"id"`
	Status         pgtype.Text `json:"status"`
	MotivoRejeicao pgtype.Text `json:"motivo_rejeicao"`
}

func (q *Queries) UpdateConviteStatus(ctx context.Context, arg UpdateConviteStatusParams) (ConvitesDiario, error) {
	row := q.db.QueryRow(ctx, updateConviteStatus, arg.ID, arg.Status, arg.MotivoRejeicao)
	var i ConvitesDiario
	err := row.Scan(
		&i.ID,
		&i.ProfissionalID,
		&i.Data,
		&i.Status,
		&i.MotivoRejeicao,
		&i.Regiao,
		&i.CriadoEm,
		&i.AtualizadoEm,
	)
	return i, err
}