docusign_esign.apis.connect_api
Docusign eSignature REST API
The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign. # noqa: E501
OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git
1# coding: utf-8 2 3""" 4 Docusign eSignature REST API 5 6 The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign. # noqa: E501 7 8 OpenAPI spec version: v2.1 9 Contact: devcenter@docusign.com 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11""" 12 13 14from __future__ import absolute_import 15 16import sys 17import os 18import re 19 20# python 2 and python 3 compatibility library 21from six import iteritems 22 23from ..client.configuration import Configuration 24from ..client.api_client import ApiClient 25 26 27class ConnectApi(object): 28 """ 29 NOTE: This class is auto generated by the swagger code generator program. 30 Do not edit the class manually. 31 Ref: https://github.com/swagger-api/swagger-codegen 32 """ 33 34 def __init__(self, api_client=None): 35 config = Configuration() 36 if api_client: 37 self.api_client = api_client 38 else: 39 if not config.api_client: 40 config.api_client = ApiClient() 41 self.api_client = config.api_client 42 43 def create_configuration(self, account_id, **kwargs): 44 """ 45 Creates a connect configuration for the specified account. 46 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 47 This method makes a synchronous HTTP request by default. To make an 48 asynchronous HTTP request, please define a `callback` function 49 to be invoked when receiving the response. 50 >>> def callback_function(response): 51 >>> pprint(response) 52 >>> 53 >>> thread = api.create_configuration(account_id, callback=callback_function) 54 55 :param callback function: The callback function 56 for asynchronous request. (optional) 57 :param str account_id: The external account number (int) or account ID Guid. (required) 58 :param ConnectCustomConfiguration connect_custom_configuration: 59 :return: ConnectCustomConfiguration 60 If the method is called asynchronously, 61 returns the request thread. 62 """ 63 kwargs['_return_http_data_only'] = True 64 if kwargs.get('callback'): 65 return self.create_configuration_with_http_info(account_id, **kwargs) 66 else: 67 (data) = self.create_configuration_with_http_info(account_id, **kwargs) 68 return data 69 70 def create_configuration_with_http_info(self, account_id, **kwargs): 71 """ 72 Creates a connect configuration for the specified account. 73 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 74 This method makes a synchronous HTTP request by default. To make an 75 asynchronous HTTP request, please define a `callback` function 76 to be invoked when receiving the response. 77 >>> def callback_function(response): 78 >>> pprint(response) 79 >>> 80 >>> thread = api.create_configuration_with_http_info(account_id, callback=callback_function) 81 82 :param callback function: The callback function 83 for asynchronous request. (optional) 84 :param str account_id: The external account number (int) or account ID Guid. (required) 85 :param ConnectCustomConfiguration connect_custom_configuration: 86 :return: ConnectCustomConfiguration 87 If the method is called asynchronously, 88 returns the request thread. 89 """ 90 91 all_params = ['account_id', 'connect_custom_configuration'] 92 all_params.append('callback') 93 all_params.append('_return_http_data_only') 94 all_params.append('_preload_content') 95 all_params.append('_request_timeout') 96 97 params = locals() 98 for key, val in iteritems(params['kwargs']): 99 if key not in all_params: 100 raise TypeError( 101 "Got an unexpected keyword argument '%s'" 102 " to method create_configuration" % key 103 ) 104 params[key] = val 105 del params['kwargs'] 106 # verify the required parameter 'account_id' is set 107 if ('account_id' not in params) or (params['account_id'] is None): 108 raise ValueError("Missing the required parameter `account_id` when calling `create_configuration`") 109 110 111 collection_formats = {} 112 113 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 114 path_params = {} 115 if 'account_id' in params: 116 path_params['accountId'] = params['account_id'] 117 118 query_params = {} 119 120 header_params = {} 121 122 form_params = [] 123 local_var_files = {} 124 125 body_params = None 126 if 'connect_custom_configuration' in params: 127 body_params = params['connect_custom_configuration'] 128 # HTTP header `Accept` 129 header_params['Accept'] = self.api_client.\ 130 select_header_accept(['application/json']) 131 132 # Authentication setting 133 auth_settings = [] 134 135 return self.api_client.call_api(resource_path, 'POST', 136 path_params, 137 query_params, 138 header_params, 139 body=body_params, 140 post_params=form_params, 141 files=local_var_files, 142 response_type='ConnectCustomConfiguration', 143 auth_settings=auth_settings, 144 callback=params.get('callback'), 145 _return_http_data_only=params.get('_return_http_data_only'), 146 _preload_content=params.get('_preload_content', True), 147 _request_timeout=params.get('_request_timeout'), 148 collection_formats=collection_formats) 149 150 def create_connect_o_auth_config(self, account_id, **kwargs): 151 """ 152 Sets the Connect OAuth Config for the account. 153 This method makes a synchronous HTTP request by default. To make an 154 asynchronous HTTP request, please define a `callback` function 155 to be invoked when receiving the response. 156 >>> def callback_function(response): 157 >>> pprint(response) 158 >>> 159 >>> thread = api.create_connect_o_auth_config(account_id, callback=callback_function) 160 161 :param callback function: The callback function 162 for asynchronous request. (optional) 163 :param str account_id: The external account number (int) or account ID Guid. (required) 164 :param ConnectOAuthConfig connect_o_auth_config: 165 :return: ConnectOAuthConfig 166 If the method is called asynchronously, 167 returns the request thread. 168 """ 169 kwargs['_return_http_data_only'] = True 170 if kwargs.get('callback'): 171 return self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 172 else: 173 (data) = self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 174 return data 175 176 def create_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 177 """ 178 Sets the Connect OAuth Config for the account. 179 This method makes a synchronous HTTP request by default. To make an 180 asynchronous HTTP request, please define a `callback` function 181 to be invoked when receiving the response. 182 >>> def callback_function(response): 183 >>> pprint(response) 184 >>> 185 >>> thread = api.create_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 186 187 :param callback function: The callback function 188 for asynchronous request. (optional) 189 :param str account_id: The external account number (int) or account ID Guid. (required) 190 :param ConnectOAuthConfig connect_o_auth_config: 191 :return: ConnectOAuthConfig 192 If the method is called asynchronously, 193 returns the request thread. 194 """ 195 196 all_params = ['account_id', 'connect_o_auth_config'] 197 all_params.append('callback') 198 all_params.append('_return_http_data_only') 199 all_params.append('_preload_content') 200 all_params.append('_request_timeout') 201 202 params = locals() 203 for key, val in iteritems(params['kwargs']): 204 if key not in all_params: 205 raise TypeError( 206 "Got an unexpected keyword argument '%s'" 207 " to method create_connect_o_auth_config" % key 208 ) 209 params[key] = val 210 del params['kwargs'] 211 # verify the required parameter 'account_id' is set 212 if ('account_id' not in params) or (params['account_id'] is None): 213 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_o_auth_config`") 214 215 216 collection_formats = {} 217 218 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 219 path_params = {} 220 if 'account_id' in params: 221 path_params['accountId'] = params['account_id'] 222 223 query_params = {} 224 225 header_params = {} 226 227 form_params = [] 228 local_var_files = {} 229 230 body_params = None 231 if 'connect_o_auth_config' in params: 232 body_params = params['connect_o_auth_config'] 233 # HTTP header `Accept` 234 header_params['Accept'] = self.api_client.\ 235 select_header_accept(['application/json']) 236 237 # Authentication setting 238 auth_settings = [] 239 240 return self.api_client.call_api(resource_path, 'POST', 241 path_params, 242 query_params, 243 header_params, 244 body=body_params, 245 post_params=form_params, 246 files=local_var_files, 247 response_type='ConnectOAuthConfig', 248 auth_settings=auth_settings, 249 callback=params.get('callback'), 250 _return_http_data_only=params.get('_return_http_data_only'), 251 _preload_content=params.get('_preload_content', True), 252 _request_timeout=params.get('_request_timeout'), 253 collection_formats=collection_formats) 254 255 def create_connect_secret(self, account_id, **kwargs): 256 """ 257 Generates a new connect HMAC Secret. 258 This method makes a synchronous HTTP request by default. To make an 259 asynchronous HTTP request, please define a `callback` function 260 to be invoked when receiving the response. 261 >>> def callback_function(response): 262 >>> pprint(response) 263 >>> 264 >>> thread = api.create_connect_secret(account_id, callback=callback_function) 265 266 :param callback function: The callback function 267 for asynchronous request. (optional) 268 :param str account_id: The external account number (int) or account ID Guid. (required) 269 :return: None 270 If the method is called asynchronously, 271 returns the request thread. 272 """ 273 kwargs['_return_http_data_only'] = True 274 if kwargs.get('callback'): 275 return self.create_connect_secret_with_http_info(account_id, **kwargs) 276 else: 277 (data) = self.create_connect_secret_with_http_info(account_id, **kwargs) 278 return data 279 280 def create_connect_secret_with_http_info(self, account_id, **kwargs): 281 """ 282 Generates a new connect HMAC Secret. 283 This method makes a synchronous HTTP request by default. To make an 284 asynchronous HTTP request, please define a `callback` function 285 to be invoked when receiving the response. 286 >>> def callback_function(response): 287 >>> pprint(response) 288 >>> 289 >>> thread = api.create_connect_secret_with_http_info(account_id, callback=callback_function) 290 291 :param callback function: The callback function 292 for asynchronous request. (optional) 293 :param str account_id: The external account number (int) or account ID Guid. (required) 294 :return: None 295 If the method is called asynchronously, 296 returns the request thread. 297 """ 298 299 all_params = ['account_id'] 300 all_params.append('callback') 301 all_params.append('_return_http_data_only') 302 all_params.append('_preload_content') 303 all_params.append('_request_timeout') 304 305 params = locals() 306 for key, val in iteritems(params['kwargs']): 307 if key not in all_params: 308 raise TypeError( 309 "Got an unexpected keyword argument '%s'" 310 " to method create_connect_secret" % key 311 ) 312 params[key] = val 313 del params['kwargs'] 314 # verify the required parameter 'account_id' is set 315 if ('account_id' not in params) or (params['account_id'] is None): 316 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_secret`") 317 318 319 collection_formats = {} 320 321 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 322 path_params = {} 323 if 'account_id' in params: 324 path_params['accountId'] = params['account_id'] 325 326 query_params = {} 327 328 header_params = {} 329 330 form_params = [] 331 local_var_files = {} 332 333 body_params = None 334 # HTTP header `Accept` 335 header_params['Accept'] = self.api_client.\ 336 select_header_accept(['application/json']) 337 338 # Authentication setting 339 auth_settings = [] 340 341 return self.api_client.call_api(resource_path, 'POST', 342 path_params, 343 query_params, 344 header_params, 345 body=body_params, 346 post_params=form_params, 347 files=local_var_files, 348 response_type=None, 349 auth_settings=auth_settings, 350 callback=params.get('callback'), 351 _return_http_data_only=params.get('_return_http_data_only'), 352 _preload_content=params.get('_preload_content', True), 353 _request_timeout=params.get('_request_timeout'), 354 collection_formats=collection_formats) 355 356 def delete_configuration(self, account_id, connect_id, **kwargs): 357 """ 358 Deletes the specified connect configuration. 359 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 360 This method makes a synchronous HTTP request by default. To make an 361 asynchronous HTTP request, please define a `callback` function 362 to be invoked when receiving the response. 363 >>> def callback_function(response): 364 >>> pprint(response) 365 >>> 366 >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function) 367 368 :param callback function: The callback function 369 for asynchronous request. (optional) 370 :param str account_id: The external account number (int) or account ID Guid. (required) 371 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 372 :return: None 373 If the method is called asynchronously, 374 returns the request thread. 375 """ 376 kwargs['_return_http_data_only'] = True 377 if kwargs.get('callback'): 378 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 379 else: 380 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 381 return data 382 383 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 384 """ 385 Deletes the specified connect configuration. 386 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 387 This method makes a synchronous HTTP request by default. To make an 388 asynchronous HTTP request, please define a `callback` function 389 to be invoked when receiving the response. 390 >>> def callback_function(response): 391 >>> pprint(response) 392 >>> 393 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 394 395 :param callback function: The callback function 396 for asynchronous request. (optional) 397 :param str account_id: The external account number (int) or account ID Guid. (required) 398 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 399 :return: None 400 If the method is called asynchronously, 401 returns the request thread. 402 """ 403 404 all_params = ['account_id', 'connect_id'] 405 all_params.append('callback') 406 all_params.append('_return_http_data_only') 407 all_params.append('_preload_content') 408 all_params.append('_request_timeout') 409 410 params = locals() 411 for key, val in iteritems(params['kwargs']): 412 if key not in all_params: 413 raise TypeError( 414 "Got an unexpected keyword argument '%s'" 415 " to method delete_configuration" % key 416 ) 417 params[key] = val 418 del params['kwargs'] 419 # verify the required parameter 'account_id' is set 420 if ('account_id' not in params) or (params['account_id'] is None): 421 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 422 # verify the required parameter 'connect_id' is set 423 if ('connect_id' not in params) or (params['connect_id'] is None): 424 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 425 426 427 collection_formats = {} 428 429 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 430 path_params = {} 431 if 'account_id' in params: 432 path_params['accountId'] = params['account_id'] 433 if 'connect_id' in params: 434 path_params['connectId'] = params['connect_id'] 435 436 query_params = {} 437 438 header_params = {} 439 440 form_params = [] 441 local_var_files = {} 442 443 body_params = None 444 # HTTP header `Accept` 445 header_params['Accept'] = self.api_client.\ 446 select_header_accept(['application/json']) 447 448 # Authentication setting 449 auth_settings = [] 450 451 return self.api_client.call_api(resource_path, 'DELETE', 452 path_params, 453 query_params, 454 header_params, 455 body=body_params, 456 post_params=form_params, 457 files=local_var_files, 458 response_type=None, 459 auth_settings=auth_settings, 460 callback=params.get('callback'), 461 _return_http_data_only=params.get('_return_http_data_only'), 462 _preload_content=params.get('_preload_content', True), 463 _request_timeout=params.get('_request_timeout'), 464 collection_formats=collection_formats) 465 466 def delete_connect_o_auth_config(self, account_id, **kwargs): 467 """ 468 Sets the Connect OAuth Config for the account. 469 This method makes a synchronous HTTP request by default. To make an 470 asynchronous HTTP request, please define a `callback` function 471 to be invoked when receiving the response. 472 >>> def callback_function(response): 473 >>> pprint(response) 474 >>> 475 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 476 477 :param callback function: The callback function 478 for asynchronous request. (optional) 479 :param str account_id: The external account number (int) or account ID Guid. (required) 480 :return: None 481 If the method is called asynchronously, 482 returns the request thread. 483 """ 484 kwargs['_return_http_data_only'] = True 485 if kwargs.get('callback'): 486 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 487 else: 488 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 489 return data 490 491 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 492 """ 493 Sets the Connect OAuth Config for the account. 494 This method makes a synchronous HTTP request by default. To make an 495 asynchronous HTTP request, please define a `callback` function 496 to be invoked when receiving the response. 497 >>> def callback_function(response): 498 >>> pprint(response) 499 >>> 500 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 501 502 :param callback function: The callback function 503 for asynchronous request. (optional) 504 :param str account_id: The external account number (int) or account ID Guid. (required) 505 :return: None 506 If the method is called asynchronously, 507 returns the request thread. 508 """ 509 510 all_params = ['account_id'] 511 all_params.append('callback') 512 all_params.append('_return_http_data_only') 513 all_params.append('_preload_content') 514 all_params.append('_request_timeout') 515 516 params = locals() 517 for key, val in iteritems(params['kwargs']): 518 if key not in all_params: 519 raise TypeError( 520 "Got an unexpected keyword argument '%s'" 521 " to method delete_connect_o_auth_config" % key 522 ) 523 params[key] = val 524 del params['kwargs'] 525 # verify the required parameter 'account_id' is set 526 if ('account_id' not in params) or (params['account_id'] is None): 527 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 528 529 530 collection_formats = {} 531 532 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 533 path_params = {} 534 if 'account_id' in params: 535 path_params['accountId'] = params['account_id'] 536 537 query_params = {} 538 539 header_params = {} 540 541 form_params = [] 542 local_var_files = {} 543 544 body_params = None 545 # HTTP header `Accept` 546 header_params['Accept'] = self.api_client.\ 547 select_header_accept(['application/json']) 548 549 # Authentication setting 550 auth_settings = [] 551 552 return self.api_client.call_api(resource_path, 'DELETE', 553 path_params, 554 query_params, 555 header_params, 556 body=body_params, 557 post_params=form_params, 558 files=local_var_files, 559 response_type=None, 560 auth_settings=auth_settings, 561 callback=params.get('callback'), 562 _return_http_data_only=params.get('_return_http_data_only'), 563 _preload_content=params.get('_preload_content', True), 564 _request_timeout=params.get('_request_timeout'), 565 collection_formats=collection_formats) 566 567 def delete_connect_secret(self, account_id, key_id, **kwargs): 568 """ 569 Delete the connect HMAC Secret for AccountID 570 This method makes a synchronous HTTP request by default. To make an 571 asynchronous HTTP request, please define a `callback` function 572 to be invoked when receiving the response. 573 >>> def callback_function(response): 574 >>> pprint(response) 575 >>> 576 >>> thread = api.delete_connect_secret(account_id, key_id, callback=callback_function) 577 578 :param callback function: The callback function 579 for asynchronous request. (optional) 580 :param str account_id: The external account number (int) or account ID Guid. (required) 581 :param str key_id: (required) 582 :return: None 583 If the method is called asynchronously, 584 returns the request thread. 585 """ 586 kwargs['_return_http_data_only'] = True 587 if kwargs.get('callback'): 588 return self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 589 else: 590 (data) = self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 591 return data 592 593 def delete_connect_secret_with_http_info(self, account_id, key_id, **kwargs): 594 """ 595 Delete the connect HMAC Secret for AccountID 596 This method makes a synchronous HTTP request by default. To make an 597 asynchronous HTTP request, please define a `callback` function 598 to be invoked when receiving the response. 599 >>> def callback_function(response): 600 >>> pprint(response) 601 >>> 602 >>> thread = api.delete_connect_secret_with_http_info(account_id, key_id, callback=callback_function) 603 604 :param callback function: The callback function 605 for asynchronous request. (optional) 606 :param str account_id: The external account number (int) or account ID Guid. (required) 607 :param str key_id: (required) 608 :return: None 609 If the method is called asynchronously, 610 returns the request thread. 611 """ 612 613 all_params = ['account_id', 'key_id'] 614 all_params.append('callback') 615 all_params.append('_return_http_data_only') 616 all_params.append('_preload_content') 617 all_params.append('_request_timeout') 618 619 params = locals() 620 for key, val in iteritems(params['kwargs']): 621 if key not in all_params: 622 raise TypeError( 623 "Got an unexpected keyword argument '%s'" 624 " to method delete_connect_secret" % key 625 ) 626 params[key] = val 627 del params['kwargs'] 628 # verify the required parameter 'account_id' is set 629 if ('account_id' not in params) or (params['account_id'] is None): 630 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_secret`") 631 # verify the required parameter 'key_id' is set 632 if ('key_id' not in params) or (params['key_id'] is None): 633 raise ValueError("Missing the required parameter `key_id` when calling `delete_connect_secret`") 634 635 636 collection_formats = {} 637 638 resource_path = '/v2.1/accounts/{accountId}/connect/secret/{keyId}'.replace('{format}', 'json') 639 path_params = {} 640 if 'account_id' in params: 641 path_params['accountId'] = params['account_id'] 642 if 'key_id' in params: 643 path_params['keyId'] = params['key_id'] 644 645 query_params = {} 646 647 header_params = {} 648 649 form_params = [] 650 local_var_files = {} 651 652 body_params = None 653 # HTTP header `Accept` 654 header_params['Accept'] = self.api_client.\ 655 select_header_accept(['application/json']) 656 657 # Authentication setting 658 auth_settings = [] 659 660 return self.api_client.call_api(resource_path, 'DELETE', 661 path_params, 662 query_params, 663 header_params, 664 body=body_params, 665 post_params=form_params, 666 files=local_var_files, 667 response_type=None, 668 auth_settings=auth_settings, 669 callback=params.get('callback'), 670 _return_http_data_only=params.get('_return_http_data_only'), 671 _preload_content=params.get('_preload_content', True), 672 _request_timeout=params.get('_request_timeout'), 673 collection_formats=collection_formats) 674 675 def delete_event_failure_log(self, account_id, failure_id, **kwargs): 676 """ 677 Deletes a Connect failure log entry. 678 Deletes the Connect failure log information for the specified entry. 679 This method makes a synchronous HTTP request by default. To make an 680 asynchronous HTTP request, please define a `callback` function 681 to be invoked when receiving the response. 682 >>> def callback_function(response): 683 >>> pprint(response) 684 >>> 685 >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function) 686 687 :param callback function: The callback function 688 for asynchronous request. (optional) 689 :param str account_id: The external account number (int) or account ID Guid. (required) 690 :param str failure_id: The ID of the failed connect log entry. (required) 691 :return: ConnectDeleteFailureResult 692 If the method is called asynchronously, 693 returns the request thread. 694 """ 695 kwargs['_return_http_data_only'] = True 696 if kwargs.get('callback'): 697 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 698 else: 699 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 700 return data 701 702 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 703 """ 704 Deletes a Connect failure log entry. 705 Deletes the Connect failure log information for the specified entry. 706 This method makes a synchronous HTTP request by default. To make an 707 asynchronous HTTP request, please define a `callback` function 708 to be invoked when receiving the response. 709 >>> def callback_function(response): 710 >>> pprint(response) 711 >>> 712 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 713 714 :param callback function: The callback function 715 for asynchronous request. (optional) 716 :param str account_id: The external account number (int) or account ID Guid. (required) 717 :param str failure_id: The ID of the failed connect log entry. (required) 718 :return: ConnectDeleteFailureResult 719 If the method is called asynchronously, 720 returns the request thread. 721 """ 722 723 all_params = ['account_id', 'failure_id'] 724 all_params.append('callback') 725 all_params.append('_return_http_data_only') 726 all_params.append('_preload_content') 727 all_params.append('_request_timeout') 728 729 params = locals() 730 for key, val in iteritems(params['kwargs']): 731 if key not in all_params: 732 raise TypeError( 733 "Got an unexpected keyword argument '%s'" 734 " to method delete_event_failure_log" % key 735 ) 736 params[key] = val 737 del params['kwargs'] 738 # verify the required parameter 'account_id' is set 739 if ('account_id' not in params) or (params['account_id'] is None): 740 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 741 # verify the required parameter 'failure_id' is set 742 if ('failure_id' not in params) or (params['failure_id'] is None): 743 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 744 745 746 collection_formats = {} 747 748 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 749 path_params = {} 750 if 'account_id' in params: 751 path_params['accountId'] = params['account_id'] 752 if 'failure_id' in params: 753 path_params['failureId'] = params['failure_id'] 754 755 query_params = {} 756 757 header_params = {} 758 759 form_params = [] 760 local_var_files = {} 761 762 body_params = None 763 # HTTP header `Accept` 764 header_params['Accept'] = self.api_client.\ 765 select_header_accept(['application/json']) 766 767 # Authentication setting 768 auth_settings = [] 769 770 return self.api_client.call_api(resource_path, 'DELETE', 771 path_params, 772 query_params, 773 header_params, 774 body=body_params, 775 post_params=form_params, 776 files=local_var_files, 777 response_type='ConnectDeleteFailureResult', 778 auth_settings=auth_settings, 779 callback=params.get('callback'), 780 _return_http_data_only=params.get('_return_http_data_only'), 781 _preload_content=params.get('_preload_content', True), 782 _request_timeout=params.get('_request_timeout'), 783 collection_formats=collection_formats) 784 785 def delete_event_log(self, account_id, log_id, **kwargs): 786 """ 787 Deletes a specified Connect log entry. 788 Deletes a specified entry from the Connect Log. 789 This method makes a synchronous HTTP request by default. To make an 790 asynchronous HTTP request, please define a `callback` function 791 to be invoked when receiving the response. 792 >>> def callback_function(response): 793 >>> pprint(response) 794 >>> 795 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 796 797 :param callback function: The callback function 798 for asynchronous request. (optional) 799 :param str account_id: The external account number (int) or account ID Guid. (required) 800 :param str log_id: The ID of the connect log entry (required) 801 :return: None 802 If the method is called asynchronously, 803 returns the request thread. 804 """ 805 kwargs['_return_http_data_only'] = True 806 if kwargs.get('callback'): 807 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 808 else: 809 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 810 return data 811 812 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 813 """ 814 Deletes a specified Connect log entry. 815 Deletes a specified entry from the Connect Log. 816 This method makes a synchronous HTTP request by default. To make an 817 asynchronous HTTP request, please define a `callback` function 818 to be invoked when receiving the response. 819 >>> def callback_function(response): 820 >>> pprint(response) 821 >>> 822 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 823 824 :param callback function: The callback function 825 for asynchronous request. (optional) 826 :param str account_id: The external account number (int) or account ID Guid. (required) 827 :param str log_id: The ID of the connect log entry (required) 828 :return: None 829 If the method is called asynchronously, 830 returns the request thread. 831 """ 832 833 all_params = ['account_id', 'log_id'] 834 all_params.append('callback') 835 all_params.append('_return_http_data_only') 836 all_params.append('_preload_content') 837 all_params.append('_request_timeout') 838 839 params = locals() 840 for key, val in iteritems(params['kwargs']): 841 if key not in all_params: 842 raise TypeError( 843 "Got an unexpected keyword argument '%s'" 844 " to method delete_event_log" % key 845 ) 846 params[key] = val 847 del params['kwargs'] 848 # verify the required parameter 'account_id' is set 849 if ('account_id' not in params) or (params['account_id'] is None): 850 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 851 # verify the required parameter 'log_id' is set 852 if ('log_id' not in params) or (params['log_id'] is None): 853 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 854 855 856 collection_formats = {} 857 858 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 859 path_params = {} 860 if 'account_id' in params: 861 path_params['accountId'] = params['account_id'] 862 if 'log_id' in params: 863 path_params['logId'] = params['log_id'] 864 865 query_params = {} 866 867 header_params = {} 868 869 form_params = [] 870 local_var_files = {} 871 872 body_params = None 873 # HTTP header `Accept` 874 header_params['Accept'] = self.api_client.\ 875 select_header_accept(['application/json']) 876 877 # Authentication setting 878 auth_settings = [] 879 880 return self.api_client.call_api(resource_path, 'DELETE', 881 path_params, 882 query_params, 883 header_params, 884 body=body_params, 885 post_params=form_params, 886 files=local_var_files, 887 response_type=None, 888 auth_settings=auth_settings, 889 callback=params.get('callback'), 890 _return_http_data_only=params.get('_return_http_data_only'), 891 _preload_content=params.get('_preload_content', True), 892 _request_timeout=params.get('_request_timeout'), 893 collection_formats=collection_formats) 894 895 def delete_event_logs(self, account_id, **kwargs): 896 """ 897 Gets a list of Connect log entries. 898 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 899 This method makes a synchronous HTTP request by default. To make an 900 asynchronous HTTP request, please define a `callback` function 901 to be invoked when receiving the response. 902 >>> def callback_function(response): 903 >>> pprint(response) 904 >>> 905 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 906 907 :param callback function: The callback function 908 for asynchronous request. (optional) 909 :param str account_id: The external account number (int) or account ID Guid. (required) 910 :return: None 911 If the method is called asynchronously, 912 returns the request thread. 913 """ 914 kwargs['_return_http_data_only'] = True 915 if kwargs.get('callback'): 916 return self.delete_event_logs_with_http_info(account_id, **kwargs) 917 else: 918 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 919 return data 920 921 def delete_event_logs_with_http_info(self, account_id, **kwargs): 922 """ 923 Gets a list of Connect log entries. 924 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 925 This method makes a synchronous HTTP request by default. To make an 926 asynchronous HTTP request, please define a `callback` function 927 to be invoked when receiving the response. 928 >>> def callback_function(response): 929 >>> pprint(response) 930 >>> 931 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 932 933 :param callback function: The callback function 934 for asynchronous request. (optional) 935 :param str account_id: The external account number (int) or account ID Guid. (required) 936 :return: None 937 If the method is called asynchronously, 938 returns the request thread. 939 """ 940 941 all_params = ['account_id'] 942 all_params.append('callback') 943 all_params.append('_return_http_data_only') 944 all_params.append('_preload_content') 945 all_params.append('_request_timeout') 946 947 params = locals() 948 for key, val in iteritems(params['kwargs']): 949 if key not in all_params: 950 raise TypeError( 951 "Got an unexpected keyword argument '%s'" 952 " to method delete_event_logs" % key 953 ) 954 params[key] = val 955 del params['kwargs'] 956 # verify the required parameter 'account_id' is set 957 if ('account_id' not in params) or (params['account_id'] is None): 958 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 959 960 961 collection_formats = {} 962 963 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 964 path_params = {} 965 if 'account_id' in params: 966 path_params['accountId'] = params['account_id'] 967 968 query_params = {} 969 970 header_params = {} 971 972 form_params = [] 973 local_var_files = {} 974 975 body_params = None 976 # HTTP header `Accept` 977 header_params['Accept'] = self.api_client.\ 978 select_header_accept(['application/json']) 979 980 # Authentication setting 981 auth_settings = [] 982 983 return self.api_client.call_api(resource_path, 'DELETE', 984 path_params, 985 query_params, 986 header_params, 987 body=body_params, 988 post_params=form_params, 989 files=local_var_files, 990 response_type=None, 991 auth_settings=auth_settings, 992 callback=params.get('callback'), 993 _return_http_data_only=params.get('_return_http_data_only'), 994 _preload_content=params.get('_preload_content', True), 995 _request_timeout=params.get('_request_timeout'), 996 collection_formats=collection_formats) 997 998 def delete_mobile_notifiers(self, account_id, **kwargs): 999 """ 1000 Reserved 1001 Reserved: 1002 This method makes a synchronous HTTP request by default. To make an 1003 asynchronous HTTP request, please define a `callback` function 1004 to be invoked when receiving the response. 1005 >>> def callback_function(response): 1006 >>> pprint(response) 1007 >>> 1008 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 1009 1010 :param callback function: The callback function 1011 for asynchronous request. (optional) 1012 :param str account_id: The external account number (int) or account ID Guid. (required) 1013 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1014 :return: MobileNotifierConfigurationInformation 1015 If the method is called asynchronously, 1016 returns the request thread. 1017 """ 1018 kwargs['_return_http_data_only'] = True 1019 if kwargs.get('callback'): 1020 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1021 else: 1022 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1023 return data 1024 1025 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1026 """ 1027 Reserved 1028 Reserved: 1029 This method makes a synchronous HTTP request by default. To make an 1030 asynchronous HTTP request, please define a `callback` function 1031 to be invoked when receiving the response. 1032 >>> def callback_function(response): 1033 >>> pprint(response) 1034 >>> 1035 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1036 1037 :param callback function: The callback function 1038 for asynchronous request. (optional) 1039 :param str account_id: The external account number (int) or account ID Guid. (required) 1040 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1041 :return: MobileNotifierConfigurationInformation 1042 If the method is called asynchronously, 1043 returns the request thread. 1044 """ 1045 1046 all_params = ['account_id', 'mobile_notifier_configuration_information'] 1047 all_params.append('callback') 1048 all_params.append('_return_http_data_only') 1049 all_params.append('_preload_content') 1050 all_params.append('_request_timeout') 1051 1052 params = locals() 1053 for key, val in iteritems(params['kwargs']): 1054 if key not in all_params: 1055 raise TypeError( 1056 "Got an unexpected keyword argument '%s'" 1057 " to method delete_mobile_notifiers" % key 1058 ) 1059 params[key] = val 1060 del params['kwargs'] 1061 # verify the required parameter 'account_id' is set 1062 if ('account_id' not in params) or (params['account_id'] is None): 1063 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 1064 1065 1066 collection_formats = {} 1067 1068 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1069 path_params = {} 1070 if 'account_id' in params: 1071 path_params['accountId'] = params['account_id'] 1072 1073 query_params = {} 1074 1075 header_params = {} 1076 1077 form_params = [] 1078 local_var_files = {} 1079 1080 body_params = None 1081 if 'mobile_notifier_configuration_information' in params: 1082 body_params = params['mobile_notifier_configuration_information'] 1083 # HTTP header `Accept` 1084 header_params['Accept'] = self.api_client.\ 1085 select_header_accept(['application/json']) 1086 1087 # Authentication setting 1088 auth_settings = [] 1089 1090 return self.api_client.call_api(resource_path, 'DELETE', 1091 path_params, 1092 query_params, 1093 header_params, 1094 body=body_params, 1095 post_params=form_params, 1096 files=local_var_files, 1097 response_type='MobileNotifierConfigurationInformation', 1098 auth_settings=auth_settings, 1099 callback=params.get('callback'), 1100 _return_http_data_only=params.get('_return_http_data_only'), 1101 _preload_content=params.get('_preload_content', True), 1102 _request_timeout=params.get('_request_timeout'), 1103 collection_formats=collection_formats) 1104 1105 def get_configuration(self, account_id, connect_id, **kwargs): 1106 """ 1107 Get a Connect Configuration Information 1108 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1109 This method makes a synchronous HTTP request by default. To make an 1110 asynchronous HTTP request, please define a `callback` function 1111 to be invoked when receiving the response. 1112 >>> def callback_function(response): 1113 >>> pprint(response) 1114 >>> 1115 >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function) 1116 1117 :param callback function: The callback function 1118 for asynchronous request. (optional) 1119 :param str account_id: The external account number (int) or account ID Guid. (required) 1120 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1121 :return: ConnectConfigResults 1122 If the method is called asynchronously, 1123 returns the request thread. 1124 """ 1125 kwargs['_return_http_data_only'] = True 1126 if kwargs.get('callback'): 1127 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1128 else: 1129 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1130 return data 1131 1132 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 1133 """ 1134 Get a Connect Configuration Information 1135 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1136 This method makes a synchronous HTTP request by default. To make an 1137 asynchronous HTTP request, please define a `callback` function 1138 to be invoked when receiving the response. 1139 >>> def callback_function(response): 1140 >>> pprint(response) 1141 >>> 1142 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 1143 1144 :param callback function: The callback function 1145 for asynchronous request. (optional) 1146 :param str account_id: The external account number (int) or account ID Guid. (required) 1147 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1148 :return: ConnectConfigResults 1149 If the method is called asynchronously, 1150 returns the request thread. 1151 """ 1152 1153 all_params = ['account_id', 'connect_id'] 1154 all_params.append('callback') 1155 all_params.append('_return_http_data_only') 1156 all_params.append('_preload_content') 1157 all_params.append('_request_timeout') 1158 1159 params = locals() 1160 for key, val in iteritems(params['kwargs']): 1161 if key not in all_params: 1162 raise TypeError( 1163 "Got an unexpected keyword argument '%s'" 1164 " to method get_configuration" % key 1165 ) 1166 params[key] = val 1167 del params['kwargs'] 1168 # verify the required parameter 'account_id' is set 1169 if ('account_id' not in params) or (params['account_id'] is None): 1170 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 1171 # verify the required parameter 'connect_id' is set 1172 if ('connect_id' not in params) or (params['connect_id'] is None): 1173 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 1174 1175 1176 collection_formats = {} 1177 1178 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 1179 path_params = {} 1180 if 'account_id' in params: 1181 path_params['accountId'] = params['account_id'] 1182 if 'connect_id' in params: 1183 path_params['connectId'] = params['connect_id'] 1184 1185 query_params = {} 1186 1187 header_params = {} 1188 1189 form_params = [] 1190 local_var_files = {} 1191 1192 body_params = None 1193 # HTTP header `Accept` 1194 header_params['Accept'] = self.api_client.\ 1195 select_header_accept(['application/json']) 1196 1197 # Authentication setting 1198 auth_settings = [] 1199 1200 return self.api_client.call_api(resource_path, 'GET', 1201 path_params, 1202 query_params, 1203 header_params, 1204 body=body_params, 1205 post_params=form_params, 1206 files=local_var_files, 1207 response_type='ConnectConfigResults', 1208 auth_settings=auth_settings, 1209 callback=params.get('callback'), 1210 _return_http_data_only=params.get('_return_http_data_only'), 1211 _preload_content=params.get('_preload_content', True), 1212 _request_timeout=params.get('_request_timeout'), 1213 collection_formats=collection_formats) 1214 1215 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1216 """ 1217 Returns all users from the configured Connect service. 1218 1219 This method makes a synchronous HTTP request by default. To make an 1220 asynchronous HTTP request, please define a `callback` function 1221 to be invoked when receiving the response. 1222 >>> def callback_function(response): 1223 >>> pprint(response) 1224 >>> 1225 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1226 1227 :param callback function: The callback function 1228 for asynchronous request. (optional) 1229 :param str account_id: The external account number (int) or account ID Guid. (required) 1230 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1231 :param str count: 1232 :param str domain_users_only: 1233 :param str email_substring: 1234 :param str start_position: 1235 :param str status: 1236 :param str user_name_substring: 1237 :return: IntegratedConnectUserInfoList 1238 If the method is called asynchronously, 1239 returns the request thread. 1240 """ 1241 kwargs['_return_http_data_only'] = True 1242 if kwargs.get('callback'): 1243 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1244 else: 1245 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1246 return data 1247 1248 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1249 """ 1250 Returns all users from the configured Connect service. 1251 1252 This method makes a synchronous HTTP request by default. To make an 1253 asynchronous HTTP request, please define a `callback` function 1254 to be invoked when receiving the response. 1255 >>> def callback_function(response): 1256 >>> pprint(response) 1257 >>> 1258 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1259 1260 :param callback function: The callback function 1261 for asynchronous request. (optional) 1262 :param str account_id: The external account number (int) or account ID Guid. (required) 1263 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1264 :param str count: 1265 :param str domain_users_only: 1266 :param str email_substring: 1267 :param str start_position: 1268 :param str status: 1269 :param str user_name_substring: 1270 :return: IntegratedConnectUserInfoList 1271 If the method is called asynchronously, 1272 returns the request thread. 1273 """ 1274 1275 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1276 all_params.append('callback') 1277 all_params.append('_return_http_data_only') 1278 all_params.append('_preload_content') 1279 all_params.append('_request_timeout') 1280 1281 params = locals() 1282 for key, val in iteritems(params['kwargs']): 1283 if key not in all_params: 1284 raise TypeError( 1285 "Got an unexpected keyword argument '%s'" 1286 " to method get_connect_all_users" % key 1287 ) 1288 params[key] = val 1289 del params['kwargs'] 1290 # verify the required parameter 'account_id' is set 1291 if ('account_id' not in params) or (params['account_id'] is None): 1292 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1293 # verify the required parameter 'connect_id' is set 1294 if ('connect_id' not in params) or (params['connect_id'] is None): 1295 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1296 1297 1298 collection_formats = {} 1299 1300 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1301 path_params = {} 1302 if 'account_id' in params: 1303 path_params['accountId'] = params['account_id'] 1304 if 'connect_id' in params: 1305 path_params['connectId'] = params['connect_id'] 1306 1307 query_params = {} 1308 if 'count' in params: 1309 query_params['count'] = params['count'] 1310 if 'domain_users_only' in params: 1311 query_params['domain_users_only'] = params['domain_users_only'] 1312 if 'email_substring' in params: 1313 query_params['email_substring'] = params['email_substring'] 1314 if 'start_position' in params: 1315 query_params['start_position'] = params['start_position'] 1316 if 'status' in params: 1317 query_params['status'] = params['status'] 1318 if 'user_name_substring' in params: 1319 query_params['user_name_substring'] = params['user_name_substring'] 1320 1321 header_params = {} 1322 1323 form_params = [] 1324 local_var_files = {} 1325 1326 body_params = None 1327 # HTTP header `Accept` 1328 header_params['Accept'] = self.api_client.\ 1329 select_header_accept(['application/json']) 1330 1331 # Authentication setting 1332 auth_settings = [] 1333 1334 return self.api_client.call_api(resource_path, 'GET', 1335 path_params, 1336 query_params, 1337 header_params, 1338 body=body_params, 1339 post_params=form_params, 1340 files=local_var_files, 1341 response_type='IntegratedConnectUserInfoList', 1342 auth_settings=auth_settings, 1343 callback=params.get('callback'), 1344 _return_http_data_only=params.get('_return_http_data_only'), 1345 _preload_content=params.get('_preload_content', True), 1346 _request_timeout=params.get('_request_timeout'), 1347 collection_formats=collection_formats) 1348 1349 def get_connect_o_auth_config(self, account_id, **kwargs): 1350 """ 1351 Sets the Connect OAuth Config for the account. 1352 This method makes a synchronous HTTP request by default. To make an 1353 asynchronous HTTP request, please define a `callback` function 1354 to be invoked when receiving the response. 1355 >>> def callback_function(response): 1356 >>> pprint(response) 1357 >>> 1358 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1359 1360 :param callback function: The callback function 1361 for asynchronous request. (optional) 1362 :param str account_id: The external account number (int) or account ID Guid. (required) 1363 :return: ConnectOAuthConfig 1364 If the method is called asynchronously, 1365 returns the request thread. 1366 """ 1367 kwargs['_return_http_data_only'] = True 1368 if kwargs.get('callback'): 1369 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1370 else: 1371 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1372 return data 1373 1374 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1375 """ 1376 Sets the Connect OAuth Config for the account. 1377 This method makes a synchronous HTTP request by default. To make an 1378 asynchronous HTTP request, please define a `callback` function 1379 to be invoked when receiving the response. 1380 >>> def callback_function(response): 1381 >>> pprint(response) 1382 >>> 1383 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1384 1385 :param callback function: The callback function 1386 for asynchronous request. (optional) 1387 :param str account_id: The external account number (int) or account ID Guid. (required) 1388 :return: ConnectOAuthConfig 1389 If the method is called asynchronously, 1390 returns the request thread. 1391 """ 1392 1393 all_params = ['account_id'] 1394 all_params.append('callback') 1395 all_params.append('_return_http_data_only') 1396 all_params.append('_preload_content') 1397 all_params.append('_request_timeout') 1398 1399 params = locals() 1400 for key, val in iteritems(params['kwargs']): 1401 if key not in all_params: 1402 raise TypeError( 1403 "Got an unexpected keyword argument '%s'" 1404 " to method get_connect_o_auth_config" % key 1405 ) 1406 params[key] = val 1407 del params['kwargs'] 1408 # verify the required parameter 'account_id' is set 1409 if ('account_id' not in params) or (params['account_id'] is None): 1410 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1411 1412 1413 collection_formats = {} 1414 1415 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1416 path_params = {} 1417 if 'account_id' in params: 1418 path_params['accountId'] = params['account_id'] 1419 1420 query_params = {} 1421 1422 header_params = {} 1423 1424 form_params = [] 1425 local_var_files = {} 1426 1427 body_params = None 1428 # HTTP header `Accept` 1429 header_params['Accept'] = self.api_client.\ 1430 select_header_accept(['application/json']) 1431 1432 # Authentication setting 1433 auth_settings = [] 1434 1435 return self.api_client.call_api(resource_path, 'GET', 1436 path_params, 1437 query_params, 1438 header_params, 1439 body=body_params, 1440 post_params=form_params, 1441 files=local_var_files, 1442 response_type='ConnectOAuthConfig', 1443 auth_settings=auth_settings, 1444 callback=params.get('callback'), 1445 _return_http_data_only=params.get('_return_http_data_only'), 1446 _preload_content=params.get('_preload_content', True), 1447 _request_timeout=params.get('_request_timeout'), 1448 collection_formats=collection_formats) 1449 1450 def get_connect_secret(self, account_id, **kwargs): 1451 """ 1452 Get the connect HMAC Secrets for AccountID 1453 This method makes a synchronous HTTP request by default. To make an 1454 asynchronous HTTP request, please define a `callback` function 1455 to be invoked when receiving the response. 1456 >>> def callback_function(response): 1457 >>> pprint(response) 1458 >>> 1459 >>> thread = api.get_connect_secret(account_id, callback=callback_function) 1460 1461 :param callback function: The callback function 1462 for asynchronous request. (optional) 1463 :param str account_id: The external account number (int) or account ID Guid. (required) 1464 :return: None 1465 If the method is called asynchronously, 1466 returns the request thread. 1467 """ 1468 kwargs['_return_http_data_only'] = True 1469 if kwargs.get('callback'): 1470 return self.get_connect_secret_with_http_info(account_id, **kwargs) 1471 else: 1472 (data) = self.get_connect_secret_with_http_info(account_id, **kwargs) 1473 return data 1474 1475 def get_connect_secret_with_http_info(self, account_id, **kwargs): 1476 """ 1477 Get the connect HMAC Secrets for AccountID 1478 This method makes a synchronous HTTP request by default. To make an 1479 asynchronous HTTP request, please define a `callback` function 1480 to be invoked when receiving the response. 1481 >>> def callback_function(response): 1482 >>> pprint(response) 1483 >>> 1484 >>> thread = api.get_connect_secret_with_http_info(account_id, callback=callback_function) 1485 1486 :param callback function: The callback function 1487 for asynchronous request. (optional) 1488 :param str account_id: The external account number (int) or account ID Guid. (required) 1489 :return: None 1490 If the method is called asynchronously, 1491 returns the request thread. 1492 """ 1493 1494 all_params = ['account_id'] 1495 all_params.append('callback') 1496 all_params.append('_return_http_data_only') 1497 all_params.append('_preload_content') 1498 all_params.append('_request_timeout') 1499 1500 params = locals() 1501 for key, val in iteritems(params['kwargs']): 1502 if key not in all_params: 1503 raise TypeError( 1504 "Got an unexpected keyword argument '%s'" 1505 " to method get_connect_secret" % key 1506 ) 1507 params[key] = val 1508 del params['kwargs'] 1509 # verify the required parameter 'account_id' is set 1510 if ('account_id' not in params) or (params['account_id'] is None): 1511 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_secret`") 1512 1513 1514 collection_formats = {} 1515 1516 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 1517 path_params = {} 1518 if 'account_id' in params: 1519 path_params['accountId'] = params['account_id'] 1520 1521 query_params = {} 1522 1523 header_params = {} 1524 1525 form_params = [] 1526 local_var_files = {} 1527 1528 body_params = None 1529 # HTTP header `Accept` 1530 header_params['Accept'] = self.api_client.\ 1531 select_header_accept(['application/json']) 1532 1533 # Authentication setting 1534 auth_settings = [] 1535 1536 return self.api_client.call_api(resource_path, 'GET', 1537 path_params, 1538 query_params, 1539 header_params, 1540 body=body_params, 1541 post_params=form_params, 1542 files=local_var_files, 1543 response_type=None, 1544 auth_settings=auth_settings, 1545 callback=params.get('callback'), 1546 _return_http_data_only=params.get('_return_http_data_only'), 1547 _preload_content=params.get('_preload_content', True), 1548 _request_timeout=params.get('_request_timeout'), 1549 collection_formats=collection_formats) 1550 1551 def get_event_log(self, account_id, log_id, **kwargs): 1552 """ 1553 Get the specified Connect log entry. 1554 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1555 This method makes a synchronous HTTP request by default. To make an 1556 asynchronous HTTP request, please define a `callback` function 1557 to be invoked when receiving the response. 1558 >>> def callback_function(response): 1559 >>> pprint(response) 1560 >>> 1561 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1562 1563 :param callback function: The callback function 1564 for asynchronous request. (optional) 1565 :param str account_id: The external account number (int) or account ID Guid. (required) 1566 :param str log_id: The ID of the connect log entry (required) 1567 :param str additional_info: When true, the connectDebugLog information is included in the response. 1568 :return: ConnectLog 1569 If the method is called asynchronously, 1570 returns the request thread. 1571 """ 1572 kwargs['_return_http_data_only'] = True 1573 if kwargs.get('callback'): 1574 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1575 else: 1576 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1577 return data 1578 1579 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1580 """ 1581 Get the specified Connect log entry. 1582 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1583 This method makes a synchronous HTTP request by default. To make an 1584 asynchronous HTTP request, please define a `callback` function 1585 to be invoked when receiving the response. 1586 >>> def callback_function(response): 1587 >>> pprint(response) 1588 >>> 1589 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1590 1591 :param callback function: The callback function 1592 for asynchronous request. (optional) 1593 :param str account_id: The external account number (int) or account ID Guid. (required) 1594 :param str log_id: The ID of the connect log entry (required) 1595 :param str additional_info: When true, the connectDebugLog information is included in the response. 1596 :return: ConnectLog 1597 If the method is called asynchronously, 1598 returns the request thread. 1599 """ 1600 1601 all_params = ['account_id', 'log_id', 'additional_info'] 1602 all_params.append('callback') 1603 all_params.append('_return_http_data_only') 1604 all_params.append('_preload_content') 1605 all_params.append('_request_timeout') 1606 1607 params = locals() 1608 for key, val in iteritems(params['kwargs']): 1609 if key not in all_params: 1610 raise TypeError( 1611 "Got an unexpected keyword argument '%s'" 1612 " to method get_event_log" % key 1613 ) 1614 params[key] = val 1615 del params['kwargs'] 1616 # verify the required parameter 'account_id' is set 1617 if ('account_id' not in params) or (params['account_id'] is None): 1618 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1619 # verify the required parameter 'log_id' is set 1620 if ('log_id' not in params) or (params['log_id'] is None): 1621 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1622 1623 1624 collection_formats = {} 1625 1626 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1627 path_params = {} 1628 if 'account_id' in params: 1629 path_params['accountId'] = params['account_id'] 1630 if 'log_id' in params: 1631 path_params['logId'] = params['log_id'] 1632 1633 query_params = {} 1634 if 'additional_info' in params: 1635 query_params['additional_info'] = params['additional_info'] 1636 1637 header_params = {} 1638 1639 form_params = [] 1640 local_var_files = {} 1641 1642 body_params = None 1643 # HTTP header `Accept` 1644 header_params['Accept'] = self.api_client.\ 1645 select_header_accept(['application/json']) 1646 1647 # Authentication setting 1648 auth_settings = [] 1649 1650 return self.api_client.call_api(resource_path, 'GET', 1651 path_params, 1652 query_params, 1653 header_params, 1654 body=body_params, 1655 post_params=form_params, 1656 files=local_var_files, 1657 response_type='ConnectLog', 1658 auth_settings=auth_settings, 1659 callback=params.get('callback'), 1660 _return_http_data_only=params.get('_return_http_data_only'), 1661 _preload_content=params.get('_preload_content', True), 1662 _request_timeout=params.get('_request_timeout'), 1663 collection_formats=collection_formats) 1664 1665 def list_configurations(self, account_id, **kwargs): 1666 """ 1667 Get Connect Configuration Information 1668 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1669 This method makes a synchronous HTTP request by default. To make an 1670 asynchronous HTTP request, please define a `callback` function 1671 to be invoked when receiving the response. 1672 >>> def callback_function(response): 1673 >>> pprint(response) 1674 >>> 1675 >>> thread = api.list_configurations(account_id, callback=callback_function) 1676 1677 :param callback function: The callback function 1678 for asynchronous request. (optional) 1679 :param str account_id: The external account number (int) or account ID Guid. (required) 1680 :return: ConnectConfigResults 1681 If the method is called asynchronously, 1682 returns the request thread. 1683 """ 1684 kwargs['_return_http_data_only'] = True 1685 if kwargs.get('callback'): 1686 return self.list_configurations_with_http_info(account_id, **kwargs) 1687 else: 1688 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1689 return data 1690 1691 def list_configurations_with_http_info(self, account_id, **kwargs): 1692 """ 1693 Get Connect Configuration Information 1694 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1695 This method makes a synchronous HTTP request by default. To make an 1696 asynchronous HTTP request, please define a `callback` function 1697 to be invoked when receiving the response. 1698 >>> def callback_function(response): 1699 >>> pprint(response) 1700 >>> 1701 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1702 1703 :param callback function: The callback function 1704 for asynchronous request. (optional) 1705 :param str account_id: The external account number (int) or account ID Guid. (required) 1706 :return: ConnectConfigResults 1707 If the method is called asynchronously, 1708 returns the request thread. 1709 """ 1710 1711 all_params = ['account_id'] 1712 all_params.append('callback') 1713 all_params.append('_return_http_data_only') 1714 all_params.append('_preload_content') 1715 all_params.append('_request_timeout') 1716 1717 params = locals() 1718 for key, val in iteritems(params['kwargs']): 1719 if key not in all_params: 1720 raise TypeError( 1721 "Got an unexpected keyword argument '%s'" 1722 " to method list_configurations" % key 1723 ) 1724 params[key] = val 1725 del params['kwargs'] 1726 # verify the required parameter 'account_id' is set 1727 if ('account_id' not in params) or (params['account_id'] is None): 1728 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1729 1730 1731 collection_formats = {} 1732 1733 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1734 path_params = {} 1735 if 'account_id' in params: 1736 path_params['accountId'] = params['account_id'] 1737 1738 query_params = {} 1739 1740 header_params = {} 1741 1742 form_params = [] 1743 local_var_files = {} 1744 1745 body_params = None 1746 # HTTP header `Accept` 1747 header_params['Accept'] = self.api_client.\ 1748 select_header_accept(['application/json']) 1749 1750 # Authentication setting 1751 auth_settings = [] 1752 1753 return self.api_client.call_api(resource_path, 'GET', 1754 path_params, 1755 query_params, 1756 header_params, 1757 body=body_params, 1758 post_params=form_params, 1759 files=local_var_files, 1760 response_type='ConnectConfigResults', 1761 auth_settings=auth_settings, 1762 callback=params.get('callback'), 1763 _return_http_data_only=params.get('_return_http_data_only'), 1764 _preload_content=params.get('_preload_content', True), 1765 _request_timeout=params.get('_request_timeout'), 1766 collection_formats=collection_formats) 1767 1768 def list_event_failure_logs(self, account_id, **kwargs): 1769 """ 1770 Gets the Connect failure log information. 1771 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1772 This method makes a synchronous HTTP request by default. To make an 1773 asynchronous HTTP request, please define a `callback` function 1774 to be invoked when receiving the response. 1775 >>> def callback_function(response): 1776 >>> pprint(response) 1777 >>> 1778 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1779 1780 :param callback function: The callback function 1781 for asynchronous request. (optional) 1782 :param str account_id: The external account number (int) or account ID Guid. (required) 1783 :param str from_date: 1784 :param str to_date: 1785 :return: ConnectLogs 1786 If the method is called asynchronously, 1787 returns the request thread. 1788 """ 1789 kwargs['_return_http_data_only'] = True 1790 if kwargs.get('callback'): 1791 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1792 else: 1793 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1794 return data 1795 1796 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1797 """ 1798 Gets the Connect failure log information. 1799 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1800 This method makes a synchronous HTTP request by default. To make an 1801 asynchronous HTTP request, please define a `callback` function 1802 to be invoked when receiving the response. 1803 >>> def callback_function(response): 1804 >>> pprint(response) 1805 >>> 1806 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1807 1808 :param callback function: The callback function 1809 for asynchronous request. (optional) 1810 :param str account_id: The external account number (int) or account ID Guid. (required) 1811 :param str from_date: 1812 :param str to_date: 1813 :return: ConnectLogs 1814 If the method is called asynchronously, 1815 returns the request thread. 1816 """ 1817 1818 all_params = ['account_id', 'from_date', 'to_date'] 1819 all_params.append('callback') 1820 all_params.append('_return_http_data_only') 1821 all_params.append('_preload_content') 1822 all_params.append('_request_timeout') 1823 1824 params = locals() 1825 for key, val in iteritems(params['kwargs']): 1826 if key not in all_params: 1827 raise TypeError( 1828 "Got an unexpected keyword argument '%s'" 1829 " to method list_event_failure_logs" % key 1830 ) 1831 params[key] = val 1832 del params['kwargs'] 1833 # verify the required parameter 'account_id' is set 1834 if ('account_id' not in params) or (params['account_id'] is None): 1835 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1836 1837 1838 collection_formats = {} 1839 1840 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1841 path_params = {} 1842 if 'account_id' in params: 1843 path_params['accountId'] = params['account_id'] 1844 1845 query_params = {} 1846 if 'from_date' in params: 1847 query_params['from_date'] = params['from_date'] 1848 if 'to_date' in params: 1849 query_params['to_date'] = params['to_date'] 1850 1851 header_params = {} 1852 1853 form_params = [] 1854 local_var_files = {} 1855 1856 body_params = None 1857 # HTTP header `Accept` 1858 header_params['Accept'] = self.api_client.\ 1859 select_header_accept(['application/json']) 1860 1861 # Authentication setting 1862 auth_settings = [] 1863 1864 return self.api_client.call_api(resource_path, 'GET', 1865 path_params, 1866 query_params, 1867 header_params, 1868 body=body_params, 1869 post_params=form_params, 1870 files=local_var_files, 1871 response_type='ConnectLogs', 1872 auth_settings=auth_settings, 1873 callback=params.get('callback'), 1874 _return_http_data_only=params.get('_return_http_data_only'), 1875 _preload_content=params.get('_preload_content', True), 1876 _request_timeout=params.get('_request_timeout'), 1877 collection_formats=collection_formats) 1878 1879 def list_event_logs(self, account_id, **kwargs): 1880 """ 1881 Gets the Connect log. 1882 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1883 This method makes a synchronous HTTP request by default. To make an 1884 asynchronous HTTP request, please define a `callback` function 1885 to be invoked when receiving the response. 1886 >>> def callback_function(response): 1887 >>> pprint(response) 1888 >>> 1889 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1890 1891 :param callback function: The callback function 1892 for asynchronous request. (optional) 1893 :param str account_id: The external account number (int) or account ID Guid. (required) 1894 :param str from_date: 1895 :param str to_date: 1896 :return: ConnectLogs 1897 If the method is called asynchronously, 1898 returns the request thread. 1899 """ 1900 kwargs['_return_http_data_only'] = True 1901 if kwargs.get('callback'): 1902 return self.list_event_logs_with_http_info(account_id, **kwargs) 1903 else: 1904 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1905 return data 1906 1907 def list_event_logs_with_http_info(self, account_id, **kwargs): 1908 """ 1909 Gets the Connect log. 1910 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1911 This method makes a synchronous HTTP request by default. To make an 1912 asynchronous HTTP request, please define a `callback` function 1913 to be invoked when receiving the response. 1914 >>> def callback_function(response): 1915 >>> pprint(response) 1916 >>> 1917 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1918 1919 :param callback function: The callback function 1920 for asynchronous request. (optional) 1921 :param str account_id: The external account number (int) or account ID Guid. (required) 1922 :param str from_date: 1923 :param str to_date: 1924 :return: ConnectLogs 1925 If the method is called asynchronously, 1926 returns the request thread. 1927 """ 1928 1929 all_params = ['account_id', 'from_date', 'to_date'] 1930 all_params.append('callback') 1931 all_params.append('_return_http_data_only') 1932 all_params.append('_preload_content') 1933 all_params.append('_request_timeout') 1934 1935 params = locals() 1936 for key, val in iteritems(params['kwargs']): 1937 if key not in all_params: 1938 raise TypeError( 1939 "Got an unexpected keyword argument '%s'" 1940 " to method list_event_logs" % key 1941 ) 1942 params[key] = val 1943 del params['kwargs'] 1944 # verify the required parameter 'account_id' is set 1945 if ('account_id' not in params) or (params['account_id'] is None): 1946 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1947 1948 1949 collection_formats = {} 1950 1951 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1952 path_params = {} 1953 if 'account_id' in params: 1954 path_params['accountId'] = params['account_id'] 1955 1956 query_params = {} 1957 if 'from_date' in params: 1958 query_params['from_date'] = params['from_date'] 1959 if 'to_date' in params: 1960 query_params['to_date'] = params['to_date'] 1961 1962 header_params = {} 1963 1964 form_params = [] 1965 local_var_files = {} 1966 1967 body_params = None 1968 # HTTP header `Accept` 1969 header_params['Accept'] = self.api_client.\ 1970 select_header_accept(['application/json']) 1971 1972 # Authentication setting 1973 auth_settings = [] 1974 1975 return self.api_client.call_api(resource_path, 'GET', 1976 path_params, 1977 query_params, 1978 header_params, 1979 body=body_params, 1980 post_params=form_params, 1981 files=local_var_files, 1982 response_type='ConnectLogs', 1983 auth_settings=auth_settings, 1984 callback=params.get('callback'), 1985 _return_http_data_only=params.get('_return_http_data_only'), 1986 _preload_content=params.get('_preload_content', True), 1987 _request_timeout=params.get('_request_timeout'), 1988 collection_formats=collection_formats) 1989 1990 def list_mobile_notifiers(self, account_id, **kwargs): 1991 """ 1992 Reserved 1993 Reserved: 1994 This method makes a synchronous HTTP request by default. To make an 1995 asynchronous HTTP request, please define a `callback` function 1996 to be invoked when receiving the response. 1997 >>> def callback_function(response): 1998 >>> pprint(response) 1999 >>> 2000 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 2001 2002 :param callback function: The callback function 2003 for asynchronous request. (optional) 2004 :param str account_id: The external account number (int) or account ID Guid. (required) 2005 :return: MobileNotifierConfigurationInformation 2006 If the method is called asynchronously, 2007 returns the request thread. 2008 """ 2009 kwargs['_return_http_data_only'] = True 2010 if kwargs.get('callback'): 2011 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2012 else: 2013 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2014 return data 2015 2016 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2017 """ 2018 Reserved 2019 Reserved: 2020 This method makes a synchronous HTTP request by default. To make an 2021 asynchronous HTTP request, please define a `callback` function 2022 to be invoked when receiving the response. 2023 >>> def callback_function(response): 2024 >>> pprint(response) 2025 >>> 2026 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2027 2028 :param callback function: The callback function 2029 for asynchronous request. (optional) 2030 :param str account_id: The external account number (int) or account ID Guid. (required) 2031 :return: MobileNotifierConfigurationInformation 2032 If the method is called asynchronously, 2033 returns the request thread. 2034 """ 2035 2036 all_params = ['account_id'] 2037 all_params.append('callback') 2038 all_params.append('_return_http_data_only') 2039 all_params.append('_preload_content') 2040 all_params.append('_request_timeout') 2041 2042 params = locals() 2043 for key, val in iteritems(params['kwargs']): 2044 if key not in all_params: 2045 raise TypeError( 2046 "Got an unexpected keyword argument '%s'" 2047 " to method list_mobile_notifiers" % key 2048 ) 2049 params[key] = val 2050 del params['kwargs'] 2051 # verify the required parameter 'account_id' is set 2052 if ('account_id' not in params) or (params['account_id'] is None): 2053 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 2054 2055 2056 collection_formats = {} 2057 2058 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2059 path_params = {} 2060 if 'account_id' in params: 2061 path_params['accountId'] = params['account_id'] 2062 2063 query_params = {} 2064 2065 header_params = {} 2066 2067 form_params = [] 2068 local_var_files = {} 2069 2070 body_params = None 2071 # HTTP header `Accept` 2072 header_params['Accept'] = self.api_client.\ 2073 select_header_accept(['application/json']) 2074 2075 # Authentication setting 2076 auth_settings = [] 2077 2078 return self.api_client.call_api(resource_path, 'GET', 2079 path_params, 2080 query_params, 2081 header_params, 2082 body=body_params, 2083 post_params=form_params, 2084 files=local_var_files, 2085 response_type='MobileNotifierConfigurationInformation', 2086 auth_settings=auth_settings, 2087 callback=params.get('callback'), 2088 _return_http_data_only=params.get('_return_http_data_only'), 2089 _preload_content=params.get('_preload_content', True), 2090 _request_timeout=params.get('_request_timeout'), 2091 collection_formats=collection_formats) 2092 2093 def list_users(self, account_id, connect_id, **kwargs): 2094 """ 2095 Returns users from the configured Connect service. 2096 Returns users from the configured Connect service. 2097 This method makes a synchronous HTTP request by default. To make an 2098 asynchronous HTTP request, please define a `callback` function 2099 to be invoked when receiving the response. 2100 >>> def callback_function(response): 2101 >>> pprint(response) 2102 >>> 2103 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 2104 2105 :param callback function: The callback function 2106 for asynchronous request. (optional) 2107 :param str account_id: The external account number (int) or account ID Guid. (required) 2108 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2109 :param str count: 2110 :param str email_substring: 2111 :param str list_included_users: 2112 :param str start_position: 2113 :param str status: 2114 :param str user_name_substring: 2115 :return: IntegratedUserInfoList 2116 If the method is called asynchronously, 2117 returns the request thread. 2118 """ 2119 kwargs['_return_http_data_only'] = True 2120 if kwargs.get('callback'): 2121 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 2122 else: 2123 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 2124 return data 2125 2126 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 2127 """ 2128 Returns users from the configured Connect service. 2129 Returns users from the configured Connect service. 2130 This method makes a synchronous HTTP request by default. To make an 2131 asynchronous HTTP request, please define a `callback` function 2132 to be invoked when receiving the response. 2133 >>> def callback_function(response): 2134 >>> pprint(response) 2135 >>> 2136 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 2137 2138 :param callback function: The callback function 2139 for asynchronous request. (optional) 2140 :param str account_id: The external account number (int) or account ID Guid. (required) 2141 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2142 :param str count: 2143 :param str email_substring: 2144 :param str list_included_users: 2145 :param str start_position: 2146 :param str status: 2147 :param str user_name_substring: 2148 :return: IntegratedUserInfoList 2149 If the method is called asynchronously, 2150 returns the request thread. 2151 """ 2152 2153 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 2154 all_params.append('callback') 2155 all_params.append('_return_http_data_only') 2156 all_params.append('_preload_content') 2157 all_params.append('_request_timeout') 2158 2159 params = locals() 2160 for key, val in iteritems(params['kwargs']): 2161 if key not in all_params: 2162 raise TypeError( 2163 "Got an unexpected keyword argument '%s'" 2164 " to method list_users" % key 2165 ) 2166 params[key] = val 2167 del params['kwargs'] 2168 # verify the required parameter 'account_id' is set 2169 if ('account_id' not in params) or (params['account_id'] is None): 2170 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 2171 # verify the required parameter 'connect_id' is set 2172 if ('connect_id' not in params) or (params['connect_id'] is None): 2173 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 2174 2175 2176 collection_formats = {} 2177 2178 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 2179 path_params = {} 2180 if 'account_id' in params: 2181 path_params['accountId'] = params['account_id'] 2182 if 'connect_id' in params: 2183 path_params['connectId'] = params['connect_id'] 2184 2185 query_params = {} 2186 if 'count' in params: 2187 query_params['count'] = params['count'] 2188 if 'email_substring' in params: 2189 query_params['email_substring'] = params['email_substring'] 2190 if 'list_included_users' in params: 2191 query_params['list_included_users'] = params['list_included_users'] 2192 if 'start_position' in params: 2193 query_params['start_position'] = params['start_position'] 2194 if 'status' in params: 2195 query_params['status'] = params['status'] 2196 if 'user_name_substring' in params: 2197 query_params['user_name_substring'] = params['user_name_substring'] 2198 2199 header_params = {} 2200 2201 form_params = [] 2202 local_var_files = {} 2203 2204 body_params = None 2205 # HTTP header `Accept` 2206 header_params['Accept'] = self.api_client.\ 2207 select_header_accept(['application/json']) 2208 2209 # Authentication setting 2210 auth_settings = [] 2211 2212 return self.api_client.call_api(resource_path, 'GET', 2213 path_params, 2214 query_params, 2215 header_params, 2216 body=body_params, 2217 post_params=form_params, 2218 files=local_var_files, 2219 response_type='IntegratedUserInfoList', 2220 auth_settings=auth_settings, 2221 callback=params.get('callback'), 2222 _return_http_data_only=params.get('_return_http_data_only'), 2223 _preload_content=params.get('_preload_content', True), 2224 _request_timeout=params.get('_request_timeout'), 2225 collection_formats=collection_formats) 2226 2227 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 2228 """ 2229 Republishes Connect information for the specified envelope. 2230 Republishes Connect information for the specified envelope. 2231 This method makes a synchronous HTTP request by default. To make an 2232 asynchronous HTTP request, please define a `callback` function 2233 to be invoked when receiving the response. 2234 >>> def callback_function(response): 2235 >>> pprint(response) 2236 >>> 2237 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 2238 2239 :param callback function: The callback function 2240 for asynchronous request. (optional) 2241 :param str account_id: The external account number (int) or account ID Guid. (required) 2242 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2243 :return: ConnectFailureResults 2244 If the method is called asynchronously, 2245 returns the request thread. 2246 """ 2247 kwargs['_return_http_data_only'] = True 2248 if kwargs.get('callback'): 2249 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2250 else: 2251 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2252 return data 2253 2254 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 2255 """ 2256 Republishes Connect information for the specified envelope. 2257 Republishes Connect information for the specified envelope. 2258 This method makes a synchronous HTTP request by default. To make an 2259 asynchronous HTTP request, please define a `callback` function 2260 to be invoked when receiving the response. 2261 >>> def callback_function(response): 2262 >>> pprint(response) 2263 >>> 2264 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 2265 2266 :param callback function: The callback function 2267 for asynchronous request. (optional) 2268 :param str account_id: The external account number (int) or account ID Guid. (required) 2269 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2270 :return: ConnectFailureResults 2271 If the method is called asynchronously, 2272 returns the request thread. 2273 """ 2274 2275 all_params = ['account_id', 'envelope_id'] 2276 all_params.append('callback') 2277 all_params.append('_return_http_data_only') 2278 all_params.append('_preload_content') 2279 all_params.append('_request_timeout') 2280 2281 params = locals() 2282 for key, val in iteritems(params['kwargs']): 2283 if key not in all_params: 2284 raise TypeError( 2285 "Got an unexpected keyword argument '%s'" 2286 " to method retry_event_for_envelope" % key 2287 ) 2288 params[key] = val 2289 del params['kwargs'] 2290 # verify the required parameter 'account_id' is set 2291 if ('account_id' not in params) or (params['account_id'] is None): 2292 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 2293 # verify the required parameter 'envelope_id' is set 2294 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2295 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 2296 2297 2298 collection_formats = {} 2299 2300 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 2301 path_params = {} 2302 if 'account_id' in params: 2303 path_params['accountId'] = params['account_id'] 2304 if 'envelope_id' in params: 2305 path_params['envelopeId'] = params['envelope_id'] 2306 2307 query_params = {} 2308 2309 header_params = {} 2310 2311 form_params = [] 2312 local_var_files = {} 2313 2314 body_params = None 2315 # HTTP header `Accept` 2316 header_params['Accept'] = self.api_client.\ 2317 select_header_accept(['application/json']) 2318 2319 # Authentication setting 2320 auth_settings = [] 2321 2322 return self.api_client.call_api(resource_path, 'PUT', 2323 path_params, 2324 query_params, 2325 header_params, 2326 body=body_params, 2327 post_params=form_params, 2328 files=local_var_files, 2329 response_type='ConnectFailureResults', 2330 auth_settings=auth_settings, 2331 callback=params.get('callback'), 2332 _return_http_data_only=params.get('_return_http_data_only'), 2333 _preload_content=params.get('_preload_content', True), 2334 _request_timeout=params.get('_request_timeout'), 2335 collection_formats=collection_formats) 2336 2337 def retry_event_for_envelopes(self, account_id, **kwargs): 2338 """ 2339 Republishes Connect information for multiple envelopes. 2340 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2341 This method makes a synchronous HTTP request by default. To make an 2342 asynchronous HTTP request, please define a `callback` function 2343 to be invoked when receiving the response. 2344 >>> def callback_function(response): 2345 >>> pprint(response) 2346 >>> 2347 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2348 2349 :param callback function: The callback function 2350 for asynchronous request. (optional) 2351 :param str account_id: The external account number (int) or account ID Guid. (required) 2352 :param ConnectFailureFilter connect_failure_filter: 2353 :return: ConnectFailureResults 2354 If the method is called asynchronously, 2355 returns the request thread. 2356 """ 2357 kwargs['_return_http_data_only'] = True 2358 if kwargs.get('callback'): 2359 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2360 else: 2361 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2362 return data 2363 2364 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2365 """ 2366 Republishes Connect information for multiple envelopes. 2367 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2368 This method makes a synchronous HTTP request by default. To make an 2369 asynchronous HTTP request, please define a `callback` function 2370 to be invoked when receiving the response. 2371 >>> def callback_function(response): 2372 >>> pprint(response) 2373 >>> 2374 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2375 2376 :param callback function: The callback function 2377 for asynchronous request. (optional) 2378 :param str account_id: The external account number (int) or account ID Guid. (required) 2379 :param ConnectFailureFilter connect_failure_filter: 2380 :return: ConnectFailureResults 2381 If the method is called asynchronously, 2382 returns the request thread. 2383 """ 2384 2385 all_params = ['account_id', 'connect_failure_filter'] 2386 all_params.append('callback') 2387 all_params.append('_return_http_data_only') 2388 all_params.append('_preload_content') 2389 all_params.append('_request_timeout') 2390 2391 params = locals() 2392 for key, val in iteritems(params['kwargs']): 2393 if key not in all_params: 2394 raise TypeError( 2395 "Got an unexpected keyword argument '%s'" 2396 " to method retry_event_for_envelopes" % key 2397 ) 2398 params[key] = val 2399 del params['kwargs'] 2400 # verify the required parameter 'account_id' is set 2401 if ('account_id' not in params) or (params['account_id'] is None): 2402 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2403 2404 2405 collection_formats = {} 2406 2407 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2408 path_params = {} 2409 if 'account_id' in params: 2410 path_params['accountId'] = params['account_id'] 2411 2412 query_params = {} 2413 2414 header_params = {} 2415 2416 form_params = [] 2417 local_var_files = {} 2418 2419 body_params = None 2420 if 'connect_failure_filter' in params: 2421 body_params = params['connect_failure_filter'] 2422 # HTTP header `Accept` 2423 header_params['Accept'] = self.api_client.\ 2424 select_header_accept(['application/json']) 2425 2426 # Authentication setting 2427 auth_settings = [] 2428 2429 return self.api_client.call_api(resource_path, 'PUT', 2430 path_params, 2431 query_params, 2432 header_params, 2433 body=body_params, 2434 post_params=form_params, 2435 files=local_var_files, 2436 response_type='ConnectFailureResults', 2437 auth_settings=auth_settings, 2438 callback=params.get('callback'), 2439 _return_http_data_only=params.get('_return_http_data_only'), 2440 _preload_content=params.get('_preload_content', True), 2441 _request_timeout=params.get('_request_timeout'), 2442 collection_formats=collection_formats) 2443 2444 def update_configuration(self, account_id, **kwargs): 2445 """ 2446 Updates a specified Connect configuration. 2447 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2448 This method makes a synchronous HTTP request by default. To make an 2449 asynchronous HTTP request, please define a `callback` function 2450 to be invoked when receiving the response. 2451 >>> def callback_function(response): 2452 >>> pprint(response) 2453 >>> 2454 >>> thread = api.update_configuration(account_id, callback=callback_function) 2455 2456 :param callback function: The callback function 2457 for asynchronous request. (optional) 2458 :param str account_id: The external account number (int) or account ID Guid. (required) 2459 :param ConnectCustomConfiguration connect_custom_configuration: 2460 :return: ConnectCustomConfiguration 2461 If the method is called asynchronously, 2462 returns the request thread. 2463 """ 2464 kwargs['_return_http_data_only'] = True 2465 if kwargs.get('callback'): 2466 return self.update_configuration_with_http_info(account_id, **kwargs) 2467 else: 2468 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2469 return data 2470 2471 def update_configuration_with_http_info(self, account_id, **kwargs): 2472 """ 2473 Updates a specified Connect configuration. 2474 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2475 This method makes a synchronous HTTP request by default. To make an 2476 asynchronous HTTP request, please define a `callback` function 2477 to be invoked when receiving the response. 2478 >>> def callback_function(response): 2479 >>> pprint(response) 2480 >>> 2481 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2482 2483 :param callback function: The callback function 2484 for asynchronous request. (optional) 2485 :param str account_id: The external account number (int) or account ID Guid. (required) 2486 :param ConnectCustomConfiguration connect_custom_configuration: 2487 :return: ConnectCustomConfiguration 2488 If the method is called asynchronously, 2489 returns the request thread. 2490 """ 2491 2492 all_params = ['account_id', 'connect_custom_configuration'] 2493 all_params.append('callback') 2494 all_params.append('_return_http_data_only') 2495 all_params.append('_preload_content') 2496 all_params.append('_request_timeout') 2497 2498 params = locals() 2499 for key, val in iteritems(params['kwargs']): 2500 if key not in all_params: 2501 raise TypeError( 2502 "Got an unexpected keyword argument '%s'" 2503 " to method update_configuration" % key 2504 ) 2505 params[key] = val 2506 del params['kwargs'] 2507 # verify the required parameter 'account_id' is set 2508 if ('account_id' not in params) or (params['account_id'] is None): 2509 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2510 2511 2512 collection_formats = {} 2513 2514 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2515 path_params = {} 2516 if 'account_id' in params: 2517 path_params['accountId'] = params['account_id'] 2518 2519 query_params = {} 2520 2521 header_params = {} 2522 2523 form_params = [] 2524 local_var_files = {} 2525 2526 body_params = None 2527 if 'connect_custom_configuration' in params: 2528 body_params = params['connect_custom_configuration'] 2529 # HTTP header `Accept` 2530 header_params['Accept'] = self.api_client.\ 2531 select_header_accept(['application/json']) 2532 2533 # Authentication setting 2534 auth_settings = [] 2535 2536 return self.api_client.call_api(resource_path, 'PUT', 2537 path_params, 2538 query_params, 2539 header_params, 2540 body=body_params, 2541 post_params=form_params, 2542 files=local_var_files, 2543 response_type='ConnectCustomConfiguration', 2544 auth_settings=auth_settings, 2545 callback=params.get('callback'), 2546 _return_http_data_only=params.get('_return_http_data_only'), 2547 _preload_content=params.get('_preload_content', True), 2548 _request_timeout=params.get('_request_timeout'), 2549 collection_formats=collection_formats) 2550 2551 def update_connect_o_auth_config(self, account_id, **kwargs): 2552 """ 2553 Updates the existing Connect OAuth Config for the account. 2554 This method makes a synchronous HTTP request by default. To make an 2555 asynchronous HTTP request, please define a `callback` function 2556 to be invoked when receiving the response. 2557 >>> def callback_function(response): 2558 >>> pprint(response) 2559 >>> 2560 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2561 2562 :param callback function: The callback function 2563 for asynchronous request. (optional) 2564 :param str account_id: The external account number (int) or account ID Guid. (required) 2565 :param ConnectOAuthConfig connect_o_auth_config: 2566 :return: ConnectOAuthConfig 2567 If the method is called asynchronously, 2568 returns the request thread. 2569 """ 2570 kwargs['_return_http_data_only'] = True 2571 if kwargs.get('callback'): 2572 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2573 else: 2574 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2575 return data 2576 2577 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2578 """ 2579 Updates the existing Connect OAuth Config for the account. 2580 This method makes a synchronous HTTP request by default. To make an 2581 asynchronous HTTP request, please define a `callback` function 2582 to be invoked when receiving the response. 2583 >>> def callback_function(response): 2584 >>> pprint(response) 2585 >>> 2586 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2587 2588 :param callback function: The callback function 2589 for asynchronous request. (optional) 2590 :param str account_id: The external account number (int) or account ID Guid. (required) 2591 :param ConnectOAuthConfig connect_o_auth_config: 2592 :return: ConnectOAuthConfig 2593 If the method is called asynchronously, 2594 returns the request thread. 2595 """ 2596 2597 all_params = ['account_id', 'connect_o_auth_config'] 2598 all_params.append('callback') 2599 all_params.append('_return_http_data_only') 2600 all_params.append('_preload_content') 2601 all_params.append('_request_timeout') 2602 2603 params = locals() 2604 for key, val in iteritems(params['kwargs']): 2605 if key not in all_params: 2606 raise TypeError( 2607 "Got an unexpected keyword argument '%s'" 2608 " to method update_connect_o_auth_config" % key 2609 ) 2610 params[key] = val 2611 del params['kwargs'] 2612 # verify the required parameter 'account_id' is set 2613 if ('account_id' not in params) or (params['account_id'] is None): 2614 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2615 2616 2617 collection_formats = {} 2618 2619 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2620 path_params = {} 2621 if 'account_id' in params: 2622 path_params['accountId'] = params['account_id'] 2623 2624 query_params = {} 2625 2626 header_params = {} 2627 2628 form_params = [] 2629 local_var_files = {} 2630 2631 body_params = None 2632 if 'connect_o_auth_config' in params: 2633 body_params = params['connect_o_auth_config'] 2634 # HTTP header `Accept` 2635 header_params['Accept'] = self.api_client.\ 2636 select_header_accept(['application/json']) 2637 2638 # Authentication setting 2639 auth_settings = [] 2640 2641 return self.api_client.call_api(resource_path, 'PUT', 2642 path_params, 2643 query_params, 2644 header_params, 2645 body=body_params, 2646 post_params=form_params, 2647 files=local_var_files, 2648 response_type='ConnectOAuthConfig', 2649 auth_settings=auth_settings, 2650 callback=params.get('callback'), 2651 _return_http_data_only=params.get('_return_http_data_only'), 2652 _preload_content=params.get('_preload_content', True), 2653 _request_timeout=params.get('_request_timeout'), 2654 collection_formats=collection_formats) 2655 2656 def update_mobile_notifiers(self, account_id, **kwargs): 2657 """ 2658 Reserved 2659 Reserved: 2660 This method makes a synchronous HTTP request by default. To make an 2661 asynchronous HTTP request, please define a `callback` function 2662 to be invoked when receiving the response. 2663 >>> def callback_function(response): 2664 >>> pprint(response) 2665 >>> 2666 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2667 2668 :param callback function: The callback function 2669 for asynchronous request. (optional) 2670 :param str account_id: The external account number (int) or account ID Guid. (required) 2671 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2672 :return: MobileNotifierConfigurationInformation 2673 If the method is called asynchronously, 2674 returns the request thread. 2675 """ 2676 kwargs['_return_http_data_only'] = True 2677 if kwargs.get('callback'): 2678 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2679 else: 2680 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2681 return data 2682 2683 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2684 """ 2685 Reserved 2686 Reserved: 2687 This method makes a synchronous HTTP request by default. To make an 2688 asynchronous HTTP request, please define a `callback` function 2689 to be invoked when receiving the response. 2690 >>> def callback_function(response): 2691 >>> pprint(response) 2692 >>> 2693 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2694 2695 :param callback function: The callback function 2696 for asynchronous request. (optional) 2697 :param str account_id: The external account number (int) or account ID Guid. (required) 2698 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2699 :return: MobileNotifierConfigurationInformation 2700 If the method is called asynchronously, 2701 returns the request thread. 2702 """ 2703 2704 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2705 all_params.append('callback') 2706 all_params.append('_return_http_data_only') 2707 all_params.append('_preload_content') 2708 all_params.append('_request_timeout') 2709 2710 params = locals() 2711 for key, val in iteritems(params['kwargs']): 2712 if key not in all_params: 2713 raise TypeError( 2714 "Got an unexpected keyword argument '%s'" 2715 " to method update_mobile_notifiers" % key 2716 ) 2717 params[key] = val 2718 del params['kwargs'] 2719 # verify the required parameter 'account_id' is set 2720 if ('account_id' not in params) or (params['account_id'] is None): 2721 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2722 2723 2724 collection_formats = {} 2725 2726 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2727 path_params = {} 2728 if 'account_id' in params: 2729 path_params['accountId'] = params['account_id'] 2730 2731 query_params = {} 2732 2733 header_params = {} 2734 2735 form_params = [] 2736 local_var_files = {} 2737 2738 body_params = None 2739 if 'mobile_notifier_configuration_information' in params: 2740 body_params = params['mobile_notifier_configuration_information'] 2741 # HTTP header `Accept` 2742 header_params['Accept'] = self.api_client.\ 2743 select_header_accept(['application/json']) 2744 2745 # Authentication setting 2746 auth_settings = [] 2747 2748 return self.api_client.call_api(resource_path, 'PUT', 2749 path_params, 2750 query_params, 2751 header_params, 2752 body=body_params, 2753 post_params=form_params, 2754 files=local_var_files, 2755 response_type='MobileNotifierConfigurationInformation', 2756 auth_settings=auth_settings, 2757 callback=params.get('callback'), 2758 _return_http_data_only=params.get('_return_http_data_only'), 2759 _preload_content=params.get('_preload_content', True), 2760 _request_timeout=params.get('_request_timeout'), 2761 collection_formats=collection_formats)
class
ConnectApi:
28class ConnectApi(object): 29 """ 30 NOTE: This class is auto generated by the swagger code generator program. 31 Do not edit the class manually. 32 Ref: https://github.com/swagger-api/swagger-codegen 33 """ 34 35 def __init__(self, api_client=None): 36 config = Configuration() 37 if api_client: 38 self.api_client = api_client 39 else: 40 if not config.api_client: 41 config.api_client = ApiClient() 42 self.api_client = config.api_client 43 44 def create_configuration(self, account_id, **kwargs): 45 """ 46 Creates a connect configuration for the specified account. 47 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.create_configuration(account_id, callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str account_id: The external account number (int) or account ID Guid. (required) 59 :param ConnectCustomConfiguration connect_custom_configuration: 60 :return: ConnectCustomConfiguration 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_configuration_with_http_info(account_id, **kwargs) 67 else: 68 (data) = self.create_configuration_with_http_info(account_id, **kwargs) 69 return data 70 71 def create_configuration_with_http_info(self, account_id, **kwargs): 72 """ 73 Creates a connect configuration for the specified account. 74 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_configuration_with_http_info(account_id, callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str account_id: The external account number (int) or account ID Guid. (required) 86 :param ConnectCustomConfiguration connect_custom_configuration: 87 :return: ConnectCustomConfiguration 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['account_id', 'connect_custom_configuration'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create_configuration" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 # verify the required parameter 'account_id' is set 108 if ('account_id' not in params) or (params['account_id'] is None): 109 raise ValueError("Missing the required parameter `account_id` when calling `create_configuration`") 110 111 112 collection_formats = {} 113 114 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 115 path_params = {} 116 if 'account_id' in params: 117 path_params['accountId'] = params['account_id'] 118 119 query_params = {} 120 121 header_params = {} 122 123 form_params = [] 124 local_var_files = {} 125 126 body_params = None 127 if 'connect_custom_configuration' in params: 128 body_params = params['connect_custom_configuration'] 129 # HTTP header `Accept` 130 header_params['Accept'] = self.api_client.\ 131 select_header_accept(['application/json']) 132 133 # Authentication setting 134 auth_settings = [] 135 136 return self.api_client.call_api(resource_path, 'POST', 137 path_params, 138 query_params, 139 header_params, 140 body=body_params, 141 post_params=form_params, 142 files=local_var_files, 143 response_type='ConnectCustomConfiguration', 144 auth_settings=auth_settings, 145 callback=params.get('callback'), 146 _return_http_data_only=params.get('_return_http_data_only'), 147 _preload_content=params.get('_preload_content', True), 148 _request_timeout=params.get('_request_timeout'), 149 collection_formats=collection_formats) 150 151 def create_connect_o_auth_config(self, account_id, **kwargs): 152 """ 153 Sets the Connect OAuth Config for the account. 154 This method makes a synchronous HTTP request by default. To make an 155 asynchronous HTTP request, please define a `callback` function 156 to be invoked when receiving the response. 157 >>> def callback_function(response): 158 >>> pprint(response) 159 >>> 160 >>> thread = api.create_connect_o_auth_config(account_id, callback=callback_function) 161 162 :param callback function: The callback function 163 for asynchronous request. (optional) 164 :param str account_id: The external account number (int) or account ID Guid. (required) 165 :param ConnectOAuthConfig connect_o_auth_config: 166 :return: ConnectOAuthConfig 167 If the method is called asynchronously, 168 returns the request thread. 169 """ 170 kwargs['_return_http_data_only'] = True 171 if kwargs.get('callback'): 172 return self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 173 else: 174 (data) = self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 175 return data 176 177 def create_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 178 """ 179 Sets the Connect OAuth Config for the account. 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param ConnectOAuthConfig connect_o_auth_config: 192 :return: ConnectOAuthConfig 193 If the method is called asynchronously, 194 returns the request thread. 195 """ 196 197 all_params = ['account_id', 'connect_o_auth_config'] 198 all_params.append('callback') 199 all_params.append('_return_http_data_only') 200 all_params.append('_preload_content') 201 all_params.append('_request_timeout') 202 203 params = locals() 204 for key, val in iteritems(params['kwargs']): 205 if key not in all_params: 206 raise TypeError( 207 "Got an unexpected keyword argument '%s'" 208 " to method create_connect_o_auth_config" % key 209 ) 210 params[key] = val 211 del params['kwargs'] 212 # verify the required parameter 'account_id' is set 213 if ('account_id' not in params) or (params['account_id'] is None): 214 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_o_auth_config`") 215 216 217 collection_formats = {} 218 219 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 220 path_params = {} 221 if 'account_id' in params: 222 path_params['accountId'] = params['account_id'] 223 224 query_params = {} 225 226 header_params = {} 227 228 form_params = [] 229 local_var_files = {} 230 231 body_params = None 232 if 'connect_o_auth_config' in params: 233 body_params = params['connect_o_auth_config'] 234 # HTTP header `Accept` 235 header_params['Accept'] = self.api_client.\ 236 select_header_accept(['application/json']) 237 238 # Authentication setting 239 auth_settings = [] 240 241 return self.api_client.call_api(resource_path, 'POST', 242 path_params, 243 query_params, 244 header_params, 245 body=body_params, 246 post_params=form_params, 247 files=local_var_files, 248 response_type='ConnectOAuthConfig', 249 auth_settings=auth_settings, 250 callback=params.get('callback'), 251 _return_http_data_only=params.get('_return_http_data_only'), 252 _preload_content=params.get('_preload_content', True), 253 _request_timeout=params.get('_request_timeout'), 254 collection_formats=collection_formats) 255 256 def create_connect_secret(self, account_id, **kwargs): 257 """ 258 Generates a new connect HMAC Secret. 259 This method makes a synchronous HTTP request by default. To make an 260 asynchronous HTTP request, please define a `callback` function 261 to be invoked when receiving the response. 262 >>> def callback_function(response): 263 >>> pprint(response) 264 >>> 265 >>> thread = api.create_connect_secret(account_id, callback=callback_function) 266 267 :param callback function: The callback function 268 for asynchronous request. (optional) 269 :param str account_id: The external account number (int) or account ID Guid. (required) 270 :return: None 271 If the method is called asynchronously, 272 returns the request thread. 273 """ 274 kwargs['_return_http_data_only'] = True 275 if kwargs.get('callback'): 276 return self.create_connect_secret_with_http_info(account_id, **kwargs) 277 else: 278 (data) = self.create_connect_secret_with_http_info(account_id, **kwargs) 279 return data 280 281 def create_connect_secret_with_http_info(self, account_id, **kwargs): 282 """ 283 Generates a new connect HMAC Secret. 284 This method makes a synchronous HTTP request by default. To make an 285 asynchronous HTTP request, please define a `callback` function 286 to be invoked when receiving the response. 287 >>> def callback_function(response): 288 >>> pprint(response) 289 >>> 290 >>> thread = api.create_connect_secret_with_http_info(account_id, callback=callback_function) 291 292 :param callback function: The callback function 293 for asynchronous request. (optional) 294 :param str account_id: The external account number (int) or account ID Guid. (required) 295 :return: None 296 If the method is called asynchronously, 297 returns the request thread. 298 """ 299 300 all_params = ['account_id'] 301 all_params.append('callback') 302 all_params.append('_return_http_data_only') 303 all_params.append('_preload_content') 304 all_params.append('_request_timeout') 305 306 params = locals() 307 for key, val in iteritems(params['kwargs']): 308 if key not in all_params: 309 raise TypeError( 310 "Got an unexpected keyword argument '%s'" 311 " to method create_connect_secret" % key 312 ) 313 params[key] = val 314 del params['kwargs'] 315 # verify the required parameter 'account_id' is set 316 if ('account_id' not in params) or (params['account_id'] is None): 317 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_secret`") 318 319 320 collection_formats = {} 321 322 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 323 path_params = {} 324 if 'account_id' in params: 325 path_params['accountId'] = params['account_id'] 326 327 query_params = {} 328 329 header_params = {} 330 331 form_params = [] 332 local_var_files = {} 333 334 body_params = None 335 # HTTP header `Accept` 336 header_params['Accept'] = self.api_client.\ 337 select_header_accept(['application/json']) 338 339 # Authentication setting 340 auth_settings = [] 341 342 return self.api_client.call_api(resource_path, 'POST', 343 path_params, 344 query_params, 345 header_params, 346 body=body_params, 347 post_params=form_params, 348 files=local_var_files, 349 response_type=None, 350 auth_settings=auth_settings, 351 callback=params.get('callback'), 352 _return_http_data_only=params.get('_return_http_data_only'), 353 _preload_content=params.get('_preload_content', True), 354 _request_timeout=params.get('_request_timeout'), 355 collection_formats=collection_formats) 356 357 def delete_configuration(self, account_id, connect_id, **kwargs): 358 """ 359 Deletes the specified connect configuration. 360 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 361 This method makes a synchronous HTTP request by default. To make an 362 asynchronous HTTP request, please define a `callback` function 363 to be invoked when receiving the response. 364 >>> def callback_function(response): 365 >>> pprint(response) 366 >>> 367 >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function) 368 369 :param callback function: The callback function 370 for asynchronous request. (optional) 371 :param str account_id: The external account number (int) or account ID Guid. (required) 372 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 373 :return: None 374 If the method is called asynchronously, 375 returns the request thread. 376 """ 377 kwargs['_return_http_data_only'] = True 378 if kwargs.get('callback'): 379 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 380 else: 381 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 382 return data 383 384 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 385 """ 386 Deletes the specified connect configuration. 387 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 388 This method makes a synchronous HTTP request by default. To make an 389 asynchronous HTTP request, please define a `callback` function 390 to be invoked when receiving the response. 391 >>> def callback_function(response): 392 >>> pprint(response) 393 >>> 394 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 395 396 :param callback function: The callback function 397 for asynchronous request. (optional) 398 :param str account_id: The external account number (int) or account ID Guid. (required) 399 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 400 :return: None 401 If the method is called asynchronously, 402 returns the request thread. 403 """ 404 405 all_params = ['account_id', 'connect_id'] 406 all_params.append('callback') 407 all_params.append('_return_http_data_only') 408 all_params.append('_preload_content') 409 all_params.append('_request_timeout') 410 411 params = locals() 412 for key, val in iteritems(params['kwargs']): 413 if key not in all_params: 414 raise TypeError( 415 "Got an unexpected keyword argument '%s'" 416 " to method delete_configuration" % key 417 ) 418 params[key] = val 419 del params['kwargs'] 420 # verify the required parameter 'account_id' is set 421 if ('account_id' not in params) or (params['account_id'] is None): 422 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 423 # verify the required parameter 'connect_id' is set 424 if ('connect_id' not in params) or (params['connect_id'] is None): 425 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 426 427 428 collection_formats = {} 429 430 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 431 path_params = {} 432 if 'account_id' in params: 433 path_params['accountId'] = params['account_id'] 434 if 'connect_id' in params: 435 path_params['connectId'] = params['connect_id'] 436 437 query_params = {} 438 439 header_params = {} 440 441 form_params = [] 442 local_var_files = {} 443 444 body_params = None 445 # HTTP header `Accept` 446 header_params['Accept'] = self.api_client.\ 447 select_header_accept(['application/json']) 448 449 # Authentication setting 450 auth_settings = [] 451 452 return self.api_client.call_api(resource_path, 'DELETE', 453 path_params, 454 query_params, 455 header_params, 456 body=body_params, 457 post_params=form_params, 458 files=local_var_files, 459 response_type=None, 460 auth_settings=auth_settings, 461 callback=params.get('callback'), 462 _return_http_data_only=params.get('_return_http_data_only'), 463 _preload_content=params.get('_preload_content', True), 464 _request_timeout=params.get('_request_timeout'), 465 collection_formats=collection_formats) 466 467 def delete_connect_o_auth_config(self, account_id, **kwargs): 468 """ 469 Sets the Connect OAuth Config for the account. 470 This method makes a synchronous HTTP request by default. To make an 471 asynchronous HTTP request, please define a `callback` function 472 to be invoked when receiving the response. 473 >>> def callback_function(response): 474 >>> pprint(response) 475 >>> 476 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 477 478 :param callback function: The callback function 479 for asynchronous request. (optional) 480 :param str account_id: The external account number (int) or account ID Guid. (required) 481 :return: None 482 If the method is called asynchronously, 483 returns the request thread. 484 """ 485 kwargs['_return_http_data_only'] = True 486 if kwargs.get('callback'): 487 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 488 else: 489 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 490 return data 491 492 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 493 """ 494 Sets the Connect OAuth Config for the account. 495 This method makes a synchronous HTTP request by default. To make an 496 asynchronous HTTP request, please define a `callback` function 497 to be invoked when receiving the response. 498 >>> def callback_function(response): 499 >>> pprint(response) 500 >>> 501 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 502 503 :param callback function: The callback function 504 for asynchronous request. (optional) 505 :param str account_id: The external account number (int) or account ID Guid. (required) 506 :return: None 507 If the method is called asynchronously, 508 returns the request thread. 509 """ 510 511 all_params = ['account_id'] 512 all_params.append('callback') 513 all_params.append('_return_http_data_only') 514 all_params.append('_preload_content') 515 all_params.append('_request_timeout') 516 517 params = locals() 518 for key, val in iteritems(params['kwargs']): 519 if key not in all_params: 520 raise TypeError( 521 "Got an unexpected keyword argument '%s'" 522 " to method delete_connect_o_auth_config" % key 523 ) 524 params[key] = val 525 del params['kwargs'] 526 # verify the required parameter 'account_id' is set 527 if ('account_id' not in params) or (params['account_id'] is None): 528 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 529 530 531 collection_formats = {} 532 533 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 534 path_params = {} 535 if 'account_id' in params: 536 path_params['accountId'] = params['account_id'] 537 538 query_params = {} 539 540 header_params = {} 541 542 form_params = [] 543 local_var_files = {} 544 545 body_params = None 546 # HTTP header `Accept` 547 header_params['Accept'] = self.api_client.\ 548 select_header_accept(['application/json']) 549 550 # Authentication setting 551 auth_settings = [] 552 553 return self.api_client.call_api(resource_path, 'DELETE', 554 path_params, 555 query_params, 556 header_params, 557 body=body_params, 558 post_params=form_params, 559 files=local_var_files, 560 response_type=None, 561 auth_settings=auth_settings, 562 callback=params.get('callback'), 563 _return_http_data_only=params.get('_return_http_data_only'), 564 _preload_content=params.get('_preload_content', True), 565 _request_timeout=params.get('_request_timeout'), 566 collection_formats=collection_formats) 567 568 def delete_connect_secret(self, account_id, key_id, **kwargs): 569 """ 570 Delete the connect HMAC Secret for AccountID 571 This method makes a synchronous HTTP request by default. To make an 572 asynchronous HTTP request, please define a `callback` function 573 to be invoked when receiving the response. 574 >>> def callback_function(response): 575 >>> pprint(response) 576 >>> 577 >>> thread = api.delete_connect_secret(account_id, key_id, callback=callback_function) 578 579 :param callback function: The callback function 580 for asynchronous request. (optional) 581 :param str account_id: The external account number (int) or account ID Guid. (required) 582 :param str key_id: (required) 583 :return: None 584 If the method is called asynchronously, 585 returns the request thread. 586 """ 587 kwargs['_return_http_data_only'] = True 588 if kwargs.get('callback'): 589 return self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 590 else: 591 (data) = self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 592 return data 593 594 def delete_connect_secret_with_http_info(self, account_id, key_id, **kwargs): 595 """ 596 Delete the connect HMAC Secret for AccountID 597 This method makes a synchronous HTTP request by default. To make an 598 asynchronous HTTP request, please define a `callback` function 599 to be invoked when receiving the response. 600 >>> def callback_function(response): 601 >>> pprint(response) 602 >>> 603 >>> thread = api.delete_connect_secret_with_http_info(account_id, key_id, callback=callback_function) 604 605 :param callback function: The callback function 606 for asynchronous request. (optional) 607 :param str account_id: The external account number (int) or account ID Guid. (required) 608 :param str key_id: (required) 609 :return: None 610 If the method is called asynchronously, 611 returns the request thread. 612 """ 613 614 all_params = ['account_id', 'key_id'] 615 all_params.append('callback') 616 all_params.append('_return_http_data_only') 617 all_params.append('_preload_content') 618 all_params.append('_request_timeout') 619 620 params = locals() 621 for key, val in iteritems(params['kwargs']): 622 if key not in all_params: 623 raise TypeError( 624 "Got an unexpected keyword argument '%s'" 625 " to method delete_connect_secret" % key 626 ) 627 params[key] = val 628 del params['kwargs'] 629 # verify the required parameter 'account_id' is set 630 if ('account_id' not in params) or (params['account_id'] is None): 631 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_secret`") 632 # verify the required parameter 'key_id' is set 633 if ('key_id' not in params) or (params['key_id'] is None): 634 raise ValueError("Missing the required parameter `key_id` when calling `delete_connect_secret`") 635 636 637 collection_formats = {} 638 639 resource_path = '/v2.1/accounts/{accountId}/connect/secret/{keyId}'.replace('{format}', 'json') 640 path_params = {} 641 if 'account_id' in params: 642 path_params['accountId'] = params['account_id'] 643 if 'key_id' in params: 644 path_params['keyId'] = params['key_id'] 645 646 query_params = {} 647 648 header_params = {} 649 650 form_params = [] 651 local_var_files = {} 652 653 body_params = None 654 # HTTP header `Accept` 655 header_params['Accept'] = self.api_client.\ 656 select_header_accept(['application/json']) 657 658 # Authentication setting 659 auth_settings = [] 660 661 return self.api_client.call_api(resource_path, 'DELETE', 662 path_params, 663 query_params, 664 header_params, 665 body=body_params, 666 post_params=form_params, 667 files=local_var_files, 668 response_type=None, 669 auth_settings=auth_settings, 670 callback=params.get('callback'), 671 _return_http_data_only=params.get('_return_http_data_only'), 672 _preload_content=params.get('_preload_content', True), 673 _request_timeout=params.get('_request_timeout'), 674 collection_formats=collection_formats) 675 676 def delete_event_failure_log(self, account_id, failure_id, **kwargs): 677 """ 678 Deletes a Connect failure log entry. 679 Deletes the Connect failure log information for the specified entry. 680 This method makes a synchronous HTTP request by default. To make an 681 asynchronous HTTP request, please define a `callback` function 682 to be invoked when receiving the response. 683 >>> def callback_function(response): 684 >>> pprint(response) 685 >>> 686 >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function) 687 688 :param callback function: The callback function 689 for asynchronous request. (optional) 690 :param str account_id: The external account number (int) or account ID Guid. (required) 691 :param str failure_id: The ID of the failed connect log entry. (required) 692 :return: ConnectDeleteFailureResult 693 If the method is called asynchronously, 694 returns the request thread. 695 """ 696 kwargs['_return_http_data_only'] = True 697 if kwargs.get('callback'): 698 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 699 else: 700 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 701 return data 702 703 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 704 """ 705 Deletes a Connect failure log entry. 706 Deletes the Connect failure log information for the specified entry. 707 This method makes a synchronous HTTP request by default. To make an 708 asynchronous HTTP request, please define a `callback` function 709 to be invoked when receiving the response. 710 >>> def callback_function(response): 711 >>> pprint(response) 712 >>> 713 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 714 715 :param callback function: The callback function 716 for asynchronous request. (optional) 717 :param str account_id: The external account number (int) or account ID Guid. (required) 718 :param str failure_id: The ID of the failed connect log entry. (required) 719 :return: ConnectDeleteFailureResult 720 If the method is called asynchronously, 721 returns the request thread. 722 """ 723 724 all_params = ['account_id', 'failure_id'] 725 all_params.append('callback') 726 all_params.append('_return_http_data_only') 727 all_params.append('_preload_content') 728 all_params.append('_request_timeout') 729 730 params = locals() 731 for key, val in iteritems(params['kwargs']): 732 if key not in all_params: 733 raise TypeError( 734 "Got an unexpected keyword argument '%s'" 735 " to method delete_event_failure_log" % key 736 ) 737 params[key] = val 738 del params['kwargs'] 739 # verify the required parameter 'account_id' is set 740 if ('account_id' not in params) or (params['account_id'] is None): 741 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 742 # verify the required parameter 'failure_id' is set 743 if ('failure_id' not in params) or (params['failure_id'] is None): 744 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 745 746 747 collection_formats = {} 748 749 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 750 path_params = {} 751 if 'account_id' in params: 752 path_params['accountId'] = params['account_id'] 753 if 'failure_id' in params: 754 path_params['failureId'] = params['failure_id'] 755 756 query_params = {} 757 758 header_params = {} 759 760 form_params = [] 761 local_var_files = {} 762 763 body_params = None 764 # HTTP header `Accept` 765 header_params['Accept'] = self.api_client.\ 766 select_header_accept(['application/json']) 767 768 # Authentication setting 769 auth_settings = [] 770 771 return self.api_client.call_api(resource_path, 'DELETE', 772 path_params, 773 query_params, 774 header_params, 775 body=body_params, 776 post_params=form_params, 777 files=local_var_files, 778 response_type='ConnectDeleteFailureResult', 779 auth_settings=auth_settings, 780 callback=params.get('callback'), 781 _return_http_data_only=params.get('_return_http_data_only'), 782 _preload_content=params.get('_preload_content', True), 783 _request_timeout=params.get('_request_timeout'), 784 collection_formats=collection_formats) 785 786 def delete_event_log(self, account_id, log_id, **kwargs): 787 """ 788 Deletes a specified Connect log entry. 789 Deletes a specified entry from the Connect Log. 790 This method makes a synchronous HTTP request by default. To make an 791 asynchronous HTTP request, please define a `callback` function 792 to be invoked when receiving the response. 793 >>> def callback_function(response): 794 >>> pprint(response) 795 >>> 796 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 797 798 :param callback function: The callback function 799 for asynchronous request. (optional) 800 :param str account_id: The external account number (int) or account ID Guid. (required) 801 :param str log_id: The ID of the connect log entry (required) 802 :return: None 803 If the method is called asynchronously, 804 returns the request thread. 805 """ 806 kwargs['_return_http_data_only'] = True 807 if kwargs.get('callback'): 808 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 809 else: 810 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 811 return data 812 813 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 814 """ 815 Deletes a specified Connect log entry. 816 Deletes a specified entry from the Connect Log. 817 This method makes a synchronous HTTP request by default. To make an 818 asynchronous HTTP request, please define a `callback` function 819 to be invoked when receiving the response. 820 >>> def callback_function(response): 821 >>> pprint(response) 822 >>> 823 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 824 825 :param callback function: The callback function 826 for asynchronous request. (optional) 827 :param str account_id: The external account number (int) or account ID Guid. (required) 828 :param str log_id: The ID of the connect log entry (required) 829 :return: None 830 If the method is called asynchronously, 831 returns the request thread. 832 """ 833 834 all_params = ['account_id', 'log_id'] 835 all_params.append('callback') 836 all_params.append('_return_http_data_only') 837 all_params.append('_preload_content') 838 all_params.append('_request_timeout') 839 840 params = locals() 841 for key, val in iteritems(params['kwargs']): 842 if key not in all_params: 843 raise TypeError( 844 "Got an unexpected keyword argument '%s'" 845 " to method delete_event_log" % key 846 ) 847 params[key] = val 848 del params['kwargs'] 849 # verify the required parameter 'account_id' is set 850 if ('account_id' not in params) or (params['account_id'] is None): 851 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 852 # verify the required parameter 'log_id' is set 853 if ('log_id' not in params) or (params['log_id'] is None): 854 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 855 856 857 collection_formats = {} 858 859 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 860 path_params = {} 861 if 'account_id' in params: 862 path_params['accountId'] = params['account_id'] 863 if 'log_id' in params: 864 path_params['logId'] = params['log_id'] 865 866 query_params = {} 867 868 header_params = {} 869 870 form_params = [] 871 local_var_files = {} 872 873 body_params = None 874 # HTTP header `Accept` 875 header_params['Accept'] = self.api_client.\ 876 select_header_accept(['application/json']) 877 878 # Authentication setting 879 auth_settings = [] 880 881 return self.api_client.call_api(resource_path, 'DELETE', 882 path_params, 883 query_params, 884 header_params, 885 body=body_params, 886 post_params=form_params, 887 files=local_var_files, 888 response_type=None, 889 auth_settings=auth_settings, 890 callback=params.get('callback'), 891 _return_http_data_only=params.get('_return_http_data_only'), 892 _preload_content=params.get('_preload_content', True), 893 _request_timeout=params.get('_request_timeout'), 894 collection_formats=collection_formats) 895 896 def delete_event_logs(self, account_id, **kwargs): 897 """ 898 Gets a list of Connect log entries. 899 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 900 This method makes a synchronous HTTP request by default. To make an 901 asynchronous HTTP request, please define a `callback` function 902 to be invoked when receiving the response. 903 >>> def callback_function(response): 904 >>> pprint(response) 905 >>> 906 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 907 908 :param callback function: The callback function 909 for asynchronous request. (optional) 910 :param str account_id: The external account number (int) or account ID Guid. (required) 911 :return: None 912 If the method is called asynchronously, 913 returns the request thread. 914 """ 915 kwargs['_return_http_data_only'] = True 916 if kwargs.get('callback'): 917 return self.delete_event_logs_with_http_info(account_id, **kwargs) 918 else: 919 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 920 return data 921 922 def delete_event_logs_with_http_info(self, account_id, **kwargs): 923 """ 924 Gets a list of Connect log entries. 925 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 926 This method makes a synchronous HTTP request by default. To make an 927 asynchronous HTTP request, please define a `callback` function 928 to be invoked when receiving the response. 929 >>> def callback_function(response): 930 >>> pprint(response) 931 >>> 932 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 933 934 :param callback function: The callback function 935 for asynchronous request. (optional) 936 :param str account_id: The external account number (int) or account ID Guid. (required) 937 :return: None 938 If the method is called asynchronously, 939 returns the request thread. 940 """ 941 942 all_params = ['account_id'] 943 all_params.append('callback') 944 all_params.append('_return_http_data_only') 945 all_params.append('_preload_content') 946 all_params.append('_request_timeout') 947 948 params = locals() 949 for key, val in iteritems(params['kwargs']): 950 if key not in all_params: 951 raise TypeError( 952 "Got an unexpected keyword argument '%s'" 953 " to method delete_event_logs" % key 954 ) 955 params[key] = val 956 del params['kwargs'] 957 # verify the required parameter 'account_id' is set 958 if ('account_id' not in params) or (params['account_id'] is None): 959 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 960 961 962 collection_formats = {} 963 964 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 965 path_params = {} 966 if 'account_id' in params: 967 path_params['accountId'] = params['account_id'] 968 969 query_params = {} 970 971 header_params = {} 972 973 form_params = [] 974 local_var_files = {} 975 976 body_params = None 977 # HTTP header `Accept` 978 header_params['Accept'] = self.api_client.\ 979 select_header_accept(['application/json']) 980 981 # Authentication setting 982 auth_settings = [] 983 984 return self.api_client.call_api(resource_path, 'DELETE', 985 path_params, 986 query_params, 987 header_params, 988 body=body_params, 989 post_params=form_params, 990 files=local_var_files, 991 response_type=None, 992 auth_settings=auth_settings, 993 callback=params.get('callback'), 994 _return_http_data_only=params.get('_return_http_data_only'), 995 _preload_content=params.get('_preload_content', True), 996 _request_timeout=params.get('_request_timeout'), 997 collection_formats=collection_formats) 998 999 def delete_mobile_notifiers(self, account_id, **kwargs): 1000 """ 1001 Reserved 1002 Reserved: 1003 This method makes a synchronous HTTP request by default. To make an 1004 asynchronous HTTP request, please define a `callback` function 1005 to be invoked when receiving the response. 1006 >>> def callback_function(response): 1007 >>> pprint(response) 1008 >>> 1009 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 1010 1011 :param callback function: The callback function 1012 for asynchronous request. (optional) 1013 :param str account_id: The external account number (int) or account ID Guid. (required) 1014 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1015 :return: MobileNotifierConfigurationInformation 1016 If the method is called asynchronously, 1017 returns the request thread. 1018 """ 1019 kwargs['_return_http_data_only'] = True 1020 if kwargs.get('callback'): 1021 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1022 else: 1023 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1024 return data 1025 1026 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1027 """ 1028 Reserved 1029 Reserved: 1030 This method makes a synchronous HTTP request by default. To make an 1031 asynchronous HTTP request, please define a `callback` function 1032 to be invoked when receiving the response. 1033 >>> def callback_function(response): 1034 >>> pprint(response) 1035 >>> 1036 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1037 1038 :param callback function: The callback function 1039 for asynchronous request. (optional) 1040 :param str account_id: The external account number (int) or account ID Guid. (required) 1041 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1042 :return: MobileNotifierConfigurationInformation 1043 If the method is called asynchronously, 1044 returns the request thread. 1045 """ 1046 1047 all_params = ['account_id', 'mobile_notifier_configuration_information'] 1048 all_params.append('callback') 1049 all_params.append('_return_http_data_only') 1050 all_params.append('_preload_content') 1051 all_params.append('_request_timeout') 1052 1053 params = locals() 1054 for key, val in iteritems(params['kwargs']): 1055 if key not in all_params: 1056 raise TypeError( 1057 "Got an unexpected keyword argument '%s'" 1058 " to method delete_mobile_notifiers" % key 1059 ) 1060 params[key] = val 1061 del params['kwargs'] 1062 # verify the required parameter 'account_id' is set 1063 if ('account_id' not in params) or (params['account_id'] is None): 1064 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 1065 1066 1067 collection_formats = {} 1068 1069 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1070 path_params = {} 1071 if 'account_id' in params: 1072 path_params['accountId'] = params['account_id'] 1073 1074 query_params = {} 1075 1076 header_params = {} 1077 1078 form_params = [] 1079 local_var_files = {} 1080 1081 body_params = None 1082 if 'mobile_notifier_configuration_information' in params: 1083 body_params = params['mobile_notifier_configuration_information'] 1084 # HTTP header `Accept` 1085 header_params['Accept'] = self.api_client.\ 1086 select_header_accept(['application/json']) 1087 1088 # Authentication setting 1089 auth_settings = [] 1090 1091 return self.api_client.call_api(resource_path, 'DELETE', 1092 path_params, 1093 query_params, 1094 header_params, 1095 body=body_params, 1096 post_params=form_params, 1097 files=local_var_files, 1098 response_type='MobileNotifierConfigurationInformation', 1099 auth_settings=auth_settings, 1100 callback=params.get('callback'), 1101 _return_http_data_only=params.get('_return_http_data_only'), 1102 _preload_content=params.get('_preload_content', True), 1103 _request_timeout=params.get('_request_timeout'), 1104 collection_formats=collection_formats) 1105 1106 def get_configuration(self, account_id, connect_id, **kwargs): 1107 """ 1108 Get a Connect Configuration Information 1109 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1110 This method makes a synchronous HTTP request by default. To make an 1111 asynchronous HTTP request, please define a `callback` function 1112 to be invoked when receiving the response. 1113 >>> def callback_function(response): 1114 >>> pprint(response) 1115 >>> 1116 >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function) 1117 1118 :param callback function: The callback function 1119 for asynchronous request. (optional) 1120 :param str account_id: The external account number (int) or account ID Guid. (required) 1121 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1122 :return: ConnectConfigResults 1123 If the method is called asynchronously, 1124 returns the request thread. 1125 """ 1126 kwargs['_return_http_data_only'] = True 1127 if kwargs.get('callback'): 1128 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1129 else: 1130 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1131 return data 1132 1133 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 1134 """ 1135 Get a Connect Configuration Information 1136 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1137 This method makes a synchronous HTTP request by default. To make an 1138 asynchronous HTTP request, please define a `callback` function 1139 to be invoked when receiving the response. 1140 >>> def callback_function(response): 1141 >>> pprint(response) 1142 >>> 1143 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 1144 1145 :param callback function: The callback function 1146 for asynchronous request. (optional) 1147 :param str account_id: The external account number (int) or account ID Guid. (required) 1148 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1149 :return: ConnectConfigResults 1150 If the method is called asynchronously, 1151 returns the request thread. 1152 """ 1153 1154 all_params = ['account_id', 'connect_id'] 1155 all_params.append('callback') 1156 all_params.append('_return_http_data_only') 1157 all_params.append('_preload_content') 1158 all_params.append('_request_timeout') 1159 1160 params = locals() 1161 for key, val in iteritems(params['kwargs']): 1162 if key not in all_params: 1163 raise TypeError( 1164 "Got an unexpected keyword argument '%s'" 1165 " to method get_configuration" % key 1166 ) 1167 params[key] = val 1168 del params['kwargs'] 1169 # verify the required parameter 'account_id' is set 1170 if ('account_id' not in params) or (params['account_id'] is None): 1171 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 1172 # verify the required parameter 'connect_id' is set 1173 if ('connect_id' not in params) or (params['connect_id'] is None): 1174 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 1175 1176 1177 collection_formats = {} 1178 1179 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 1180 path_params = {} 1181 if 'account_id' in params: 1182 path_params['accountId'] = params['account_id'] 1183 if 'connect_id' in params: 1184 path_params['connectId'] = params['connect_id'] 1185 1186 query_params = {} 1187 1188 header_params = {} 1189 1190 form_params = [] 1191 local_var_files = {} 1192 1193 body_params = None 1194 # HTTP header `Accept` 1195 header_params['Accept'] = self.api_client.\ 1196 select_header_accept(['application/json']) 1197 1198 # Authentication setting 1199 auth_settings = [] 1200 1201 return self.api_client.call_api(resource_path, 'GET', 1202 path_params, 1203 query_params, 1204 header_params, 1205 body=body_params, 1206 post_params=form_params, 1207 files=local_var_files, 1208 response_type='ConnectConfigResults', 1209 auth_settings=auth_settings, 1210 callback=params.get('callback'), 1211 _return_http_data_only=params.get('_return_http_data_only'), 1212 _preload_content=params.get('_preload_content', True), 1213 _request_timeout=params.get('_request_timeout'), 1214 collection_formats=collection_formats) 1215 1216 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1217 """ 1218 Returns all users from the configured Connect service. 1219 1220 This method makes a synchronous HTTP request by default. To make an 1221 asynchronous HTTP request, please define a `callback` function 1222 to be invoked when receiving the response. 1223 >>> def callback_function(response): 1224 >>> pprint(response) 1225 >>> 1226 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1227 1228 :param callback function: The callback function 1229 for asynchronous request. (optional) 1230 :param str account_id: The external account number (int) or account ID Guid. (required) 1231 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1232 :param str count: 1233 :param str domain_users_only: 1234 :param str email_substring: 1235 :param str start_position: 1236 :param str status: 1237 :param str user_name_substring: 1238 :return: IntegratedConnectUserInfoList 1239 If the method is called asynchronously, 1240 returns the request thread. 1241 """ 1242 kwargs['_return_http_data_only'] = True 1243 if kwargs.get('callback'): 1244 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1245 else: 1246 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1247 return data 1248 1249 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1250 """ 1251 Returns all users from the configured Connect service. 1252 1253 This method makes a synchronous HTTP request by default. To make an 1254 asynchronous HTTP request, please define a `callback` function 1255 to be invoked when receiving the response. 1256 >>> def callback_function(response): 1257 >>> pprint(response) 1258 >>> 1259 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1260 1261 :param callback function: The callback function 1262 for asynchronous request. (optional) 1263 :param str account_id: The external account number (int) or account ID Guid. (required) 1264 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1265 :param str count: 1266 :param str domain_users_only: 1267 :param str email_substring: 1268 :param str start_position: 1269 :param str status: 1270 :param str user_name_substring: 1271 :return: IntegratedConnectUserInfoList 1272 If the method is called asynchronously, 1273 returns the request thread. 1274 """ 1275 1276 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1277 all_params.append('callback') 1278 all_params.append('_return_http_data_only') 1279 all_params.append('_preload_content') 1280 all_params.append('_request_timeout') 1281 1282 params = locals() 1283 for key, val in iteritems(params['kwargs']): 1284 if key not in all_params: 1285 raise TypeError( 1286 "Got an unexpected keyword argument '%s'" 1287 " to method get_connect_all_users" % key 1288 ) 1289 params[key] = val 1290 del params['kwargs'] 1291 # verify the required parameter 'account_id' is set 1292 if ('account_id' not in params) or (params['account_id'] is None): 1293 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1294 # verify the required parameter 'connect_id' is set 1295 if ('connect_id' not in params) or (params['connect_id'] is None): 1296 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1297 1298 1299 collection_formats = {} 1300 1301 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1302 path_params = {} 1303 if 'account_id' in params: 1304 path_params['accountId'] = params['account_id'] 1305 if 'connect_id' in params: 1306 path_params['connectId'] = params['connect_id'] 1307 1308 query_params = {} 1309 if 'count' in params: 1310 query_params['count'] = params['count'] 1311 if 'domain_users_only' in params: 1312 query_params['domain_users_only'] = params['domain_users_only'] 1313 if 'email_substring' in params: 1314 query_params['email_substring'] = params['email_substring'] 1315 if 'start_position' in params: 1316 query_params['start_position'] = params['start_position'] 1317 if 'status' in params: 1318 query_params['status'] = params['status'] 1319 if 'user_name_substring' in params: 1320 query_params['user_name_substring'] = params['user_name_substring'] 1321 1322 header_params = {} 1323 1324 form_params = [] 1325 local_var_files = {} 1326 1327 body_params = None 1328 # HTTP header `Accept` 1329 header_params['Accept'] = self.api_client.\ 1330 select_header_accept(['application/json']) 1331 1332 # Authentication setting 1333 auth_settings = [] 1334 1335 return self.api_client.call_api(resource_path, 'GET', 1336 path_params, 1337 query_params, 1338 header_params, 1339 body=body_params, 1340 post_params=form_params, 1341 files=local_var_files, 1342 response_type='IntegratedConnectUserInfoList', 1343 auth_settings=auth_settings, 1344 callback=params.get('callback'), 1345 _return_http_data_only=params.get('_return_http_data_only'), 1346 _preload_content=params.get('_preload_content', True), 1347 _request_timeout=params.get('_request_timeout'), 1348 collection_formats=collection_formats) 1349 1350 def get_connect_o_auth_config(self, account_id, **kwargs): 1351 """ 1352 Sets the Connect OAuth Config for the account. 1353 This method makes a synchronous HTTP request by default. To make an 1354 asynchronous HTTP request, please define a `callback` function 1355 to be invoked when receiving the response. 1356 >>> def callback_function(response): 1357 >>> pprint(response) 1358 >>> 1359 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1360 1361 :param callback function: The callback function 1362 for asynchronous request. (optional) 1363 :param str account_id: The external account number (int) or account ID Guid. (required) 1364 :return: ConnectOAuthConfig 1365 If the method is called asynchronously, 1366 returns the request thread. 1367 """ 1368 kwargs['_return_http_data_only'] = True 1369 if kwargs.get('callback'): 1370 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1371 else: 1372 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1373 return data 1374 1375 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1376 """ 1377 Sets the Connect OAuth Config for the account. 1378 This method makes a synchronous HTTP request by default. To make an 1379 asynchronous HTTP request, please define a `callback` function 1380 to be invoked when receiving the response. 1381 >>> def callback_function(response): 1382 >>> pprint(response) 1383 >>> 1384 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1385 1386 :param callback function: The callback function 1387 for asynchronous request. (optional) 1388 :param str account_id: The external account number (int) or account ID Guid. (required) 1389 :return: ConnectOAuthConfig 1390 If the method is called asynchronously, 1391 returns the request thread. 1392 """ 1393 1394 all_params = ['account_id'] 1395 all_params.append('callback') 1396 all_params.append('_return_http_data_only') 1397 all_params.append('_preload_content') 1398 all_params.append('_request_timeout') 1399 1400 params = locals() 1401 for key, val in iteritems(params['kwargs']): 1402 if key not in all_params: 1403 raise TypeError( 1404 "Got an unexpected keyword argument '%s'" 1405 " to method get_connect_o_auth_config" % key 1406 ) 1407 params[key] = val 1408 del params['kwargs'] 1409 # verify the required parameter 'account_id' is set 1410 if ('account_id' not in params) or (params['account_id'] is None): 1411 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1412 1413 1414 collection_formats = {} 1415 1416 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1417 path_params = {} 1418 if 'account_id' in params: 1419 path_params['accountId'] = params['account_id'] 1420 1421 query_params = {} 1422 1423 header_params = {} 1424 1425 form_params = [] 1426 local_var_files = {} 1427 1428 body_params = None 1429 # HTTP header `Accept` 1430 header_params['Accept'] = self.api_client.\ 1431 select_header_accept(['application/json']) 1432 1433 # Authentication setting 1434 auth_settings = [] 1435 1436 return self.api_client.call_api(resource_path, 'GET', 1437 path_params, 1438 query_params, 1439 header_params, 1440 body=body_params, 1441 post_params=form_params, 1442 files=local_var_files, 1443 response_type='ConnectOAuthConfig', 1444 auth_settings=auth_settings, 1445 callback=params.get('callback'), 1446 _return_http_data_only=params.get('_return_http_data_only'), 1447 _preload_content=params.get('_preload_content', True), 1448 _request_timeout=params.get('_request_timeout'), 1449 collection_formats=collection_formats) 1450 1451 def get_connect_secret(self, account_id, **kwargs): 1452 """ 1453 Get the connect HMAC Secrets for AccountID 1454 This method makes a synchronous HTTP request by default. To make an 1455 asynchronous HTTP request, please define a `callback` function 1456 to be invoked when receiving the response. 1457 >>> def callback_function(response): 1458 >>> pprint(response) 1459 >>> 1460 >>> thread = api.get_connect_secret(account_id, callback=callback_function) 1461 1462 :param callback function: The callback function 1463 for asynchronous request. (optional) 1464 :param str account_id: The external account number (int) or account ID Guid. (required) 1465 :return: None 1466 If the method is called asynchronously, 1467 returns the request thread. 1468 """ 1469 kwargs['_return_http_data_only'] = True 1470 if kwargs.get('callback'): 1471 return self.get_connect_secret_with_http_info(account_id, **kwargs) 1472 else: 1473 (data) = self.get_connect_secret_with_http_info(account_id, **kwargs) 1474 return data 1475 1476 def get_connect_secret_with_http_info(self, account_id, **kwargs): 1477 """ 1478 Get the connect HMAC Secrets for AccountID 1479 This method makes a synchronous HTTP request by default. To make an 1480 asynchronous HTTP request, please define a `callback` function 1481 to be invoked when receiving the response. 1482 >>> def callback_function(response): 1483 >>> pprint(response) 1484 >>> 1485 >>> thread = api.get_connect_secret_with_http_info(account_id, callback=callback_function) 1486 1487 :param callback function: The callback function 1488 for asynchronous request. (optional) 1489 :param str account_id: The external account number (int) or account ID Guid. (required) 1490 :return: None 1491 If the method is called asynchronously, 1492 returns the request thread. 1493 """ 1494 1495 all_params = ['account_id'] 1496 all_params.append('callback') 1497 all_params.append('_return_http_data_only') 1498 all_params.append('_preload_content') 1499 all_params.append('_request_timeout') 1500 1501 params = locals() 1502 for key, val in iteritems(params['kwargs']): 1503 if key not in all_params: 1504 raise TypeError( 1505 "Got an unexpected keyword argument '%s'" 1506 " to method get_connect_secret" % key 1507 ) 1508 params[key] = val 1509 del params['kwargs'] 1510 # verify the required parameter 'account_id' is set 1511 if ('account_id' not in params) or (params['account_id'] is None): 1512 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_secret`") 1513 1514 1515 collection_formats = {} 1516 1517 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 1518 path_params = {} 1519 if 'account_id' in params: 1520 path_params['accountId'] = params['account_id'] 1521 1522 query_params = {} 1523 1524 header_params = {} 1525 1526 form_params = [] 1527 local_var_files = {} 1528 1529 body_params = None 1530 # HTTP header `Accept` 1531 header_params['Accept'] = self.api_client.\ 1532 select_header_accept(['application/json']) 1533 1534 # Authentication setting 1535 auth_settings = [] 1536 1537 return self.api_client.call_api(resource_path, 'GET', 1538 path_params, 1539 query_params, 1540 header_params, 1541 body=body_params, 1542 post_params=form_params, 1543 files=local_var_files, 1544 response_type=None, 1545 auth_settings=auth_settings, 1546 callback=params.get('callback'), 1547 _return_http_data_only=params.get('_return_http_data_only'), 1548 _preload_content=params.get('_preload_content', True), 1549 _request_timeout=params.get('_request_timeout'), 1550 collection_formats=collection_formats) 1551 1552 def get_event_log(self, account_id, log_id, **kwargs): 1553 """ 1554 Get the specified Connect log entry. 1555 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1556 This method makes a synchronous HTTP request by default. To make an 1557 asynchronous HTTP request, please define a `callback` function 1558 to be invoked when receiving the response. 1559 >>> def callback_function(response): 1560 >>> pprint(response) 1561 >>> 1562 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1563 1564 :param callback function: The callback function 1565 for asynchronous request. (optional) 1566 :param str account_id: The external account number (int) or account ID Guid. (required) 1567 :param str log_id: The ID of the connect log entry (required) 1568 :param str additional_info: When true, the connectDebugLog information is included in the response. 1569 :return: ConnectLog 1570 If the method is called asynchronously, 1571 returns the request thread. 1572 """ 1573 kwargs['_return_http_data_only'] = True 1574 if kwargs.get('callback'): 1575 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1576 else: 1577 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1578 return data 1579 1580 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1581 """ 1582 Get the specified Connect log entry. 1583 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1584 This method makes a synchronous HTTP request by default. To make an 1585 asynchronous HTTP request, please define a `callback` function 1586 to be invoked when receiving the response. 1587 >>> def callback_function(response): 1588 >>> pprint(response) 1589 >>> 1590 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1591 1592 :param callback function: The callback function 1593 for asynchronous request. (optional) 1594 :param str account_id: The external account number (int) or account ID Guid. (required) 1595 :param str log_id: The ID of the connect log entry (required) 1596 :param str additional_info: When true, the connectDebugLog information is included in the response. 1597 :return: ConnectLog 1598 If the method is called asynchronously, 1599 returns the request thread. 1600 """ 1601 1602 all_params = ['account_id', 'log_id', 'additional_info'] 1603 all_params.append('callback') 1604 all_params.append('_return_http_data_only') 1605 all_params.append('_preload_content') 1606 all_params.append('_request_timeout') 1607 1608 params = locals() 1609 for key, val in iteritems(params['kwargs']): 1610 if key not in all_params: 1611 raise TypeError( 1612 "Got an unexpected keyword argument '%s'" 1613 " to method get_event_log" % key 1614 ) 1615 params[key] = val 1616 del params['kwargs'] 1617 # verify the required parameter 'account_id' is set 1618 if ('account_id' not in params) or (params['account_id'] is None): 1619 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1620 # verify the required parameter 'log_id' is set 1621 if ('log_id' not in params) or (params['log_id'] is None): 1622 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1623 1624 1625 collection_formats = {} 1626 1627 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1628 path_params = {} 1629 if 'account_id' in params: 1630 path_params['accountId'] = params['account_id'] 1631 if 'log_id' in params: 1632 path_params['logId'] = params['log_id'] 1633 1634 query_params = {} 1635 if 'additional_info' in params: 1636 query_params['additional_info'] = params['additional_info'] 1637 1638 header_params = {} 1639 1640 form_params = [] 1641 local_var_files = {} 1642 1643 body_params = None 1644 # HTTP header `Accept` 1645 header_params['Accept'] = self.api_client.\ 1646 select_header_accept(['application/json']) 1647 1648 # Authentication setting 1649 auth_settings = [] 1650 1651 return self.api_client.call_api(resource_path, 'GET', 1652 path_params, 1653 query_params, 1654 header_params, 1655 body=body_params, 1656 post_params=form_params, 1657 files=local_var_files, 1658 response_type='ConnectLog', 1659 auth_settings=auth_settings, 1660 callback=params.get('callback'), 1661 _return_http_data_only=params.get('_return_http_data_only'), 1662 _preload_content=params.get('_preload_content', True), 1663 _request_timeout=params.get('_request_timeout'), 1664 collection_formats=collection_formats) 1665 1666 def list_configurations(self, account_id, **kwargs): 1667 """ 1668 Get Connect Configuration Information 1669 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1670 This method makes a synchronous HTTP request by default. To make an 1671 asynchronous HTTP request, please define a `callback` function 1672 to be invoked when receiving the response. 1673 >>> def callback_function(response): 1674 >>> pprint(response) 1675 >>> 1676 >>> thread = api.list_configurations(account_id, callback=callback_function) 1677 1678 :param callback function: The callback function 1679 for asynchronous request. (optional) 1680 :param str account_id: The external account number (int) or account ID Guid. (required) 1681 :return: ConnectConfigResults 1682 If the method is called asynchronously, 1683 returns the request thread. 1684 """ 1685 kwargs['_return_http_data_only'] = True 1686 if kwargs.get('callback'): 1687 return self.list_configurations_with_http_info(account_id, **kwargs) 1688 else: 1689 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1690 return data 1691 1692 def list_configurations_with_http_info(self, account_id, **kwargs): 1693 """ 1694 Get Connect Configuration Information 1695 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1696 This method makes a synchronous HTTP request by default. To make an 1697 asynchronous HTTP request, please define a `callback` function 1698 to be invoked when receiving the response. 1699 >>> def callback_function(response): 1700 >>> pprint(response) 1701 >>> 1702 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1703 1704 :param callback function: The callback function 1705 for asynchronous request. (optional) 1706 :param str account_id: The external account number (int) or account ID Guid. (required) 1707 :return: ConnectConfigResults 1708 If the method is called asynchronously, 1709 returns the request thread. 1710 """ 1711 1712 all_params = ['account_id'] 1713 all_params.append('callback') 1714 all_params.append('_return_http_data_only') 1715 all_params.append('_preload_content') 1716 all_params.append('_request_timeout') 1717 1718 params = locals() 1719 for key, val in iteritems(params['kwargs']): 1720 if key not in all_params: 1721 raise TypeError( 1722 "Got an unexpected keyword argument '%s'" 1723 " to method list_configurations" % key 1724 ) 1725 params[key] = val 1726 del params['kwargs'] 1727 # verify the required parameter 'account_id' is set 1728 if ('account_id' not in params) or (params['account_id'] is None): 1729 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1730 1731 1732 collection_formats = {} 1733 1734 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1735 path_params = {} 1736 if 'account_id' in params: 1737 path_params['accountId'] = params['account_id'] 1738 1739 query_params = {} 1740 1741 header_params = {} 1742 1743 form_params = [] 1744 local_var_files = {} 1745 1746 body_params = None 1747 # HTTP header `Accept` 1748 header_params['Accept'] = self.api_client.\ 1749 select_header_accept(['application/json']) 1750 1751 # Authentication setting 1752 auth_settings = [] 1753 1754 return self.api_client.call_api(resource_path, 'GET', 1755 path_params, 1756 query_params, 1757 header_params, 1758 body=body_params, 1759 post_params=form_params, 1760 files=local_var_files, 1761 response_type='ConnectConfigResults', 1762 auth_settings=auth_settings, 1763 callback=params.get('callback'), 1764 _return_http_data_only=params.get('_return_http_data_only'), 1765 _preload_content=params.get('_preload_content', True), 1766 _request_timeout=params.get('_request_timeout'), 1767 collection_formats=collection_formats) 1768 1769 def list_event_failure_logs(self, account_id, **kwargs): 1770 """ 1771 Gets the Connect failure log information. 1772 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1773 This method makes a synchronous HTTP request by default. To make an 1774 asynchronous HTTP request, please define a `callback` function 1775 to be invoked when receiving the response. 1776 >>> def callback_function(response): 1777 >>> pprint(response) 1778 >>> 1779 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1780 1781 :param callback function: The callback function 1782 for asynchronous request. (optional) 1783 :param str account_id: The external account number (int) or account ID Guid. (required) 1784 :param str from_date: 1785 :param str to_date: 1786 :return: ConnectLogs 1787 If the method is called asynchronously, 1788 returns the request thread. 1789 """ 1790 kwargs['_return_http_data_only'] = True 1791 if kwargs.get('callback'): 1792 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1793 else: 1794 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1795 return data 1796 1797 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1798 """ 1799 Gets the Connect failure log information. 1800 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1801 This method makes a synchronous HTTP request by default. To make an 1802 asynchronous HTTP request, please define a `callback` function 1803 to be invoked when receiving the response. 1804 >>> def callback_function(response): 1805 >>> pprint(response) 1806 >>> 1807 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1808 1809 :param callback function: The callback function 1810 for asynchronous request. (optional) 1811 :param str account_id: The external account number (int) or account ID Guid. (required) 1812 :param str from_date: 1813 :param str to_date: 1814 :return: ConnectLogs 1815 If the method is called asynchronously, 1816 returns the request thread. 1817 """ 1818 1819 all_params = ['account_id', 'from_date', 'to_date'] 1820 all_params.append('callback') 1821 all_params.append('_return_http_data_only') 1822 all_params.append('_preload_content') 1823 all_params.append('_request_timeout') 1824 1825 params = locals() 1826 for key, val in iteritems(params['kwargs']): 1827 if key not in all_params: 1828 raise TypeError( 1829 "Got an unexpected keyword argument '%s'" 1830 " to method list_event_failure_logs" % key 1831 ) 1832 params[key] = val 1833 del params['kwargs'] 1834 # verify the required parameter 'account_id' is set 1835 if ('account_id' not in params) or (params['account_id'] is None): 1836 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1837 1838 1839 collection_formats = {} 1840 1841 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1842 path_params = {} 1843 if 'account_id' in params: 1844 path_params['accountId'] = params['account_id'] 1845 1846 query_params = {} 1847 if 'from_date' in params: 1848 query_params['from_date'] = params['from_date'] 1849 if 'to_date' in params: 1850 query_params['to_date'] = params['to_date'] 1851 1852 header_params = {} 1853 1854 form_params = [] 1855 local_var_files = {} 1856 1857 body_params = None 1858 # HTTP header `Accept` 1859 header_params['Accept'] = self.api_client.\ 1860 select_header_accept(['application/json']) 1861 1862 # Authentication setting 1863 auth_settings = [] 1864 1865 return self.api_client.call_api(resource_path, 'GET', 1866 path_params, 1867 query_params, 1868 header_params, 1869 body=body_params, 1870 post_params=form_params, 1871 files=local_var_files, 1872 response_type='ConnectLogs', 1873 auth_settings=auth_settings, 1874 callback=params.get('callback'), 1875 _return_http_data_only=params.get('_return_http_data_only'), 1876 _preload_content=params.get('_preload_content', True), 1877 _request_timeout=params.get('_request_timeout'), 1878 collection_formats=collection_formats) 1879 1880 def list_event_logs(self, account_id, **kwargs): 1881 """ 1882 Gets the Connect log. 1883 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1884 This method makes a synchronous HTTP request by default. To make an 1885 asynchronous HTTP request, please define a `callback` function 1886 to be invoked when receiving the response. 1887 >>> def callback_function(response): 1888 >>> pprint(response) 1889 >>> 1890 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1891 1892 :param callback function: The callback function 1893 for asynchronous request. (optional) 1894 :param str account_id: The external account number (int) or account ID Guid. (required) 1895 :param str from_date: 1896 :param str to_date: 1897 :return: ConnectLogs 1898 If the method is called asynchronously, 1899 returns the request thread. 1900 """ 1901 kwargs['_return_http_data_only'] = True 1902 if kwargs.get('callback'): 1903 return self.list_event_logs_with_http_info(account_id, **kwargs) 1904 else: 1905 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1906 return data 1907 1908 def list_event_logs_with_http_info(self, account_id, **kwargs): 1909 """ 1910 Gets the Connect log. 1911 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1912 This method makes a synchronous HTTP request by default. To make an 1913 asynchronous HTTP request, please define a `callback` function 1914 to be invoked when receiving the response. 1915 >>> def callback_function(response): 1916 >>> pprint(response) 1917 >>> 1918 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1919 1920 :param callback function: The callback function 1921 for asynchronous request. (optional) 1922 :param str account_id: The external account number (int) or account ID Guid. (required) 1923 :param str from_date: 1924 :param str to_date: 1925 :return: ConnectLogs 1926 If the method is called asynchronously, 1927 returns the request thread. 1928 """ 1929 1930 all_params = ['account_id', 'from_date', 'to_date'] 1931 all_params.append('callback') 1932 all_params.append('_return_http_data_only') 1933 all_params.append('_preload_content') 1934 all_params.append('_request_timeout') 1935 1936 params = locals() 1937 for key, val in iteritems(params['kwargs']): 1938 if key not in all_params: 1939 raise TypeError( 1940 "Got an unexpected keyword argument '%s'" 1941 " to method list_event_logs" % key 1942 ) 1943 params[key] = val 1944 del params['kwargs'] 1945 # verify the required parameter 'account_id' is set 1946 if ('account_id' not in params) or (params['account_id'] is None): 1947 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1948 1949 1950 collection_formats = {} 1951 1952 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1953 path_params = {} 1954 if 'account_id' in params: 1955 path_params['accountId'] = params['account_id'] 1956 1957 query_params = {} 1958 if 'from_date' in params: 1959 query_params['from_date'] = params['from_date'] 1960 if 'to_date' in params: 1961 query_params['to_date'] = params['to_date'] 1962 1963 header_params = {} 1964 1965 form_params = [] 1966 local_var_files = {} 1967 1968 body_params = None 1969 # HTTP header `Accept` 1970 header_params['Accept'] = self.api_client.\ 1971 select_header_accept(['application/json']) 1972 1973 # Authentication setting 1974 auth_settings = [] 1975 1976 return self.api_client.call_api(resource_path, 'GET', 1977 path_params, 1978 query_params, 1979 header_params, 1980 body=body_params, 1981 post_params=form_params, 1982 files=local_var_files, 1983 response_type='ConnectLogs', 1984 auth_settings=auth_settings, 1985 callback=params.get('callback'), 1986 _return_http_data_only=params.get('_return_http_data_only'), 1987 _preload_content=params.get('_preload_content', True), 1988 _request_timeout=params.get('_request_timeout'), 1989 collection_formats=collection_formats) 1990 1991 def list_mobile_notifiers(self, account_id, **kwargs): 1992 """ 1993 Reserved 1994 Reserved: 1995 This method makes a synchronous HTTP request by default. To make an 1996 asynchronous HTTP request, please define a `callback` function 1997 to be invoked when receiving the response. 1998 >>> def callback_function(response): 1999 >>> pprint(response) 2000 >>> 2001 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 2002 2003 :param callback function: The callback function 2004 for asynchronous request. (optional) 2005 :param str account_id: The external account number (int) or account ID Guid. (required) 2006 :return: MobileNotifierConfigurationInformation 2007 If the method is called asynchronously, 2008 returns the request thread. 2009 """ 2010 kwargs['_return_http_data_only'] = True 2011 if kwargs.get('callback'): 2012 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2013 else: 2014 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2015 return data 2016 2017 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2018 """ 2019 Reserved 2020 Reserved: 2021 This method makes a synchronous HTTP request by default. To make an 2022 asynchronous HTTP request, please define a `callback` function 2023 to be invoked when receiving the response. 2024 >>> def callback_function(response): 2025 >>> pprint(response) 2026 >>> 2027 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2028 2029 :param callback function: The callback function 2030 for asynchronous request. (optional) 2031 :param str account_id: The external account number (int) or account ID Guid. (required) 2032 :return: MobileNotifierConfigurationInformation 2033 If the method is called asynchronously, 2034 returns the request thread. 2035 """ 2036 2037 all_params = ['account_id'] 2038 all_params.append('callback') 2039 all_params.append('_return_http_data_only') 2040 all_params.append('_preload_content') 2041 all_params.append('_request_timeout') 2042 2043 params = locals() 2044 for key, val in iteritems(params['kwargs']): 2045 if key not in all_params: 2046 raise TypeError( 2047 "Got an unexpected keyword argument '%s'" 2048 " to method list_mobile_notifiers" % key 2049 ) 2050 params[key] = val 2051 del params['kwargs'] 2052 # verify the required parameter 'account_id' is set 2053 if ('account_id' not in params) or (params['account_id'] is None): 2054 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 2055 2056 2057 collection_formats = {} 2058 2059 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2060 path_params = {} 2061 if 'account_id' in params: 2062 path_params['accountId'] = params['account_id'] 2063 2064 query_params = {} 2065 2066 header_params = {} 2067 2068 form_params = [] 2069 local_var_files = {} 2070 2071 body_params = None 2072 # HTTP header `Accept` 2073 header_params['Accept'] = self.api_client.\ 2074 select_header_accept(['application/json']) 2075 2076 # Authentication setting 2077 auth_settings = [] 2078 2079 return self.api_client.call_api(resource_path, 'GET', 2080 path_params, 2081 query_params, 2082 header_params, 2083 body=body_params, 2084 post_params=form_params, 2085 files=local_var_files, 2086 response_type='MobileNotifierConfigurationInformation', 2087 auth_settings=auth_settings, 2088 callback=params.get('callback'), 2089 _return_http_data_only=params.get('_return_http_data_only'), 2090 _preload_content=params.get('_preload_content', True), 2091 _request_timeout=params.get('_request_timeout'), 2092 collection_formats=collection_formats) 2093 2094 def list_users(self, account_id, connect_id, **kwargs): 2095 """ 2096 Returns users from the configured Connect service. 2097 Returns users from the configured Connect service. 2098 This method makes a synchronous HTTP request by default. To make an 2099 asynchronous HTTP request, please define a `callback` function 2100 to be invoked when receiving the response. 2101 >>> def callback_function(response): 2102 >>> pprint(response) 2103 >>> 2104 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 2105 2106 :param callback function: The callback function 2107 for asynchronous request. (optional) 2108 :param str account_id: The external account number (int) or account ID Guid. (required) 2109 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2110 :param str count: 2111 :param str email_substring: 2112 :param str list_included_users: 2113 :param str start_position: 2114 :param str status: 2115 :param str user_name_substring: 2116 :return: IntegratedUserInfoList 2117 If the method is called asynchronously, 2118 returns the request thread. 2119 """ 2120 kwargs['_return_http_data_only'] = True 2121 if kwargs.get('callback'): 2122 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 2123 else: 2124 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 2125 return data 2126 2127 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 2128 """ 2129 Returns users from the configured Connect service. 2130 Returns users from the configured Connect service. 2131 This method makes a synchronous HTTP request by default. To make an 2132 asynchronous HTTP request, please define a `callback` function 2133 to be invoked when receiving the response. 2134 >>> def callback_function(response): 2135 >>> pprint(response) 2136 >>> 2137 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 2138 2139 :param callback function: The callback function 2140 for asynchronous request. (optional) 2141 :param str account_id: The external account number (int) or account ID Guid. (required) 2142 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2143 :param str count: 2144 :param str email_substring: 2145 :param str list_included_users: 2146 :param str start_position: 2147 :param str status: 2148 :param str user_name_substring: 2149 :return: IntegratedUserInfoList 2150 If the method is called asynchronously, 2151 returns the request thread. 2152 """ 2153 2154 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 2155 all_params.append('callback') 2156 all_params.append('_return_http_data_only') 2157 all_params.append('_preload_content') 2158 all_params.append('_request_timeout') 2159 2160 params = locals() 2161 for key, val in iteritems(params['kwargs']): 2162 if key not in all_params: 2163 raise TypeError( 2164 "Got an unexpected keyword argument '%s'" 2165 " to method list_users" % key 2166 ) 2167 params[key] = val 2168 del params['kwargs'] 2169 # verify the required parameter 'account_id' is set 2170 if ('account_id' not in params) or (params['account_id'] is None): 2171 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 2172 # verify the required parameter 'connect_id' is set 2173 if ('connect_id' not in params) or (params['connect_id'] is None): 2174 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 2175 2176 2177 collection_formats = {} 2178 2179 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 2180 path_params = {} 2181 if 'account_id' in params: 2182 path_params['accountId'] = params['account_id'] 2183 if 'connect_id' in params: 2184 path_params['connectId'] = params['connect_id'] 2185 2186 query_params = {} 2187 if 'count' in params: 2188 query_params['count'] = params['count'] 2189 if 'email_substring' in params: 2190 query_params['email_substring'] = params['email_substring'] 2191 if 'list_included_users' in params: 2192 query_params['list_included_users'] = params['list_included_users'] 2193 if 'start_position' in params: 2194 query_params['start_position'] = params['start_position'] 2195 if 'status' in params: 2196 query_params['status'] = params['status'] 2197 if 'user_name_substring' in params: 2198 query_params['user_name_substring'] = params['user_name_substring'] 2199 2200 header_params = {} 2201 2202 form_params = [] 2203 local_var_files = {} 2204 2205 body_params = None 2206 # HTTP header `Accept` 2207 header_params['Accept'] = self.api_client.\ 2208 select_header_accept(['application/json']) 2209 2210 # Authentication setting 2211 auth_settings = [] 2212 2213 return self.api_client.call_api(resource_path, 'GET', 2214 path_params, 2215 query_params, 2216 header_params, 2217 body=body_params, 2218 post_params=form_params, 2219 files=local_var_files, 2220 response_type='IntegratedUserInfoList', 2221 auth_settings=auth_settings, 2222 callback=params.get('callback'), 2223 _return_http_data_only=params.get('_return_http_data_only'), 2224 _preload_content=params.get('_preload_content', True), 2225 _request_timeout=params.get('_request_timeout'), 2226 collection_formats=collection_formats) 2227 2228 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 2229 """ 2230 Republishes Connect information for the specified envelope. 2231 Republishes Connect information for the specified envelope. 2232 This method makes a synchronous HTTP request by default. To make an 2233 asynchronous HTTP request, please define a `callback` function 2234 to be invoked when receiving the response. 2235 >>> def callback_function(response): 2236 >>> pprint(response) 2237 >>> 2238 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 2239 2240 :param callback function: The callback function 2241 for asynchronous request. (optional) 2242 :param str account_id: The external account number (int) or account ID Guid. (required) 2243 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2244 :return: ConnectFailureResults 2245 If the method is called asynchronously, 2246 returns the request thread. 2247 """ 2248 kwargs['_return_http_data_only'] = True 2249 if kwargs.get('callback'): 2250 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2251 else: 2252 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2253 return data 2254 2255 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 2256 """ 2257 Republishes Connect information for the specified envelope. 2258 Republishes Connect information for the specified envelope. 2259 This method makes a synchronous HTTP request by default. To make an 2260 asynchronous HTTP request, please define a `callback` function 2261 to be invoked when receiving the response. 2262 >>> def callback_function(response): 2263 >>> pprint(response) 2264 >>> 2265 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 2266 2267 :param callback function: The callback function 2268 for asynchronous request. (optional) 2269 :param str account_id: The external account number (int) or account ID Guid. (required) 2270 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2271 :return: ConnectFailureResults 2272 If the method is called asynchronously, 2273 returns the request thread. 2274 """ 2275 2276 all_params = ['account_id', 'envelope_id'] 2277 all_params.append('callback') 2278 all_params.append('_return_http_data_only') 2279 all_params.append('_preload_content') 2280 all_params.append('_request_timeout') 2281 2282 params = locals() 2283 for key, val in iteritems(params['kwargs']): 2284 if key not in all_params: 2285 raise TypeError( 2286 "Got an unexpected keyword argument '%s'" 2287 " to method retry_event_for_envelope" % key 2288 ) 2289 params[key] = val 2290 del params['kwargs'] 2291 # verify the required parameter 'account_id' is set 2292 if ('account_id' not in params) or (params['account_id'] is None): 2293 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 2294 # verify the required parameter 'envelope_id' is set 2295 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2296 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 2297 2298 2299 collection_formats = {} 2300 2301 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 2302 path_params = {} 2303 if 'account_id' in params: 2304 path_params['accountId'] = params['account_id'] 2305 if 'envelope_id' in params: 2306 path_params['envelopeId'] = params['envelope_id'] 2307 2308 query_params = {} 2309 2310 header_params = {} 2311 2312 form_params = [] 2313 local_var_files = {} 2314 2315 body_params = None 2316 # HTTP header `Accept` 2317 header_params['Accept'] = self.api_client.\ 2318 select_header_accept(['application/json']) 2319 2320 # Authentication setting 2321 auth_settings = [] 2322 2323 return self.api_client.call_api(resource_path, 'PUT', 2324 path_params, 2325 query_params, 2326 header_params, 2327 body=body_params, 2328 post_params=form_params, 2329 files=local_var_files, 2330 response_type='ConnectFailureResults', 2331 auth_settings=auth_settings, 2332 callback=params.get('callback'), 2333 _return_http_data_only=params.get('_return_http_data_only'), 2334 _preload_content=params.get('_preload_content', True), 2335 _request_timeout=params.get('_request_timeout'), 2336 collection_formats=collection_formats) 2337 2338 def retry_event_for_envelopes(self, account_id, **kwargs): 2339 """ 2340 Republishes Connect information for multiple envelopes. 2341 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2342 This method makes a synchronous HTTP request by default. To make an 2343 asynchronous HTTP request, please define a `callback` function 2344 to be invoked when receiving the response. 2345 >>> def callback_function(response): 2346 >>> pprint(response) 2347 >>> 2348 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2349 2350 :param callback function: The callback function 2351 for asynchronous request. (optional) 2352 :param str account_id: The external account number (int) or account ID Guid. (required) 2353 :param ConnectFailureFilter connect_failure_filter: 2354 :return: ConnectFailureResults 2355 If the method is called asynchronously, 2356 returns the request thread. 2357 """ 2358 kwargs['_return_http_data_only'] = True 2359 if kwargs.get('callback'): 2360 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2361 else: 2362 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2363 return data 2364 2365 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2366 """ 2367 Republishes Connect information for multiple envelopes. 2368 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2369 This method makes a synchronous HTTP request by default. To make an 2370 asynchronous HTTP request, please define a `callback` function 2371 to be invoked when receiving the response. 2372 >>> def callback_function(response): 2373 >>> pprint(response) 2374 >>> 2375 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2376 2377 :param callback function: The callback function 2378 for asynchronous request. (optional) 2379 :param str account_id: The external account number (int) or account ID Guid. (required) 2380 :param ConnectFailureFilter connect_failure_filter: 2381 :return: ConnectFailureResults 2382 If the method is called asynchronously, 2383 returns the request thread. 2384 """ 2385 2386 all_params = ['account_id', 'connect_failure_filter'] 2387 all_params.append('callback') 2388 all_params.append('_return_http_data_only') 2389 all_params.append('_preload_content') 2390 all_params.append('_request_timeout') 2391 2392 params = locals() 2393 for key, val in iteritems(params['kwargs']): 2394 if key not in all_params: 2395 raise TypeError( 2396 "Got an unexpected keyword argument '%s'" 2397 " to method retry_event_for_envelopes" % key 2398 ) 2399 params[key] = val 2400 del params['kwargs'] 2401 # verify the required parameter 'account_id' is set 2402 if ('account_id' not in params) or (params['account_id'] is None): 2403 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2404 2405 2406 collection_formats = {} 2407 2408 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2409 path_params = {} 2410 if 'account_id' in params: 2411 path_params['accountId'] = params['account_id'] 2412 2413 query_params = {} 2414 2415 header_params = {} 2416 2417 form_params = [] 2418 local_var_files = {} 2419 2420 body_params = None 2421 if 'connect_failure_filter' in params: 2422 body_params = params['connect_failure_filter'] 2423 # HTTP header `Accept` 2424 header_params['Accept'] = self.api_client.\ 2425 select_header_accept(['application/json']) 2426 2427 # Authentication setting 2428 auth_settings = [] 2429 2430 return self.api_client.call_api(resource_path, 'PUT', 2431 path_params, 2432 query_params, 2433 header_params, 2434 body=body_params, 2435 post_params=form_params, 2436 files=local_var_files, 2437 response_type='ConnectFailureResults', 2438 auth_settings=auth_settings, 2439 callback=params.get('callback'), 2440 _return_http_data_only=params.get('_return_http_data_only'), 2441 _preload_content=params.get('_preload_content', True), 2442 _request_timeout=params.get('_request_timeout'), 2443 collection_formats=collection_formats) 2444 2445 def update_configuration(self, account_id, **kwargs): 2446 """ 2447 Updates a specified Connect configuration. 2448 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2449 This method makes a synchronous HTTP request by default. To make an 2450 asynchronous HTTP request, please define a `callback` function 2451 to be invoked when receiving the response. 2452 >>> def callback_function(response): 2453 >>> pprint(response) 2454 >>> 2455 >>> thread = api.update_configuration(account_id, callback=callback_function) 2456 2457 :param callback function: The callback function 2458 for asynchronous request. (optional) 2459 :param str account_id: The external account number (int) or account ID Guid. (required) 2460 :param ConnectCustomConfiguration connect_custom_configuration: 2461 :return: ConnectCustomConfiguration 2462 If the method is called asynchronously, 2463 returns the request thread. 2464 """ 2465 kwargs['_return_http_data_only'] = True 2466 if kwargs.get('callback'): 2467 return self.update_configuration_with_http_info(account_id, **kwargs) 2468 else: 2469 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2470 return data 2471 2472 def update_configuration_with_http_info(self, account_id, **kwargs): 2473 """ 2474 Updates a specified Connect configuration. 2475 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2476 This method makes a synchronous HTTP request by default. To make an 2477 asynchronous HTTP request, please define a `callback` function 2478 to be invoked when receiving the response. 2479 >>> def callback_function(response): 2480 >>> pprint(response) 2481 >>> 2482 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2483 2484 :param callback function: The callback function 2485 for asynchronous request. (optional) 2486 :param str account_id: The external account number (int) or account ID Guid. (required) 2487 :param ConnectCustomConfiguration connect_custom_configuration: 2488 :return: ConnectCustomConfiguration 2489 If the method is called asynchronously, 2490 returns the request thread. 2491 """ 2492 2493 all_params = ['account_id', 'connect_custom_configuration'] 2494 all_params.append('callback') 2495 all_params.append('_return_http_data_only') 2496 all_params.append('_preload_content') 2497 all_params.append('_request_timeout') 2498 2499 params = locals() 2500 for key, val in iteritems(params['kwargs']): 2501 if key not in all_params: 2502 raise TypeError( 2503 "Got an unexpected keyword argument '%s'" 2504 " to method update_configuration" % key 2505 ) 2506 params[key] = val 2507 del params['kwargs'] 2508 # verify the required parameter 'account_id' is set 2509 if ('account_id' not in params) or (params['account_id'] is None): 2510 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2511 2512 2513 collection_formats = {} 2514 2515 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2516 path_params = {} 2517 if 'account_id' in params: 2518 path_params['accountId'] = params['account_id'] 2519 2520 query_params = {} 2521 2522 header_params = {} 2523 2524 form_params = [] 2525 local_var_files = {} 2526 2527 body_params = None 2528 if 'connect_custom_configuration' in params: 2529 body_params = params['connect_custom_configuration'] 2530 # HTTP header `Accept` 2531 header_params['Accept'] = self.api_client.\ 2532 select_header_accept(['application/json']) 2533 2534 # Authentication setting 2535 auth_settings = [] 2536 2537 return self.api_client.call_api(resource_path, 'PUT', 2538 path_params, 2539 query_params, 2540 header_params, 2541 body=body_params, 2542 post_params=form_params, 2543 files=local_var_files, 2544 response_type='ConnectCustomConfiguration', 2545 auth_settings=auth_settings, 2546 callback=params.get('callback'), 2547 _return_http_data_only=params.get('_return_http_data_only'), 2548 _preload_content=params.get('_preload_content', True), 2549 _request_timeout=params.get('_request_timeout'), 2550 collection_formats=collection_formats) 2551 2552 def update_connect_o_auth_config(self, account_id, **kwargs): 2553 """ 2554 Updates the existing Connect OAuth Config for the account. 2555 This method makes a synchronous HTTP request by default. To make an 2556 asynchronous HTTP request, please define a `callback` function 2557 to be invoked when receiving the response. 2558 >>> def callback_function(response): 2559 >>> pprint(response) 2560 >>> 2561 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2562 2563 :param callback function: The callback function 2564 for asynchronous request. (optional) 2565 :param str account_id: The external account number (int) or account ID Guid. (required) 2566 :param ConnectOAuthConfig connect_o_auth_config: 2567 :return: ConnectOAuthConfig 2568 If the method is called asynchronously, 2569 returns the request thread. 2570 """ 2571 kwargs['_return_http_data_only'] = True 2572 if kwargs.get('callback'): 2573 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2574 else: 2575 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2576 return data 2577 2578 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2579 """ 2580 Updates the existing Connect OAuth Config for the account. 2581 This method makes a synchronous HTTP request by default. To make an 2582 asynchronous HTTP request, please define a `callback` function 2583 to be invoked when receiving the response. 2584 >>> def callback_function(response): 2585 >>> pprint(response) 2586 >>> 2587 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2588 2589 :param callback function: The callback function 2590 for asynchronous request. (optional) 2591 :param str account_id: The external account number (int) or account ID Guid. (required) 2592 :param ConnectOAuthConfig connect_o_auth_config: 2593 :return: ConnectOAuthConfig 2594 If the method is called asynchronously, 2595 returns the request thread. 2596 """ 2597 2598 all_params = ['account_id', 'connect_o_auth_config'] 2599 all_params.append('callback') 2600 all_params.append('_return_http_data_only') 2601 all_params.append('_preload_content') 2602 all_params.append('_request_timeout') 2603 2604 params = locals() 2605 for key, val in iteritems(params['kwargs']): 2606 if key not in all_params: 2607 raise TypeError( 2608 "Got an unexpected keyword argument '%s'" 2609 " to method update_connect_o_auth_config" % key 2610 ) 2611 params[key] = val 2612 del params['kwargs'] 2613 # verify the required parameter 'account_id' is set 2614 if ('account_id' not in params) or (params['account_id'] is None): 2615 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2616 2617 2618 collection_formats = {} 2619 2620 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2621 path_params = {} 2622 if 'account_id' in params: 2623 path_params['accountId'] = params['account_id'] 2624 2625 query_params = {} 2626 2627 header_params = {} 2628 2629 form_params = [] 2630 local_var_files = {} 2631 2632 body_params = None 2633 if 'connect_o_auth_config' in params: 2634 body_params = params['connect_o_auth_config'] 2635 # HTTP header `Accept` 2636 header_params['Accept'] = self.api_client.\ 2637 select_header_accept(['application/json']) 2638 2639 # Authentication setting 2640 auth_settings = [] 2641 2642 return self.api_client.call_api(resource_path, 'PUT', 2643 path_params, 2644 query_params, 2645 header_params, 2646 body=body_params, 2647 post_params=form_params, 2648 files=local_var_files, 2649 response_type='ConnectOAuthConfig', 2650 auth_settings=auth_settings, 2651 callback=params.get('callback'), 2652 _return_http_data_only=params.get('_return_http_data_only'), 2653 _preload_content=params.get('_preload_content', True), 2654 _request_timeout=params.get('_request_timeout'), 2655 collection_formats=collection_formats) 2656 2657 def update_mobile_notifiers(self, account_id, **kwargs): 2658 """ 2659 Reserved 2660 Reserved: 2661 This method makes a synchronous HTTP request by default. To make an 2662 asynchronous HTTP request, please define a `callback` function 2663 to be invoked when receiving the response. 2664 >>> def callback_function(response): 2665 >>> pprint(response) 2666 >>> 2667 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2668 2669 :param callback function: The callback function 2670 for asynchronous request. (optional) 2671 :param str account_id: The external account number (int) or account ID Guid. (required) 2672 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2673 :return: MobileNotifierConfigurationInformation 2674 If the method is called asynchronously, 2675 returns the request thread. 2676 """ 2677 kwargs['_return_http_data_only'] = True 2678 if kwargs.get('callback'): 2679 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2680 else: 2681 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2682 return data 2683 2684 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2685 """ 2686 Reserved 2687 Reserved: 2688 This method makes a synchronous HTTP request by default. To make an 2689 asynchronous HTTP request, please define a `callback` function 2690 to be invoked when receiving the response. 2691 >>> def callback_function(response): 2692 >>> pprint(response) 2693 >>> 2694 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2695 2696 :param callback function: The callback function 2697 for asynchronous request. (optional) 2698 :param str account_id: The external account number (int) or account ID Guid. (required) 2699 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2700 :return: MobileNotifierConfigurationInformation 2701 If the method is called asynchronously, 2702 returns the request thread. 2703 """ 2704 2705 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2706 all_params.append('callback') 2707 all_params.append('_return_http_data_only') 2708 all_params.append('_preload_content') 2709 all_params.append('_request_timeout') 2710 2711 params = locals() 2712 for key, val in iteritems(params['kwargs']): 2713 if key not in all_params: 2714 raise TypeError( 2715 "Got an unexpected keyword argument '%s'" 2716 " to method update_mobile_notifiers" % key 2717 ) 2718 params[key] = val 2719 del params['kwargs'] 2720 # verify the required parameter 'account_id' is set 2721 if ('account_id' not in params) or (params['account_id'] is None): 2722 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2723 2724 2725 collection_formats = {} 2726 2727 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2728 path_params = {} 2729 if 'account_id' in params: 2730 path_params['accountId'] = params['account_id'] 2731 2732 query_params = {} 2733 2734 header_params = {} 2735 2736 form_params = [] 2737 local_var_files = {} 2738 2739 body_params = None 2740 if 'mobile_notifier_configuration_information' in params: 2741 body_params = params['mobile_notifier_configuration_information'] 2742 # HTTP header `Accept` 2743 header_params['Accept'] = self.api_client.\ 2744 select_header_accept(['application/json']) 2745 2746 # Authentication setting 2747 auth_settings = [] 2748 2749 return self.api_client.call_api(resource_path, 'PUT', 2750 path_params, 2751 query_params, 2752 header_params, 2753 body=body_params, 2754 post_params=form_params, 2755 files=local_var_files, 2756 response_type='MobileNotifierConfigurationInformation', 2757 auth_settings=auth_settings, 2758 callback=params.get('callback'), 2759 _return_http_data_only=params.get('_return_http_data_only'), 2760 _preload_content=params.get('_preload_content', True), 2761 _request_timeout=params.get('_request_timeout'), 2762 collection_formats=collection_formats)
NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen
def
create_configuration(self, account_id, **kwargs)
44 def create_configuration(self, account_id, **kwargs): 45 """ 46 Creates a connect configuration for the specified account. 47 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.create_configuration(account_id, callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str account_id: The external account number (int) or account ID Guid. (required) 59 :param ConnectCustomConfiguration connect_custom_configuration: 60 :return: ConnectCustomConfiguration 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_configuration_with_http_info(account_id, **kwargs) 67 else: 68 (data) = self.create_configuration_with_http_info(account_id, **kwargs) 69 return data
Creates a connect configuration for the specified account.
Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectCustomConfiguration connect_custom_configuration:
Returns
ConnectCustomConfiguration If the method is called asynchronously, returns the request thread.
def
create_configuration_with_http_info(self, account_id, **kwargs)
71 def create_configuration_with_http_info(self, account_id, **kwargs): 72 """ 73 Creates a connect configuration for the specified account. 74 Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_configuration_with_http_info(account_id, callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str account_id: The external account number (int) or account ID Guid. (required) 86 :param ConnectCustomConfiguration connect_custom_configuration: 87 :return: ConnectCustomConfiguration 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['account_id', 'connect_custom_configuration'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create_configuration" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 # verify the required parameter 'account_id' is set 108 if ('account_id' not in params) or (params['account_id'] is None): 109 raise ValueError("Missing the required parameter `account_id` when calling `create_configuration`") 110 111 112 collection_formats = {} 113 114 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 115 path_params = {} 116 if 'account_id' in params: 117 path_params['accountId'] = params['account_id'] 118 119 query_params = {} 120 121 header_params = {} 122 123 form_params = [] 124 local_var_files = {} 125 126 body_params = None 127 if 'connect_custom_configuration' in params: 128 body_params = params['connect_custom_configuration'] 129 # HTTP header `Accept` 130 header_params['Accept'] = self.api_client.\ 131 select_header_accept(['application/json']) 132 133 # Authentication setting 134 auth_settings = [] 135 136 return self.api_client.call_api(resource_path, 'POST', 137 path_params, 138 query_params, 139 header_params, 140 body=body_params, 141 post_params=form_params, 142 files=local_var_files, 143 response_type='ConnectCustomConfiguration', 144 auth_settings=auth_settings, 145 callback=params.get('callback'), 146 _return_http_data_only=params.get('_return_http_data_only'), 147 _preload_content=params.get('_preload_content', True), 148 _request_timeout=params.get('_request_timeout'), 149 collection_formats=collection_formats)
Creates a connect configuration for the specified account.
Creates a DocuSign Custom Connect definition for your account. DocuSign Connect enables the sending of real-time data updates to external applications. These updates are generated by user transactions as the envelope progresses through actions to completion. The Connect Service provides updated information about the status of these transactions and returns updates that include the actual content of document form fields. Be aware that, these updates might or might not include the document itself. For more information about Connect, see the [ML:DocuSign Connect Service Guide]. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to set up Connect configurations for Salesforce or eOriginal.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectCustomConfiguration connect_custom_configuration:
Returns
ConnectCustomConfiguration If the method is called asynchronously, returns the request thread.
def
create_connect_o_auth_config(self, account_id, **kwargs)
151 def create_connect_o_auth_config(self, account_id, **kwargs): 152 """ 153 Sets the Connect OAuth Config for the account. 154 This method makes a synchronous HTTP request by default. To make an 155 asynchronous HTTP request, please define a `callback` function 156 to be invoked when receiving the response. 157 >>> def callback_function(response): 158 >>> pprint(response) 159 >>> 160 >>> thread = api.create_connect_o_auth_config(account_id, callback=callback_function) 161 162 :param callback function: The callback function 163 for asynchronous request. (optional) 164 :param str account_id: The external account number (int) or account ID Guid. (required) 165 :param ConnectOAuthConfig connect_o_auth_config: 166 :return: ConnectOAuthConfig 167 If the method is called asynchronously, 168 returns the request thread. 169 """ 170 kwargs['_return_http_data_only'] = True 171 if kwargs.get('callback'): 172 return self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 173 else: 174 (data) = self.create_connect_o_auth_config_with_http_info(account_id, **kwargs) 175 return data
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_connect_o_auth_config(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectOAuthConfig connect_o_auth_config:
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
create_connect_o_auth_config_with_http_info(self, account_id, **kwargs)
177 def create_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 178 """ 179 Sets the Connect OAuth Config for the account. 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param ConnectOAuthConfig connect_o_auth_config: 192 :return: ConnectOAuthConfig 193 If the method is called asynchronously, 194 returns the request thread. 195 """ 196 197 all_params = ['account_id', 'connect_o_auth_config'] 198 all_params.append('callback') 199 all_params.append('_return_http_data_only') 200 all_params.append('_preload_content') 201 all_params.append('_request_timeout') 202 203 params = locals() 204 for key, val in iteritems(params['kwargs']): 205 if key not in all_params: 206 raise TypeError( 207 "Got an unexpected keyword argument '%s'" 208 " to method create_connect_o_auth_config" % key 209 ) 210 params[key] = val 211 del params['kwargs'] 212 # verify the required parameter 'account_id' is set 213 if ('account_id' not in params) or (params['account_id'] is None): 214 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_o_auth_config`") 215 216 217 collection_formats = {} 218 219 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 220 path_params = {} 221 if 'account_id' in params: 222 path_params['accountId'] = params['account_id'] 223 224 query_params = {} 225 226 header_params = {} 227 228 form_params = [] 229 local_var_files = {} 230 231 body_params = None 232 if 'connect_o_auth_config' in params: 233 body_params = params['connect_o_auth_config'] 234 # HTTP header `Accept` 235 header_params['Accept'] = self.api_client.\ 236 select_header_accept(['application/json']) 237 238 # Authentication setting 239 auth_settings = [] 240 241 return self.api_client.call_api(resource_path, 'POST', 242 path_params, 243 query_params, 244 header_params, 245 body=body_params, 246 post_params=form_params, 247 files=local_var_files, 248 response_type='ConnectOAuthConfig', 249 auth_settings=auth_settings, 250 callback=params.get('callback'), 251 _return_http_data_only=params.get('_return_http_data_only'), 252 _preload_content=params.get('_preload_content', True), 253 _request_timeout=params.get('_request_timeout'), 254 collection_formats=collection_formats)
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectOAuthConfig connect_o_auth_config:
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
create_connect_secret(self, account_id, **kwargs)
256 def create_connect_secret(self, account_id, **kwargs): 257 """ 258 Generates a new connect HMAC Secret. 259 This method makes a synchronous HTTP request by default. To make an 260 asynchronous HTTP request, please define a `callback` function 261 to be invoked when receiving the response. 262 >>> def callback_function(response): 263 >>> pprint(response) 264 >>> 265 >>> thread = api.create_connect_secret(account_id, callback=callback_function) 266 267 :param callback function: The callback function 268 for asynchronous request. (optional) 269 :param str account_id: The external account number (int) or account ID Guid. (required) 270 :return: None 271 If the method is called asynchronously, 272 returns the request thread. 273 """ 274 kwargs['_return_http_data_only'] = True 275 if kwargs.get('callback'): 276 return self.create_connect_secret_with_http_info(account_id, **kwargs) 277 else: 278 (data) = self.create_connect_secret_with_http_info(account_id, **kwargs) 279 return data
Generates a new connect HMAC Secret.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_connect_secret(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
create_connect_secret_with_http_info(self, account_id, **kwargs)
281 def create_connect_secret_with_http_info(self, account_id, **kwargs): 282 """ 283 Generates a new connect HMAC Secret. 284 This method makes a synchronous HTTP request by default. To make an 285 asynchronous HTTP request, please define a `callback` function 286 to be invoked when receiving the response. 287 >>> def callback_function(response): 288 >>> pprint(response) 289 >>> 290 >>> thread = api.create_connect_secret_with_http_info(account_id, callback=callback_function) 291 292 :param callback function: The callback function 293 for asynchronous request. (optional) 294 :param str account_id: The external account number (int) or account ID Guid. (required) 295 :return: None 296 If the method is called asynchronously, 297 returns the request thread. 298 """ 299 300 all_params = ['account_id'] 301 all_params.append('callback') 302 all_params.append('_return_http_data_only') 303 all_params.append('_preload_content') 304 all_params.append('_request_timeout') 305 306 params = locals() 307 for key, val in iteritems(params['kwargs']): 308 if key not in all_params: 309 raise TypeError( 310 "Got an unexpected keyword argument '%s'" 311 " to method create_connect_secret" % key 312 ) 313 params[key] = val 314 del params['kwargs'] 315 # verify the required parameter 'account_id' is set 316 if ('account_id' not in params) or (params['account_id'] is None): 317 raise ValueError("Missing the required parameter `account_id` when calling `create_connect_secret`") 318 319 320 collection_formats = {} 321 322 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 323 path_params = {} 324 if 'account_id' in params: 325 path_params['accountId'] = params['account_id'] 326 327 query_params = {} 328 329 header_params = {} 330 331 form_params = [] 332 local_var_files = {} 333 334 body_params = None 335 # HTTP header `Accept` 336 header_params['Accept'] = self.api_client.\ 337 select_header_accept(['application/json']) 338 339 # Authentication setting 340 auth_settings = [] 341 342 return self.api_client.call_api(resource_path, 'POST', 343 path_params, 344 query_params, 345 header_params, 346 body=body_params, 347 post_params=form_params, 348 files=local_var_files, 349 response_type=None, 350 auth_settings=auth_settings, 351 callback=params.get('callback'), 352 _return_http_data_only=params.get('_return_http_data_only'), 353 _preload_content=params.get('_preload_content', True), 354 _request_timeout=params.get('_request_timeout'), 355 collection_formats=collection_formats)
Generates a new connect HMAC Secret.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_connect_secret_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_configuration(self, account_id, connect_id, **kwargs)
357 def delete_configuration(self, account_id, connect_id, **kwargs): 358 """ 359 Deletes the specified connect configuration. 360 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 361 This method makes a synchronous HTTP request by default. To make an 362 asynchronous HTTP request, please define a `callback` function 363 to be invoked when receiving the response. 364 >>> def callback_function(response): 365 >>> pprint(response) 366 >>> 367 >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function) 368 369 :param callback function: The callback function 370 for asynchronous request. (optional) 371 :param str account_id: The external account number (int) or account ID Guid. (required) 372 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 373 :return: None 374 If the method is called asynchronously, 375 returns the request thread. 376 """ 377 kwargs['_return_http_data_only'] = True 378 if kwargs.get('callback'): 379 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 380 else: 381 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 382 return data
Deletes the specified connect configuration.
Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_configuration_with_http_info(self, account_id, connect_id, **kwargs)
384 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 385 """ 386 Deletes the specified connect configuration. 387 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 388 This method makes a synchronous HTTP request by default. To make an 389 asynchronous HTTP request, please define a `callback` function 390 to be invoked when receiving the response. 391 >>> def callback_function(response): 392 >>> pprint(response) 393 >>> 394 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 395 396 :param callback function: The callback function 397 for asynchronous request. (optional) 398 :param str account_id: The external account number (int) or account ID Guid. (required) 399 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 400 :return: None 401 If the method is called asynchronously, 402 returns the request thread. 403 """ 404 405 all_params = ['account_id', 'connect_id'] 406 all_params.append('callback') 407 all_params.append('_return_http_data_only') 408 all_params.append('_preload_content') 409 all_params.append('_request_timeout') 410 411 params = locals() 412 for key, val in iteritems(params['kwargs']): 413 if key not in all_params: 414 raise TypeError( 415 "Got an unexpected keyword argument '%s'" 416 " to method delete_configuration" % key 417 ) 418 params[key] = val 419 del params['kwargs'] 420 # verify the required parameter 'account_id' is set 421 if ('account_id' not in params) or (params['account_id'] is None): 422 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 423 # verify the required parameter 'connect_id' is set 424 if ('connect_id' not in params) or (params['connect_id'] is None): 425 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 426 427 428 collection_formats = {} 429 430 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 431 path_params = {} 432 if 'account_id' in params: 433 path_params['accountId'] = params['account_id'] 434 if 'connect_id' in params: 435 path_params['connectId'] = params['connect_id'] 436 437 query_params = {} 438 439 header_params = {} 440 441 form_params = [] 442 local_var_files = {} 443 444 body_params = None 445 # HTTP header `Accept` 446 header_params['Accept'] = self.api_client.\ 447 select_header_accept(['application/json']) 448 449 # Authentication setting 450 auth_settings = [] 451 452 return self.api_client.call_api(resource_path, 'DELETE', 453 path_params, 454 query_params, 455 header_params, 456 body=body_params, 457 post_params=form_params, 458 files=local_var_files, 459 response_type=None, 460 auth_settings=auth_settings, 461 callback=params.get('callback'), 462 _return_http_data_only=params.get('_return_http_data_only'), 463 _preload_content=params.get('_preload_content', True), 464 _request_timeout=params.get('_request_timeout'), 465 collection_formats=collection_formats)
Deletes the specified connect configuration.
Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_connect_o_auth_config(self, account_id, **kwargs)
467 def delete_connect_o_auth_config(self, account_id, **kwargs): 468 """ 469 Sets the Connect OAuth Config for the account. 470 This method makes a synchronous HTTP request by default. To make an 471 asynchronous HTTP request, please define a `callback` function 472 to be invoked when receiving the response. 473 >>> def callback_function(response): 474 >>> pprint(response) 475 >>> 476 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 477 478 :param callback function: The callback function 479 for asynchronous request. (optional) 480 :param str account_id: The external account number (int) or account ID Guid. (required) 481 :return: None 482 If the method is called asynchronously, 483 returns the request thread. 484 """ 485 kwargs['_return_http_data_only'] = True 486 if kwargs.get('callback'): 487 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 488 else: 489 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 490 return data
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs)
492 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 493 """ 494 Sets the Connect OAuth Config for the account. 495 This method makes a synchronous HTTP request by default. To make an 496 asynchronous HTTP request, please define a `callback` function 497 to be invoked when receiving the response. 498 >>> def callback_function(response): 499 >>> pprint(response) 500 >>> 501 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 502 503 :param callback function: The callback function 504 for asynchronous request. (optional) 505 :param str account_id: The external account number (int) or account ID Guid. (required) 506 :return: None 507 If the method is called asynchronously, 508 returns the request thread. 509 """ 510 511 all_params = ['account_id'] 512 all_params.append('callback') 513 all_params.append('_return_http_data_only') 514 all_params.append('_preload_content') 515 all_params.append('_request_timeout') 516 517 params = locals() 518 for key, val in iteritems(params['kwargs']): 519 if key not in all_params: 520 raise TypeError( 521 "Got an unexpected keyword argument '%s'" 522 " to method delete_connect_o_auth_config" % key 523 ) 524 params[key] = val 525 del params['kwargs'] 526 # verify the required parameter 'account_id' is set 527 if ('account_id' not in params) or (params['account_id'] is None): 528 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 529 530 531 collection_formats = {} 532 533 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 534 path_params = {} 535 if 'account_id' in params: 536 path_params['accountId'] = params['account_id'] 537 538 query_params = {} 539 540 header_params = {} 541 542 form_params = [] 543 local_var_files = {} 544 545 body_params = None 546 # HTTP header `Accept` 547 header_params['Accept'] = self.api_client.\ 548 select_header_accept(['application/json']) 549 550 # Authentication setting 551 auth_settings = [] 552 553 return self.api_client.call_api(resource_path, 'DELETE', 554 path_params, 555 query_params, 556 header_params, 557 body=body_params, 558 post_params=form_params, 559 files=local_var_files, 560 response_type=None, 561 auth_settings=auth_settings, 562 callback=params.get('callback'), 563 _return_http_data_only=params.get('_return_http_data_only'), 564 _preload_content=params.get('_preload_content', True), 565 _request_timeout=params.get('_request_timeout'), 566 collection_formats=collection_formats)
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_connect_secret(self, account_id, key_id, **kwargs)
568 def delete_connect_secret(self, account_id, key_id, **kwargs): 569 """ 570 Delete the connect HMAC Secret for AccountID 571 This method makes a synchronous HTTP request by default. To make an 572 asynchronous HTTP request, please define a `callback` function 573 to be invoked when receiving the response. 574 >>> def callback_function(response): 575 >>> pprint(response) 576 >>> 577 >>> thread = api.delete_connect_secret(account_id, key_id, callback=callback_function) 578 579 :param callback function: The callback function 580 for asynchronous request. (optional) 581 :param str account_id: The external account number (int) or account ID Guid. (required) 582 :param str key_id: (required) 583 :return: None 584 If the method is called asynchronously, 585 returns the request thread. 586 """ 587 kwargs['_return_http_data_only'] = True 588 if kwargs.get('callback'): 589 return self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 590 else: 591 (data) = self.delete_connect_secret_with_http_info(account_id, key_id, **kwargs) 592 return data
Delete the connect HMAC Secret for AccountID
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_connect_secret(account_id, key_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str key_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_connect_secret_with_http_info(self, account_id, key_id, **kwargs)
594 def delete_connect_secret_with_http_info(self, account_id, key_id, **kwargs): 595 """ 596 Delete the connect HMAC Secret for AccountID 597 This method makes a synchronous HTTP request by default. To make an 598 asynchronous HTTP request, please define a `callback` function 599 to be invoked when receiving the response. 600 >>> def callback_function(response): 601 >>> pprint(response) 602 >>> 603 >>> thread = api.delete_connect_secret_with_http_info(account_id, key_id, callback=callback_function) 604 605 :param callback function: The callback function 606 for asynchronous request. (optional) 607 :param str account_id: The external account number (int) or account ID Guid. (required) 608 :param str key_id: (required) 609 :return: None 610 If the method is called asynchronously, 611 returns the request thread. 612 """ 613 614 all_params = ['account_id', 'key_id'] 615 all_params.append('callback') 616 all_params.append('_return_http_data_only') 617 all_params.append('_preload_content') 618 all_params.append('_request_timeout') 619 620 params = locals() 621 for key, val in iteritems(params['kwargs']): 622 if key not in all_params: 623 raise TypeError( 624 "Got an unexpected keyword argument '%s'" 625 " to method delete_connect_secret" % key 626 ) 627 params[key] = val 628 del params['kwargs'] 629 # verify the required parameter 'account_id' is set 630 if ('account_id' not in params) or (params['account_id'] is None): 631 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_secret`") 632 # verify the required parameter 'key_id' is set 633 if ('key_id' not in params) or (params['key_id'] is None): 634 raise ValueError("Missing the required parameter `key_id` when calling `delete_connect_secret`") 635 636 637 collection_formats = {} 638 639 resource_path = '/v2.1/accounts/{accountId}/connect/secret/{keyId}'.replace('{format}', 'json') 640 path_params = {} 641 if 'account_id' in params: 642 path_params['accountId'] = params['account_id'] 643 if 'key_id' in params: 644 path_params['keyId'] = params['key_id'] 645 646 query_params = {} 647 648 header_params = {} 649 650 form_params = [] 651 local_var_files = {} 652 653 body_params = None 654 # HTTP header `Accept` 655 header_params['Accept'] = self.api_client.\ 656 select_header_accept(['application/json']) 657 658 # Authentication setting 659 auth_settings = [] 660 661 return self.api_client.call_api(resource_path, 'DELETE', 662 path_params, 663 query_params, 664 header_params, 665 body=body_params, 666 post_params=form_params, 667 files=local_var_files, 668 response_type=None, 669 auth_settings=auth_settings, 670 callback=params.get('callback'), 671 _return_http_data_only=params.get('_return_http_data_only'), 672 _preload_content=params.get('_preload_content', True), 673 _request_timeout=params.get('_request_timeout'), 674 collection_formats=collection_formats)
Delete the connect HMAC Secret for AccountID
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_connect_secret_with_http_info(account_id, key_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str key_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_event_failure_log(self, account_id, failure_id, **kwargs)
676 def delete_event_failure_log(self, account_id, failure_id, **kwargs): 677 """ 678 Deletes a Connect failure log entry. 679 Deletes the Connect failure log information for the specified entry. 680 This method makes a synchronous HTTP request by default. To make an 681 asynchronous HTTP request, please define a `callback` function 682 to be invoked when receiving the response. 683 >>> def callback_function(response): 684 >>> pprint(response) 685 >>> 686 >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function) 687 688 :param callback function: The callback function 689 for asynchronous request. (optional) 690 :param str account_id: The external account number (int) or account ID Guid. (required) 691 :param str failure_id: The ID of the failed connect log entry. (required) 692 :return: ConnectDeleteFailureResult 693 If the method is called asynchronously, 694 returns the request thread. 695 """ 696 kwargs['_return_http_data_only'] = True 697 if kwargs.get('callback'): 698 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 699 else: 700 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 701 return data
Deletes a Connect failure log entry.
Deletes the Connect failure log information for the specified entry.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str failure_id: The ID of the failed connect log entry. (required)
Returns
ConnectDeleteFailureResult If the method is called asynchronously, returns the request thread.
def
delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs)
703 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 704 """ 705 Deletes a Connect failure log entry. 706 Deletes the Connect failure log information for the specified entry. 707 This method makes a synchronous HTTP request by default. To make an 708 asynchronous HTTP request, please define a `callback` function 709 to be invoked when receiving the response. 710 >>> def callback_function(response): 711 >>> pprint(response) 712 >>> 713 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 714 715 :param callback function: The callback function 716 for asynchronous request. (optional) 717 :param str account_id: The external account number (int) or account ID Guid. (required) 718 :param str failure_id: The ID of the failed connect log entry. (required) 719 :return: ConnectDeleteFailureResult 720 If the method is called asynchronously, 721 returns the request thread. 722 """ 723 724 all_params = ['account_id', 'failure_id'] 725 all_params.append('callback') 726 all_params.append('_return_http_data_only') 727 all_params.append('_preload_content') 728 all_params.append('_request_timeout') 729 730 params = locals() 731 for key, val in iteritems(params['kwargs']): 732 if key not in all_params: 733 raise TypeError( 734 "Got an unexpected keyword argument '%s'" 735 " to method delete_event_failure_log" % key 736 ) 737 params[key] = val 738 del params['kwargs'] 739 # verify the required parameter 'account_id' is set 740 if ('account_id' not in params) or (params['account_id'] is None): 741 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 742 # verify the required parameter 'failure_id' is set 743 if ('failure_id' not in params) or (params['failure_id'] is None): 744 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 745 746 747 collection_formats = {} 748 749 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 750 path_params = {} 751 if 'account_id' in params: 752 path_params['accountId'] = params['account_id'] 753 if 'failure_id' in params: 754 path_params['failureId'] = params['failure_id'] 755 756 query_params = {} 757 758 header_params = {} 759 760 form_params = [] 761 local_var_files = {} 762 763 body_params = None 764 # HTTP header `Accept` 765 header_params['Accept'] = self.api_client.\ 766 select_header_accept(['application/json']) 767 768 # Authentication setting 769 auth_settings = [] 770 771 return self.api_client.call_api(resource_path, 'DELETE', 772 path_params, 773 query_params, 774 header_params, 775 body=body_params, 776 post_params=form_params, 777 files=local_var_files, 778 response_type='ConnectDeleteFailureResult', 779 auth_settings=auth_settings, 780 callback=params.get('callback'), 781 _return_http_data_only=params.get('_return_http_data_only'), 782 _preload_content=params.get('_preload_content', True), 783 _request_timeout=params.get('_request_timeout'), 784 collection_formats=collection_formats)
Deletes a Connect failure log entry.
Deletes the Connect failure log information for the specified entry.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str failure_id: The ID of the failed connect log entry. (required)
Returns
ConnectDeleteFailureResult If the method is called asynchronously, returns the request thread.
def
delete_event_log(self, account_id, log_id, **kwargs)
786 def delete_event_log(self, account_id, log_id, **kwargs): 787 """ 788 Deletes a specified Connect log entry. 789 Deletes a specified entry from the Connect Log. 790 This method makes a synchronous HTTP request by default. To make an 791 asynchronous HTTP request, please define a `callback` function 792 to be invoked when receiving the response. 793 >>> def callback_function(response): 794 >>> pprint(response) 795 >>> 796 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 797 798 :param callback function: The callback function 799 for asynchronous request. (optional) 800 :param str account_id: The external account number (int) or account ID Guid. (required) 801 :param str log_id: The ID of the connect log entry (required) 802 :return: None 803 If the method is called asynchronously, 804 returns the request thread. 805 """ 806 kwargs['_return_http_data_only'] = True 807 if kwargs.get('callback'): 808 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 809 else: 810 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 811 return data
Deletes a specified Connect log entry.
Deletes a specified entry from the Connect Log.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_log(account_id, log_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str log_id: The ID of the connect log entry (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_event_log_with_http_info(self, account_id, log_id, **kwargs)
813 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 814 """ 815 Deletes a specified Connect log entry. 816 Deletes a specified entry from the Connect Log. 817 This method makes a synchronous HTTP request by default. To make an 818 asynchronous HTTP request, please define a `callback` function 819 to be invoked when receiving the response. 820 >>> def callback_function(response): 821 >>> pprint(response) 822 >>> 823 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 824 825 :param callback function: The callback function 826 for asynchronous request. (optional) 827 :param str account_id: The external account number (int) or account ID Guid. (required) 828 :param str log_id: The ID of the connect log entry (required) 829 :return: None 830 If the method is called asynchronously, 831 returns the request thread. 832 """ 833 834 all_params = ['account_id', 'log_id'] 835 all_params.append('callback') 836 all_params.append('_return_http_data_only') 837 all_params.append('_preload_content') 838 all_params.append('_request_timeout') 839 840 params = locals() 841 for key, val in iteritems(params['kwargs']): 842 if key not in all_params: 843 raise TypeError( 844 "Got an unexpected keyword argument '%s'" 845 " to method delete_event_log" % key 846 ) 847 params[key] = val 848 del params['kwargs'] 849 # verify the required parameter 'account_id' is set 850 if ('account_id' not in params) or (params['account_id'] is None): 851 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 852 # verify the required parameter 'log_id' is set 853 if ('log_id' not in params) or (params['log_id'] is None): 854 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 855 856 857 collection_formats = {} 858 859 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 860 path_params = {} 861 if 'account_id' in params: 862 path_params['accountId'] = params['account_id'] 863 if 'log_id' in params: 864 path_params['logId'] = params['log_id'] 865 866 query_params = {} 867 868 header_params = {} 869 870 form_params = [] 871 local_var_files = {} 872 873 body_params = None 874 # HTTP header `Accept` 875 header_params['Accept'] = self.api_client.\ 876 select_header_accept(['application/json']) 877 878 # Authentication setting 879 auth_settings = [] 880 881 return self.api_client.call_api(resource_path, 'DELETE', 882 path_params, 883 query_params, 884 header_params, 885 body=body_params, 886 post_params=form_params, 887 files=local_var_files, 888 response_type=None, 889 auth_settings=auth_settings, 890 callback=params.get('callback'), 891 _return_http_data_only=params.get('_return_http_data_only'), 892 _preload_content=params.get('_preload_content', True), 893 _request_timeout=params.get('_request_timeout'), 894 collection_formats=collection_formats)
Deletes a specified Connect log entry.
Deletes a specified entry from the Connect Log.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str log_id: The ID of the connect log entry (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_event_logs(self, account_id, **kwargs)
896 def delete_event_logs(self, account_id, **kwargs): 897 """ 898 Gets a list of Connect log entries. 899 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 900 This method makes a synchronous HTTP request by default. To make an 901 asynchronous HTTP request, please define a `callback` function 902 to be invoked when receiving the response. 903 >>> def callback_function(response): 904 >>> pprint(response) 905 >>> 906 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 907 908 :param callback function: The callback function 909 for asynchronous request. (optional) 910 :param str account_id: The external account number (int) or account ID Guid. (required) 911 :return: None 912 If the method is called asynchronously, 913 returns the request thread. 914 """ 915 kwargs['_return_http_data_only'] = True 916 if kwargs.get('callback'): 917 return self.delete_event_logs_with_http_info(account_id, **kwargs) 918 else: 919 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 920 return data
Gets a list of Connect log entries.
Retrieves a list of connect log entries for your account. ###### Note: The enableLog property in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_logs(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_event_logs_with_http_info(self, account_id, **kwargs)
922 def delete_event_logs_with_http_info(self, account_id, **kwargs): 923 """ 924 Gets a list of Connect log entries. 925 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` property in the Connect configuration must be set to **true** to enable logging. If logging is not enabled, then no log entries are recorded. 926 This method makes a synchronous HTTP request by default. To make an 927 asynchronous HTTP request, please define a `callback` function 928 to be invoked when receiving the response. 929 >>> def callback_function(response): 930 >>> pprint(response) 931 >>> 932 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 933 934 :param callback function: The callback function 935 for asynchronous request. (optional) 936 :param str account_id: The external account number (int) or account ID Guid. (required) 937 :return: None 938 If the method is called asynchronously, 939 returns the request thread. 940 """ 941 942 all_params = ['account_id'] 943 all_params.append('callback') 944 all_params.append('_return_http_data_only') 945 all_params.append('_preload_content') 946 all_params.append('_request_timeout') 947 948 params = locals() 949 for key, val in iteritems(params['kwargs']): 950 if key not in all_params: 951 raise TypeError( 952 "Got an unexpected keyword argument '%s'" 953 " to method delete_event_logs" % key 954 ) 955 params[key] = val 956 del params['kwargs'] 957 # verify the required parameter 'account_id' is set 958 if ('account_id' not in params) or (params['account_id'] is None): 959 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 960 961 962 collection_formats = {} 963 964 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 965 path_params = {} 966 if 'account_id' in params: 967 path_params['accountId'] = params['account_id'] 968 969 query_params = {} 970 971 header_params = {} 972 973 form_params = [] 974 local_var_files = {} 975 976 body_params = None 977 # HTTP header `Accept` 978 header_params['Accept'] = self.api_client.\ 979 select_header_accept(['application/json']) 980 981 # Authentication setting 982 auth_settings = [] 983 984 return self.api_client.call_api(resource_path, 'DELETE', 985 path_params, 986 query_params, 987 header_params, 988 body=body_params, 989 post_params=form_params, 990 files=local_var_files, 991 response_type=None, 992 auth_settings=auth_settings, 993 callback=params.get('callback'), 994 _return_http_data_only=params.get('_return_http_data_only'), 995 _preload_content=params.get('_preload_content', True), 996 _request_timeout=params.get('_request_timeout'), 997 collection_formats=collection_formats)
Gets a list of Connect log entries.
Retrieves a list of connect log entries for your account. ###### Note: The enableLog property in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_mobile_notifiers(self, account_id, **kwargs)
999 def delete_mobile_notifiers(self, account_id, **kwargs): 1000 """ 1001 Reserved 1002 Reserved: 1003 This method makes a synchronous HTTP request by default. To make an 1004 asynchronous HTTP request, please define a `callback` function 1005 to be invoked when receiving the response. 1006 >>> def callback_function(response): 1007 >>> pprint(response) 1008 >>> 1009 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 1010 1011 :param callback function: The callback function 1012 for asynchronous request. (optional) 1013 :param str account_id: The external account number (int) or account ID Guid. (required) 1014 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1015 :return: MobileNotifierConfigurationInformation 1016 If the method is called asynchronously, 1017 returns the request thread. 1018 """ 1019 kwargs['_return_http_data_only'] = True 1020 if kwargs.get('callback'): 1021 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1022 else: 1023 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 1024 return data
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.
def
delete_mobile_notifiers_with_http_info(self, account_id, **kwargs)
1026 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1027 """ 1028 Reserved 1029 Reserved: 1030 This method makes a synchronous HTTP request by default. To make an 1031 asynchronous HTTP request, please define a `callback` function 1032 to be invoked when receiving the response. 1033 >>> def callback_function(response): 1034 >>> pprint(response) 1035 >>> 1036 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1037 1038 :param callback function: The callback function 1039 for asynchronous request. (optional) 1040 :param str account_id: The external account number (int) or account ID Guid. (required) 1041 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 1042 :return: MobileNotifierConfigurationInformation 1043 If the method is called asynchronously, 1044 returns the request thread. 1045 """ 1046 1047 all_params = ['account_id', 'mobile_notifier_configuration_information'] 1048 all_params.append('callback') 1049 all_params.append('_return_http_data_only') 1050 all_params.append('_preload_content') 1051 all_params.append('_request_timeout') 1052 1053 params = locals() 1054 for key, val in iteritems(params['kwargs']): 1055 if key not in all_params: 1056 raise TypeError( 1057 "Got an unexpected keyword argument '%s'" 1058 " to method delete_mobile_notifiers" % key 1059 ) 1060 params[key] = val 1061 del params['kwargs'] 1062 # verify the required parameter 'account_id' is set 1063 if ('account_id' not in params) or (params['account_id'] is None): 1064 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 1065 1066 1067 collection_formats = {} 1068 1069 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1070 path_params = {} 1071 if 'account_id' in params: 1072 path_params['accountId'] = params['account_id'] 1073 1074 query_params = {} 1075 1076 header_params = {} 1077 1078 form_params = [] 1079 local_var_files = {} 1080 1081 body_params = None 1082 if 'mobile_notifier_configuration_information' in params: 1083 body_params = params['mobile_notifier_configuration_information'] 1084 # HTTP header `Accept` 1085 header_params['Accept'] = self.api_client.\ 1086 select_header_accept(['application/json']) 1087 1088 # Authentication setting 1089 auth_settings = [] 1090 1091 return self.api_client.call_api(resource_path, 'DELETE', 1092 path_params, 1093 query_params, 1094 header_params, 1095 body=body_params, 1096 post_params=form_params, 1097 files=local_var_files, 1098 response_type='MobileNotifierConfigurationInformation', 1099 auth_settings=auth_settings, 1100 callback=params.get('callback'), 1101 _return_http_data_only=params.get('_return_http_data_only'), 1102 _preload_content=params.get('_preload_content', True), 1103 _request_timeout=params.get('_request_timeout'), 1104 collection_formats=collection_formats)
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.
def
get_configuration(self, account_id, connect_id, **kwargs)
1106 def get_configuration(self, account_id, connect_id, **kwargs): 1107 """ 1108 Get a Connect Configuration Information 1109 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1110 This method makes a synchronous HTTP request by default. To make an 1111 asynchronous HTTP request, please define a `callback` function 1112 to be invoked when receiving the response. 1113 >>> def callback_function(response): 1114 >>> pprint(response) 1115 >>> 1116 >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function) 1117 1118 :param callback function: The callback function 1119 for asynchronous request. (optional) 1120 :param str account_id: The external account number (int) or account ID Guid. (required) 1121 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1122 :return: ConnectConfigResults 1123 If the method is called asynchronously, 1124 returns the request thread. 1125 """ 1126 kwargs['_return_http_data_only'] = True 1127 if kwargs.get('callback'): 1128 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1129 else: 1130 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 1131 return data
Get a Connect Configuration Information
Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_configuration(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
Returns
ConnectConfigResults If the method is called asynchronously, returns the request thread.
def
get_configuration_with_http_info(self, account_id, connect_id, **kwargs)
1133 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 1134 """ 1135 Get a Connect Configuration Information 1136 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 1137 This method makes a synchronous HTTP request by default. To make an 1138 asynchronous HTTP request, please define a `callback` function 1139 to be invoked when receiving the response. 1140 >>> def callback_function(response): 1141 >>> pprint(response) 1142 >>> 1143 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 1144 1145 :param callback function: The callback function 1146 for asynchronous request. (optional) 1147 :param str account_id: The external account number (int) or account ID Guid. (required) 1148 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1149 :return: ConnectConfigResults 1150 If the method is called asynchronously, 1151 returns the request thread. 1152 """ 1153 1154 all_params = ['account_id', 'connect_id'] 1155 all_params.append('callback') 1156 all_params.append('_return_http_data_only') 1157 all_params.append('_preload_content') 1158 all_params.append('_request_timeout') 1159 1160 params = locals() 1161 for key, val in iteritems(params['kwargs']): 1162 if key not in all_params: 1163 raise TypeError( 1164 "Got an unexpected keyword argument '%s'" 1165 " to method get_configuration" % key 1166 ) 1167 params[key] = val 1168 del params['kwargs'] 1169 # verify the required parameter 'account_id' is set 1170 if ('account_id' not in params) or (params['account_id'] is None): 1171 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 1172 # verify the required parameter 'connect_id' is set 1173 if ('connect_id' not in params) or (params['connect_id'] is None): 1174 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 1175 1176 1177 collection_formats = {} 1178 1179 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 1180 path_params = {} 1181 if 'account_id' in params: 1182 path_params['accountId'] = params['account_id'] 1183 if 'connect_id' in params: 1184 path_params['connectId'] = params['connect_id'] 1185 1186 query_params = {} 1187 1188 header_params = {} 1189 1190 form_params = [] 1191 local_var_files = {} 1192 1193 body_params = None 1194 # HTTP header `Accept` 1195 header_params['Accept'] = self.api_client.\ 1196 select_header_accept(['application/json']) 1197 1198 # Authentication setting 1199 auth_settings = [] 1200 1201 return self.api_client.call_api(resource_path, 'GET', 1202 path_params, 1203 query_params, 1204 header_params, 1205 body=body_params, 1206 post_params=form_params, 1207 files=local_var_files, 1208 response_type='ConnectConfigResults', 1209 auth_settings=auth_settings, 1210 callback=params.get('callback'), 1211 _return_http_data_only=params.get('_return_http_data_only'), 1212 _preload_content=params.get('_preload_content', True), 1213 _request_timeout=params.get('_request_timeout'), 1214 collection_formats=collection_formats)
Get a Connect Configuration Information
Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
Returns
ConnectConfigResults If the method is called asynchronously, returns the request thread.
def
get_connect_all_users(self, account_id, connect_id, **kwargs)
1216 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1217 """ 1218 Returns all users from the configured Connect service. 1219 1220 This method makes a synchronous HTTP request by default. To make an 1221 asynchronous HTTP request, please define a `callback` function 1222 to be invoked when receiving the response. 1223 >>> def callback_function(response): 1224 >>> pprint(response) 1225 >>> 1226 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1227 1228 :param callback function: The callback function 1229 for asynchronous request. (optional) 1230 :param str account_id: The external account number (int) or account ID Guid. (required) 1231 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1232 :param str count: 1233 :param str domain_users_only: 1234 :param str email_substring: 1235 :param str start_position: 1236 :param str status: 1237 :param str user_name_substring: 1238 :return: IntegratedConnectUserInfoList 1239 If the method is called asynchronously, 1240 returns the request thread. 1241 """ 1242 kwargs['_return_http_data_only'] = True 1243 if kwargs.get('callback'): 1244 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1245 else: 1246 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1247 return data
Returns all users from the configured Connect service.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
- str count:
- str domain_users_only:
- str email_substring:
- str start_position:
- str status:
- str user_name_substring:
Returns
IntegratedConnectUserInfoList If the method is called asynchronously, returns the request thread.
def
get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs)
1249 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1250 """ 1251 Returns all users from the configured Connect service. 1252 1253 This method makes a synchronous HTTP request by default. To make an 1254 asynchronous HTTP request, please define a `callback` function 1255 to be invoked when receiving the response. 1256 >>> def callback_function(response): 1257 >>> pprint(response) 1258 >>> 1259 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1260 1261 :param callback function: The callback function 1262 for asynchronous request. (optional) 1263 :param str account_id: The external account number (int) or account ID Guid. (required) 1264 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1265 :param str count: 1266 :param str domain_users_only: 1267 :param str email_substring: 1268 :param str start_position: 1269 :param str status: 1270 :param str user_name_substring: 1271 :return: IntegratedConnectUserInfoList 1272 If the method is called asynchronously, 1273 returns the request thread. 1274 """ 1275 1276 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1277 all_params.append('callback') 1278 all_params.append('_return_http_data_only') 1279 all_params.append('_preload_content') 1280 all_params.append('_request_timeout') 1281 1282 params = locals() 1283 for key, val in iteritems(params['kwargs']): 1284 if key not in all_params: 1285 raise TypeError( 1286 "Got an unexpected keyword argument '%s'" 1287 " to method get_connect_all_users" % key 1288 ) 1289 params[key] = val 1290 del params['kwargs'] 1291 # verify the required parameter 'account_id' is set 1292 if ('account_id' not in params) or (params['account_id'] is None): 1293 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1294 # verify the required parameter 'connect_id' is set 1295 if ('connect_id' not in params) or (params['connect_id'] is None): 1296 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1297 1298 1299 collection_formats = {} 1300 1301 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1302 path_params = {} 1303 if 'account_id' in params: 1304 path_params['accountId'] = params['account_id'] 1305 if 'connect_id' in params: 1306 path_params['connectId'] = params['connect_id'] 1307 1308 query_params = {} 1309 if 'count' in params: 1310 query_params['count'] = params['count'] 1311 if 'domain_users_only' in params: 1312 query_params['domain_users_only'] = params['domain_users_only'] 1313 if 'email_substring' in params: 1314 query_params['email_substring'] = params['email_substring'] 1315 if 'start_position' in params: 1316 query_params['start_position'] = params['start_position'] 1317 if 'status' in params: 1318 query_params['status'] = params['status'] 1319 if 'user_name_substring' in params: 1320 query_params['user_name_substring'] = params['user_name_substring'] 1321 1322 header_params = {} 1323 1324 form_params = [] 1325 local_var_files = {} 1326 1327 body_params = None 1328 # HTTP header `Accept` 1329 header_params['Accept'] = self.api_client.\ 1330 select_header_accept(['application/json']) 1331 1332 # Authentication setting 1333 auth_settings = [] 1334 1335 return self.api_client.call_api(resource_path, 'GET', 1336 path_params, 1337 query_params, 1338 header_params, 1339 body=body_params, 1340 post_params=form_params, 1341 files=local_var_files, 1342 response_type='IntegratedConnectUserInfoList', 1343 auth_settings=auth_settings, 1344 callback=params.get('callback'), 1345 _return_http_data_only=params.get('_return_http_data_only'), 1346 _preload_content=params.get('_preload_content', True), 1347 _request_timeout=params.get('_request_timeout'), 1348 collection_formats=collection_formats)
Returns all users from the configured Connect service.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
- str count:
- str domain_users_only:
- str email_substring:
- str start_position:
- str status:
- str user_name_substring:
Returns
IntegratedConnectUserInfoList If the method is called asynchronously, returns the request thread.
def
get_connect_o_auth_config(self, account_id, **kwargs)
1350 def get_connect_o_auth_config(self, account_id, **kwargs): 1351 """ 1352 Sets the Connect OAuth Config for the account. 1353 This method makes a synchronous HTTP request by default. To make an 1354 asynchronous HTTP request, please define a `callback` function 1355 to be invoked when receiving the response. 1356 >>> def callback_function(response): 1357 >>> pprint(response) 1358 >>> 1359 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1360 1361 :param callback function: The callback function 1362 for asynchronous request. (optional) 1363 :param str account_id: The external account number (int) or account ID Guid. (required) 1364 :return: ConnectOAuthConfig 1365 If the method is called asynchronously, 1366 returns the request thread. 1367 """ 1368 kwargs['_return_http_data_only'] = True 1369 if kwargs.get('callback'): 1370 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1371 else: 1372 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1373 return data
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
get_connect_o_auth_config_with_http_info(self, account_id, **kwargs)
1375 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1376 """ 1377 Sets the Connect OAuth Config for the account. 1378 This method makes a synchronous HTTP request by default. To make an 1379 asynchronous HTTP request, please define a `callback` function 1380 to be invoked when receiving the response. 1381 >>> def callback_function(response): 1382 >>> pprint(response) 1383 >>> 1384 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1385 1386 :param callback function: The callback function 1387 for asynchronous request. (optional) 1388 :param str account_id: The external account number (int) or account ID Guid. (required) 1389 :return: ConnectOAuthConfig 1390 If the method is called asynchronously, 1391 returns the request thread. 1392 """ 1393 1394 all_params = ['account_id'] 1395 all_params.append('callback') 1396 all_params.append('_return_http_data_only') 1397 all_params.append('_preload_content') 1398 all_params.append('_request_timeout') 1399 1400 params = locals() 1401 for key, val in iteritems(params['kwargs']): 1402 if key not in all_params: 1403 raise TypeError( 1404 "Got an unexpected keyword argument '%s'" 1405 " to method get_connect_o_auth_config" % key 1406 ) 1407 params[key] = val 1408 del params['kwargs'] 1409 # verify the required parameter 'account_id' is set 1410 if ('account_id' not in params) or (params['account_id'] is None): 1411 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1412 1413 1414 collection_formats = {} 1415 1416 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1417 path_params = {} 1418 if 'account_id' in params: 1419 path_params['accountId'] = params['account_id'] 1420 1421 query_params = {} 1422 1423 header_params = {} 1424 1425 form_params = [] 1426 local_var_files = {} 1427 1428 body_params = None 1429 # HTTP header `Accept` 1430 header_params['Accept'] = self.api_client.\ 1431 select_header_accept(['application/json']) 1432 1433 # Authentication setting 1434 auth_settings = [] 1435 1436 return self.api_client.call_api(resource_path, 'GET', 1437 path_params, 1438 query_params, 1439 header_params, 1440 body=body_params, 1441 post_params=form_params, 1442 files=local_var_files, 1443 response_type='ConnectOAuthConfig', 1444 auth_settings=auth_settings, 1445 callback=params.get('callback'), 1446 _return_http_data_only=params.get('_return_http_data_only'), 1447 _preload_content=params.get('_preload_content', True), 1448 _request_timeout=params.get('_request_timeout'), 1449 collection_formats=collection_formats)
Sets the Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
get_connect_secret(self, account_id, **kwargs)
1451 def get_connect_secret(self, account_id, **kwargs): 1452 """ 1453 Get the connect HMAC Secrets for AccountID 1454 This method makes a synchronous HTTP request by default. To make an 1455 asynchronous HTTP request, please define a `callback` function 1456 to be invoked when receiving the response. 1457 >>> def callback_function(response): 1458 >>> pprint(response) 1459 >>> 1460 >>> thread = api.get_connect_secret(account_id, callback=callback_function) 1461 1462 :param callback function: The callback function 1463 for asynchronous request. (optional) 1464 :param str account_id: The external account number (int) or account ID Guid. (required) 1465 :return: None 1466 If the method is called asynchronously, 1467 returns the request thread. 1468 """ 1469 kwargs['_return_http_data_only'] = True 1470 if kwargs.get('callback'): 1471 return self.get_connect_secret_with_http_info(account_id, **kwargs) 1472 else: 1473 (data) = self.get_connect_secret_with_http_info(account_id, **kwargs) 1474 return data
Get the connect HMAC Secrets for AccountID
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_secret(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_connect_secret_with_http_info(self, account_id, **kwargs)
1476 def get_connect_secret_with_http_info(self, account_id, **kwargs): 1477 """ 1478 Get the connect HMAC Secrets for AccountID 1479 This method makes a synchronous HTTP request by default. To make an 1480 asynchronous HTTP request, please define a `callback` function 1481 to be invoked when receiving the response. 1482 >>> def callback_function(response): 1483 >>> pprint(response) 1484 >>> 1485 >>> thread = api.get_connect_secret_with_http_info(account_id, callback=callback_function) 1486 1487 :param callback function: The callback function 1488 for asynchronous request. (optional) 1489 :param str account_id: The external account number (int) or account ID Guid. (required) 1490 :return: None 1491 If the method is called asynchronously, 1492 returns the request thread. 1493 """ 1494 1495 all_params = ['account_id'] 1496 all_params.append('callback') 1497 all_params.append('_return_http_data_only') 1498 all_params.append('_preload_content') 1499 all_params.append('_request_timeout') 1500 1501 params = locals() 1502 for key, val in iteritems(params['kwargs']): 1503 if key not in all_params: 1504 raise TypeError( 1505 "Got an unexpected keyword argument '%s'" 1506 " to method get_connect_secret" % key 1507 ) 1508 params[key] = val 1509 del params['kwargs'] 1510 # verify the required parameter 'account_id' is set 1511 if ('account_id' not in params) or (params['account_id'] is None): 1512 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_secret`") 1513 1514 1515 collection_formats = {} 1516 1517 resource_path = '/v2.1/accounts/{accountId}/connect/secret'.replace('{format}', 'json') 1518 path_params = {} 1519 if 'account_id' in params: 1520 path_params['accountId'] = params['account_id'] 1521 1522 query_params = {} 1523 1524 header_params = {} 1525 1526 form_params = [] 1527 local_var_files = {} 1528 1529 body_params = None 1530 # HTTP header `Accept` 1531 header_params['Accept'] = self.api_client.\ 1532 select_header_accept(['application/json']) 1533 1534 # Authentication setting 1535 auth_settings = [] 1536 1537 return self.api_client.call_api(resource_path, 'GET', 1538 path_params, 1539 query_params, 1540 header_params, 1541 body=body_params, 1542 post_params=form_params, 1543 files=local_var_files, 1544 response_type=None, 1545 auth_settings=auth_settings, 1546 callback=params.get('callback'), 1547 _return_http_data_only=params.get('_return_http_data_only'), 1548 _preload_content=params.get('_preload_content', True), 1549 _request_timeout=params.get('_request_timeout'), 1550 collection_formats=collection_formats)
Get the connect HMAC Secrets for AccountID
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_connect_secret_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_event_log(self, account_id, log_id, **kwargs)
1552 def get_event_log(self, account_id, log_id, **kwargs): 1553 """ 1554 Get the specified Connect log entry. 1555 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1556 This method makes a synchronous HTTP request by default. To make an 1557 asynchronous HTTP request, please define a `callback` function 1558 to be invoked when receiving the response. 1559 >>> def callback_function(response): 1560 >>> pprint(response) 1561 >>> 1562 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1563 1564 :param callback function: The callback function 1565 for asynchronous request. (optional) 1566 :param str account_id: The external account number (int) or account ID Guid. (required) 1567 :param str log_id: The ID of the connect log entry (required) 1568 :param str additional_info: When true, the connectDebugLog information is included in the response. 1569 :return: ConnectLog 1570 If the method is called asynchronously, 1571 returns the request thread. 1572 """ 1573 kwargs['_return_http_data_only'] = True 1574 if kwargs.get('callback'): 1575 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1576 else: 1577 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1578 return data
Get the specified Connect log entry.
Retrieves the specified Connect log entry for your account. ###### Note: The enableLog setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_event_log(account_id, log_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str log_id: The ID of the connect log entry (required)
- str additional_info: When true, the connectDebugLog information is included in the response.
Returns
ConnectLog If the method is called asynchronously, returns the request thread.
def
get_event_log_with_http_info(self, account_id, log_id, **kwargs)
1580 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1581 """ 1582 Get the specified Connect log entry. 1583 Retrieves the specified Connect log entry for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1584 This method makes a synchronous HTTP request by default. To make an 1585 asynchronous HTTP request, please define a `callback` function 1586 to be invoked when receiving the response. 1587 >>> def callback_function(response): 1588 >>> pprint(response) 1589 >>> 1590 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1591 1592 :param callback function: The callback function 1593 for asynchronous request. (optional) 1594 :param str account_id: The external account number (int) or account ID Guid. (required) 1595 :param str log_id: The ID of the connect log entry (required) 1596 :param str additional_info: When true, the connectDebugLog information is included in the response. 1597 :return: ConnectLog 1598 If the method is called asynchronously, 1599 returns the request thread. 1600 """ 1601 1602 all_params = ['account_id', 'log_id', 'additional_info'] 1603 all_params.append('callback') 1604 all_params.append('_return_http_data_only') 1605 all_params.append('_preload_content') 1606 all_params.append('_request_timeout') 1607 1608 params = locals() 1609 for key, val in iteritems(params['kwargs']): 1610 if key not in all_params: 1611 raise TypeError( 1612 "Got an unexpected keyword argument '%s'" 1613 " to method get_event_log" % key 1614 ) 1615 params[key] = val 1616 del params['kwargs'] 1617 # verify the required parameter 'account_id' is set 1618 if ('account_id' not in params) or (params['account_id'] is None): 1619 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1620 # verify the required parameter 'log_id' is set 1621 if ('log_id' not in params) or (params['log_id'] is None): 1622 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1623 1624 1625 collection_formats = {} 1626 1627 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1628 path_params = {} 1629 if 'account_id' in params: 1630 path_params['accountId'] = params['account_id'] 1631 if 'log_id' in params: 1632 path_params['logId'] = params['log_id'] 1633 1634 query_params = {} 1635 if 'additional_info' in params: 1636 query_params['additional_info'] = params['additional_info'] 1637 1638 header_params = {} 1639 1640 form_params = [] 1641 local_var_files = {} 1642 1643 body_params = None 1644 # HTTP header `Accept` 1645 header_params['Accept'] = self.api_client.\ 1646 select_header_accept(['application/json']) 1647 1648 # Authentication setting 1649 auth_settings = [] 1650 1651 return self.api_client.call_api(resource_path, 'GET', 1652 path_params, 1653 query_params, 1654 header_params, 1655 body=body_params, 1656 post_params=form_params, 1657 files=local_var_files, 1658 response_type='ConnectLog', 1659 auth_settings=auth_settings, 1660 callback=params.get('callback'), 1661 _return_http_data_only=params.get('_return_http_data_only'), 1662 _preload_content=params.get('_preload_content', True), 1663 _request_timeout=params.get('_request_timeout'), 1664 collection_formats=collection_formats)
Get the specified Connect log entry.
Retrieves the specified Connect log entry for your account. ###### Note: The enableLog setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str log_id: The ID of the connect log entry (required)
- str additional_info: When true, the connectDebugLog information is included in the response.
Returns
ConnectLog If the method is called asynchronously, returns the request thread.
def
list_configurations(self, account_id, **kwargs)
1666 def list_configurations(self, account_id, **kwargs): 1667 """ 1668 Get Connect Configuration Information 1669 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1670 This method makes a synchronous HTTP request by default. To make an 1671 asynchronous HTTP request, please define a `callback` function 1672 to be invoked when receiving the response. 1673 >>> def callback_function(response): 1674 >>> pprint(response) 1675 >>> 1676 >>> thread = api.list_configurations(account_id, callback=callback_function) 1677 1678 :param callback function: The callback function 1679 for asynchronous request. (optional) 1680 :param str account_id: The external account number (int) or account ID Guid. (required) 1681 :return: ConnectConfigResults 1682 If the method is called asynchronously, 1683 returns the request thread. 1684 """ 1685 kwargs['_return_http_data_only'] = True 1686 if kwargs.get('callback'): 1687 return self.list_configurations_with_http_info(account_id, **kwargs) 1688 else: 1689 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1690 return data
Get Connect Configuration Information
Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_configurations(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ConnectConfigResults If the method is called asynchronously, returns the request thread.
def
list_configurations_with_http_info(self, account_id, **kwargs)
1692 def list_configurations_with_http_info(self, account_id, **kwargs): 1693 """ 1694 Get Connect Configuration Information 1695 Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce. 1696 This method makes a synchronous HTTP request by default. To make an 1697 asynchronous HTTP request, please define a `callback` function 1698 to be invoked when receiving the response. 1699 >>> def callback_function(response): 1700 >>> pprint(response) 1701 >>> 1702 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1703 1704 :param callback function: The callback function 1705 for asynchronous request. (optional) 1706 :param str account_id: The external account number (int) or account ID Guid. (required) 1707 :return: ConnectConfigResults 1708 If the method is called asynchronously, 1709 returns the request thread. 1710 """ 1711 1712 all_params = ['account_id'] 1713 all_params.append('callback') 1714 all_params.append('_return_http_data_only') 1715 all_params.append('_preload_content') 1716 all_params.append('_request_timeout') 1717 1718 params = locals() 1719 for key, val in iteritems(params['kwargs']): 1720 if key not in all_params: 1721 raise TypeError( 1722 "Got an unexpected keyword argument '%s'" 1723 " to method list_configurations" % key 1724 ) 1725 params[key] = val 1726 del params['kwargs'] 1727 # verify the required parameter 'account_id' is set 1728 if ('account_id' not in params) or (params['account_id'] is None): 1729 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1730 1731 1732 collection_formats = {} 1733 1734 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1735 path_params = {} 1736 if 'account_id' in params: 1737 path_params['accountId'] = params['account_id'] 1738 1739 query_params = {} 1740 1741 header_params = {} 1742 1743 form_params = [] 1744 local_var_files = {} 1745 1746 body_params = None 1747 # HTTP header `Accept` 1748 header_params['Accept'] = self.api_client.\ 1749 select_header_accept(['application/json']) 1750 1751 # Authentication setting 1752 auth_settings = [] 1753 1754 return self.api_client.call_api(resource_path, 'GET', 1755 path_params, 1756 query_params, 1757 header_params, 1758 body=body_params, 1759 post_params=form_params, 1760 files=local_var_files, 1761 response_type='ConnectConfigResults', 1762 auth_settings=auth_settings, 1763 callback=params.get('callback'), 1764 _return_http_data_only=params.get('_return_http_data_only'), 1765 _preload_content=params.get('_preload_content', True), 1766 _request_timeout=params.get('_request_timeout'), 1767 collection_formats=collection_formats)
Get Connect Configuration Information
Retrieves all the DocuSign Custom Connect definitions for the specified account. ###### Note: Connect must be enabled for your account to use this function. This does not retrieve information for Connect configurations for Box, eOriginal, or Salesforce.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ConnectConfigResults If the method is called asynchronously, returns the request thread.
def
list_event_failure_logs(self, account_id, **kwargs)
1769 def list_event_failure_logs(self, account_id, **kwargs): 1770 """ 1771 Gets the Connect failure log information. 1772 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1773 This method makes a synchronous HTTP request by default. To make an 1774 asynchronous HTTP request, please define a `callback` function 1775 to be invoked when receiving the response. 1776 >>> def callback_function(response): 1777 >>> pprint(response) 1778 >>> 1779 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1780 1781 :param callback function: The callback function 1782 for asynchronous request. (optional) 1783 :param str account_id: The external account number (int) or account ID Guid. (required) 1784 :param str from_date: 1785 :param str to_date: 1786 :return: ConnectLogs 1787 If the method is called asynchronously, 1788 returns the request thread. 1789 """ 1790 kwargs['_return_http_data_only'] = True 1791 if kwargs.get('callback'): 1792 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1793 else: 1794 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1795 return data
Gets the Connect failure log information.
Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_event_failure_logs(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str from_date:
- str to_date:
Returns
ConnectLogs If the method is called asynchronously, returns the request thread.
def
list_event_failure_logs_with_http_info(self, account_id, **kwargs)
1797 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1798 """ 1799 Gets the Connect failure log information. 1800 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1801 This method makes a synchronous HTTP request by default. To make an 1802 asynchronous HTTP request, please define a `callback` function 1803 to be invoked when receiving the response. 1804 >>> def callback_function(response): 1805 >>> pprint(response) 1806 >>> 1807 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1808 1809 :param callback function: The callback function 1810 for asynchronous request. (optional) 1811 :param str account_id: The external account number (int) or account ID Guid. (required) 1812 :param str from_date: 1813 :param str to_date: 1814 :return: ConnectLogs 1815 If the method is called asynchronously, 1816 returns the request thread. 1817 """ 1818 1819 all_params = ['account_id', 'from_date', 'to_date'] 1820 all_params.append('callback') 1821 all_params.append('_return_http_data_only') 1822 all_params.append('_preload_content') 1823 all_params.append('_request_timeout') 1824 1825 params = locals() 1826 for key, val in iteritems(params['kwargs']): 1827 if key not in all_params: 1828 raise TypeError( 1829 "Got an unexpected keyword argument '%s'" 1830 " to method list_event_failure_logs" % key 1831 ) 1832 params[key] = val 1833 del params['kwargs'] 1834 # verify the required parameter 'account_id' is set 1835 if ('account_id' not in params) or (params['account_id'] is None): 1836 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1837 1838 1839 collection_formats = {} 1840 1841 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1842 path_params = {} 1843 if 'account_id' in params: 1844 path_params['accountId'] = params['account_id'] 1845 1846 query_params = {} 1847 if 'from_date' in params: 1848 query_params['from_date'] = params['from_date'] 1849 if 'to_date' in params: 1850 query_params['to_date'] = params['to_date'] 1851 1852 header_params = {} 1853 1854 form_params = [] 1855 local_var_files = {} 1856 1857 body_params = None 1858 # HTTP header `Accept` 1859 header_params['Accept'] = self.api_client.\ 1860 select_header_accept(['application/json']) 1861 1862 # Authentication setting 1863 auth_settings = [] 1864 1865 return self.api_client.call_api(resource_path, 'GET', 1866 path_params, 1867 query_params, 1868 header_params, 1869 body=body_params, 1870 post_params=form_params, 1871 files=local_var_files, 1872 response_type='ConnectLogs', 1873 auth_settings=auth_settings, 1874 callback=params.get('callback'), 1875 _return_http_data_only=params.get('_return_http_data_only'), 1876 _preload_content=params.get('_preload_content', True), 1877 _request_timeout=params.get('_request_timeout'), 1878 collection_formats=collection_formats)
Gets the Connect failure log information.
Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str from_date:
- str to_date:
Returns
ConnectLogs If the method is called asynchronously, returns the request thread.
def
list_event_logs(self, account_id, **kwargs)
1880 def list_event_logs(self, account_id, **kwargs): 1881 """ 1882 Gets the Connect log. 1883 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1884 This method makes a synchronous HTTP request by default. To make an 1885 asynchronous HTTP request, please define a `callback` function 1886 to be invoked when receiving the response. 1887 >>> def callback_function(response): 1888 >>> pprint(response) 1889 >>> 1890 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1891 1892 :param callback function: The callback function 1893 for asynchronous request. (optional) 1894 :param str account_id: The external account number (int) or account ID Guid. (required) 1895 :param str from_date: 1896 :param str to_date: 1897 :return: ConnectLogs 1898 If the method is called asynchronously, 1899 returns the request thread. 1900 """ 1901 kwargs['_return_http_data_only'] = True 1902 if kwargs.get('callback'): 1903 return self.list_event_logs_with_http_info(account_id, **kwargs) 1904 else: 1905 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1906 return data
Gets the Connect log.
Retrieves a list of connect log entries for your account. ###### Note: The enableLog setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_event_logs(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str from_date:
- str to_date:
Returns
ConnectLogs If the method is called asynchronously, returns the request thread.
def
list_event_logs_with_http_info(self, account_id, **kwargs)
1908 def list_event_logs_with_http_info(self, account_id, **kwargs): 1909 """ 1910 Gets the Connect log. 1911 Retrieves a list of connect log entries for your account. ###### Note: The `enableLog` setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded. 1912 This method makes a synchronous HTTP request by default. To make an 1913 asynchronous HTTP request, please define a `callback` function 1914 to be invoked when receiving the response. 1915 >>> def callback_function(response): 1916 >>> pprint(response) 1917 >>> 1918 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1919 1920 :param callback function: The callback function 1921 for asynchronous request. (optional) 1922 :param str account_id: The external account number (int) or account ID Guid. (required) 1923 :param str from_date: 1924 :param str to_date: 1925 :return: ConnectLogs 1926 If the method is called asynchronously, 1927 returns the request thread. 1928 """ 1929 1930 all_params = ['account_id', 'from_date', 'to_date'] 1931 all_params.append('callback') 1932 all_params.append('_return_http_data_only') 1933 all_params.append('_preload_content') 1934 all_params.append('_request_timeout') 1935 1936 params = locals() 1937 for key, val in iteritems(params['kwargs']): 1938 if key not in all_params: 1939 raise TypeError( 1940 "Got an unexpected keyword argument '%s'" 1941 " to method list_event_logs" % key 1942 ) 1943 params[key] = val 1944 del params['kwargs'] 1945 # verify the required parameter 'account_id' is set 1946 if ('account_id' not in params) or (params['account_id'] is None): 1947 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1948 1949 1950 collection_formats = {} 1951 1952 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1953 path_params = {} 1954 if 'account_id' in params: 1955 path_params['accountId'] = params['account_id'] 1956 1957 query_params = {} 1958 if 'from_date' in params: 1959 query_params['from_date'] = params['from_date'] 1960 if 'to_date' in params: 1961 query_params['to_date'] = params['to_date'] 1962 1963 header_params = {} 1964 1965 form_params = [] 1966 local_var_files = {} 1967 1968 body_params = None 1969 # HTTP header `Accept` 1970 header_params['Accept'] = self.api_client.\ 1971 select_header_accept(['application/json']) 1972 1973 # Authentication setting 1974 auth_settings = [] 1975 1976 return self.api_client.call_api(resource_path, 'GET', 1977 path_params, 1978 query_params, 1979 header_params, 1980 body=body_params, 1981 post_params=form_params, 1982 files=local_var_files, 1983 response_type='ConnectLogs', 1984 auth_settings=auth_settings, 1985 callback=params.get('callback'), 1986 _return_http_data_only=params.get('_return_http_data_only'), 1987 _preload_content=params.get('_preload_content', True), 1988 _request_timeout=params.get('_request_timeout'), 1989 collection_formats=collection_formats)
Gets the Connect log.
Retrieves a list of connect log entries for your account. ###### Note: The enableLog setting in the Connect configuration must be set to true to enable logging. If logging is not enabled, then no log entries are recorded.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str from_date:
- str to_date:
Returns
ConnectLogs If the method is called asynchronously, returns the request thread.
def
list_mobile_notifiers(self, account_id, **kwargs)
1991 def list_mobile_notifiers(self, account_id, **kwargs): 1992 """ 1993 Reserved 1994 Reserved: 1995 This method makes a synchronous HTTP request by default. To make an 1996 asynchronous HTTP request, please define a `callback` function 1997 to be invoked when receiving the response. 1998 >>> def callback_function(response): 1999 >>> pprint(response) 2000 >>> 2001 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 2002 2003 :param callback function: The callback function 2004 for asynchronous request. (optional) 2005 :param str account_id: The external account number (int) or account ID Guid. (required) 2006 :return: MobileNotifierConfigurationInformation 2007 If the method is called asynchronously, 2008 returns the request thread. 2009 """ 2010 kwargs['_return_http_data_only'] = True 2011 if kwargs.get('callback'): 2012 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2013 else: 2014 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 2015 return data
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_mobile_notifiers(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.
def
list_mobile_notifiers_with_http_info(self, account_id, **kwargs)
2017 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2018 """ 2019 Reserved 2020 Reserved: 2021 This method makes a synchronous HTTP request by default. To make an 2022 asynchronous HTTP request, please define a `callback` function 2023 to be invoked when receiving the response. 2024 >>> def callback_function(response): 2025 >>> pprint(response) 2026 >>> 2027 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2028 2029 :param callback function: The callback function 2030 for asynchronous request. (optional) 2031 :param str account_id: The external account number (int) or account ID Guid. (required) 2032 :return: MobileNotifierConfigurationInformation 2033 If the method is called asynchronously, 2034 returns the request thread. 2035 """ 2036 2037 all_params = ['account_id'] 2038 all_params.append('callback') 2039 all_params.append('_return_http_data_only') 2040 all_params.append('_preload_content') 2041 all_params.append('_request_timeout') 2042 2043 params = locals() 2044 for key, val in iteritems(params['kwargs']): 2045 if key not in all_params: 2046 raise TypeError( 2047 "Got an unexpected keyword argument '%s'" 2048 " to method list_mobile_notifiers" % key 2049 ) 2050 params[key] = val 2051 del params['kwargs'] 2052 # verify the required parameter 'account_id' is set 2053 if ('account_id' not in params) or (params['account_id'] is None): 2054 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 2055 2056 2057 collection_formats = {} 2058 2059 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2060 path_params = {} 2061 if 'account_id' in params: 2062 path_params['accountId'] = params['account_id'] 2063 2064 query_params = {} 2065 2066 header_params = {} 2067 2068 form_params = [] 2069 local_var_files = {} 2070 2071 body_params = None 2072 # HTTP header `Accept` 2073 header_params['Accept'] = self.api_client.\ 2074 select_header_accept(['application/json']) 2075 2076 # Authentication setting 2077 auth_settings = [] 2078 2079 return self.api_client.call_api(resource_path, 'GET', 2080 path_params, 2081 query_params, 2082 header_params, 2083 body=body_params, 2084 post_params=form_params, 2085 files=local_var_files, 2086 response_type='MobileNotifierConfigurationInformation', 2087 auth_settings=auth_settings, 2088 callback=params.get('callback'), 2089 _return_http_data_only=params.get('_return_http_data_only'), 2090 _preload_content=params.get('_preload_content', True), 2091 _request_timeout=params.get('_request_timeout'), 2092 collection_formats=collection_formats)
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.
def
list_users(self, account_id, connect_id, **kwargs)
2094 def list_users(self, account_id, connect_id, **kwargs): 2095 """ 2096 Returns users from the configured Connect service. 2097 Returns users from the configured Connect service. 2098 This method makes a synchronous HTTP request by default. To make an 2099 asynchronous HTTP request, please define a `callback` function 2100 to be invoked when receiving the response. 2101 >>> def callback_function(response): 2102 >>> pprint(response) 2103 >>> 2104 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 2105 2106 :param callback function: The callback function 2107 for asynchronous request. (optional) 2108 :param str account_id: The external account number (int) or account ID Guid. (required) 2109 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2110 :param str count: 2111 :param str email_substring: 2112 :param str list_included_users: 2113 :param str start_position: 2114 :param str status: 2115 :param str user_name_substring: 2116 :return: IntegratedUserInfoList 2117 If the method is called asynchronously, 2118 returns the request thread. 2119 """ 2120 kwargs['_return_http_data_only'] = True 2121 if kwargs.get('callback'): 2122 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 2123 else: 2124 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 2125 return data
Returns users from the configured Connect service.
Returns users from the configured Connect service.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_users(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
- str count:
- str email_substring:
- str list_included_users:
- str start_position:
- str status:
- str user_name_substring:
Returns
IntegratedUserInfoList If the method is called asynchronously, returns the request thread.
def
list_users_with_http_info(self, account_id, connect_id, **kwargs)
2127 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 2128 """ 2129 Returns users from the configured Connect service. 2130 Returns users from the configured Connect service. 2131 This method makes a synchronous HTTP request by default. To make an 2132 asynchronous HTTP request, please define a `callback` function 2133 to be invoked when receiving the response. 2134 >>> def callback_function(response): 2135 >>> pprint(response) 2136 >>> 2137 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 2138 2139 :param callback function: The callback function 2140 for asynchronous request. (optional) 2141 :param str account_id: The external account number (int) or account ID Guid. (required) 2142 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 2143 :param str count: 2144 :param str email_substring: 2145 :param str list_included_users: 2146 :param str start_position: 2147 :param str status: 2148 :param str user_name_substring: 2149 :return: IntegratedUserInfoList 2150 If the method is called asynchronously, 2151 returns the request thread. 2152 """ 2153 2154 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 2155 all_params.append('callback') 2156 all_params.append('_return_http_data_only') 2157 all_params.append('_preload_content') 2158 all_params.append('_request_timeout') 2159 2160 params = locals() 2161 for key, val in iteritems(params['kwargs']): 2162 if key not in all_params: 2163 raise TypeError( 2164 "Got an unexpected keyword argument '%s'" 2165 " to method list_users" % key 2166 ) 2167 params[key] = val 2168 del params['kwargs'] 2169 # verify the required parameter 'account_id' is set 2170 if ('account_id' not in params) or (params['account_id'] is None): 2171 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 2172 # verify the required parameter 'connect_id' is set 2173 if ('connect_id' not in params) or (params['connect_id'] is None): 2174 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 2175 2176 2177 collection_formats = {} 2178 2179 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 2180 path_params = {} 2181 if 'account_id' in params: 2182 path_params['accountId'] = params['account_id'] 2183 if 'connect_id' in params: 2184 path_params['connectId'] = params['connect_id'] 2185 2186 query_params = {} 2187 if 'count' in params: 2188 query_params['count'] = params['count'] 2189 if 'email_substring' in params: 2190 query_params['email_substring'] = params['email_substring'] 2191 if 'list_included_users' in params: 2192 query_params['list_included_users'] = params['list_included_users'] 2193 if 'start_position' in params: 2194 query_params['start_position'] = params['start_position'] 2195 if 'status' in params: 2196 query_params['status'] = params['status'] 2197 if 'user_name_substring' in params: 2198 query_params['user_name_substring'] = params['user_name_substring'] 2199 2200 header_params = {} 2201 2202 form_params = [] 2203 local_var_files = {} 2204 2205 body_params = None 2206 # HTTP header `Accept` 2207 header_params['Accept'] = self.api_client.\ 2208 select_header_accept(['application/json']) 2209 2210 # Authentication setting 2211 auth_settings = [] 2212 2213 return self.api_client.call_api(resource_path, 'GET', 2214 path_params, 2215 query_params, 2216 header_params, 2217 body=body_params, 2218 post_params=form_params, 2219 files=local_var_files, 2220 response_type='IntegratedUserInfoList', 2221 auth_settings=auth_settings, 2222 callback=params.get('callback'), 2223 _return_http_data_only=params.get('_return_http_data_only'), 2224 _preload_content=params.get('_preload_content', True), 2225 _request_timeout=params.get('_request_timeout'), 2226 collection_formats=collection_formats)
Returns users from the configured Connect service.
Returns users from the configured Connect service.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str connect_id: The ID of the custom Connect configuration being accessed. (required)
- str count:
- str email_substring:
- str list_included_users:
- str start_position:
- str status:
- str user_name_substring:
Returns
IntegratedUserInfoList If the method is called asynchronously, returns the request thread.
def
retry_event_for_envelope(self, account_id, envelope_id, **kwargs)
2228 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 2229 """ 2230 Republishes Connect information for the specified envelope. 2231 Republishes Connect information for the specified envelope. 2232 This method makes a synchronous HTTP request by default. To make an 2233 asynchronous HTTP request, please define a `callback` function 2234 to be invoked when receiving the response. 2235 >>> def callback_function(response): 2236 >>> pprint(response) 2237 >>> 2238 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 2239 2240 :param callback function: The callback function 2241 for asynchronous request. (optional) 2242 :param str account_id: The external account number (int) or account ID Guid. (required) 2243 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2244 :return: ConnectFailureResults 2245 If the method is called asynchronously, 2246 returns the request thread. 2247 """ 2248 kwargs['_return_http_data_only'] = True 2249 if kwargs.get('callback'): 2250 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2251 else: 2252 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 2253 return data
Republishes Connect information for the specified envelope.
Republishes Connect information for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
ConnectFailureResults If the method is called asynchronously, returns the request thread.
def
retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs)
2255 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 2256 """ 2257 Republishes Connect information for the specified envelope. 2258 Republishes Connect information for the specified envelope. 2259 This method makes a synchronous HTTP request by default. To make an 2260 asynchronous HTTP request, please define a `callback` function 2261 to be invoked when receiving the response. 2262 >>> def callback_function(response): 2263 >>> pprint(response) 2264 >>> 2265 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 2266 2267 :param callback function: The callback function 2268 for asynchronous request. (optional) 2269 :param str account_id: The external account number (int) or account ID Guid. (required) 2270 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2271 :return: ConnectFailureResults 2272 If the method is called asynchronously, 2273 returns the request thread. 2274 """ 2275 2276 all_params = ['account_id', 'envelope_id'] 2277 all_params.append('callback') 2278 all_params.append('_return_http_data_only') 2279 all_params.append('_preload_content') 2280 all_params.append('_request_timeout') 2281 2282 params = locals() 2283 for key, val in iteritems(params['kwargs']): 2284 if key not in all_params: 2285 raise TypeError( 2286 "Got an unexpected keyword argument '%s'" 2287 " to method retry_event_for_envelope" % key 2288 ) 2289 params[key] = val 2290 del params['kwargs'] 2291 # verify the required parameter 'account_id' is set 2292 if ('account_id' not in params) or (params['account_id'] is None): 2293 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 2294 # verify the required parameter 'envelope_id' is set 2295 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2296 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 2297 2298 2299 collection_formats = {} 2300 2301 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 2302 path_params = {} 2303 if 'account_id' in params: 2304 path_params['accountId'] = params['account_id'] 2305 if 'envelope_id' in params: 2306 path_params['envelopeId'] = params['envelope_id'] 2307 2308 query_params = {} 2309 2310 header_params = {} 2311 2312 form_params = [] 2313 local_var_files = {} 2314 2315 body_params = None 2316 # HTTP header `Accept` 2317 header_params['Accept'] = self.api_client.\ 2318 select_header_accept(['application/json']) 2319 2320 # Authentication setting 2321 auth_settings = [] 2322 2323 return self.api_client.call_api(resource_path, 'PUT', 2324 path_params, 2325 query_params, 2326 header_params, 2327 body=body_params, 2328 post_params=form_params, 2329 files=local_var_files, 2330 response_type='ConnectFailureResults', 2331 auth_settings=auth_settings, 2332 callback=params.get('callback'), 2333 _return_http_data_only=params.get('_return_http_data_only'), 2334 _preload_content=params.get('_preload_content', True), 2335 _request_timeout=params.get('_request_timeout'), 2336 collection_formats=collection_formats)
Republishes Connect information for the specified envelope.
Republishes Connect information for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
ConnectFailureResults If the method is called asynchronously, returns the request thread.
def
retry_event_for_envelopes(self, account_id, **kwargs)
2338 def retry_event_for_envelopes(self, account_id, **kwargs): 2339 """ 2340 Republishes Connect information for multiple envelopes. 2341 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2342 This method makes a synchronous HTTP request by default. To make an 2343 asynchronous HTTP request, please define a `callback` function 2344 to be invoked when receiving the response. 2345 >>> def callback_function(response): 2346 >>> pprint(response) 2347 >>> 2348 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2349 2350 :param callback function: The callback function 2351 for asynchronous request. (optional) 2352 :param str account_id: The external account number (int) or account ID Guid. (required) 2353 :param ConnectFailureFilter connect_failure_filter: 2354 :return: ConnectFailureResults 2355 If the method is called asynchronously, 2356 returns the request thread. 2357 """ 2358 kwargs['_return_http_data_only'] = True 2359 if kwargs.get('callback'): 2360 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2361 else: 2362 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2363 return data
Republishes Connect information for multiple envelopes.
Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectFailureFilter connect_failure_filter:
Returns
ConnectFailureResults If the method is called asynchronously, returns the request thread.
def
retry_event_for_envelopes_with_http_info(self, account_id, **kwargs)
2365 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2366 """ 2367 Republishes Connect information for multiple envelopes. 2368 Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log. 2369 This method makes a synchronous HTTP request by default. To make an 2370 asynchronous HTTP request, please define a `callback` function 2371 to be invoked when receiving the response. 2372 >>> def callback_function(response): 2373 >>> pprint(response) 2374 >>> 2375 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2376 2377 :param callback function: The callback function 2378 for asynchronous request. (optional) 2379 :param str account_id: The external account number (int) or account ID Guid. (required) 2380 :param ConnectFailureFilter connect_failure_filter: 2381 :return: ConnectFailureResults 2382 If the method is called asynchronously, 2383 returns the request thread. 2384 """ 2385 2386 all_params = ['account_id', 'connect_failure_filter'] 2387 all_params.append('callback') 2388 all_params.append('_return_http_data_only') 2389 all_params.append('_preload_content') 2390 all_params.append('_request_timeout') 2391 2392 params = locals() 2393 for key, val in iteritems(params['kwargs']): 2394 if key not in all_params: 2395 raise TypeError( 2396 "Got an unexpected keyword argument '%s'" 2397 " to method retry_event_for_envelopes" % key 2398 ) 2399 params[key] = val 2400 del params['kwargs'] 2401 # verify the required parameter 'account_id' is set 2402 if ('account_id' not in params) or (params['account_id'] is None): 2403 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2404 2405 2406 collection_formats = {} 2407 2408 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2409 path_params = {} 2410 if 'account_id' in params: 2411 path_params['accountId'] = params['account_id'] 2412 2413 query_params = {} 2414 2415 header_params = {} 2416 2417 form_params = [] 2418 local_var_files = {} 2419 2420 body_params = None 2421 if 'connect_failure_filter' in params: 2422 body_params = params['connect_failure_filter'] 2423 # HTTP header `Accept` 2424 header_params['Accept'] = self.api_client.\ 2425 select_header_accept(['application/json']) 2426 2427 # Authentication setting 2428 auth_settings = [] 2429 2430 return self.api_client.call_api(resource_path, 'PUT', 2431 path_params, 2432 query_params, 2433 header_params, 2434 body=body_params, 2435 post_params=form_params, 2436 files=local_var_files, 2437 response_type='ConnectFailureResults', 2438 auth_settings=auth_settings, 2439 callback=params.get('callback'), 2440 _return_http_data_only=params.get('_return_http_data_only'), 2441 _preload_content=params.get('_preload_content', True), 2442 _request_timeout=params.get('_request_timeout'), 2443 collection_formats=collection_formats)
Republishes Connect information for multiple envelopes.
Republishes Connect information for the specified set of envelopes. The primary use is to republish Connect post failures by including envelope IDs for the envelopes that failed to post in the request. The list of envelope IDs that failed to post correctly can be retrieved by calling to [ML:GetConnectLog] retrieve the failure log.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectFailureFilter connect_failure_filter:
Returns
ConnectFailureResults If the method is called asynchronously, returns the request thread.
def
update_configuration(self, account_id, **kwargs)
2445 def update_configuration(self, account_id, **kwargs): 2446 """ 2447 Updates a specified Connect configuration. 2448 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2449 This method makes a synchronous HTTP request by default. To make an 2450 asynchronous HTTP request, please define a `callback` function 2451 to be invoked when receiving the response. 2452 >>> def callback_function(response): 2453 >>> pprint(response) 2454 >>> 2455 >>> thread = api.update_configuration(account_id, callback=callback_function) 2456 2457 :param callback function: The callback function 2458 for asynchronous request. (optional) 2459 :param str account_id: The external account number (int) or account ID Guid. (required) 2460 :param ConnectCustomConfiguration connect_custom_configuration: 2461 :return: ConnectCustomConfiguration 2462 If the method is called asynchronously, 2463 returns the request thread. 2464 """ 2465 kwargs['_return_http_data_only'] = True 2466 if kwargs.get('callback'): 2467 return self.update_configuration_with_http_info(account_id, **kwargs) 2468 else: 2469 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2470 return data
Updates a specified Connect configuration.
Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectCustomConfiguration connect_custom_configuration:
Returns
ConnectCustomConfiguration If the method is called asynchronously, returns the request thread.
def
update_configuration_with_http_info(self, account_id, **kwargs)
2472 def update_configuration_with_http_info(self, account_id, **kwargs): 2473 """ 2474 Updates a specified Connect configuration. 2475 Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce. 2476 This method makes a synchronous HTTP request by default. To make an 2477 asynchronous HTTP request, please define a `callback` function 2478 to be invoked when receiving the response. 2479 >>> def callback_function(response): 2480 >>> pprint(response) 2481 >>> 2482 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2483 2484 :param callback function: The callback function 2485 for asynchronous request. (optional) 2486 :param str account_id: The external account number (int) or account ID Guid. (required) 2487 :param ConnectCustomConfiguration connect_custom_configuration: 2488 :return: ConnectCustomConfiguration 2489 If the method is called asynchronously, 2490 returns the request thread. 2491 """ 2492 2493 all_params = ['account_id', 'connect_custom_configuration'] 2494 all_params.append('callback') 2495 all_params.append('_return_http_data_only') 2496 all_params.append('_preload_content') 2497 all_params.append('_request_timeout') 2498 2499 params = locals() 2500 for key, val in iteritems(params['kwargs']): 2501 if key not in all_params: 2502 raise TypeError( 2503 "Got an unexpected keyword argument '%s'" 2504 " to method update_configuration" % key 2505 ) 2506 params[key] = val 2507 del params['kwargs'] 2508 # verify the required parameter 'account_id' is set 2509 if ('account_id' not in params) or (params['account_id'] is None): 2510 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2511 2512 2513 collection_formats = {} 2514 2515 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2516 path_params = {} 2517 if 'account_id' in params: 2518 path_params['accountId'] = params['account_id'] 2519 2520 query_params = {} 2521 2522 header_params = {} 2523 2524 form_params = [] 2525 local_var_files = {} 2526 2527 body_params = None 2528 if 'connect_custom_configuration' in params: 2529 body_params = params['connect_custom_configuration'] 2530 # HTTP header `Accept` 2531 header_params['Accept'] = self.api_client.\ 2532 select_header_accept(['application/json']) 2533 2534 # Authentication setting 2535 auth_settings = [] 2536 2537 return self.api_client.call_api(resource_path, 'PUT', 2538 path_params, 2539 query_params, 2540 header_params, 2541 body=body_params, 2542 post_params=form_params, 2543 files=local_var_files, 2544 response_type='ConnectCustomConfiguration', 2545 auth_settings=auth_settings, 2546 callback=params.get('callback'), 2547 _return_http_data_only=params.get('_return_http_data_only'), 2548 _preload_content=params.get('_preload_content', True), 2549 _request_timeout=params.get('_request_timeout'), 2550 collection_formats=collection_formats)
Updates a specified Connect configuration.
Updates the specified DocuSign Connect configuration in your account. ###### Note: Connect must be enabled for your account to use this function. This cannot be used to update Connect configurations for Box, eOriginal, or Salesforce.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectCustomConfiguration connect_custom_configuration:
Returns
ConnectCustomConfiguration If the method is called asynchronously, returns the request thread.
def
update_connect_o_auth_config(self, account_id, **kwargs)
2552 def update_connect_o_auth_config(self, account_id, **kwargs): 2553 """ 2554 Updates the existing Connect OAuth Config for the account. 2555 This method makes a synchronous HTTP request by default. To make an 2556 asynchronous HTTP request, please define a `callback` function 2557 to be invoked when receiving the response. 2558 >>> def callback_function(response): 2559 >>> pprint(response) 2560 >>> 2561 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2562 2563 :param callback function: The callback function 2564 for asynchronous request. (optional) 2565 :param str account_id: The external account number (int) or account ID Guid. (required) 2566 :param ConnectOAuthConfig connect_o_auth_config: 2567 :return: ConnectOAuthConfig 2568 If the method is called asynchronously, 2569 returns the request thread. 2570 """ 2571 kwargs['_return_http_data_only'] = True 2572 if kwargs.get('callback'): 2573 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2574 else: 2575 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2576 return data
Updates the existing Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectOAuthConfig connect_o_auth_config:
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
update_connect_o_auth_config_with_http_info(self, account_id, **kwargs)
2578 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2579 """ 2580 Updates the existing Connect OAuth Config for the account. 2581 This method makes a synchronous HTTP request by default. To make an 2582 asynchronous HTTP request, please define a `callback` function 2583 to be invoked when receiving the response. 2584 >>> def callback_function(response): 2585 >>> pprint(response) 2586 >>> 2587 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2588 2589 :param callback function: The callback function 2590 for asynchronous request. (optional) 2591 :param str account_id: The external account number (int) or account ID Guid. (required) 2592 :param ConnectOAuthConfig connect_o_auth_config: 2593 :return: ConnectOAuthConfig 2594 If the method is called asynchronously, 2595 returns the request thread. 2596 """ 2597 2598 all_params = ['account_id', 'connect_o_auth_config'] 2599 all_params.append('callback') 2600 all_params.append('_return_http_data_only') 2601 all_params.append('_preload_content') 2602 all_params.append('_request_timeout') 2603 2604 params = locals() 2605 for key, val in iteritems(params['kwargs']): 2606 if key not in all_params: 2607 raise TypeError( 2608 "Got an unexpected keyword argument '%s'" 2609 " to method update_connect_o_auth_config" % key 2610 ) 2611 params[key] = val 2612 del params['kwargs'] 2613 # verify the required parameter 'account_id' is set 2614 if ('account_id' not in params) or (params['account_id'] is None): 2615 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2616 2617 2618 collection_formats = {} 2619 2620 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2621 path_params = {} 2622 if 'account_id' in params: 2623 path_params['accountId'] = params['account_id'] 2624 2625 query_params = {} 2626 2627 header_params = {} 2628 2629 form_params = [] 2630 local_var_files = {} 2631 2632 body_params = None 2633 if 'connect_o_auth_config' in params: 2634 body_params = params['connect_o_auth_config'] 2635 # HTTP header `Accept` 2636 header_params['Accept'] = self.api_client.\ 2637 select_header_accept(['application/json']) 2638 2639 # Authentication setting 2640 auth_settings = [] 2641 2642 return self.api_client.call_api(resource_path, 'PUT', 2643 path_params, 2644 query_params, 2645 header_params, 2646 body=body_params, 2647 post_params=form_params, 2648 files=local_var_files, 2649 response_type='ConnectOAuthConfig', 2650 auth_settings=auth_settings, 2651 callback=params.get('callback'), 2652 _return_http_data_only=params.get('_return_http_data_only'), 2653 _preload_content=params.get('_preload_content', True), 2654 _request_timeout=params.get('_request_timeout'), 2655 collection_formats=collection_formats)
Updates the existing Connect OAuth Config for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectOAuthConfig connect_o_auth_config:
Returns
ConnectOAuthConfig If the method is called asynchronously, returns the request thread.
def
update_mobile_notifiers(self, account_id, **kwargs)
2657 def update_mobile_notifiers(self, account_id, **kwargs): 2658 """ 2659 Reserved 2660 Reserved: 2661 This method makes a synchronous HTTP request by default. To make an 2662 asynchronous HTTP request, please define a `callback` function 2663 to be invoked when receiving the response. 2664 >>> def callback_function(response): 2665 >>> pprint(response) 2666 >>> 2667 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2668 2669 :param callback function: The callback function 2670 for asynchronous request. (optional) 2671 :param str account_id: The external account number (int) or account ID Guid. (required) 2672 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2673 :return: MobileNotifierConfigurationInformation 2674 If the method is called asynchronously, 2675 returns the request thread. 2676 """ 2677 kwargs['_return_http_data_only'] = True 2678 if kwargs.get('callback'): 2679 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2680 else: 2681 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2682 return data
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_mobile_notifiers(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.
def
update_mobile_notifiers_with_http_info(self, account_id, **kwargs)
2684 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2685 """ 2686 Reserved 2687 Reserved: 2688 This method makes a synchronous HTTP request by default. To make an 2689 asynchronous HTTP request, please define a `callback` function 2690 to be invoked when receiving the response. 2691 >>> def callback_function(response): 2692 >>> pprint(response) 2693 >>> 2694 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2695 2696 :param callback function: The callback function 2697 for asynchronous request. (optional) 2698 :param str account_id: The external account number (int) or account ID Guid. (required) 2699 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2700 :return: MobileNotifierConfigurationInformation 2701 If the method is called asynchronously, 2702 returns the request thread. 2703 """ 2704 2705 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2706 all_params.append('callback') 2707 all_params.append('_return_http_data_only') 2708 all_params.append('_preload_content') 2709 all_params.append('_request_timeout') 2710 2711 params = locals() 2712 for key, val in iteritems(params['kwargs']): 2713 if key not in all_params: 2714 raise TypeError( 2715 "Got an unexpected keyword argument '%s'" 2716 " to method update_mobile_notifiers" % key 2717 ) 2718 params[key] = val 2719 del params['kwargs'] 2720 # verify the required parameter 'account_id' is set 2721 if ('account_id' not in params) or (params['account_id'] is None): 2722 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2723 2724 2725 collection_formats = {} 2726 2727 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2728 path_params = {} 2729 if 'account_id' in params: 2730 path_params['accountId'] = params['account_id'] 2731 2732 query_params = {} 2733 2734 header_params = {} 2735 2736 form_params = [] 2737 local_var_files = {} 2738 2739 body_params = None 2740 if 'mobile_notifier_configuration_information' in params: 2741 body_params = params['mobile_notifier_configuration_information'] 2742 # HTTP header `Accept` 2743 header_params['Accept'] = self.api_client.\ 2744 select_header_accept(['application/json']) 2745 2746 # Authentication setting 2747 auth_settings = [] 2748 2749 return self.api_client.call_api(resource_path, 'PUT', 2750 path_params, 2751 query_params, 2752 header_params, 2753 body=body_params, 2754 post_params=form_params, 2755 files=local_var_files, 2756 response_type='MobileNotifierConfigurationInformation', 2757 auth_settings=auth_settings, 2758 callback=params.get('callback'), 2759 _return_http_data_only=params.get('_return_http_data_only'), 2760 _preload_content=params.get('_preload_content', True), 2761 _request_timeout=params.get('_request_timeout'), 2762 collection_formats=collection_formats)
Reserved
Reserved:
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- MobileNotifierConfigurationInformation mobile_notifier_configuration_information:
Returns
MobileNotifierConfigurationInformation If the method is called asynchronously, returns the request thread.