def roles_list_with_http_info(self, **kwargs): # noqa: E501
"""roles_list # noqa: E501
Read-only API endpoint for viewing roles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.roles_list_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int limit: Number of results to return per page.
:param int offset: The initial index from which to return the results.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InlineResponse2008, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['limit', 'offset']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method roles_list" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'limit' in local_var_params and local_var_params[
'limit'] is not None: # noqa: E501
query_params.append(
('limit', local_var_params['limit'])) # noqa: E501
if 'offset' in local_var_params and local_var_params[
'offset'] is not None: # noqa: E501
query_params.append(
('offset', local_var_params['offset'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['Bearer'] # noqa: E501
return self.api_client.call_api(
'/roles/',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InlineResponse2008', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def api_web_route_controller_index_with_http_info(self, **kwargs): # noqa: E501
"""api_web_route_controller_index # noqa: E501
List of routes. ## Names and Descriptions There are 3 attributes with increasing details for naming and describing the route. 1. `/data/{index}/attributes/short_name` 2. `/data/{index}/attributes/long_name` 3. `/data/{index}/attributes/description` ## Directions `/data/{index}/attributes/direction_names` is the only place to convert the `direction_id` used throughout the rest of the API to human-readable names. ## Type `/data/{index}/attributes/type` corresponds to [GTFS `routes.txt` `route_type`](https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#routestxt). | Value | Name | Example | |-------|---------------|------------| | `0` | Light Rail | Green Line | | `1` | Heavy Rail | Red Line | | `2` | Commuter Rail | | | `3` | Bus | | | `4` | Ferry | | # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_web_route_controller_index_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int page_offset: Offset (0-based) of first element in the page
:param int page_limit: Max number of elements to return
:param str sort: Results can be [sorted](http://jsonapi.org/format/#fetching-sorting) by the id or any `/data/{index}/attributes` key. Assumes ascending; may be prefixed with '-' for descending | JSON pointer | Direction | `sort` | |--------------|-----------|------------| | `/data/{index}/attributes/color` | ascending | `color` | | `/data/{index}/attributes/color` | descending | `-color` | | `/data/{index}/attributes/description` | ascending | `description` | | `/data/{index}/attributes/description` | descending | `-description` | | `/data/{index}/attributes/direction_destinations` | ascending | `direction_destinations` | | `/data/{index}/attributes/direction_destinations` | descending | `-direction_destinations` | | `/data/{index}/attributes/direction_names` | ascending | `direction_names` | | `/data/{index}/attributes/direction_names` | descending | `-direction_names` | | `/data/{index}/attributes/fare_class` | ascending | `fare_class` | | `/data/{index}/attributes/fare_class` | descending | `-fare_class` | | `/data/{index}/attributes/long_name` | ascending | `long_name` | | `/data/{index}/attributes/long_name` | descending | `-long_name` | | `/data/{index}/attributes/short_name` | ascending | `short_name` | | `/data/{index}/attributes/short_name` | descending | `-short_name` | | `/data/{index}/attributes/sort_order` | ascending | `sort_order` | | `/data/{index}/attributes/sort_order` | descending | `-sort_order` | | `/data/{index}/attributes/text_color` | ascending | `text_color` | | `/data/{index}/attributes/text_color` | descending | `-text_color` | | `/data/{index}/attributes/type` | ascending | `type` | | `/data/{index}/attributes/type` | descending | `-type` |
:param str fields_route: Fields to include with the response. Multiple fields **MUST** be a comma-separated (U+002C COMMA, \",\") list. Note that fields can also be selected for included data types: see the [V3 API Best Practices](https://www.mbta.com/developers/v3-api/best-practices) for an example.
:param str include: Relationships to include. * `stop` * `line` * `route_patterns` The value of the include parameter **MUST** be a comma-separated (U+002C COMMA, \",\") list of relationship paths. A relationship path is a dot-separated (U+002E FULL-STOP, \".\") list of relationship names. [JSONAPI \"include\" behavior](http://jsonapi.org/format/#fetching-includes) include=stop only works when `filter[stop]` is also used
:param str filter_stop: Filter by `/data/{index}/relationships/stop/data/id`. Must filter by stop in order to include stop with response
:param str filter_type: | Value | Name | Example | |-------|---------------|------------| | `0` | Light Rail | Green Line | | `1` | Heavy Rail | Red Line | | `2` | Commuter Rail | | | `3` | Bus | | | `4` | Ferry | | Multiple `route_type` **MUST** be a comma-separated (U+002C COMMA, \",\") list.
:param str filter_direction_id: Filter by direction of travel along the route. The meaning of `direction_id` varies based on the route. You can programmatically get the direction names from `/routes` `/data/{index}/attributes/direction_names` or `/routes/{id}` `/data/attributes/direction_names`. When combined with stop_id, filters by routes which stop at that stop when traveling in a particular direction
:param date filter_date: Filter by date that route is active The active date is the service date. Trips that begin between midnight and 3am are considered part of the previous service day. The format is ISO8601 with the template of YYYY-MM-DD.
:param str filter_id: Filter by multiple IDs. Multiple IDs **MUST** be a comma-separated (U+002C COMMA, \",\") list.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Routes, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['page_offset', 'page_limit', 'sort', 'fields_route', 'include', 'filter_stop', 'filter_type', 'filter_direction_id', 'filter_date', 'filter_id'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method api_web_route_controller_index" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'page_offset' in local_var_params and local_var_params['page_offset'] < 0: # noqa: E501
raise ApiValueError("Invalid value for parameter `page_offset` when calling `api_web_route_controller_index`, must be a value greater than or equal to `0`") # noqa: E501
if self.api_client.client_side_validation and 'page_limit' in local_var_params and local_var_params['page_limit'] < 1: # noqa: E501
raise ApiValueError("Invalid value for parameter `page_limit` when calling `api_web_route_controller_index`, must be a value greater than or equal to `1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'page_offset' in local_var_params and local_var_params['page_offset'] is not None: # noqa: E501
query_params.append(('page[offset]', local_var_params['page_offset'])) # noqa: E501
if 'page_limit' in local_var_params and local_var_params['page_limit'] is not None: # noqa: E501
query_params.append(('page[limit]', local_var_params['page_limit'])) # noqa: E501
if 'sort' in local_var_params and local_var_params['sort'] is not None: # noqa: E501
query_params.append(('sort', local_var_params['sort'])) # noqa: E501
if 'fields_route' in local_var_params and local_var_params['fields_route'] is not None: # noqa: E501
query_params.append(('fields[route]', local_var_params['fields_route'])) # noqa: E501
if 'include' in local_var_params and local_var_params['include'] is not None: # noqa: E501
query_params.append(('include', local_var_params['include'])) # noqa: E501
if 'filter_stop' in local_var_params and local_var_params['filter_stop'] is not None: # noqa: E501
query_params.append(('filter[stop]', local_var_params['filter_stop'])) # noqa: E501
if 'filter_type' in local_var_params and local_var_params['filter_type'] is not None: # noqa: E501
query_params.append(('filter[type]', local_var_params['filter_type'])) # noqa: E501
if 'filter_direction_id' in local_var_params and local_var_params['filter_direction_id'] is not None: # noqa: E501
query_params.append(('filter[direction_id]', local_var_params['filter_direction_id'])) # noqa: E501
if 'filter_date' in local_var_params and local_var_params['filter_date'] is not None: # noqa: E501
query_params.append(('filter[date]', local_var_params['filter_date'])) # noqa: E501
if 'filter_id' in local_var_params and local_var_params['filter_id'] is not None: # noqa: E501
query_params.append(('filter[id]', local_var_params['filter_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/vnd.api+json']) # noqa: E501
# Authentication setting
auth_settings = ['api_key_in_header', 'api_key_in_query'] # noqa: E501
return self.api_client.call_api(
'/routes', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Routes', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_status_with_http_info(self, **kwargs): # noqa: E501
"""Get the account status and QR code for authorization. # noqa: E501
Reauthorization is necessary only in case of changing the device or manually pressing \"Logout on all devices\" on the phone. Keep the WhastsApp application open during authorization. Instance statuses: **authenticated** - Authorization passed successfully **init** - Initial status **loading** - The system is still loading, try again in 1 minute **got qr code** - There is a QR code and you need to take a picture of it in the Whatsapp application by going to Menu -> WhatsApp Web -> Add. QR code is valid for one minute. [Example showing base64 images on a page.](https://stackoverflow.com/questions/31526085/how-to-encode-an-image-into-an-html-file) Manually easier to get [QR-code as an image](/#getQRCode) When you request the status of the instance in standby mode (status **\"init\"**), it will automatically turn on. To avoid this behavior, use the **no_wakeup** parameter # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_status_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param bool full: Get full information on the current status
:param bool no_wakeup: Ignore autowakeup
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InstanceStatus, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['full', 'no_wakeup'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_status" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'full' in local_var_params:
query_params.append(('full', local_var_params['full'])) # noqa: E501
if 'no_wakeup' in local_var_params:
query_params.append(('no_wakeup', local_var_params['no_wakeup'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['instanceId', 'token'] # noqa: E501
return self.api_client.call_api(
'/status', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InstanceStatus', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def time_trackings_get_with_http_info(self, **kwargs): # noqa: E501
"""Fetch time trackings list # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.time_trackings_get_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int limit: Limited the result. Default is 100. Maximum can be 1000.
:param int page: Set current Page. Default is 1.
:param str login_id: Filter time-tracking by login_id. You can add multiple ids separate by comma like id,id,id.
:param str project_id: Filter time-tracking by project_id. You can add multiple ids separate by comma like id,id,id.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TimeTrackings, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['limit', 'page', 'login_id', 'project_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method time_trackings_get" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params[
'limit'] > 1000: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `limit` when calling `time_trackings_get`, must be a value less than or equal to `1000`"
) # noqa: E501
if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params[
'limit'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `limit` when calling `time_trackings_get`, must be a value greater than or equal to `1`"
) # noqa: E501
if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params[
'page'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `page` when calling `time_trackings_get`, must be a value greater than or equal to `1`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'limit' in local_var_params and local_var_params[
'limit'] is not None: # noqa: E501
query_params.append(
('limit', local_var_params['limit'])) # noqa: E501
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'login_id' in local_var_params and local_var_params[
'login_id'] is not None: # noqa: E501
query_params.append(
('login_id', local_var_params['login_id'])) # noqa: E501
if 'project_id' in local_var_params and local_var_params[
'project_id'] is not None: # noqa: E501
query_params.append(
('project_id', local_var_params['project_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['Bearer', 'basicAuth'] # noqa: E501
return self.api_client.call_api(
'/time-trackings',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TimeTrackings', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def positions_with_http_info(self, consumerKey, sessionToken, **kwargs): # noqa: E501
"""Get's raw position from Trading Engine. # noqa: E501
Snapshot of Position data for a client available in System. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.positions_with_http_info(consumerKey, sessionToken, async_req=True)
>>> result = thread.get()
:param consumerKey: (required)
:type consumerKey: str
:param sessionToken: (required)
:type sessionToken: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(list[Positions], status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
all_params = [
'consumerKey',
'sessionToken'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method positions" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'consumerKey' is set
if self.api_client.client_side_validation and ('consumerKey' not in local_var_params or # noqa: E501
local_var_params['consumerKey'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `consumerKey` when calling `positions`") # noqa: E501
# verify the required parameter 'sessionToken' is set
if self.api_client.client_side_validation and ('sessionToken' not in local_var_params or # noqa: E501
local_var_params['sessionToken'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `sessionToken` when calling `positions`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
if 'consumerKey' in local_var_params:
header_params['consumerKey'] = local_var_params['consumerKey'] # noqa: E501
if 'sessionToken' in local_var_params:
header_params['sessionToken'] = local_var_params['sessionToken'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['bearerAuth'] # noqa: E501
return self.api_client.call_api(
'/positions/1.0/positions', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[Positions]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats,
_request_auth=local_var_params.get('_request_auth'))
def get_trigger_events_with_http_info(self, trigger_id,
**kwargs): # noqa: E501
"""Gets all trigger events for current page and their count # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_trigger_events_with_http_info(trigger_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str trigger_id: The ID of updated trigger (required)
:param int page: Defines the number of the displayed page. E.g, page=2 would display the 2nd page.
:param int size: Number of items to be displayed on one page.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InlineResponse2002, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['trigger_id', 'page', 'size']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_trigger_events" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'trigger_id' is set
if self.api_client.client_side_validation and (
'trigger_id' not in local_var_params or # noqa: E501
local_var_params['trigger_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `trigger_id` when calling `get_trigger_events`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'trigger_id' in local_var_params:
path_params['triggerID'] = local_var_params[
'trigger_id'] # noqa: E501
query_params = []
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'size' in local_var_params and local_var_params[
'size'] is not None: # noqa: E501
query_params.append(
('size', local_var_params['size'])) # noqa: E501
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/html',
]) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/event/{triggerID}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InlineResponse2002', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def time_trackings_id_delete_with_http_info(self, id,
**kwargs): # noqa: E501
"""Delete time tracking # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.time_trackings_id_delete_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int id: ID of time tracking (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method time_trackings_id_delete" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if self.api_client.client_side_validation and (
'id' not in local_var_params or # noqa: E501
local_var_params['id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `id` when calling `time_trackings_id_delete`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['Bearer', 'basicAuth'] # noqa: E501
return self.api_client.call_api(
'/time-trackings/{id}',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def post_mem_usage_api_with_http_info(self, payload,
**kwargs): # noqa: E501
"""post_mem_usage_api # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_mem_usage_api_with_http_info(payload, async_req=True)
>>> result = thread.get()
:param payload: (required)
:type payload: MemThresholdModel
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
all_params = ['payload']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method post_mem_usage_api" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'payload' is set
if self.api_client.client_side_validation and (
'payload' not in local_var_params or # noqa: E501
local_var_params['payload'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `payload` when calling `post_mem_usage_api`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'payload' in local_var_params:
body_params = local_var_params['payload']
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
response_types_map = {}
return self.api_client.call_api(
'/api/memusage',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats,
_request_auth=local_var_params.get('_request_auth'))
def get_home_api_with_http_info(self, **kwargs): # noqa: E501
"""get_home_api # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_home_api_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
all_params = []
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout', '_request_auth'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_home_api" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
response_types_map = {}
return self.api_client.call_api(
'/api/help',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_types_map=response_types_map,
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats,
_request_auth=local_var_params.get('_request_auth'))
def delete_all_orders_with_http_info(self, **kwargs): # noqa: E501
"""Delete all open orders (of a symbol, if specified) # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_all_orders_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str symbol:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['symbol']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method delete_all_orders" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'symbol' in local_var_params and not re.search(
r'^[A-Z]{3,5}-[A-Z]{3,5}$',
local_var_params['symbol']): # noqa: E501
raise ApiValueError(
"Invalid value for parameter `symbol` when calling `delete_all_orders`, must conform to the pattern `/^[A-Z]{3,5}-[A-Z]{3,5}$/`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'symbol' in local_var_params and local_var_params[
'symbol'] is not None: # noqa: E501
query_params.append(
('symbol', local_var_params['symbol'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['ApiKeyAuth'] # noqa: E501
return self.api_client.call_api(
'/orders',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_orders_with_http_info(self, **kwargs): # noqa: E501
"""Get a list orders # noqa: E501
Returns live and historic orders, defaulting to live orders. Returns at most 100 results, use timestamp to paginate for further results # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_orders_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str symbol: Only return results for this symbol
:param int _from: Epoch timestamp in ms
:param int to: Epoch timestamp in ms
:param OrderStatus status: Order Status
:param int limit: Maximum amount of results to return in a single call. If omitted, 100 results are returned by default.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[OrderSummary], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['symbol', '_from', 'to', 'status', 'limit']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_orders" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'symbol' in local_var_params and not re.search(
r'^[A-Z]{3,5}-[A-Z]{3,5}$',
local_var_params['symbol']): # noqa: E501
raise ApiValueError(
"Invalid value for parameter `symbol` when calling `get_orders`, must conform to the pattern `/^[A-Z]{3,5}-[A-Z]{3,5}$/`"
) # noqa: E501
if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params[
'limit'] > 1000: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `limit` when calling `get_orders`, must be a value less than or equal to `1000`"
) # noqa: E501
if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params[
'limit'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `limit` when calling `get_orders`, must be a value greater than or equal to `1`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'symbol' in local_var_params and local_var_params[
'symbol'] is not None: # noqa: E501
query_params.append(
('symbol', local_var_params['symbol'])) # noqa: E501
if '_from' in local_var_params and local_var_params[
'_from'] is not None: # noqa: E501
query_params.append(
('from', local_var_params['_from'])) # noqa: E501
if 'to' in local_var_params and local_var_params[
'to'] is not None: # noqa: E501
query_params.append(('to', local_var_params['to'])) # noqa: E501
if 'status' in local_var_params and local_var_params[
'status'] is not None: # noqa: E501
query_params.append(
('status', local_var_params['status'])) # noqa: E501
if 'limit' in local_var_params and local_var_params[
'limit'] is not None: # noqa: E501
query_params.append(
('limit', local_var_params['limit'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['ApiKeyAuth'] # noqa: E501
return self.api_client.call_api(
'/orders',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[OrderSummary]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_metrics_with_http_info(self, metrics_name, **kwargs): # noqa: E501
"""get_metrics # noqa: E501
Retrieves the `sum` (count) for a given metric. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_metrics_with_http_info(metrics_name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str metrics_name: The name of the metric. (required)
:param datetime start_date: The start date (inclusive).
:param datetime end_date: The end date (exclusive).
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(MetricsResultDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'metrics_name',
'start_date',
'end_date'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_metrics" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'metrics_name' is set
if self.api_client.client_side_validation and ('metrics_name' not in local_var_params or # noqa: E501
local_var_params['metrics_name'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `metrics_name` when calling `get_metrics`") # noqa: E501
collection_formats = {}
path_params = {}
if 'metrics_name' in local_var_params:
path_params['metrics-name'] = local_var_params['metrics_name'] # noqa: E501
query_params = []
if 'start_date' in local_var_params and local_var_params['start_date'] is not None: # noqa: E501
query_params.append(('startDate', local_var_params['start_date'])) # noqa: E501
if 'end_date' in local_var_params and local_var_params['end_date'] is not None: # noqa: E501
query_params.append(('endDate', local_var_params['end_date'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/metrics/{metrics-name}/sum', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='MetricsResultDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def interval_with_http_info(self, **kwargs): # noqa: E501
"""interval # noqa: E501
Retrieves a list of metrics, aggregated for a given interval. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.interval_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: The name of the metric.
:param str reporter: The name of the reporter (host), on which the metrics was logged. This will have value provided by the [hostname configuration property](https://docs.camunda.org/manual/7.13/reference/deployment-descriptors/tags/process-engine/#hostname).
:param datetime start_date: The start date (inclusive).
:param datetime end_date: The end date (exclusive).
:param int first_result: Pagination of results. Specifies the index of the first result to return.
:param int max_results: Pagination of results. Specifies the maximum number of results to return. Will return less results if there are no more results left.
:param str interval: The interval for which the metrics should be aggregated. Time unit is seconds. Default: The interval is set to 15 minutes (900 seconds).
:param str aggregate_by_reporter: Aggregate metrics by reporter.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[MetricsIntervalResultDto], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'name',
'reporter',
'start_date',
'end_date',
'first_result',
'max_results',
'interval',
'aggregate_by_reporter'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method interval" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'name' in local_var_params and local_var_params['name'] is not None: # noqa: E501
query_params.append(('name', local_var_params['name'])) # noqa: E501
if 'reporter' in local_var_params and local_var_params['reporter'] is not None: # noqa: E501
query_params.append(('reporter', local_var_params['reporter'])) # noqa: E501
if 'start_date' in local_var_params and local_var_params['start_date'] is not None: # noqa: E501
query_params.append(('startDate', local_var_params['start_date'])) # noqa: E501
if 'end_date' in local_var_params and local_var_params['end_date'] is not None: # noqa: E501
query_params.append(('endDate', local_var_params['end_date'])) # noqa: E501
if 'first_result' in local_var_params and local_var_params['first_result'] is not None: # noqa: E501
query_params.append(('firstResult', local_var_params['first_result'])) # noqa: E501
if 'max_results' in local_var_params and local_var_params['max_results'] is not None: # noqa: E501
query_params.append(('maxResults', local_var_params['max_results'])) # noqa: E501
if 'interval' in local_var_params and local_var_params['interval'] is not None: # noqa: E501
query_params.append(('interval', local_var_params['interval'])) # noqa: E501
if 'aggregate_by_reporter' in local_var_params and local_var_params['aggregate_by_reporter'] is not None: # noqa: E501
query_params.append(('aggregateByReporter', local_var_params['aggregate_by_reporter'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/metrics', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[MetricsIntervalResultDto]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_sales_estimates_with_http_info(self, **kwargs): # noqa: E501
"""Returns all Sales Estimates # noqa: E501
Returns all Sales Estimates ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇫🇷, 🇮🇪, 🇬🇧, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇫🇷, 🇮🇪, 🇬🇧, 🇺🇸 ### Access Control Restrictions Requires the authenticated user to have any of the following roles in the area `Sales`: Full Access, Read Only, Restricted Access # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_sales_estimates_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str contact_id: Use this to filter by contact id
:param str search: Use this to filter by the estimate reference or contact name.
:param str status_id: Use this to filter by status id
:param datetime from_date: Use this to filter by Sales Estimates dates
:param datetime to_date: Use this to filter by Sales Estimates dates
:param datetime updated_or_created_since: Use this to limit the response to Sales Estimates changed since a given date (format: YYYY-MM-DDT(+|-)hh:mm) or date-time (format: YYYY-MM-DDThh:mm:ss(+|-)hh:mm). Inclusive of the passed timestamp.
:param bool has_attachments: Use this to filter Sales Estimates by whether they have attachments or not
:param bool show_legacy_id: Display the legacy_id for the Sales Estimates.
:param int items_per_page: Returns the given number of Sales Estimates per request.
:param int page: Go to specific page of Sales Estimates
:param str attributes: Specify the attributes that you want to expose for the Sales Estimates (expose all attributes with 'all'). These are in addition to the base attributes (name, path)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[SalesEstimate], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'contact_id', 'search', 'status_id', 'from_date', 'to_date',
'updated_or_created_since', 'has_attachments', 'show_legacy_id',
'items_per_page', 'page', 'attributes'
] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_sales_estimates" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'items_per_page' in local_var_params and local_var_params[
'items_per_page'] > 200: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `items_per_page` when calling `get_sales_estimates`, must be a value less than or equal to `200`"
) # noqa: E501
if self.api_client.client_side_validation and 'items_per_page' in local_var_params and local_var_params[
'items_per_page'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `items_per_page` when calling `get_sales_estimates`, must be a value greater than or equal to `1`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'contact_id' in local_var_params and local_var_params[
'contact_id'] is not None: # noqa: E501
query_params.append(
('contact_id', local_var_params['contact_id'])) # noqa: E501
if 'search' in local_var_params and local_var_params[
'search'] is not None: # noqa: E501
query_params.append(
('search', local_var_params['search'])) # noqa: E501
if 'status_id' in local_var_params and local_var_params[
'status_id'] is not None: # noqa: E501
query_params.append(
('status_id', local_var_params['status_id'])) # noqa: E501
if 'from_date' in local_var_params and local_var_params[
'from_date'] is not None: # noqa: E501
query_params.append(
('from_date', local_var_params['from_date'])) # noqa: E501
if 'to_date' in local_var_params and local_var_params[
'to_date'] is not None: # noqa: E501
query_params.append(
('to_date', local_var_params['to_date'])) # noqa: E501
if 'updated_or_created_since' in local_var_params and local_var_params[
'updated_or_created_since'] is not None: # noqa: E501
query_params.append(
('updated_or_created_since',
local_var_params['updated_or_created_since'])) # noqa: E501
if 'has_attachments' in local_var_params and local_var_params[
'has_attachments'] is not None: # noqa: E501
query_params.append(
('has_attachments',
local_var_params['has_attachments'])) # noqa: E501
if 'show_legacy_id' in local_var_params and local_var_params[
'show_legacy_id'] is not None: # noqa: E501
query_params.append(
('show_legacy_id',
local_var_params['show_legacy_id'])) # noqa: E501
if 'items_per_page' in local_var_params and local_var_params[
'items_per_page'] is not None: # noqa: E501
query_params.append(
('items_per_page',
local_var_params['items_per_page'])) # noqa: E501
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'attributes' in local_var_params and local_var_params[
'attributes'] is not None: # noqa: E501
query_params.append(
('attributes', local_var_params['attributes'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/sales_estimates',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[SalesEstimate]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def contracts_read_with_http_info(self, id, **kwargs): # noqa: E501
"""contracts_read # noqa: E501
API endpoint for interacting with contracts. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contracts_read_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int id: A unique integer value identifying this contract. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Contract, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method contracts_read" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if self.api_client.client_side_validation and (
'id' not in local_var_params or # noqa: E501
local_var_params['id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `id` when calling `contracts_read`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
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']) # noqa: E501
# Authentication setting
auth_settings = ['Bearer'] # noqa: E501
return self.api_client.call_api(
'/contracts/{id}/',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Contract', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def put_business_exchange_rates_key_with_http_info(self, key, business_exchange_rates, **kwargs): # noqa: E501
"""Updates a Business Exchange Rate # noqa: E501
Updates a Business Exchange Rate ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 ### Access Control Restrictions Requires the authenticated user to have any of the following roles in the area `Settings`: Full Access # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.put_business_exchange_rates_key_with_http_info(key, business_exchange_rates, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str key: The Business Exchange Rate Key. (required)
:param PutBusinessExchangeRates business_exchange_rates: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(BusinessExchangeRate, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['key', 'business_exchange_rates'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method put_business_exchange_rates_key" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'key' is set
if self.api_client.client_side_validation and ('key' not in local_var_params or # noqa: E501
local_var_params['key'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `key` when calling `put_business_exchange_rates_key`") # noqa: E501
# verify the required parameter 'business_exchange_rates' is set
if self.api_client.client_side_validation and ('business_exchange_rates' not in local_var_params or # noqa: E501
local_var_params['business_exchange_rates'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `business_exchange_rates` when calling `put_business_exchange_rates_key`") # noqa: E501
collection_formats = {}
path_params = {}
if 'key' in local_var_params:
path_params['key'] = local_var_params['key'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'business_exchange_rates' in local_var_params:
body_params = local_var_params['business_exchange_rates']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/business_exchange_rates/{key}', 'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='BusinessExchangeRate', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_countries_key_with_http_info(self, key, **kwargs): # noqa: E501
"""Returns a Country # noqa: E501
Returns a Country ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_countries_key_with_http_info(key, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str key: The Country Key. (required)
:param bool show_legacy_id: Display the legacy_id for the Country.
:param str attributes: Specify the attributes that you want to expose for the Country (expose all attributes with 'all'). These are in addition to the base attributes (name, path)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Base, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['key', 'show_legacy_id', 'attributes'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_countries_key" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'key' is set
if self.api_client.client_side_validation and (
'key' not in local_var_params or # noqa: E501
local_var_params['key'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `key` when calling `get_countries_key`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'key' in local_var_params:
path_params['key'] = local_var_params['key'] # noqa: E501
query_params = []
if 'show_legacy_id' in local_var_params and local_var_params[
'show_legacy_id'] is not None: # noqa: E501
query_params.append(
('show_legacy_id',
local_var_params['show_legacy_id'])) # noqa: E501
if 'attributes' in local_var_params and local_var_params[
'attributes'] is not None: # noqa: E501
query_params.append(
('attributes', local_var_params['attributes'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/countries/{key}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Base', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_opening_balance_journals_key_with_http_info(
self, key, **kwargs): # noqa: E501
"""Deletes a Opening Balance Journal # noqa: E501
Deletes a Opening Balance Journal ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 ### Access Control Restrictions Requires the authenticated user to have any of the following roles in the areas `Sales`, `Purchases`, `Contacts`, `Journals`, `Settings`, `Bank`, `Statutory Reporting`, `Products & Services`, and `Reporting`: Full Access # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_opening_balance_journals_key_with_http_info(key, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str key: The Opening Balance Journal Key. (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['key'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_opening_balance_journals_key" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'key' is set
if self.api_client.client_side_validation and (
'key' not in local_var_params or # noqa: E501
local_var_params['key'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `key` when calling `delete_opening_balance_journals_key`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'key' in local_var_params:
path_params['key'] = local_var_params['key'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/opening_balance_journals/{key}',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_events_with_http_info(self, **kwargs): # noqa: E501
"""Deletes all notification events # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_events_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = []
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method delete_events" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/event/all',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def call_with_http_info(self, **kwargs):
try:
_host = self.settings['servers'][kwargs['_host_index']]
except IndexError:
if self.settings['servers']:
raise ApiValueError(
"Invalid host index. Must be 0 <= index < %s" %
len(self.settings['servers'])
)
_host = None
for key, value in six.iteritems(kwargs):
if key not in self.params_map['all']:
raise ApiTypeError(
"Got an unexpected parameter '%s'"
" to method `%s`" %
(key, self.settings['operation_id'])
)
# only throw this nullable ApiValueError if _check_input_type
# is False, if _check_input_type==True we catch this case
# in self.__validate_inputs
if (key not in self.params_map['nullable'] and value is None
and kwargs['_check_input_type'] is False):
raise ApiValueError(
"Value may not be None for non-nullable parameter `%s`"
" when calling `%s`" %
(key, self.settings['operation_id'])
)
for key in self.params_map['required']:
if key not in kwargs.keys():
raise ApiValueError(
"Missing the required parameter `%s` when calling "
"`%s`" % (key, self.settings['operation_id'])
)
self.__validate_inputs(kwargs)
params = self.__gather_params(kwargs)
accept_headers_list = self.headers_map['accept']
if accept_headers_list:
params['header']['Accept'] = self.api_client.select_header_accept(
accept_headers_list)
content_type_headers_list = self.headers_map['content_type']
if content_type_headers_list:
header_list = self.api_client.select_header_content_type(
content_type_headers_list)
params['header']['Content-Type'] = header_list
return self.api_client.call_api(
self.settings['endpoint_path'], self.settings['http_method'],
params['path'],
params['query'],
params['header'],
body=params['body'],
post_params=params['form'],
files=params['file'],
response_type=self.settings['response_type'],
auth_settings=self.settings['auth'],
async_req=kwargs['async_req'],
_check_type=kwargs['_check_return_type'],
_return_http_data_only=kwargs['_return_http_data_only'],
_preload_content=kwargs['_preload_content'],
_request_timeout=kwargs['_request_timeout'],
_host=_host,
collection_formats=params['collection_format'])
def time_trackings_post_with_http_info(self, body, **kwargs): # noqa: E501
"""Create time tracking # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.time_trackings_post_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param TimeTracking body: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TimeTracking, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['body']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method time_trackings_post" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'body' is set
if self.api_client.client_side_validation and (
'body' not in local_var_params or # noqa: E501
local_var_params['body'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `body` when calling `time_trackings_post`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['Bearer', 'basicAuth'] # noqa: E501
return self.api_client.call_api(
'/time-trackings',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TimeTracking', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def update_contact_with_http_info(self, contact_id, contact_request,
**kwargs): # noqa: E501
"""Updates an existing notification contact to the values passed in the request body. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_contact_with_http_info(contact_id, contact_request, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str contact_id: The ID of the target contact (required)
:param ContactRequest contact_request: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Contact, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['contact_id', 'contact_request']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method update_contact" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'contact_id' is set
if self.api_client.client_side_validation and (
'contact_id' not in local_var_params or # noqa: E501
local_var_params['contact_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `contact_id` when calling `update_contact`"
) # noqa: E501
# verify the required parameter 'contact_request' is set
if self.api_client.client_side_validation and (
'contact_request' not in local_var_params or # noqa: E501
local_var_params['contact_request'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `contact_request` when calling `update_contact`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'contact_id' in local_var_params:
path_params['contactId'] = local_var_params[
'contact_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'contact_request' in local_var_params:
body_params = local_var_params['contact_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept([
'application/json',
'text/html',
]) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/contact/{contactId}',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Contact', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_ledger_account_classifications_with_http_info(self, **kwargs): # noqa: E501
"""Returns all Ledger Account Classifications # noqa: E501
Returns all Ledger Account Classifications ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_ledger_account_classifications_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str ledger_account_type_id: Use this to filter by ledger account type id
:param bool show_legacy_id: Display the legacy_id for the Ledger Account Classifications.
:param int items_per_page: Returns the given number of Ledger Account Classifications per request.
:param int page: Go to specific page of Ledger Account Classifications
:param str attributes: Specify the attributes that you want to expose for the Ledger Account Classifications (expose all attributes with 'all'). These are in addition to the base attributes (name, path)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[Base], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['ledger_account_type_id', 'show_legacy_id', 'items_per_page', 'page', 'attributes'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_ledger_account_classifications" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'items_per_page' in local_var_params and local_var_params['items_per_page'] > 200: # noqa: E501
raise ApiValueError("Invalid value for parameter `items_per_page` when calling `get_ledger_account_classifications`, must be a value less than or equal to `200`") # noqa: E501
if self.api_client.client_side_validation and 'items_per_page' in local_var_params and local_var_params['items_per_page'] < 1: # noqa: E501
raise ApiValueError("Invalid value for parameter `items_per_page` when calling `get_ledger_account_classifications`, must be a value greater than or equal to `1`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'ledger_account_type_id' in local_var_params and local_var_params['ledger_account_type_id'] is not None: # noqa: E501
query_params.append(('ledger_account_type_id', local_var_params['ledger_account_type_id'])) # noqa: E501
if 'show_legacy_id' in local_var_params and local_var_params['show_legacy_id'] is not None: # noqa: E501
query_params.append(('show_legacy_id', local_var_params['show_legacy_id'])) # noqa: E501
if 'items_per_page' in local_var_params and local_var_params['items_per_page'] is not None: # noqa: E501
query_params.append(('items_per_page', local_var_params['items_per_page'])) # noqa: E501
if 'page' in local_var_params and local_var_params['page'] is not None: # noqa: E501
query_params.append(('page', local_var_params['page'])) # noqa: E501
if 'attributes' in local_var_params and local_var_params['attributes'] is not None: # noqa: E501
query_params.append(('attributes', local_var_params['attributes'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/ledger_account_classifications', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[Base]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_invoice_settings_with_http_info(self, **kwargs): # noqa: E501
"""Returns all Invoice Settings # noqa: E501
Returns all Invoice Settings ### Endpoint Availability * Accounting: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 * Accounting Start: 🇨🇦, 🇩🇪, 🇪🇸, 🇫🇷, 🇬🇧, 🇮🇪, 🇺🇸 ### Access Control Restrictions Requires the authenticated user to have any mentioned role in one of the listed areas: * Area: `Settings`: Full Access, Read Only # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_invoice_settings_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param bool show_legacy_id: Display the legacy_id for the Invoice Settings.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InvoiceSettings, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['show_legacy_id'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_invoice_settings" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'show_legacy_id' in local_var_params and local_var_params['show_legacy_id'] is not None: # noqa: E501
query_params.append(('show_legacy_id', local_var_params['show_legacy_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/invoice_settings', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InvoiceSettings', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def api_web_route_controller_show_with_http_info(self, id, **kwargs): # noqa: E501
"""api_web_route_controller_show # noqa: E501
Show a particular route by the route's id. ## Names and Descriptions There are 3 attributes with increasing details for naming and describing the route. 1. `/data/attributes/short_name` 2. `/data/attributes/long_name` 3. `/data/attributes/description` ## Directions `/data/attributes/direction_names` is the only place to convert the `direction_id` used throughout the rest of the API to human-readable names. ## Type `/data/attributes/type` corresponds to [GTFS `routes.txt` `route_type`](https://github.com/google/transit/blob/master/gtfs/spec/en/reference.md#routestxt). | Value | Name | Example | |-------|---------------|------------| | `0` | Light Rail | Green Line | | `1` | Heavy Rail | Red Line | | `2` | Commuter Rail | | | `3` | Bus | | | `4` | Ferry | | # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_web_route_controller_show_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: Unique identifier for route (required)
:param str fields_route: Fields to include with the response. Multiple fields **MUST** be a comma-separated (U+002C COMMA, \",\") list. Note that fields can also be selected for included data types: see the [V3 API Best Practices](https://www.mbta.com/developers/v3-api/best-practices) for an example.
:param str include: Relationships to include. * `line` * `route_patterns` The value of the include parameter **MUST** be a comma-separated (U+002C COMMA, \",\") list of relationship paths. A relationship path is a dot-separated (U+002E FULL-STOP, \".\") list of relationship names. [JSONAPI \"include\" behavior](http://jsonapi.org/format/#fetching-includes)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Route, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id', 'fields_route', 'include'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method api_web_route_controller_show" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if self.api_client.client_side_validation and ('id' not in local_var_params or # noqa: E501
local_var_params['id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `id` when calling `api_web_route_controller_show`") # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
if 'fields_route' in local_var_params and local_var_params['fields_route'] is not None: # noqa: E501
query_params.append(('fields[route]', local_var_params['fields_route'])) # noqa: E501
if 'include' in local_var_params and local_var_params['include'] is not None: # noqa: E501
query_params.append(('include', local_var_params['include'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/vnd.api+json']) # noqa: E501
# Authentication setting
auth_settings = ['api_key_in_header', 'api_key_in_query'] # noqa: E501
return self.api_client.call_api(
'/routes/{id}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Route', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_api_version_with_http_info(self, **kwargs): # noqa: E501
"""Get API version # noqa: E501
Returns information about the service API. This service is public API since Teamscale 5.8. The API requires no login # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_api_version_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(ServiceApiInfo, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_api_version" % key
)
local_var_params[key] = val
del local_var_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']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/api/version', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ServiceApiInfo', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_settings_with_http_info(self, **kwargs): # noqa: E501
"""Get settings # noqa: E501
**webhookUrl** - Http or https URL for receiving notifications. For testing, we recommend using [our RequestBin](http://bin.chat-api.com). **ackNotificationsOn** - Turn on/off ack (message delivered and message viewed) notifications in webhooks. GET method works for the same address. **chatUpdateOn** - Turn on/off chat update notifications in webhooks. GET method works for the same address. **videoUploadOn** - Turn on/off receiving video messages. **proxy** - Socks5 IP address and port proxy for instance. **guaranteedHooks** - Guarantee webhook delivery. Each webhook will make 20 attempts to send until it receives 200 status from the server. **ignoreOldMessages** - Do not send webhooks with old messages during authorization. **processArchive** - Process messages from archived chats. **instanceStatuses** - Turn on/off collecting instance status changing history. **webhookStatuses** - Turn on/off collecting messages webhooks statuses. **statusNotificationsOn** - Turn on/off instance changind status notifications in webhooks. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_settings_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Settings, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_settings" % key
)
local_var_params[key] = val
del local_var_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']) # noqa: E501
# Authentication setting
auth_settings = ['instanceId', 'token'] # noqa: E501
return self.api_client.call_api(
'/settings', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Settings', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def contracts_list_with_http_info(self, **kwargs): # noqa: E501
"""Overview of organisations that have a valid 3Di contract. # noqa: E501
List all organisations that already have used some fraction of their calculation quota (for the current year - the `hours_used` property is based on the current calender year) ``` ?hours_used__gt=0 ``` # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contracts_list_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param float organisation__id:
:param float organisation__id__gt:
:param float organisation__id__gte:
:param float organisation__id__lt:
:param float organisation__id__lte:
:param str organisation__id__isnull:
:param str organisation__name:
:param str organisation__name__contains:
:param str organisation__name__icontains:
:param str organisation__name__in: Multiple values may be separated by commas.
:param str organisation__name__startswith:
:param str organisation__name__istartswith:
:param str organisation__name__endswith:
:param str organisation__name__regex:
:param str organisation__unique_id:
:param str organisation__unique_id__contains:
:param str organisation__unique_id__icontains:
:param str organisation__unique_id__in: Multiple values may be separated by commas.
:param str organisation__unique_id__startswith:
:param str organisation__unique_id__istartswith:
:param str organisation__unique_id__endswith:
:param str organisation__unique_id__regex:
:param float hours_used__gt:
:param float hours_used__lt:
:param int limit: Number of results to return per page.
:param int offset: The initial index from which to return the results.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InlineResponse2001, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'organisation__id', 'organisation__id__gt',
'organisation__id__gte', 'organisation__id__lt',
'organisation__id__lte', 'organisation__id__isnull',
'organisation__name', 'organisation__name__contains',
'organisation__name__icontains', 'organisation__name__in',
'organisation__name__startswith',
'organisation__name__istartswith', 'organisation__name__endswith',
'organisation__name__regex', 'organisation__unique_id',
'organisation__unique_id__contains',
'organisation__unique_id__icontains',
'organisation__unique_id__in',
'organisation__unique_id__startswith',
'organisation__unique_id__istartswith',
'organisation__unique_id__endswith',
'organisation__unique_id__regex', 'hours_used__gt',
'hours_used__lt', 'limit', 'offset'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method contracts_list" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'organisation__id' in local_var_params and local_var_params[
'organisation__id'] is not None: # noqa: E501
query_params.append(
('organisation__id',
local_var_params['organisation__id'])) # noqa: E501
if 'organisation__id__gt' in local_var_params and local_var_params[
'organisation__id__gt'] is not None: # noqa: E501
query_params.append(
('organisation__id__gt',
local_var_params['organisation__id__gt'])) # noqa: E501
if 'organisation__id__gte' in local_var_params and local_var_params[
'organisation__id__gte'] is not None: # noqa: E501
query_params.append(
('organisation__id__gte',
local_var_params['organisation__id__gte'])) # noqa: E501
if 'organisation__id__lt' in local_var_params and local_var_params[
'organisation__id__lt'] is not None: # noqa: E501
query_params.append(
('organisation__id__lt',
local_var_params['organisation__id__lt'])) # noqa: E501
if 'organisation__id__lte' in local_var_params and local_var_params[
'organisation__id__lte'] is not None: # noqa: E501
query_params.append(
('organisation__id__lte',
local_var_params['organisation__id__lte'])) # noqa: E501
if 'organisation__id__isnull' in local_var_params and local_var_params[
'organisation__id__isnull'] is not None: # noqa: E501
query_params.append(
('organisation__id__isnull',
local_var_params['organisation__id__isnull'])) # noqa: E501
if 'organisation__name' in local_var_params and local_var_params[
'organisation__name'] is not None: # noqa: E501
query_params.append(
('organisation__name',
local_var_params['organisation__name'])) # noqa: E501
if 'organisation__name__contains' in local_var_params and local_var_params[
'organisation__name__contains'] is not None: # noqa: E501
query_params.append(
('organisation__name__contains',
local_var_params['organisation__name__contains']
)) # noqa: E501
if 'organisation__name__icontains' in local_var_params and local_var_params[
'organisation__name__icontains'] is not None: # noqa: E501
query_params.append(
('organisation__name__icontains',
local_var_params['organisation__name__icontains']
)) # noqa: E501
if 'organisation__name__in' in local_var_params and local_var_params[
'organisation__name__in'] is not None: # noqa: E501
query_params.append(
('organisation__name__in',
local_var_params['organisation__name__in'])) # noqa: E501
if 'organisation__name__startswith' in local_var_params and local_var_params[
'organisation__name__startswith'] is not None: # noqa: E501
query_params.append(
('organisation__name__startswith',
local_var_params['organisation__name__startswith']
)) # noqa: E501
if 'organisation__name__istartswith' in local_var_params and local_var_params[
'organisation__name__istartswith'] is not None: # noqa: E501
query_params.append(
('organisation__name__istartswith',
local_var_params['organisation__name__istartswith']
)) # noqa: E501
if 'organisation__name__endswith' in local_var_params and local_var_params[
'organisation__name__endswith'] is not None: # noqa: E501
query_params.append(
('organisation__name__endswith',
local_var_params['organisation__name__endswith']
)) # noqa: E501
if 'organisation__name__regex' in local_var_params and local_var_params[
'organisation__name__regex'] is not None: # noqa: E501
query_params.append(
('organisation__name__regex',
local_var_params['organisation__name__regex'])) # noqa: E501
if 'organisation__unique_id' in local_var_params and local_var_params[
'organisation__unique_id'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id',
local_var_params['organisation__unique_id'])) # noqa: E501
if 'organisation__unique_id__contains' in local_var_params and local_var_params[
'organisation__unique_id__contains'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__contains',
local_var_params['organisation__unique_id__contains']
)) # noqa: E501
if 'organisation__unique_id__icontains' in local_var_params and local_var_params[
'organisation__unique_id__icontains'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__icontains',
local_var_params['organisation__unique_id__icontains']
)) # noqa: E501
if 'organisation__unique_id__in' in local_var_params and local_var_params[
'organisation__unique_id__in'] is not None: # noqa: E501
query_params.append((
'organisation__unique_id__in',
local_var_params['organisation__unique_id__in'])) # noqa: E501
if 'organisation__unique_id__startswith' in local_var_params and local_var_params[
'organisation__unique_id__startswith'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__startswith',
local_var_params['organisation__unique_id__startswith']
)) # noqa: E501
if 'organisation__unique_id__istartswith' in local_var_params and local_var_params[
'organisation__unique_id__istartswith'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__istartswith',
local_var_params['organisation__unique_id__istartswith']
)) # noqa: E501
if 'organisation__unique_id__endswith' in local_var_params and local_var_params[
'organisation__unique_id__endswith'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__endswith',
local_var_params['organisation__unique_id__endswith']
)) # noqa: E501
if 'organisation__unique_id__regex' in local_var_params and local_var_params[
'organisation__unique_id__regex'] is not None: # noqa: E501
query_params.append(
('organisation__unique_id__regex',
local_var_params['organisation__unique_id__regex']
)) # noqa: E501
if 'hours_used__gt' in local_var_params and local_var_params[
'hours_used__gt'] is not None: # noqa: E501
query_params.append(
('hours_used__gt',
local_var_params['hours_used__gt'])) # noqa: E501
if 'hours_used__lt' in local_var_params and local_var_params[
'hours_used__lt'] is not None: # noqa: E501
query_params.append(
('hours_used__lt',
local_var_params['hours_used__lt'])) # noqa: E501
if 'limit' in local_var_params and local_var_params[
'limit'] is not None: # noqa: E501
query_params.append(
('limit', local_var_params['limit'])) # noqa: E501
if 'offset' in local_var_params and local_var_params[
'offset'] is not None: # noqa: E501
query_params.append(
('offset', local_var_params['offset'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['Bearer'] # noqa: E501
return self.api_client.call_api(
'/contracts/',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InlineResponse2001', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def retry_with_http_info(self, **kwargs): # noqa: E501
"""Repeat the manual synchronization attempt with the device # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.retry_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(InlineResponse2003, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method retry" % key
)
local_var_params[key] = val
del local_var_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']) # noqa: E501
# Authentication setting
auth_settings = ['instanceId', 'token'] # noqa: E501
return self.api_client.call_api(
'/retry', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InlineResponse2003', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def modify_task_with_http_info(self, task_id, task_detail, **kwargs):
"""modify tasks
This api is used to modify task
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.modify_task_with_http_info(task_id, task_detail, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str task_id: (required)
:param TaskDetail task_detail:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(TaskID, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['task_id', 'task_detail']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method modify_task" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'task_id' is set
if ('task_id' not in local_var_params
or local_var_params['task_id'] is None):
raise ApiValueError(
"Missing the required parameter `task_id` when calling `modify_task`"
)
collection_formats = {}
path_params = {}
if 'task_id' in local_var_params:
path_params['task_id'] = local_var_params['task_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'task_detail' in local_var_params:
body_params = local_var_params['task_detail']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json'])
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type(
['application/json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(
'/tasks/{task_id}',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TaskID',
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'),
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
