def request(self, method, url, query_params=None, headers=None,
post_params=None, body=None, _preload_content=True,
_request_timeout=None):
"""Makes the HTTP request using RESTClient."""
if method == "GET":
return self.rest_client.GET(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "HEAD":
return self.rest_client.HEAD(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "OPTIONS":
return self.rest_client.OPTIONS(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout)
elif method == "POST":
return self.rest_client.POST(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PUT":
return self.rest_client.PUT(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PATCH":
return self.rest_client.PATCH(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "DELETE":
return self.rest_client.DELETE(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
else:
raise ApiValueError(
"http method must be `GET`, `HEAD`, `OPTIONS`,"
" `POST`, `PATCH`, `PUT` or `DELETE`."
)
def update_params_for_auth(self, headers, querys, auth_settings):
"""Updates header and query params based on authentication setting.
:param headers: Header parameters dict to be updated.
:param querys: Query parameters tuple list to be updated.
:param auth_settings: Authentication setting identifiers list.
"""
if not auth_settings:
return
for auth in auth_settings:
auth_setting = self.configuration.auth_settings().get(auth)
if auth_setting:
if auth_setting['in'] == 'cookie':
headers['Cookie'] = auth_setting['value']
elif auth_setting['in'] == 'header':
headers[auth_setting['key']] = auth_setting['value']
elif auth_setting['in'] == 'query':
querys.append((auth_setting['key'], auth_setting['value']))
else:
raise ApiValueError(
'Authentication token must be in `query` or `header`')
def get_inbox_forwarder_with_http_info(self, id, **kwargs): # noqa: E501
"""Get an inbox forwarder # noqa: E501
Get inbox ruleset # 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_inbox_forwarder_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: ID of inbox forwarder (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(InboxForwarderDto, 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 get_inbox_forwarder" % 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 `get_inbox_forwarder`"
) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders/{id}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InboxForwarderDto', # 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 empty_inbox_with_http_info(self, inbox_id, **kwargs): # noqa: E501
"""Delete all emails in an inbox # noqa: E501
Deletes all emails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.empty_inbox_with_http_info(inbox_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str inbox_id: inboxId (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 = ['inbox_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 empty_inbox" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'inbox_id' is set
if self.api_client.client_side_validation and (
'inbox_id' not in local_var_params or # noqa: E501
local_var_params['inbox_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `inbox_id` when calling `empty_inbox`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/emptyInbox',
'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_expired_inbox_record_with_http_info(self, expired_id,
**kwargs): # noqa: E501
"""Get an expired inbox record # noqa: E501
Inboxes created with an expiration date will expire after the given date and be moved to an ExpiredInbox entity. You can still read emails in the inbox but it can no longer send or receive emails. Fetch the expired inboxes to view the old inboxes properties # 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_expired_inbox_record_with_http_info(expired_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str expired_id: ID of the ExpiredInboxRecord you want to retrieve. This is different from the ID of the inbox you are interested in. See other methods for getting ExpiredInboxRecord for an inbox inboxId) (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(ExpiredInboxDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['expired_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_expired_inbox_record" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'expired_id' is set
if self.api_client.client_side_validation and (
'expired_id' not in local_var_params or # noqa: E501
local_var_params['expired_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `expired_id` when calling `get_expired_inbox_record`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'expired_id' in local_var_params:
path_params['expiredId'] = local_var_params[
'expired_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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/expired/{expiredId}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ExpiredInboxDto', # 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 request(self,
method,
url,
query_params=None,
headers=None,
body=None,
post_params=None,
_preload_content=True,
_request_timeout=None):
"""Perform requests.
:param method: http request method
:param url: http request url
:param query_params: query parameters in the url
:param headers: http request headers
:param body: request json body, for `application/json`
:param post_params: request post parameters,
`application/x-www-form-urlencoded`
and `multipart/form-data`
: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.
"""
method = method.upper()
assert method in [
'GET', 'HEAD', 'DELETE', 'POST', 'PUT', 'PATCH', 'OPTIONS'
]
if post_params and body:
raise ApiValueError(
"body parameter cannot be used with post_params parameter.")
post_params = post_params or {}
headers = headers or {}
timeout = None
if _request_timeout:
if isinstance(_request_timeout, (int, ) if six.PY3 else
(int, long)): # noqa: E501,F821
timeout = urllib3.Timeout(total=_request_timeout)
elif (isinstance(_request_timeout, tuple)
and len(_request_timeout) == 2):
timeout = urllib3.Timeout(connect=_request_timeout[0],
read=_request_timeout[1])
if 'Content-Type' not in headers:
headers['Content-Type'] = 'application/json'
try:
# For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
if query_params:
url += '?' + urlencode(query_params)
if re.search('json', headers['Content-Type'], re.IGNORECASE):
request_body = None
if body is not None:
request_body = json.dumps(body)
r = self.pool_manager.request(
method,
url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers[
'Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501
r = self.pool_manager.request(
method,
url,
fields=post_params,
encode_multipart=False,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers['Content-Type'] == 'multipart/form-data':
# must del headers['Content-Type'], or the correct
# Content-Type which generated by urllib3 will be
# overwritten.
del headers['Content-Type']
r = self.pool_manager.request(
method,
url,
fields=post_params,
encode_multipart=True,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
# Pass a `string` parameter directly in the body to support
# other content types than Json when `body` argument is
# provided in serialized form
elif isinstance(body, str) or isinstance(body, bytes):
request_body = body
r = self.pool_manager.request(
method,
url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
else:
# Cannot generate the request from given parameters
msg = """Cannot prepare a request message for provided
arguments. Please check that your arguments match
declared content type."""
raise ApiException(status=0, reason=msg)
# For `GET`, `HEAD`
else:
r = self.pool_manager.request(method,
url,
fields=query_params,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
except urllib3.exceptions.SSLError as e:
msg = "{0}\n{1}".format(type(e).__name__, str(e))
raise ApiException(status=0, reason=msg)
if _preload_content:
r = RESTResponse(r)
# log response body
logger.debug("response body: %s", r.data)
if not 200 <= r.status <= 299:
raise ApiException(http_resp=r)
return r
def filter_bounced_recipient_with_http_info(self, filter_bounced_recipients_options, **kwargs): # noqa: E501
"""Filter a list of email recipients and remove those who have bounced # noqa: E501
Prevent email sending errors by remove recipients who have resulted in past email bounces or complaints # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.filter_bounced_recipient_with_http_info(filter_bounced_recipients_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param FilterBouncedRecipientsOptions filter_bounced_recipients_options: (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(FilterBouncedRecipientsResult, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'filter_bounced_recipients_options'
]
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 filter_bounced_recipient" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'filter_bounced_recipients_options' is set
if self.api_client.client_side_validation and ('filter_bounced_recipients_options' not in local_var_params or # noqa: E501
local_var_params['filter_bounced_recipients_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `filter_bounced_recipients_options` when calling `filter_bounced_recipient`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'filter_bounced_recipients_options' in local_var_params:
body_params = local_var_params['filter_bounced_recipients_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bounce/filter-recipients', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='FilterBouncedRecipientsResult', # 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 bulk_send_emails_with_http_info(self, bulk_send_email_options,
**kwargs): # noqa: E501
"""Bulk Send Emails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bulk_send_emails_with_http_info(bulk_send_email_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param BulkSendEmailOptions bulk_send_email_options: bulkSendEmailOptions (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 = ['bulk_send_email_options']
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 bulk_send_emails" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'bulk_send_email_options' is set
if self.api_client.client_side_validation and (
'bulk_send_email_options' not in local_var_params
or # noqa: E501
local_var_params['bulk_send_email_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `bulk_send_email_options` when calling `bulk_send_emails`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'bulk_send_email_options' in local_var_params:
body_params = local_var_params['bulk_send_email_options']
# 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bulk/send',
'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 export_entities_with_http_info(self, export_type, api_key,
output_format, **kwargs): # noqa: E501
"""Export inboxes link callable via browser # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.export_entities_with_http_info(export_type, api_key, output_format, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str export_type: (required)
:param str api_key: (required)
:param str output_format: (required)
:param str filter:
:param str list_separator_token:
:param bool exclude_previously_exported:
:param datetime created_earliest_time:
:param datetime created_oldest_time:
: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[str], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'export_type', 'api_key', 'output_format', 'filter',
'list_separator_token', 'exclude_previously_exported',
'created_earliest_time', 'created_oldest_time'
]
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 export_entities" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'export_type' is set
if self.api_client.client_side_validation and (
'export_type' not in local_var_params or # noqa: E501
local_var_params['export_type'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_type` when calling `export_entities`"
) # noqa: E501
# verify the required parameter 'api_key' is set
if self.api_client.client_side_validation and (
'api_key' not in local_var_params or # noqa: E501
local_var_params['api_key'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `api_key` when calling `export_entities`"
) # noqa: E501
# verify the required parameter 'output_format' is set
if self.api_client.client_side_validation and (
'output_format' not in local_var_params or # noqa: E501
local_var_params['output_format'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `output_format` when calling `export_entities`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'export_type' in local_var_params and local_var_params[
'export_type'] is not None: # noqa: E501
query_params.append(
('exportType', local_var_params['export_type'])) # noqa: E501
if 'api_key' in local_var_params and local_var_params[
'api_key'] is not None: # noqa: E501
query_params.append(
('apiKey', local_var_params['api_key'])) # noqa: E501
if 'output_format' in local_var_params and local_var_params[
'output_format'] is not None: # noqa: E501
query_params.append(
('outputFormat',
local_var_params['output_format'])) # noqa: E501
if 'filter' in local_var_params and local_var_params[
'filter'] is not None: # noqa: E501
query_params.append(
('filter', local_var_params['filter'])) # noqa: E501
if 'list_separator_token' in local_var_params and local_var_params[
'list_separator_token'] is not None: # noqa: E501
query_params.append(
('listSeparatorToken',
local_var_params['list_separator_token'])) # noqa: E501
if 'exclude_previously_exported' in local_var_params and local_var_params[
'exclude_previously_exported'] is not None: # noqa: E501
query_params.append((
'excludePreviouslyExported',
local_var_params['exclude_previously_exported'])) # noqa: E501
if 'created_earliest_time' in local_var_params and local_var_params[
'created_earliest_time'] is not None: # noqa: E501
query_params.append(
('createdEarliestTime',
local_var_params['created_earliest_time'])) # noqa: E501
if 'created_oldest_time' in local_var_params and local_var_params[
'created_oldest_time'] is not None: # noqa: E501
query_params.append(
('createdOldestTime',
local_var_params['created_oldest_time'])) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/export',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[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_group_with_contacts_paginated_with_http_info(
self, group_id, **kwargs): # noqa: E501
"""Get group and paginated contacts belonging to it # 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_group_with_contacts_paginated_with_http_info(group_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str group_id: groupId (required)
:param int page: Optional page index in group contact pagination
:param int size: Optional page size in group contact pagination
:param str sort: Optional createdAt sort direction ASC or DESC
: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(PageContactProjection, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['group_id', 'page', 'size', 'sort']
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_group_with_contacts_paginated" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'group_id' is set
if self.api_client.client_side_validation and (
'group_id' not in local_var_params or # noqa: E501
local_var_params['group_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `group_id` when calling `get_group_with_contacts_paginated`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'group_id' in local_var_params:
path_params['groupId'] = local_var_params['group_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
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
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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/groups/{groupId}/contacts-paginated',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageContactProjection', # 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 create_tracking_pixel_with_http_info(self,
create_tracking_pixel_options,
**kwargs): # noqa: E501
"""Create tracking pixel # noqa: E501
Create a tracking pixel. A tracking pixel is an image that can be embedded in an email. When the email is viewed and the image is seen MailSlurp will mark the pixel as seen. Use tracking pixels to monitor email open events. You can receive open notifications via webhook or by fetching the pixel. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_tracking_pixel_with_http_info(create_tracking_pixel_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateTrackingPixelOptions create_tracking_pixel_options: (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(TrackingPixelDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_tracking_pixel_options']
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 create_tracking_pixel" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_tracking_pixel_options' is set
if self.api_client.client_side_validation and (
'create_tracking_pixel_options' not in local_var_params
or # noqa: E501
local_var_params['create_tracking_pixel_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_tracking_pixel_options` when calling `create_tracking_pixel`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_tracking_pixel_options' in local_var_params:
body_params = local_var_params['create_tracking_pixel_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/tracking/pixels',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TrackingPixelDto', # 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 wait_for_nth_missed_email_with_http_info(self, index,
**kwargs): # noqa: E501
"""Wait for Nth missed email # noqa: E501
Wait for 0 based index missed email # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_nth_missed_email_with_http_info(index, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int index: Zero based index of the email to wait for. If 1 missed email already and you want to wait for the 2nd email pass index=1 (required)
:param str inbox_id: Optional inbox ID filter
:param int timeout: Optional timeout milliseconds
:param datetime since: Filter by created at after the given timestamp
:param datetime before: Filter by created at before the given timestamp
: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(MissedEmail, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['index', 'inbox_id', 'timeout', 'since', 'before']
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 wait_for_nth_missed_email" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'index' is set
if self.api_client.client_side_validation and (
'index' not in local_var_params or # noqa: E501
local_var_params['index'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `index` when calling `wait_for_nth_missed_email`"
) # noqa: E501
if self.api_client.client_side_validation and 'index' in local_var_params and local_var_params[
'index'] > 2147483647: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `index` when calling `wait_for_nth_missed_email`, must be a value less than or equal to `2147483647`"
) # noqa: E501
if self.api_client.client_side_validation and 'index' in local_var_params and local_var_params[
'index'] < 0: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `index` when calling `wait_for_nth_missed_email`, must be a value greater than or equal to `0`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'timeout' in local_var_params and local_var_params[
'timeout'] is not None: # noqa: E501
query_params.append(
('timeout', local_var_params['timeout'])) # noqa: E501
if 'index' in local_var_params and local_var_params[
'index'] is not None: # noqa: E501
query_params.append(
('index', local_var_params['index'])) # noqa: E501
if 'since' in local_var_params and local_var_params[
'since'] is not None: # noqa: E501
query_params.append(
('since', local_var_params['since'])) # noqa: E501
if 'before' in local_var_params and local_var_params[
'before'] is not None: # noqa: E501
query_params.append(
('before', local_var_params['before'])) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/missed-emails/waitForNthMissedEmail',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='MissedEmail', # 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_domain_with_http_info(self, id, update_domain_options,
**kwargs): # noqa: E501
"""Update a domain # noqa: E501
Update values on a domain. Note you cannot change the domain name as it is immutable. Recreate the domain if you need to alter this. # 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_domain_with_http_info(id, update_domain_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: (required)
:param UpdateDomainOptions update_domain_options: (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(DomainDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id', 'update_domain_options']
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_domain" % 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 `update_domain`"
) # noqa: E501
# verify the required parameter 'update_domain_options' is set
if self.api_client.client_side_validation and (
'update_domain_options' not in local_var_params
or # noqa: E501
local_var_params['update_domain_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `update_domain_options` when calling `update_domain`"
) # 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
if 'update_domain_options' in local_var_params:
body_params = local_var_params['update_domain_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/domains/{id}',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DomainDto', # 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 create_domain_with_http_info(self, create_domain_options,
**kwargs): # noqa: E501
"""Create Domain # noqa: E501
Link a domain that you own with MailSlurp so you can create email addresses using it. Endpoint returns DNS records used for validation. You must add these verification records to your host provider's DNS setup to verify the domain. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_domain_with_http_info(create_domain_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateDomainOptions create_domain_options: (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(DomainDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_domain_options']
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 create_domain" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_domain_options' is set
if self.api_client.client_side_validation and (
'create_domain_options' not in local_var_params
or # noqa: E501
local_var_params['create_domain_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_domain_options` when calling `create_domain`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_domain_options' in local_var_params:
body_params = local_var_params['create_domain_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/domains',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DomainDto', # 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 create_new_inbox_forwarder_with_http_info(
self, create_inbox_forwarder_options, **kwargs): # noqa: E501
"""Create an inbox forwarder # noqa: E501
Create a new inbox rule for forwarding, blocking, and allowing emails when sending and receiving # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_new_inbox_forwarder_with_http_info(create_inbox_forwarder_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateInboxForwarderOptions create_inbox_forwarder_options: createInboxForwarderOptions (required)
:param str inbox_id: Inbox id to attach forwarder 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(InboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_inbox_forwarder_options', 'inbox_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 create_new_inbox_forwarder" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_inbox_forwarder_options' is set
if self.api_client.client_side_validation and (
'create_inbox_forwarder_options' not in local_var_params
or # noqa: E501
local_var_params['create_inbox_forwarder_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_inbox_forwarder_options` when calling `create_new_inbox_forwarder`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_inbox_forwarder_options' in local_var_params:
body_params = local_var_params['create_inbox_forwarder_options']
# 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InboxForwarderDto', # 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_export_link_with_http_info(self, export_type, export_options,
**kwargs): # noqa: E501
"""Get export link # 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_export_link_with_http_info(export_type, export_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str export_type: (required)
:param ExportOptions export_options: (required)
:param str api_key:
: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(ExportLink, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['export_type', 'export_options', 'api_key']
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_export_link" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'export_type' is set
if self.api_client.client_side_validation and (
'export_type' not in local_var_params or # noqa: E501
local_var_params['export_type'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_type` when calling `get_export_link`"
) # noqa: E501
# verify the required parameter 'export_options' is set
if self.api_client.client_side_validation and (
'export_options' not in local_var_params or # noqa: E501
local_var_params['export_options'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_options` when calling `get_export_link`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'export_type' in local_var_params and local_var_params[
'export_type'] is not None: # noqa: E501
query_params.append(
('exportType', local_var_params['export_type'])) # noqa: E501
if 'api_key' in local_var_params and local_var_params[
'api_key'] is not None: # noqa: E501
query_params.append(
('apiKey', local_var_params['api_key'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'export_options' in local_var_params:
body_params = local_var_params['export_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/export',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ExportLink', # 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_contacts_from_group_with_http_info(self, group_id,
update_group_contacts_option,
**kwargs): # noqa: E501
"""Remove contacts from a 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.remove_contacts_from_group_with_http_info(group_id, update_group_contacts_option, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str group_id: groupId (required)
:param UpdateGroupContacts update_group_contacts_option: updateGroupContactsOption (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(GroupContactsDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['group_id', 'update_group_contacts_option']
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_contacts_from_group" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'group_id' is set
if self.api_client.client_side_validation and (
'group_id' not in local_var_params or # noqa: E501
local_var_params['group_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `group_id` when calling `remove_contacts_from_group`"
) # noqa: E501
# verify the required parameter 'update_group_contacts_option' is set
if self.api_client.client_side_validation and (
'update_group_contacts_option' not in local_var_params
or # noqa: E501
local_var_params['update_group_contacts_option'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `update_group_contacts_option` when calling `remove_contacts_from_group`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'group_id' in local_var_params:
path_params['groupId'] = local_var_params['group_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'update_group_contacts_option' in local_var_params:
body_params = local_var_params['update_group_contacts_option']
# 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/groups/{groupId}/contacts',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='GroupContactsDto', # 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 verify_email_address_with_http_info(self, verify_email_address_options, **kwargs): # noqa: E501
"""Deprecated. Use the EmailVerificationController methods for more accurate and reliable functionality. Verify the existence of an email address at a given mail server. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verify_email_address_with_http_info(verify_email_address_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param VerifyEmailAddressOptions verify_email_address_options: (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(EmailVerificationResult, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'verify_email_address_options'
]
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 verify_email_address" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'verify_email_address_options' is set
if self.api_client.client_side_validation and ('verify_email_address_options' not in local_var_params or # noqa: E501
local_var_params['verify_email_address_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `verify_email_address_options` when calling `verify_email_address`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'verify_email_address_options' in local_var_params:
body_params = local_var_params['verify_email_address_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/mail-server/verify/email-address', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='EmailVerificationResult', # 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_validation_requests_with_http_info(self, **kwargs): # noqa: E501
"""Validate a list of email addresses. Per unit billing. See your plan for pricing. # 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_validation_requests_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int page: Optional page index in list pagination
:param int size: Optional page size for paginated result list.
:param str sort: Optional createdAt sort direction ASC or DESC
:param str search_filter: Optional search filter
:param datetime since: Filter by created at after the given timestamp
:param datetime before: Filter by created at before the given timestamp
:param bool is_valid: Filter where email is valid is true or false
: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(PageEmailValidationRequest, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'page', 'size', 'sort', 'search_filter', 'since', 'before',
'is_valid'
]
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_validation_requests" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params[
'page'] > 9223372036854775807: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `page` when calling `get_validation_requests`, must be a value less than or equal to `9223372036854775807`"
) # noqa: E501
if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params[
'page'] < 0: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `page` when calling `get_validation_requests`, must be a value greater than or equal to `0`"
) # noqa: E501
if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params[
'size'] > 100: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `size` when calling `get_validation_requests`, must be a value less than or equal to `100`"
) # noqa: E501
if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params[
'size'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `size` when calling `get_validation_requests`, must be a value greater than or equal to `1`"
) # noqa: E501
collection_formats = {}
path_params = {}
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
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 'search_filter' in local_var_params and local_var_params[
'search_filter'] is not None: # noqa: E501
query_params.append(
('searchFilter',
local_var_params['search_filter'])) # noqa: E501
if 'since' in local_var_params and local_var_params[
'since'] is not None: # noqa: E501
query_params.append(
('since', local_var_params['since'])) # noqa: E501
if 'before' in local_var_params and local_var_params[
'before'] is not None: # noqa: E501
query_params.append(
('before', local_var_params['before'])) # noqa: E501
if 'is_valid' in local_var_params and local_var_params[
'is_valid'] is not None: # noqa: E501
query_params.append(
('isValid', local_var_params['is_valid'])) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/email-verification/validation-requests',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageEmailValidationRequest', # 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 bulk_create_inboxes_with_http_info(self, count,
**kwargs): # noqa: E501
"""Bulk create Inboxes (email addresses) # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bulk_create_inboxes_with_http_info(count, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int count: Number of inboxes to be created in bulk (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(list[Inbox], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['count']
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 bulk_create_inboxes" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'count' is set
if self.api_client.client_side_validation and (
'count' not in local_var_params or # noqa: E501
local_var_params['count'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `count` when calling `bulk_create_inboxes`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'count' in local_var_params and local_var_params[
'count'] is not None: # noqa: E501
query_params.append(
('count', local_var_params['count'])) # 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bulk/inboxes',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[Inbox]', # 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 wait_for_matching_first_email_with_http_info(self, match_options, **kwargs): # noqa: E501
"""Wait for or return the first email that matches provided MatchOptions array # noqa: E501
Perform a search of emails in an inbox with the given patterns. If a result if found then return or else retry the search until a result is found or timeout is reached. Match options allow simple CONTAINS or EQUALS filtering on SUBJECT, TO, BCC, CC, and FROM. See the `MatchOptions` object for options. An example payload is `{ matches: [{field: 'SUBJECT',should:'CONTAIN',value:'needle'}] }`. You can use an array of matches and they will be applied sequentially to filter out emails. If you want to perform matches and extractions of content using Regex patterns see the EmailController `getEmailContentMatch` method. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_matching_first_email_with_http_info(match_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param MatchOptions match_options: matchOptions (required)
:param int delay: Max milliseconds delay between calls
:param str inbox_id: Id of the inbox we are matching an email for
:param datetime since: Filter for emails that were received after the given timestamp
:param str sort: Sort direction
:param int timeout: Max milliseconds to wait
:param bool unread_only: Optional filter for unread only
: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(Email, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'match_options',
'delay',
'inbox_id',
'since',
'sort',
'timeout',
'unread_only'
]
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 wait_for_matching_first_email" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'match_options' is set
if self.api_client.client_side_validation and ('match_options' not in local_var_params or # noqa: E501
local_var_params['match_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `match_options` when calling `wait_for_matching_first_email`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'delay' in local_var_params and local_var_params['delay'] is not None: # noqa: E501
query_params.append(('delay', local_var_params['delay'])) # noqa: E501
if 'inbox_id' in local_var_params and local_var_params['inbox_id'] is not None: # noqa: E501
query_params.append(('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'since' in local_var_params and local_var_params['since'] is not None: # noqa: E501
query_params.append(('since', local_var_params['since'])) # 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 'timeout' in local_var_params and local_var_params['timeout'] is not None: # noqa: E501
query_params.append(('timeout', local_var_params['timeout'])) # noqa: E501
if 'unread_only' in local_var_params and local_var_params['unread_only'] is not None: # noqa: E501
query_params.append(('unreadOnly', local_var_params['unread_only'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'match_options' in local_var_params:
body_params = local_var_params['match_options']
# 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 = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/waitForMatchingFirstEmail', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Email', # 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)