# Visualizar totales e informes

Esta guía explica cómo recuperar los totales acumulados de las transacciones utilizando el `TotalsRepository`. Esta función es esencial para la conciliación, permitiéndote ver resúmenes de ventas, devoluciones y recuentos de operaciones para periodos específicos.

Puedes consultar los totales por **Sesión** (periodos definidos por la liquidación del host) o por **Turno** (periodos definidos localmente por tu operativa).

## 1. Consulta por sesión

Las sesiones son periodos que suelen cerrarse mediante la operación `closeSession`. Puedes recuperar los totales de fechas o intervalos específicos.

**Repositorio**: `TotalsRepository`

### Obtener sesiones de un día específico

Utiliza `getSessions` para recuperar todos los totales de las sesiones de una fecha determinada.

```kotlin
suspend fun getDailyTotals(date: Date) {
    val result = totalsRepository.getSessions(
        date = date,
        wantBrandDetails = true // Include breakdown by card brand (Visa, MC, etc.)
    )
    handleTotalsResult(result)
}
```

### Obtener una sesión específica

Si conoces el ID de la sesión (p. ej., por un recibo impreso), puedes consultarla directamente. Ten en cuenta que `sessionId` es un `Int`.

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

---

### Obtener sesiones entre fechas

Para obtener un informe de un rango de fechas.

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

### Obtener la última sesión

Recupera la última sesión cerrada.

<Callout type="note">

Este método devuelve un envoltorio GetLastSessionResult, a diferencia de los demás.

</Callout>

```kotlin
suspend fun getLastSessionTotal() {
    val result = totalsRepository.getLastSession()
    // Returns GetLastSessionResult instead of TotalsResult
}
```

## 2. Consulta por turno

Los turnos son periodos de trabajo locales definidos por las llamadas a `openShift`.

**Repositorio**: `TotalsRepository`

### Obtener turnos de un día específico

Recupera todos los turnos abiertos en una fecha concreta.

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

---

### Obtener un turno específico

Consulta un turno por su ID único. Ten en cuenta que `shiftId` es un `String`.

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

### Obtener turnos entre fechas

Recupera los turnos de un rango de fechas específico.

```kotlin
suspend fun getWeeklyShiftTotals(startDate: Date, endDate: Date) {
    val result = totalsRepository.getShiftsBetweenDates(
        initDate = startDate,
        endDate = endDate,
        wantBrandDetails = true
    )
    handleTotalsResult(result)
}
```

## Interpretar TotalsResult

La mayoría de los métodos devuelven un `RepositoryResult<TotalsResult>`. `TotalsResult` es una interfaz sellada con tres estados:

### 1. Datos recibidos (`TotalsResult.IncomingData`)

Los totales se han encontrado correctamente.
* **Datos**: Contiene un `TotalsModel` con el resumen (importe total, recuento de operaciones, moneda, etc.).

### 2. Datos vacíos (`TotalsResult.EmptyData`)

No se han encontrado totales para los criterios especificados.

### 3. Identificador erróneo (`TotalsResult.WrongIdentifierError`)

El ID de sesión o de turno proporcionado es incorrecto.

### Ejemplo de lógica de gestión

```kotlin
fun handleTotalsResult(result: RepositoryResult<TotalsResult>) {
    when (result) {
        is RepositoryResult.Success -> {
            when (val totalsOutcome = result.data) {
                is TotalsResult.IncomingData -> {
                    val data = totalsOutcome.data
                    println("✅ Totals Found for Merchant: ${data.merchantName}")
                    println("Total Sale Amount: ${data.salesTotal}")
                    println("Total Refund Amount: ${data.refundsTotal}")
                }
                is TotalsResult.EmptyData -> {
                    println("⚠️ No data found for this period.")
                }
                is TotalsResult.WrongIdentifierError -> {
                    println("❌ Error: Invalid Session/Shift ID.")
                }
            }
        }
        is RepositoryResult.ConnectionError -> println("❌ Connection Error")
        is RepositoryResult.ProtocolError -> println("❌ Error: ${result.type}")
        else -> {}
    }
}
```

## Próximos pasos

* [**Emitir Recibos Digitales**](/es/get-smart/get-smart-sdk/integration-guides/peripherals-and-receipts/issue-digital-receipts): Gestiona copias de tickets y envíos electrónicos.