# Visualizar Totais e Relatórios

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.

```kotlin
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`.

```kotlin
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:

```kotlin
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.

```kotlin
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`.

```kotlin
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

```kotlin
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

* [**Histórico de Transações**](): Explore transações específicas detalhadamente.  
* [**Emitir Comprovantes Digitais**](/pt/get-smart/get-smart-sdk/integration-guides/peripherals-and-receipts/issue-digital-receipts): Gerencie cópias de tickets e envios digitais.