Details concerning quotissuer response codequot paramete

W pierwszym kroku zostanie wywołany iFrame, który pozwala zebrać i przesłać dane karty bezpośrednio do bramki Espago w celu uzyskania tokenu, a następnie umieści otrzymany token w formularzu na stronie sklepu.
Należy użyć karty o numerze 4242 4242 4242 4242, dacie wygaśnięcia 02/2025 i kodzie CVV 123.

<!-- konfiguracja iFrame -->
<script 
  async=""
  data-id="EspagoFrameScript"
  data-key="VrYVaA1CjmRooKh63YYv"
  data-live="false"
  data-button="Pay"
    src="https://js.espago.com/iframe.js">
</script>

<!-- formularz z tokenem -->
<form id="espago_form" 
      action="/charge_client" 
      accept-charset="UTF-8" 
      method="post">
</form>

Następnie zostanie wysłane właściwe zapytanie do bramki Espago. Składa się ono kolejno z: nagłówka wskazującego wersję API, danych uwierzytelniających użytkownika, kwoty i waluty. Pole card zwiera token uzyskany w poprzednim kroku, dzięki czemu aplikacja sprzedawcy nie musi przetwarzać danych karty..

curl -i https://sandbox.espago.com/api/charges \
 -H "Accept: application/vnd.espago.v3+json" \
 -u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
 -d "amount=10" \
 -d "currency=pln" \
 -d "card=[card_token]" \
 -d "description=Espago docs"

Spodziewana odpowiedź od bramki Espago w formacie json. Kluczowymi informacjami są tutaj id i state. Więcej na temat back requestów

{
 "id":"pay_7715NocOaPcNTL9O",
 "description":"Espago docs", 
 "channel":"elavon",
 "amount":"10.00",
 "currency":"pln",
 "state":"executed",
 [...]
}

curl -i https://sandbox.espago.com/api/test \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
        request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send('api/test', method: :post)
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/test');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "state":"passed",
  "warnings":[]
}

{
  "state":"failed",
  "warnings":[
    {
      "title":"Access denied",
      "message":"Wrong app_id or password."
    },
    {
      "title":"Wrong request headers",
      "message":"Check your 'Accept' header."
    },
        . . .
  ]
}

1. Przesłanie formularza

Klient inicjuje płatność w przeglądarce: klikając przycisk “Kupuję”, przesyła synchronicznie formularz z ukrytymi parametrami płatności do bramki Espago metodą POST. Zostaje w ten sposób przekierowany na stronę płatności Espago.

<form accept-charset="UTF-8" action="https://sandbox.espago.com/secure_web_page" id="espago_secure_web_page" method="post">
  <input name="api_version" type="hidden" value="3" />
  <input name="app_id" type="hidden" value="ms_771eUTliRiZ" />
  <input name="kind" type="hidden" value="sale" />
  <input name="session_id" type="hidden" value="1559655843622983577" />
  <input name="amount" type="hidden" value="10.00" />
  <input name="currency" type="hidden" value="PLN" />
  <input name="title" type="hidden" value="payment_id:294" />
  <input name="description" type="hidden" value="Platność - Jan Kowalski" />
  <input name="positive_url" type="hidden" value="http://example.com/payments/ok" />
  <input name="negative_url" type="hidden" value="http://example.com/payments/bad" />
  <input name="ts" type="hidden" value="1444044688" />
  <input name="checksum" type="hidden" value="938ee2f7729ac4ba1a7c98f5ead8b167" />
  <button name="button" type="submit" class="btn espago-blue pulse">Kupuję</button>
</form>

2. Wprowadzenie danych karty

Klient podaje dane karty na stronie Espago. Dokonywane jest silne uwierzytelnienie mechanizmem 3-D Secure - może nastąpić przekierowanie na stronę banku. Po zakończeniu autoryzacji, do aplikacji sprzedawcy wysyłany jest back request z informacją o stanie transakcji.

3. Przekierowanie użytkownika

W zależności od powodzenia operacji klient zostaje przekierowany na adres odpowiadający pozytywnemu lub negatywnemu wynikowi. W aplikacji sprzedawcy należy wyświetlić użytkownikowi status płatności i ewentualnym powodzie niepowodzenia.

curl -i https://sandbox.espago.com/api/secure_web_page_register \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u app_id:password \
-d 'amount=199' \
-d 'currency=PLN' \
-d 'description=Opis transakcji' \
-d 'kind=sale' 

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send(
  'api/secure_web_page_register',
  method: :post,
  body: {
    amount: 199,
    currency: 'PLN',
    description: 'Opis transakcji',
    kind: 'sale',
    service_client_id: 'xxxxxx',
    client_description: 'xxxxx'
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/secure_web_page_register');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=199&currency=PLN&description=Opis transakcji&kind=sale&service_client_id=xxxxxx&client_description=xxxxx");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'app_id' . ':' . 'password');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "pay_IZTq8l_qaHuOHH",
  "description": "Opis transakcji",
  "amount": "199",
  "currency": "PLN",
  "state": "new",
  "created_at": 1550224439,
  "transaction_id": "tn_CLN2HhetI",
  "redirect_url": "https://sandbox.espago.com/secure_web_page/tn_CLN2HhetI"
}

1. Wywołanie iFrame

W pierwszym kroku klient wywołuje iFrame Espago poprzez naciśnięcie przycisku (uruchomienie musi zostać wywołane ręcznie za pomocą funkcji showEspagoFrame()). Następnie podaje dane swojej karty, które po zatwierdzeniu formularza w iFrame zostają przesłane asynchronicznie do bramki Espago w celu wygenerowania tokenu.

 <script src="https://js.espago.com/espago-1.3.js"></script>
 <script 
   async=""
   data-id="EspagoFrameScript"
   data-key="VrYVaA1CjmRooKh63YYv"
   data-live="false"
   data-button="Pay"
   src="https://js.espago.com/iframe.js">
 </script>

 <a id="pay_btn">Zapłać</a>

$('#pay_btn').click( () => {
  showEspagoFrame()
})

2. Odebranie tokenu

Po odebraniu tokenu skrypt Espago wyszukuje formularz o id espago_form, a następnie tworzy w nim pole <input type="hidden" id="card_token" name="card_token" value="[TOKEN]">. Formularz zostaje wysłany na podany adres.

<form id="espago_form" 
      action="/charge_client" 
      accept-charset="UTF-8" 
      method="post">
</form>

Jeżeli Token nie zostanie użyty, to kod CVV z tokenu zostanie automatycznie usunięty po maksymalnie 2 dobach od utworzenia, a cały token po 2 miesiącach.

3. Obciążenie

Serwer po otrzymaniu tokenu powinien wysłać zapytanie metodą POST na adres https://sandbox.espago.com/api/charges.

curl -i https://sandbox.espago.com/api/charges \
 -H "Accept: application/vnd.espago.v3+json" \
 -u ms_771eUTliRiZ:SeCreT_P@ssw0rD \    # app_id:pass
 -d "amount=10" \
 -d "currency=pln" \
 -d "card=cc_8a1kqN20X6JYeuD-Y" \    # token
 -d "description=Espago docs"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send(
  'api/charges',
  method: :post,
  body: {
    amount: 10,
    currency: 'PLN',
    card: 'cc_8a1kqN20X6JYeuD-Y',
    description: 'Espago docs'
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=10&currency=pln&card=cc_8a1kqN20X6JYeuD-Y&description=Espago docs");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

więcej o parametrach obciążenia

4. Odpowiedź z Espago

Po wykonaniu zapytania o obciążenie klienta Espago zwraca informacje w formacje JSON na temat płatności. Kluczowym parametrem jest state. executed oznacza, iż płatność się powiodła .
Przykładowa odpowiedź od bramki Espago:

{
 "id":"pay_772FThyrtalisvgk",
 "description":"Espago docs",
 "channel":"elavon",
 "amount":"10.00",
 "currency":"pln",
 "state":"executed",
 "client":"cli_772coQy1BaW3F0Zn",
 "created_at":1559649971,
 "card":
 {
  "company":"VI",
  "last4":"4242",
  "year":2020,
  "month":2,
  "first_name":"Adam",
  "last_name":"Kowalski",
  "authorized":null,
  "created_at":1559649956
 },
 "issuer_response_code":"00",
 "reversable":true,
 "transaction_id":"tr_7728ogw8v"
}

5. Odpowiedź - informacja dla klienta

Po zakończeniu płatności niezbędne jest wyświetlenie jej statusu klientowi oraz powodu odrzucenia w przypadku niepowodzenia. Kody błedów dostępne są w dziale do pobrania.

{
  "amount": 10,
  "currency": "pln",
  "card": "cc_772ahSzjmMnOt4eIk",
  "description": "Espago docs"
}

curl -i https://sandbox.espago.com/api/charges \
 -H "Accept: application/vnd.espago.v3+json" \
 -u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
 -d "amount=10" \
 -d "currency=pln" \
 -d "card=cc_772ahSzjmMnOt4eIk" \
 -d "description=Espago docs"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send(
  'api/charges',
  method: :post,
  body: {
    amount: 10,
    currency: 'pln',
    card: 'cc_8a1kqN20X6JYeuD-Y',
    description: 'Espago docs'
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=10&currency=pln&card=cc_772ahSzjmMnOt4eIk&description=Espago docs");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id":"pay_773ob8rbBtid0PYd",
  "description":"Espago docs",
  "channel":"elavon",
  "amount":"10.00",
  "currency":"pln",
  "state":"executed",
  "client":"cli_7733nQkDLdlhHmh-",
  "created_at":1561990343,
  "card":{
    "company":"VI",
    "last4":"4242",
    "year":2020,
    "month":2,
    "first_name":"Adam",
    "last_name":"Adam",
    "authorized":null,
    "created_at":1561990328
  },
  "issuer_response_code":"00",
  "reversable":true,
  "transaction_id":"tr_773OKuy0b"
}

Więcej na temat odpowiedzi z serwera znajdziesz tutaj.

{
  "id": "pay_772LFdT3JG6KaAir",
  "description": "order_481",
  "channel": "elavon",
  "amount": "9.99",
  "currency": "PLN",
  "state": "new",
  "client": "cli_772mtwcEVYBfRCJ2",
  "created_at": 1560935536,
  "card": { ... },
  "issuer_response_code": "",
  "transaction_id": "tr_772atPpUX",
  "redirect_url": "https://sandbox.espago.com/3d-secure/tr_772atPpUX",
  "tds_redirect_form": { ... }
}

curl -i https://sandbox.espago.com/api/charges \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "amount=49.99" \
-d "currency=pln" \
-d "client=cli_772uWYtgJXnL_F9I" \ # klient z kartą w innej walucie
-d "description=Opis transakcji"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send(
  'api/charges',
  method: :post,
  body: {
    amount: 49.99,
    currency: 'pln',
    client: 'cli_772uWYtgJXnL_F9I',
    description: 'Opis transakcji'
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=49.99&currency=pln&client=cli_772uWYtgJXnL_F9I&description=Opis transakcji");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "pay_7724xNjCpNPWYevy",
  "description": "order_502",
  "channel": "elavon",
  "amount": "17.98",
  "currency": "PLN",
  "state": "dcc_decision",
  "client": "cli_772KDwdXQIbqpFp3",
  "created_at": 1560942887,
  "card": { ... },
  "issuer_response_code": "",
  "transaction_id": "tr_772_lDLkv",
  "dcc_decision_information": {
    "cardholder_currency_name": "HKD",
    "cardholder_amount": "39.74",
    "conversion_rate": "2.210174",
    "redirect_url": "https://sandbox.espago.com/secure_web_page/tr_772_lDLkv",
    "mark_up_percentage": "300"
  }
}

curl -i https://sandbox.espago.com/api/charges/(ID_TRANSAKCJI)/dcc_decision \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "decision=Y"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
payment_id = 'pay_8a1FKrxqzJG9sszX'
response = client.send(
  "api/charges/#{payment_id}/dcc_decision",
  method: :post,
  body: {
    decision: 'Y'
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges/(ID_TRANSAKCJI)/dcc_decision');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "decision=Y");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "pay_77219xeZ-8xvxUdE",
  "description": "order_523",
  "channel": "elavon",
  "amount": "39.96",
  "currency": "PLN",
  "state": "executed",
  "client": "cli_772KEkYX7Vq54DJe",
  "created_at": 1560949080,
  "issuer_response_code": "00",
  "reversable": true,
  "transaction_id": "tr_7722-YsY6",
  "multicurrency_indicator": "Z",
  "dcc_decision_information": {
    "cardholder_currency_name": "HKD",
    "cardholder_amount": "88.32",
    "conversion_rate": "2.210174"
  }
}

curl -i https://sandbox.espago.com/api/dcc/rates \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send "api/dcc/rates", method: :get

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/dcc/rates');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "timestamp":"2017-12-01T04:48:00.000+01:00",
  "mark_up_percentage":"300",
  "currency_name":"PLN",
  "currency_code":"985",
  "rates":{
    "USD":"0.285413",
    "ARS":"2.546572",
    "RON":"1.136708",
    "CZK":"6.997923",
    "EUR":"0.255955",
    "KWD":"0.085902",
    "MYR":"1.025983",
    "MXN":"4.372453",
    "GBP":"0.183134",
    ...
  }
}

curl -i https://sandbox.espago.com/api/charges \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "card=cc_7724fuzWy0SYasoLV" \
-d "amount=49.99" \
-d "currency=pln" \
-d "description=Opis transakcji" \
-d "complete=false"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
response = client.send(
  'api/charges',
  method: :post,
  body: {
    card: 'cc_7724fuzWy0SYasoLV',
    amount: 49.99,
    currency: 'pln',
    description: 'Opis transakcji',
    complete: false
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "card=cc_7724fuzWy0SYasoLV&amount=49.99&currency=pln&description=Opis transakcji&complete=false");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id":"pay_772Zm0D5saC0pEA9",
  "description":"Opis transakcji",
  "channel":"elavon",
  "amount":"49.99",
  "currency":"pln",
  "state":"preauthorized",
  "client":"cli_772yY9NvH2Hyt2DM",
  "created_at":1561559076,
  "card":{ ... },
  "issuer_response_code":"00",
  "completed":false,
  "reversable":true,
  "transaction_id":"tr_772_88A0S"
}

curl -i https://sandbox.espago.com/api/charges/pay_772Zm0D5saC0pEA9/complete \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "amount=35"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new(user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD')
payment_id = 'pay_8a1Wx0ggKxvxxmv1'
response = client.send(
  "api/charges/#{payment_id}/complete",
  method: :post,
  body: {
    amount: 35
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges/pay_772Zm0D5saC0pEA9/complete');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=35");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id":"pay_772Zm0D5saC0pEA9",
  "description":"Opis transakcji",
  "channel":"elavon",
  "amount":"35.00",
  "currency":"pln",
  "state":"executed",
  "client":"cli_772yY9NvH2Hyt2DM",
  "created_at":1561559076,
  "issuer_response_code":"00",
  "reversable":true,
  "transaction_id":"tr_772JlqSER"
}

curl -i https://sandbox.espago.com/api/charges/pay_772Zm0D5saC0pEA9 \
-X DELETE \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
payment_id = 'pay_8a1Wx0ggKxvxxmv1'
response = client.send "api/charges/#{payment_id}", method: :delete

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges/pay_772Zm0D5saC0pEA9');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id":"pay_772Zm0D5saC0pEA9",
  "description":"Opis transakcji",
  "channel":"elavon",
  "amount":"35.00",
  "currency":"pln",
  "state":"reversed",
  "client":"cli_772yY9NvH2Hyt2DM",
  "created_at":1561559076,
  "issuer_response_code":"00",
  "transaction_id":"tr_772JlqSER"
}

curl -i https://sandbox.espago.com/api/charges/pay_771MKFI-15SIK1Pm \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
payment_id = 'pay_8a1Wx0ggKxvxxmv1'
response = client.send "api/charges/#{payment_id}", method: :get

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges/pay_771MKFI-15SIK1Pm');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "pay_771MKFI-15SIK1Pm",
  "description": "Espago docs",
  "channel": "elavon",
  "amount": "10.00",
  "currency": "PLN",
  "state": "executed",
  "client": "cli_771Xsyr9GkpN8iTp",
  "created_at": 1559130872,
  "card": {
    "company": "VI",
    "last4": "4242",
    "year": 2024,
    "month": 9,
    "first_name": "Adam",
    "last_name": "Nowak",
    "authorized": null,
    "created_at": 1612977801
  },
  "issuer_response_code": "00",
  "reversable": true,
  "transaction_id": "tr_771EQhf18",
  "reference_number": "Test_doc"
}

curl -i https://sandbox.espago.com/api/charges \
-X GET \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "page=1" \
-d "per=5" \
-d "client=cli_772YYE_98HM1DmAD"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  'api/charges',
  method: :get,
  body: {
    client: 'cli_772YYE_98HM1DmAD',
    page: 1,
    per: 5,
  }
)

puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "page=1&per=5&client=cli_772YYE_98HM1DmAD");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "count":4,
  "charges":[
    {
      "id":"pay_772xZV-3uSUTIxPz",
      "description":"Payment #88",
      "channel":"elavon",
      "amount":"79.00",
      "currency":"pln",
      "state":"executed",
      "client":"cli_772YYE_98HM1DmAD",
      "created_at":1561645210,
      "card":{ ... },
      "issuer_response_code":"00",
      "reversable":true,
      "transaction_id":"tr_772bk-yP2"
    },
    {
      "id":"pay_772X3bE9o9JHdpZt",
      "description":"Payment #23",
      "channel":"elavon",
      "amount":"19.99",
      "currency":"pln",
      "state":"executed",
      "client":"cli_772YYE_98HM1DmAD",
      "created_at":1561645191,
      "card":{ ... },
      "issuer_response_code":"00",
      "reversable":true,
      "transaction_id":"tr_772ZZm3Zt"
    },
    . . .
  ]
}

curl -i https://sandbox.espago.com/api/plans -H \
'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "description=opis planu" \
-d "period_unit=month" \
-d "period=1" \
-d "amount=50" \
-d "currency=pln"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  'api/plans',
  method: :post,
  body: {
    description: 'plan description',
    period_unit: 'month',
    period: 1,
    amount: 50,
    currency: 'pln'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/plans');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "description=opis planu&period_unit=month&period=1&amount=50&currency=pln");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id":"pl_77299uAqqIu4a6eQB",
  "description":"opis planu",
  "period":1,
  "period_unit":"month",
  "amount":"50.0",
  "currency":"pln",
  "created_at":1559739533
}

curl -i https://sandbox.espago.com/api/plans/ID \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
plan_id = 'pl_8a1W3P6xTXOZ4epTp'
response = client.send "api/plans/#{plan_id}", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/plans/ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id":"pl_77299uAqqIu4a6eQB",
  "description":"opis planu",
  "period":1,
  "period_unit":"month",
  "amount":50.0,
  "currency":"pln",
  "created_at":1559739533
}

curl -i https://sandbox.espago.com/api/plans/ID \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-X DELETE 

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
plan_id = 'pl_8a1FInbtEadoX0PER'
response = client.send "api/plans/#{plan_id}", method: :delete

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/plans/ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

curl -i https://sandbox.espago.com/api/plans/ID \
-X PUT -u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "description=Aktualzacja planu" \
-d "period_unit=month" \
-d "period=1" \
-d "amount=75" \
-d "currency=pln"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
plan_id = 'pl_8a1FInbtEadoX0PER'
response = client.send(
  "api/plans/#{plan_id}",
  method: :put,
  body: {
    description: 'updated plan description',
    period_unit: 'month',
    period: 1,
    amount: 75,
    currency: 'pln'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/plans/ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "description=Aktualzacja planu&period_unit=month&period=1&amount=75&currency=pln");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

curl -i https://sandbox.espago.com/api/plans \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD 

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send 'api/plans', method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/plans');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "count":3,
  "plans":[
  {
    "id":"pl_772F0N8AqpLJ8tUhK",
    "description":"Karnet EXCLUSIVE PRO",
    "period":1,
    "period_unit":"month",
    "amount":119.0,
    "currency":"pln",
    "created_at":1559745412
  },
  {
    "id":"pl_772eAqoP50JRfV3Fo",
    "description":"Karnet PRO",
    "period":1,
    "period_unit":"month",
    "amount":79.0,
    "currency":"pln",
    "created_at":1559745395
  },
  {
    "id":"pl_772tYQqPm5QaD9ye9",
    "description":"Karnet NORMAL",
    "period":1,
    "period_unit":"month",
    "amount":50.0,
    "currency":"pln",
    "created_at":1559745382
  }]
}

curl -i https://sandbox.espago.com/api/subscriptions \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "client=client_id" \
-d "plan=plan_id"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  'api/subscriptions',
  method: :post,
  body: {
    client: 'cli_772YYE_98HM1DmAD',
    plan: 'pl_8a1trIGa-EMTQN1VI'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/subscriptions');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "client=client_id&plan=plan_id");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

W odpowiedzi poza informacją dotyczącą subskrypcji wysyłamy także dane pierwszego obciążenia (last_invoice).

{
  "id": "sub_i3CoQEnqX5IKve",
  "state": "active",
  "client": "cli_buoBpPrw6rU7iC",
  "plan": "pl_vGTGxa_Kf521Sdv",
  "created_at": 1373461486,
  "last_invoice": {
    "id": "in_MVt4vwsp7VvOTqa",
    "date": 1373461485,
    "client": "cli_buoBpPrw6rU7iC",
    "subscription": "sub_i3CoQEnqX5IKve",
    "amount": "7.00",
    "currency": "PLN",
    "paid": true,
    "issuer_response_code": "00",
    "attempts": 1,
    "next_payment_attempt": "null",
    "created_at": 1373461485
  }
}

curl -i https://sandbox.espago.com/api/subscriptions/ID \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
subscription_id = 'sub_8a1xsjIpXYYlKFzF'
response = client.send "api/subscriptions/#{subscription_id}", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/subscriptions/ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id": "sub_i3CoQEnqX5IKve",
  "state": "active",
  "client": "cli_buoBpPrw6rU7iC",
  "plan": "pl_vGTGxa_Kf521Sdv",
  "created_at": 1373461486,
  "last_invoice": {
    "id": "in_MVt4vwsp7VvOTqa",
    "date": 1373461485,
    "client": "cli_buoBpPrw6rU7iC",
    "subscription": "sub_i3CoQEnqX5IKve",
    "amount": "7.00",
    "currency": "PLN",
    "paid": true,
    "issuer_response_code": "00",
    "attempts": 1,
    "next_payment_attempt": "null",
    "created_at": 1373461485
  }
}

curl -i https://sandbox.espago.com/api/subscriptions/ID \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-X DELETE 

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
subscription_id = 'sub_8a1FXEDVNMINvTOS'
response = client.send "api/subscriptions/#{subscription_id}", method: :delete

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/subscriptions/ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

curl -i https://sandbox.espago.com/api/subscriptions \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "page=2" \
-d "per=5"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  'api/subscriptions',
  method: :get,
  body: {
    page: 1,
    per: 5
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/subscriptions');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "page=2&per=5");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "count": 1,
  "subscriptions": [
    {
      "id": "sub_i3CoQEnqX5IKve",
      "state": "active",
      "client": "cli_buoBpPrw6rU7iC",
      "plan": "pl_vGTGxa_Kf521Sdv",
      "created_at": 1373461486,
      "last_invoice": {
        "id": "in_9d7xIbhzLMkxTFm",
        "date": 1373463196,
        "client": "cli_buoBpPrw6rU7iC",
        "subscription": "sub_i3CoQEnqX5IKve",
        "amount": "7.00",
        "currency": "PLN",
        "paid": true,
        "issuer_response_code": "00",
        "attempts": 1,
        "next_payment_attempt": "null",
        "created_at": 1373463196,
      }
    }
  ]
}

curl -i https://sandbox.espago.com/api/clients/CLIENT_ID/subscriptions \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "page=2" \
-d "per=5"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send(
  "api/clients/#{client_id}/subscriptions",
  method: :get,
  body: {
    page: 1,
    per: 5
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/CLIENT_ID/subscriptions');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "page=2&per=5");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "count": 2,
  "subscriptions": [
    {
      "id": "sub_WbAUbaC_7KB79V",
      "state": "active",
      "client": "cli_buoBpPrw6rU7iC",
      "plan": "pl_vGTGxa_Kf521Sdv",
      "created_at": 1373463500,
      "last_invoice": {
        "id": "in_I3iEPUZFxUsLUR-",
        "date": 1373463498,
        "client": "cli_buoBpPrw6rU7iC",
        "subscription": "sub_WbAUbaC_7KB79V",
        "amount": "7.00",
        "currency": "PLN",
        "paid": true,
        "issuer_response_code": "00",
        "attempts": 1,
        "next_payment_attempt": "null",
        "created_at": 1373463498
      }
    },
    {
      "id": "sub_FMw5DlPzK0dW9V",
      "state": "active",
      "client": "cli_buoBpPrw6rU7iC",
      "plan": "pl_vGTGxa_Kf521Sdv",
      "created_at": 1373463506,
      "last_invoice": {
        "id": "in_WtlQMDFdUDpIdSq",
        "date": 1373463504,
        "client": "cli_buoBpPrw6rU7iC",
        "subscription": "sub_FMw5DlPzK0dW9V",
        "amount": "7.00",
        "currency": "PLN",
        "paid": true,
        "issuer_response_code": "00",
        "attempts": 1,
        "next_payment_attempt": "null",
        "created_at": 1373463504,
      }
    }
  ]
}

curl -i https://sandbox.espago.com/api/clients/CLIENT_ID/invoices/ \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send "api/clients/#{client_id}/invoices", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/CLIENT_ID/invoices/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "count":1,
  "invoices":[
    {
      "id":"in_7728vjvj-BdSK0B64",
      "date":1559903458,
      "client":"cli_772YYE_98HM1DmAD",
      "subscription":"sub_772pHbFAL2vs-z8g",
      "amount":"119.00",
      "currency":"pln",
      "paid":true,
      "issuer_response_code":"00",
      "attempts":1,
      "next_payment_attempt":null,
      "created_at":1559903458,
      "last_payment":"pay_772Nkgo8MS-25osp"
    }
  ]
}

curl -i https://sandbox.espago.com/api/invoices/(:invoice_id)/pay \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
invoice_id = 'in_7728vjvj-BdSK0B64'
response = client.send "api/invoices/#{invoice_id}/pay", method: :post

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/invoices/(:invoice_id)/pay');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id": "in_MUL7PeIUTDwOHx8",
  "date": 1371805245,
  "client": "cli_N7hldWZqSoBLva",
  "subscription": "sub_occMPm6-_284b3",
  "amount": "7.00",
  "currency": "PLN",
  "paid": true,
  "attempts": 2,
  "next_payment_attempt": "null",
  "created_at": 1371805245,
    "last_payment":"pay_772Nkgo8MS-25osp"
}

Dla opłaconej wcześniej faktury wysyłana jest odpowiedź z kodem błędu 422 "Unprocessable Entity.

curl -i https://sandbox.espago.com/api/invoices/ID_FAKTURY \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
invoice_id = 'in_7728vjvj-BdSK0B64'
response = client.send "api/invoices/#{invoice_id}", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/invoices/ID_FAKTURY');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);

{
  "id":"in_7728vjvj-BdSK0B64",
  "date":1559903458,
  "client":"cli_772YYE_98HM1DmAD",
  "subscription":"sub_772pHbFAL2vs-z8g",
  "amount":"119.00",
  "currency":"pln",
  "paid":true,
  "issuer_response_code":"00",
  "attempts":1,
  "next_payment_attempt":null,
  "created_at":1559903458,
  "last_payment":"pay_772Nkgo8MS-25osp"
}

curl -i https://sandbox.espago.com/api/invoice_items \
-H 'Accept: application/vnd.espago.v3+json' \
-u app_id:password \
-d "currency=currency" \
-d "date=unix_time" \
-d "amount=100" \
-d "client=client_id" \
-d "description=Opis transakcji"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/invoice_items",
  method: :post,
  body: {
    currency: 'pln',
    date: 1764363614,
    amount: 100,
    client: 'cli_772YYE_98HM1DmAD',
    description: 'Opis transakcji'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/invoice_items');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "currency=currency&date=unix_time&amount=100&client=client_id&description=Opis transakcji");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'app_id' . ':' . 'password');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "ii_1sbC2i-UHMWJXZH",
  "client": "cli_xNKNXh-_kWu6Qi",
  "description": "Opis transakcji",
  "amount": "100.00",
  "currency": "PLN",
  "created_at": 1381755981
}

curl -i https://sandbox.espago.com/api/invoices/(:invoice_id)/line_items \
-H 'Accept: application/vnd.espago.v3+json' \
-u app_id:password

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
invoice_id = 'in_7728vjvj-BdSK0B64'
response = client.send "api/invoices/#{invoice_id}/line_items", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/invoices/:invoice_id/line_items');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'app_id' . ':' . 'password');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "count": 1,
  "invoice_items": [
    {
    "id": "ii_1KZ0VBahlukLI2X",
    "client": "cli_OU7k00vEMGi53C",
    "description": "Pozycja 1",
    "amount": "7.00",
    "currency": "PLN",
    "created_at": 1371631057
    }
  ]
}

curl -i https://sandbox.espago.com/api/invoice_items/(:id) \
-X DELETE \
-H 'Accept: application/vnd.espago.v3+json' \
-u app_id:password

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
invoice_id = 'in_7728vjvj-BdSK0B63'
response = client.send "api/invoices/#{invoice_id}", method: :delete

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/invoice_items/(:id)');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');

curl_setopt($ch, CURLOPT_USERPWD, 'app_id' . ':' . 'password');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

curl -i https://sandbox.espago.com/api/back_request_settings \
-X PUT \
-H 'Accept: application/vnd.espago.v3+json' \
-u your_app_id:your_api_app_password \
-d "url=https://example.espago.com/" \
-d "login=MyLogin" \
-d "password=MyPassword"

{}

{
   "url": ["is invalid or not responding"]
}

curl -i https://sandbox.espago.com/api/charges/(:id)/refund \
 -X POST \
 -H 'Accept: application/vnd.espago.v3+json' \
 -u app_id:password \
 -d "amount=n"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
payment_id = 'pay_315gfsdf234'
response = client.send(
  "api/charges/#{payment_id}/refund",
  method: :post,
  body: {
    amount: 100
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges/(:id)/refund');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=n");
curl_setopt($ch, CURLOPT_USERPWD, 'app_id' . ':' . 'password');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "pay_COy6zH9fLj1d7K",
  "description": "Opis transakcji",
  "channel": "elavon",
  "amount": "49.99",
  "refunded_amount": "15.00",
  "currency": "pln",
  "state": "refunded",
  "client": "cli_xNKNXh-_kWu6Qi",
  "created_at": 1381823580,
  "card": {
    "company": "VI",
    "last4": "4242",
    "year": 2017,
    "month": 2,
    "first_name": "Jan",
    "last_name": "Kowalski",
    "authorized": true,
    "created_at": 1381755890
  },
  "issuer_response_code": "00",
  "transaction_id": "tn_AKZ71ysMF"
}

curl -i https://sandbox.espago.com/api/refunds \
 -X POST \
 -H 'Content-Type: application/json' \
 -H 'Accept: application/vnd.espago.v3+json' \
 -u  ms_771eUTliRiZ:SeCreT_P@ssw0rD \
 -d '{ "amount": 10, "currency": "PLN", "channel": "elavon_eisop", "description": "docs test refund",  "eisop_token": { "token": "BEYOVBGIVPBX0006", "card_year": "2025", "card_month": "12" } }'

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
payment_id = 'pay_315gfsdf234'
response = client.send(
  "api/charges/#{payment_id}/refund",
  method: :post,
  body: {
    amount: 10,
        currency: "PLN",
        description: "docs test refund",
        eisop_token: {
          token:  "BEYOVBGIVPBX0006",
            card_year: "2025", 
        card_month: "12"
      }
  }
)

puts response.code
puts response.body

{
  "id": "pay_COy6zH9fLj1d7K",
  "channel": "elavon_eisop",
  "refunded_amount": "10.0",
  "currency": "GBP",
  "state": "refunded",
  "created_at": 1381823580,
  "eisop_token": {
    "token": "xxx",
    "token_type": "xxx",
    "last4": "xxxx",
    "year": "YYYY",
    "month": "MM",
    "company": "CC"
  },
  "issuer_response_code": "XX",
  "transaction_id": "xxx"
}

curl -i https://sandbox.espago.com/api/clients \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "description=Jan Kowalski" \
-d "card=token_id"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/clients",
  method: :post,
  body: {
    description: 'Jan Kowalski',
    card: 'token_id'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "description=Jan Kowalski&card=token_id");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "email": "jan@kowalski.com",
  "id": "cli_Yzij0t46pV88oR",
  "created_at": 1381825758,
  "description": "Jan Kowalski",
  "card": {
    "company": "VI",
    "last4": "4242",
    "year": 2017,
    "month": 2,
    "first_name": "Jan",
    "last_name": "Kowalski",
    "authorized": true,
    "created_at": 1381825758,
  },
  "deleted": false
}

curl -i https://sandbox.espago.com/api/tokens \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "card[first_name]=Jan" \
-d "card[last_name]=Kowalski" \
-d "card[number]=4242424242424242" \
-d "card[verification_value]=123" \
-d "card[year]=2018" \
-d "card[month]=02"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/tokens",
  method: :post,
  body: {
    card: {
      first_name: "Jan",
      last_name: "Kowalski",
      month: "02",
      number: "4242424242424242",
      verification_value: "123",
      year: "2030"
    }
  }
)

puts response.code
puts response.body

// Generated by curl-to-PHP: http://incarnate.github.io/curl-to-php/
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/tokens');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "card[first_name]=Jan&card[last_name]=Kowalski&card[number]=4242424242424242&card[verification_value]=123&card[year]=2018&card[month]=02");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id": "cc_J_wDRKH6jmIEb_8",
  "created_at": 1550871516,
  "used": false,
  "card": {
    "company": "VI",
    "last4": "4242",
    "year": 2018,
    "month": 2,
    "first_name": "John",
    "last_name": "Kowalsky",
    "authorized": "null",
    "created_at": 1550871586
  }
}

curl -i https://sandbox.espago.com/api/tokens/cc_776Hzu24ArvnooVvq/check_type \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
token_id = 'cc_8a1IcKzD4NzD7httF'
response = client.send "api/tokens/#{token_id}/check_type", method: :post

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/tokens/cc_776Hzu24ArvnooVvq/check_type');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
    "id":"cc_776Hzu24ArvnooVvq",
    "created_at":1570612905,
    "used":false,
    "card":{
        "company":"VI",
        "last4":"4242",
        "year":2026,
        "month":2,
        "first_name":"Jan",
        "last_name":"Kowalski",
        "authorized":null,
        "card_type":"D",
        "country":"HKG",
        "currency":"HKD",
        "bank":"U",
        "created_at":1570612905
    }
}

curl -i https://sandbox.espago.com/api/clients/CLIENT_ID \
-X DELETE \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_8a1IcKzD4NzD7httF'
response = client.send "api/clients/#{client_id}", method: :delete

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/CLIENT_ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

W odpowiedzi wysyłamy Status 204: no content

curl -i https://sandbox.espago.com/api/clients/ID_KLIENTA \
-X PUT \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "description=Jan Kowalski" \
-d "email=client@example.com" \
-d "card[first_name]=Jan" \
-d "card[last_name]=Kowalski" \
-d "card[number]=4242424242424242" \
-d "card[verification_value]=123" \
-d "card[year]=2025" \
-d "card[month]=02"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send(
  "api/clients/#{client_id}",
  method: :put,
  body: {
    description: 'Jan Kowalski',
    email: 'client@example.com',
    card: {
      first_name: 'Jan',
      last_name: 'Kowalski',
      number: 4242424242424242,
      verification_value: 123,
      year: 2025,
      month: 02
    }
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/ID_KLIENTA');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "description=Jan Kowalski&email=client@example.com&card[first_name]=Jan&card[last_name]=Kowalski&card[number]=4242424242424242&card[verification_value]=123&card[year]=2025&card[month]=02");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "email":"client@example.com",
  "id":"cli_772q8GcejiQfRl4z",
  "created_at":1560960175,
  "description":"Jan Kowalski",
  "card":{
    "company":"VI",
    "last4":"4242",
    "year":2025,
    "month":2,
    "first_name":"Jan",
    "last_name":"Kowalski",
    "authorized":null,
    "created_at":1561125908
  },
  "deleted":false
}

curl -i https://sandbox.espago.com/api/clients/CLIENT_ID \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send "api/clients/#{client_id}", method: :get

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/CLIENT_ID');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "email":"client@example.com",
  "id":"cli_772q8GcejiQfRl4z",
  "created_at":1560960175,
  "description":"Jan Kowalski",
  "card":{
    "company":"VI",
    "last4":"4242",
    "year":2022,
    "month":2,
    "first_name":"Jan",
    "last_name":"Kowalski",
    "authorized":true,
    "created_at":1561126879
    },
  "deleted":false",
  "sca_payment": {
    "payment_id": "pay_772bLKUDa1sdfsd",
    "amount": "0.00",
    "channel": "elavon",
    "updated_at": 1561126879,
    "client_id": "cli_772q8GcejiQfRl4z"
    }
}

curl -i https://sandbox.espago.com/api/clients \
-X GET \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "page=2" \
-d "per=15"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/clients",
  method: :get,
  body: {
    page: 1,
    per: 5
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "page=2&per=15");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "count":19,
  "clients":[
    {
      "email":"client@example.com",
      "id":"cli_772q8GcejiQfRl4z",
      "created_at":1560960175,
      "description":"Jan Kowalski",
      "card":{
        "company":"VI",
        "last4":"4242",
        "year":2022,
        "month":2,
        "first_name":"Jan",
        "last_name":"Kowalski",
        "authorized":true,
        "authorized_cvv_cvc":true,
        "issuer_response_code":"00",
        "created_at":1561126879
      },
      "deleted":false
    },
    {
      "email":"test@example.com",
      "id":"cli_772psATGSdMbS8NS",
      "created_at":1560960154,
      "description":"Jan Kowalski id:321",
      "card":{
        "company":null,
        "last4":null,
        "year":null,
        "month":null,
        "first_name":null,
        "last_name":null,
        "authorized":null,
        "created_at":null
      },
      "deleted":false
    },
    (. . .)
  ]
}

curl -i https://sandbox.espago.com/api/clients/CLIENT_ID/authorize \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send "api/clients/#{client_id}/authorize", method: :post

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/CLIENT_ID/authorize');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "email":"client@example.com",
  "id":"cli_772q8GcejiQfRl4z",
  "created_at":1560960175,
  "description":"Jan Kowalski",
  "card":{
    "company":"VI",
    "last4":"2239",
    "year":2025,
    "month":2,
    "first_name":"Jan",
    "last_name":"Kowalski",
    "authorized":true,
    "issuer_response_code":"00",
    "created_at":1561369769
  },
  "deleted":false
}

curl -i https://sandbox.espago.com/api/clients/card_page \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "client[description]=Jan Kowalski id:321" \
-d "client[email]=test@example.com" \
-d "check=recurring" \
-d "store=recurring" \
-d "title=Card for future subscription for the radio ABC"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/clients/card_page",
  method: :post,
  body: {
    client: {
      description: "Jan Kowalski id:321",
      email: "test@example.com"
    },
    check: "recurring",
    store: "recurring",
    title: "Card for future subscription for the radio ABC"
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/card_page');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "client[description]=Jan Kowalski id:321&client[email]=test@example.com&check=recurring&store=recurring&title=Card for future subscription for the radio ABC");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "id":"cpl_772AUdz2l2DMHCvz",
  "url":"https://sandbox.espago.com/client_card_page/cpl_772AUdz2l2DMHCvz",
  "client":"cli_772IYA6M52V4njJR",
  "store":"recurring",
  "check":"recurring",
  "title":"Card for future subscription for the radio ABC",
  "valid_to":1561459867,
  "created_at":1561373467,
  "used":false,
  "positive_url":null,
  "negative_url":null
}

curl -i https://sandbox.espago.com/api/clients/cli_772IYA6M52V4njJR/check_type \
-X POST \
-H 'Accept: application/vnd.espago.v3+json' \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
client_id = 'cli_772YYE_98HM1DmAD'
response = client.send "api/clients/#{client_id}/check_type", method: :post

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/clients/cli_772IYA6M52V4njJR/check_type');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);

{
  "email":"test@example.com",
  "id":"cli_772IYA6M52V4njJR",
  "created_at":1561373467,
  "description":"Jan Kowalski id:321",
  "card":{
    "company":"VI",
    "last4":"4242",
    "year":2026,
    "month":2,
    "first_name":"Jan",
    "last_name":"Kowalski",
    "card_type":"D",
    "country":"HKG",
    "currency":"HKD",
    "bank":"U",
    "created_at":1561373520
  },
  "deleted":false
}

1. Wywołanie IFrame

Klient wywołuje IFrame przystosowany do generowania tokenów cvv, a następnie go wypełnia i przesyła do espago

<script src="https://js.espago.com/espago-1.3.js"></script>
 <script 
   async=""
   data-id="EspagoFrameScript"
   data-key="VrYVaA1CjmRooKh63YYv"
   data-live="false"
     data-cvv-only="true"
   data-button="Pay"
   src="https://js.espago.com/iframe.js">
 </script>

 <a id="pay_btn">Zapłać</a>

$('#pay_btn').click( () => {
  showEspagoFrame()
})

Odebranie tokenu

Po wywołaniu formularza i podaniu danych karty przez płatnika, skrypt wysyła je bezpośrednio do serwera Espago. W przypadku utworzenia tokenu, skrypt domyślnie szuka na stronie z której został wywołany formularza o identyfikatorze “espago_form” i dodaje w nim pole z tokenem.

Działanie to można zmienić, wskazując parametr data-target lub data-success w wywołaniu iframe, o czym wspomniano w tabeli poniżej.

<form id="espago_form">
  <input type="hidden" id="cvv_token" name="cvv_token" value="cvv_xxxxxx">
</form>

Wywołanie płatności

Wywołanie płatności wraz z dodanym parametrem cvv=cvv_token_id.

curl -i https://sandbox.espago.com/api/charges \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "amount=10" \
-d "currency=pln" \
-d "client=cli_772IYA6M52V4njJR" \
-d "description=Espago docs" \
-d "cvv=cv_772oAPNIwkEZlEIPo"

curl -i https://sandbox.espago.com/api/charges \
-H "Accept: application/vnd.espago.v3+json" \
-u ms_771eUTliRiZ:SeCreT_P@ssw0rD \
-d "amount=10" \
-d "currency=pln" \
-d "client=cli_772IYA6M52V4njJR" \
-d "description=Espago docs" \
-d "cvv=cv_772oAPNIwkEZlEIPo"

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

class EspagoClient
  # @param user [String]
  # @param password [String]
  def initialize(user:, password:)
    @user = user
    @password = password
  end

  # @param path [String]
  # @param body [Hash, nil]
  # @param method [Symbol]
  # @return [Net::HTTPResponse]
  def send(path, body: nil, method: :get)
    uri = URI.join('https://sandbox.espago.com', path)
    request = request_class(method).new(uri)
    request.basic_auth(@user, @password)
    request['Accept'] = 'application/vnd.espago.v3+json'
    request['Content-Type'] = 'application/json'
    request.body = body.to_json if body

    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
  end

  private

  # @param [Symbol]
  # @return [Class<Net::HTTPRequest>]
  def request_class(method_name)
    Net::HTTP.const_get(method_name.to_s.capitalize)
  end
end

client = EspagoClient.new user: 'ms_771eUTliRiZ', password: 'SeCreT_P@ssw0rD'
response = client.send(
  "api/charges",
  method: :post,
  body: {
    amount: 10,
    currency: 'pln',
    client: 'cli_772YYE_98HM1DmAD',
    description: 'Espago docs',
    cvv: 'cv_772oAPNIwkEZlEIPo'
  }
)

puts response.code
puts response.body

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://sandbox.espago.com/api/charges');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "amount=10&currency=pln&client=cli_772IYA6M52V4njJR&description=Espago docs&cvv=cv_772oAPNIwkEZlEIPo");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, 'ms_771eUTliRiZ' . ':' . 'SeCreT_P@ssw0rD');

$headers = array();
$headers[] = 'Accept: application/vnd.espago.v3+json';
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);