class LabelDescriptionServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def all(self, **kwargs): """All This operation returns all entities which are available. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all(async_req=True) >>> result = thread.get() :param async_req bool :return: list[LabelDescriptor] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.all_with_http_info(**kwargs) else: (data) = self.all_with_http_info(**kwargs) return data def all_with_http_info(self, **kwargs): """All This operation returns all entities which are available. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool :return: list[LabelDescriptor] If the method is called asynchronously, returns the request thread. """ all_params = [] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method all" % key) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/label-description-service/all', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[LabelDescriptor]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: The id of the label descriptor which should be returned. (required) :return: LabelDescriptor If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(id, **kwargs) else: (data) = self.read_with_http_info(id, **kwargs) return data def read_with_http_info(self, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: The id of the label descriptor which should be returned. (required) :return: LabelDescriptor If the method is called asynchronously, returns the request thread. """ all_params = ['id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method read" % key) params[key] = val del params['kwargs'] # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/label-description-service/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='LabelDescriptor', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class BankTransactionServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method count" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `count`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/bank-transaction/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The ID of the bank transaction which should be returned. (required) :return: BankTransaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The ID of the bank transaction which should be returned. (required) :return: BankTransaction If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `read`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/bank-transaction/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='BankTransaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the bank transactions which are returned by the search. (required) :return: list[BankTransaction] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the bank transactions which are returned by the search. (required) :return: list[BankTransaction] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method search" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `search`") # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError("Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/bank-transaction/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[BankTransaction]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class CountryServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def all(self, **kwargs): """All This operation returns all countries. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all(async_req=True) >>> result = thread.get() :param async_req bool :return: list[RestCountry] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.all_with_http_info(**kwargs) else: (data) = self.all_with_http_info(**kwargs) return data def all_with_http_info(self, **kwargs): """All This operation returns all countries. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool :return: list[RestCountry] If the method is called asynchronously, returns the request thread. """ all_params = [] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method all" % key) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/country/all', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[RestCountry]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class ChargeFlowServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def apply_flow(self, space_id, id, **kwargs): """applyFlow This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.apply_flow(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The transaction id of the transaction which should be process asynchronously. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.apply_flow_with_http_info(space_id, id, **kwargs) else: (data) = self.apply_flow_with_http_info(space_id, id, **kwargs) return data def apply_flow_with_http_info(self, space_id, id, **kwargs): """applyFlow This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.apply_flow_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The transaction id of the transaction which should be process asynchronously. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method apply_flow" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `apply_flow`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `apply_flow`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/applyFlow', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Transaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def cancel_charge_flow(self, space_id, id, **kwargs): """Cancel Charge Flow This operation cancels the charge flow that is linked with the transaction indicated by the given ID. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.cancel_charge_flow(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The ID of the transaction for which the charge flow should be canceled. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.cancel_charge_flow_with_http_info(space_id, id, **kwargs) else: (data) = self.cancel_charge_flow_with_http_info(space_id, id, **kwargs) return data def cancel_charge_flow_with_http_info(self, space_id, id, **kwargs): """Cancel Charge Flow This operation cancels the charge flow that is linked with the transaction indicated by the given ID. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.cancel_charge_flow_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The ID of the transaction for which the charge flow should be canceled. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method cancel_charge_flow" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `cancel_charge_flow`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `cancel_charge_flow`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/cancel-charge-flow', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Transaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method count" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `count`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def fetch_charge_flow_payment_page_url(self, space_id, id, **kwargs): """Fetch Charge Flow Payment Page URL This operation allows to fetch the payment page URL that is been applied on the charge flow linked with the provided transaction. The operation might return an empty result when no payment page is needed or can be invoked. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fetch_charge_flow_payment_page_url(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The transaction id of the transaction for which the URL of the charge flow should be fetched. (required) :return: str If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.fetch_charge_flow_payment_page_url_with_http_info(space_id, id, **kwargs) else: (data) = self.fetch_charge_flow_payment_page_url_with_http_info(space_id, id, **kwargs) return data def fetch_charge_flow_payment_page_url_with_http_info(self, space_id, id, **kwargs): """Fetch Charge Flow Payment Page URL This operation allows to fetch the payment page URL that is been applied on the charge flow linked with the provided transaction. The operation might return an empty result when no payment page is needed or can be invoked. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fetch_charge_flow_payment_page_url_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The transaction id of the transaction for which the URL of the charge flow should be fetched. (required) :return: str If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method fetch_charge_flow_payment_page_url" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `fetch_charge_flow_payment_page_url`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `fetch_charge_flow_payment_page_url`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json', 'text/plain;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/fetch-charge-flow-payment-page-url', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='str', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the charge flow which should be returned. (required) :return: ChargeFlow If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the charge flow which should be returned. (required) :return: ChargeFlow If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `read`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ChargeFlow', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the charge flows which are returned by the search. (required) :return: list[ChargeFlow] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the charge flows which are returned by the search. (required) :return: list[ChargeFlow] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method search" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `search`") # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError("Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[ChargeFlow]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update_recipient(self, space_id, transaction_id, type, recipient, **kwargs): """updateRecipient This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_recipient(space_id, transaction_id, type, recipient, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The transaction id of the transaction whose recipient should be updated. (required) :param int type: The id of the charge flow configuration type to recipient should be updated for. (required) :param str recipient: The recipient address that should be used to send the payment URL. (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_recipient_with_http_info(space_id, transaction_id, type, recipient, **kwargs) else: (data) = self.update_recipient_with_http_info(space_id, transaction_id, type, recipient, **kwargs) return data def update_recipient_with_http_info(self, space_id, transaction_id, type, recipient, **kwargs): """updateRecipient This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_recipient_with_http_info(space_id, transaction_id, type, recipient, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The transaction id of the transaction whose recipient should be updated. (required) :param int type: The id of the charge flow configuration type to recipient should be updated for. (required) :param str recipient: The recipient address that should be used to send the payment URL. (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id', 'type', 'recipient'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method update_recipient" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `update_recipient`") # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError("Missing the required parameter `transaction_id` when calling `update_recipient`") # verify the required parameter 'type' is set if ('type' not in params or params['type'] is None): raise ValueError("Missing the required parameter `type` when calling `update_recipient`") # verify the required parameter 'recipient' is set if ('recipient' not in params or params['recipient'] is None): raise ValueError("Missing the required parameter `recipient` when calling `update_recipient`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) if 'type' in params: query_params.append(('type', params['type'])) if 'recipient' in params: query_params.append(('recipient', params['recipient'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/charge-flow/updateRecipient', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class SpaceServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def count(self, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(async_req=True) >>> result = thread.get() :param async_req bool :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(**kwargs) else: (data) = self.count_with_http_info(**kwargs) return data def count_with_http_info(self, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method count" % key ) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create(self, entity, **kwargs): """Create Creates the entity with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create(entity, async_req=True) >>> result = thread.get() :param async_req bool :param SpaceCreate entity: The space object with the properties which should be created. (required) :return: Space If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_with_http_info(entity, **kwargs) else: (data) = self.create_with_http_info(entity, **kwargs) return data def create_with_http_info(self, entity, **kwargs): """Create Creates the entity with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_with_http_info(entity, async_req=True) >>> result = thread.get() :param async_req bool :param SpaceCreate entity: The space object with the properties which should be created. (required) :return: Space If the method is called asynchronously, returns the request thread. """ all_params = ['entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method create" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError("Missing the required parameter `entity` when calling `create`") collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/create', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Space', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def delete(self, id, **kwargs): """Delete Deletes the entity with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.delete_with_http_info(id, **kwargs) else: (data) = self.delete_with_http_info(id, **kwargs) return data def delete_with_http_info(self, id, **kwargs): """Delete Deletes the entity with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_with_http_info(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method delete" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `delete`") collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'id' in params: body_params = params['id'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/delete', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: The id of the space which should be returned. (required) :return: Space If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(id, **kwargs) else: (data) = self.read_with_http_info(id, **kwargs) return data def read_with_http_info(self, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(id, async_req=True) >>> result = thread.get() :param async_req bool :param int id: The id of the space which should be returned. (required) :return: Space If the method is called asynchronously, returns the request thread. """ all_params = ['id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Space', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(query, async_req=True) >>> result = thread.get() :param async_req bool :param EntityQuery query: The query restricts the spaces which are returned by the search. (required) :return: list[Space] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(query, **kwargs) else: (data) = self.search_with_http_info(query, **kwargs) return data def search_with_http_info(self, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(query, async_req=True) >>> result = thread.get() :param async_req bool :param EntityQuery query: The query restricts the spaces which are returned by the search. (required) :return: list[Space] If the method is called asynchronously, returns the request thread. """ all_params = ['query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method search" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError("Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[Space]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update(self, entity, **kwargs): """Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update(entity, async_req=True) >>> result = thread.get() :param async_req bool :param SpaceUpdate entity: The space object with all the properties which should be updated. The id and the version are required properties. (required) :return: Space If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_with_http_info(entity, **kwargs) else: (data) = self.update_with_http_info(entity, **kwargs) return data def update_with_http_info(self, entity, **kwargs): """Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_with_http_info(entity, async_req=True) >>> result = thread.get() :param async_req bool :param SpaceUpdate entity: The space object with all the properties which should be updated. The id and the version are required properties. (required) :return: Space If the method is called asynchronously, returns the request thread. """ all_params = ['entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method update" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError("Missing the required parameter `entity` when calling `update`") collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/space/update', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Space', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class TransactionCommentServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def all(self, space_id, transaction_id, **kwargs): """Find by transaction Returns all comments of the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: (required) :return: list[TransactionComment] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.all_with_http_info(space_id, transaction_id, **kwargs) else: (data) = self.all_with_http_info(space_id, transaction_id, **kwargs) return data def all_with_http_info(self, space_id, transaction_id, **kwargs): """Find by transaction Returns all comments of the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all_with_http_info(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: (required) :return: list[TransactionComment] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method all" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `all`") # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError("Missing the required parameter `transaction_id` when calling `all`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/all', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[TransactionComment]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create(self, space_id, entity, **kwargs): """Create Creates the comment with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TransactionCommentCreate entity: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_with_http_info(space_id, entity, **kwargs) else: (data) = self.create_with_http_info(space_id, entity, **kwargs) return data def create_with_http_info(self, space_id, entity, **kwargs): """Create Creates the comment with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_with_http_info(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TransactionCommentCreate entity: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method create" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `create`") # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError("Missing the required parameter `entity` when calling `create`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/create', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionComment', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def delete(self, space_id, id, **kwargs): """Delete Deletes the comment with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.delete_with_http_info(space_id, id, **kwargs) else: (data) = self.delete_with_http_info(space_id, id, **kwargs) return data def delete_with_http_info(self, space_id, id, **kwargs): """Delete Deletes the comment with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method delete" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `delete`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `delete`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/delete', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def pin(self, space_id, id, **kwargs): """Pin Pins the comment to the top. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.pin(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.pin_with_http_info(space_id, id, **kwargs) else: (data) = self.pin_with_http_info(space_id, id, **kwargs) return data def pin_with_http_info(self, space_id, id, **kwargs): """Pin Pins the comment to the top. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.pin_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method pin" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `pin`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `pin`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/pin', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the comment with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the comment with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `read`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionComment', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def unpin(self, space_id, id, **kwargs): """Unpin Unpins the comment from the top. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unpin(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.unpin_with_http_info(space_id, id, **kwargs) else: (data) = self.unpin_with_http_info(space_id, id, **kwargs) return data def unpin_with_http_info(self, space_id, id, **kwargs): """Unpin Unpins the comment from the top. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unpin_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method unpin" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `unpin`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `unpin`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/unpin', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update(self, space_id, entity, **kwargs): """Update This updates the comment with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the comment. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TransactionCommentActive entity: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_with_http_info(space_id, entity, **kwargs) else: (data) = self.update_with_http_info(space_id, entity, **kwargs) return data def update_with_http_info(self, space_id, entity, **kwargs): """Update This updates the comment with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the comment. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_with_http_info(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TransactionCommentActive entity: (required) :return: TransactionComment If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method update" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `update`") # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError("Missing the required parameter `entity` when calling `update`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-comment/update', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionComment', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class RefundServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method count" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `count`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def fail(self, space_id, refund_id, **kwargs): """fail This operation allows to mark a refund as failed which is in state MANUAL_CHECK. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fail(space_id, refund_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int refund_id: The id of the refund which should be marked as failed. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.fail_with_http_info(space_id, refund_id, **kwargs) else: (data) = self.fail_with_http_info(space_id, refund_id, **kwargs) return data def fail_with_http_info(self, space_id, refund_id, **kwargs): """fail This operation allows to mark a refund as failed which is in state MANUAL_CHECK. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fail_with_http_info(space_id, refund_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int refund_id: The id of the refund which should be marked as failed. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'refund_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method fail" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `fail`") # verify the required parameter 'refund_id' is set if ('refund_id' not in params or params['refund_id'] is None): raise ValueError("Missing the required parameter `refund_id` when calling `fail`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'refund_id' in params: query_params.append(('refundId', params['refund_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/fail', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Refund', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_refund_document(self, space_id, id, **kwargs): """getRefundDocument Returns the PDF document for the refund with given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_refund_document(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund to get the document for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_refund_document_with_http_info(space_id, id, **kwargs) else: (data) = self.get_refund_document_with_http_info(space_id, id, **kwargs) return data def get_refund_document_with_http_info(self, space_id, id, **kwargs): """getRefundDocument Returns the PDF document for the refund with given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_refund_document_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund to get the document for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_refund_document" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `get_refund_document`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `get_refund_document`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/getRefundDocument', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='RenderedDocument', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_refund_document_with_target_media_type(self, space_id, id, target_media_type_id, **kwargs): """getRefundDocumentWithTargetMediaType Returns the PDF document for the refund with given id and the given target media type. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_refund_document_with_target_media_type(space_id, id, target_media_type_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund to get the document for. (required) :param int target_media_type_id: The id of the target media type for which the refund should be generated for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_refund_document_with_target_media_type_with_http_info(space_id, id, target_media_type_id, **kwargs) else: (data) = self.get_refund_document_with_target_media_type_with_http_info(space_id, id, target_media_type_id, **kwargs) return data def get_refund_document_with_target_media_type_with_http_info(self, space_id, id, target_media_type_id, **kwargs): """getRefundDocumentWithTargetMediaType Returns the PDF document for the refund with given id and the given target media type. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_refund_document_with_target_media_type_with_http_info(space_id, id, target_media_type_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund to get the document for. (required) :param int target_media_type_id: The id of the target media type for which the refund should be generated for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id', 'target_media_type_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_refund_document_with_target_media_type" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `get_refund_document_with_target_media_type`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `get_refund_document_with_target_media_type`") # verify the required parameter 'target_media_type_id' is set if ('target_media_type_id' not in params or params['target_media_type_id'] is None): raise ValueError("Missing the required parameter `target_media_type_id` when calling `get_refund_document_with_target_media_type`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) if 'target_media_type_id' in params: query_params.append(('targetMediaTypeId', params['target_media_type_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/getRefundDocumentWithTargetMediaType', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='RenderedDocument', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund which should be returned. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the refund which should be returned. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `read`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Refund', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def refund(self, space_id, refund, **kwargs): """create This operation creates and executes a refund of a particular transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.refund(space_id, refund, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param RefundCreate refund: The refund object which should be created. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.refund_with_http_info(space_id, refund, **kwargs) else: (data) = self.refund_with_http_info(space_id, refund, **kwargs) return data def refund_with_http_info(self, space_id, refund, **kwargs): """create This operation creates and executes a refund of a particular transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.refund_with_http_info(space_id, refund, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param RefundCreate refund: The refund object which should be created. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'refund'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method refund" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `refund`") # verify the required parameter 'refund' is set if ('refund' not in params or params['refund'] is None): raise ValueError("Missing the required parameter `refund` when calling `refund`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'refund' in params: body_params = params['refund'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/refund', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Refund', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the refunds which are returned by the search. (required) :return: list[Refund] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the refunds which are returned by the search. (required) :return: list[Refund] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method search" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `search`") # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError("Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[Refund]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def succeed(self, space_id, refund_id, **kwargs): """succeed This operation allows to mark a refund as successful which is in state MANUAL_CHECK. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.succeed(space_id, refund_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int refund_id: The id of the refund which should be marked as successful. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.succeed_with_http_info(space_id, refund_id, **kwargs) else: (data) = self.succeed_with_http_info(space_id, refund_id, **kwargs) return data def succeed_with_http_info(self, space_id, refund_id, **kwargs): """succeed This operation allows to mark a refund as successful which is in state MANUAL_CHECK. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.succeed_with_http_info(space_id, refund_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int refund_id: The id of the refund which should be marked as successful. (required) :return: Refund If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'refund_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method succeed" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `succeed`") # verify the required parameter 'refund_id' is set if ('refund_id' not in params or params['refund_id'] is None): raise ValueError("Missing the required parameter `refund_id` when calling `succeed`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'refund_id' in params: query_params.append(('refundId', params['refund_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/refund/succeed', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Refund', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class ShopifySubscriptionServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method count" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `count`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create(self, space_id, creation_request, **kwargs): """Create This operation allows to create a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create(space_id, creation_request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionCreationRequest creation_request: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_with_http_info(space_id, creation_request, **kwargs) else: (data) = self.create_with_http_info(space_id, creation_request, **kwargs) return data def create_with_http_info(self, space_id, creation_request, **kwargs): """Create This operation allows to create a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_with_http_info(space_id, creation_request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionCreationRequest creation_request: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'creation_request'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method create" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `create`") # verify the required parameter 'creation_request' is set if ('creation_request' not in params or params['creation_request'] is None): raise ValueError("Missing the required parameter `creation_request` when calling `create`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'creation_request' in params: body_params = params['creation_request'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/create', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShopifySubscriptionVersion', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the Shopify subscription which should be returned. (required) :return: ShopifySubscription If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the Shopify subscription which should be returned. (required) :return: ShopifySubscription If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method read" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `read`") # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShopifySubscription', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the Shopify subscriptions which are returned by the search. (required) :return: list[ShopifySubscription] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the Shopify subscriptions which are returned by the search. (required) :return: list[ShopifySubscription] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method search" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `search`") # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError("Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[ShopifySubscription]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def terminate(self, space_id, subscription_id, respect_termination_period, **kwargs): """Terminate This operation allows to terminate a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.terminate(space_id, subscription_id, respect_termination_period, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int subscription_id: The ID identifies the Shopify subscription which should be terminated. (required) :param bool respect_termination_period: The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.terminate_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs) else: (data) = self.terminate_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs) return data def terminate_with_http_info(self, space_id, subscription_id, respect_termination_period, **kwargs): """Terminate This operation allows to terminate a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.terminate_with_http_info(space_id, subscription_id, respect_termination_period, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int subscription_id: The ID identifies the Shopify subscription which should be terminated. (required) :param bool respect_termination_period: The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'subscription_id', 'respect_termination_period'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method terminate" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `terminate`") # verify the required parameter 'subscription_id' is set if ('subscription_id' not in params or params['subscription_id'] is None): raise ValueError("Missing the required parameter `subscription_id` when calling `terminate`") # verify the required parameter 'respect_termination_period' is set if ('respect_termination_period' not in params or params['respect_termination_period'] is None): raise ValueError("Missing the required parameter `respect_termination_period` when calling `terminate`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'subscription_id' in params: query_params.append(('subscriptionId', params['subscription_id'])) if 'respect_termination_period' in params: query_params.append(('respectTerminationPeriod', params['respect_termination_period'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/terminate', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update(self, space_id, subscription, **kwargs): """Update This operation allows to update a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update(space_id, subscription, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionUpdateRequest subscription: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_with_http_info(space_id, subscription, **kwargs) else: (data) = self.update_with_http_info(space_id, subscription, **kwargs) return data def update_with_http_info(self, space_id, subscription, **kwargs): """Update This operation allows to update a Shopify subscription. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_with_http_info(space_id, subscription, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionUpdateRequest subscription: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'subscription'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method update" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `update`") # verify the required parameter 'subscription' is set if ('subscription' not in params or params['subscription'] is None): raise ValueError("Missing the required parameter `subscription` when calling `update`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'subscription' in params: body_params = params['subscription'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/update', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShopifySubscriptionVersion', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update_addresses(self, space_id, update_request, **kwargs): """Update Addresses This operation allows to update a Shopify subscription addresses. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_addresses(space_id, update_request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionUpdateAddressesRequest update_request: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_addresses_with_http_info(space_id, update_request, **kwargs) else: (data) = self.update_addresses_with_http_info(space_id, update_request, **kwargs) return data def update_addresses_with_http_info(self, space_id, update_request, **kwargs): """Update Addresses This operation allows to update a Shopify subscription addresses. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_addresses_with_http_info(space_id, update_request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param ShopifySubscriptionUpdateAddressesRequest update_request: (required) :return: ShopifySubscriptionVersion If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'update_request'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method update_addresses" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError("Missing the required parameter `space_id` when calling `update_addresses`") # verify the required parameter 'update_request' is set if ('update_request' not in params or params['update_request'] is None): raise ValueError("Missing the required parameter `update_request` when calling `update_addresses`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'update_request' in params: body_params = params['update_request'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/shopify-subscription/update-addresses', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShopifySubscriptionVersion', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class TransactionInvoiceServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method count" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `count`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_invoice_document(self, space_id, id, **kwargs): """getInvoiceDocument Returns the PDF document for the transaction invoice with given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_invoice_document(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice to get the document for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_invoice_document_with_http_info( space_id, id, **kwargs) else: (data) = self.get_invoice_document_with_http_info( space_id, id, **kwargs) return data def get_invoice_document_with_http_info(self, space_id, id, **kwargs): """getInvoiceDocument Returns the PDF document for the transaction invoice with given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_invoice_document_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice to get the document for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method get_invoice_document" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `get_invoice_document`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `get_invoice_document`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/getInvoiceDocument', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='RenderedDocument', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_invoice_document_with_target_media_type(self, space_id, id, target_media_type_id, **kwargs): """getInvoiceDocumentWithTargetMediaType Returns the PDF document for the transaction invoice with given id and target media type id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_invoice_document_with_target_media_type(space_id, id, target_media_type_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice to get the document for. (required) :param int target_media_type_id: The id of the target media type for which the invoice should be generated for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_invoice_document_with_target_media_type_with_http_info( space_id, id, target_media_type_id, **kwargs) else: ( data ) = self.get_invoice_document_with_target_media_type_with_http_info( space_id, id, target_media_type_id, **kwargs) return data def get_invoice_document_with_target_media_type_with_http_info( self, space_id, id, target_media_type_id, **kwargs): """getInvoiceDocumentWithTargetMediaType Returns the PDF document for the transaction invoice with given id and target media type id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_invoice_document_with_target_media_type_with_http_info(space_id, id, target_media_type_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice to get the document for. (required) :param int target_media_type_id: The id of the target media type for which the invoice should be generated for. (required) :return: RenderedDocument If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id', 'target_media_type_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_invoice_document_with_target_media_type" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `get_invoice_document_with_target_media_type`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `get_invoice_document_with_target_media_type`" ) # verify the required parameter 'target_media_type_id' is set if ('target_media_type_id' not in params or params['target_media_type_id'] is None): raise ValueError( "Missing the required parameter `target_media_type_id` when calling `get_invoice_document_with_target_media_type`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) if 'target_media_type_id' in params: query_params.append( ('targetMediaTypeId', params['target_media_type_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/getInvoiceDocumentWithTargetMediaType', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='RenderedDocument', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def is_replacement_possible(self, space_id, id, **kwargs): """isReplacementPossible Returns whether the transaction invoice with the given id can be replaced. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.is_replacement_possible(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The invoice which should be checked if a replacement is possible. (required) :return: bool If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.is_replacement_possible_with_http_info( space_id, id, **kwargs) else: (data) = self.is_replacement_possible_with_http_info( space_id, id, **kwargs) return data def is_replacement_possible_with_http_info(self, space_id, id, **kwargs): """isReplacementPossible Returns whether the transaction invoice with the given id can be replaced. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.is_replacement_possible_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The invoice which should be checked if a replacement is possible. (required) :return: bool If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method is_replacement_possible" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `is_replacement_possible`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `is_replacement_possible`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/isReplacementPossible', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='bool', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def mark_as_derecognized(self, space_id, id, **kwargs): """Mark as Derecognized Marks the transaction invoice with the given id as derecognized. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_as_derecognized(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice which should be marked as derecognized. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.mark_as_derecognized_with_http_info( space_id, id, **kwargs) else: (data) = self.mark_as_derecognized_with_http_info( space_id, id, **kwargs) return data def mark_as_derecognized_with_http_info(self, space_id, id, **kwargs): """Mark as Derecognized Marks the transaction invoice with the given id as derecognized. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_as_derecognized_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice which should be marked as derecognized. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method mark_as_derecognized" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `mark_as_derecognized`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `mark_as_derecognized`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/markAsDerecognized', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionInvoice', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def mark_as_paid(self, space_id, id, **kwargs): """Mark as Paid Marks the transaction invoice with the given id as paid. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_as_paid(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice which should be marked as paid. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.mark_as_paid_with_http_info(space_id, id, **kwargs) else: (data) = self.mark_as_paid_with_http_info(space_id, id, **kwargs) return data def mark_as_paid_with_http_info(self, space_id, id, **kwargs): """Mark as Paid Marks the transaction invoice with the given id as paid. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_as_paid_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoice which should be marked as paid. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method mark_as_paid" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `mark_as_paid`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `mark_as_paid`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/markAsPaid', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionInvoice', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoices which should be returned. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoices which should be returned. (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method read" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `read`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionInvoice', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def replace(self, space_id, id, replacement, **kwargs): """replace Replaces the transaction invoice with given id with the replacement and returns the new transaction invoice. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace(space_id, id, replacement, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoices which should be replaced. (required) :param TransactionInvoiceReplacement replacement: (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.replace_with_http_info(space_id, id, replacement, **kwargs) else: (data) = self.replace_with_http_info(space_id, id, replacement, **kwargs) return data def replace_with_http_info(self, space_id, id, replacement, **kwargs): """replace Replaces the transaction invoice with given id with the replacement and returns the new transaction invoice. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace_with_http_info(space_id, id, replacement, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the transaction invoices which should be replaced. (required) :param TransactionInvoiceReplacement replacement: (required) :return: TransactionInvoice If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id', 'replacement'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method replace" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `replace`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `replace`") # verify the required parameter 'replacement' is set if ('replacement' not in params or params['replacement'] is None): raise ValueError( "Missing the required parameter `replacement` when calling `replace`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'replacement' in params: body_params = params['replacement'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/replace', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TransactionInvoice', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the transaction invoices which are returned by the search. (required) :return: list[TransactionInvoice] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the transaction invoices which are returned by the search. (required) :return: list[TransactionInvoice] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method search" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `search`" ) # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError( "Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-invoice/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[TransactionInvoice]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class CountryStateServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def all(self, **kwargs): """All This operation returns all states of all countries. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all(async_req=True) >>> result = thread.get() :param async_req bool :return: list[RestCountryState] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.all_with_http_info(**kwargs) else: (data) = self.all_with_http_info(**kwargs) return data def all_with_http_info(self, **kwargs): """All This operation returns all states of all countries. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.all_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool :return: list[RestCountryState] If the method is called asynchronously, returns the request thread. """ all_params = [] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method all" % key) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/country-state/all', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[RestCountryState]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def country(self, code, **kwargs): """Find by Country This operation returns all states for a given country. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.country(code, async_req=True) >>> result = thread.get() :param async_req bool :param str code: The country code in ISO code two letter format for which all states should be returned. (required) :return: list[RestCountryState] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.country_with_http_info(code, **kwargs) else: (data) = self.country_with_http_info(code, **kwargs) return data def country_with_http_info(self, code, **kwargs): """Find by Country This operation returns all states for a given country. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.country_with_http_info(code, async_req=True) >>> result = thread.get() :param async_req bool :param str code: The country code in ISO code two letter format for which all states should be returned. (required) :return: list[RestCountryState] If the method is called asynchronously, returns the request thread. """ all_params = ['code'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method country" % key) params[key] = val del params['kwargs'] # verify the required parameter 'code' is set if ('code' not in params or params['code'] is None): raise ValueError( "Missing the required parameter `code` when calling `country`") collection_formats = {} path_params = {} query_params = [] if 'code' in params: query_params.append(('code', params['code'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/country-state/country', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[RestCountryState]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class TokenServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def check_token_creation_possible(self, space_id, transaction_id, **kwargs): """Check If Token Creation Is Possible This operation checks if the given transaction can be used to create a token out of it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.check_token_creation_possible(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to check if the token can be created or not. (required) :return: bool If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.check_token_creation_possible_with_http_info( space_id, transaction_id, **kwargs) else: (data) = self.check_token_creation_possible_with_http_info( space_id, transaction_id, **kwargs) return data def check_token_creation_possible_with_http_info(self, space_id, transaction_id, **kwargs): """Check If Token Creation Is Possible This operation checks if the given transaction can be used to create a token out of it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.check_token_creation_possible_with_http_info(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to check if the token can be created or not. (required) :return: bool If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method check_token_creation_possible" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `check_token_creation_possible`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `check_token_creation_possible`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/check-token-creation-possible', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='bool', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def count(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.count_with_http_info(space_id, **kwargs) else: (data) = self.count_with_http_info(space_id, **kwargs) return data def count_with_http_info(self, space_id, **kwargs): """Count Counts the number of items in the database as restricted by the given filter. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_with_http_info(space_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count. :return: int If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'filter'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method count" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `count`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'filter' in params: body_params = params['filter'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/count', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='int', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create(self, space_id, entity, **kwargs): """Create Creates the entity with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TokenCreate entity: The token object with the properties which should be created. (required) :return: Token If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_with_http_info(space_id, entity, **kwargs) else: (data) = self.create_with_http_info(space_id, entity, **kwargs) return data def create_with_http_info(self, space_id, entity, **kwargs): """Create Creates the entity with the given properties. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_with_http_info(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TokenCreate entity: The token object with the properties which should be created. (required) :return: Token If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method create" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `create`" ) # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError( "Missing the required parameter `entity` when calling `create`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/create', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Token', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create_token_based_on_transaction(self, space_id, transaction_id, **kwargs): """Create Token Based On Transaction This operation creates a token for the given transaction and fills it with the stored payment information of the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_token_based_on_transaction(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to create the token. (required) :return: TokenVersion If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_token_based_on_transaction_with_http_info( space_id, transaction_id, **kwargs) else: (data) = self.create_token_based_on_transaction_with_http_info( space_id, transaction_id, **kwargs) return data def create_token_based_on_transaction_with_http_info( self, space_id, transaction_id, **kwargs): """Create Token Based On Transaction This operation creates a token for the given transaction and fills it with the stored payment information of the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_token_based_on_transaction_with_http_info(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to create the token. (required) :return: TokenVersion If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method create_token_based_on_transaction" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `create_token_based_on_transaction`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `create_token_based_on_transaction`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/create-token-based-on-transaction', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='TokenVersion', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def create_transaction_for_token_update(self, space_id, token_id, **kwargs): """Create Transaction for Token Update This operation creates a transaction which allows the updating of the provided token. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_transaction_for_token_update(space_id, token_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int token_id: The id of the token which should be updated. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.create_transaction_for_token_update_with_http_info( space_id, token_id, **kwargs) else: (data) = self.create_transaction_for_token_update_with_http_info( space_id, token_id, **kwargs) return data def create_transaction_for_token_update_with_http_info( self, space_id, token_id, **kwargs): """Create Transaction for Token Update This operation creates a transaction which allows the updating of the provided token. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_transaction_for_token_update_with_http_info(space_id, token_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int token_id: The id of the token which should be updated. (required) :return: Transaction If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'token_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method create_transaction_for_token_update" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `create_transaction_for_token_update`" ) # verify the required parameter 'token_id' is set if ('token_id' not in params or params['token_id'] is None): raise ValueError( "Missing the required parameter `token_id` when calling `create_transaction_for_token_update`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'token_id' in params: query_params.append(('tokenId', params['token_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/createTransactionForTokenUpdate', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Transaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def delete(self, space_id, id, **kwargs): """Delete Deletes the entity with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.delete_with_http_info(space_id, id, **kwargs) else: (data) = self.delete_with_http_info(space_id, id, **kwargs) return data def delete_with_http_info(self, space_id, id, **kwargs): """Delete Deletes the entity with the given id. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method delete" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `delete`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `delete`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'id' in params: body_params = params['id'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/delete', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def process_transaction(self, space_id, transaction_id, **kwargs): """Process Transaction This operation processes the given transaction by using the token associated with the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.process_transaction(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to check if the token can be created or not. (required) :return: Charge If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.process_transaction_with_http_info( space_id, transaction_id, **kwargs) else: (data) = self.process_transaction_with_http_info( space_id, transaction_id, **kwargs) return data def process_transaction_with_http_info(self, space_id, transaction_id, **kwargs): """Process Transaction This operation processes the given transaction by using the token associated with the transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.process_transaction_with_http_info(space_id, transaction_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The id of the transaction for which we want to check if the token can be created or not. (required) :return: Charge If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method process_transaction" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `process_transaction`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `process_transaction`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/process-transaction', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Charge', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def read(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the token which should be returned. (required) :return: Token If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.read_with_http_info(space_id, id, **kwargs) else: (data) = self.read_with_http_info(space_id, id, **kwargs) return data def read_with_http_info(self, space_id, id, **kwargs): """Read Reads the entity with the given 'id' and returns it. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.read_with_http_info(space_id, id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int id: The id of the token which should be returned. (required) :return: Token If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'id'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method read" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `read`" ) # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError( "Missing the required parameter `id` when calling `read`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'id' in params: query_params.append(('id', params['id'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['*/*']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/read', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Token', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def search(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the tokens which are returned by the search. (required) :return: list[Token] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.search_with_http_info(space_id, query, **kwargs) else: (data) = self.search_with_http_info(space_id, query, **kwargs) return data def search_with_http_info(self, space_id, query, **kwargs): """Search Searches for the entities as specified by the given query. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.search_with_http_info(space_id, query, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param EntityQuery query: The query restricts the tokens which are returned by the search. (required) :return: list[Token] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'query'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method search" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `search`" ) # verify the required parameter 'query' is set if ('query' not in params or params['query'] is None): raise ValueError( "Missing the required parameter `query` when calling `search`") collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'query' in params: body_params = params['query'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/search', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[Token]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def update(self, space_id, entity, **kwargs): """Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TokenUpdate entity: The object with all the properties which should be updated. The id and the version are required properties. (required) :return: Token If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.update_with_http_info(space_id, entity, **kwargs) else: (data) = self.update_with_http_info(space_id, entity, **kwargs) return data def update_with_http_info(self, space_id, entity, **kwargs): """Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_with_http_info(space_id, entity, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TokenUpdate entity: The object with all the properties which should be updated. The id and the version are required properties. (required) :return: Token If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'entity'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method update" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `update`" ) # verify the required parameter 'entity' is set if ('entity' not in params or params['entity'] is None): raise ValueError( "Missing the required parameter `entity` when calling `update`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'entity' in params: body_params = params['entity'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/token/update', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Token', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class TransactionTerminalServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def fetch_receipts(self, space_id, request, **kwargs): """Fetch Receipts Returns all receipts for the requested terminal transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fetch_receipts(space_id, request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TerminalReceiptFetchRequest request: (required) :return: list[RenderedTerminalReceipt] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.fetch_receipts_with_http_info(space_id, request, **kwargs) else: (data) = self.fetch_receipts_with_http_info( space_id, request, **kwargs) return data def fetch_receipts_with_http_info(self, space_id, request, **kwargs): """Fetch Receipts Returns all receipts for the requested terminal transaction. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.fetch_receipts_with_http_info(space_id, request, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param TerminalReceiptFetchRequest request: (required) :return: list[RenderedTerminalReceipt] If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'request'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method fetch_receipts" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `fetch_receipts`" ) # verify the required parameter 'request' is set if ('request' not in params or params['request'] is None): raise ValueError( "Missing the required parameter `request` when calling `fetch_receipts`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) header_params = {} form_params = [] local_var_files = {} body_params = None if 'request' in params: body_params = params['request'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-terminal/fetch-receipts', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[RenderedTerminalReceipt]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def till_connection_credentials(self, space_id, transaction_id, terminal_id, **kwargs): """Create Till Connection Credentials This operation creates a set of credentials to use within the WebSocket. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.till_connection_credentials(space_id, transaction_id, terminal_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param int terminal_id: The ID of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: str If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.till_connection_credentials_with_http_info( space_id, transaction_id, terminal_id, **kwargs) else: (data) = self.till_connection_credentials_with_http_info( space_id, transaction_id, terminal_id, **kwargs) return data def till_connection_credentials_with_http_info(self, space_id, transaction_id, terminal_id, **kwargs): """Create Till Connection Credentials This operation creates a set of credentials to use within the WebSocket. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.till_connection_credentials_with_http_info(space_id, transaction_id, terminal_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param int terminal_id: The ID of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: str If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id', 'terminal_id', 'language'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method till_connection_credentials" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `till_connection_credentials`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `till_connection_credentials`" ) # verify the required parameter 'terminal_id' is set if ('terminal_id' not in params or params['terminal_id'] is None): raise ValueError( "Missing the required parameter `terminal_id` when calling `till_connection_credentials`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) if 'terminal_id' in params: query_params.append(('terminalId', params['terminal_id'])) if 'language' in params: query_params.append(('language', params['language'])) header_params = {} form_params = [] local_var_files = {} body_params = None # Authentication setting auth_settings = [] return self.api_client.call_api( '/transaction-terminal/till-connection-credentials', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='str', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
class PaymentTerminalTillServiceApi: def __init__(self, configuration): self.api_client = ApiClient(configuration=configuration) def perform_transaction(self, space_id, transaction_id, terminal_id, **kwargs): """Perform Payment Terminal Transaction Starts a payment terminal transaction and waits for its completion. If the call returns with a long polling timeout status, you may try again. The processing of the transaction will be picked up where it was left off. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.perform_transaction(space_id, transaction_id, terminal_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param int terminal_id: The ID of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: Transaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True kwargs['_request_timeout'] = 90 if kwargs.get('async_req'): return self.perform_transaction_with_http_info( space_id, transaction_id, terminal_id, **kwargs) else: (data) = self.perform_transaction_with_http_info( space_id, transaction_id, terminal_id, **kwargs) return data def perform_transaction_with_http_info(self, space_id, transaction_id, terminal_id, **kwargs): """Perform Payment Terminal Transaction Starts a payment terminal transaction and waits for its completion. If the call returns with a long polling timeout status, you may try again. The processing of the transaction will be picked up where it was left off. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.perform_transaction_with_http_info(space_id, transaction_id, terminal_id, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param int terminal_id: The ID of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: Transaction If the method is called asynchronously, returns the request thread. """ all_params = ['space_id', 'transaction_id', 'terminal_id', 'language'] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError("Got an unexpected keyword argument '%s'" " to method perform_transaction" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `perform_transaction`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `perform_transaction`" ) # verify the required parameter 'terminal_id' is set if ('terminal_id' not in params or params['terminal_id'] is None): raise ValueError( "Missing the required parameter `terminal_id` when calling `perform_transaction`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) if 'terminal_id' in params: query_params.append(('terminalId', params['terminal_id'])) if 'language' in params: query_params.append(('language', params['language'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/payment-terminal-till/perform-transaction', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Transaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def perform_transaction_by_identifier(self, space_id, transaction_id, terminal_identifier, **kwargs): """Perform Payment Terminal Transaction (using TID) Starts a payment terminal transaction and waits for its completion. If the call returns with a long polling timeout status, you may try again. The processing of the transaction will be picked up where it was left off. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.perform_transaction_by_identifier(space_id, transaction_id, terminal_identifier, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param str terminal_identifier: The identifier (aka TID) of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: Transaction If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True kwargs['_request_timeout'] = 90 if kwargs.get('async_req'): return self.perform_transaction_by_identifier_with_http_info( space_id, transaction_id, terminal_identifier, **kwargs) else: (data) = self.perform_transaction_by_identifier_with_http_info( space_id, transaction_id, terminal_identifier, **kwargs) return data def perform_transaction_by_identifier_with_http_info( self, space_id, transaction_id, terminal_identifier, **kwargs): """Perform Payment Terminal Transaction (using TID) Starts a payment terminal transaction and waits for its completion. If the call returns with a long polling timeout status, you may try again. The processing of the transaction will be picked up where it was left off. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.perform_transaction_by_identifier_with_http_info(space_id, transaction_id, terminal_identifier, async_req=True) >>> result = thread.get() :param async_req bool :param int space_id: (required) :param int transaction_id: The ID of the transaction which is used to process with the terminal. (required) :param str terminal_identifier: The identifier (aka TID) of the terminal which should be used to process the transaction. (required) :param str language: The language in which the messages should be rendered in. :return: Transaction If the method is called asynchronously, returns the request thread. """ all_params = [ 'space_id', 'transaction_id', 'terminal_identifier', 'language' ] all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method perform_transaction_by_identifier" % key) params[key] = val del params['kwargs'] # verify the required parameter 'space_id' is set if ('space_id' not in params or params['space_id'] is None): raise ValueError( "Missing the required parameter `space_id` when calling `perform_transaction_by_identifier`" ) # verify the required parameter 'transaction_id' is set if ('transaction_id' not in params or params['transaction_id'] is None): raise ValueError( "Missing the required parameter `transaction_id` when calling `perform_transaction_by_identifier`" ) # verify the required parameter 'terminal_identifier' is set if ('terminal_identifier' not in params or params['terminal_identifier'] is None): raise ValueError( "Missing the required parameter `terminal_identifier` when calling `perform_transaction_by_identifier`" ) collection_formats = {} path_params = {} query_params = [] if 'space_id' in params: query_params.append(('spaceId', params['space_id'])) if 'transaction_id' in params: query_params.append(('transactionId', params['transaction_id'])) if 'terminal_identifier' in params: query_params.append( ('terminalIdentifier', params['terminal_identifier'])) if 'language' in params: query_params.append(('language', params['language'])) header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json;charset=utf-8']) # HTTP header `Content-Type` header_params[ 'Content-Type'] = self.api_client.select_header_content_type( ['application/json;charset=utf-8']) # Authentication setting auth_settings = [] return self.api_client.call_api( '/payment-terminal-till/perform-transaction-by-identifier', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Transaction', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)