Getting started

Pagarme 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.

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

How to Use

The following section explains how to use the PagarmeCoreApi 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 PagarmeCoreApi 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 'pagarme_core_api', '~> 5.6.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:

1. From terminal/cmd navigate to the root directory of the SDK.
2. 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 = PagarmeCoreApi::PagarmeCoreApiClient.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

• PlansController
• SubscriptionsController
• OrdersController
• InvoicesController
• CustomersController
• ChargesController
• TransfersController
• RecipientsController
• TokensController
• TransactionsController

PlansController

Get singleton instance

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

plans_controller = client.plans

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_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)

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_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)

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)

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 = 104
size = 104
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)

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)

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)

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

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)

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)

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)

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)

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)

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)

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_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 = 104
size = 104
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)

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)

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 = 104
size = 104
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)

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)

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)

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

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_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)

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)

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)

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_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_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)

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 = 63
size = 63

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

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)

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)

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 = 63
size = 63

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

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)

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_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_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_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)

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 = 63
size = 63
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_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)

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_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)

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)

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

OrdersController

Get singleton instance

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

orders_controller = client.orders

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 = 63
size = 63
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)

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_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)

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)

close_order

TODO: Add a method description

def close_order(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.close_order(id, request, idempotency_key)

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)

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)

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_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_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)

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

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)

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)

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)

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	TODO: Add a parameter description

Example Usage

page = 63
size = 63
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)

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_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)

Back to List of Controllers

CustomersController

Get singleton instance

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

customers_controller = client.customers

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)

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)

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_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)

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)

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)

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_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)

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)

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)

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)

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)

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 = 63
size = 63

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

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 = 63
size = 63

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

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)

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)

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_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_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 = 63
size = 63

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

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_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)

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

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_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)

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 = 63
size = 63

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

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)

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 = 154
size = 154
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)

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_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)

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)

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)

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)

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)

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)

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

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)

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_transfers

Gets all transfers

def get_transfers; end

Example Usage

result = transfers_controller.get_transfers()

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

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)

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_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)

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_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 = 154
size = 154

result = recipients_controller.get_recipients(page, size)

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)

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)

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)

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 = 154
size = 154
status = 'status'
created_since = DateTime.now
created_until = DateTime.now

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

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)

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_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)

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_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 = 154
size = 154
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)

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_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 = 154
size = 154
status = 'status'
created_since = DateTime.now
created_until = DateTime.now

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

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)

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_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)

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)

get_default_recipient

TODO: Add a method description

def get_default_recipient; end

Example Usage

result = recipients_controller.get_default_recipient()

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

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