Getnet DocsGetnet Docs

Visualizar Totais e Relatórios

View as MarkdownView this page as plain textOpen in ChatGPTAsk questions about this pageOpen in ClaudeAsk questions about this pageOpen in PerplexityAsk questions about this page
Connect to CursorUse these docs in CursorConnect to VS CodeUse these docs in VS Code

Este guia explica como recuperar totais acumulados de transações utilizando o TotalsRepository. Este recurso é essencial para a conciliação bancária, permitindo visualizar resumos de vendas, estornos e contagens de operações para períodos específicos.

Você pode consultar os totais por Sessão (períodos definidos pela liquidação no host) ou por Turno (períodos operacionais definidos localmente pela sua aplicação).

1. Consulta por Sessão

As sessões são períodos geralmente encerrados pela operação closeSession. Você pode recuperar totais para datas específicas ou intervalos.

Repositório: TotalsRepository

Obter Sessões de um Dia Específico

Use getSessions para recuperar todos os totais de sessão para uma determinada data.

suspend fun obterTotaisDiarios(date: Date) {
    val result = totalsRepository.getSessions(
        date = date,
        wantBrandDetails = true // Inclui detalhamento por bandeira (Visa, MC, etc.)
    )
    handleTotalsResult(result)
}

Obter uma Sessão Específica

Se você souber o ID da Sessão (ex: a partir de um comprovante impresso), pode consultá-la diretamente. Note que o sessionId é um Int.

suspend fun obterTotalSessaoEspecifica(date: Date, sessionId: Int) {
    val result = totalsRepository.getSession(
        date = date,
        sessionId = sessionId,
        wantBrandDetails = true
    )
    handleTotalsResult(result)
}

Obter Sessões Entre Datas

Para gerar um relatório sobre um intervalo de tempo:

suspend fun obterTotaisSemanais(startDate: Date, endDate: Date) {
    val result = totalsRepository.getSessionsBetweenDates(
        initDate = startDate,
        endDate = endDate,
        wantBrandDetails = true
    )
    handleTotalsResult(result)
}

2. Consulta por Turno

Os turnos são períodos de trabalho locais definidos pelas chamadas de openShift.

Repositório: TotalsRepository

Obter Turnos de um Dia Específico

Recupera todos os turnos abertos em uma data específica.

suspend fun obterTotaisTurnoDiario(date: Date) {
    val result = totalsRepository.getShifts(
        date = date,
        wantBrandDetails = true
    )
    handleTotalsResult(result)
}

Obter um Turno Específico

Consulte um turno pelo seu ID exclusivo. Note que o shiftId é uma String.

suspend fun obterTotalTurno(date: Date, shiftId: String) {
    val result = totalsRepository.getShift(
        date = date,
        shiftId = shiftId,
        wantBrandDetails = true
    )
    handleTotalsResult(result)
}

Interpretando o TotalsResult

A maioria dos métodos retorna um RepositoryResult<TotalsResult>. O TotalsResult é uma interface selada com três estados:

1. Dados Recebidos (TotalsResult.IncomingData)

Os totais foram encontrados com sucesso.

  • Dados: Contém um TotalsModel com o resumo (valor total, contagem de operações, moeda, etc.).

2. Dados Vazios (TotalsResult.EmptyData)

Nenhum total foi encontrado para os critérios especificados (ex: nenhuma sessão naquela data).

3. Identificador Incorreto (TotalsResult.WrongIdentifierError)

O ID da Sessão ou do Turno fornecido está incorreto.

Exemplo de Lógica de Tratamento

fun handleTotalsResult(result: RepositoryResult<TotalsResult>) {
    when (result) {
        is RepositoryResult.Success -> {
            when (val totalsOutcome = result.data) {
                is TotalsResult.IncomingData -> {
                    val data = totalsOutcome.data
                    println("✅ Totais encontrados para: ${data.merchantName}")
                    println("Total de Vendas: ${data.salesTotal}")
                    println("Total de Estornos: ${data.refundsTotal}")
                }
                is TotalsResult.EmptyData -> {
                    println("⚠️ Nenhum dado encontrado para este período.")
                }
                is TotalsResult.WrongIdentifierError -> {
                    println("❌ Erro: ID de Sessão/Turno inválido.")
                }
            }
        }
        is RepositoryResult.ConnectionError -> println("❌ Erro de Conexão")
        is RepositoryResult.ProtocolError -> println("❌ Erro: ${result.type}")
        else -> {}
    }
}

Próximos Passos