class Beaver::APIController

APIController

Public Class Methods

new(config, http_call_back: nil) click to toggle source
Calls superclass method
# File lib/beaver/controllers/api_controller.rb, line 9
def initialize(config, http_call_back: nil)
  super(config, http_call_back: http_call_back)
end

Public Instance Methods

delete_items_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The DELETE /items/{id} call allows your platform to delete an item. Items describe an item or service for sale. For standardized merchandise, an item could be a stock keeping unit (SKU). @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [ItemResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1470
def delete_items_id(id,
                    app_id,
                    app_token,
                    api_version,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/items/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  ItemResp.from_hash(decoded)
end
delete_notification_preferences_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The DELETE /notification_preferences/{id} call allows your platform to delete a notification preference. Notification preferences allow your platform to subscribe to notifications based on an event topic. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [NotificationPreferencesResponse1] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2506
def delete_notification_preferences_id(id,
                                       app_id,
                                       app_token,
                                       api_version,
                                       unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notification_preferences/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, RESOURCE_PREVIOUSLY_DELETED',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationPreferencesResponse1.from_hash(decoded)
end
delete_orders_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The DELETE /orders/{id} call allows your platform to delete an order. Orders identify both the merchant and payer, and describe items sold, shipment date, prices, delivery details, and payment terms. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [OrderResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2778
def delete_orders_id(id,
                     app_id,
                     app_token,
                     api_version,
                     unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/orders/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  OrderResp.from_hash(decoded)
end
delete_payment_methods_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The DELETE /payment_methods/{id} call allows your platform to delete a single payment method. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3633
def delete_payment_methods_id(id,
                              app_id,
                              app_token,
                              api_version,
                              unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, PAYMENT_METHOD_CANNOT_BE_DELETED',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodResp.from_hash(decoded)
end
delete_rbits_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The DELETE /rbits call allows you to delete an rbit. The rbits resource provides a way to communicate risk-related account and transaction level information between an application and WePay. An rbit contains risk related information about your users, their accounts, and their transactions. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [RbitsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4521
def delete_rbits_id(id,
                    app_id,
                    app_token,
                    api_version,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/rbits/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RbitsResponse.from_hash(decoded)
end
delete_terminals_id(app_id, app_token, api_version, id) click to toggle source

Delete's the terminal from the system, marking it as deleted. The physical terminal represented by this API record will not be able to process payments until it is onboarded again. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] id Required parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5382
def delete_terminals_id(app_id,
                        app_token,
                        api_version,
                        id)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.delete(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
get_accounts(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, beneficiary_legal_entity_id: nil, reference_id: nil) click to toggle source

The GET /accounts call allows your platform to look up a collection of accounts. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: Example: @param [String] beneficiary_legal_entity_id Optional parameter: Filter search window by elements that match the account's beneficiary legal entity. @param [String] reference_id Optional parameter: Return elements having this reference_id. @return [AccountsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 104
def get_accounts(app_id,
                 app_token,
                 api_version,
                 unique_key: nil,
                 page: nil,
                 page_size: 10,
                 create_time_start: nil,
                 create_time_end: nil,
                 owner_id: nil,
                 beneficiary_legal_entity_id: nil,
                 reference_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'beneficiary_legal_entity_id' => beneficiary_legal_entity_id,
    'reference_id' => reference_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  AccountsResponse.from_hash(decoded)
end
get_accounts_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /accounts/{id} call allows your platform to look up a single account. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [AccountResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 259
def get_accounts_id(id,
                    app_id,
                    app_token,
                    api_version,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 401
    raise APIException.new(
      'COULD_NOT_AUTHENTICATE',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  AccountResp.from_hash(decoded)
end
get_accounts_id_capabilities(id, app_id, app_token, api_version, unique_key: nil, is_expanded: true) click to toggle source

The GET /accounts/{id}/capabilities call allows your platform to look up an account's capabilities. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [Boolean] is_expanded Optional parameter: Return a descriptive response enumerating any unfulfilled requirements. @return [CapabilitiesResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 405
def get_accounts_id_capabilities(id,
                                 app_id,
                                 app_token,
                                 api_version,
                                 unique_key: nil,
                                 is_expanded: true)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts/{id}/capabilities'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'is_expanded' => is_expanded
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  CapabilitiesResp.from_hash(decoded)
end
get_adjustments(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil) click to toggle source

The GET /adjustments call allows your platform to look up a collection of adjustments. The adjustments resource notifies your platform that WePay made an adjustment to an account. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: Example: @return [AdjustmentsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 483
def get_adjustments(app_id,
                    app_token,
                    api_version,
                    unique_key: nil,
                    page: nil,
                    page_size: 10,
                    create_time_start: nil,
                    create_time_end: nil,
                    owner_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/adjustments'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  AdjustmentsResponse.from_hash(decoded)
end
get_adjustments_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /adjustments/{id} call allows your platform to look up a single adjustment. The adjustments resource notifies your platform that WePay made an adjustment to an account. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Adjustments] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 555
def get_adjustments_id(id,
                       app_id,
                       app_token,
                       api_version,
                       unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/adjustments/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Adjustments.from_hash(decoded)
end
get_billing_statements(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, account_id: nil) click to toggle source

The GET /billing_statements call allows your platform to look up a collection of billing statements. Billing statements provide aggregate transaction amounts for an account in a certain time period. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [String] account_id Optional parameter: All billing statements owned by an account. @return [BillingStatementsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 692
def get_billing_statements(app_id,
                           app_token,
                           api_version,
                           unique_key: nil,
                           page: nil,
                           page_size: 10,
                           account_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/billing_statements'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'account_id' => account_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  BillingStatementsResponse.from_hash(decoded)
end
get_billing_statements_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /billing_statements/{id} call allows your platform to look up a single billing statement. Billing statements provide aggregate transaction amounts for an account in a certain time period. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [BillingStatement] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 760
def get_billing_statements_id(id,
                              app_id,
                              app_token,
                              api_version,
                              unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/billing_statements/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  BillingStatement.from_hash(decoded)
end
get_billing_statements_id_interchange_fees(id, app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10) click to toggle source

Look up summaries of interchange fee transactions in a billing statement. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @return [BillingStatementsInterchangeFeesResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 826
def get_billing_statements_id_interchange_fees(id,
                                               app_id,
                                               app_token,
                                               api_version,
                                               unique_key: nil,
                                               page: nil,
                                               page_size: 10)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/billing_statements/{id}/interchange_fees'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  BillingStatementsInterchangeFeesResponse.from_hash(decoded)
end
get_billing_statements_id_transactions_summary(id, app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10) click to toggle source

The GET /billing_statements/{id}/transactions_summary call allows your platform to look up all transactions in a single billing statement. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @return [BillingStatementsTransactionsSummaryResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 900
def get_billing_statements_id_transactions_summary(id,
                                                   app_id,
                                                   app_token,
                                                   api_version,
                                                   unique_key: nil,
                                                   page: nil,
                                                   page_size: 10)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/billing_statements/{id}/transactions_summary'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  BillingStatementsTransactionsSummaryResponse.from_hash(decoded)
end
get_disputes(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, type: nil, payment_id: nil, status: nil) click to toggle source

The GET /disputes call allows your platform to look up a collection of disputes. Disputes represent a conflict between a payer and merchant. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: Example: @param [Type6Enum] type Optional parameter: The type of dispute to filter by @param [String] payment_id Optional parameter: Example: @param [Status5Enum] status Optional parameter: Example: @return [DisputesResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 983
def get_disputes(app_id,
                 app_token,
                 api_version,
                 unique_key: nil,
                 page: nil,
                 page_size: 10,
                 create_time_start: nil,
                 create_time_end: nil,
                 owner_id: nil,
                 type: nil,
                 payment_id: nil,
                 status: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/disputes'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'type' => type,
    'payment_id' => payment_id,
    'status' => status
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  DisputesResponse.from_hash(decoded)
end
get_disputes_id(id, app_id, app_token, api_version, content_type, unique_key: nil) click to toggle source

The GET /disputes/{id} call allows your platform to look up a single dispute. Disputes represent a conflict between a payer and merchant. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] content_type Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Disputes] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1061
def get_disputes_id(id,
                    app_id,
                    app_token,
                    api_version,
                    content_type,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/disputes/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Content-Type' => content_type,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Disputes.from_hash(decoded)
end
get_items(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, reference_number: nil) click to toggle source

The GET /items call allows your platform to look up a collection of items. Items describe an item or service for sale. For standardized merchandise, an item could be a stock keeping unit (SKU). @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] reference_number Optional parameter: Return elements with this reference number. @return [ItemsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1334
def get_items(app_id,
              app_token,
              api_version,
              unique_key: nil,
              page: nil,
              page_size: 10,
              create_time_start: nil,
              create_time_end: nil,
              reference_number: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/items'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'reference_number' => reference_number
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  ItemsResponse.from_hash(decoded)
end
get_items_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /items/{id} call allows your platform to look up a single item. Items describe an item or service for sale. For standardized merchandise, an item could be a stock keeping unit (SKU). @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [ItemResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1406
def get_items_id(id,
                 app_id,
                 app_token,
                 api_version,
                 unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/items/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  ItemResp.from_hash(decoded)
end
get_notification_preferences(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, type: nil, status: nil, topic: nil, callback_uri: nil) click to toggle source

The GET /notification_preferences call allows your platform to look up a collection of notification preferences. Notification preferences allow your platform to subscribe to notifications based on an event topic. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [Type27Enum] type Optional parameter: Type of notification preference @param [Status20Enum] status Optional parameter: Status of the notification preference @param [TopicEnum] topic Optional parameter: Topic of the notification preference to search for. @param [String] callback_uri Optional parameter: Callback URI of the notification preference to search for. @return [NotificationPreferencesResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2232
def get_notification_preferences(app_id,
                                 app_token,
                                 api_version,
                                 unique_key: nil,
                                 page: nil,
                                 page_size: 10,
                                 create_time_start: nil,
                                 create_time_end: nil,
                                 type: nil,
                                 status: nil,
                                 topic: nil,
                                 callback_uri: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notification_preferences'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'type' => type,
    'status' => status,
    'topic' => topic,
    'callback_uri' => callback_uri
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationPreferencesResponse.from_hash(decoded)
end
get_notification_preferences_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /notification_preferences/{id} call allows your platform to look up a single notification preference. Notification preferences allow your platform to subscribe to notifications based on an event topic. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [NotificationPreferencesResponse2] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2373
def get_notification_preferences_id(id,
                                    app_id,
                                    app_token,
                                    api_version,
                                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notification_preferences/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationPreferencesResponse2.from_hash(decoded)
end
get_notifications(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, object_type: nil, object_id: nil, event_time_start: nil, event_time_end: nil) click to toggle source

The GET /notifications call allows your platform to look up a collection of notifications. The notifications resource allows your platform to retrieve details on a specific notification or a collection of notifications. Your platform can utilize notifications to gain insight into WePay’s system, communicate with your users, monitor issues, etc. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [String] object_type Optional parameter: Scope type of a notification @param [String] object_id Optional parameter: Scope id of a notification @param [Integer] event_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] event_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @return [NotificationsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2076
def get_notifications(app_id,
                      app_token,
                      api_version,
                      unique_key: nil,
                      page: nil,
                      page_size: 10,
                      object_type: nil,
                      object_id: nil,
                      event_time_start: nil,
                      event_time_end: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notifications'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'object_type' => object_type,
    'object_id' => object_id,
    'event_time_start' => event_time_start,
    'event_time_end' => event_time_end
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationsResponse.from_hash(decoded)
end
get_notifications_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /notifications/{id} call allows your platform to look up a notification. The notifications resource allows your platform to retrieve details on a specific notification or a collection of notifications. Your platform can utilize notifications to gain insight into WePay’s system, communicate with your users, monitor issues, etc. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [NotificationsResponse1] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2152
def get_notifications_id(id,
                         app_id,
                         app_token,
                         api_version,
                         unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notifications/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationsResponse1.from_hash(decoded)
end
get_orders(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, reference_number: nil) click to toggle source

The GET /orders call allows your platform to look up a collection of orders. Orders identify both the merchant and payer, and describe items sold, shipment date, prices, delivery details, and payment terms. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] reference_number Optional parameter: Return elements with this reference number. @return [OrdersResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2642
def get_orders(app_id,
               app_token,
               api_version,
               unique_key: nil,
               page: nil,
               page_size: 10,
               create_time_start: nil,
               create_time_end: nil,
               reference_number: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/orders'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'reference_number' => reference_number
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  OrdersResponse.from_hash(decoded)
end
get_orders_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /orders/{id} call allows your platform to look up a single order. Orders identify both the merchant and payer, and describe items sold, shipment date, prices, delivery details, and payment terms. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [OrderResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2714
def get_orders_id(id,
                  app_id,
                  app_token,
                  api_version,
                  unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/orders/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  OrderResp.from_hash(decoded)
end
get_payment_methods(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, card_brand: nil, card_last_four: nil, bank_routing_number: nil, bank_last_four: nil, type: nil) click to toggle source

The GET /payment_methods call allows your platform to look up a collection of payment methods. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [CardBrand2Enum] card_brand Optional parameter: The brand of the card to search for. @param [String] card_last_four Optional parameter: The last 4 digits of the card to search for. @param [String] bank_routing_number Optional parameter: The routing number of the bank to search for. @param [String] bank_last_four Optional parameter: The last 4 of the bank account number to search for. @param [Type3Enum] type Optional parameter: The type of payment method to search for. Required unless page is provided @return [PaymentMethodsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3423
def get_payment_methods(app_id,
                        app_token,
                        api_version,
                        unique_key: nil,
                        page: nil,
                        page_size: 10,
                        create_time_start: nil,
                        create_time_end: nil,
                        card_brand: nil,
                        card_last_four: nil,
                        bank_routing_number: nil,
                        bank_last_four: nil,
                        type: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'card_brand' => card_brand,
    'card_last_four' => card_last_four,
    'bank_routing_number' => bank_routing_number,
    'bank_last_four' => bank_last_four,
    'type' => type
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodsResponse.from_hash(decoded)
end
get_payment_methods_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /payment_methods/{id} call allows your platform to look up a specific payment method. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3568
def get_payment_methods_id(id,
                           app_id,
                           app_token,
                           api_version,
                           unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodResp.from_hash(decoded)
end
get_payments(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, payment_method_type: nil, payment_method_id: nil, status: nil, reference_id: nil) click to toggle source

The GET /payments call allows your platform to look up a collection of payments. undefined @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: Example: @param [PaymentMethodTypeEnum] payment_method_type Optional parameter: The last 4 digits of the card to search for. @param [String] payment_method_id Optional parameter: Example: @param [Status3Enum] status Optional parameter: Example: @param [String] reference_id Optional parameter: The reference_id to search for. @return [PaymentsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2992
def get_payments(app_id,
                 app_token,
                 api_version,
                 unique_key: nil,
                 page: nil,
                 page_size: 10,
                 create_time_start: nil,
                 create_time_end: nil,
                 owner_id: nil,
                 payment_method_type: nil,
                 payment_method_id: nil,
                 status: nil,
                 reference_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'payment_method_type' => payment_method_type,
    'payment_method_id' => payment_method_id,
    'status' => status,
    'reference_id' => reference_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsResponse.from_hash(decoded)
end
get_payments_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /payments/{id} call allows your platform to look up a single payment. undefined @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentsV30] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3071
def get_payments_id(id,
                    app_id,
                    app_token,
                    api_version,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsV30.from_hash(decoded)
end
get_payout_methods(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil) click to toggle source

The GET /payout_methods call allows your platform to look up a collection of payout methods. Payout methods represent payout targets, such as bank accounts. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: The ID of the owning entity for which to find payout methods. Required unless “page” provided. @return [PayoutMethodsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4091
def get_payout_methods(app_id,
                       app_token,
                       api_version,
                       unique_key: nil,
                       page: nil,
                       page_size: 10,
                       create_time_start: nil,
                       create_time_end: nil,
                       owner_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payout_methods'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PayoutMethodsResponse.from_hash(decoded)
end
get_payout_methods_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /payout_methods/{id} call allows your platform to look up a single payout method. Payout methods represent payout targets, such as bank accounts. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PayoutMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4237
def get_payout_methods_id(id,
                          app_id,
                          app_token,
                          api_version,
                          unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payout_methods/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PayoutMethodResp.from_hash(decoded)
end
get_payouts(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, payout_method_type: nil, payout_method_id: nil, status: nil, payment_id: nil, refund_id: nil, dispute_id: nil, recovery_id: nil, adjustment_id: nil) click to toggle source

The GET /payouts call allows your platform to look up a collection of payouts. Payouts allow your merchants to receive their funds from your platform. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: The ID of the owning entity for which to find payouts. @param [PayoutMethodTypeEnum] payout_method_type Optional parameter: The payout method type to search for. @param [String] payout_method_id Optional parameter: Search for a payout that uses this payout method ID. @param [StatusEnum] status Optional parameter: The status of the payout to search for. @param [String] payment_id Optional parameter: Search for a payout that includes funds with this payment ID. @param [String] refund_id Optional parameter: Search for a payout that includes funds with this refund ID. @param [String] dispute_id Optional parameter: Search for a payout that includes funds with this dispute ID. @param [String] recovery_id Optional parameter: Search for a payout that includes funds with this recovery ID. @param [String] adjustment_id Optional parameter: Search for a payout that includes funds with this adjustment ID. @return [PayoutsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3793
def get_payouts(app_id,
                app_token,
                api_version,
                unique_key: nil,
                page: nil,
                page_size: 10,
                create_time_start: nil,
                create_time_end: nil,
                owner_id: nil,
                payout_method_type: nil,
                payout_method_id: nil,
                status: nil,
                payment_id: nil,
                refund_id: nil,
                dispute_id: nil,
                recovery_id: nil,
                adjustment_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payouts'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'payout_method_type' => payout_method_type,
    'payout_method_id' => payout_method_id,
    'status' => status,
    'payment_id' => payment_id,
    'refund_id' => refund_id,
    'dispute_id' => dispute_id,
    'recovery_id' => recovery_id,
    'adjustment_id' => adjustment_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PayoutsResponse.from_hash(decoded)
end
get_payouts_id(id, app_id, app_token, content_type, unique_key: nil) click to toggle source

The GET /payouts/{id} call allows your platform to look up a single payout. Payouts allow your merchants to receive their funds from your platform. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] content_type Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Payout] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3949
def get_payouts_id(id,
                   app_id,
                   app_token,
                   content_type,
                   unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payouts/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Content-Type' => content_type,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Payout.from_hash(decoded)
end
get_rbits(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, owner_type: nil) click to toggle source

The GET /rbits call allows your platform to look up a collection of rbits. The rbits resource provides a way to communicate risk-related account and transaction level information between an application and WePay. An rbit contains risk related information about your users, their accounts, and their transactions. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: The ID of the owner for which to find rbits. @param [String] owner_type Optional parameter: The resource type of the owner for which to find rbits. @return [RbitsResponse1] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4379
def get_rbits(app_id,
              app_token,
              api_version,
              unique_key: nil,
              page: nil,
              page_size: 10,
              create_time_start: nil,
              create_time_end: nil,
              owner_id: nil,
              owner_type: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/rbits'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'owner_type' => owner_type
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RbitsResponse1.from_hash(decoded)
end
get_rbits_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /rbits/{id} call allows your platform to look up a single rbit. The rbits resource provides a way to communicate risk-related account and transaction level information between an application and WePay. An rbit contains risk related information about your users, their accounts, and their transactions. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [RbitsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4455
def get_rbits_id(id,
                 app_id,
                 app_token,
                 api_version,
                 unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/rbits/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RbitsResponse.from_hash(decoded)
end
get_recoveries(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, payout_method_type: nil, payout_method_id: nil, status: nil) click to toggle source

The GET /recoveries call allows your platform to look up a collection of recoveries. The recovery resource notifies your platform that WePay made a recovery attempt to a merchant’s bank account in order to bring their balance up to $0. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: The ID of the owning entity for which to find recoveries. @param [PayoutMethodTypeEnum] payout_method_type Optional parameter: The payout method type to filter by. @param [String] payout_method_id Optional parameter: The payout method id to filter by. @param [StatusEnum] status Optional parameter: The status of recoveries to return. @return [RecoveriesResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4602
def get_recoveries(app_id,
                   app_token,
                   api_version,
                   unique_key: nil,
                   page: nil,
                   page_size: 10,
                   create_time_start: nil,
                   create_time_end: nil,
                   owner_id: nil,
                   payout_method_type: nil,
                   payout_method_id: nil,
                   status: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/recoveries'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'payout_method_type' => payout_method_type,
    'payout_method_id' => payout_method_id,
    'status' => status
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RecoveriesResponse.from_hash(decoded)
end
get_recoveries_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /recoveries/{id} call allows your platform to look up information on a single recovery. The recovery resource notifies your platform that WePay made a recovery attempt to a merchant’s bank account in order to bring their balance up to $0. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Recoveries] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4681
def get_recoveries_id(id,
                      app_id,
                      app_token,
                      api_version,
                      unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/recoveries/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Recoveries.from_hash(decoded)
end
get_refunds(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, owner_id: nil, payment_method_type: nil, payment_method_id: nil, status: nil, payment_id: nil, reference_id: nil) click to toggle source

The GET /refunds call allows your platform to look up a collection of refunds. Refunds facilitate the return of money from the merchant to the payer. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] owner_id Optional parameter: The ID of the owning entity for which to find refunds. @param [PaymentMethodTypeEnum] payment_method_type Optional parameter: The payment method type to filter by. @param [String] payment_method_id Optional parameter: The payment method id to filter by. @param [StatusEnum] status Optional parameter: The status of refunds to return. @param [String] payment_id Optional parameter: The payment id to filter by. @param [String] reference_id Optional parameter: The reference_id to search for. @return [RefundsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4834
def get_refunds(app_id,
                app_token,
                api_version,
                unique_key: nil,
                page: nil,
                page_size: 10,
                create_time_start: nil,
                create_time_end: nil,
                owner_id: nil,
                payment_method_type: nil,
                payment_method_id: nil,
                status: nil,
                payment_id: nil,
                reference_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/refunds'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'owner_id' => owner_id,
    'payment_method_type' => payment_method_type,
    'payment_method_id' => payment_method_id,
    'status' => status,
    'payment_id' => payment_id,
    'reference_id' => reference_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RefundsResponse.from_hash(decoded)
end
get_refunds_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /refunds/{id} call allows your platform to look up a single refund. Refunds facilitate the return of money from the merchant to the payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [RefundResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4977
def get_refunds_id(id,
                   app_id,
                   app_token,
                   api_version,
                   unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/refunds/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RefundResp.from_hash(decoded)
end
get_terminals(app_id, app_token, api_version, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, account_id: nil, reference_id: nil, model: nil, serial_number: nil, status: nil) click to toggle source

Look up a collection of terminals, filtered by the optional specified parameters. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] account_id Optional parameter: Example: @param [String] reference_id Optional parameter: Filter search window by elements that match the reference ID. @param [Model1Enum] model Optional parameter: Filter search window by elements that match the model. @param [String] serial_number Optional parameter: Filter search window by elements that match the serial_number. @param [TerminalsStatusEnum] status Optional parameter: Filter search window by elements that match the status. @return [TerminalsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5185
def get_terminals(app_id,
                  app_token,
                  api_version,
                  page: nil,
                  page_size: 10,
                  create_time_start: nil,
                  create_time_end: nil,
                  account_id: nil,
                  reference_id: nil,
                  model: nil,
                  serial_number: nil,
                  status: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'account_id' => account_id,
    'reference_id' => reference_id,
    'model' => model,
    'serial_number' => serial_number,
    'status' => status
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalsResponse.from_hash(decoded)
end
get_terminals_id(app_id, app_token, api_version, id) click to toggle source

Look up a terminal to see its current status and configuration. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] id Required parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5321
def get_terminals_id(app_id,
                     app_token,
                     api_version,
                     id)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
get_transaction_records(app_id, app_token, api_version, unique_key: nil, page: nil, page_size: 10, create_time_start: nil, create_time_end: nil, account_id: nil, payout_id: nil) click to toggle source

The GET /transaction_records call allows your platform to look up a collection of transaction records. Transactions records represent one entry (e.g. payout) and the impact to an account’s balance. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] page Optional parameter: Return elements starting from this page. If specified, no other query parameters can be specified. @param [Integer] page_size Optional parameter: Maximum number of items per page of results. @param [Integer] create_time_start Optional parameter: The create time epoch timestamp (in seconds) for the start of the search window, inclusive. @param [Integer] create_time_end Optional parameter: The create time epoch timestamp (in seconds) for the end of the search window, inclusive. @param [String] account_id Optional parameter: All transaction records for resources owned by an account (Payments, Refunds, Adjustments, Payouts, Recoveries, Disputes). @param [String] payout_id Optional parameter: All transaction records for resources included in a payout (very useful for reconciliation). @return [TransactionRecordsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5627
def get_transaction_records(app_id,
                            app_token,
                            api_version,
                            unique_key: nil,
                            page: nil,
                            page_size: 10,
                            create_time_start: nil,
                            create_time_end: nil,
                            account_id: nil,
                            payout_id: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/transaction_records'
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'page' => page,
    'page_size' => page_size,
    'create_time_start' => create_time_start,
    'create_time_end' => create_time_end,
    'account_id' => account_id,
    'payout_id' => payout_id
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TransactionRecordsResponse.from_hash(decoded)
end
get_transaction_records_id(id, app_id, app_token, api_version, unique_key: nil) click to toggle source

The GET /transaction_records/{id} call allows your platform to look up a single transaction record. Transactions records represent one entry (e.g. payout) and the impact to an account’s balance. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [TransactionRecord] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5701
def get_transaction_records_id(id,
                               app_id,
                               app_token,
                               api_version,
                               unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/transaction_records/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.get(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TransactionRecord.from_hash(decoded)
end
post_accounts(app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /accounts call allows your platform to create a new account owned by a legal entity. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [AccountsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [AccountResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 24
def post_accounts(app_id,
                  app_token,
                  api_version,
                  body,
                  unique_key: nil,
                  we_pay_risk_token: nil,
                  client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, UNSUPPORTED_COUNTRY, UNSUPPORTED_CURRENCY ',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  AccountResp.from_hash(decoded)
end
post_accounts_id(id, app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /accounts/{id} call allows your platform to update and add custom data to an account. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [AccountsRequest1] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [AccountResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 183
def post_accounts_id(id,
                     app_id,
                     app_token,
                     api_version,
                     body,
                     unique_key: nil,
                     we_pay_risk_token: nil,
                     client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, UNSUPPORTED_COUNTRY, UNSUPPORTED_CURRENCY',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 409
    raise APIException.new(
      'RESOURCE_CONFLICT',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  AccountResp.from_hash(decoded)
end
post_accounts_id_capabilities(id, app_id, app_token, api_version, body, unique_key: nil, is_expanded: true) click to toggle source

The POST /accounts/{id}/capabilities call allows your platform to update an account's capabilities. The accounts resource allows your platform to create a new merchant account for each distinct business purpose. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [AccountsCapabilitiesRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [Boolean] is_expanded Optional parameter: Return a descriptive response enumerating any unfulfilled requirements. @return [CapabilitiesResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 331
def post_accounts_id_capabilities(id,
                                  app_id,
                                  app_token,
                                  api_version,
                                  body,
                                  unique_key: nil,
                                  is_expanded: true)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/accounts/{id}/capabilities'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'is_expanded' => is_expanded
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  CapabilitiesResp.from_hash(decoded)
end
post_adjustments_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /adjustments/{id} call allows your platform to update and add custom data to an adjustment. The adjustments resource notifies your platform that WePay made an adjustment to an account. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [AdjustmentsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Adjustments] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 620
def post_adjustments_id(id,
                        app_id,
                        app_token,
                        api_version,
                        body,
                        unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/adjustments/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Adjustments.from_hash(decoded)
end
post_disputes_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /disputes/{id} call allows your platform to update and add custom data to a single dispute. Disputes represent a conflict between a payer and merchant. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [DisputesRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Disputes] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1128
def post_disputes_id(id,
                     app_id,
                     app_token,
                     api_version,
                     body,
                     unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/disputes/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'DISPUTE_CANNOT_BE_FURTHER_MODIFIED, INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Disputes.from_hash(decoded)
end
post_disputes_id_concede(id, app_id, app_token, api_version, content_type, unique_key: nil) click to toggle source

The POST /disputes/{id}/concede call allows your platform to concede a dispute on behalf of your merchant. Disputes represent a conflict between a payer and merchant. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] content_type Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Disputes] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1196
def post_disputes_id_concede(id,
                             app_id,
                             app_token,
                             api_version,
                             content_type,
                             unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/disputes/{id}/concede'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Content-Type' => content_type,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'DISPUTE_CANNOT_BE_CONCEDED, INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Disputes.from_hash(decoded)
end
post_items(app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /items call allows your platform to create a new item. Items describe an item or service for sale. For standardized merchandise, an item could be a stock keeping unit (SKU). @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [ItemReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [ItemResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1262
def post_items(app_id,
               app_token,
               api_version,
               body,
               unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/items'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  ItemResp.from_hash(decoded)
end
post_items_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /items/{id} call allows your platform to update and add custom data an item. Items describe an item or service for sale. For standardized merchandise, an item could be a stock keeping unit (SKU). @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [ItemReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [ItemResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1535
def post_items_id(id,
                  app_id,
                  app_token,
                  api_version,
                  body,
                  unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/items/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  ItemResp.from_hash(decoded)
end
post_legal_entities(app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /legal_entities call allows your platform to create a new legal entity. Onboarding a merchant requires the creation of a legal entity. A legal entity may be a business, individual, nonprofit, etc., and is completely owned by a single partner application. WePay collects information about the legal entity so we can properly underwrite them when provisioning a merchant account. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [LegalEntity] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [LegalEntityResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1607
def post_legal_entities(app_id,
                        app_token,
                        api_version,
                        body,
                        unique_key: nil,
                        we_pay_risk_token: nil,
                        client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/legal_entities'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, UNSUPPORTED_COUNTRY',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  LegalEntityResp.from_hash(decoded)
end
post_legal_entities_id(id, app_id, app_token, api_version, body, we_pay_risk_token: nil, unique_key: nil) click to toggle source

The POST /legal_entities/{id} call allows your platform to update and add custom data to a legal entity. Onboarding a merchant requires the creation of a legal entity. A legal entity may be a business, individual, nonprofit, etc., and is completely owned by a single partner application. WePay collects information about the legal entity so we can properly underwrite them when provisioning a merchant account. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [LegalEntitiesRequest] body Required parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] unique_key Optional parameter: Example: @return [LegalEntityResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1758
def post_legal_entities_id(id,
                           app_id,
                           app_token,
                           api_version,
                           body,
                           we_pay_risk_token: nil,
                           unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/legal_entities/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, UNSUPPORTED_COUNTRY',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 409
    raise APIException.new(
      'RESOURCE_CONFLICT',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  LegalEntityResp.from_hash(decoded)
end
post_legal_entities_id_verifications(id, app_id, app_token, api_version, body, unique_key: nil, is_expanded: true) click to toggle source

The POST /legal_entities/{id}/verifications call allows your platform to add and update documents to help WePay verify the identity of a legal entity. Onboarding a merchant requires the creation of a legal entity. A legal entity may be a business, individual, nonprofit, etc., and is completely owned by a single partner application. WePay collects information about the legal entity so we can properly underwrite them when provisioning a merchant account. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [LegalEntitiesVerificationsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [Boolean] is_expanded Optional parameter: Return a descriptive response enumerating any unfulfilled requirements. @return [LegalEntitiesVerificationsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 1907
def post_legal_entities_id_verifications(id,
                                         app_id,
                                         app_token,
                                         api_version,
                                         body,
                                         unique_key: nil,
                                         is_expanded: true)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/legal_entities/{id}/verifications'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_builder = APIHelper.append_url_with_query_parameters(
    _query_builder,
    'is_expanded' => is_expanded
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, JSON_PARSE_FAILURE',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 409
    raise APIException.new(
      'RESOURCE_CONFLICT',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  LegalEntitiesVerificationsResponse.from_hash(decoded)
end
post_notification_preferences(app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /notification_preferences call allows your platform to create a new notification preference. Notification preferences allow your platform to subscribe to notifications based on an event topic. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [NotificationPreferencesRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [NotificationPreferencesResponse1] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2311
def post_notification_preferences(app_id,
                                  app_token,
                                  api_version,
                                  body,
                                  unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notification_preferences'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationPreferencesResponse1.from_hash(decoded)
end
post_notification_preferences_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /notification_preferences/{id} call allows your platform to update a notification preference. Notification preferences allow your platform to subscribe to notifications based on an event topic. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [NotificationPreferencesRequest1] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [NotificationPreferencesResponse1] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2439
def post_notification_preferences_id(id,
                                     app_id,
                                     app_token,
                                     api_version,
                                     body,
                                     unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/notification_preferences/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  NotificationPreferencesResponse1.from_hash(decoded)
end
post_orders(app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /orders call allows your platform to create a new order. Orders identify both the merchant and payer, and describe items sold, shipment date, prices, delivery details, and payment terms. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [OrderReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [OrderResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2570
def post_orders(app_id,
                app_token,
                api_version,
                body,
                unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/orders'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  OrderResp.from_hash(decoded)
end
post_orders_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /orders/{id} call allows your platform to update and add custom data an order. Orders identify both the merchant and payer, and describe items sold, shipment date, prices, delivery details, and payment terms. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [OrderReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [OrderResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2843
def post_orders_id(id,
                   app_id,
                   app_token,
                   api_version,
                   body,
                   unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/orders/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  OrderResp.from_hash(decoded)
end
post_payment_methods(app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /payment_methods call allows your platform to create a payment method. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PaymentMethodReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [PaymentMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3338
def post_payment_methods(app_id,
                         app_token,
                         api_version,
                         body,
                         unique_key: nil,
                         we_pay_risk_token: nil,
                         client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, MERCHANT_ACCOUNT_CANNOT_ACCEPT_PAYMENTS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodResp.from_hash(decoded)
end
post_payment_methods_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /payment_methods/{id} call allows your platform to update and add custom data to an existing payment method. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PaymentMethodsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3500
def post_payment_methods_id(id,
                            app_id,
                            app_token,
                            api_version,
                            body,
                            unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodResp.from_hash(decoded)
end
post_payment_methods_id_verify_bank_deposits(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /payment_methods/{id}/verify_bank_deposits call allows your platform to verify a payment method. Payment methods represent payment data like credit cards and bank accounts, and allow your platform to charge and accept money from a payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PaymentMethodsVerifyBankDepositsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3700
def post_payment_methods_id_verify_bank_deposits(id,
                                                 app_id,
                                                 app_token,
                                                 api_version,
                                                 body,
                                                 unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payment_methods/{id}/verify_bank_deposits'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, PAYMENT_METHOD_CANNOT_BE_VERIFIED',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentMethodResp.from_hash(decoded)
end
post_payments(app_id, app_token, api_version, unique_key, body, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /payments call allows your platform to create a new payment. undefined @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Required parameter: Example: @param [PaymentsRequest] body Required parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [PaymentsV30] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 2911
def post_payments(app_id,
                  app_token,
                  api_version,
                  unique_key,
                  body,
                  we_pay_risk_token: nil,
                  client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, MERCHANT_ACCOUNT_CANNOT_ACCEPT_PAYMENTS,' \
      ' TRANSACTION_DECLINED, UNSUPPORTED_CURRENCY',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsV30.from_hash(decoded)
end
post_payments_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /payments/{id} call allows your platform to update and add custom data to a payment. undefined @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PaymentsRequest1] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentsV30] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3135
def post_payments_id(id,
                     app_id,
                     app_token,
                     api_version,
                     body,
                     unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsV30.from_hash(decoded)
end
post_payments_id_cancel(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /payments/{id}/cancel call allows your platform to cancel a payment. undefined @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PaymentsCancelRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [PaymentsV30] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3202
def post_payments_id_cancel(id,
                            app_id,
                            app_token,
                            api_version,
                            body,
                            unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments/{id}/cancel'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, PAYMENT_CANNOT_BE_CANCELED',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsV30.from_hash(decoded)
end
post_payments_id_capture(id, app_id, app_token, api_version, unique_key: nil, body: nil) click to toggle source

The POST /payments/{id}/capture call allows your platform to capture a payment (when `auto_capture` is set to false). undefined @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [PaymentsCaptureRequest] body Optional parameter: Example: @return [PaymentsV30] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3269
def post_payments_id_capture(id,
                             app_id,
                             app_token,
                             api_version,
                             unique_key: nil,
                             body: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payments/{id}/capture'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PaymentsV30.from_hash(decoded)
end
post_payout_methods(app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /payout_methods call allows your platform to create a new payout method owned by a legal entity. Payout methods represent payout targets, such as bank accounts. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PayoutMethodReq] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [PayoutMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4015
def post_payout_methods(app_id,
                        app_token,
                        api_version,
                        body,
                        unique_key: nil,
                        we_pay_risk_token: nil,
                        client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payout_methods'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, MERCHANT_ACCOUNT_CANNOT_ACCEPT_PAYMENTS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PayoutMethodResp.from_hash(decoded)
end
post_payout_methods_id(id, app_id, app_token, api_version, body, unique_key: nil, we_pay_risk_token: nil, client_ip: nil) click to toggle source

The POST /payout_methods/{id} call allows your platform to update and add custom data to a payout method. Payout methods represent payout targets, such as bank accounts. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PayoutMethodsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @param [String] we_pay_risk_token Optional parameter: Example: @param [String] client_ip Optional parameter: Example: @return [PayoutMethodResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4166
def post_payout_methods_id(id,
                           app_id,
                           app_token,
                           api_version,
                           body,
                           unique_key: nil,
                           we_pay_risk_token: nil,
                           client_ip: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payout_methods/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key,
    'WePay-Risk-Token' => we_pay_risk_token,
    'Client-IP' => client_ip
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  PayoutMethodResp.from_hash(decoded)
end
post_payouts_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /payouts/{id} call allows your platform to update and add custom data to a payout. Payouts allow your merchants to receive their funds from your platform. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [PayoutsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Payout] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 3882
def post_payouts_id(id,
                    app_id,
                    app_token,
                    api_version,
                    body,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/payouts/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Payout.from_hash(decoded)
end
post_rbits(app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /rbits call allows your platform to create an rbit for a user, account, or transaction. The rbits resource provides a way to communicate risk-related account and transaction level information between an application and WePay. An rbit contains risk related information about your users, their accounts, and their transactions. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [RbitsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [RbitsResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4303
def post_rbits(app_id,
               app_token,
               api_version,
               body,
               unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/rbits'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RbitsResponse.from_hash(decoded)
end
post_recoveries_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /recoveries/{id} call allows your platform to update and add custom data to a recovery. The recovery resource notifies your platform that WePay made a recovery attempt to a merchant’s bank account in order to bring their balance up to $0. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [RecoveriesRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [Recoveries] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4747
def post_recoveries_id(id,
                       app_id,
                       app_token,
                       api_version,
                       body,
                       unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/recoveries/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  Recoveries.from_hash(decoded)
end
post_refunds(app_id, app_token, api_version, unique_key, body) click to toggle source

The POST /refunds call allows your platform to create a new refund. Refunds facilitate the return of money from the merchant to the payer. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] unique_key Required parameter: Example: @param [RefundReq] body Required parameter: Example: @return [RefundResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 4915
def post_refunds(app_id,
                 app_token,
                 api_version,
                 unique_key,
                 body)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/refunds'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, PAYMENT_CANNOT_BE_REFUNDED',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RefundResp.from_hash(decoded)
end
post_refunds_id(id, app_id, app_token, api_version, body, unique_key: nil) click to toggle source

The POST /refunds/{id} call allows your platform to update and add custom data to a refund. Refunds facilitate the return of money from the merchant to the payer. @param [String] id Required parameter: Example: @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [RefundsRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [RefundResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5042
def post_refunds_id(id,
                    app_id,
                    app_token,
                    api_version,
                    body,
                    unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/refunds/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  RefundResp.from_hash(decoded)
end
post_terminals(app_id, app_token, api_version, body) click to toggle source

Onboard a Point-of-Sale terminal into the WePay system. A terminals resource represents a mechanism by which you can control the configuration and lifecycle of your terminals. You can only have one non-deleted instance of a terminals resource per physical terminal, which is uniquely identified by the model and serial number. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [TerminalsRequest] body Required parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5110
def post_terminals(app_id,
                   app_token,
                   api_version,
                   body)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS, ACCOUNT_CANNOT_CREATE_TERMINALS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
post_terminals_id(app_id, app_token, api_version, body, id) click to toggle source

Modify a terminal's configuration. Note that changes in configuration will only be reflected on your physical terminal when it has performed an online update. You cannot modify the configuration of an inactive or deleted terminal. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [TerminalsRequest1] body Required parameter: Example: @param [String] id Required parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5259
def post_terminals_id(app_id,
                      app_token,
                      api_version,
                      body,
                      id)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals/{id}'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
post_terminals_id_activate(app_id, app_token, api_version, content_type, id, unique_key: nil) click to toggle source

Activating a terminal will allow it to process payments after being deactivated. You can only activate a deactivated terminal. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] content_type Required parameter: Example: @param [String] id Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5444
def post_terminals_id_activate(app_id,
                               app_token,
                               api_version,
                               content_type,
                               id,
                               unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals/{id}/activate'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Content-Type' => content_type,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
post_terminals_id_deactivate(app_id, app_token, api_version, content_type, id, unique_key: nil) click to toggle source

Dectivating a terminal will prevent it from processin payments after being deactivated. You can only deactivate an active terminal. @param [String] app_id Required parameter: Example: @param [String] app_token Required parameter: Example: @param [String] api_version Required parameter: Example: @param [String] content_type Required parameter: Example: @param [String] id Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [TerminalResp] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5510
def post_terminals_id_deactivate(app_id,
                                 app_token,
                                 api_version,
                                 content_type,
                                 id,
                                 unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/terminals/{id}/deactivate'
  _query_builder = APIHelper.append_url_with_template_parameters(
    _query_builder,
    'id' => { 'value' => id, 'encode' => true }
  )
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'App-Id' => app_id,
    'App-Token' => app_token,
    'Api-Version' => api_version,
    'Content-Type' => content_type,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers
  )
  CustomHeaderAuth.apply(config, _request)
  _response = execute_request(_request)

  # Validate response against endpoint and global error codes.
  if _response.status_code == 400
    raise APIException.new(
      'INVALID_PARAMS',
      _response
    )
  elsif _response.status_code == 403
    raise APIException.new(
      'NOT_AUTHORIZED',
      _response
    )
  elsif _response.status_code == 500
    raise APIException.new(
      'UNEXPECTED_ERROR',
      _response
    )
  end
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TerminalResp.from_hash(decoded)
end
post_tokens(app_id, api_version, body, unique_key: nil) click to toggle source

Create a new token @param [String] app_id Required parameter: Example: @param [String] api_version Required parameter: Example: @param [TokensRequest] body Required parameter: Example: @param [String] unique_key Optional parameter: Example: @return [TokensResponse] response from the API call

# File lib/beaver/controllers/api_controller.rb, line 5573
def post_tokens(app_id,
                api_version,
                body,
                unique_key: nil)
  # Prepare query url.
  _query_builder = config.get_base_uri
  _query_builder << '/tokens'
  _query_url = APIHelper.clean_url _query_builder

  # Prepare headers.
  _headers = {
    'accept' => 'application/json',
    'content-type' => 'application/json; charset=utf-8',
    'App-Id' => app_id,
    'Api-Version' => api_version,
    'Unique-Key' => unique_key
  }

  # Prepare and execute HttpRequest.
  _request = config.http_client.post(
    _query_url,
    headers: _headers,
    parameters: body.to_json
  )
  _response = execute_request(_request)
  validate_response(_response)

  # Return appropriate response type.
  decoded = APIHelper.json_deserialize(_response.raw_body)
  TokensResponse.from_hash(decoded)
end