# Histórico de Transações

Este guia explica como pesquisar transações anteriores usando o `TransactionRepository`. Esta funcionalidade permite que você recupere listas detalhadas de operações com base em intervalos de datas e critérios específicos, como bandeira do cartão, valor ou status do resultado.

Antes de pesquisar, certifique-se de que o TPV esteja [**inicializado**](/pt/get-smart/get-smart-sdk/integration-guides/payment-operations/initialize-the-tpv).

## Pesquisa Básica por Data

Para recuperar transações, use o método `getTransactions`. Você deve fornecer uma data de início e uma data de término.

<Callout type="note">

O intervalo entre `initDate` e `endDate` não pode exceder **15 dias**.

</Callout>

```kotlin
suspend fun searchTransactions(start: Date, end: Date) {
    val result = transactionRepository.getTransactions(
        initDate = start,
        endDate = end
    )
    handleTransactionResult(result)
}
```

## Filtragem Avançada

Você pode refinar sua pesquisa usando o objeto `TransactionFilter`. Todas as propriedades neste filtro são opcionais, você só precisa definir os critérios que deseja aplicar.

### Propriedades do Filtro

* `operationNumber`: Pesquisa por um ID de transação específico (Int).  
* `type`: Uma lista de OperationType (por exemplo, PAYMENT, REFUND).  
* `result`: O status de OperationResult (por exemplo, AUTHORIZED, DENIED).  
* `lastCardDigits`: Os últimos 4 dígitos do cartão (Int).  
* `rangeAmountMinMax`: Um Pair de objetos Money definindo o valor mínimo e máximo.  
* `cardBrand`: A CardBrand (por exemplo, VISA, MASTERCARD).

### Exemplo: Filtrando por Bandeira do Cartão e Valor

```kotlin
suspend fun searchVisaHighValue(start: Date, end: Date) {
    // Define the filter
    val myFilter = TransactionFilter(
        cardBrand = CardBrand.VISA,
        rangeAmountMinMax = Pair(
            Money(BigDecimal("50.00"), Currency.getInstance("EUR")),
            Money(BigDecimal("500.00"), Currency.getInstance("EUR"))
        ),
        result = OperationResult.AUTHORIZED
    )

    // Execute search
    val result = transactionRepository.getTransactions(
        initDate = start,
        endDate = end,
        filter = myFilter
    )

    handleTransactionResult(result)
}
```

## Paginação e Limites

Para gerenciar grandes conjuntos de dados, use o `TransactionResultsFilter`.

* `maxOperations`: Limita o número de transações retornadas.  
* `offset`: Ignora o número especificado de transações (útil para paginação).

```kotlin
val pagingFilter = TransactionResultsFilter(
    maxOperations = 20,
    offset = 0
)

val result = transactionRepository.getTransactions(
    initDate = start,
    endDate = end,
    resultsFilter = pagingFilter
)
```

## Interpretando o Resultado

O repositório retorna um `RepositoryResult<GetTransactionsResult>`.

A data class `GetTransactionsResult` contém:

* `transactionList`: Uma `List<Transaction>` contendo as operações encontradas.  
* `hasMoreOperations`: Um `Boolean` indicando se há mais transações disponíveis que correspondem aos seus critérios (útil para paginação).

### Lógica de Tratamento

```kotlin
fun handleTransactionResult(result: RepositoryResult<GetTransactionsResult>) {
    when (result) {
        is RepositoryResult.Success -> {
            val searchData = result.data
            val transactions = searchData.transactionList

            if (transactions.isEmpty()) {
                println("No transactions found.")
            } else {
                println("Found ${transactions.size} transactions.")
                transactions.forEach { txn ->
                    println("ID: ${txn.operationInfo.number} - Amount: ${txn.amount}")
                }
            }

            if (searchData.hasMoreOperations) {
                println("⚠️ There are more transactions available. Load next page.")
            }
        }
        is RepositoryResult.ConnectionError -> println("❌ Connection Error")
        is RepositoryResult.ProtocolError -> println("❌ Error: ${result.type}")
        else -> {}
    }
}
```

## Próximos Passos

* [**Emitir Comprovantes Digitais**](/pt/get-smart/get-smart-sdk/integration-guides/peripherals-and-receipts/issue-digital-receipts): Aprenda a recuperar cópias digitais de comprovantes para essas transações.  
* [**Controlar a Impressora do Dispositivo**](/pt/get-smart/get-smart-sdk/integration-guides/peripherals-and-receipts/control-the-device-printer): Controle a impressora para reimprimir comprovantes.