class IntegrationApi::CardApi

Attributes

api_client[RW]

Public Class Methods

new(api_client = ApiClient.default) click to toggle source
# File lib/integration_api/api/card_api.rb, line 19
def initialize(api_client = ApiClient.default)
  @api_client = api_client
end

Public Instance Methods

create_auto_reload_using_post(request, opts = {}) click to toggle source

Card auto reload @param request request @param [Hash] opts the optional parameters @return [CardAutoReloadResponseVO]

# File lib/integration_api/api/card_api.rb, line 26
def create_auto_reload_using_post(request, opts = {})
  data, _status_code, _headers = create_auto_reload_using_post_with_http_info(request, opts)
  data
end
create_auto_reload_using_post_with_http_info(request, opts = {}) click to toggle source

Card auto reload @param request request @param [Hash] opts the optional parameters @return [Array<(CardAutoReloadResponseVO, Fixnum, Hash)>] CardAutoReloadResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 35
def create_auto_reload_using_post_with_http_info(request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_auto_reload_using_post ...'
  end
  # verify the required parameter 'request' is set
  if @api_client.config.client_side_validation && request.nil?
    fail ArgumentError, "Missing the required parameter 'request' when calling CardApi.create_auto_reload_using_post"
  end
  # resource path
  local_var_path = '/card/auto_reload'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardAutoReloadResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_auto_reload_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_activate_using_post(activate_request, opts = {}) click to toggle source

Activate card @param activate_request activateRequest @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 78
def create_card_activate_using_post(activate_request, opts = {})
  data, _status_code, _headers = create_card_activate_using_post_with_http_info(activate_request, opts)
  data
end
create_card_activate_using_post_with_http_info(activate_request, opts = {}) click to toggle source

Activate card @param activate_request activateRequest @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 87
def create_card_activate_using_post_with_http_info(activate_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_activate_using_post ...'
  end
  # verify the required parameter 'activate_request' is set
  if @api_client.config.client_side_validation && activate_request.nil?
    fail ArgumentError, "Missing the required parameter 'activate_request' when calling CardApi.create_card_activate_using_post"
  end
  # resource path
  local_var_path = '/card/activate'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(activate_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_activate_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_business_using_post(card_business_request_co, opts = {}) click to toggle source

Create a card business @param card_business_request_co cardBusinessRequestCO @param [Hash] opts the optional parameters @return [CreateBusinessResponseVO]

# File lib/integration_api/api/card_api.rb, line 130
def create_card_business_using_post(card_business_request_co, opts = {})
  data, _status_code, _headers = create_card_business_using_post_with_http_info(card_business_request_co, opts)
  data
end
create_card_business_using_post_with_http_info(card_business_request_co, opts = {}) click to toggle source

Create a card business @param card_business_request_co cardBusinessRequestCO @param [Hash] opts the optional parameters @return [Array<(CreateBusinessResponseVO, Fixnum, Hash)>] CreateBusinessResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 139
def create_card_business_using_post_with_http_info(card_business_request_co, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_business_using_post ...'
  end
  # verify the required parameter 'card_business_request_co' is set
  if @api_client.config.client_side_validation && card_business_request_co.nil?
    fail ArgumentError, "Missing the required parameter 'card_business_request_co' when calling CardApi.create_card_business_using_post"
  end
  # resource path
  local_var_path = '/card/business'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(card_business_request_co)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CreateBusinessResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_business_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_close_using_post(close_request, opts = {}) click to toggle source

close a card @param close_request closeRequest @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 182
def create_card_close_using_post(close_request, opts = {})
  data, _status_code, _headers = create_card_close_using_post_with_http_info(close_request, opts)
  data
end
create_card_close_using_post_with_http_info(close_request, opts = {}) click to toggle source

close a card @param close_request closeRequest @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 191
def create_card_close_using_post_with_http_info(close_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_close_using_post ...'
  end
  # verify the required parameter 'close_request' is set
  if @api_client.config.client_side_validation && close_request.nil?
    fail ArgumentError, "Missing the required parameter 'close_request' when calling CardApi.create_card_close_using_post"
  end
  # resource path
  local_var_path = '/card/close'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(close_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_close_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_issue_using_post(issue_request, opts = {}) click to toggle source

issue a card @param issue_request issueRequest @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 234
def create_card_issue_using_post(issue_request, opts = {})
  data, _status_code, _headers = create_card_issue_using_post_with_http_info(issue_request, opts)
  data
end
create_card_issue_using_post_with_http_info(issue_request, opts = {}) click to toggle source

issue a card @param issue_request issueRequest @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 243
def create_card_issue_using_post_with_http_info(issue_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_issue_using_post ...'
  end
  # verify the required parameter 'issue_request' is set
  if @api_client.config.client_side_validation && issue_request.nil?
    fail ArgumentError, "Missing the required parameter 'issue_request' when calling CardApi.create_card_issue_using_post"
  end
  # resource path
  local_var_path = '/card/issue'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(issue_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_issue_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_load_using_post(load_request, opts = {}) click to toggle source

Create a card load @param load_request loadRequest @param [Hash] opts the optional parameters @return [CardLoadUnloadResponseVO]

# File lib/integration_api/api/card_api.rb, line 286
def create_card_load_using_post(load_request, opts = {})
  data, _status_code, _headers = create_card_load_using_post_with_http_info(load_request, opts)
  data
end
create_card_load_using_post_with_http_info(load_request, opts = {}) click to toggle source

Create a card load @param load_request loadRequest @param [Hash] opts the optional parameters @return [Array<(CardLoadUnloadResponseVO, Fixnum, Hash)>] CardLoadUnloadResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 295
def create_card_load_using_post_with_http_info(load_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_load_using_post ...'
  end
  # verify the required parameter 'load_request' is set
  if @api_client.config.client_side_validation && load_request.nil?
    fail ArgumentError, "Missing the required parameter 'load_request' when calling CardApi.create_card_load_using_post"
  end
  # resource path
  local_var_path = '/card/load'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(load_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardLoadUnloadResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_load_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_pin_using_post(card_pin_request_co, opts = {}) click to toggle source

pin card @param card_pin_request_co cardPinRequestCO @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 338
def create_card_pin_using_post(card_pin_request_co, opts = {})
  data, _status_code, _headers = create_card_pin_using_post_with_http_info(card_pin_request_co, opts)
  data
end
create_card_pin_using_post_with_http_info(card_pin_request_co, opts = {}) click to toggle source

pin card @param card_pin_request_co cardPinRequestCO @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 347
def create_card_pin_using_post_with_http_info(card_pin_request_co, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_pin_using_post ...'
  end
  # verify the required parameter 'card_pin_request_co' is set
  if @api_client.config.client_side_validation && card_pin_request_co.nil?
    fail ArgumentError, "Missing the required parameter 'card_pin_request_co' when calling CardApi.create_card_pin_using_post"
  end
  # resource path
  local_var_path = '/card/pin'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(card_pin_request_co)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_pin_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_reactivate_using_post(reactivate_request, opts = {}) click to toggle source

reactivate card @param reactivate_request reactivateRequest @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 390
def create_card_reactivate_using_post(reactivate_request, opts = {})
  data, _status_code, _headers = create_card_reactivate_using_post_with_http_info(reactivate_request, opts)
  data
end
create_card_reactivate_using_post_with_http_info(reactivate_request, opts = {}) click to toggle source

reactivate card @param reactivate_request reactivateRequest @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 399
def create_card_reactivate_using_post_with_http_info(reactivate_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_reactivate_using_post ...'
  end
  # verify the required parameter 'reactivate_request' is set
  if @api_client.config.client_side_validation && reactivate_request.nil?
    fail ArgumentError, "Missing the required parameter 'reactivate_request' when calling CardApi.create_card_reactivate_using_post"
  end
  # resource path
  local_var_path = '/card/reactivate'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(reactivate_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_reactivate_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_reissue_using_post(request, opts = {}) click to toggle source

Reissue a card @param request request @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 442
def create_card_reissue_using_post(request, opts = {})
  data, _status_code, _headers = create_card_reissue_using_post_with_http_info(request, opts)
  data
end
create_card_reissue_using_post_with_http_info(request, opts = {}) click to toggle source

Reissue a card @param request request @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 451
def create_card_reissue_using_post_with_http_info(request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_reissue_using_post ...'
  end
  # verify the required parameter 'request' is set
  if @api_client.config.client_side_validation && request.nil?
    fail ArgumentError, "Missing the required parameter 'request' when calling CardApi.create_card_reissue_using_post"
  end
  # resource path
  local_var_path = '/card/reissue'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_reissue_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_replace_using_post(request, opts = {}) click to toggle source

Create card replace @param request request @param [Hash] opts the optional parameters @return [CardReplaceResponseVO]

# File lib/integration_api/api/card_api.rb, line 494
def create_card_replace_using_post(request, opts = {})
  data, _status_code, _headers = create_card_replace_using_post_with_http_info(request, opts)
  data
end
create_card_replace_using_post_with_http_info(request, opts = {}) click to toggle source

Create card replace @param request request @param [Hash] opts the optional parameters @return [Array<(CardReplaceResponseVO, Fixnum, Hash)>] CardReplaceResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 503
def create_card_replace_using_post_with_http_info(request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_replace_using_post ...'
  end
  # verify the required parameter 'request' is set
  if @api_client.config.client_side_validation && request.nil?
    fail ArgumentError, "Missing the required parameter 'request' when calling CardApi.create_card_replace_using_post"
  end
  # resource path
  local_var_path = '/card/replace'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardReplaceResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_replace_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_reserve_transfer_using_post(request, opts = {}) click to toggle source

Card reserve transfer @param request request @param [Hash] opts the optional parameters @return [CardReserveTransferResponseVO]

# File lib/integration_api/api/card_api.rb, line 546
def create_card_reserve_transfer_using_post(request, opts = {})
  data, _status_code, _headers = create_card_reserve_transfer_using_post_with_http_info(request, opts)
  data
end
create_card_reserve_transfer_using_post_with_http_info(request, opts = {}) click to toggle source

Card reserve transfer @param request request @param [Hash] opts the optional parameters @return [Array<(CardReserveTransferResponseVO, Fixnum, Hash)>] CardReserveTransferResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 555
def create_card_reserve_transfer_using_post_with_http_info(request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_reserve_transfer_using_post ...'
  end
  # verify the required parameter 'request' is set
  if @api_client.config.client_side_validation && request.nil?
    fail ArgumentError, "Missing the required parameter 'request' when calling CardApi.create_card_reserve_transfer_using_post"
  end
  # resource path
  local_var_path = '/card/reserve_transfer'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardReserveTransferResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_reserve_transfer_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_spending_control_using_post(request, opts = {}) click to toggle source

Create card spending control @param request request @param [Hash] opts the optional parameters @return [CardSpendingControlResponseVO]

# File lib/integration_api/api/card_api.rb, line 598
def create_card_spending_control_using_post(request, opts = {})
  data, _status_code, _headers = create_card_spending_control_using_post_with_http_info(request, opts)
  data
end
create_card_spending_control_using_post_with_http_info(request, opts = {}) click to toggle source

Create card spending control @param request request @param [Hash] opts the optional parameters @return [Array<(CardSpendingControlResponseVO, Fixnum, Hash)>] CardSpendingControlResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 607
def create_card_spending_control_using_post_with_http_info(request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_spending_control_using_post ...'
  end
  # verify the required parameter 'request' is set
  if @api_client.config.client_side_validation && request.nil?
    fail ArgumentError, "Missing the required parameter 'request' when calling CardApi.create_card_spending_control_using_post"
  end
  # resource path
  local_var_path = '/card/spending_control'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardSpendingControlResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_spending_control_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_suspend_using_post(suspend_request, opts = {}) click to toggle source

suspend card @param suspend_request suspendRequest @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 650
def create_card_suspend_using_post(suspend_request, opts = {})
  data, _status_code, _headers = create_card_suspend_using_post_with_http_info(suspend_request, opts)
  data
end
create_card_suspend_using_post_with_http_info(suspend_request, opts = {}) click to toggle source

suspend card @param suspend_request suspendRequest @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 659
def create_card_suspend_using_post_with_http_info(suspend_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_suspend_using_post ...'
  end
  # verify the required parameter 'suspend_request' is set
  if @api_client.config.client_side_validation && suspend_request.nil?
    fail ArgumentError, "Missing the required parameter 'suspend_request' when calling CardApi.create_card_suspend_using_post"
  end
  # resource path
  local_var_path = '/card/suspend'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(suspend_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_suspend_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_token_using_post(tokenize_request, opts = {}) click to toggle source

token card @param tokenize_request tokenizeRequest @param [Hash] opts the optional parameters @return [CardTokenResponseVO]

# File lib/integration_api/api/card_api.rb, line 702
def create_card_token_using_post(tokenize_request, opts = {})
  data, _status_code, _headers = create_card_token_using_post_with_http_info(tokenize_request, opts)
  data
end
create_card_token_using_post_with_http_info(tokenize_request, opts = {}) click to toggle source

token card @param tokenize_request tokenizeRequest @param [Hash] opts the optional parameters @return [Array<(CardTokenResponseVO, Fixnum, Hash)>] CardTokenResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 711
def create_card_token_using_post_with_http_info(tokenize_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_token_using_post ...'
  end
  # verify the required parameter 'tokenize_request' is set
  if @api_client.config.client_side_validation && tokenize_request.nil?
    fail ArgumentError, "Missing the required parameter 'tokenize_request' when calling CardApi.create_card_token_using_post"
  end
  # resource path
  local_var_path = '/card/token'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(tokenize_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardTokenResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_token_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_card_unload_using_post(reload_request, opts = {}) click to toggle source

Create a card upload @param reload_request reloadRequest @param [Hash] opts the optional parameters @return [CardLoadUnloadResponseVO]

# File lib/integration_api/api/card_api.rb, line 754
def create_card_unload_using_post(reload_request, opts = {})
  data, _status_code, _headers = create_card_unload_using_post_with_http_info(reload_request, opts)
  data
end
create_card_unload_using_post_with_http_info(reload_request, opts = {}) click to toggle source

Create a card upload @param reload_request reloadRequest @param [Hash] opts the optional parameters @return [Array<(CardLoadUnloadResponseVO, Fixnum, Hash)>] CardLoadUnloadResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 763
def create_card_unload_using_post_with_http_info(reload_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_card_unload_using_post ...'
  end
  # verify the required parameter 'reload_request' is set
  if @api_client.config.client_side_validation && reload_request.nil?
    fail ArgumentError, "Missing the required parameter 'reload_request' when calling CardApi.create_card_unload_using_post"
  end
  # resource path
  local_var_path = '/card/unload'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(reload_request)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardLoadUnloadResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_card_unload_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_client_card_using_post(card_client_request_co, opts = {}) click to toggle source

Create a card client @param card_client_request_co cardClientRequestCO @param [Hash] opts the optional parameters @return [CreateCardClientResponseVO]

# File lib/integration_api/api/card_api.rb, line 806
def create_client_card_using_post(card_client_request_co, opts = {})
  data, _status_code, _headers = create_client_card_using_post_with_http_info(card_client_request_co, opts)
  data
end
create_client_card_using_post_with_http_info(card_client_request_co, opts = {}) click to toggle source

Create a card client @param card_client_request_co cardClientRequestCO @param [Hash] opts the optional parameters @return [Array<(CreateCardClientResponseVO, Fixnum, Hash)>] CreateCardClientResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 815
def create_client_card_using_post_with_http_info(card_client_request_co, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.create_client_card_using_post ...'
  end
  # verify the required parameter 'card_client_request_co' is set
  if @api_client.config.client_side_validation && card_client_request_co.nil?
    fail ArgumentError, "Missing the required parameter 'card_client_request_co' when calling CardApi.create_client_card_using_post"
  end
  # resource path
  local_var_path = '/card/client'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(card_client_request_co)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CreateCardClientResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#create_client_card_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_business_status_using_get(nucleus_business_id, opts = {}) click to toggle source

Get a business status @param nucleus_business_id nucleus_business_id @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 858
def get_business_status_using_get(nucleus_business_id, opts = {})
  data, _status_code, _headers = get_business_status_using_get_with_http_info(nucleus_business_id, opts)
  data
end
get_business_status_using_get_with_http_info(nucleus_business_id, opts = {}) click to toggle source

Get a business status @param nucleus_business_id nucleus_business_id @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 867
def get_business_status_using_get_with_http_info(nucleus_business_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_business_status_using_get ...'
  end
  # verify the required parameter 'nucleus_business_id' is set
  if @api_client.config.client_side_validation && nucleus_business_id.nil?
    fail ArgumentError, "Missing the required parameter 'nucleus_business_id' when calling CardApi.get_business_status_using_get"
  end
  # resource path
  local_var_path = '/card/status'

  # query parameters
  query_params = {}
  query_params[:'nucleus_business_id'] = nucleus_business_id

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_business_status_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_balance_using_get(id, opts = {}) click to toggle source

Get a Card Balance @param id id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [CardBalanceResponseVO]

# File lib/integration_api/api/card_api.rb, line 911
def get_card_balance_using_get(id, opts = {})
  data, _status_code, _headers = get_card_balance_using_get_with_http_info(id, opts)
  data
end
get_card_balance_using_get_with_http_info(id, opts = {}) click to toggle source

Get a Card Balance @param id id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [Array<(CardBalanceResponseVO, Fixnum, Hash)>] CardBalanceResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 922
def get_card_balance_using_get_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_balance_using_get ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.get_card_balance_using_get"
  end
  # resource path
  local_var_path = '/card/balance/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}
  query_params[:'end_date'] = opts[:'end_date'] if !opts[:'end_date'].nil?
  query_params[:'start_date'] = opts[:'start_date'] if !opts[:'start_date'].nil?

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardBalanceResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_balance_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_image(card_id, opts = {}) click to toggle source

Get card image @param card_id card_id @param [Hash] opts the optional parameters @return [GetCardImageResponseVO]

# File lib/integration_api/api/card_api.rb, line 965
def get_card_image(card_id, opts = {})
  data, _status_code, _headers = get_card_image_with_http_info(card_id, opts)
  data
end
get_card_image_with_http_info(card_id, opts = {}) click to toggle source

Get card image @param card_id card_id @param [Hash] opts the optional parameters @return [Array<(GetCardImageResponseVO, Fixnum, Hash)>] GetCardImageResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 974
def get_card_image_with_http_info(card_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_image ...'
  end
  # verify the required parameter 'card_id' is set
  if @api_client.config.client_side_validation && card_id.nil?
    fail ArgumentError, "Missing the required parameter 'card_id' when calling CardApi.get_card_image"
  end
  # resource path
  local_var_path = '/card/image/{card_id}'.sub('{' + 'card_id' + '}', card_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'GetCardImageResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_image\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_pci_details(card_id, opts = {}) click to toggle source

Get card pci details @param card_id card_id @param [Hash] opts the optional parameters @return [GetCardPciDetailsResponseVO]

# File lib/integration_api/api/card_api.rb, line 1015
def get_card_pci_details(card_id, opts = {})
  data, _status_code, _headers = get_card_pci_details_with_http_info(card_id, opts)
  data
end
get_card_pci_details_with_http_info(card_id, opts = {}) click to toggle source

Get card pci details @param card_id card_id @param [Hash] opts the optional parameters @return [Array<(GetCardPciDetailsResponseVO, Fixnum, Hash)>] GetCardPciDetailsResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1024
def get_card_pci_details_with_http_info(card_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_pci_details ...'
  end
  # verify the required parameter 'card_id' is set
  if @api_client.config.client_side_validation && card_id.nil?
    fail ArgumentError, "Missing the required parameter 'card_id' when calling CardApi.get_card_pci_details"
  end
  # resource path
  local_var_path = '/card/pci_details/{card_id}'.sub('{' + 'card_id' + '}', card_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'GetCardPciDetailsResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_pci_details\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_reserve_account_details_using_get(opts = {}) click to toggle source

Card reserve account @param [Hash] opts the optional parameters @return [CardReserveAccountResponseVO]

# File lib/integration_api/api/card_api.rb, line 1064
def get_card_reserve_account_details_using_get(opts = {})
  data, _status_code, _headers = get_card_reserve_account_details_using_get_with_http_info(opts)
  data
end
get_card_reserve_account_details_using_get_with_http_info(opts = {}) click to toggle source

Card reserve account @param [Hash] opts the optional parameters @return [Array<(CardReserveAccountResponseVO, Fixnum, Hash)>] CardReserveAccountResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1072
def get_card_reserve_account_details_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_reserve_account_details_using_get ...'
  end
  # resource path
  local_var_path = '/card/reserve'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardReserveAccountResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_reserve_account_details_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_statement_using_get(card_id, opts = {}) click to toggle source

Get card statement @param card_id card_id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [GetCardStatementResponseVO]

# File lib/integration_api/api/card_api.rb, line 1111
def get_card_statement_using_get(card_id, opts = {})
  data, _status_code, _headers = get_card_statement_using_get_with_http_info(card_id, opts)
  data
end
get_card_statement_using_get_with_http_info(card_id, opts = {}) click to toggle source

Get card statement @param card_id card_id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [Array<(GetCardStatementResponseVO, Fixnum, Hash)>] GetCardStatementResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1122
def get_card_statement_using_get_with_http_info(card_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_statement_using_get ...'
  end
  # verify the required parameter 'card_id' is set
  if @api_client.config.client_side_validation && card_id.nil?
    fail ArgumentError, "Missing the required parameter 'card_id' when calling CardApi.get_card_statement_using_get"
  end
  # resource path
  local_var_path = '/card/statement/{card_id}'.sub('{' + 'card_id' + '}', card_id.to_s)

  # query parameters
  query_params = {}
  query_params[:'end_date'] = opts[:'end_date'] if !opts[:'end_date'].nil?
  query_params[:'start_date'] = opts[:'start_date'] if !opts[:'start_date'].nil?

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'GetCardStatementResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_statement_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_token_using_token(id, opts = {}) click to toggle source

Get a card token @param id id @param [Hash] opts the optional parameters @option opts [String] :device_id device_id @option opts [String] :device_type device_type @option opts [String] :wallet wallet @return [Array<GetCardTokenResponseVO>]

# File lib/integration_api/api/card_api.rb, line 1168
def get_card_token_using_token(id, opts = {})
  data, _status_code, _headers = get_card_token_using_token_with_http_info(id, opts)
  data
end
get_card_token_using_token_with_http_info(id, opts = {}) click to toggle source

Get a card token @param id id @param [Hash] opts the optional parameters @option opts [String] :device_id device_id @option opts [String] :device_type device_type @option opts [String] :wallet wallet @return [Array<(Array<GetCardTokenResponseVO>, Fixnum, Hash)>] Array<GetCardTokenResponseVO> data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1180
def get_card_token_using_token_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_token_using_token ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.get_card_token_using_token"
  end
  if @api_client.config.client_side_validation && opts[:'device_type'] && !['watch', 'mobile_phone', 'tablet', 'gaming_device', 'vehicle', 'appliance', 'laptop', 'other'].include?(opts[:'device_type'])
    fail ArgumentError, 'invalid value for "device_type", must be one of watch, mobile_phone, tablet, gaming_device, vehicle, appliance, laptop, other'
  end
  if @api_client.config.client_side_validation && opts[:'wallet'] && !['google', 'apple', 'samsung', 'other'].include?(opts[:'wallet'])
    fail ArgumentError, 'invalid value for "wallet", must be one of google, apple, samsung, other'
  end
  # resource path
  local_var_path = '/card/token/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}
  query_params[:'device_id'] = opts[:'device_id'] if !opts[:'device_id'].nil?
  query_params[:'device_type'] = opts[:'device_type'] if !opts[:'device_type'].nil?
  query_params[:'wallet'] = opts[:'wallet'] if !opts[:'wallet'].nil?

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'Array<GetCardTokenResponseVO>')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_token_using_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_transaction_using_get(id, opts = {}) click to toggle source

Get a card transaction @param id id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [CardTransactionResponseVO]

# File lib/integration_api/api/card_api.rb, line 1232
def get_card_transaction_using_get(id, opts = {})
  data, _status_code, _headers = get_card_transaction_using_get_with_http_info(id, opts)
  data
end
get_card_transaction_using_get_with_http_info(id, opts = {}) click to toggle source

Get a card transaction @param id id @param [Hash] opts the optional parameters @option opts [Date] :end_date end_date @option opts [Date] :start_date start_date @return [Array<(CardTransactionResponseVO, Fixnum, Hash)>] CardTransactionResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1243
def get_card_transaction_using_get_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_transaction_using_get ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.get_card_transaction_using_get"
  end
  # resource path
  local_var_path = '/card/transaction/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}
  query_params[:'end_date'] = opts[:'end_date'] if !opts[:'end_date'].nil?
  query_params[:'start_date'] = opts[:'start_date'] if !opts[:'start_date'].nil?

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardTransactionResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_transaction_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_card_using_get(id, opts = {}) click to toggle source

Get a card information @param id id @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 1286
def get_card_using_get(id, opts = {})
  data, _status_code, _headers = get_card_using_get_with_http_info(id, opts)
  data
end
get_card_using_get_with_http_info(id, opts = {}) click to toggle source

Get a card information @param id id @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1295
def get_card_using_get_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.get_card_using_get ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.get_card_using_get"
  end
  # resource path
  local_var_path = '/card/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#get_card_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_card_business_using_put(nucleus_business_id, opts = {}) click to toggle source

Update a card business @param nucleus_business_id nucleus_business_id @param [Hash] opts the optional parameters @return [UpdateBusinessResponseVO]

# File lib/integration_api/api/card_api.rb, line 1336
def update_card_business_using_put(nucleus_business_id, opts = {})
  data, _status_code, _headers = update_card_business_using_put_with_http_info(nucleus_business_id, opts)
  data
end
update_card_business_using_put_with_http_info(nucleus_business_id, opts = {}) click to toggle source

Update a card business @param nucleus_business_id nucleus_business_id @param [Hash] opts the optional parameters @return [Array<(UpdateBusinessResponseVO, Fixnum, Hash)>] UpdateBusinessResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1345
def update_card_business_using_put_with_http_info(nucleus_business_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.update_card_business_using_put ...'
  end
  # verify the required parameter 'nucleus_business_id' is set
  if @api_client.config.client_side_validation && nucleus_business_id.nil?
    fail ArgumentError, "Missing the required parameter 'nucleus_business_id' when calling CardApi.update_card_business_using_put"
  end
  # resource path
  local_var_path = '/card/business/{nucleus_business_id}'.sub('{' + 'nucleus_business_id' + '}', nucleus_business_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'UpdateBusinessResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#update_card_business_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_card_pin_using_put(card_pin_request_co, id, opts = {}) click to toggle source

update a pin card @param card_pin_request_co cardPinRequestCO @param id id @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 1389
def update_card_pin_using_put(card_pin_request_co, id, opts = {})
  data, _status_code, _headers = update_card_pin_using_put_with_http_info(card_pin_request_co, id, opts)
  data
end
update_card_pin_using_put_with_http_info(card_pin_request_co, id, opts = {}) click to toggle source

update a pin card @param card_pin_request_co cardPinRequestCO @param id id @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1399
def update_card_pin_using_put_with_http_info(card_pin_request_co, id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.update_card_pin_using_put ...'
  end
  # verify the required parameter 'card_pin_request_co' is set
  if @api_client.config.client_side_validation && card_pin_request_co.nil?
    fail ArgumentError, "Missing the required parameter 'card_pin_request_co' when calling CardApi.update_card_pin_using_put"
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.update_card_pin_using_put"
  end
  # resource path
  local_var_path = '/card/pin/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(card_pin_request_co)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#update_card_pin_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_card_spending_control_using_put(nucleus_spending_control_id, opts = {}) click to toggle source

Update a card spending control @param nucleus_spending_control_id nucleus_spending_control_id @param [Hash] opts the optional parameters @return [CardSpendingControlResponseVO]

# File lib/integration_api/api/card_api.rb, line 1446
def update_card_spending_control_using_put(nucleus_spending_control_id, opts = {})
  data, _status_code, _headers = update_card_spending_control_using_put_with_http_info(nucleus_spending_control_id, opts)
  data
end
update_card_spending_control_using_put_with_http_info(nucleus_spending_control_id, opts = {}) click to toggle source

Update a card spending control @param nucleus_spending_control_id nucleus_spending_control_id @param [Hash] opts the optional parameters @return [Array<(CardSpendingControlResponseVO, Fixnum, Hash)>] CardSpendingControlResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1455
def update_card_spending_control_using_put_with_http_info(nucleus_spending_control_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.update_card_spending_control_using_put ...'
  end
  # verify the required parameter 'nucleus_spending_control_id' is set
  if @api_client.config.client_side_validation && nucleus_spending_control_id.nil?
    fail ArgumentError, "Missing the required parameter 'nucleus_spending_control_id' when calling CardApi.update_card_spending_control_using_put"
  end
  # resource path
  local_var_path = '/card/spending_control/{nucleus_spending_control_id}'.sub('{' + 'nucleus_spending_control_id' + '}', nucleus_spending_control_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'CardSpendingControlResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#update_card_spending_control_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_card_using_put(id, opts = {}) click to toggle source

Update a card information @param id id @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 1498
def update_card_using_put(id, opts = {})
  data, _status_code, _headers = update_card_using_put_with_http_info(id, opts)
  data
end
update_card_using_put_with_http_info(id, opts = {}) click to toggle source

Update a card information @param id id @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1507
def update_card_using_put_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.update_card_using_put ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.update_card_using_put"
  end
  # resource path
  local_var_path = '/card/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#update_card_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_client_card_using_put(id, opts = {}) click to toggle source

Update a card client @param id id @param [Hash] opts the optional parameters @return [UpdateCardClientResponseVO]

# File lib/integration_api/api/card_api.rb, line 1550
def update_client_card_using_put(id, opts = {})
  data, _status_code, _headers = update_client_card_using_put_with_http_info(id, opts)
  data
end
update_client_card_using_put_with_http_info(id, opts = {}) click to toggle source

Update a card client @param id id @param [Hash] opts the optional parameters @return [Array<(UpdateCardClientResponseVO, Fixnum, Hash)>] UpdateCardClientResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1559
def update_client_card_using_put_with_http_info(id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.update_client_card_using_put ...'
  end
  # verify the required parameter 'id' is set
  if @api_client.config.client_side_validation && id.nil?
    fail ArgumentError, "Missing the required parameter 'id' when calling CardApi.update_client_card_using_put"
  end
  # resource path
  local_var_path = '/card/client/{id}'.sub('{' + 'id' + '}', id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = nil
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'UpdateCardClientResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#update_client_card_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
verify_card_pin_using_post(card_pin_request_co, opts = {}) click to toggle source

verify card pin @param card_pin_request_co cardPinRequestCO @param [Hash] opts the optional parameters @return [BaseResponseVO]

# File lib/integration_api/api/card_api.rb, line 1602
def verify_card_pin_using_post(card_pin_request_co, opts = {})
  data, _status_code, _headers = verify_card_pin_using_post_with_http_info(card_pin_request_co, opts)
  data
end
verify_card_pin_using_post_with_http_info(card_pin_request_co, opts = {}) click to toggle source

verify card pin @param card_pin_request_co cardPinRequestCO @param [Hash] opts the optional parameters @return [Array<(BaseResponseVO, Fixnum, Hash)>] BaseResponseVO data, response status code and response headers

# File lib/integration_api/api/card_api.rb, line 1611
def verify_card_pin_using_post_with_http_info(card_pin_request_co, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: CardApi.verify_card_pin_using_post ...'
  end
  # verify the required parameter 'card_pin_request_co' is set
  if @api_client.config.client_side_validation && card_pin_request_co.nil?
    fail ArgumentError, "Missing the required parameter 'card_pin_request_co' when calling CardApi.verify_card_pin_using_post"
  end
  # resource path
  local_var_path = '/card/pin/verify'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/json'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(card_pin_request_co)
  auth_names = ['oauth2']
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'BaseResponseVO')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: CardApi#verify_card_pin_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end