def get_sp_metadata_as_string_with_http_info(self, **kwargs): # noqa: E501
"""Returns the SAML Service Provider metadata for this instance. # noqa: E501
Returns the SAML Service Provider metadata for this instance. # 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_sp_metadata_as_string_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param bool complete: Whether or not the meta data generated should include the non-required attributes (completeMetadata = true means all the non-essential attributes too).
: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 = ['complete']
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_sp_metadata_as_string" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'complete' in local_var_params and local_var_params[
'complete'] is not None: # noqa: E501
query_params.append(
('complete', local_var_params['complete'])) # 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/xml']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/security/saml',
'GET',
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 cancel_workflow_task_with_http_info(self, workflow_task_id,
**kwargs): # noqa: E501
"""Cancel workflow task. # noqa: E501
Cancels the workflow task with the specified ID with a reason. If the given workflow is a subprocess, this method makes sure everything is cancelled from the root process instance. If the given task is not found, this method will assume it already was cancelled without throwing any error. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.cancel_workflow_task_with_http_info(workflow_task_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str workflow_task_id: The ID of the workflow task. (required)
:param str body: The reason for the cancellation of the workflow task.
: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 = ['workflow_task_id', '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 cancel_workflow_task" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'workflow_task_id' is set
if self.api_client.client_side_validation and (
'workflow_task_id' not in local_var_params or # noqa: E501
local_var_params['workflow_task_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `workflow_task_id` when calling `cancel_workflow_task`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'workflow_task_id' in local_var_params:
path_params['workflowTaskId'] = local_var_params[
'workflow_task_id'] # noqa: E501
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 `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/workflowTasks/{workflowTaskId}/canceled',
'POST',
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 reassign_task_with_http_info(self, workflow_task_id,
**kwargs): # noqa: E501
"""Reassign task. # noqa: E501
Reassigns the task with the specified ID to one or more users, groups or roles. Caller needs to provide at least one of the value list for users, groups or roles. If roles are provided then the same number of communities needs to be provided also. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.reassign_task_with_http_info(workflow_task_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str workflow_task_id: The ID of the workflow task. (required)
:param list[str] users: The user IDs to reassign to.
:param list[str] groups: The group IDs to reassign to.
:param list[str] roles: The role IDs to reassign to.
:param list[str] communities: The Community IDs of the specified roles to reassign to.
: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 = [
'workflow_task_id', 'users', 'groups', 'roles', 'communities'
]
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 reassign_task" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'workflow_task_id' is set
if self.api_client.client_side_validation and (
'workflow_task_id' not in local_var_params or # noqa: E501
local_var_params['workflow_task_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `workflow_task_id` when calling `reassign_task`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'workflow_task_id' in local_var_params:
path_params['workflowTaskId'] = local_var_params[
'workflow_task_id'] # noqa: E501
query_params = []
if 'users' in local_var_params and local_var_params[
'users'] is not None: # noqa: E501
query_params.append(
('users', local_var_params['users'])) # noqa: E501
collection_formats['users'] = 'multi' # noqa: E501
if 'groups' in local_var_params and local_var_params[
'groups'] is not None: # noqa: E501
query_params.append(
('groups', local_var_params['groups'])) # noqa: E501
collection_formats['groups'] = 'multi' # noqa: E501
if 'roles' in local_var_params and local_var_params[
'roles'] is not None: # noqa: E501
query_params.append(
('roles', local_var_params['roles'])) # noqa: E501
collection_formats['roles'] = 'multi' # noqa: E501
if 'communities' in local_var_params and local_var_params[
'communities'] is not None: # noqa: E501
query_params.append(
('communities', local_var_params['communities'])) # noqa: E501
collection_formats['communities'] = 'multi' # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/workflowTasks/{workflowTaskId}/reassign',
'POST',
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 remove_rating_with_http_info(self, rating_id, **kwargs): # noqa: E501
"""Remove rating. # noqa: E501
Removes the rating with the specified ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.remove_rating_with_http_info(rating_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str rating_id: The ID of the rating to be removed. (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 = [
'rating_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 remove_rating" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'rating_id' is set
if self.api_client.client_side_validation and ('rating_id' not in local_var_params or # noqa: E501
local_var_params['rating_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `rating_id` when calling `remove_rating`") # noqa: E501
collection_formats = {}
path_params = {}
if 'rating_id' in local_var_params:
path_params['ratingId'] = local_var_params['rating_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/ratings/{ratingId}', '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 add_diagram_picture_with_http_info(self, **kwargs): # noqa: E501
"""Adds a diagram picture. # noqa: E501
Take a diagram picture for a given asset and diagram view. A diagram picture is a copy of traceability diagram (result diagram) at a given time (for more information on traceability diagram check DGC User Guide). The motivation behind diagram picture is to be able to reopen them at a later point in time and be able to see them them exactly as they were created. This feature is not possible for result diagram which are always showing the current situation. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_diagram_picture_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddDiagramPictureRequest add_diagram_picture_request:
: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(str, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['add_diagram_picture_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 add_diagram_picture" % 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
if 'add_diagram_picture_request' in local_var_params:
body_params = local_var_params['add_diagram_picture_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/diagramPictures',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='str', # 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_job_with_http_info(self, job_id, **kwargs): # noqa: E501
"""Returns the Job identified by the given UUID. # noqa: E501
Returns the Job identified by the given UUID. # 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_job_with_http_info(job_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str job_id: The ID of the job. (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(Job, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['job_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 get_job" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'job_id' is set
if self.api_client.client_side_validation and (
'job_id' not in local_var_params or # noqa: E501
local_var_params['job_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `job_id` when calling `get_job`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'job_id' in local_var_params:
path_params['jobId'] = local_var_params['job_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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/jobs/{jobId}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Job', # 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 change_rating_with_http_info(self, rating_id, **kwargs): # noqa: E501
"""Change rating. # noqa: E501
Modifies the rating with the specified ID.<p>Only properties that are specified in these requests and have not <code>null</code> values are updated. All other properties are ignored.</p> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.change_rating_with_http_info(rating_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str rating_id: The ID of the rating to be changed. (required)
:param ChangeRatingRequest change_rating_request: The properties of the rating to be changed.
: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(Rating, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'rating_id',
'change_rating_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 change_rating" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'rating_id' is set
if self.api_client.client_side_validation and ('rating_id' not in local_var_params or # noqa: E501
local_var_params['rating_id'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `rating_id` when calling `change_rating`") # noqa: E501
collection_formats = {}
path_params = {}
if 'rating_id' in local_var_params:
path_params['ratingId'] = local_var_params['rating_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'change_rating_request' in local_var_params:
body_params = local_var_params['change_rating_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/ratings/{ratingId}', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Rating', # 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 is_logged_in_with_http_info(self, **kwargs): # noqa: E501
"""Get session # noqa: E501
Gets current session (checks if user is logged in). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.is_logged_in_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 is_logged_in" % 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(
'/auth/sessions/current', 'GET',
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 find_most_viewed_assets_with_http_info(self, **kwargs): # noqa: E501
"""Find most viewed assets. # noqa: E501
Returns the most viewed assets by all users, with navigation-related info. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_most_viewed_assets_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param int period: The time span for which most viewed assets should be found. This time span must be expressed in milliseconds.<br/>For instance, to get most viewed assets for last 24 hours, period would be <code>86400000</code>.<br/>If it's unset (period = 0) looks for all time most viewed assets.
:param bool is_guest_excluded: Whether guest visits should be excluded from result.
: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(NavigationStatisticsEntryPagedResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset',
'limit',
'period',
'is_guest_excluded'
]
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 find_most_viewed_assets" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 'period' in local_var_params and local_var_params['period'] is not None: # noqa: E501
query_params.append(('period', local_var_params['period'])) # noqa: E501
if 'is_guest_excluded' in local_var_params and local_var_params['is_guest_excluded'] is not None: # noqa: E501
query_params.append(('isGuestExcluded', local_var_params['is_guest_excluded'])) # 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/navigation/most_viewed', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='NavigationStatisticsEntryPagedResponse', # 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_insights_zip_with_http_info(self, **kwargs): # noqa: E501
"""Reporting insights download # noqa: E501
Returns a Reporting Data archive (zip) file that contains Apache Parquet files with table content for each of the six concepts (community, domain, asset, attribute, relation and responsibility) for one day (=snapshot date). Each morning, at 00:01 in the timezone of the Collibra platform, the reporting data of that platform is captured. The reporting data is retained for one rolling month and each month’s end before that. The tables structure (DDL) for this content is published [here](https://marketplace.collibra.com/listings/reporting-data-layer). # 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_insights_zip_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str snapshot_date: Snapshot date for reporting insights data in ISO8601 format (e.g.: 2019-05-14)
:param str format: Archive format. Currently only ZIP format is accepted
: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(file, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['snapshot_date', 'format']
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_insights_zip" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'snapshot_date' in local_var_params and local_var_params[
'snapshot_date'] is not None: # noqa: E501
query_params.append(
('snapshotDate',
local_var_params['snapshot_date'])) # noqa: E501
if 'format' in local_var_params and local_var_params[
'format'] is not None: # noqa: E501
query_params.append(
('format', local_var_params['format'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/reporting/insights/download',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='file', # 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 login_with_http_info(self, **kwargs): # noqa: E501
"""Login # noqa: E501
Authenticates a user and creates a new session on the server. Once the user is authenticated then the returned session id can be used to access DGC REST Api in subsequent requests. The method additionally returns the JSESSIONID cookie in a <code>Set-Cookie</code> header. If user already has an open session then this session will be terminated. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param LoginRequest login_request:
: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(DGCSession, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'login_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 login" % 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
if 'login_request' in local_var_params:
body_params = local_var_params['login_request']
# 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(
'/auth/sessions', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DGCSession', # 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 add_attachment_with_http_info(self, **kwargs): # noqa: E501
"""Add attachment # noqa: E501
Adds new attachment. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_attachment_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param file file: the file - attachment content
:param str file_name: the display name of the file of this attachment
:param str resource_type: the type of the resource the attachment should refer to
:param str resource_id: the id of the resource the attachment should refer to
: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(AttachmentImpl, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['file', 'file_name', 'resource_type', 'resource_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 add_attachment" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
if 'file' in local_var_params:
local_var_files['file'] = local_var_params['file'] # noqa: E501
if 'file_name' in local_var_params:
form_params.append(
('fileName', local_var_params['file_name'])) # noqa: E501
if 'resource_type' in local_var_params:
form_params.append(
('resourceType',
local_var_params['resource_type'])) # noqa: E501
if 'resource_id' in local_var_params:
form_params.append(
('resourceId', local_var_params['resource_id'])) # noqa: E501
body_params = None
# 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
['multipart/form-data']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/attachments',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='AttachmentImpl', # 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 add_users_to_user_group_with_http_info(self, user_group_id,
**kwargs): # noqa: E501
"""Add users to user group # noqa: E501
Adds users to an existing user group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_users_to_user_group_with_http_info(user_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str user_group_id: The ID of the user group (required)
:param AddUsersToUserGroupRequest add_users_to_user_group_request:
: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[User], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['user_group_id', 'add_users_to_user_group_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 add_users_to_user_group" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'user_group_id' is set
if self.api_client.client_side_validation and (
'user_group_id' not in local_var_params or # noqa: E501
local_var_params['user_group_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `user_group_id` when calling `add_users_to_user_group`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'user_group_id' in local_var_params:
path_params['userGroupId'] = local_var_params[
'user_group_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'add_users_to_user_group_request' in local_var_params:
body_params = local_var_params['add_users_to_user_group_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/userGroups/{userGroupId}/users',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[User]', # 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_file_with_http_info(self, file_id, **kwargs): # noqa: E501
"""Download file # noqa: E501
Downloads file identified by given id. Keep in mind to use GET /attachments/{attachmentId}/file instead of this endpoint when you want to get the file of an attachment. A File and its id can be temporary so it's possible this endpoint will not get you the desired file. # 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_file_with_http_info(file_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str file_id: the id of the file (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 = ['file_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 get_file" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'file_id' is set
if self.api_client.client_side_validation and (
'file_id' not in local_var_params or # noqa: E501
local_var_params['file_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `file_id` when calling `get_file`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'file_id' in local_var_params:
path_params['fileId'] = local_var_params['file_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/files/{fileId}',
'GET',
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 find_roles_with_http_info(self, **kwargs): # noqa: E501
"""Returns roles matching the given search criteria. # noqa: E501
Only parameters that are specified in this request and have not <code>null</code> values are used for filtering. All other parameters are ignored. The returned roles satisfy all constraints that are specified in this search criteria. By default a result containing 1000 roles is returned. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_roles_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param str name: The name of the role to search for.
:param str name_match_mode: The match mode used to compare <code>name</code>.
:param str description: The description of the role to search for.
:param bool _global: Whether global roles should be searched for.
:param str type: Indicates which type of roles should be searched for. Usage is mutually exclusive with the deprecated global flag.
: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(PagedResponseRole, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset', 'limit', 'name', 'name_match_mode', 'description',
'_global', 'type'
]
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 find_roles" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 '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 'name_match_mode' in local_var_params and local_var_params[
'name_match_mode'] is not None: # noqa: E501
query_params.append(
('nameMatchMode',
local_var_params['name_match_mode'])) # noqa: E501
if 'description' in local_var_params and local_var_params[
'description'] is not None: # noqa: E501
query_params.append(
('description', local_var_params['description'])) # noqa: E501
if '_global' in local_var_params and local_var_params[
'_global'] is not None: # noqa: E501
query_params.append(
('global', local_var_params['_global'])) # noqa: E501
if 'type' in local_var_params and local_var_params[
'type'] is not None: # noqa: E501
query_params.append(
('type', local_var_params['type'])) # 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 = ['basicAuth'] # 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='PagedResponseRole', # 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 message_event_received_with_http_info(self, process_instance_id,
message_name,
**kwargs): # noqa: E501
"""Pass message event to workflow engine. # noqa: E501
Passes the message event to the workflow engine. It will pass on this specific event to the engine with the given name, process instance and variables. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.message_event_received_with_http_info(process_instance_id, message_name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str process_instance_id: The ID of an instance of a process. Given process instance should have only one execution running at the time. Otherwise this method will fail. (required)
:param str message_name: The name of the message to trigger. (required)
:param MessageEventReceivedRequest message_event_received_request: The properties of the message event to be received.
: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 = [
'process_instance_id', 'message_name',
'message_event_received_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 message_event_received" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'process_instance_id' is set
if self.api_client.client_side_validation and (
'process_instance_id' not in local_var_params or # noqa: E501
local_var_params['process_instance_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `process_instance_id` when calling `message_event_received`"
) # noqa: E501
# verify the required parameter 'message_name' is set
if self.api_client.client_side_validation and (
'message_name' not in local_var_params or # noqa: E501
local_var_params['message_name'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `message_name` when calling `message_event_received`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'process_instance_id' in local_var_params:
path_params['processInstanceId'] = local_var_params[
'process_instance_id'] # noqa: E501
if 'message_name' in local_var_params:
path_params['messageName'] = local_var_params[
'message_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'message_event_received_request' in local_var_params:
body_params = local_var_params['message_event_received_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/workflowInstances/{processInstanceId}/messageEvents/{messageName}',
'POST',
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 remove_statuses_with_http_info(self, **kwargs): # noqa: E501
"""Removes multiple statuses. # noqa: E501
Removes multiple statuses. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.remove_statuses_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] request_body: The indentifiers of the Statuses.
: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 = ['request_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 remove_statuses" % 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
if 'request_body' in local_var_params:
body_params = local_var_params['request_body']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/statuses/bulk',
'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_activities_with_http_info(self, **kwargs): # noqa: E501
"""Returns activities matching the given search criteria. # noqa: E501
Returns activities matching the given search criteria.Only parameters that are specified in this request and have not <code>null</code> values are used for filtering.All other parameters are ignored.The returned activities satisfy all constraints that are specified in this search criteria.By default a result containing 100 activities is returned. # 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_activities_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param str task_id: The ID of the task which contains the basic find activities request.
:param str context_id: The ID of the context which the activities should be searched for.
:param list[str] involved_people_ids: The list of IDs of the people that should be involved in searched activities.
:param list[str] involved_role_ids: The list of IDs of the roles that should be involved in searched activities.
:param str performed_by_user_id: The ID of the user who performed searched activities.
:param list[str] performed_by_role_ids: The list of IDs of the roles assigned to users who performed searched activities.
:param str activity_type: The type of the activity.
:param str call_id: The ID of the call.
:param list[str] categories: The set of the categories of activities that should be searched. One of [ATTRIBUTE, ATTACHMENT, RELATION, COMMENT,<br/>STATUS, WORKFLOW, RESPONSIBILITY, USER, USER_GROUP, ROLE, TAGS, OTHERS].
:param list[str] resource_types: The set of the resource types that searched activities refer to, i.e. [Community, Asset, Domain, Attribute,<br/>Relation, WorkflowInstance].
:param int start_date: TThe start date of the searched activities. It is the timestamp (in UTC time standard).
:param int end_date: The end date of the searched activities. It is the timestamp (in UTC time standard).
:param bool call_count_enabled: Flag to indicate if the number of calls standing behind the activity should be returned or not.<br/>Note that by default that count will be not calculated as it brings an important performance penalty.
: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(ActivityPagedResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset', 'limit', 'task_id', 'context_id', 'involved_people_ids',
'involved_role_ids', 'performed_by_user_id',
'performed_by_role_ids', 'activity_type', 'call_id', 'categories',
'resource_types', 'start_date', 'end_date', 'call_count_enabled'
]
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_activities" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 'task_id' in local_var_params and local_var_params[
'task_id'] is not None: # noqa: E501
query_params.append(
('taskId', local_var_params['task_id'])) # noqa: E501
if 'context_id' in local_var_params and local_var_params[
'context_id'] is not None: # noqa: E501
query_params.append(
('contextId', local_var_params['context_id'])) # noqa: E501
if 'involved_people_ids' in local_var_params and local_var_params[
'involved_people_ids'] is not None: # noqa: E501
query_params.append(
('involvedPeopleIds',
local_var_params['involved_people_ids'])) # noqa: E501
collection_formats['involvedPeopleIds'] = 'multi' # noqa: E501
if 'involved_role_ids' in local_var_params and local_var_params[
'involved_role_ids'] is not None: # noqa: E501
query_params.append(
('involvedRoleIds',
local_var_params['involved_role_ids'])) # noqa: E501
collection_formats['involvedRoleIds'] = 'multi' # noqa: E501
if 'performed_by_user_id' in local_var_params and local_var_params[
'performed_by_user_id'] is not None: # noqa: E501
query_params.append(
('performedByUserId',
local_var_params['performed_by_user_id'])) # noqa: E501
if 'performed_by_role_ids' in local_var_params and local_var_params[
'performed_by_role_ids'] is not None: # noqa: E501
query_params.append(
('performedByRoleIds',
local_var_params['performed_by_role_ids'])) # noqa: E501
collection_formats['performedByRoleIds'] = 'multi' # noqa: E501
if 'activity_type' in local_var_params and local_var_params[
'activity_type'] is not None: # noqa: E501
query_params.append(
('activityType',
local_var_params['activity_type'])) # noqa: E501
if 'call_id' in local_var_params and local_var_params[
'call_id'] is not None: # noqa: E501
query_params.append(
('callId', local_var_params['call_id'])) # noqa: E501
if 'categories' in local_var_params and local_var_params[
'categories'] is not None: # noqa: E501
query_params.append(
('categories', local_var_params['categories'])) # noqa: E501
collection_formats['categories'] = 'multi' # noqa: E501
if 'resource_types' in local_var_params and local_var_params[
'resource_types'] is not None: # noqa: E501
query_params.append(
('resourceTypes',
local_var_params['resource_types'])) # noqa: E501
collection_formats['resourceTypes'] = 'multi' # 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 'call_count_enabled' in local_var_params and local_var_params[
'call_count_enabled'] is not None: # noqa: E501
query_params.append(
('callCountEnabled',
local_var_params['call_count_enabled'])) # 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/activities',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ActivityPagedResponse', # 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 cancel_job_with_http_info(self, job_id, **kwargs): # noqa: E501
"""Cancels given Job. # noqa: E501
Calling this endpoint will return immediately and not wait until the Job is actually stopped. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.cancel_job_with_http_info(job_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str job_id: The unique identifier of the Job. (required)
:param CancelJobRequest cancel_job_request:
: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 = ['job_id', 'cancel_job_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 cancel_job" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'job_id' is set
if self.api_client.client_side_validation and (
'job_id' not in local_var_params or # noqa: E501
local_var_params['job_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `job_id` when calling `cancel_job`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'job_id' in local_var_params:
path_params['jobId'] = local_var_params['job_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'cancel_job_request' in local_var_params:
body_params = local_var_params['cancel_job_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/jobs/{jobId}/canceled',
'POST',
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 change_attributes_with_http_info(self, **kwargs): # noqa: E501
"""Change attributes # noqa: E501
Changes multiple attributes with the information that is present in the request. Only properties that are specified in this request and have not <code>null</code> values are updated. All other properties are ignored. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.change_attributes_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[ChangeAttributeRequest] change_attribute_request: the list of properties of the attributes to be changed
: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(Attribute, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'change_attribute_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 change_attributes" % 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
if 'change_attribute_request' in local_var_params:
body_params = local_var_params['change_attribute_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/attributes/bulk', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Attribute', # 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 find_ratings_with_http_info(self, **kwargs): # noqa: E501
"""Find ratings. # noqa: E501
Returns ratings matching the given search criteria.<p>Only parameters that are specified in this request and have not <code>null</code> values are used for filtering. All other parameters are ignored.</p><p>The returned ratings satisfy all constraints that are specified in this search criteria. By default, the result contains up to 1000 ratings.</p> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_ratings_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param str sort_order: The order of sorting (on creation date) the found ratings.
:param str asset_id: The ID of the asset the rating belongs to.
:param str user_id: The ID of the rating author.
: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(RatingsPagedResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset',
'limit',
'sort_order',
'asset_id',
'user_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 find_ratings" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 'sort_order' in local_var_params and local_var_params['sort_order'] is not None: # noqa: E501
query_params.append(('sortOrder', local_var_params['sort_order'])) # noqa: E501
if 'asset_id' in local_var_params and local_var_params['asset_id'] is not None: # noqa: E501
query_params.append(('assetId', local_var_params['asset_id'])) # noqa: E501
if 'user_id' in local_var_params and local_var_params['user_id'] is not None: # noqa: E501
query_params.append(('userId', local_var_params['user_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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/ratings', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='RatingsPagedResponse', # 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 find_workflow_tasks_with_http_info(self, **kwargs): # noqa: E501
"""Find workflow tasks. # noqa: E501
Returns the workflow tasks matching given search criteria. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_workflow_tasks_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param str business_item_id: The ID of the business item
:param str business_item_type: The type of the business item
:param str workflow_task_user_relation: The type of relation between user and searched tasks. This could be either set to search for all the tasks the user is permitted to view or just those assigned to the user.
:param str business_item_name: The part of the name of the business item.
:param str user_id: The ID of the user for which the tasks need to be returned. If empty, the current logged in user will be used
:param int create_date: The creation date of the task. It is the timestamp (in UTC time standard)
:param int due_date: The due date of the task. It is the timestamp (in UTC time standard)
:param str title: The title/name of the task.
:param str type: The task type.
:param str sort_field: The field on which the results are sorted. On due date by default.
:param str sort_order: The sorting order.
: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(WorkflowTaskPagedResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset', 'limit', 'business_item_id', 'business_item_type',
'workflow_task_user_relation', 'business_item_name', 'user_id',
'create_date', 'due_date', 'title', 'type', 'sort_field',
'sort_order'
]
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 find_workflow_tasks" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 'business_item_id' in local_var_params and local_var_params[
'business_item_id'] is not None: # noqa: E501
query_params.append(
('businessItemId',
local_var_params['business_item_id'])) # noqa: E501
if 'business_item_type' in local_var_params and local_var_params[
'business_item_type'] is not None: # noqa: E501
query_params.append(
('businessItemType',
local_var_params['business_item_type'])) # noqa: E501
if 'workflow_task_user_relation' in local_var_params and local_var_params[
'workflow_task_user_relation'] is not None: # noqa: E501
query_params.append((
'workflowTaskUserRelation',
local_var_params['workflow_task_user_relation'])) # noqa: E501
if 'business_item_name' in local_var_params and local_var_params[
'business_item_name'] is not None: # noqa: E501
query_params.append(
('businessItemName',
local_var_params['business_item_name'])) # noqa: E501
if 'user_id' in local_var_params and local_var_params[
'user_id'] is not None: # noqa: E501
query_params.append(
('userId', local_var_params['user_id'])) # noqa: E501
if 'create_date' in local_var_params and local_var_params[
'create_date'] is not None: # noqa: E501
query_params.append(
('createDate', local_var_params['create_date'])) # noqa: E501
if 'due_date' in local_var_params and local_var_params[
'due_date'] is not None: # noqa: E501
query_params.append(
('dueDate', local_var_params['due_date'])) # noqa: E501
if 'title' in local_var_params and local_var_params[
'title'] is not None: # noqa: E501
query_params.append(
('title', local_var_params['title'])) # noqa: E501
if 'type' in local_var_params and local_var_params[
'type'] is not None: # noqa: E501
query_params.append(
('type', local_var_params['type'])) # noqa: E501
if 'sort_field' in local_var_params and local_var_params[
'sort_field'] is not None: # noqa: E501
query_params.append(
('sortField', local_var_params['sort_field'])) # noqa: E501
if 'sort_order' in local_var_params and local_var_params[
'sort_order'] is not None: # noqa: E501
query_params.append(
('sortOrder', local_var_params['sort_order'])) # 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/workflowTasks',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='WorkflowTaskPagedResponse', # 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 add_rating_with_http_info(self, **kwargs): # noqa: E501
"""Add rating. # noqa: E501
Adds a new rating. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_rating_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param AddRatingRequest add_rating_request: The properties of the rating to be added.
: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(Rating, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'add_rating_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 add_rating" % 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
if 'add_rating_request' in local_var_params:
body_params = local_var_params['add_rating_request']
# 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/ratings', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Rating', # 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 find_validation_results_with_http_info(self, **kwargs): # noqa: E501
"""Returns the validation results matching the given search criteria. # noqa: E501
Returns the validation results matching the given search criteria. Only parameters that are specified in this request and have not <code>null</code> values are used for filtering. All other parameters are ignored. The returned validation results satisfy all constraints that are specified in this search criteria. By default a result containing at most 1000 validation results is returned. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_validation_results_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int offset: The first result to retrieve. If not set (offset = <code>0</code>), results will be retrieved starting from row <code>0</code>.
:param int limit: The maximum number of results to retrieve. If not set (limit = <code>0</code>), the default limit will be used.
:param str asset_id: The unique identifier of the asset for which we are searching validation results.
:param str job_id: The unique identifier of the job for which we are searching validation results.
:param str validation_rule_id: The unique identifier of the validation rule for which we are searching validation results.
:param bool most_recent_job: Check the validationResults of only the most recent job according to the other criteria.
:param bool result: Filter on the result of validation 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(ValidationResultPagedResponse, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'offset', 'limit', 'asset_id', 'job_id', 'validation_rule_id',
'most_recent_job', 'result'
]
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 find_validation_results" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
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
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 'asset_id' in local_var_params and local_var_params[
'asset_id'] is not None: # noqa: E501
query_params.append(
('assetId', local_var_params['asset_id'])) # noqa: E501
if 'job_id' in local_var_params and local_var_params[
'job_id'] is not None: # noqa: E501
query_params.append(
('jobId', local_var_params['job_id'])) # noqa: E501
if 'validation_rule_id' in local_var_params and local_var_params[
'validation_rule_id'] is not None: # noqa: E501
query_params.append(
('validationRuleId',
local_var_params['validation_rule_id'])) # noqa: E501
if 'most_recent_job' in local_var_params and local_var_params[
'most_recent_job'] is not None: # noqa: E501
query_params.append(
('mostRecentJob',
local_var_params['most_recent_job'])) # noqa: E501
if 'result' in local_var_params and local_var_params[
'result'] is not None: # noqa: E501
query_params.append(
('result', local_var_params['result'])) # 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 = ['basicAuth'] # noqa: E501
return self.api_client.call_api(
'/validation',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ValidationResultPagedResponse', # 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)
