Imports System.Collections.Generic
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks
Imports Newtonsoft.Json

Public Class PayorResponse
    <JsonProperty("payorId")>
    Public Property PayorId As String

    <JsonProperty("customerAccountId")>
    Public Property CustomerAccountId As String

    <JsonProperty("createdDate")>
    Public Property CreatedDate As DateTime?

    <JsonProperty("savedPaymentMethodIds")>
    Public Property SavedPaymentMethodIds As List(Of String)

    <JsonProperty("customerData")>
    Public Property CustomerData As Dictionary(Of String, String)
End Class

Public Class PayorsClient
    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

    ' Search by customer account ID
    Public Async Function GetPayorsByCustomerIdAsync(
        merchantId As String,
        customerAccountId As String) As Task(Of List(Of PayorResponse))
        Try
            Dim endpoint As String = $"/v1/rest/merchants/{merchantId}/payors?customerAccountId={Uri.EscapeDataString(customerAccountId)}"

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

            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Return JsonConvert.DeserializeObject(Of List(Of PayorResponse))(responseBody)
        Catch ex As HttpRequestException
            Console.WriteLine($"Request error: {ex.Message}")
            Throw
        End Try
    End Function

    ' Get specific payors by IDs
    Public Async Function GetPayorsByIdsAsync(
        merchantId As String,
        payorIds As List(Of String)) As Task(Of List(Of PayorResponse))
        Try
            Dim payorIdsParam As String = String.Join(",", payorIds)
            Dim endpoint As String = $"/v1/rest/merchants/{merchantId}/payors?payorIds={Uri.EscapeDataString(payorIdsParam)}"

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

            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Return JsonConvert.DeserializeObject(Of List(Of PayorResponse))(responseBody)
        Catch ex As HttpRequestException
            Console.WriteLine($"Request error: {ex.Message}")
            Throw
        End Try
    End Function
End Class

' Example usage: Find payor by customer ID
Dim client As New PayorsClient("your-bearer-token-here")
Dim payors As List(Of PayorResponse) = Await client.GetPayorsByCustomerIdAsync(
    "12345678901",
    "CUST-12345"
)

For Each payor In payors
    Console.WriteLine($"Payor ID: {payor.PayorId}")
    Console.WriteLine($"Customer: {payor.CustomerAccountId}")
Next

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.List;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;

class PayorResponse {
    @SerializedName("payorId")
    private String payorId;

    @SerializedName("customerAccountId")
    private String customerAccountId;

    @SerializedName("savedPaymentMethodIds")
    private List savedPaymentMethodIds;

    // Getters
    public String getPayorId() { return payorId; }
    public String getCustomerAccountId() { return customerAccountId; }
    public List getSavedPaymentMethodIds() { return savedPaymentMethodIds; }
}

public class PayorsClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final String bearerToken;
    private final Gson gson;

    public PayorsClient(String bearerToken) {
        this.bearerToken = bearerToken;
        this.baseUrl = "https://your-api-domain.com";
        this.httpClient = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    // Search by customer account ID
    public List getPayorsByCustomerId(
            String merchantId,
            String customerAccountId) throws Exception {

        String encodedCustomerId = URLEncoder.encode(customerAccountId, StandardCharsets.UTF_8);
        String endpoint = baseUrl + "/v1/rest/merchants/" + merchantId +
                         "/payors?customerAccountId=" + encodedCustomerId;

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

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

        if (response.statusCode() == 200) {
            return gson.fromJson(response.body(), new TypeToken>(){}.getType());
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    // Get specific payors by IDs
    public List getPayorsByIds(
            String merchantId,
            List payorIds) throws Exception {

        String payorIdsParam = String.join(",", payorIds);
        String encodedPayorIds = URLEncoder.encode(payorIdsParam, StandardCharsets.UTF_8);
        String endpoint = baseUrl + "/v1/rest/merchants/" + merchantId +
                         "/payors?payorIds=" + encodedPayorIds;

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

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

        if (response.statusCode() == 200) {
            return gson.fromJson(response.body(), new TypeToken>(){}.getType());
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    public static void main(String[] args) {
        try {
            PayorsClient client = new PayorsClient("your-bearer-token-here");

            // Find payor by customer ID
            List payors = client.getPayorsByCustomerId(
                "12345678901",
                "CUST-12345"
            );

            for (PayorResponse payor : payors) {
                System.out.println("Payor ID: " + payor.getPayorId());
                System.out.println("Customer: " + payor.getCustomerAccountId());
                System.out.println("Payment Methods: " +
                    (payor.getSavedPaymentMethodIds() != null ?
                     payor.getSavedPaymentMethodIds().size() : 0));
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

class PayorsClient
  def initialize(bearer_token, base_url = 'https://your-api-domain.com')
    @bearer_token = bearer_token
    @base_url = base_url
  end

  # Search by customer account ID
  def get_payors_by_customer_id(merchant_id, customer_account_id)
    encoded_customer_id = CGI.escape(customer_account_id)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors?customerAccountId=#{encoded_customer_id}")

    make_request(uri)
  end

  # Get specific payors by IDs
  def get_payors_by_ids(merchant_id, payor_ids)
    payor_ids_param = payor_ids.join(',')
    encoded_payor_ids = CGI.escape(payor_ids_param)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors?payorIds=#{encoded_payor_ids}")

    make_request(uri)
  end

  private

  def make_request(uri)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'

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

    response = http.request(request)

    case response.code.to_i
    when 200
      JSON.parse(response.body)
    when 404
      raise "Payors not found"
    else
      raise "Request failed with status: #{response.code} - #{response.message}"
    end
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end
end

# Example usage 1: Find payor by customer ID
client = PayorsClient.new('your-bearer-token-here')

payors = client.get_payors_by_customer_id('12345678901', 'CUST-12345')

payors.each do |payor|
  puts "Payor ID: #{payor['payorId']}"
  puts "Customer: #{payor['customerAccountId']}"
  puts "Payment Methods: #{payor['savedPaymentMethodIds']&.length || 0}"
  puts
end

# Example usage 2: Get specific payors
payor_ids = ['payor123', 'payor456', 'payor789']
specific_payors = client.get_payors_by_ids('12345678901', payor_ids)

puts "Retrieved #{specific_payors.length} payors"