Getting started

Mundipagg API

How to Build

This client library is a Ruby gem which can be compiled and used in your Ruby and Ruby on Rails project. This library requires a few gems from the RubyGems repository.

Open the command line interface or the terminal and navigate to the folder containing the source code.
Run gem build mundi_api.gemspec to build the gem.
Once built, the gem can be installed on the current work environment using gem install mundi_api-2.4.0.gem

How to Use

The following section explains how to use the MundiApi Ruby Gem in a new Rails project using RubyMine™. The basic workflow presented here is also applicable if you prefer using a different editor or IDE.

1. Starting a new project

Close any existing projects in RubyMine™ by selecting File -> Close Project. Next, click on Create New Project to create a new project from scratch.

Next, provide TestApp as the project name, choose Rails Application as the project type, and click OK.

In the next dialog make sure that correct Ruby SDK is being used (minimum 2.0.0) and click OK.

This will create a new Rails Application project with an existing set of files and folder.

2. Add reference of the gem

In order to use the MundiApi gem in the new project we must add a gem reference. Locate the Gemfile in the Project Explorer window under the TestApp project node. The file contains references to all gems being used in the project. Here, add the reference to the library gem by adding the following line: gem 'mundi_api', '~> 2.4.0'

3. Adding a new Rails Controller

Once the TestApp project is created, a folder named controllers will be visible in the Project Explorer under the following path: TestApp > app > controllers. Right click on this folder and select New -> Run Rails Generator....

Selecting the said option will popup a small window where the generator names are displayed. Here, select the controller template.

Next, a popup window will ask you for a Controller name and included Actions. For controller name provide Hello and include an action named Index and click OK.

A new controller class anmed HelloController will be created in a file named hello_controller.rb containing a method named Index. In this method, add code for initialization and a sample for its usage.

How to Test

You can test the generated SDK and the server with automatically generated test cases as follows:

From terminal/cmd navigate to the root directory of the SDK.
Invoke: bundle exec rake

Initialization

Authentication

In order to setup authentication and initialization of the API client, you need the following information.

Parameter	Description
basic_auth_user_name	The username to use with basic authentication
basic_auth_password	The password to use with basic authentication

API client can be initialized as following.

# Configuration parameters and credentials
basic_auth_user_name = 'basic_auth_user_name' # The username to use with basic authentication
basic_auth_password = 'basic_auth_password' # The password to use with basic authentication

client = MundiApi::MundiApiClient.new(
  basic_auth_user_name: basic_auth_user_name,
  basic_auth_password: basic_auth_password
)

The added initlization code can be debugged by putting a breakpoint in the Index method and running the project in debug mode by selecting Run -> Debug 'Development: TestApp'.

Class Reference

List of Controllers

CustomersController
ChargesController
RecipientsController
SubscriptionsController
InvoicesController
OrdersController
TokensController
PlansController
TransactionsController
TransfersController

CustomersController

Get singleton instance

The singleton instance of the CustomersController class can be accessed from the API Client.

customers_controller = client.customers

create_access_token

Creates a access token for a customer

def create_access_token(customer_id,
                            request,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
request	`Required`	Request for creating a access token
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
request = CreateAccessTokenRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.create_access_token(customer_id, request, idempotency_key)

update_customer

Updates a customer

def update_customer(customer_id,
                        request,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
request	`Required`	Request for updating a customer
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
request = UpdateCustomerRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.update_customer(customer_id, request, idempotency_key)

delete_access_tokens

Delete a Customer's access tokens

def delete_access_tokens(customer_id); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id

Example Usage

customer_id = 'customer_id'

result = customers_controller.delete_access_tokens(customer_id)

get_customer

Get a customer

def get_customer(customer_id); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id

Example Usage

customer_id = 'customer_id'

result = customers_controller.get_customer(customer_id)

get_addresses

Gets all adressess from a customer

def get_addresses(customer_id,
                      page = nil,
                      size = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

customer_id = 'customer_id'
page = 97
size = 97

result = customers_controller.get_addresses(customer_id, page, size)

get_access_token

Get a Customer's access token

def get_access_token(customer_id,
                         token_id); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
token_id	`Required`	Token Id

Example Usage

customer_id = 'customer_id'
token_id = 'token_id'

result = customers_controller.get_access_token(customer_id, token_id)

get_address

Get a customer's address

def get_address(customer_id,
                    address_id); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
address_id	`Required`	Address Id

Example Usage

customer_id = 'customer_id'
address_id = 'address_id'

result = customers_controller.get_address(customer_id, address_id)

create_card

Creates a new card for a customer

def create_card(customer_id,
                    request,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
request	`Required`	Request for creating a card
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
request = CreateCardRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.create_card(customer_id, request, idempotency_key)

renew_card

Renew a card

def renew_card(customer_id,
                   card_id,
                   idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
card_id	`Required`	Card Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
card_id = 'card_id'
idempotency_key = 'idempotency-key'

result = customers_controller.renew_card(customer_id, card_id, idempotency_key)

create_customer

Creates a new customer

def create_customer(request,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
request	`Required`	Request for creating a customer
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

request = CreateCustomerRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.create_customer(request, idempotency_key)

update_address

Updates an address

def update_address(customer_id,
                       address_id,
                       request,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
address_id	`Required`	Address Id
request	`Required`	Request for updating an address
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
address_id = 'address_id'
request = UpdateAddressRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.update_address(customer_id, address_id, request, idempotency_key)

get_access_tokens

Get all access tokens from a customer

def get_access_tokens(customer_id,
                          page = nil,
                          size = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

customer_id = 'customer_id'
page = 97
size = 97

result = customers_controller.get_access_tokens(customer_id, page, size)

update_customer_metadata

Updates the metadata a customer

def update_customer_metadata(customer_id,
                                 request,
                                 idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	The customer id
request	`Required`	Request for updating the customer metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.update_customer_metadata(customer_id, request, idempotency_key)

delete_address

Delete a Customer's address

def delete_address(customer_id,
                       address_id,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
address_id	`Required`	Address Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
address_id = 'address_id'
idempotency_key = 'idempotency-key'

result = customers_controller.delete_address(customer_id, address_id, idempotency_key)

update_card

Updates a card

def update_card(customer_id,
                    card_id,
                    request,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
card_id	`Required`	Card id
request	`Required`	Request for updating a card
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
card_id = 'card_id'
request = UpdateCardRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.update_card(customer_id, card_id, request, idempotency_key)

delete_access_token

Delete a customer's access token

def delete_access_token(customer_id,
                            token_id,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
token_id	`Required`	Token Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
token_id = 'token_id'
idempotency_key = 'idempotency-key'

result = customers_controller.delete_access_token(customer_id, token_id, idempotency_key)

create_address

Creates a new address for a customer

def create_address(customer_id,
                       request,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
request	`Required`	Request for creating an address
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
request = CreateAddressRequest.new
idempotency_key = 'idempotency-key'

result = customers_controller.create_address(customer_id, request, idempotency_key)

get_card

Get a customer's card

def get_card(customer_id,
                 card_id); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer id
card_id	`Required`	Card id

Example Usage

customer_id = 'customer_id'
card_id = 'card_id'

result = customers_controller.get_card(customer_id, card_id)

get_cards

Get all cards from a customer

def get_cards(customer_id,
                  page = nil,
                  size = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

customer_id = 'customer_id'
page = 97
size = 97

result = customers_controller.get_cards(customer_id, page, size)

delete_card

Delete a customer's card

def delete_card(customer_id,
                    card_id,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
customer_id	`Required`	Customer Id
card_id	`Required`	Card Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

customer_id = 'customer_id'
card_id = 'card_id'
idempotency_key = 'idempotency-key'

result = customers_controller.delete_card(customer_id, card_id, idempotency_key)

get_customers

Get all Customers

def get_customers(name = nil,
                      document = nil,
                      page = 1,
                      size = 10,
                      email = nil,
                      code = nil); end

Parameters

Parameter	Tags	Description
name	`Optional`	Name of the Customer
document	`Optional`	Document of the Customer
page	`Optional` `DefaultValue`	Current page the the search
size	`Optional` `DefaultValue`	Quantity pages of the search
email	`Optional`	Customer's email
code	`Optional`	Customer's code

Example Usage

name = 'name'
document = 'document'
page = 1
size = 10
email = 'email'
code = 'Code'

result = customers_controller.get_customers(name, document, page, size, email, code)

Back to List of Controllers

ChargesController

Get singleton instance

The singleton instance of the ChargesController class can be accessed from the API Client.

charges_controller = client.charges

get_charge

Get a charge from its id

def get_charge(charge_id); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id

Example Usage

charge_id = 'charge_id'

result = charges_controller.get_charge(charge_id)

confirm_payment

TODO: Add a method description

def confirm_payment(charge_id,
                        request = nil,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	TODO: Add a parameter description
request	`Optional`	Request for confirm payment
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = CreateConfirmPaymentRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.confirm_payment(charge_id, request, idempotency_key)

update_charge_card

Updates the card from a charge

def update_charge_card(charge_id,
                           request,
                           idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id
request	`Required`	Request for updating a charge's card
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = UpdateChargeCardRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.update_charge_card(charge_id, request, idempotency_key)

get_charges

Lists all charges

def get_charges(page = nil,
                    size = nil,
                    code = nil,
                    status = nil,
                    payment_method = nil,
                    customer_id = nil,
                    order_id = nil,
                    created_since = nil,
                    created_until = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size
code	`Optional`	Filter for charge's code
status	`Optional`	Filter for charge's status
payment_method	`Optional`	Filter for charge's payment method
customer_id	`Optional`	Filter for charge's customer id
order_id	`Optional`	Filter for charge's order id
created_since	`Optional`	Filter for the beginning of the range for charge's creation
created_until	`Optional`	Filter for the end of the range for charge's creation

Example Usage

page = 97
size = 97
code = 'code'
status = 'status'
payment_method = 'payment_method'
customer_id = 'customer_id'
order_id = 'order_id'
created_since = DateTime.now
created_until = DateTime.now

result = charges_controller.get_charges(page, size, code, status, payment_method, customer_id, order_id, created_since, created_until)

cancel_charge

Cancel a charge

def cancel_charge(charge_id,
                      request = nil,
                      idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id
request	`Optional`	Request for cancelling a charge
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = CreateCancelChargeRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.cancel_charge(charge_id, request, idempotency_key)

retry_charge

Retries a charge

def retry_charge(charge_id,
                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
idempotency_key = 'idempotency-key'

result = charges_controller.retry_charge(charge_id, idempotency_key)

update_charge_payment_method

Updates a charge's payment method

def update_charge_payment_method(charge_id,
                                     request,
                                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id
request	`Required`	Request for updating the payment method from a charge
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = UpdateChargePaymentMethodRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.update_charge_payment_method(charge_id, request, idempotency_key)

update_charge_metadata

Updates the metadata from a charge

def update_charge_metadata(charge_id,
                               request,
                               idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	The charge id
request	`Required`	Request for updating the charge metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.update_charge_metadata(charge_id, request, idempotency_key)

capture_charge

Captures a charge

def capture_charge(charge_id,
                       request = nil,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge id
request	`Optional`	Request for capturing a charge
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = CreateCaptureChargeRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.capture_charge(charge_id, request, idempotency_key)

update_charge_due_date

Updates the due date from a charge

def update_charge_due_date(charge_id,
                               request,
                               idempotency_key = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge Id
request	`Required`	Request for updating the due date
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

charge_id = 'charge_id'
request = UpdateChargeDueDateRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.update_charge_due_date(charge_id, request, idempotency_key)

create_charge

Creates a new charge

def create_charge(request,
                      idempotency_key = nil); end

Parameters

Parameter	Tags	Description
request	`Required`	Request for creating a charge
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

request = CreateChargeRequest.new
idempotency_key = 'idempotency-key'

result = charges_controller.create_charge(request, idempotency_key)

get_charge_transactions

TODO: Add a method description

def get_charge_transactions(charge_id,
                                page = nil,
                                size = nil); end

Parameters

Parameter	Tags	Description
charge_id	`Required`	Charge Id
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

charge_id = 'charge_id'
page = 5
size = 5

result = charges_controller.get_charge_transactions(charge_id, page, size)

get_charges_summary

TODO: Add a method description

def get_charges_summary(status,
                            created_since = nil,
                            created_until = nil); end

Parameters

Parameter	Tags	Description
status	`Required`	TODO: Add a parameter description
created_since	`Optional`	TODO: Add a parameter description
created_until	`Optional`	TODO: Add a parameter description

Example Usage

status = 'status'
created_since = DateTime.now
created_until = DateTime.now

result = charges_controller.get_charges_summary(status, created_since, created_until)

Back to List of Controllers

RecipientsController

Get singleton instance

The singleton instance of the RecipientsController class can be accessed from the API Client.

recipients_controller = client.recipients

update_recipient_metadata

Updates recipient metadata

def update_recipient_metadata(recipient_id,
                                  request,
                                  idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
request	`Required`	Metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.update_recipient_metadata(recipient_id, request, idempotency_key)

update_recipient_transfer_settings

TODO: Add a method description

def update_recipient_transfer_settings(recipient_id,
                                           request,
                                           idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient Identificator
request	`Required`	TODO: Add a parameter description
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = UpdateTransferSettingsRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.update_recipient_transfer_settings(recipient_id, request, idempotency_key)

get_anticipation

Gets an anticipation

def get_anticipation(recipient_id,
                         anticipation_id); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
anticipation_id	`Required`	Anticipation id

Example Usage

recipient_id = 'recipient_id'
anticipation_id = 'anticipation_id'

result = recipients_controller.get_anticipation(recipient_id, anticipation_id)

get_recipients

Retrieves paginated recipients information

def get_recipients(page = nil,
                       size = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

page = 5
size = 5

result = recipients_controller.get_recipients(page, size)

get_balance

Get balance information for a recipient

def get_balance(recipient_id); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id

Example Usage

recipient_id = 'recipient_id'

result = recipients_controller.get_balance(recipient_id)

get_anticipations

Retrieves a paginated list of anticipations from a recipient

def get_anticipations(recipient_id,
                          page = nil,
                          size = nil,
                          status = nil,
                          timeframe = nil,
                          payment_date_since = nil,
                          payment_date_until = nil,
                          created_since = nil,
                          created_until = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
page	`Optional`	Page number
size	`Optional`	Page size
status	`Optional`	Filter for anticipation status
timeframe	`Optional`	Filter for anticipation timeframe
payment_date_since	`Optional`	Filter for start range for anticipation payment date
payment_date_until	`Optional`	Filter for end range for anticipation payment date
created_since	`Optional`	Filter for start range for anticipation creation date
created_until	`Optional`	Filter for end range for anticipation creation date

Example Usage

recipient_id = 'recipient_id'
page = 5
size = 5
status = 'status'
timeframe = 'timeframe'
payment_date_since = DateTime.now
payment_date_until = DateTime.now
created_since = DateTime.now
created_until = DateTime.now

result = recipients_controller.get_anticipations(recipient_id, page, size, status, timeframe, payment_date_since, payment_date_until, created_since, created_until)

create_anticipation

Creates an anticipation

def create_anticipation(recipient_id,
                            request,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
request	`Required`	Anticipation data
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = CreateAnticipationRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.create_anticipation(recipient_id, request, idempotency_key)

update_recipient_default_bank_account

Updates the default bank account from a recipient

def update_recipient_default_bank_account(recipient_id,
                                              request,
                                              idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
request	`Required`	Bank account data
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = UpdateRecipientBankAccountRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.update_recipient_default_bank_account(recipient_id, request, idempotency_key)

get_recipient

Retrieves recipient information

def get_recipient(recipient_id); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipiend id

Example Usage

recipient_id = 'recipient_id'

result = recipients_controller.get_recipient(recipient_id)

get_anticipation_limits

Gets the anticipation limits for a recipient

def get_anticipation_limits(recipient_id,
                                timeframe,
                                payment_date); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
timeframe	`Required`	Timeframe
payment_date	`Required`	Anticipation payment date

Example Usage

recipient_id = 'recipient_id'
timeframe = 'timeframe'
payment_date = DateTime.now

result = recipients_controller.get_anticipation_limits(recipient_id, timeframe, payment_date)

get_transfer

Gets a transfer

def get_transfer(recipient_id,
                     transfer_id); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
transfer_id	`Required`	Transfer id

Example Usage

recipient_id = 'recipient_id'
transfer_id = 'transfer_id'

result = recipients_controller.get_transfer(recipient_id, transfer_id)

get_transfers

Gets a paginated list of transfers for the recipient

def get_transfers(recipient_id,
                      page = nil,
                      size = nil,
                      status = nil,
                      created_since = nil,
                      created_until = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
page	`Optional`	Page number
size	`Optional`	Page size
status	`Optional`	Filter for transfer status
created_since	`Optional`	Filter for start range of transfer creation date
created_until	`Optional`	Filter for end range of transfer creation date

Example Usage

recipient_id = 'recipient_id'
page = 5
size = 5
status = 'status'
created_since = DateTime.now
created_until = DateTime.now

result = recipients_controller.get_transfers(recipient_id, page, size, status, created_since, created_until)

update_recipient

Updates a recipient

def update_recipient(recipient_id,
                         request,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
request	`Required`	Recipient data
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = UpdateRecipientRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.update_recipient(recipient_id, request, idempotency_key)

create_recipient

Creates a new recipient

def create_recipient(request,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
request	`Required`	Recipient data
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

request = CreateRecipientRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.create_recipient(request, idempotency_key)

create_transfer

Creates a transfer for a recipient

def create_transfer(recipient_id,
                        request,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient Id
request	`Required`	Transfer data
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = CreateTransferRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.create_transfer(recipient_id, request, idempotency_key)

create_withdraw

TODO: Add a method description

def create_withdraw(recipient_id,
                        request); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	TODO: Add a parameter description
request	`Required`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = CreateWithdrawRequest.new

result = recipients_controller.create_withdraw(recipient_id, request)

get_withdraw_by_id

TODO: Add a method description

def get_withdraw_by_id(recipient_id,
                           withdrawal_id); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	TODO: Add a parameter description
withdrawal_id	`Required`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
withdrawal_id = 'withdrawal_id'

result = recipients_controller.get_withdraw_by_id(recipient_id, withdrawal_id)

get_withdrawals

Gets a paginated list of transfers for the recipient

def get_withdrawals(recipient_id,
                        page = nil,
                        size = nil,
                        status = nil,
                        created_since = nil,
                        created_until = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	TODO: Add a parameter description
page	`Optional`	TODO: Add a parameter description
size	`Optional`	TODO: Add a parameter description
status	`Optional`	TODO: Add a parameter description
created_since	`Optional`	TODO: Add a parameter description
created_until	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
page = 5
size = 5
status = 'status'
created_since = DateTime.now
created_until = DateTime.now

result = recipients_controller.get_withdrawals(recipient_id, page, size, status, created_since, created_until)

update_automatic_anticipation_settings

Updates recipient metadata

def update_automatic_anticipation_settings(recipient_id,
                                               request,
                                               idempotency_key = nil); end

Parameters

Parameter	Tags	Description
recipient_id	`Required`	Recipient id
request	`Required`	Metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

recipient_id = 'recipient_id'
request = UpdateAutomaticAnticipationSettingsRequest.new
idempotency_key = 'idempotency-key'

result = recipients_controller.update_automatic_anticipation_settings(recipient_id, request, idempotency_key)

get_recipient_by_code

Retrieves recipient information

def get_recipient_by_code(code); end

Parameters

Parameter	Tags	Description
code	`Required`	Recipient code

Example Usage

code = 'code'

result = recipients_controller.get_recipient_by_code(code)

Back to List of Controllers

SubscriptionsController

Get singleton instance

The singleton instance of the SubscriptionsController class can be accessed from the API Client.

subscriptions_controller = client.subscriptions

create_discount

Creates a discount

def create_discount(subscription_id,
                        request,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Required`	Request for creating a discount
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = CreateDiscountRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_discount(subscription_id, request, idempotency_key)

get_subscription_item

Get Subscription Item

def get_subscription_item(subscription_id,
                              item_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
item_id	`Required`	Item id

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'

result = subscriptions_controller.get_subscription_item(subscription_id, item_id)

delete_usage

Deletes a usage

def delete_usage(subscription_id,
                     item_id,
                     usage_id,
                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
item_id	`Required`	The subscription item id
usage_id	`Required`	The usage id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'
usage_id = 'usage_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.delete_usage(subscription_id, item_id, usage_id, idempotency_key)

cancel_subscription

Cancels a subscription

def cancel_subscription(subscription_id,
                            request = nil,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Optional`	Request for cancelling a subscription
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = CreateCancelSubscriptionRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.cancel_subscription(subscription_id, request, idempotency_key)

delete_increment

Deletes a increment

def delete_increment(subscription_id,
                         increment_id,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
increment_id	`Required`	Increment id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
increment_id = 'increment_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.delete_increment(subscription_id, increment_id, idempotency_key)

get_subscription_cycle_by_id

TODO: Add a method description

def get_subscription_cycle_by_id(subscription_id,
                                     cycle_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
cycle_id	`Required`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
cycle_id = 'cycleId'

result = subscriptions_controller.get_subscription_cycle_by_id(subscription_id, cycle_id)

update_subscription_start_at

Updates the start at date from a subscription

def update_subscription_start_at(subscription_id,
                                     request,
                                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
request	`Required`	Request for updating the subscription start date
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionStartAtRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_start_at(subscription_id, request, idempotency_key)

update_subscription_payment_method

Updates the payment method from a subscription

def update_subscription_payment_method(subscription_id,
                                           request,
                                           idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Required`	Request for updating the paymentmethod from a subscription
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionPaymentMethodRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_payment_method(subscription_id, request, idempotency_key)

update_current_cycle_status

TODO: Add a method description

def update_current_cycle_status(subscription_id,
                                    request,
                                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
request	`Required`	Request for updating the end date of the subscription current status
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateCurrentCycleStatusRequest.new
idempotency_key = 'idempotency-key'

subscriptions_controller.update_current_cycle_status(subscription_id, request, idempotency_key)

create_subscription

Creates a new subscription

def create_subscription(body,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
body	`Required`	Request for creating a subscription
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

body = CreateSubscriptionRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_subscription(body, idempotency_key)

get_usages_details

TODO: Add a method description

def get_usages_details(subscription_id,
                           cycle_id = nil,
                           size = nil,
                           page = nil,
                           item_id = nil,
                           group = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Identifier
cycle_id	`Optional`	Cycle id
size	`Optional`	Page size
page	`Optional`	Page number
item_id	`Optional`	Identificador do item
group	`Optional`	identificador da loja (account) de cada item

Example Usage

subscription_id = 'subscription_id'
cycle_id = 'cycle_id'
size = 5
page = 5
item_id = 'item_id'
group = 'group'

result = subscriptions_controller.get_usages_details(subscription_id, cycle_id, size, page, item_id, group)

renew_subscription

TODO: Add a method description

def renew_subscription(subscription_id,
                           idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	TODO: Add a parameter description
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.renew_subscription(subscription_id, idempotency_key)

update_subscription_item

Updates a subscription item

def update_subscription_item(subscription_id,
                                 item_id,
                                 body,
                                 idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
item_id	`Required`	Item id
body	`Required`	Request for updating a subscription item
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'
body = UpdateSubscriptionItemRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_item(subscription_id, item_id, body, idempotency_key)

create_an_usage

Create Usage

def create_an_usage(subscription_id,
                        item_id,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
item_id	`Required`	Item id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_an_usage(subscription_id, item_id, idempotency_key)

get_increment_by_id

TODO: Add a method description

def get_increment_by_id(subscription_id,
                            increment_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription Id
increment_id	`Required`	The increment Id

Example Usage

subscription_id = 'subscription_id'
increment_id = 'increment_id'

result = subscriptions_controller.get_increment_by_id(subscription_id, increment_id)

delete_discount

Deletes a discount

def delete_discount(subscription_id,
                        discount_id,
                        idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
discount_id	`Required`	Discount Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
discount_id = 'discount_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.delete_discount(subscription_id, discount_id, idempotency_key)

get_increments

TODO: Add a method description

def get_increments(subscription_id,
                       page = nil,
                       size = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
page	`Optional`	Page number
size	`Optional`	Page size

Example Usage

subscription_id = 'subscription_id'
page = 5
size = 5

result = subscriptions_controller.get_increments(subscription_id, page, size)

create_usage

Creates a usage

def create_usage(subscription_id,
                     item_id,
                     body,
                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
item_id	`Required`	Item id
body	`Required`	Request for creating a usage
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'
body = CreateUsageRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_usage(subscription_id, item_id, body, idempotency_key)

create_subscription_item

Creates a new Subscription item

def create_subscription_item(subscription_id,
                                 request,
                                 idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Required`	Request for creating a subscription item
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = CreateSubscriptionItemRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_subscription_item(subscription_id, request, idempotency_key)

get_usages

Lists all usages from a subscription item

def get_usages(subscription_id,
                   item_id,
                   page = nil,
                   size = nil,
                   code = nil,
                   group = nil,
                   used_since = nil,
                   used_until = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
item_id	`Required`	The subscription item id
page	`Optional`	Page number
size	`Optional`	Page size
code	`Optional`	Identification code in the client system
group	`Optional`	Identification group in the client system
used_since	`Optional`	TODO: Add a parameter description
used_until	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
item_id = 'item_id'
page = 5
size = 5
code = 'code'
group = 'group'
used_since = DateTime.now
used_until = DateTime.now

result = subscriptions_controller.get_usages(subscription_id, item_id, page, size, code, group, used_since, used_until)

update_subscription_billing_date

Updates the billing date from a subscription

def update_subscription_billing_date(subscription_id,
                                         request,
                                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
request	`Required`	Request for updating the subscription billing date
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionBillingDateRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_billing_date(subscription_id, request, idempotency_key)

update_latest_period_end_at

TODO: Add a method description

def update_latest_period_end_at(subscription_id,
                                    request,
                                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	TODO: Add a parameter description
request	`Required`	Request for updating the end date of the current signature cycle
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateCurrentCycleEndDateRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_latest_period_end_at(subscription_id, request, idempotency_key)

get_subscription_cycles

TODO: Add a method description

def get_subscription_cycles(subscription_id,
                                page,
                                size); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
page	`Required`	Page number
size	`Required`	Page size

Example Usage

subscription_id = 'subscription_id'
page = 'page'
size = 'size'

result = subscriptions_controller.get_subscription_cycles(subscription_id, page, size)

get_subscriptions

Gets all subscriptions

def get_subscriptions(page = nil,
                          size = nil,
                          code = nil,
                          billing_type = nil,
                          customer_id = nil,
                          plan_id = nil,
                          card_id = nil,
                          status = nil,
                          next_billing_since = nil,
                          next_billing_until = nil,
                          created_since = nil,
                          created_until = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size
code	`Optional`	Filter for subscription's code
billing_type	`Optional`	Filter for subscription's billing type
customer_id	`Optional`	Filter for subscription's customer id
plan_id	`Optional`	Filter for subscription's plan id
card_id	`Optional`	Filter for subscription's card id
status	`Optional`	Filter for subscription's status
next_billing_since	`Optional`	Filter for subscription's next billing date start range
next_billing_until	`Optional`	Filter for subscription's next billing date end range
created_since	`Optional`	Filter for subscription's creation date start range
created_until	`Optional`	Filter for subscriptions creation date end range

Example Usage

page = 5
size = 5
code = 'code'
billing_type = 'billing_type'
customer_id = 'customer_id'
plan_id = 'plan_id'
card_id = 'card_id'
status = 'status'
next_billing_since = DateTime.now
next_billing_until = DateTime.now
created_since = DateTime.now
created_until = DateTime.now

result = subscriptions_controller.get_subscriptions(page, size, code, billing_type, customer_id, plan_id, card_id, status, next_billing_since, next_billing_until, created_since, created_until)

get_discount_by_id

TODO: Add a method description

def get_discount_by_id(subscription_id,
                           discount_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
discount_id	`Required`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
discount_id = 'discountId'

result = subscriptions_controller.get_discount_by_id(subscription_id, discount_id)

get_subscription_items

Get Subscription Items

def get_subscription_items(subscription_id,
                               page = nil,
                               size = nil,
                               name = nil,
                               code = nil,
                               status = nil,
                               description = nil,
                               created_since = nil,
                               created_until = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
page	`Optional`	Page number
size	`Optional`	Page size
name	`Optional`	The item name
code	`Optional`	Identification code in the client system
status	`Optional`	The item statis
description	`Optional`	The item description
created_since	`Optional`	Filter for item's creation date start range
created_until	`Optional`	Filter for item's creation date end range

Example Usage

subscription_id = 'subscription_id'
page = 47
size = 47
name = 'name'
code = 'code'
status = 'status'
description = 'description'
created_since = 'created_since'
created_until = 'created_until'

result = subscriptions_controller.get_subscription_items(subscription_id, page, size, name, code, status, description, created_since, created_until)

update_subscription_minium_price

Atualização do valor mínimo da assinatura

def update_subscription_minium_price(subscription_id,
                                         request,
                                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
request	`Required`	Request da requisição com o valor mínimo que será configurado
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionMinimumPriceRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_minium_price(subscription_id, request, idempotency_key)

get_subscription

Gets a subscription

def get_subscription(subscription_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id

Example Usage

subscription_id = 'subscription_id'

result = subscriptions_controller.get_subscription(subscription_id)

update_subscription_affiliation_id

TODO: Add a method description

def update_subscription_affiliation_id(subscription_id,
                                           request,
                                           idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	TODO: Add a parameter description
request	`Required`	Request for updating a subscription affiliation id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionAffiliationIdRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_affiliation_id(subscription_id, request, idempotency_key)

delete_subscription_item

Deletes a subscription item

def delete_subscription_item(subscription_id,
                                 subscription_item_id,
                                 idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
subscription_item_id	`Required`	Subscription item id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
subscription_item_id = 'subscription_item_id'
idempotency_key = 'idempotency-key'

result = subscriptions_controller.delete_subscription_item(subscription_id, subscription_item_id, idempotency_key)

update_subscription_card

Updates the credit card from a subscription

def update_subscription_card(subscription_id,
                                 request,
                                 idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Required`	Request for updating a card
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionCardRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_card(subscription_id, request, idempotency_key)

update_subscription_metadata

Updates the metadata from a subscription

def update_subscription_metadata(subscription_id,
                                     request,
                                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
request	`Required`	Request for updating the subscrption metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_metadata(subscription_id, request, idempotency_key)

update_subscription_due_days

Updates the boleto due days from a subscription

def update_subscription_due_days(subscription_id,
                                     request,
                                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
request	`Required`	TODO: Add a parameter description
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = UpdateSubscriptionDueDaysRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.update_subscription_due_days(subscription_id, request, idempotency_key)

get_discounts

TODO: Add a method description

def get_discounts(subscription_id,
                      page,
                      size); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription id
page	`Required`	Page number
size	`Required`	Page size

Example Usage

subscription_id = 'subscription_id'
page = 47
size = 47

result = subscriptions_controller.get_discounts(subscription_id, page, size)

create_increment

Creates a increment

def create_increment(subscription_id,
                         request,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription id
request	`Required`	Request for creating a increment
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
request = CreateIncrementRequest.new
idempotency_key = 'idempotency-key'

result = subscriptions_controller.create_increment(subscription_id, request, idempotency_key)

get_usage_report

TODO: Add a method description

def get_usage_report(subscription_id,
                         period_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	The subscription Id
period_id	`Required`	The period Id

Example Usage

subscription_id = 'subscription_id'
period_id = 'period_id'

result = subscriptions_controller.get_usage_report(subscription_id, period_id)

update_split_subscription

TODO: Add a method description

def update_split_subscription(id,
                                  request); end

Parameters

Parameter	Tags	Description
id	`Required`	Subscription's id
request	`Required`	TODO: Add a parameter description

Example Usage

id = 'id'
request = UpdateSubscriptionSplitRequest.new

result = subscriptions_controller.update_split_subscription(id, request)

Back to List of Controllers

InvoicesController

Get singleton instance

The singleton instance of the InvoicesController class can be accessed from the API Client.

invoices_controller = client.invoices

create_invoice

Create an Invoice

def create_invoice(subscription_id,
                       cycle_id,
                       request = nil,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id
cycle_id	`Required`	Cycle Id
request	`Optional`	TODO: Add a parameter description
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

subscription_id = 'subscription_id'
cycle_id = 'cycle_id'
request = CreateInvoiceRequest.new
idempotency_key = 'idempotency-key'

result = invoices_controller.create_invoice(subscription_id, cycle_id, request, idempotency_key)

get_partial_invoice

TODO: Add a method description

def get_partial_invoice(subscription_id); end

Parameters

Parameter	Tags	Description
subscription_id	`Required`	Subscription Id

Example Usage

subscription_id = 'subscription_id'

result = invoices_controller.get_partial_invoice(subscription_id)

update_invoice_status

Updates the status from an invoice

def update_invoice_status(invoice_id,
                              request,
                              idempotency_key = nil); end

Parameters

Parameter	Tags	Description
invoice_id	`Required`	Invoice Id
request	`Required`	Request for updating an invoice's status
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

invoice_id = 'invoice_id'
request = UpdateInvoiceStatusRequest.new
idempotency_key = 'idempotency-key'

result = invoices_controller.update_invoice_status(invoice_id, request, idempotency_key)

get_invoice

Gets an invoice

def get_invoice(invoice_id); end

Parameters

Parameter	Tags	Description
invoice_id	`Required`	Invoice Id

Example Usage

invoice_id = 'invoice_id'

result = invoices_controller.get_invoice(invoice_id)

update_invoice_metadata

Updates the metadata from an invoice

def update_invoice_metadata(invoice_id,
                                request,
                                idempotency_key = nil); end

Parameters

Parameter	Tags	Description
invoice_id	`Required`	The invoice id
request	`Required`	Request for updating the invoice metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

invoice_id = 'invoice_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = invoices_controller.update_invoice_metadata(invoice_id, request, idempotency_key)

get_invoices

Gets all invoices

def get_invoices(page = nil,
                     size = nil,
                     code = nil,
                     customer_id = nil,
                     subscription_id = nil,
                     created_since = nil,
                     created_until = nil,
                     status = nil,
                     due_since = nil,
                     due_until = nil,
                     customer_document = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size
code	`Optional`	Filter for Invoice's code
customer_id	`Optional`	Filter for Invoice's customer id
subscription_id	`Optional`	Filter for Invoice's subscription id
created_since	`Optional`	Filter for Invoice's creation date start range
created_until	`Optional`	Filter for Invoices creation date end range
status	`Optional`	Filter for Invoice's status
due_since	`Optional`	Filter for Invoice's due date start range
due_until	`Optional`	Filter for Invoice's due date end range
customer_document	`Optional`	Fillter for invoice's document

Example Usage

page = 47
size = 47
code = 'code'
customer_id = 'customer_id'
subscription_id = 'subscription_id'
created_since = DateTime.now
created_until = DateTime.now
status = 'status'
due_since = DateTime.now
due_until = DateTime.now
customer_document = 'customer_document'

result = invoices_controller.get_invoices(page, size, code, customer_id, subscription_id, created_since, created_until, status, due_since, due_until, customer_document)

cancel_invoice

Cancels an invoice

def cancel_invoice(invoice_id,
                       idempotency_key = nil); end

Parameters

Parameter	Tags	Description
invoice_id	`Required`	Invoice id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

invoice_id = 'invoice_id'
idempotency_key = 'idempotency-key'

result = invoices_controller.cancel_invoice(invoice_id, idempotency_key)

Back to List of Controllers

OrdersController

Get singleton instance

The singleton instance of the OrdersController class can be accessed from the API Client.

orders_controller = client.orders

update_order_status

TODO: Add a method description

def update_order_status(id,
                            request,
                            idempotency_key = nil); end

Parameters

Parameter	Tags	Description
id	`Required`	Order Id
request	`Required`	Update Order Model
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

id = 'id'
request = UpdateOrderStatusRequest.new
idempotency_key = 'idempotency-key'

result = orders_controller.update_order_status(id, request, idempotency_key)

delete_all_order_items

TODO: Add a method description

def delete_all_order_items(order_id,
                               idempotency_key = nil); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

order_id = 'orderId'
idempotency_key = 'idempotency-key'

result = orders_controller.delete_all_order_items(order_id, idempotency_key)

update_order_metadata

Updates the metadata from an order

def update_order_metadata(order_id,
                              request,
                              idempotency_key = nil); end

Parameters

Parameter	Tags	Description
order_id	`Required`	The order id
request	`Required`	Request for updating the order metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

order_id = 'order_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = orders_controller.update_order_metadata(order_id, request, idempotency_key)

get_orders

Gets all orders

def get_orders(page = nil,
                   size = nil,
                   code = nil,
                   status = nil,
                   created_since = nil,
                   created_until = nil,
                   customer_id = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size
code	`Optional`	Filter for order's code
status	`Optional`	Filter for order's status
created_since	`Optional`	Filter for order's creation date start range
created_until	`Optional`	Filter for order's creation date end range
customer_id	`Optional`	Filter for order's customer id

Example Usage

page = 47
size = 47
code = 'code'
status = 'status'
created_since = DateTime.now
created_until = DateTime.now
customer_id = 'customer_id'

result = orders_controller.get_orders(page, size, code, status, created_since, created_until, customer_id)

create_order_item

TODO: Add a method description

def create_order_item(order_id,
                          request,
                          idempotency_key = nil); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order Id
request	`Required`	Order Item Model
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

order_id = 'orderId'
request = CreateOrderItemRequest.new
idempotency_key = 'idempotency-key'

result = orders_controller.create_order_item(order_id, request, idempotency_key)

delete_order_item

TODO: Add a method description

def delete_order_item(order_id,
                          item_id,
                          idempotency_key = nil); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order Id
item_id	`Required`	Item Id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

order_id = 'orderId'
item_id = 'itemId'
idempotency_key = 'idempotency-key'

result = orders_controller.delete_order_item(order_id, item_id, idempotency_key)

get_order

Gets an order

def get_order(order_id); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order id

Example Usage

order_id = 'order_id'

result = orders_controller.get_order(order_id)

create_order

Creates a new Order

def create_order(body,
                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
body	`Required`	Request for creating an order
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

body = CreateOrderRequest.new
idempotency_key = 'idempotency-key'

result = orders_controller.create_order(body, idempotency_key)

get_order_item

TODO: Add a method description

def get_order_item(order_id,
                       item_id); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order Id
item_id	`Required`	Item Id

Example Usage

order_id = 'orderId'
item_id = 'itemId'

result = orders_controller.get_order_item(order_id, item_id)

update_order_item

TODO: Add a method description

def update_order_item(order_id,
                          item_id,
                          request,
                          idempotency_key = nil); end

Parameters

Parameter	Tags	Description
order_id	`Required`	Order Id
item_id	`Required`	Item Id
request	`Required`	Item Model
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

order_id = 'orderId'
item_id = 'itemId'
request = UpdateOrderItemRequest.new
idempotency_key = 'idempotency-key'

result = orders_controller.update_order_item(order_id, item_id, request, idempotency_key)

Back to List of Controllers

TokensController

Get singleton instance

The singleton instance of the TokensController class can be accessed from the API Client.

tokens_controller = client.tokens

create_token

Tags: Skips Authentication

TODO: Add a method description

def create_token(public_key,
                     request,
                     idempotency_key = nil); end

Parameters

Parameter	Tags	Description
public_key	`Required`	Public key
request	`Required`	Request for creating a token
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

public_key = 'public_key'
request = CreateTokenRequest.new
idempotency_key = 'idempotency-key'

result = tokens_controller.create_token(public_key, request, idempotency_key)

get_token

Tags: Skips Authentication

Gets a token from its id

def get_token(id,
                  public_key); end

Parameters

Parameter	Tags	Description
id	`Required`	Token id
public_key	`Required`	Public key

Example Usage

id = 'id'
public_key = 'public_key'

result = tokens_controller.get_token(id, public_key)

Back to List of Controllers

PlansController

Get singleton instance

The singleton instance of the PlansController class can be accessed from the API Client.

plans_controller = client.plans

update_plan_item

Updates a plan item

def update_plan_item(plan_id,
                         plan_item_id,
                         body,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
plan_item_id	`Required`	Plan item id
body	`Required`	Request for updating the plan item
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
plan_item_id = 'plan_item_id'
body = UpdatePlanItemRequest.new
idempotency_key = 'idempotency-key'

result = plans_controller.update_plan_item(plan_id, plan_item_id, body, idempotency_key)

create_plan_item

Adds a new item to a plan

def create_plan_item(plan_id,
                         request,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
request	`Required`	Request for creating a plan item
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
request = CreatePlanItemRequest.new
idempotency_key = 'idempotency-key'

result = plans_controller.create_plan_item(plan_id, request, idempotency_key)

get_plans

Gets all plans

def get_plans(page = nil,
                  size = nil,
                  name = nil,
                  status = nil,
                  billing_type = nil,
                  created_since = nil,
                  created_until = nil); end

Parameters

Parameter	Tags	Description
page	`Optional`	Page number
size	`Optional`	Page size
name	`Optional`	Filter for Plan's name
status	`Optional`	Filter for Plan's status
billing_type	`Optional`	Filter for plan's billing type
created_since	`Optional`	Filter for plan's creation date start range
created_until	`Optional`	Filter for plan's creation date end range

Example Usage

page = 47
size = 47
name = 'name'
status = 'status'
billing_type = 'billing_type'
created_since = DateTime.now
created_until = DateTime.now

result = plans_controller.get_plans(page, size, name, status, billing_type, created_since, created_until)

get_plan

Gets a plan

def get_plan(plan_id); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id

Example Usage

plan_id = 'plan_id'

result = plans_controller.get_plan(plan_id)

update_plan

Updates a plan

def update_plan(plan_id,
                    request,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
request	`Required`	Request for updating a plan
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
request = UpdatePlanRequest.new
idempotency_key = 'idempotency-key'

result = plans_controller.update_plan(plan_id, request, idempotency_key)

update_plan_metadata

Updates the metadata from a plan

def update_plan_metadata(plan_id,
                             request,
                             idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	The plan id
request	`Required`	Request for updating the plan metadata
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
request = UpdateMetadataRequest.new
idempotency_key = 'idempotency-key'

result = plans_controller.update_plan_metadata(plan_id, request, idempotency_key)

create_plan

Creates a new plan

def create_plan(body,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
body	`Required`	Request for creating a plan
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

body = CreatePlanRequest.new
idempotency_key = 'idempotency-key'

result = plans_controller.create_plan(body, idempotency_key)

delete_plan_item

Removes an item from a plan

def delete_plan_item(plan_id,
                         plan_item_id,
                         idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
plan_item_id	`Required`	Plan item id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
plan_item_id = 'plan_item_id'
idempotency_key = 'idempotency-key'

result = plans_controller.delete_plan_item(plan_id, plan_item_id, idempotency_key)

delete_plan

Deletes a plan

def delete_plan(plan_id,
                    idempotency_key = nil); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
idempotency_key	`Optional`	TODO: Add a parameter description

Example Usage

plan_id = 'plan_id'
idempotency_key = 'idempotency-key'

result = plans_controller.delete_plan(plan_id, idempotency_key)

get_plan_item

Gets a plan item

def get_plan_item(plan_id,
                      plan_item_id); end

Parameters

Parameter	Tags	Description
plan_id	`Required`	Plan id
plan_item_id	`Required`	Plan item id

Example Usage

plan_id = 'plan_id'
plan_item_id = 'plan_item_id'

result = plans_controller.get_plan_item(plan_id, plan_item_id)

Back to List of Controllers

TransactionsController

Get singleton instance

The singleton instance of the TransactionsController class can be accessed from the API Client.

transactions_controller = client.transactions

get_transaction

TODO: Add a method description

def get_transaction(transaction_id); end

Parameters

Parameter	Tags	Description
transaction_id	`Required`	TODO: Add a parameter description

Example Usage

transaction_id = 'transaction_id'

result = transactions_controller.get_transaction(transaction_id)

Back to List of Controllers

TransfersController

Get singleton instance

The singleton instance of the TransfersController class can be accessed from the API Client.

transfers_controller = client.transfers

create_transfer

TODO: Add a method description

def create_transfer(request); end

Parameters

Parameter	Tags	Description
request	`Required`	TODO: Add a parameter description

Example Usage

request = CreateTransfer.new

result = transfers_controller.create_transfer(request)

get_transfer_by_id

TODO: Add a method description

def get_transfer_by_id(transfer_id); end

Parameters

Parameter	Tags	Description
transfer_id	`Required`	TODO: Add a parameter description

Example Usage

transfer_id = 'transfer_id'

result = transfers_controller.get_transfer_by_id(transfer_id)

get_transfers

Gets all transfers

def get_transfers; end

Example Usage

result = transfers_controller.get_transfers()

Back to List of Controllers

Files

README.md

Latest commit

History

README.md

File metadata and controls

Getting started

How to Build

How to Use

1. Starting a new project

2. Add reference of the gem

3. Adding a new Rails Controller

How to Test

Initialization

Authentication

Class Reference

List of Controllers

CustomersController

Get singleton instance

create_access_token

Parameters

Example Usage

update_customer

Parameters

Example Usage

delete_access_tokens

Parameters

Example Usage

get_customer

Parameters

Example Usage

get_addresses

Parameters

Example Usage

get_access_token

Parameters

Example Usage

get_address

Parameters

Example Usage

create_card

Parameters

Example Usage

renew_card

Parameters

Example Usage

create_customer

Parameters

Example Usage

update_address

Parameters

Example Usage

get_access_tokens

Parameters

Example Usage

update_customer_metadata

Parameters

Example Usage

delete_address

Parameters

Example Usage

update_card

Parameters

Example Usage

delete_access_token

Parameters

Example Usage

create_address

Parameters

Example Usage

get_card

Parameters

Example Usage

get_cards

Parameters

Example Usage

delete_card

Parameters

Example Usage

get_customers