class NucleusApi::UtilsApi

Attributes

api_client[RW]

Public Class Methods

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

Public Instance Methods

create_application_using_post(application, opts = {}) click to toggle source

Create an application Create an application @param application application @param [Hash] opts the optional parameters @return [Application]

# File lib/nucleus_api/api/utils_api.rb, line 27
def create_application_using_post(application, opts = {})
  data, _status_code, _headers = create_application_using_post_with_http_info(application, opts)
  data
end
create_application_using_post_with_http_info(application, opts = {}) click to toggle source

Create an application Create an application @param application application @param [Hash] opts the optional parameters @return [Array<(Application, Fixnum, Hash)>] Application data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 37
def create_application_using_post_with_http_info(application, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_application_using_post ...'
  end
  # verify the required parameter 'application' is set
  if @api_client.config.client_side_validation && application.nil?
    fail ArgumentError, "Missing the required parameter 'application' when calling UtilsApi.create_application_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/application'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(application)
  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 => 'Application')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_application_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_audit_log_using_post(audit_log, opts = {}) click to toggle source

Create a audit log Create a new audit log. @param audit_log auditLog @param [Hash] opts the optional parameters @return [AuditLog]

# File lib/nucleus_api/api/utils_api.rb, line 81
def create_audit_log_using_post(audit_log, opts = {})
  data, _status_code, _headers = create_audit_log_using_post_with_http_info(audit_log, opts)
  data
end
create_audit_log_using_post_with_http_info(audit_log, opts = {}) click to toggle source

Create a audit log Create a new audit log. @param audit_log auditLog @param [Hash] opts the optional parameters @return [Array<(AuditLog, Fixnum, Hash)>] AuditLog data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 91
def create_audit_log_using_post_with_http_info(audit_log, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_audit_log_using_post ...'
  end
  # verify the required parameter 'audit_log' is set
  if @api_client.config.client_side_validation && audit_log.nil?
    fail ArgumentError, "Missing the required parameter 'audit_log' when calling UtilsApi.create_audit_log_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/audit_log'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(audit_log)
  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 => 'AuditLog')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_audit_log_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_feature_track_using_post(feature_track, opts = {}) click to toggle source

Create a Feature Track Create a new feature track. @param feature_track featureTrack @param [Hash] opts the optional parameters @return [FeatureTrack]

# File lib/nucleus_api/api/utils_api.rb, line 135
def create_feature_track_using_post(feature_track, opts = {})
  data, _status_code, _headers = create_feature_track_using_post_with_http_info(feature_track, opts)
  data
end
create_feature_track_using_post_with_http_info(feature_track, opts = {}) click to toggle source

Create a Feature Track Create a new feature track. @param feature_track featureTrack @param [Hash] opts the optional parameters @return [Array<(FeatureTrack, Fixnum, Hash)>] FeatureTrack data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 145
def create_feature_track_using_post_with_http_info(feature_track, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_feature_track_using_post ...'
  end
  # verify the required parameter 'feature_track' is set
  if @api_client.config.client_side_validation && feature_track.nil?
    fail ArgumentError, "Missing the required parameter 'feature_track' when calling UtilsApi.create_feature_track_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature_track'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(feature_track)
  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 => 'FeatureTrack')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_feature_track_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_feature_using_post(feature, opts = {}) click to toggle source

Create a Feature Create a new feature. @param feature feature @param [Hash] opts the optional parameters @return [Feature]

# File lib/nucleus_api/api/utils_api.rb, line 189
def create_feature_using_post(feature, opts = {})
  data, _status_code, _headers = create_feature_using_post_with_http_info(feature, opts)
  data
end
create_feature_using_post_with_http_info(feature, opts = {}) click to toggle source

Create a Feature Create a new feature. @param feature feature @param [Hash] opts the optional parameters @return [Array<(Feature, Fixnum, Hash)>] Feature data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 199
def create_feature_using_post_with_http_info(feature, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_feature_using_post ...'
  end
  # verify the required parameter 'feature' is set
  if @api_client.config.client_side_validation && feature.nil?
    fail ArgumentError, "Missing the required parameter 'feature' when calling UtilsApi.create_feature_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(feature)
  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 => 'Feature')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_feature_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_notification_client_using_post(notification_client, opts = {}) click to toggle source

Create a Notification Client Create a new Notification Client. @param notification_client notificationClient @param [Hash] opts the optional parameters @return [NotificationClient]

# File lib/nucleus_api/api/utils_api.rb, line 243
def create_notification_client_using_post(notification_client, opts = {})
  data, _status_code, _headers = create_notification_client_using_post_with_http_info(notification_client, opts)
  data
end
create_notification_client_using_post_with_http_info(notification_client, opts = {}) click to toggle source

Create a Notification Client Create a new Notification Client. @param notification_client notificationClient @param [Hash] opts the optional parameters @return [Array<(NotificationClient, Fixnum, Hash)>] NotificationClient data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 253
def create_notification_client_using_post_with_http_info(notification_client, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_notification_client_using_post ...'
  end
  # verify the required parameter 'notification_client' is set
  if @api_client.config.client_side_validation && notification_client.nil?
    fail ArgumentError, "Missing the required parameter 'notification_client' when calling UtilsApi.create_notification_client_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_client'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification_client)
  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 => 'NotificationClient')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_notification_client_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_notification_setting_using_post(notification_setting, opts = {}) click to toggle source

Create a Notification Setting Create a new Notification Setting. @param notification_setting notificationSetting @param [Hash] opts the optional parameters @return [NotificationSetting]

# File lib/nucleus_api/api/utils_api.rb, line 297
def create_notification_setting_using_post(notification_setting, opts = {})
  data, _status_code, _headers = create_notification_setting_using_post_with_http_info(notification_setting, opts)
  data
end
create_notification_setting_using_post_with_http_info(notification_setting, opts = {}) click to toggle source

Create a Notification Setting Create a new Notification Setting. @param notification_setting notificationSetting @param [Hash] opts the optional parameters @return [Array<(NotificationSetting, Fixnum, Hash)>] NotificationSetting data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 307
def create_notification_setting_using_post_with_http_info(notification_setting, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_notification_setting_using_post ...'
  end
  # verify the required parameter 'notification_setting' is set
  if @api_client.config.client_side_validation && notification_setting.nil?
    fail ArgumentError, "Missing the required parameter 'notification_setting' when calling UtilsApi.create_notification_setting_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_setting'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification_setting)
  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 => 'NotificationSetting')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_notification_setting_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_notification_using_post(notification, opts = {}) click to toggle source

Create a Notification Create a new Notification. @param notification notification @param [Hash] opts the optional parameters @return [Notification]

# File lib/nucleus_api/api/utils_api.rb, line 351
def create_notification_using_post(notification, opts = {})
  data, _status_code, _headers = create_notification_using_post_with_http_info(notification, opts)
  data
end
create_notification_using_post_with_http_info(notification, opts = {}) click to toggle source

Create a Notification Create a new Notification. @param notification notification @param [Hash] opts the optional parameters @return [Array<(Notification, Fixnum, Hash)>] Notification data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 361
def create_notification_using_post_with_http_info(notification, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_notification_using_post ...'
  end
  # verify the required parameter 'notification' is set
  if @api_client.config.client_side_validation && notification.nil?
    fail ArgumentError, "Missing the required parameter 'notification' when calling UtilsApi.create_notification_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification)
  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 => 'Notification')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_notification_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_reason_code_using_post(reason_code_request, opts = {}) click to toggle source

Create a reason code Create a new reason code for your firm. @param reason_code_request reasonCodeRequest @param [Hash] opts the optional parameters @return [ReasonCode]

# File lib/nucleus_api/api/utils_api.rb, line 405
def create_reason_code_using_post(reason_code_request, opts = {})
  data, _status_code, _headers = create_reason_code_using_post_with_http_info(reason_code_request, opts)
  data
end
create_reason_code_using_post_with_http_info(reason_code_request, opts = {}) click to toggle source

Create a reason code Create a new reason code for your firm. @param reason_code_request reasonCodeRequest @param [Hash] opts the optional parameters @return [Array<(ReasonCode, Fixnum, Hash)>] ReasonCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 415
def create_reason_code_using_post_with_http_info(reason_code_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_reason_code_using_post ...'
  end
  # verify the required parameter 'reason_code_request' is set
  if @api_client.config.client_side_validation && reason_code_request.nil?
    fail ArgumentError, "Missing the required parameter 'reason_code_request' when calling UtilsApi.create_reason_code_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/reason_code'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(reason_code_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 => 'ReasonCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_reason_code_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_stage_using_post(stage_request, opts = {}) click to toggle source

Create an account stage Create a new account stage @param stage_request stageRequest @param [Hash] opts the optional parameters @return [Stage]

# File lib/nucleus_api/api/utils_api.rb, line 459
def create_stage_using_post(stage_request, opts = {})
  data, _status_code, _headers = create_stage_using_post_with_http_info(stage_request, opts)
  data
end
create_stage_using_post_with_http_info(stage_request, opts = {}) click to toggle source

Create an account stage Create a new account stage @param stage_request stageRequest @param [Hash] opts the optional parameters @return [Array<(Stage, Fixnum, Hash)>] Stage data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 469
def create_stage_using_post_with_http_info(stage_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_stage_using_post ...'
  end
  # verify the required parameter 'stage_request' is set
  if @api_client.config.client_side_validation && stage_request.nil?
    fail ArgumentError, "Missing the required parameter 'stage_request' when calling UtilsApi.create_stage_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/stage'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(stage_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 => 'Stage')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_stage_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
create_transaction_code_using_post(transaction_request, opts = {}) click to toggle source

Create a transaction code Create a new transaction code for your firm. @param transaction_request transactionRequest @param [Hash] opts the optional parameters @return [TransactionCode]

# File lib/nucleus_api/api/utils_api.rb, line 513
def create_transaction_code_using_post(transaction_request, opts = {})
  data, _status_code, _headers = create_transaction_code_using_post_with_http_info(transaction_request, opts)
  data
end
create_transaction_code_using_post_with_http_info(transaction_request, opts = {}) click to toggle source

Create a transaction code Create a new transaction code for your firm. @param transaction_request transactionRequest @param [Hash] opts the optional parameters @return [Array<(TransactionCode, Fixnum, Hash)>] TransactionCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 523
def create_transaction_code_using_post_with_http_info(transaction_request, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.create_transaction_code_using_post ...'
  end
  # verify the required parameter 'transaction_request' is set
  if @api_client.config.client_side_validation && transaction_request.nil?
    fail ArgumentError, "Missing the required parameter 'transaction_request' when calling UtilsApi.create_transaction_code_using_post"
  end
  # resource path
  local_var_path = '/nucleus/v1/transaction_code'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(transaction_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 => 'TransactionCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#create_transaction_code_using_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
delete_application_using_delete(application_id, opts = {}) click to toggle source

Delete an Application Permanently delete an Application. @param application_id UUID application_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 567
def delete_application_using_delete(application_id, opts = {})
  delete_application_using_delete_with_http_info(application_id, opts)
  nil
end
delete_application_using_delete_with_http_info(application_id, opts = {}) click to toggle source

Delete an Application Permanently delete an Application. @param application_id UUID application_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 577
def delete_application_using_delete_with_http_info(application_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_application_using_delete ...'
  end
  # verify the required parameter 'application_id' is set
  if @api_client.config.client_side_validation && application_id.nil?
    fail ArgumentError, "Missing the required parameter 'application_id' when calling UtilsApi.delete_application_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/application/{application_id}'.sub('{' + 'application_id' + '}', application_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a Feature Track Permanently delete a feature track registered with your firm. @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 618
def delete_feature_track_using_delete(feature_track_id, opts = {})
  delete_feature_track_using_delete_with_http_info(feature_track_id, opts)
  nil
end
delete_feature_track_using_delete_with_http_info(feature_track_id, opts = {}) click to toggle source

Delete a Feature Track Permanently delete a feature track registered with your firm. @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 628
def delete_feature_track_using_delete_with_http_info(feature_track_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_feature_track_using_delete ...'
  end
  # verify the required parameter 'feature_track_id' is set
  if @api_client.config.client_side_validation && feature_track_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_track_id' when calling UtilsApi.delete_feature_track_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature_track/{feature_track_id}'.sub('{' + 'feature_track_id' + '}', feature_track_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a Feature Permanently delete a feature registered with your firm. @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 669
def delete_feature_using_delete(feature_id, opts = {})
  delete_feature_using_delete_with_http_info(feature_id, opts)
  nil
end
delete_feature_using_delete_with_http_info(feature_id, opts = {}) click to toggle source

Delete a Feature Permanently delete a feature registered with your firm. @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 679
def delete_feature_using_delete_with_http_info(feature_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_feature_using_delete ...'
  end
  # verify the required parameter 'feature_id' is set
  if @api_client.config.client_side_validation && feature_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_id' when calling UtilsApi.delete_feature_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature/{feature_id}'.sub('{' + 'feature_id' + '}', feature_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a Notification Client Permanently Delete Notification Client. @param notification_client_id notification_client_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 720
def delete_notification_client_using_delete(notification_client_id, opts = {})
  delete_notification_client_using_delete_with_http_info(notification_client_id, opts)
  nil
end
delete_notification_client_using_delete_with_http_info(notification_client_id, opts = {}) click to toggle source

Delete a Notification Client Permanently Delete Notification Client. @param notification_client_id notification_client_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 730
def delete_notification_client_using_delete_with_http_info(notification_client_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_notification_client_using_delete ...'
  end
  # verify the required parameter 'notification_client_id' is set
  if @api_client.config.client_side_validation && notification_client_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_client_id' when calling UtilsApi.delete_notification_client_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_client/{notification_client_id}'.sub('{' + 'notification_client_id' + '}', notification_client_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a Notification Setting Permanently Delete Notification Setting. @param notification_setting_id notification_setting_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 771
def delete_notification_setting_using_delete(notification_setting_id, opts = {})
  delete_notification_setting_using_delete_with_http_info(notification_setting_id, opts)
  nil
end
delete_notification_setting_using_delete_with_http_info(notification_setting_id, opts = {}) click to toggle source

Delete a Notification Setting Permanently Delete Notification Setting. @param notification_setting_id notification_setting_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 781
def delete_notification_setting_using_delete_with_http_info(notification_setting_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_notification_setting_using_delete ...'
  end
  # verify the required parameter 'notification_setting_id' is set
  if @api_client.config.client_side_validation && notification_setting_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_setting_id' when calling UtilsApi.delete_notification_setting_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_setting/{notification_setting_id}'.sub('{' + 'notification_setting_id' + '}', notification_setting_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a Notification Permanently Delete a Notification. @param notification_id UUID notification_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 822
def delete_notification_using_delete(notification_id, opts = {})
  delete_notification_using_delete_with_http_info(notification_id, opts)
  nil
end
delete_notification_using_delete_with_http_info(notification_id, opts = {}) click to toggle source

Delete a Notification Permanently Delete a Notification. @param notification_id UUID notification_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 832
def delete_notification_using_delete_with_http_info(notification_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_notification_using_delete ...'
  end
  # verify the required parameter 'notification_id' is set
  if @api_client.config.client_side_validation && notification_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_id' when calling UtilsApi.delete_notification_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification/{notification_id}'.sub('{' + 'notification_id' + '}', notification_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a reason code Permanently delete a reason code for your firm. @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 873
def delete_reason_code_using_delete(reason_code_id, opts = {})
  delete_reason_code_using_delete_with_http_info(reason_code_id, opts)
  nil
end
delete_reason_code_using_delete_with_http_info(reason_code_id, opts = {}) click to toggle source

Delete a reason code Permanently delete a reason code for your firm. @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 883
def delete_reason_code_using_delete_with_http_info(reason_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_reason_code_using_delete ...'
  end
  # verify the required parameter 'reason_code_id' is set
  if @api_client.config.client_side_validation && reason_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'reason_code_id' when calling UtilsApi.delete_reason_code_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/reason_code/{reason_code_id}'.sub('{' + 'reason_code_id' + '}', reason_code_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete an account stage Permanently delete an account stage. @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 924
def delete_stage_using_delete(stage_id, opts = {})
  delete_stage_using_delete_with_http_info(stage_id, opts)
  nil
end
delete_stage_using_delete_with_http_info(stage_id, opts = {}) click to toggle source

Delete an account stage Permanently delete an account stage. @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 934
def delete_stage_using_delete_with_http_info(stage_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_stage_using_delete ...'
  end
  # verify the required parameter 'stage_id' is set
  if @api_client.config.client_side_validation && stage_id.nil?
    fail ArgumentError, "Missing the required parameter 'stage_id' when calling UtilsApi.delete_stage_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/stage/{stage_id}'.sub('{' + 'stage_id' + '}', stage_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

Delete a transaction code Permanently delete a transaction code for your firm. @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [nil]

# File lib/nucleus_api/api/utils_api.rb, line 975
def delete_transaction_code_using_delete(transaction_code_id, opts = {})
  delete_transaction_code_using_delete_with_http_info(transaction_code_id, opts)
  nil
end
delete_transaction_code_using_delete_with_http_info(transaction_code_id, opts = {}) click to toggle source

Delete a transaction code Permanently delete a transaction code for your firm. @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [Array<(nil, Fixnum, Hash)>] nil, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 985
def delete_transaction_code_using_delete_with_http_info(transaction_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.delete_transaction_code_using_delete ...'
  end
  # verify the required parameter 'transaction_code_id' is set
  if @api_client.config.client_side_validation && transaction_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'transaction_code_id' when calling UtilsApi.delete_transaction_code_using_delete"
  end
  # resource path
  local_var_path = '/nucleus/v1/transaction_code/{transaction_code_id}'.sub('{' + 'transaction_code_id' + '}', transaction_code_id.to_s)

  # query parameters
  query_params = {}

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

  # form parameters
  form_params = {}

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

List all Application Get details for all Application. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageApplication]

# File lib/nucleus_api/api/utils_api.rb, line 1030
def get_application_all_using_get(opts = {})
  data, _status_code, _headers = get_application_all_using_get_with_http_info(opts)
  data
end
get_application_all_using_get_with_http_info(opts = {}) click to toggle source

List all Application Get details for all Application. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageApplication, Fixnum, Hash)>] PageApplication data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1044
def get_application_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_application_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/application'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageApplication')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_application_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_application_using_get(application_id, opts = {}) click to toggle source

Retrieve an Application Retrieve the information for an Application. @param application_id UUID application_id @param [Hash] opts the optional parameters @return [Application]

# File lib/nucleus_api/api/utils_api.rb, line 1087
def get_application_using_get(application_id, opts = {})
  data, _status_code, _headers = get_application_using_get_with_http_info(application_id, opts)
  data
end
get_application_using_get_with_http_info(application_id, opts = {}) click to toggle source

Retrieve an Application Retrieve the information for an Application. @param application_id UUID application_id @param [Hash] opts the optional parameters @return [Array<(Application, Fixnum, Hash)>] Application data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1097
def get_application_using_get_with_http_info(application_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_application_using_get ...'
  end
  # verify the required parameter 'application_id' is set
  if @api_client.config.client_side_validation && application_id.nil?
    fail ArgumentError, "Missing the required parameter 'application_id' when calling UtilsApi.get_application_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/application/{application_id}'.sub('{' + 'application_id' + '}', application_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'Application')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_application_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_audit_log_all_using_get(opts = {}) click to toggle source

List all audit log Get details for all audit log. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageAuditLog]

# File lib/nucleus_api/api/utils_api.rb, line 1143
def get_audit_log_all_using_get(opts = {})
  data, _status_code, _headers = get_audit_log_all_using_get_with_http_info(opts)
  data
end
get_audit_log_all_using_get_with_http_info(opts = {}) click to toggle source

List all audit log Get details for all audit log. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageAuditLog, Fixnum, Hash)>] PageAuditLog data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1157
def get_audit_log_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_audit_log_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/audit_log'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageAuditLog')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_audit_log_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_audit_log_using_get(audit_log_id, opts = {}) click to toggle source

Retrieve a audit log Retrieve the information for a audit log. @param audit_log_id UUID audit_log_id @param [Hash] opts the optional parameters @return [AuditLog]

# File lib/nucleus_api/api/utils_api.rb, line 1200
def get_audit_log_using_get(audit_log_id, opts = {})
  data, _status_code, _headers = get_audit_log_using_get_with_http_info(audit_log_id, opts)
  data
end
get_audit_log_using_get_with_http_info(audit_log_id, opts = {}) click to toggle source

Retrieve a audit log Retrieve the information for a audit log. @param audit_log_id UUID audit_log_id @param [Hash] opts the optional parameters @return [Array<(AuditLog, Fixnum, Hash)>] AuditLog data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1210
def get_audit_log_using_get_with_http_info(audit_log_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_audit_log_using_get ...'
  end
  # verify the required parameter 'audit_log_id' is set
  if @api_client.config.client_side_validation && audit_log_id.nil?
    fail ArgumentError, "Missing the required parameter 'audit_log_id' when calling UtilsApi.get_audit_log_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/audit_log/{audit_log_id}'.sub('{' + 'audit_log_id' + '}', audit_log_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'AuditLog')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_audit_log_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_feature_all_using_get(opts = {}) click to toggle source

List all Feature Get details for all features. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageFeature]

# File lib/nucleus_api/api/utils_api.rb, line 1256
def get_feature_all_using_get(opts = {})
  data, _status_code, _headers = get_feature_all_using_get_with_http_info(opts)
  data
end
get_feature_all_using_get_with_http_info(opts = {}) click to toggle source

List all Feature Get details for all features. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageFeature, Fixnum, Hash)>] PageFeature data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1270
def get_feature_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_feature_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/feature'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageFeature')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_feature_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_feature_track_all_using_get(opts = {}) click to toggle source

List all Feature track Get details for all feature track. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageFeatureTrack]

# File lib/nucleus_api/api/utils_api.rb, line 1317
def get_feature_track_all_using_get(opts = {})
  data, _status_code, _headers = get_feature_track_all_using_get_with_http_info(opts)
  data
end
get_feature_track_all_using_get_with_http_info(opts = {}) click to toggle source

List all Feature track Get details for all feature track. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageFeatureTrack, Fixnum, Hash)>] PageFeatureTrack data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1331
def get_feature_track_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_feature_track_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/feature_track'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageFeatureTrack')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_feature_track_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_feature_track_using_get(feature_track_id, opts = {}) click to toggle source

Retrieve a Feature track Retrieve the information for a Feature track. @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [FeatureTrack]

# File lib/nucleus_api/api/utils_api.rb, line 1374
def get_feature_track_using_get(feature_track_id, opts = {})
  data, _status_code, _headers = get_feature_track_using_get_with_http_info(feature_track_id, opts)
  data
end
get_feature_track_using_get_with_http_info(feature_track_id, opts = {}) click to toggle source

Retrieve a Feature track Retrieve the information for a Feature track. @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [Array<(FeatureTrack, Fixnum, Hash)>] FeatureTrack data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1384
def get_feature_track_using_get_with_http_info(feature_track_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_feature_track_using_get ...'
  end
  # verify the required parameter 'feature_track_id' is set
  if @api_client.config.client_side_validation && feature_track_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_track_id' when calling UtilsApi.get_feature_track_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature_track/{feature_track_id}'.sub('{' + 'feature_track_id' + '}', feature_track_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'FeatureTrack')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_feature_track_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_feature_using_get(feature_id, opts = {}) click to toggle source

Retrieve a Feature Retrieve the information for a Feature. @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [Feature]

# File lib/nucleus_api/api/utils_api.rb, line 1426
def get_feature_using_get(feature_id, opts = {})
  data, _status_code, _headers = get_feature_using_get_with_http_info(feature_id, opts)
  data
end
get_feature_using_get_with_http_info(feature_id, opts = {}) click to toggle source

Retrieve a Feature Retrieve the information for a Feature. @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [Array<(Feature, Fixnum, Hash)>] Feature data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1436
def get_feature_using_get_with_http_info(feature_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_feature_using_get ...'
  end
  # verify the required parameter 'feature_id' is set
  if @api_client.config.client_side_validation && feature_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_id' when calling UtilsApi.get_feature_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature/{feature_id}'.sub('{' + 'feature_id' + '}', feature_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'Feature')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_feature_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_all_using_get(opts = {}) click to toggle source

Get All Notifications Get All Notification. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageNotification]

# File lib/nucleus_api/api/utils_api.rb, line 1482
def get_notification_all_using_get(opts = {})
  data, _status_code, _headers = get_notification_all_using_get_with_http_info(opts)
  data
end
get_notification_all_using_get_with_http_info(opts = {}) click to toggle source

Get All Notifications Get All Notification. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageNotification, Fixnum, Hash)>] PageNotification data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1496
def get_notification_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/notification'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].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 => 'PageNotification')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_client_all_using_get(opts = {}) click to toggle source

List all Notification Client List all Notification Client. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageNotificationClient]

# File lib/nucleus_api/api/utils_api.rb, line 1543
def get_notification_client_all_using_get(opts = {})
  data, _status_code, _headers = get_notification_client_all_using_get_with_http_info(opts)
  data
end
get_notification_client_all_using_get_with_http_info(opts = {}) click to toggle source

List all Notification Client List all Notification Client. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageNotificationClient, Fixnum, Hash)>] PageNotificationClient data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1557
def get_notification_client_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_client_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_client'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].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 => 'PageNotificationClient')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_client_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_client_using_get(notification_client_id, opts = {}) click to toggle source

Retrieve a Notification Client Retrieve a Notification Client. @param notification_client_id notification_client_id @param [Hash] opts the optional parameters @return [NotificationClient]

# File lib/nucleus_api/api/utils_api.rb, line 1600
def get_notification_client_using_get(notification_client_id, opts = {})
  data, _status_code, _headers = get_notification_client_using_get_with_http_info(notification_client_id, opts)
  data
end
get_notification_client_using_get_with_http_info(notification_client_id, opts = {}) click to toggle source

Retrieve a Notification Client Retrieve a Notification Client. @param notification_client_id notification_client_id @param [Hash] opts the optional parameters @return [Array<(NotificationClient, Fixnum, Hash)>] NotificationClient data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1610
def get_notification_client_using_get_with_http_info(notification_client_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_client_using_get ...'
  end
  # verify the required parameter 'notification_client_id' is set
  if @api_client.config.client_side_validation && notification_client_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_client_id' when calling UtilsApi.get_notification_client_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_client/{notification_client_id}'.sub('{' + 'notification_client_id' + '}', notification_client_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'NotificationClient')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_client_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_setting_all_using_get(opts = {}) click to toggle source

List all Notification Setting List all Notification Setting. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageNotificationSetting]

# File lib/nucleus_api/api/utils_api.rb, line 1656
def get_notification_setting_all_using_get(opts = {})
  data, _status_code, _headers = get_notification_setting_all_using_get_with_http_info(opts)
  data
end
get_notification_setting_all_using_get_with_http_info(opts = {}) click to toggle source

List all Notification Setting List all Notification Setting. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageNotificationSetting, Fixnum, Hash)>] PageNotificationSetting data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1670
def get_notification_setting_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_setting_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_setting'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].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 => 'PageNotificationSetting')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_setting_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_setting_using_get(notification_setting_id, opts = {}) click to toggle source

Retrieve a Notification Setting Retrieve a Notification Setting. @param notification_setting_id notification_setting_id @param [Hash] opts the optional parameters @return [NotificationSetting]

# File lib/nucleus_api/api/utils_api.rb, line 1713
def get_notification_setting_using_get(notification_setting_id, opts = {})
  data, _status_code, _headers = get_notification_setting_using_get_with_http_info(notification_setting_id, opts)
  data
end
get_notification_setting_using_get_with_http_info(notification_setting_id, opts = {}) click to toggle source

Retrieve a Notification Setting Retrieve a Notification Setting. @param notification_setting_id notification_setting_id @param [Hash] opts the optional parameters @return [Array<(NotificationSetting, Fixnum, Hash)>] NotificationSetting data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1723
def get_notification_setting_using_get_with_http_info(notification_setting_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_setting_using_get ...'
  end
  # verify the required parameter 'notification_setting_id' is set
  if @api_client.config.client_side_validation && notification_setting_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_setting_id' when calling UtilsApi.get_notification_setting_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_setting/{notification_setting_id}'.sub('{' + 'notification_setting_id' + '}', notification_setting_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'NotificationSetting')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_setting_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_notification_using_get(notification_id, opts = {}) click to toggle source

Get a Notification Get a Notification. @param notification_id notification_id @param [Hash] opts the optional parameters @return [Notification]

# File lib/nucleus_api/api/utils_api.rb, line 1765
def get_notification_using_get(notification_id, opts = {})
  data, _status_code, _headers = get_notification_using_get_with_http_info(notification_id, opts)
  data
end
get_notification_using_get_with_http_info(notification_id, opts = {}) click to toggle source

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

# File lib/nucleus_api/api/utils_api.rb, line 1775
def get_notification_using_get_with_http_info(notification_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_notification_using_get ...'
  end
  # verify the required parameter 'notification_id' is set
  if @api_client.config.client_side_validation && notification_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_id' when calling UtilsApi.get_notification_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification/{notification_id}'.sub('{' + 'notification_id' + '}', notification_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 => 'Notification')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_notification_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_reason_code_all_using_get(opts = {}) click to toggle source

List all reason codes Get the information for all reason codes defined by your firm. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageReasonCode]

# File lib/nucleus_api/api/utils_api.rb, line 1821
def get_reason_code_all_using_get(opts = {})
  data, _status_code, _headers = get_reason_code_all_using_get_with_http_info(opts)
  data
end
get_reason_code_all_using_get_with_http_info(opts = {}) click to toggle source

List all reason codes Get the information for all reason codes defined by your firm. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageReasonCode, Fixnum, Hash)>] PageReasonCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1835
def get_reason_code_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_reason_code_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/reason_code'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageReasonCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_reason_code_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_reason_code_using_get(reason_code_id, opts = {}) click to toggle source

Retrieve a reason code Retrieve the information for a reason code defined by your firm. @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [ReasonCode]

# File lib/nucleus_api/api/utils_api.rb, line 1878
def get_reason_code_using_get(reason_code_id, opts = {})
  data, _status_code, _headers = get_reason_code_using_get_with_http_info(reason_code_id, opts)
  data
end
get_reason_code_using_get_with_http_info(reason_code_id, opts = {}) click to toggle source

Retrieve a reason code Retrieve the information for a reason code defined by your firm. @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [Array<(ReasonCode, Fixnum, Hash)>] ReasonCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1888
def get_reason_code_using_get_with_http_info(reason_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_reason_code_using_get ...'
  end
  # verify the required parameter 'reason_code_id' is set
  if @api_client.config.client_side_validation && reason_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'reason_code_id' when calling UtilsApi.get_reason_code_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/reason_code/{reason_code_id}'.sub('{' + 'reason_code_id' + '}', reason_code_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'ReasonCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_reason_code_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_stage_all_using_get(opts = {}) click to toggle source

List all account stages Get the information for all possible account stages. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageStage]

# File lib/nucleus_api/api/utils_api.rb, line 1934
def get_stage_all_using_get(opts = {})
  data, _status_code, _headers = get_stage_all_using_get_with_http_info(opts)
  data
end
get_stage_all_using_get_with_http_info(opts = {}) click to toggle source

List all account stages Get the information for all possible account stages. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageStage, Fixnum, Hash)>] PageStage data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 1948
def get_stage_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_stage_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/stage'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageStage')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_stage_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_stage_using_get(stage_id, opts = {}) click to toggle source

Retrieve an account stage Retrieve the information for a specific account stage. @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [Stage]

# File lib/nucleus_api/api/utils_api.rb, line 1991
def get_stage_using_get(stage_id, opts = {})
  data, _status_code, _headers = get_stage_using_get_with_http_info(stage_id, opts)
  data
end
get_stage_using_get_with_http_info(stage_id, opts = {}) click to toggle source

Retrieve an account stage Retrieve the information for a specific account stage. @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [Array<(Stage, Fixnum, Hash)>] Stage data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2001
def get_stage_using_get_with_http_info(stage_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_stage_using_get ...'
  end
  # verify the required parameter 'stage_id' is set
  if @api_client.config.client_side_validation && stage_id.nil?
    fail ArgumentError, "Missing the required parameter 'stage_id' when calling UtilsApi.get_stage_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/stage/{stage_id}'.sub('{' + 'stage_id' + '}', stage_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'Stage')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_stage_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_transaction_code_all_using_get(opts = {}) click to toggle source

List all transaction codes Get the information for all transaction codes defined by your firm. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending (default to false) @option opts [String] :filter filter @option opts [String] :order_by order_by (default to update_date) @option opts [Integer] :page page (default to 0) @option opts [Integer] :size size (default to 25) @return [PageTransactionCode]

# File lib/nucleus_api/api/utils_api.rb, line 2047
def get_transaction_code_all_using_get(opts = {})
  data, _status_code, _headers = get_transaction_code_all_using_get_with_http_info(opts)
  data
end
get_transaction_code_all_using_get_with_http_info(opts = {}) click to toggle source

List all transaction codes Get the information for all transaction codes defined by your firm. @param [Hash] opts the optional parameters @option opts [BOOLEAN] :ascending ascending @option opts [String] :filter filter @option opts [String] :order_by order_by @option opts [Integer] :page page @option opts [Integer] :size size @return [Array<(PageTransactionCode, Fixnum, Hash)>] PageTransactionCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2061
def get_transaction_code_all_using_get_with_http_info(opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_transaction_code_all_using_get ...'
  end
  # resource path
  local_var_path = '/nucleus/v1/transaction_code'

  # query parameters
  query_params = {}
  query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?
  query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?
  query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?

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

  # 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 => 'PageTransactionCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_transaction_code_all_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
get_transaction_code_using_get(transaction_code_id, opts = {}) click to toggle source

Retrieve a transaction code Retrieve the information for a transaction code defined by your firm. @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [TransactionCode]

# File lib/nucleus_api/api/utils_api.rb, line 2104
def get_transaction_code_using_get(transaction_code_id, opts = {})
  data, _status_code, _headers = get_transaction_code_using_get_with_http_info(transaction_code_id, opts)
  data
end
get_transaction_code_using_get_with_http_info(transaction_code_id, opts = {}) click to toggle source

Retrieve a transaction code Retrieve the information for a transaction code defined by your firm. @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [Array<(TransactionCode, Fixnum, Hash)>] TransactionCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2114
def get_transaction_code_using_get_with_http_info(transaction_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.get_transaction_code_using_get ...'
  end
  # verify the required parameter 'transaction_code_id' is set
  if @api_client.config.client_side_validation && transaction_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'transaction_code_id' when calling UtilsApi.get_transaction_code_using_get"
  end
  # resource path
  local_var_path = '/nucleus/v1/transaction_code/{transaction_code_id}'.sub('{' + 'transaction_code_id' + '}', transaction_code_id.to_s)

  # query parameters
  query_params = {}

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

  # 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 => 'TransactionCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#get_transaction_code_using_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_application_using_put(application, application_id, opts = {}) click to toggle source

Update an Application Update the information for an Application @param application application @param application_id UUID application_id @param [Hash] opts the optional parameters @return [Application]

# File lib/nucleus_api/api/utils_api.rb, line 2157
def update_application_using_put(application, application_id, opts = {})
  data, _status_code, _headers = update_application_using_put_with_http_info(application, application_id, opts)
  data
end
update_application_using_put_with_http_info(application, application_id, opts = {}) click to toggle source

Update an Application Update the information for an Application @param application application @param application_id UUID application_id @param [Hash] opts the optional parameters @return [Array<(Application, Fixnum, Hash)>] Application data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2168
def update_application_using_put_with_http_info(application, application_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_application_using_put ...'
  end
  # verify the required parameter 'application' is set
  if @api_client.config.client_side_validation && application.nil?
    fail ArgumentError, "Missing the required parameter 'application' when calling UtilsApi.update_application_using_put"
  end
  # verify the required parameter 'application_id' is set
  if @api_client.config.client_side_validation && application_id.nil?
    fail ArgumentError, "Missing the required parameter 'application_id' when calling UtilsApi.update_application_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/application/{application_id}'.sub('{' + 'application_id' + '}', application_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(application)
  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 => 'Application')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_application_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_feature_track_using_put(feature_track, feature_track_id, opts = {}) click to toggle source

Update a Feature Track Update the information for a Feature track registered with your firm. @param feature_track feature_track @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [FeatureTrack]

# File lib/nucleus_api/api/utils_api.rb, line 2217
def update_feature_track_using_put(feature_track, feature_track_id, opts = {})
  data, _status_code, _headers = update_feature_track_using_put_with_http_info(feature_track, feature_track_id, opts)
  data
end
update_feature_track_using_put_with_http_info(feature_track, feature_track_id, opts = {}) click to toggle source

Update a Feature Track Update the information for a Feature track registered with your firm. @param feature_track feature_track @param feature_track_id UUID feature_track_id @param [Hash] opts the optional parameters @return [Array<(FeatureTrack, Fixnum, Hash)>] FeatureTrack data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2228
def update_feature_track_using_put_with_http_info(feature_track, feature_track_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_feature_track_using_put ...'
  end
  # verify the required parameter 'feature_track' is set
  if @api_client.config.client_side_validation && feature_track.nil?
    fail ArgumentError, "Missing the required parameter 'feature_track' when calling UtilsApi.update_feature_track_using_put"
  end
  # verify the required parameter 'feature_track_id' is set
  if @api_client.config.client_side_validation && feature_track_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_track_id' when calling UtilsApi.update_feature_track_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature_track/{feature_track_id}'.sub('{' + 'feature_track_id' + '}', feature_track_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(feature_track)
  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 => 'FeatureTrack')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_feature_track_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_feature_using_put(feature, feature_id, opts = {}) click to toggle source

Update a Feature Update the information for a Feature registered with your firm. @param feature feature @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [Feature]

# File lib/nucleus_api/api/utils_api.rb, line 2277
def update_feature_using_put(feature, feature_id, opts = {})
  data, _status_code, _headers = update_feature_using_put_with_http_info(feature, feature_id, opts)
  data
end
update_feature_using_put_with_http_info(feature, feature_id, opts = {}) click to toggle source

Update a Feature Update the information for a Feature registered with your firm. @param feature feature @param feature_id UUID feature_id @param [Hash] opts the optional parameters @return [Array<(Feature, Fixnum, Hash)>] Feature data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2288
def update_feature_using_put_with_http_info(feature, feature_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_feature_using_put ...'
  end
  # verify the required parameter 'feature' is set
  if @api_client.config.client_side_validation && feature.nil?
    fail ArgumentError, "Missing the required parameter 'feature' when calling UtilsApi.update_feature_using_put"
  end
  # verify the required parameter 'feature_id' is set
  if @api_client.config.client_side_validation && feature_id.nil?
    fail ArgumentError, "Missing the required parameter 'feature_id' when calling UtilsApi.update_feature_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/feature/{feature_id}'.sub('{' + 'feature_id' + '}', feature_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(feature)
  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 => 'Feature')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_feature_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_notification_client_using_put(notification_client, notification_client_id, opts = {}) click to toggle source

Update a Notification Client Update a Notification Client. @param notification_client notification_client @param notification_client_id UUID notification_client_id @param [Hash] opts the optional parameters @return [NotificationClient]

# File lib/nucleus_api/api/utils_api.rb, line 2337
def update_notification_client_using_put(notification_client, notification_client_id, opts = {})
  data, _status_code, _headers = update_notification_client_using_put_with_http_info(notification_client, notification_client_id, opts)
  data
end
update_notification_client_using_put_with_http_info(notification_client, notification_client_id, opts = {}) click to toggle source

Update a Notification Client Update a Notification Client. @param notification_client notification_client @param notification_client_id UUID notification_client_id @param [Hash] opts the optional parameters @return [Array<(NotificationClient, Fixnum, Hash)>] NotificationClient data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2348
def update_notification_client_using_put_with_http_info(notification_client, notification_client_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_notification_client_using_put ...'
  end
  # verify the required parameter 'notification_client' is set
  if @api_client.config.client_side_validation && notification_client.nil?
    fail ArgumentError, "Missing the required parameter 'notification_client' when calling UtilsApi.update_notification_client_using_put"
  end
  # verify the required parameter 'notification_client_id' is set
  if @api_client.config.client_side_validation && notification_client_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_client_id' when calling UtilsApi.update_notification_client_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_client/{notification_client_id}'.sub('{' + 'notification_client_id' + '}', notification_client_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification_client)
  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 => 'NotificationClient')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_notification_client_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_notification_setting_using_put(notification_setting, notification_setting_id, opts = {}) click to toggle source

Update a Notification Setting Update a Notification Setting. @param notification_setting notification_setting @param notification_setting_id UUID notification_setting_id @param [Hash] opts the optional parameters @return [NotificationSetting]

# File lib/nucleus_api/api/utils_api.rb, line 2397
def update_notification_setting_using_put(notification_setting, notification_setting_id, opts = {})
  data, _status_code, _headers = update_notification_setting_using_put_with_http_info(notification_setting, notification_setting_id, opts)
  data
end
update_notification_setting_using_put_with_http_info(notification_setting, notification_setting_id, opts = {}) click to toggle source

Update a Notification Setting Update a Notification Setting. @param notification_setting notification_setting @param notification_setting_id UUID notification_setting_id @param [Hash] opts the optional parameters @return [Array<(NotificationSetting, Fixnum, Hash)>] NotificationSetting data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2408
def update_notification_setting_using_put_with_http_info(notification_setting, notification_setting_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_notification_setting_using_put ...'
  end
  # verify the required parameter 'notification_setting' is set
  if @api_client.config.client_side_validation && notification_setting.nil?
    fail ArgumentError, "Missing the required parameter 'notification_setting' when calling UtilsApi.update_notification_setting_using_put"
  end
  # verify the required parameter 'notification_setting_id' is set
  if @api_client.config.client_side_validation && notification_setting_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_setting_id' when calling UtilsApi.update_notification_setting_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification_setting/{notification_setting_id}'.sub('{' + 'notification_setting_id' + '}', notification_setting_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification_setting)
  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 => 'NotificationSetting')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_notification_setting_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_notification_using_put(notification, notification_id, opts = {}) click to toggle source

Update a Notification Update a Notification. @param notification notification @param notification_id UUID notification_id @param [Hash] opts the optional parameters @return [Notification]

# File lib/nucleus_api/api/utils_api.rb, line 2457
def update_notification_using_put(notification, notification_id, opts = {})
  data, _status_code, _headers = update_notification_using_put_with_http_info(notification, notification_id, opts)
  data
end
update_notification_using_put_with_http_info(notification, notification_id, opts = {}) click to toggle source

Update a Notification Update a Notification. @param notification notification @param notification_id UUID notification_id @param [Hash] opts the optional parameters @return [Array<(Notification, Fixnum, Hash)>] Notification data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2468
def update_notification_using_put_with_http_info(notification, notification_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_notification_using_put ...'
  end
  # verify the required parameter 'notification' is set
  if @api_client.config.client_side_validation && notification.nil?
    fail ArgumentError, "Missing the required parameter 'notification' when calling UtilsApi.update_notification_using_put"
  end
  # verify the required parameter 'notification_id' is set
  if @api_client.config.client_side_validation && notification_id.nil?
    fail ArgumentError, "Missing the required parameter 'notification_id' when calling UtilsApi.update_notification_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/notification/{notification_id}'.sub('{' + 'notification_id' + '}', notification_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(notification)
  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 => 'Notification')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_notification_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_reason_code_using_put(reason_code, reason_code_id, opts = {}) click to toggle source

Update a reason code Update a reason code for your firm. @param reason_code reason_code @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [ReasonCode]

# File lib/nucleus_api/api/utils_api.rb, line 2517
def update_reason_code_using_put(reason_code, reason_code_id, opts = {})
  data, _status_code, _headers = update_reason_code_using_put_with_http_info(reason_code, reason_code_id, opts)
  data
end
update_reason_code_using_put_with_http_info(reason_code, reason_code_id, opts = {}) click to toggle source

Update a reason code Update a reason code for your firm. @param reason_code reason_code @param reason_code_id UUID reason_code_id @param [Hash] opts the optional parameters @return [Array<(ReasonCode, Fixnum, Hash)>] ReasonCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2528
def update_reason_code_using_put_with_http_info(reason_code, reason_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_reason_code_using_put ...'
  end
  # verify the required parameter 'reason_code' is set
  if @api_client.config.client_side_validation && reason_code.nil?
    fail ArgumentError, "Missing the required parameter 'reason_code' when calling UtilsApi.update_reason_code_using_put"
  end
  # verify the required parameter 'reason_code_id' is set
  if @api_client.config.client_side_validation && reason_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'reason_code_id' when calling UtilsApi.update_reason_code_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/reason_code/{reason_code_id}'.sub('{' + 'reason_code_id' + '}', reason_code_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(reason_code)
  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 => 'ReasonCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_reason_code_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_stage_using_put(stage, stage_id, opts = {}) click to toggle source

Update an account stage Update the information for an account stage. @param stage stage @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [Stage]

# File lib/nucleus_api/api/utils_api.rb, line 2577
def update_stage_using_put(stage, stage_id, opts = {})
  data, _status_code, _headers = update_stage_using_put_with_http_info(stage, stage_id, opts)
  data
end
update_stage_using_put_with_http_info(stage, stage_id, opts = {}) click to toggle source

Update an account stage Update the information for an account stage. @param stage stage @param stage_id UUID stage_id @param [Hash] opts the optional parameters @return [Array<(Stage, Fixnum, Hash)>] Stage data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2588
def update_stage_using_put_with_http_info(stage, stage_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_stage_using_put ...'
  end
  # verify the required parameter 'stage' is set
  if @api_client.config.client_side_validation && stage.nil?
    fail ArgumentError, "Missing the required parameter 'stage' when calling UtilsApi.update_stage_using_put"
  end
  # verify the required parameter 'stage_id' is set
  if @api_client.config.client_side_validation && stage_id.nil?
    fail ArgumentError, "Missing the required parameter 'stage_id' when calling UtilsApi.update_stage_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/stage/{stage_id}'.sub('{' + 'stage_id' + '}', stage_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(stage)
  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 => 'Stage')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_stage_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end
update_transaction_code_using_put(transaction_code, transaction_code_id, opts = {}) click to toggle source

Update a transaction code Update a transaction code for your firm. @param transaction_code transaction_code @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [TransactionCode]

# File lib/nucleus_api/api/utils_api.rb, line 2637
def update_transaction_code_using_put(transaction_code, transaction_code_id, opts = {})
  data, _status_code, _headers = update_transaction_code_using_put_with_http_info(transaction_code, transaction_code_id, opts)
  data
end
update_transaction_code_using_put_with_http_info(transaction_code, transaction_code_id, opts = {}) click to toggle source

Update a transaction code Update a transaction code for your firm. @param transaction_code transaction_code @param transaction_code_id UUID transaction_code_id @param [Hash] opts the optional parameters @return [Array<(TransactionCode, Fixnum, Hash)>] TransactionCode data, response status code and response headers

# File lib/nucleus_api/api/utils_api.rb, line 2648
def update_transaction_code_using_put_with_http_info(transaction_code, transaction_code_id, opts = {})
  if @api_client.config.debugging
    @api_client.config.logger.debug 'Calling API: UtilsApi.update_transaction_code_using_put ...'
  end
  # verify the required parameter 'transaction_code' is set
  if @api_client.config.client_side_validation && transaction_code.nil?
    fail ArgumentError, "Missing the required parameter 'transaction_code' when calling UtilsApi.update_transaction_code_using_put"
  end
  # verify the required parameter 'transaction_code_id' is set
  if @api_client.config.client_side_validation && transaction_code_id.nil?
    fail ArgumentError, "Missing the required parameter 'transaction_code_id' when calling UtilsApi.update_transaction_code_using_put"
  end
  # resource path
  local_var_path = '/nucleus/v1/transaction_code/{transaction_code_id}'.sub('{' + 'transaction_code_id' + '}', transaction_code_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['*/*'])
  # 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(transaction_code)
  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 => 'TransactionCode')
  if @api_client.config.debugging
    @api_client.config.logger.debug "API called: UtilsApi#update_transaction_code_using_put\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
  end
  return data, status_code, headers
end