def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_aem_product_info(
self,
**kwargs
):
"""get_aem_product_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.get_aem_product_info(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[str]
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_aem_product_info = Endpoint(
settings={
'response_type': ([str],),
'auth': [
'aemAuth'
],
'endpoint_path': '/system/console/status-productinfo.json',
'operation_id': 'get_aem_product_info',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__get_aem_product_info
)
def __get_config_mgr(
self,
**kwargs
):
"""get_config_mgr # 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_config_mgr(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_config_mgr = Endpoint(
settings={
'response_type': (str,),
'auth': [
'aemAuth'
],
'endpoint_path': '/system/console/configMgr',
'operation_id': 'get_config_mgr',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'text/xml'
],
'content_type': [],
},
api_client=api_client,
callable=__get_config_mgr
)
def __post_bundle(
self,
name,
action,
**kwargs
):
"""post_bundle # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_bundle(name, action, async_req=True)
>>> result = thread.get()
Args:
name (str):
action (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['name'] = \
name
kwargs['action'] = \
action
return self.call_with_http_info(**kwargs)
self.post_bundle = Endpoint(
settings={
'response_type': None,
'auth': [
'aemAuth'
],
'endpoint_path': '/system/console/bundles/{name}',
'operation_id': 'post_bundle',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'name',
'action',
],
'required': [
'name',
'action',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'action':
(str,),
},
'attribute_map': {
'name': 'name',
'action': 'action',
},
'location_map': {
'name': 'path',
'action': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__post_bundle
)
def __post_jmx_repository(
self,
action,
**kwargs
):
"""post_jmx_repository # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_jmx_repository(action, async_req=True)
>>> result = thread.get()
Args:
action (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['action'] = \
action
return self.call_with_http_info(**kwargs)
self.post_jmx_repository = Endpoint(
settings={
'response_type': None,
'auth': [
'aemAuth'
],
'endpoint_path': '/system/console/jmx/com.adobe.granite:type=Repository/op/{action}',
'operation_id': 'post_jmx_repository',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'action',
],
'required': [
'action',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'action':
(str,),
},
'attribute_map': {
'action': 'action',
},
'location_map': {
'action': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__post_jmx_repository
)
def __post_saml_configuration(
self,
**kwargs
):
"""post_saml_configuration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_saml_configuration(async_req=True)
>>> result = thread.get()
Keyword Args:
post (bool): [optional]
apply (bool): [optional]
delete (bool): [optional]
action (str): [optional]
location (str): [optional]
path ([str]): [optional]
service_ranking (int): [optional]
idp_url (str): [optional]
idp_cert_alias (str): [optional]
idp_http_redirect (bool): [optional]
service_provider_entity_id (str): [optional]
assertion_consumer_service_url (str): [optional]
sp_private_key_alias (str): [optional]
key_store_password (str): [optional]
default_redirect_url (str): [optional]
user_id_attribute (str): [optional]
use_encryption (bool): [optional]
create_user (bool): [optional]
add_group_memberships (bool): [optional]
group_membership_attribute (str): [optional]
default_groups ([str]): [optional]
name_id_format (str): [optional]
synchronize_attributes ([str]): [optional]
handle_logout (bool): [optional]
logout_url (str): [optional]
clock_tolerance (int): [optional]
digest_method (str): [optional]
signature_method (str): [optional]
user_intermediate_path (str): [optional]
propertylist ([str]): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
SamlConfigurationInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.post_saml_configuration = Endpoint(
settings={
'response_type': (SamlConfigurationInfo,),
'auth': [
'aemAuth'
],
'endpoint_path': '/system/console/configMgr/com.adobe.granite.auth.saml.SamlAuthenticationHandler',
'operation_id': 'post_saml_configuration',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'post',
'apply',
'delete',
'action',
'location',
'path',
'service_ranking',
'idp_url',
'idp_cert_alias',
'idp_http_redirect',
'service_provider_entity_id',
'assertion_consumer_service_url',
'sp_private_key_alias',
'key_store_password',
'default_redirect_url',
'user_id_attribute',
'use_encryption',
'create_user',
'add_group_memberships',
'group_membership_attribute',
'default_groups',
'name_id_format',
'synchronize_attributes',
'handle_logout',
'logout_url',
'clock_tolerance',
'digest_method',
'signature_method',
'user_intermediate_path',
'propertylist',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'post':
(bool,),
'apply':
(bool,),
'delete':
(bool,),
'action':
(str,),
'location':
(str,),
'path':
([str],),
'service_ranking':
(int,),
'idp_url':
(str,),
'idp_cert_alias':
(str,),
'idp_http_redirect':
(bool,),
'service_provider_entity_id':
(str,),
'assertion_consumer_service_url':
(str,),
'sp_private_key_alias':
(str,),
'key_store_password':
(str,),
'default_redirect_url':
(str,),
'user_id_attribute':
(str,),
'use_encryption':
(bool,),
'create_user':
(bool,),
'add_group_memberships':
(bool,),
'group_membership_attribute':
(str,),
'default_groups':
([str],),
'name_id_format':
(str,),
'synchronize_attributes':
([str],),
'handle_logout':
(bool,),
'logout_url':
(str,),
'clock_tolerance':
(int,),
'digest_method':
(str,),
'signature_method':
(str,),
'user_intermediate_path':
(str,),
'propertylist':
([str],),
},
'attribute_map': {
'post': 'post',
'apply': 'apply',
'delete': 'delete',
'action': 'action',
'location': '$location',
'path': 'path',
'service_ranking': 'service.ranking',
'idp_url': 'idpUrl',
'idp_cert_alias': 'idpCertAlias',
'idp_http_redirect': 'idpHttpRedirect',
'service_provider_entity_id': 'serviceProviderEntityId',
'assertion_consumer_service_url': 'assertionConsumerServiceURL',
'sp_private_key_alias': 'spPrivateKeyAlias',
'key_store_password': '******',
'default_redirect_url': 'defaultRedirectUrl',
'user_id_attribute': 'userIDAttribute',
'use_encryption': 'useEncryption',
'create_user': '******',
'add_group_memberships': 'addGroupMemberships',
'group_membership_attribute': 'groupMembershipAttribute',
'default_groups': 'defaultGroups',
'name_id_format': 'nameIdFormat',
'synchronize_attributes': 'synchronizeAttributes',
'handle_logout': 'handleLogout',
'logout_url': 'logoutUrl',
'clock_tolerance': 'clockTolerance',
'digest_method': 'digestMethod',
'signature_method': 'signatureMethod',
'user_intermediate_path': 'userIntermediatePath',
'propertylist': 'propertylist',
},
'location_map': {
'post': 'query',
'apply': 'query',
'delete': 'query',
'action': 'query',
'location': 'query',
'path': 'query',
'service_ranking': 'query',
'idp_url': 'query',
'idp_cert_alias': 'query',
'idp_http_redirect': 'query',
'service_provider_entity_id': 'query',
'assertion_consumer_service_url': 'query',
'sp_private_key_alias': 'query',
'key_store_password': '******',
'default_redirect_url': 'query',
'user_id_attribute': 'query',
'use_encryption': 'query',
'create_user': '******',
'add_group_memberships': 'query',
'group_membership_attribute': 'query',
'default_groups': 'query',
'name_id_format': 'query',
'synchronize_attributes': 'query',
'handle_logout': 'query',
'logout_url': 'query',
'clock_tolerance': 'query',
'digest_method': 'query',
'signature_method': 'query',
'user_intermediate_path': 'query',
'propertylist': 'query',
},
'collection_format_map': {
'path': 'multi',
'default_groups': 'multi',
'synchronize_attributes': 'multi',
'propertylist': 'csv',
}
},
headers_map={
'accept': [
'text/plain'
],
'content_type': [],
},
api_client=api_client,
callable=__post_saml_configuration
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_login_page(self, **kwargs):
"""get_login_page # 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_login_page(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_login_page = Endpoint(settings={
'response_type': (str, ),
'auth': [],
'endpoint_path': '/libs/granite/core/content/login.html',
'operation_id': 'get_login_page',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['text/html'],
'content_type': [],
},
api_client=api_client,
callable=__get_login_page)
def __post_cq_actions(self, authorizable_id, changelog, **kwargs):
"""post_cq_actions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_cq_actions(authorizable_id, changelog, async_req=True)
>>> result = thread.get()
Args:
authorizable_id (str):
changelog (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['authorizable_id'] = \
authorizable_id
kwargs['changelog'] = \
changelog
return self.call_with_http_info(**kwargs)
self.post_cq_actions = Endpoint(settings={
'response_type': None,
'auth': ['aemAuth'],
'endpoint_path': '/.cqactions.html',
'operation_id': 'post_cq_actions',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'authorizable_id',
'changelog',
],
'required': [
'authorizable_id',
'changelog',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'authorizable_id': (str, ),
'changelog': (str, ),
},
'attribute_map': {
'authorizable_id':
'authorizableId',
'changelog': 'changelog',
},
'location_map': {
'authorizable_id': 'query',
'changelog': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__post_cq_actions)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_crxde_status(self, **kwargs):
"""get_crxde_status # 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_crxde_status(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_crxde_status = Endpoint(settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/server/crx.default/jcr:root/.1.json',
'operation_id': 'get_crxde_status',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['plain/text'],
'content_type': [],
},
api_client=api_client,
callable=__get_crxde_status)
def __get_install_status(self, **kwargs):
"""get_install_status # 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_install_status(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
InstallStatus
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_install_status = Endpoint(settings={
'response_type': (InstallStatus, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/packmgr/installstatus.jsp',
'operation_id': 'get_install_status',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_install_status)
def __get_package_manager_servlet(self, **kwargs):
"""get_package_manager_servlet # 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_package_manager_servlet(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_package_manager_servlet = Endpoint(
settings={
'response_type': None,
'auth': ['aemAuth'],
'endpoint_path': '/crx/packmgr/service/script.html',
'operation_id': 'get_package_manager_servlet',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['text/html'],
'content_type': [],
},
api_client=api_client,
callable=__get_package_manager_servlet)
def __post_package_service(self, cmd, **kwargs):
"""post_package_service # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_package_service(cmd, async_req=True)
>>> result = thread.get()
Args:
cmd (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cmd'] = \
cmd
return self.call_with_http_info(**kwargs)
self.post_package_service = Endpoint(settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/packmgr/service.jsp',
'operation_id': 'post_package_service',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'cmd',
],
'required': [
'cmd',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'cmd': (str, ),
},
'attribute_map': {
'cmd': 'cmd',
},
'location_map': {
'cmd': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['text/xml'],
'content_type': [],
},
api_client=api_client,
callable=__post_package_service)
def __post_package_service_json(self, path, cmd, **kwargs):
"""post_package_service_json # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_package_service_json(path, cmd, async_req=True)
>>> result = thread.get()
Args:
path (str):
cmd (str):
Keyword Args:
group_name (str): [optional]
package_name (str): [optional]
package_version (str): [optional]
charset_ (str): [optional]
force (bool): [optional]
recursive (bool): [optional]
package (file_type): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['path'] = \
path
kwargs['cmd'] = \
cmd
return self.call_with_http_info(**kwargs)
self.post_package_service_json = Endpoint(
settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/packmgr/service/.json/{path}',
'operation_id': 'post_package_service_json',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'path',
'cmd',
'group_name',
'package_name',
'package_version',
'charset_',
'force',
'recursive',
'package',
],
'required': [
'path',
'cmd',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'path': (str, ),
'cmd': (str, ),
'group_name': (str, ),
'package_name': (str, ),
'package_version': (str, ),
'charset_': (str, ),
'force': (bool, ),
'recursive': (bool, ),
'package': (file_type, ),
},
'attribute_map': {
'path': 'path',
'cmd': 'cmd',
'group_name': 'groupName',
'package_name': 'packageName',
'package_version': 'packageVersion',
'charset_': '_charset_',
'force': 'force',
'recursive': 'recursive',
'package': 'package',
},
'location_map': {
'path': 'path',
'cmd': 'query',
'group_name': 'query',
'package_name': 'query',
'package_version': 'query',
'charset_': 'query',
'force': 'query',
'recursive': 'query',
'package': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__post_package_service_json)
def __post_package_update(self, group_name, package_name, version,
path, **kwargs):
"""post_package_update # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_package_update(group_name, package_name, version, path, async_req=True)
>>> result = thread.get()
Args:
group_name (str):
package_name (str):
version (str):
path (str):
Keyword Args:
filter (str): [optional]
charset_ (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['group_name'] = \
group_name
kwargs['package_name'] = \
package_name
kwargs['version'] = \
version
kwargs['path'] = \
path
return self.call_with_http_info(**kwargs)
self.post_package_update = Endpoint(settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/packmgr/update.jsp',
'operation_id': 'post_package_update',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'group_name',
'package_name',
'version',
'path',
'filter',
'charset_',
],
'required': [
'group_name',
'package_name',
'version',
'path',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'group_name': (str, ),
'package_name': (str, ),
'version': (str, ),
'path': (str, ),
'filter': (str, ),
'charset_': (str, ),
},
'attribute_map': {
'group_name': 'groupName',
'package_name':
'packageName',
'version': 'version',
'path': 'path',
'filter': 'filter',
'charset_': '_charset_',
},
'location_map': {
'group_name': 'query',
'package_name': 'query',
'version': 'query',
'path': 'query',
'filter': 'query',
'charset_': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__post_package_update)
def __post_set_password(self, old, plain, verify, **kwargs):
"""post_set_password # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_set_password(old, plain, verify, async_req=True)
>>> result = thread.get()
Args:
old (str):
plain (str):
verify (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['old'] = \
old
kwargs['plain'] = \
plain
kwargs['verify'] = \
verify
return self.call_with_http_info(**kwargs)
self.post_set_password = Endpoint(settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/crx/explorer/ui/setpassword.jsp',
'operation_id': 'post_set_password',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'old',
'plain',
'verify',
],
'required': [
'old',
'plain',
'verify',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'old': (str, ),
'plain': (str, ),
'verify': (str, ),
},
'attribute_map': {
'old': 'old',
'plain': 'plain',
'verify': 'verify',
},
'location_map': {
'old': 'query',
'plain': 'query',
'verify': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['text/plain'],
'content_type': [],
},
api_client=api_client,
callable=__post_set_password)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_aem_health_check(
self,
**kwargs
):
"""get_aem_health_check # 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_aem_health_check(async_req=True)
>>> result = thread.get()
Keyword Args:
tags (str): [optional]
combine_tags_or (bool): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.get_aem_health_check = Endpoint(
settings={
'response_type': (str,),
'auth': [
'aemAuth'
],
'endpoint_path': '/system/health',
'operation_id': 'get_aem_health_check',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'tags',
'combine_tags_or',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'tags':
(str,),
'combine_tags_or':
(bool,),
},
'attribute_map': {
'tags': 'tags',
'combine_tags_or': 'combineTagsOr',
},
'location_map': {
'tags': 'query',
'combine_tags_or': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__get_aem_health_check
)
def __post_config_aem_health_check_servlet(
self,
**kwargs
):
"""post_config_aem_health_check_servlet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_config_aem_health_check_servlet(async_req=True)
>>> result = thread.get()
Keyword Args:
bundles_ignored ([str]): [optional]
bundles_ignored_type_hint (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.post_config_aem_health_check_servlet = Endpoint(
settings={
'response_type': None,
'auth': [
'aemAuth'
],
'endpoint_path': '/apps/system/config/com.shinesolutions.healthcheck.hc.impl.ActiveBundleHealthCheck',
'operation_id': 'post_config_aem_health_check_servlet',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'bundles_ignored',
'bundles_ignored_type_hint',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'bundles_ignored':
([str],),
'bundles_ignored_type_hint':
(str,),
},
'attribute_map': {
'bundles_ignored': 'bundles.ignored',
'bundles_ignored_type_hint': 'bundles.ignored@TypeHint',
},
'location_map': {
'bundles_ignored': 'query',
'bundles_ignored_type_hint': 'query',
},
'collection_format_map': {
'bundles_ignored': 'multi',
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__post_config_aem_health_check_servlet
)
def __post_config_aem_password_reset(
self,
**kwargs
):
"""post_config_aem_password_reset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.post_config_aem_password_reset(async_req=True)
>>> result = thread.get()
Keyword Args:
pwdreset_authorizables ([str]): [optional]
pwdreset_authorizables_type_hint (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.post_config_aem_password_reset = Endpoint(
settings={
'response_type': None,
'auth': [
'aemAuth'
],
'endpoint_path': '/apps/system/config/com.shinesolutions.aem.passwordreset.Activator',
'operation_id': 'post_config_aem_password_reset',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'pwdreset_authorizables',
'pwdreset_authorizables_type_hint',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'pwdreset_authorizables':
([str],),
'pwdreset_authorizables_type_hint':
(str,),
},
'attribute_map': {
'pwdreset_authorizables': 'pwdreset.authorizables',
'pwdreset_authorizables_type_hint': 'pwdreset.authorizables@TypeHint',
},
'location_map': {
'pwdreset_authorizables': 'query',
'pwdreset_authorizables_type_hint': 'query',
},
'collection_format_map': {
'pwdreset_authorizables': 'multi',
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__post_config_aem_password_reset
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __ssl_setup(self, keystore_password, keystore_password_confirm,
truststore_password, truststore_password_confirm,
https_hostname, https_port, **kwargs):
"""ssl_setup # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.ssl_setup(keystore_password, keystore_password_confirm, truststore_password, truststore_password_confirm, https_hostname, https_port, async_req=True)
>>> result = thread.get()
Args:
keystore_password (str):
keystore_password_confirm (str):
truststore_password (str):
truststore_password_confirm (str):
https_hostname (str):
https_port (str):
Keyword Args:
privatekey_file (file_type): [optional]
certificate_file (file_type): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): 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.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
str
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['keystore_password'] = \
keystore_password
kwargs['keystore_password_confirm'] = \
keystore_password_confirm
kwargs['truststore_password'] = \
truststore_password
kwargs['truststore_password_confirm'] = \
truststore_password_confirm
kwargs['https_hostname'] = \
https_hostname
kwargs['https_port'] = \
https_port
return self.call_with_http_info(**kwargs)
self.ssl_setup = Endpoint(
settings={
'response_type': (str, ),
'auth': ['aemAuth'],
'endpoint_path': '/libs/granite/security/post/sslSetup.html',
'operation_id': 'ssl_setup',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'keystore_password',
'keystore_password_confirm',
'truststore_password',
'truststore_password_confirm',
'https_hostname',
'https_port',
'privatekey_file',
'certificate_file',
],
'required': [
'keystore_password',
'keystore_password_confirm',
'truststore_password',
'truststore_password_confirm',
'https_hostname',
'https_port',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'keystore_password': (str, ),
'keystore_password_confirm': (str, ),
'truststore_password': (str, ),
'truststore_password_confirm': (str, ),
'https_hostname': (str, ),
'https_port': (str, ),
'privatekey_file': (file_type, ),
'certificate_file': (file_type, ),
},
'attribute_map': {
'keystore_password': '******',
'keystore_password_confirm': 'keystorePasswordConfirm',
'truststore_password': '******',
'truststore_password_confirm': 'truststorePasswordConfirm',
'https_hostname': 'httpsHostname',
'https_port': 'httpsPort',
'privatekey_file': 'privatekeyFile',
'certificate_file': 'certificateFile',
},
'location_map': {
'keystore_password': '******',
'keystore_password_confirm': 'query',
'truststore_password': '******',
'truststore_password_confirm': 'query',
'https_hostname': 'query',
'https_port': 'query',
'privatekey_file': 'form',
'certificate_file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['text/plain'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__ssl_setup)