Imports System
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks
Imports System.Collections.Generic
Imports System.Web

Public Class TransactionClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String = "https://your-api-domain.com"
    Private ReadOnly _bearerToken As String

    Public Sub New(bearerToken As String)
        _bearerToken = bearerToken
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)
        _httpClient.DefaultRequestHeaders.Authorization =
            New AuthenticationHeaderValue("Bearer", _bearerToken)
        _httpClient.DefaultRequestHeaders.Accept.Add(
            New MediaTypeWithQualityHeaderValue("application/json"))
    End Sub

    Public Async Function SearchTransactionsAsync(
        merchantId As String,
        Optional filters As Dictionary(Of String, String) = Nothing) As Task(Of String)

        Try
            ' Build query string from filters
            Dim queryParams = HttpUtility.ParseQueryString(String.Empty)
            If filters IsNot Nothing Then
                For Each filter In filters
                    queryParams(filter.Key) = filter.Value
                Next
            End If

            Dim queryString As String = queryParams.ToString()
            Dim endpoint As String = $"/v1/rest/merchants/{merchantId}/transactions"
            If Not String.IsNullOrEmpty(queryString) Then
                endpoint &= $"?{queryString}"
            End If

            Dim response As HttpResponseMessage = Await _httpClient.GetAsync(endpoint)
            response.EnsureSuccessStatusCode()

            Return Await response.Content.ReadAsStringAsync()
        Catch e As HttpRequestException
            Console.WriteLine($"Request error: {e.Message}")
            Throw
        End Try
    End Function
End Class

' Example usage: Search by date range
Dim client As New TransactionClient("your-bearer-token-here")
Dim filters As New Dictionary(Of String, String) From {
    {"transactiondate", "2026-01-01T00:00:00Z"},
    {"transactionenddate", "2026-01-31T23:59:59Z"},
    {"minimumamount", "10.00"}
}

Dim transactions As String = Await client.SearchTransactionsAsync("12345678901", filters)
Console.WriteLine(transactions)

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.stream.Collectors;

public class TransactionClient {
    private final String baseUrl;
    private final String bearerToken;
    private final HttpClient httpClient;

    public TransactionClient(String baseUrl, String bearerToken) {
        this.baseUrl = baseUrl;
        this.bearerToken = bearerToken;
        this.httpClient = HttpClient.newHttpClient();
    }

    public String searchTransactions(String merchantId, Map<String, String> filters)
            throws IOException, InterruptedException {

        // Build query string from filters
        String queryString = "";
        if (filters != null && !filters.isEmpty()) {
            queryString = "?" + filters.entrySet().stream()
                .map(entry -> URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8) +
                             "=" + URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8))
                .collect(Collectors.joining("&"));
        }

        String endpoint = baseUrl + "/v1/rest/merchants/" + merchantId +
                         "/transactions" + queryString;

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .header("Authorization", "Bearer " + bearerToken)
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = httpClient.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() != 200) {
            throw new IOException("HTTP Error: " + response.statusCode());
        }

        return response.body();
    }
}

// Example usage: Search by date range
TransactionClient client = new TransactionClient(
    "https://your-api-domain.com",
    "your-bearer-token-here"
);

Map<String, String> filters = new HashMap<>();
filters.put("transactiondate", "2026-01-01T00:00:00Z");
filters.put("transactionenddate", "2026-01-31T23:59:59Z");
filters.put("minimumamount", "10.00");

String transactions = client.searchTransactions("12345678901", filters);
System.out.println(transactions);

require 'net/http'
require 'uri'
require 'json'
require 'cgi'

class TransactionClient
  def initialize(base_url, bearer_token)
    @base_url = base_url
    @bearer_token = bearer_token
  end

  def search_transactions(merchant_id, filters = {})
    # Build query string from filters
    query_string = ''
    unless filters.empty?
      query_params = filters.map do |key, value|
        "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
      end.join('&')
      query_string = "?#{query_params}"
    end

    endpoint = "#{@base_url}/v1/rest/merchants/#{merchant_id}/transactions#{query_string}"
    uri = URI.parse(endpoint)

    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Authorization'] = "Bearer #{@bearer_token}"
    request['Accept'] = 'application/json'

    response = http.request(request)

    if response.code.to_i != 200
      raise "HTTP Error: #{response.code} - #{response.body}"
    end

    response.body
  end
end

# Example usage: Search by date range
client = TransactionClient.new(
  'https://your-api-domain.com',
  'your-bearer-token-here'
)

filters = {
  transactiondate: '2026-01-01T00:00:00Z',
  transactionenddate: '2026-01-31T23:59:59Z',
  minimumamount: '10.00'
}

transactions = client.search_transactions('12345678901', filters)
puts transactions

Imports System
Imports System.Collections.Generic
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text.Json
Imports System.Threading.Tasks
Imports System.Web

Public Class PaginationMeta
    Public Property HasNextPage As Boolean
    Public Property NextCursor As String
End Class

Public Class PaginatedTransactionResult
    Public Property Data As List(Of Dictionary(Of String, Object))
    Public Property Pagination As PaginationMeta
End Class

Public Class TransactionClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String = "https://your-api-domain.com"

    Public Sub New(bearerToken As String)
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)
        _httpClient.DefaultRequestHeaders.Authorization =
            New AuthenticationHeaderValue("Bearer", bearerToken)
        _httpClient.DefaultRequestHeaders.Accept.Add(
            New MediaTypeWithQualityHeaderValue("application/json"))
    End Sub

    Public Async Function FetchAllTransactionsAsync(
        merchantId As String,
        filters As Dictionary(Of String, String),
        Optional pageSize As Integer = 100) As Task(Of List(Of Dictionary(Of String, Object)))

        Dim allTransactions As New List(Of Dictionary(Of String, Object))
        Dim cursor As String = Nothing

        Do
            Dim queryParams = HttpUtility.ParseQueryString(String.Empty)
            For Each kv In filters
                queryParams(kv.Key) = kv.Value
            Next
            queryParams("pagesize") = pageSize.ToString()
            If cursor IsNot Nothing Then
                queryParams("pagecursor") = cursor
            End If

            Dim url As String = $"/v1/rest/merchants/{merchantId}/transactions?{queryParams}"
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync(url)
            response.EnsureSuccessStatusCode()

            Dim json As String = Await response.Content.ReadAsStringAsync()
            Dim options As New JsonSerializerOptions With {.PropertyNameCaseInsensitive = True}
            Dim page = JsonSerializer.Deserialize(Of PaginatedTransactionResult)(json, options)

            allTransactions.AddRange(page.Data)
            cursor = If(page.Pagination?.HasNextPage = True, page.Pagination.NextCursor, Nothing)

        Loop While cursor IsNot Nothing

        Return allTransactions
    End Function
End Class

' Usage
Dim client As New TransactionClient("your-bearer-token-here")
Dim filters As New Dictionary(Of String, String) From {
    {"transactiondate", "2026-01-01T00:00:00Z"},
    {"transactionenddate", "2026-01-31T23:59:59Z"}
}

Dim allTransactions = Await client.FetchAllTransactionsAsync("12345678901", filters, pageSize:=100)
Console.WriteLine($"Total transactions: {allTransactions.Count}")

// Maven:  com.fasterxml.jackson.core:jackson-databind:2.17.x
// Gradle: implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.+'
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class TransactionClient {
    private final String baseUrl;
    private final String bearerToken;
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper = new ObjectMapper();

    public TransactionClient(String baseUrl, String bearerToken) {
        this.baseUrl = baseUrl;
        this.bearerToken = bearerToken;
        this.httpClient = HttpClient.newHttpClient();
    }

    public List<Map<String, Object>> fetchAllTransactions(
            String merchantId, Map<String, String> filters, int pageSize)
            throws IOException, InterruptedException {

        List<Map<String, Object>> allTransactions = new ArrayList<>();
        String cursor = null;

        do {
            Map<String, String> params = new LinkedHashMap<>(filters);
            params.put("pagesize", String.valueOf(pageSize));
            if (cursor != null) params.put("pagecursor", cursor);

            String queryString = params.entrySet().stream()
                .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "=" +
                          URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
                .collect(java.util.stream.Collectors.joining("&"));

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + "/v1/rest/merchants/" + merchantId +
                                "/transactions?" + queryString))
                .header("Authorization", "Bearer " + bearerToken)
                .header("Accept", "application/json")
                .GET()
                .build();

            HttpResponse<String> response =
                httpClient.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() != 200)
                throw new IOException("HTTP " + response.statusCode());

            Map<String, Object> page = objectMapper.readValue(
                response.body(), new TypeReference<Map<String, Object>>() {});
            List<Map<String, Object>> data =
                (List<Map<String, Object>>) page.get("data");
            allTransactions.addAll(data);

            Map<String, Object> pagination =
                (Map<String, Object>) page.get("pagination");
            boolean hasNextPage = pagination != null &&
                Boolean.TRUE.equals(pagination.get("hasNextPage"));
            cursor = hasNextPage ? (String) pagination.get("nextCursor") : null;

        } while (cursor != null);

        return allTransactions;
    }
}

// Usage
TransactionClient client = new TransactionClient(
    "https://your-api-domain.com", "your-bearer-token-here");

Map<String, String> filters = new LinkedHashMap<>();
filters.put("transactiondate", "2026-01-01T00:00:00Z");
filters.put("transactionenddate", "2026-01-31T23:59:59Z");

List<Map<String, Object>> all = client.fetchAllTransactions("12345678901", filters, 100);
System.out.println("Total transactions: " + all.size());

require 'net/http'
require 'uri'
require 'json'
require 'cgi'

class TransactionClient
  def initialize(base_url, bearer_token)
    @base_url = base_url
    @bearer_token = bearer_token
  end

  def fetch_all_transactions(merchant_id, filters = {}, page_size: 100)
    all_transactions = []
    cursor = nil

    loop do
      params = filters.merge(pagesize: page_size.to_s)
      params[:pagecursor] = cursor if cursor

      query_string = params.map do |k, v|
        "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
      end.join('&')

      uri = URI.parse("#{@base_url}/v1/rest/merchants/#{merchant_id}/transactions?#{query_string}")
      http = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl = true

      request = Net::HTTP::Get.new(uri.request_uri)
      request['Authorization'] = "Bearer #{@bearer_token}"
      request['Accept'] = 'application/json'

      response = http.request(request)
      raise "HTTP #{response.code}" unless response.code.to_i == 200

      page = JSON.parse(response.body)
      all_transactions.concat(page['data'])

      pagination = page['pagination']
      break unless pagination&.dig('hasNextPage')
      cursor = pagination['nextCursor']
    end

    all_transactions
  end
end

# Usage
client = TransactionClient.new('https://your-api-domain.com', 'your-bearer-token-here')
filters = {
  transactiondate: '2026-01-01T00:00:00Z',
  transactionenddate: '2026-01-31T23:59:59Z'
}

all_transactions = client.fetch_all_transactions('12345678901', filters, page_size: 100)
puts "Total transactions: #{all_transactions.size}"