Class: AdvancedBilling::PaymentProfilesController

Inherits:

BaseController

• Object
• BaseController
• AdvancedBilling::PaymentProfilesController

Defined in:

lib/advanced_billing/controllers/payment_profiles_controller.rb

Overview

PaymentProfilesController

Constant Summary

Constants inherited from BaseController

BaseController::GLOBAL_ERRORS

Instance Attribute Summary

Attributes inherited from BaseController

#config, #http_call_back

Instance Method Summary

• #change_subscription_default_payment_profile(subscription_id, payment_profile_id) ⇒ PaymentProfileResponse

  This will change the default payment profile on the subscription to the existing payment profile with the id specified.

• #change_subscription_group_default_payment_profile(uid, payment_profile_id) ⇒ PaymentProfileResponse

  This will change the default payment profile on the subscription group to the existing payment profile with the id specified.

• #create_payment_profile(body: nil) ⇒ PaymentProfileResponse

  Creates a payment profile for a customer.

• #delete_subscription_group_payment_profile(uid, payment_profile_id) ⇒ void

  This will delete a Payment Profile belonging to a Subscription Group.

• #delete_subscriptions_payment_profile(subscription_id, payment_profile_id) ⇒ void

  This will delete a payment profile belonging to the customer on the subscription.

• #delete_unused_payment_profile(payment_profile_id) ⇒ void

  Deletes an unused payment profile.

• #list_payment_profiles(options = {}) ⇒ Array[PaymentProfileResponse]

  This method will return all of the active ‘payment_profiles` for a Site, or for one Customer within a site.

• #read_one_time_token(chargify_token) ⇒ GetOneTimeTokenRequest

  One Time Tokens aka Advanced Billing Tokens house the credit card or ACH (Authorize.Net or Stripe only) data for a customer.

• #read_payment_profile(payment_profile_id) ⇒ PaymentProfileResponse

  Using the GET method you can retrieve a Payment Profile identified by its unique ID.

• #send_request_update_payment_email(subscription_id) ⇒ void

  You can send a “request payment update” email to the customer associated with the subscription.

• #update_payment_profile(payment_profile_id, body: nil) ⇒ PaymentProfileResponse

  ## Partial Card Updates In the event that you are using the Authorize.net, Stripe, Cybersource, Forte or Braintree Blue payment gateways, you can update just the billing and contact information for a payment method.

• #verify_bank_account(bank_account_id, body: nil) ⇒ BankAccountResponse

  Submit the two small deposit amounts the customer received in their bank account in order to verify the bank account.

Methods inherited from BaseController

#initialize, #new_parameter, #new_request_builder, #new_response_handler, user_agent, user_agent_parameters

Constructor Details

This class inherits a constructor from AdvancedBilling::BaseController

Instance Method Details

#change_subscription_default_payment_profile(subscription_id, payment_profile_id) ⇒ PaymentProfileResponse

This will change the default payment profile on the subscription to the existing payment profile with the id specified. You must elect to change the existing payment profile to a new payment profile ID in order to receive a satisfactory response from this endpoint. the subscription the payment profile

Parameters:

• subscription_id (Integer) —

  Required parameter: The Chargify id of

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

Returns:

• (PaymentProfileResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 472

def change_subscription_default_payment_profile(subscription_id,
                                                payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/subscriptions/{subscription_id}/payment_profiles/{payment_profile_id}/change_payment_profile.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(subscription_id, key: 'subscription_id')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .local_error('404',
                             'Not Found',
                             APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end

#change_subscription_group_default_payment_profile(uid, payment_profile_id) ⇒ PaymentProfileResponse

This will change the default payment profile on the subscription group to the existing payment profile with the id specified. You must elect to change the existing payment profile to a new payment profile ID in order to receive a satisfactory response from this endpoint. The new payment profile must belong to the subscription group’s customer, otherwise you will receive an error. group the payment profile

Parameters:

• uid (String) —

  Required parameter: The uid of the subscription

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

Returns:

• (PaymentProfileResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 510

def change_subscription_group_default_payment_profile(uid,
                                                      payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/subscription_groups/{uid}/payment_profiles/{payment_profile_id}/change_payment_profile.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(uid, key: 'uid')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end

#create_payment_profile(body: nil) ⇒ PaymentProfileResponse

Creates a payment profile for a customer. When you create a new payment profile for a customer via the API, it does not automatically make the profile current for any of the customer’s subscriptions. To use the payment profile as the default, you must set it explicitly for the subscription or subscription group. Select an option from the **Request Examples** drop-down on the right side of the portal to see examples of common scenarios for creating payment profiles. Do not use real card information for testing. See the Sites articles that cover [testing your site setup](docs.maxio.com/hc/en-us/articles/24250712113165-Testing-Ove rview#testing-overview-0-0) for more details on testing in your sandbox. Note that collecting and sending raw card details in production requires [PCI compliance](docs.maxio.com/hc/en-us/articles/24183956938381-PCI-Co mpliance#pci-compliance-0-0) on your end. If your business is not PCI compliant, use [Chargify.js](docs.maxio.com/hc/en-us/articles/38163190843789-Char gify-js-Overview#chargify-js-overview-0-0) to collect credit card or bank account information. See the following articles to learn more about subscriptions and payments: + [Subscriber Payment Details](maxio.zendesk.com/hc/en-us/articles/24251599929613-Subscr iption-Summary-Payment-Details-Tab) + [Self Service Pages](maxio.zendesk.com/hc/en-us/articles/24261425318541-Self-Ser vice-Pages) (Allows credit card updates by Subscriber) + [Public Signup Pages payment settings](maxio.zendesk.com/hc/en-us/articles/24261368332557-Indiv idual-Page-Settings) + [Taxes](developers.chargify.com/docs/developer-docs/d2e9e34db740e- signups#taxes) + [Chargify.js](docs.maxio.com/hc/en-us/articles/38163190843789-Char gify-js-Overview)

+ [Chargify.js with GoCardless - minimal

example](docs.maxio.com/hc/en-us/articles/38206331271693-Examples# h_01K0PJ15QQZKCER8CFK40MR6XJ)

+ [Chargify.js with GoCardless - full

example](docs.maxio.com/hc/en-us/articles/38206331271693-Examples# h_01K0PJ15QR09JVHWW0MCA7HVJV)

+ [Chargify.js with Stripe Direct Debit - minimal

example](docs.maxio.com/hc/en-us/articles/38206331271693-Examples# h_01K0PJ15QQFKKN8Z7B7DZ9AJS5)

+ [Chargify.js with Stripe Direct Debit - full

example](docs.maxio.com/hc/en-us/articles/38206331271693-Examples# h_01K0PJ15QRECQQ4ECS3ZA55GY7)

+ [Chargify.js with Stripe BECS Direct Debit - minimal

example](developers.chargify.com/docs/developer-docs/ZG9jOjE0NjAzN DIy-examples#minimal-example-with-sepa-or-becs-direct-debit-stripe-gateway )

+ [Chargify.js with Stripe BECS Direct Debit - full

example](developers.chargify.com/docs/developer-docs/ZG9jOjE0NjAzN DIy-examples#full-example-with-sepa-direct-debit-stripe-gateway) + [Full documentation on GoCardless](maxio.zendesk.com/hc/en-us/articles/24176159136909-GoC ardless) + [Full documentation on Stripe SEPA Direct Debit](maxio.zendesk.com/hc/en-us/articles/24176170430093-Stripe-S EPA-and-BECS-Direct-Debit) + [Full documentation on Stripe BECS Direct Debit](maxio.zendesk.com/hc/en-us/articles/24176170430093-Stripe-S EPA-and-BECS-Direct-Debit) + [Full documentation on Stripe BACS Direct Debit](maxio.zendesk.com/hc/en-us/articles/24176170430093-Stripe-S EPA-and-BECS-Direct-Debit) ## 3D Secure Authentication during payment profile creation. When a payment requires 3D Secure Authentication to adhear to Strong Customer Authentication (SCA) during payment profile creation, the request enters a [post-authentication flow](maxio.zendesk.com/hc/en-us/articles/24176278996493-Testing-I mplementing-3D-Secure#psd2-flows-pre-authentication-and-post-authenticatio n). In this case, a 422 Unprocessable Entity status is returned with the following response: “‘json {

"jsonapi": {
    "version": "1.0"
},
"errors": [
    {
        "title": "This card requires 3DSecure verification.",
        "detail": "This card requires 3D secure authentication.

Redirect the customer to the URL from the action_link attribute to authenticate. Attach callback_url param to this URL if you want to be notified about the result of 3D Secure authentication. Attach redirect_url param to this URL if you want to redirect a customer back to your page after 3D Secure authentication. Example: checkout-test.chargifypay.test/3d-secure/checkout/pay_uerzhsxd5uhk bodx5jhvkg6yeu?one_time_token_id=93&callback_url=localhost:4000&red irect_url=yourpage.com will do a POST request to localhost:4000 after credit card is authenticated and will redirect a customer to yourpage.com after 3DS authentication.“,

"links": {
    "action_link":

“checkout-test.chargifypay.test/3d-secure/checkout/pay_uerzhsxd5uh kbodx5jhvkg6yeu?one_time_token_id=93”

        }
    }
]

} “‘ To let the customer go through 3D Secure Authentication, they need to be redirected to the URL specified in `action_link`. Optionally, you can specify the `callback_url` parameter in the `action_link` URL to receive notification about the result of 3D Secure Authentication. The `callback_url` will return the following information:

• whether the authentication was successful (‘success`)

• the payment profile ID (‘payment_profile_id`)

You can also specify a ‘redirect_url` parameter in the `action_link` URL to redirect the customer back to your site. You cannot use action_link in an iframe inside a custom application. You must redirect the customer directly to the `action_link` and use the `redirect_url` or `callback_url` to be notified of the result. The final URL that you send a customer to complete 3D Secure may resemble the following, where the first half is the `action_link` and the second half contains a `redirect_url` and `callback_url`:

‘checkout-test.chargifypay.test/3d-secure/checkout/pay_uerzhsxd5uh kbodx5jhvkg6yeu?one_time_token_id=93&callback_url=localhost:4000&re direct_url=yourpage.com` ### Example Redirect Flow Here’s an example flow to redirect customers to different pages depending on whether SCA was performed successfully:

1. Create a payment profile via the API; it requires 3DS.

2. You receive an ‘action_link` in the response.

3. Use this ‘action_link` to, for example, connect with your internal

resources or generate a ‘session_id`.

1. Include one of those attributes inside the ‘callback_url` and

‘redirect_url` to be aware which “session” this applies to.

1. Redirect the customer to the ‘action_link` with `callback_url` and

‘redirect_url` applied

1. After the customer completes 3DS authentication, we notify you of the

result via the applied ‘callback_url`.

1. After that, we redirect the customer to the ‘redirect_url`; at this

point the result of authentication is known.

1. Optionally, you can use the applied “msg” param in the ‘redirect_url`

to determine if the redirect was successful. following the IBAN or the Local Bank details examples, a customer, bank account and mandate will be created in your current vault. If the customer, bank account, and mandate already exist in your vault, follow the Import example to link the payment profile into Advanced Billing.

Parameters:

• body (CreatePaymentProfileRequest) (defaults to: nil) —

  Optional parameter: When

Returns:

• (PaymentProfileResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 155

def create_payment_profile(body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/payment_profiles.json',
                                 Server::PRODUCTION)
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .local_error_template('404',
                                      'Not Found:\'{$response.body}\'',
                                      APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end

#delete_subscription_group_payment_profile(uid, payment_profile_id) ⇒ void

This method returns an undefined value.

This will delete a Payment Profile belonging to a Subscription Group. Note: If the Payment Profile belongs to multiple Subscription Groups and/or Subscriptions, it will be removed from all of them. group the payment profile

Parameters:

• uid (String) —

  Required parameter: The uid of the subscription

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 445

def delete_subscription_group_payment_profile(uid,
                                              payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/subscription_groups/{uid}/payment_profiles/{payment_profile_id}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(uid, key: 'uid')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .is_response_void(true))
    .execute
end

#delete_subscriptions_payment_profile(subscription_id, payment_profile_id) ⇒ void

This method returns an undefined value.

This will delete a payment profile belonging to the customer on the subscription. + If the customer has multiple subscriptions, the payment profile will be removed from all of them. + If you delete the default payment profile for a subscription, you will need to specify another payment profile to be the default through the api, or either prompt the user to enter a card in the billing portal or on the self-service page, or visit the Payment Details tab on the subscription in the Admin UI and use the “Add New Credit Card” or “Make Active Payment Method” link, (depending on whether there are other cards present). the subscription the payment profile

Parameters:

• subscription_id (Integer) —

  Required parameter: The Chargify id of

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 385

def delete_subscriptions_payment_profile(subscription_id,
                                         payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/subscriptions/{subscription_id}/payment_profiles/{payment_profile_id}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(subscription_id, key: 'subscription_id')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .is_response_void(true))
    .execute
end

#delete_unused_payment_profile(payment_profile_id) ⇒ void

This method returns an undefined value.

Deletes an unused payment profile. If the payment profile is in use by one or more subscriptions or groups, a 422 and error message will be returned. the payment profile

Parameters:

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 349

def delete_unused_payment_profile(payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/payment_profiles/{payment_profile_id}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .is_response_void(true)
                .local_error('404',
                             'Not Found',
                             APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end

#list_payment_profiles(options = {}) ⇒ Array[PaymentProfileResponse]

This method will return all of the active ‘payment_profiles` for a Site, or for one Customer within a site. If no payment profiles are found, this endpoint will return an empty array, not a 404. pages. By default, the first page of results is displayed. The page parameter specifies a page number of results to fetch. You can start navigating through the pages to consume the results. You do this by passing in a page parameter. Retrieve the next page by adding ?page=2 to the query string. If there are no results to return, then an empty result set will be returned. Use in query `page=1`. many records to fetch in each request. Default value is 20. The maximum allowed values is 200; any per_page value over 200 will be changed to 200. Use in query `per_page=200`. for which you wish to list payment profiles

Parameters:

• page (Integer) —

  Optional parameter: Result records are organized in

• per_page (Integer) —

  Optional parameter: This parameter indicates how

• customer_id (Integer) —

  Optional parameter: The ID of the customer

Returns:

• (Array[PaymentProfileResponse]) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 195

def list_payment_profiles(options = {})
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/payment_profiles.json',
                                 Server::PRODUCTION)
               .query_param(new_parameter(options['page'], key: 'page'))
               .query_param(new_parameter(options['per_page'], key: 'per_page'))
               .query_param(new_parameter(options['customer_id'], key: 'customer_id'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .is_response_array(true))
    .execute
end

#read_one_time_token(chargify_token) ⇒ GetOneTimeTokenRequest

One Time Tokens aka Advanced Billing Tokens house the credit card or ACH (Authorize.Net or Stripe only) data for a customer. You can use One Time Tokens while creating a subscription or payment profile instead of passing all bank account or credit card data directly to a given API endpoint. To obtain a One Time Token you have to use [Chargify.js](docs.maxio.com/hc/en-us/articles/38163190843789-Char gify-js-Overview#chargify-js-overview-0-0). Token

Parameters:

• chargify_token (String) —

  Required parameter: Advanced Billing

Returns:

• (GetOneTimeTokenRequest) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 545

def read_one_time_token(chargify_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/one_time_tokens/{chargify_token}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(chargify_token, key: 'chargify_token')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(GetOneTimeTokenRequest.method(:from_hash))
                .local_error_template('404',
                                      'Not Found:\'{$response.body}\'',
                                      ErrorListResponseException))
    .execute
end

#read_payment_profile(payment_profile_id) ⇒ PaymentProfileResponse

Using the GET method you can retrieve a Payment Profile identified by its unique ID. Note that a different JSON object will be returned if the card method on file is a bank account. ### Response for Bank Account Example response for Bank Account: “‘ {

"payment_profile": {
  "id": 10089892,
  "first_name": "Chester",
  "last_name": "Tester",
  "created_at": "2025-01-01T00:00:00-05:00",
  "updated_at": "2025-01-01T00:00:00-05:00",
  "customer_id": 14543792,
  "current_vault": "bogus",
  "vault_token": "0011223344",
  "billing_address": "456 Juniper Court",
  "billing_city": "Boulder",
  "billing_state": "CO",
  "billing_zip": "80302",
  "billing_country": "US",
  "customer_vault_token": null,
  "billing_address_2": "",
  "bank_name": "Bank of Kansas City",
  "masked_bank_routing_number": "XXXX6789",
  "masked_bank_account_number": "XXXX3344",
  "bank_account_type": "checking",
  "bank_account_holder_type": "personal",
  "payment_type": "bank_account",
  "site_gateway_setting_id": 1,
  "gateway_handle": null
}

} “‘ the payment profile

Parameters:

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

Returns:

• (PaymentProfileResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 250

def read_payment_profile(payment_profile_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/payment_profiles/{payment_profile_id}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .local_error('404',
                             'Not Found',
                             APIException))
    .execute
end

#send_request_update_payment_email(subscription_id) ⇒ void

This method returns an undefined value.

You can send a “request payment update” email to the customer associated with the subscription. If you attempt to send a “request payment update” email more than five times within a 30-minute period, you will receive a ‘422` response with an error message in the body. This error message will indicate that the request has been rejected due to excessive attempts, and will provide instructions on how to resubmit the request. Additionally, if you attempt to send a “request payment update” email for a subscription that does not exist, you will receive a `404` error response. This error message will indicate that the subscription could not be found, and will provide instructions on how to correct the error and resubmit the request. These error responses are designed to prevent excessive or invalid requests, and to provide clear and helpful information to users who encounter errors during the request process. the subscription

Parameters:

• subscription_id (Integer) —

  Required parameter: The Chargify id of

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 582

def send_request_update_payment_email(subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/subscriptions/{subscription_id}/request_payment_profiles_update.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(subscription_id, key: 'subscription_id')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .is_response_void(true)
                .local_error_template('404',
                                      'Not Found:\'{$response.body}\'',
                                      APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end

#update_payment_profile(payment_profile_id, body: nil) ⇒ PaymentProfileResponse

## Partial Card Updates In the event that you are using the Authorize.net, Stripe, Cybersource, Forte or Braintree Blue payment gateways, you can update just the billing and contact information for a payment method. Note the lack of credit-card related data contained in the JSON payload. In this case, the following JSON is acceptable: “‘ {

"payment_profile": {
  "first_name": "Kelly",
  "last_name": "Test",
  "billing_address": "789 Juniper Court",
  "billing_city": "Boulder",
  "billing_state": "CO",
  "billing_zip": "80302",
  "billing_country": "US",
  "billing_address_2": null
}

} “‘ The result will be that you have updated the billing information for the card, yet retained the original card number data. ## Specific notes on updating payment profiles

• Merchants with Authorize.net, Cybersource, Forte,

**Braintree Blue** or Stripe as their payment gateway can update their Customer’s credit cards without passing in the full credit card number and CVV.

• If you are using Authorize.net, Cybersource, Forte,

**Braintree Blue** or Stripe, Advanced Billing will ignore the credit card number and CVV when processing an update via the API, and attempt a partial update instead. If you wish to change the card number on a payment profile, you will need to create a new payment profile for the given customer.

• A Payment Profile cannot be updated with the attributes of another type

of Payment Profile. For example, if the payment profile you are attempting to update is a credit card, you cannot pass in bank account attributes (like ‘bank_account_number`), and vice versa.

• Updating a payment profile directly will not trigger an attempt to

capture a past-due balance. If this is the intent, update the card details via the Subscription instead.

• If you are using Authorize.net or Stripe, you may elect to manually

trigger a retry for a past due subscription after a partial update. the payment profile description here

Parameters:

• payment_profile_id (Integer) —

  Required parameter: The Chargify id of

• body (UpdatePaymentProfileRequest) (defaults to: nil) —

  Optional parameter: TODO: type

Returns:

• (PaymentProfileResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 316

def update_payment_profile(payment_profile_id,
                           body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/payment_profiles/{payment_profile_id}.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(payment_profile_id, key: 'payment_profile_id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentProfileResponse.method(:from_hash))
                .local_error('404',
                             'Not Found',
                             APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorStringMapResponseException))
    .execute
end

#verify_bank_account(bank_account_id, body: nil) ⇒ BankAccountResponse

Submit the two small deposit amounts the customer received in their bank account in order to verify the bank account. (Stripe only) bank account in the system. type description here

Parameters:

• bank_account_id (Integer) —

  Required parameter: Identifier of the

• body (BankAccountVerificationRequest) (defaults to: nil) —

  Optional parameter: TODO:

Returns:

• (BankAccountResponse) —

  Response from the API call.

# File 'lib/advanced_billing/controllers/payment_profiles_controller.rb', line 410

def verify_bank_account(bank_account_id,
                        body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/bank_accounts/{bank_account_id}/verification.json',
                                 Server::PRODUCTION)
               .template_param(new_parameter(bank_account_id, key: 'bank_account_id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(BankAccountResponse.method(:from_hash))
                .local_error_template('404',
                                      'Not Found:\'{$response.body}\'',
                                      APIException)
                .local_error_template('422',
                                      'HTTP Response Not OK. Status code: {$statusCode}.'\
                                       ' Response: \'{$response.body}\'.',
                                      ErrorListResponseException))
    .execute
end