docusign_esign.apis.connect_api
DocuSign REST API
The DocuSign 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 REST API 5 6 The DocuSign 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 delete_configuration(self, account_id, connect_id, **kwargs): 256 """ 257 Deletes the specified connect configuration. 258 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 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.delete_configuration(account_id, connect_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 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 271 :return: None 272 If the method is called asynchronously, 273 returns the request thread. 274 """ 275 kwargs['_return_http_data_only'] = True 276 if kwargs.get('callback'): 277 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 278 else: 279 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 280 return data 281 282 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 283 """ 284 Deletes the specified connect configuration. 285 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 286 This method makes a synchronous HTTP request by default. To make an 287 asynchronous HTTP request, please define a `callback` function 288 to be invoked when receiving the response. 289 >>> def callback_function(response): 290 >>> pprint(response) 291 >>> 292 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 293 294 :param callback function: The callback function 295 for asynchronous request. (optional) 296 :param str account_id: The external account number (int) or account ID Guid. (required) 297 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 298 :return: None 299 If the method is called asynchronously, 300 returns the request thread. 301 """ 302 303 all_params = ['account_id', 'connect_id'] 304 all_params.append('callback') 305 all_params.append('_return_http_data_only') 306 all_params.append('_preload_content') 307 all_params.append('_request_timeout') 308 309 params = locals() 310 for key, val in iteritems(params['kwargs']): 311 if key not in all_params: 312 raise TypeError( 313 "Got an unexpected keyword argument '%s'" 314 " to method delete_configuration" % key 315 ) 316 params[key] = val 317 del params['kwargs'] 318 # verify the required parameter 'account_id' is set 319 if ('account_id' not in params) or (params['account_id'] is None): 320 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 321 # verify the required parameter 'connect_id' is set 322 if ('connect_id' not in params) or (params['connect_id'] is None): 323 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 324 325 326 collection_formats = {} 327 328 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 329 path_params = {} 330 if 'account_id' in params: 331 path_params['accountId'] = params['account_id'] 332 if 'connect_id' in params: 333 path_params['connectId'] = params['connect_id'] 334 335 query_params = {} 336 337 header_params = {} 338 339 form_params = [] 340 local_var_files = {} 341 342 body_params = None 343 # HTTP header `Accept` 344 header_params['Accept'] = self.api_client.\ 345 select_header_accept(['application/json']) 346 347 # Authentication setting 348 auth_settings = [] 349 350 return self.api_client.call_api(resource_path, 'DELETE', 351 path_params, 352 query_params, 353 header_params, 354 body=body_params, 355 post_params=form_params, 356 files=local_var_files, 357 response_type=None, 358 auth_settings=auth_settings, 359 callback=params.get('callback'), 360 _return_http_data_only=params.get('_return_http_data_only'), 361 _preload_content=params.get('_preload_content', True), 362 _request_timeout=params.get('_request_timeout'), 363 collection_formats=collection_formats) 364 365 def delete_connect_o_auth_config(self, account_id, **kwargs): 366 """ 367 Sets the Connect OAuth Config for the account. 368 This method makes a synchronous HTTP request by default. To make an 369 asynchronous HTTP request, please define a `callback` function 370 to be invoked when receiving the response. 371 >>> def callback_function(response): 372 >>> pprint(response) 373 >>> 374 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 375 376 :param callback function: The callback function 377 for asynchronous request. (optional) 378 :param str account_id: The external account number (int) or account ID Guid. (required) 379 :return: None 380 If the method is called asynchronously, 381 returns the request thread. 382 """ 383 kwargs['_return_http_data_only'] = True 384 if kwargs.get('callback'): 385 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 386 else: 387 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 388 return data 389 390 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 391 """ 392 Sets the Connect OAuth Config for the account. 393 This method makes a synchronous HTTP request by default. To make an 394 asynchronous HTTP request, please define a `callback` function 395 to be invoked when receiving the response. 396 >>> def callback_function(response): 397 >>> pprint(response) 398 >>> 399 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 400 401 :param callback function: The callback function 402 for asynchronous request. (optional) 403 :param str account_id: The external account number (int) or account ID Guid. (required) 404 :return: None 405 If the method is called asynchronously, 406 returns the request thread. 407 """ 408 409 all_params = ['account_id'] 410 all_params.append('callback') 411 all_params.append('_return_http_data_only') 412 all_params.append('_preload_content') 413 all_params.append('_request_timeout') 414 415 params = locals() 416 for key, val in iteritems(params['kwargs']): 417 if key not in all_params: 418 raise TypeError( 419 "Got an unexpected keyword argument '%s'" 420 " to method delete_connect_o_auth_config" % key 421 ) 422 params[key] = val 423 del params['kwargs'] 424 # verify the required parameter 'account_id' is set 425 if ('account_id' not in params) or (params['account_id'] is None): 426 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 427 428 429 collection_formats = {} 430 431 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 432 path_params = {} 433 if 'account_id' in params: 434 path_params['accountId'] = params['account_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_event_failure_log(self, account_id, failure_id, **kwargs): 467 """ 468 Deletes a Connect failure log entry. 469 Deletes the Connect failure log information for the specified entry. 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_event_failure_log(account_id, failure_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 :param str failure_id: The ID of the failed connect log entry. (required) 482 :return: ConnectDeleteFailureResult 483 If the method is called asynchronously, 484 returns the request thread. 485 """ 486 kwargs['_return_http_data_only'] = True 487 if kwargs.get('callback'): 488 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 489 else: 490 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 491 return data 492 493 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 494 """ 495 Deletes a Connect failure log entry. 496 Deletes the Connect failure log information for the specified entry. 497 This method makes a synchronous HTTP request by default. To make an 498 asynchronous HTTP request, please define a `callback` function 499 to be invoked when receiving the response. 500 >>> def callback_function(response): 501 >>> pprint(response) 502 >>> 503 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 504 505 :param callback function: The callback function 506 for asynchronous request. (optional) 507 :param str account_id: The external account number (int) or account ID Guid. (required) 508 :param str failure_id: The ID of the failed connect log entry. (required) 509 :return: ConnectDeleteFailureResult 510 If the method is called asynchronously, 511 returns the request thread. 512 """ 513 514 all_params = ['account_id', 'failure_id'] 515 all_params.append('callback') 516 all_params.append('_return_http_data_only') 517 all_params.append('_preload_content') 518 all_params.append('_request_timeout') 519 520 params = locals() 521 for key, val in iteritems(params['kwargs']): 522 if key not in all_params: 523 raise TypeError( 524 "Got an unexpected keyword argument '%s'" 525 " to method delete_event_failure_log" % key 526 ) 527 params[key] = val 528 del params['kwargs'] 529 # verify the required parameter 'account_id' is set 530 if ('account_id' not in params) or (params['account_id'] is None): 531 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 532 # verify the required parameter 'failure_id' is set 533 if ('failure_id' not in params) or (params['failure_id'] is None): 534 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 535 536 537 collection_formats = {} 538 539 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 540 path_params = {} 541 if 'account_id' in params: 542 path_params['accountId'] = params['account_id'] 543 if 'failure_id' in params: 544 path_params['failureId'] = params['failure_id'] 545 546 query_params = {} 547 548 header_params = {} 549 550 form_params = [] 551 local_var_files = {} 552 553 body_params = None 554 # HTTP header `Accept` 555 header_params['Accept'] = self.api_client.\ 556 select_header_accept(['application/json']) 557 558 # Authentication setting 559 auth_settings = [] 560 561 return self.api_client.call_api(resource_path, 'DELETE', 562 path_params, 563 query_params, 564 header_params, 565 body=body_params, 566 post_params=form_params, 567 files=local_var_files, 568 response_type='ConnectDeleteFailureResult', 569 auth_settings=auth_settings, 570 callback=params.get('callback'), 571 _return_http_data_only=params.get('_return_http_data_only'), 572 _preload_content=params.get('_preload_content', True), 573 _request_timeout=params.get('_request_timeout'), 574 collection_formats=collection_formats) 575 576 def delete_event_log(self, account_id, log_id, **kwargs): 577 """ 578 Deletes a specified Connect log entry. 579 Deletes a specified entry from the Connect Log. 580 This method makes a synchronous HTTP request by default. To make an 581 asynchronous HTTP request, please define a `callback` function 582 to be invoked when receiving the response. 583 >>> def callback_function(response): 584 >>> pprint(response) 585 >>> 586 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 587 588 :param callback function: The callback function 589 for asynchronous request. (optional) 590 :param str account_id: The external account number (int) or account ID Guid. (required) 591 :param str log_id: The ID of the connect log entry (required) 592 :return: None 593 If the method is called asynchronously, 594 returns the request thread. 595 """ 596 kwargs['_return_http_data_only'] = True 597 if kwargs.get('callback'): 598 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 599 else: 600 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 601 return data 602 603 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 604 """ 605 Deletes a specified Connect log entry. 606 Deletes a specified entry from the Connect Log. 607 This method makes a synchronous HTTP request by default. To make an 608 asynchronous HTTP request, please define a `callback` function 609 to be invoked when receiving the response. 610 >>> def callback_function(response): 611 >>> pprint(response) 612 >>> 613 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 614 615 :param callback function: The callback function 616 for asynchronous request. (optional) 617 :param str account_id: The external account number (int) or account ID Guid. (required) 618 :param str log_id: The ID of the connect log entry (required) 619 :return: None 620 If the method is called asynchronously, 621 returns the request thread. 622 """ 623 624 all_params = ['account_id', 'log_id'] 625 all_params.append('callback') 626 all_params.append('_return_http_data_only') 627 all_params.append('_preload_content') 628 all_params.append('_request_timeout') 629 630 params = locals() 631 for key, val in iteritems(params['kwargs']): 632 if key not in all_params: 633 raise TypeError( 634 "Got an unexpected keyword argument '%s'" 635 " to method delete_event_log" % key 636 ) 637 params[key] = val 638 del params['kwargs'] 639 # verify the required parameter 'account_id' is set 640 if ('account_id' not in params) or (params['account_id'] is None): 641 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 642 # verify the required parameter 'log_id' is set 643 if ('log_id' not in params) or (params['log_id'] is None): 644 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 645 646 647 collection_formats = {} 648 649 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 650 path_params = {} 651 if 'account_id' in params: 652 path_params['accountId'] = params['account_id'] 653 if 'log_id' in params: 654 path_params['logId'] = params['log_id'] 655 656 query_params = {} 657 658 header_params = {} 659 660 form_params = [] 661 local_var_files = {} 662 663 body_params = None 664 # HTTP header `Accept` 665 header_params['Accept'] = self.api_client.\ 666 select_header_accept(['application/json']) 667 668 # Authentication setting 669 auth_settings = [] 670 671 return self.api_client.call_api(resource_path, 'DELETE', 672 path_params, 673 query_params, 674 header_params, 675 body=body_params, 676 post_params=form_params, 677 files=local_var_files, 678 response_type=None, 679 auth_settings=auth_settings, 680 callback=params.get('callback'), 681 _return_http_data_only=params.get('_return_http_data_only'), 682 _preload_content=params.get('_preload_content', True), 683 _request_timeout=params.get('_request_timeout'), 684 collection_formats=collection_formats) 685 686 def delete_event_logs(self, account_id, **kwargs): 687 """ 688 Gets a list of Connect log entries. 689 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. 690 This method makes a synchronous HTTP request by default. To make an 691 asynchronous HTTP request, please define a `callback` function 692 to be invoked when receiving the response. 693 >>> def callback_function(response): 694 >>> pprint(response) 695 >>> 696 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 697 698 :param callback function: The callback function 699 for asynchronous request. (optional) 700 :param str account_id: The external account number (int) or account ID Guid. (required) 701 :return: None 702 If the method is called asynchronously, 703 returns the request thread. 704 """ 705 kwargs['_return_http_data_only'] = True 706 if kwargs.get('callback'): 707 return self.delete_event_logs_with_http_info(account_id, **kwargs) 708 else: 709 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 710 return data 711 712 def delete_event_logs_with_http_info(self, account_id, **kwargs): 713 """ 714 Gets a list of Connect log entries. 715 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. 716 This method makes a synchronous HTTP request by default. To make an 717 asynchronous HTTP request, please define a `callback` function 718 to be invoked when receiving the response. 719 >>> def callback_function(response): 720 >>> pprint(response) 721 >>> 722 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 723 724 :param callback function: The callback function 725 for asynchronous request. (optional) 726 :param str account_id: The external account number (int) or account ID Guid. (required) 727 :return: None 728 If the method is called asynchronously, 729 returns the request thread. 730 """ 731 732 all_params = ['account_id'] 733 all_params.append('callback') 734 all_params.append('_return_http_data_only') 735 all_params.append('_preload_content') 736 all_params.append('_request_timeout') 737 738 params = locals() 739 for key, val in iteritems(params['kwargs']): 740 if key not in all_params: 741 raise TypeError( 742 "Got an unexpected keyword argument '%s'" 743 " to method delete_event_logs" % key 744 ) 745 params[key] = val 746 del params['kwargs'] 747 # verify the required parameter 'account_id' is set 748 if ('account_id' not in params) or (params['account_id'] is None): 749 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 750 751 752 collection_formats = {} 753 754 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 755 path_params = {} 756 if 'account_id' in params: 757 path_params['accountId'] = params['account_id'] 758 759 query_params = {} 760 761 header_params = {} 762 763 form_params = [] 764 local_var_files = {} 765 766 body_params = None 767 # HTTP header `Accept` 768 header_params['Accept'] = self.api_client.\ 769 select_header_accept(['application/json']) 770 771 # Authentication setting 772 auth_settings = [] 773 774 return self.api_client.call_api(resource_path, 'DELETE', 775 path_params, 776 query_params, 777 header_params, 778 body=body_params, 779 post_params=form_params, 780 files=local_var_files, 781 response_type=None, 782 auth_settings=auth_settings, 783 callback=params.get('callback'), 784 _return_http_data_only=params.get('_return_http_data_only'), 785 _preload_content=params.get('_preload_content', True), 786 _request_timeout=params.get('_request_timeout'), 787 collection_formats=collection_formats) 788 789 def delete_mobile_notifiers(self, account_id, **kwargs): 790 """ 791 Reserved 792 Reserved: 793 This method makes a synchronous HTTP request by default. To make an 794 asynchronous HTTP request, please define a `callback` function 795 to be invoked when receiving the response. 796 >>> def callback_function(response): 797 >>> pprint(response) 798 >>> 799 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 800 801 :param callback function: The callback function 802 for asynchronous request. (optional) 803 :param str account_id: The external account number (int) or account ID Guid. (required) 804 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 805 :return: MobileNotifierConfigurationInformation 806 If the method is called asynchronously, 807 returns the request thread. 808 """ 809 kwargs['_return_http_data_only'] = True 810 if kwargs.get('callback'): 811 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 812 else: 813 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 814 return data 815 816 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 817 """ 818 Reserved 819 Reserved: 820 This method makes a synchronous HTTP request by default. To make an 821 asynchronous HTTP request, please define a `callback` function 822 to be invoked when receiving the response. 823 >>> def callback_function(response): 824 >>> pprint(response) 825 >>> 826 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 827 828 :param callback function: The callback function 829 for asynchronous request. (optional) 830 :param str account_id: The external account number (int) or account ID Guid. (required) 831 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 832 :return: MobileNotifierConfigurationInformation 833 If the method is called asynchronously, 834 returns the request thread. 835 """ 836 837 all_params = ['account_id', 'mobile_notifier_configuration_information'] 838 all_params.append('callback') 839 all_params.append('_return_http_data_only') 840 all_params.append('_preload_content') 841 all_params.append('_request_timeout') 842 843 params = locals() 844 for key, val in iteritems(params['kwargs']): 845 if key not in all_params: 846 raise TypeError( 847 "Got an unexpected keyword argument '%s'" 848 " to method delete_mobile_notifiers" % key 849 ) 850 params[key] = val 851 del params['kwargs'] 852 # verify the required parameter 'account_id' is set 853 if ('account_id' not in params) or (params['account_id'] is None): 854 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 855 856 857 collection_formats = {} 858 859 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 860 path_params = {} 861 if 'account_id' in params: 862 path_params['accountId'] = params['account_id'] 863 864 query_params = {} 865 866 header_params = {} 867 868 form_params = [] 869 local_var_files = {} 870 871 body_params = None 872 if 'mobile_notifier_configuration_information' in params: 873 body_params = params['mobile_notifier_configuration_information'] 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='MobileNotifierConfigurationInformation', 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 get_configuration(self, account_id, connect_id, **kwargs): 897 """ 898 Get a Connect Configuration Information 899 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 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.get_configuration(account_id, connect_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 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 912 :return: ConnectConfigResults 913 If the method is called asynchronously, 914 returns the request thread. 915 """ 916 kwargs['_return_http_data_only'] = True 917 if kwargs.get('callback'): 918 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 919 else: 920 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 921 return data 922 923 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 924 """ 925 Get a Connect Configuration Information 926 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 927 This method makes a synchronous HTTP request by default. To make an 928 asynchronous HTTP request, please define a `callback` function 929 to be invoked when receiving the response. 930 >>> def callback_function(response): 931 >>> pprint(response) 932 >>> 933 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 934 935 :param callback function: The callback function 936 for asynchronous request. (optional) 937 :param str account_id: The external account number (int) or account ID Guid. (required) 938 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 939 :return: ConnectConfigResults 940 If the method is called asynchronously, 941 returns the request thread. 942 """ 943 944 all_params = ['account_id', 'connect_id'] 945 all_params.append('callback') 946 all_params.append('_return_http_data_only') 947 all_params.append('_preload_content') 948 all_params.append('_request_timeout') 949 950 params = locals() 951 for key, val in iteritems(params['kwargs']): 952 if key not in all_params: 953 raise TypeError( 954 "Got an unexpected keyword argument '%s'" 955 " to method get_configuration" % key 956 ) 957 params[key] = val 958 del params['kwargs'] 959 # verify the required parameter 'account_id' is set 960 if ('account_id' not in params) or (params['account_id'] is None): 961 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 962 # verify the required parameter 'connect_id' is set 963 if ('connect_id' not in params) or (params['connect_id'] is None): 964 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 965 966 967 collection_formats = {} 968 969 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 970 path_params = {} 971 if 'account_id' in params: 972 path_params['accountId'] = params['account_id'] 973 if 'connect_id' in params: 974 path_params['connectId'] = params['connect_id'] 975 976 query_params = {} 977 978 header_params = {} 979 980 form_params = [] 981 local_var_files = {} 982 983 body_params = None 984 # HTTP header `Accept` 985 header_params['Accept'] = self.api_client.\ 986 select_header_accept(['application/json']) 987 988 # Authentication setting 989 auth_settings = [] 990 991 return self.api_client.call_api(resource_path, 'GET', 992 path_params, 993 query_params, 994 header_params, 995 body=body_params, 996 post_params=form_params, 997 files=local_var_files, 998 response_type='ConnectConfigResults', 999 auth_settings=auth_settings, 1000 callback=params.get('callback'), 1001 _return_http_data_only=params.get('_return_http_data_only'), 1002 _preload_content=params.get('_preload_content', True), 1003 _request_timeout=params.get('_request_timeout'), 1004 collection_formats=collection_formats) 1005 1006 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1007 """ 1008 Returns all users from the configured Connect service. 1009 1010 This method makes a synchronous HTTP request by default. To make an 1011 asynchronous HTTP request, please define a `callback` function 1012 to be invoked when receiving the response. 1013 >>> def callback_function(response): 1014 >>> pprint(response) 1015 >>> 1016 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1017 1018 :param callback function: The callback function 1019 for asynchronous request. (optional) 1020 :param str account_id: The external account number (int) or account ID Guid. (required) 1021 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1022 :param str count: 1023 :param str domain_users_only: 1024 :param str email_substring: 1025 :param str start_position: 1026 :param str status: 1027 :param str user_name_substring: 1028 :return: IntegratedConnectUserInfoList 1029 If the method is called asynchronously, 1030 returns the request thread. 1031 """ 1032 kwargs['_return_http_data_only'] = True 1033 if kwargs.get('callback'): 1034 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1035 else: 1036 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1037 return data 1038 1039 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1040 """ 1041 Returns all users from the configured Connect service. 1042 1043 This method makes a synchronous HTTP request by default. To make an 1044 asynchronous HTTP request, please define a `callback` function 1045 to be invoked when receiving the response. 1046 >>> def callback_function(response): 1047 >>> pprint(response) 1048 >>> 1049 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1050 1051 :param callback function: The callback function 1052 for asynchronous request. (optional) 1053 :param str account_id: The external account number (int) or account ID Guid. (required) 1054 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1055 :param str count: 1056 :param str domain_users_only: 1057 :param str email_substring: 1058 :param str start_position: 1059 :param str status: 1060 :param str user_name_substring: 1061 :return: IntegratedConnectUserInfoList 1062 If the method is called asynchronously, 1063 returns the request thread. 1064 """ 1065 1066 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1067 all_params.append('callback') 1068 all_params.append('_return_http_data_only') 1069 all_params.append('_preload_content') 1070 all_params.append('_request_timeout') 1071 1072 params = locals() 1073 for key, val in iteritems(params['kwargs']): 1074 if key not in all_params: 1075 raise TypeError( 1076 "Got an unexpected keyword argument '%s'" 1077 " to method get_connect_all_users" % key 1078 ) 1079 params[key] = val 1080 del params['kwargs'] 1081 # verify the required parameter 'account_id' is set 1082 if ('account_id' not in params) or (params['account_id'] is None): 1083 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1084 # verify the required parameter 'connect_id' is set 1085 if ('connect_id' not in params) or (params['connect_id'] is None): 1086 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1087 1088 1089 collection_formats = {} 1090 1091 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1092 path_params = {} 1093 if 'account_id' in params: 1094 path_params['accountId'] = params['account_id'] 1095 if 'connect_id' in params: 1096 path_params['connectId'] = params['connect_id'] 1097 1098 query_params = {} 1099 if 'count' in params: 1100 query_params['count'] = params['count'] 1101 if 'domain_users_only' in params: 1102 query_params['domain_users_only'] = params['domain_users_only'] 1103 if 'email_substring' in params: 1104 query_params['email_substring'] = params['email_substring'] 1105 if 'start_position' in params: 1106 query_params['start_position'] = params['start_position'] 1107 if 'status' in params: 1108 query_params['status'] = params['status'] 1109 if 'user_name_substring' in params: 1110 query_params['user_name_substring'] = params['user_name_substring'] 1111 1112 header_params = {} 1113 1114 form_params = [] 1115 local_var_files = {} 1116 1117 body_params = None 1118 # HTTP header `Accept` 1119 header_params['Accept'] = self.api_client.\ 1120 select_header_accept(['application/json']) 1121 1122 # Authentication setting 1123 auth_settings = [] 1124 1125 return self.api_client.call_api(resource_path, 'GET', 1126 path_params, 1127 query_params, 1128 header_params, 1129 body=body_params, 1130 post_params=form_params, 1131 files=local_var_files, 1132 response_type='IntegratedConnectUserInfoList', 1133 auth_settings=auth_settings, 1134 callback=params.get('callback'), 1135 _return_http_data_only=params.get('_return_http_data_only'), 1136 _preload_content=params.get('_preload_content', True), 1137 _request_timeout=params.get('_request_timeout'), 1138 collection_formats=collection_formats) 1139 1140 def get_connect_o_auth_config(self, account_id, **kwargs): 1141 """ 1142 Sets the Connect OAuth Config for the account. 1143 This method makes a synchronous HTTP request by default. To make an 1144 asynchronous HTTP request, please define a `callback` function 1145 to be invoked when receiving the response. 1146 >>> def callback_function(response): 1147 >>> pprint(response) 1148 >>> 1149 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1150 1151 :param callback function: The callback function 1152 for asynchronous request. (optional) 1153 :param str account_id: The external account number (int) or account ID Guid. (required) 1154 :return: ConnectOAuthConfig 1155 If the method is called asynchronously, 1156 returns the request thread. 1157 """ 1158 kwargs['_return_http_data_only'] = True 1159 if kwargs.get('callback'): 1160 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1161 else: 1162 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1163 return data 1164 1165 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1166 """ 1167 Sets the Connect OAuth Config for the account. 1168 This method makes a synchronous HTTP request by default. To make an 1169 asynchronous HTTP request, please define a `callback` function 1170 to be invoked when receiving the response. 1171 >>> def callback_function(response): 1172 >>> pprint(response) 1173 >>> 1174 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1175 1176 :param callback function: The callback function 1177 for asynchronous request. (optional) 1178 :param str account_id: The external account number (int) or account ID Guid. (required) 1179 :return: ConnectOAuthConfig 1180 If the method is called asynchronously, 1181 returns the request thread. 1182 """ 1183 1184 all_params = ['account_id'] 1185 all_params.append('callback') 1186 all_params.append('_return_http_data_only') 1187 all_params.append('_preload_content') 1188 all_params.append('_request_timeout') 1189 1190 params = locals() 1191 for key, val in iteritems(params['kwargs']): 1192 if key not in all_params: 1193 raise TypeError( 1194 "Got an unexpected keyword argument '%s'" 1195 " to method get_connect_o_auth_config" % key 1196 ) 1197 params[key] = val 1198 del params['kwargs'] 1199 # verify the required parameter 'account_id' is set 1200 if ('account_id' not in params) or (params['account_id'] is None): 1201 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1202 1203 1204 collection_formats = {} 1205 1206 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1207 path_params = {} 1208 if 'account_id' in params: 1209 path_params['accountId'] = params['account_id'] 1210 1211 query_params = {} 1212 1213 header_params = {} 1214 1215 form_params = [] 1216 local_var_files = {} 1217 1218 body_params = None 1219 # HTTP header `Accept` 1220 header_params['Accept'] = self.api_client.\ 1221 select_header_accept(['application/json']) 1222 1223 # Authentication setting 1224 auth_settings = [] 1225 1226 return self.api_client.call_api(resource_path, 'GET', 1227 path_params, 1228 query_params, 1229 header_params, 1230 body=body_params, 1231 post_params=form_params, 1232 files=local_var_files, 1233 response_type='ConnectOAuthConfig', 1234 auth_settings=auth_settings, 1235 callback=params.get('callback'), 1236 _return_http_data_only=params.get('_return_http_data_only'), 1237 _preload_content=params.get('_preload_content', True), 1238 _request_timeout=params.get('_request_timeout'), 1239 collection_formats=collection_formats) 1240 1241 def get_event_log(self, account_id, log_id, **kwargs): 1242 """ 1243 Get the specified Connect log entry. 1244 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. 1245 This method makes a synchronous HTTP request by default. To make an 1246 asynchronous HTTP request, please define a `callback` function 1247 to be invoked when receiving the response. 1248 >>> def callback_function(response): 1249 >>> pprint(response) 1250 >>> 1251 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1252 1253 :param callback function: The callback function 1254 for asynchronous request. (optional) 1255 :param str account_id: The external account number (int) or account ID Guid. (required) 1256 :param str log_id: The ID of the connect log entry (required) 1257 :param str additional_info: When true, the connectDebugLog information is included in the response. 1258 :return: ConnectLog 1259 If the method is called asynchronously, 1260 returns the request thread. 1261 """ 1262 kwargs['_return_http_data_only'] = True 1263 if kwargs.get('callback'): 1264 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1265 else: 1266 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1267 return data 1268 1269 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1270 """ 1271 Get the specified Connect log entry. 1272 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. 1273 This method makes a synchronous HTTP request by default. To make an 1274 asynchronous HTTP request, please define a `callback` function 1275 to be invoked when receiving the response. 1276 >>> def callback_function(response): 1277 >>> pprint(response) 1278 >>> 1279 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1280 1281 :param callback function: The callback function 1282 for asynchronous request. (optional) 1283 :param str account_id: The external account number (int) or account ID Guid. (required) 1284 :param str log_id: The ID of the connect log entry (required) 1285 :param str additional_info: When true, the connectDebugLog information is included in the response. 1286 :return: ConnectLog 1287 If the method is called asynchronously, 1288 returns the request thread. 1289 """ 1290 1291 all_params = ['account_id', 'log_id', 'additional_info'] 1292 all_params.append('callback') 1293 all_params.append('_return_http_data_only') 1294 all_params.append('_preload_content') 1295 all_params.append('_request_timeout') 1296 1297 params = locals() 1298 for key, val in iteritems(params['kwargs']): 1299 if key not in all_params: 1300 raise TypeError( 1301 "Got an unexpected keyword argument '%s'" 1302 " to method get_event_log" % key 1303 ) 1304 params[key] = val 1305 del params['kwargs'] 1306 # verify the required parameter 'account_id' is set 1307 if ('account_id' not in params) or (params['account_id'] is None): 1308 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1309 # verify the required parameter 'log_id' is set 1310 if ('log_id' not in params) or (params['log_id'] is None): 1311 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1312 1313 1314 collection_formats = {} 1315 1316 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1317 path_params = {} 1318 if 'account_id' in params: 1319 path_params['accountId'] = params['account_id'] 1320 if 'log_id' in params: 1321 path_params['logId'] = params['log_id'] 1322 1323 query_params = {} 1324 if 'additional_info' in params: 1325 query_params['additional_info'] = params['additional_info'] 1326 1327 header_params = {} 1328 1329 form_params = [] 1330 local_var_files = {} 1331 1332 body_params = None 1333 # HTTP header `Accept` 1334 header_params['Accept'] = self.api_client.\ 1335 select_header_accept(['application/json']) 1336 1337 # Authentication setting 1338 auth_settings = [] 1339 1340 return self.api_client.call_api(resource_path, 'GET', 1341 path_params, 1342 query_params, 1343 header_params, 1344 body=body_params, 1345 post_params=form_params, 1346 files=local_var_files, 1347 response_type='ConnectLog', 1348 auth_settings=auth_settings, 1349 callback=params.get('callback'), 1350 _return_http_data_only=params.get('_return_http_data_only'), 1351 _preload_content=params.get('_preload_content', True), 1352 _request_timeout=params.get('_request_timeout'), 1353 collection_formats=collection_formats) 1354 1355 def list_configurations(self, account_id, **kwargs): 1356 """ 1357 Get Connect Configuration Information 1358 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. 1359 This method makes a synchronous HTTP request by default. To make an 1360 asynchronous HTTP request, please define a `callback` function 1361 to be invoked when receiving the response. 1362 >>> def callback_function(response): 1363 >>> pprint(response) 1364 >>> 1365 >>> thread = api.list_configurations(account_id, callback=callback_function) 1366 1367 :param callback function: The callback function 1368 for asynchronous request. (optional) 1369 :param str account_id: The external account number (int) or account ID Guid. (required) 1370 :return: ConnectConfigResults 1371 If the method is called asynchronously, 1372 returns the request thread. 1373 """ 1374 kwargs['_return_http_data_only'] = True 1375 if kwargs.get('callback'): 1376 return self.list_configurations_with_http_info(account_id, **kwargs) 1377 else: 1378 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1379 return data 1380 1381 def list_configurations_with_http_info(self, account_id, **kwargs): 1382 """ 1383 Get Connect Configuration Information 1384 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. 1385 This method makes a synchronous HTTP request by default. To make an 1386 asynchronous HTTP request, please define a `callback` function 1387 to be invoked when receiving the response. 1388 >>> def callback_function(response): 1389 >>> pprint(response) 1390 >>> 1391 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1392 1393 :param callback function: The callback function 1394 for asynchronous request. (optional) 1395 :param str account_id: The external account number (int) or account ID Guid. (required) 1396 :return: ConnectConfigResults 1397 If the method is called asynchronously, 1398 returns the request thread. 1399 """ 1400 1401 all_params = ['account_id'] 1402 all_params.append('callback') 1403 all_params.append('_return_http_data_only') 1404 all_params.append('_preload_content') 1405 all_params.append('_request_timeout') 1406 1407 params = locals() 1408 for key, val in iteritems(params['kwargs']): 1409 if key not in all_params: 1410 raise TypeError( 1411 "Got an unexpected keyword argument '%s'" 1412 " to method list_configurations" % key 1413 ) 1414 params[key] = val 1415 del params['kwargs'] 1416 # verify the required parameter 'account_id' is set 1417 if ('account_id' not in params) or (params['account_id'] is None): 1418 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1419 1420 1421 collection_formats = {} 1422 1423 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1424 path_params = {} 1425 if 'account_id' in params: 1426 path_params['accountId'] = params['account_id'] 1427 1428 query_params = {} 1429 1430 header_params = {} 1431 1432 form_params = [] 1433 local_var_files = {} 1434 1435 body_params = None 1436 # HTTP header `Accept` 1437 header_params['Accept'] = self.api_client.\ 1438 select_header_accept(['application/json']) 1439 1440 # Authentication setting 1441 auth_settings = [] 1442 1443 return self.api_client.call_api(resource_path, 'GET', 1444 path_params, 1445 query_params, 1446 header_params, 1447 body=body_params, 1448 post_params=form_params, 1449 files=local_var_files, 1450 response_type='ConnectConfigResults', 1451 auth_settings=auth_settings, 1452 callback=params.get('callback'), 1453 _return_http_data_only=params.get('_return_http_data_only'), 1454 _preload_content=params.get('_preload_content', True), 1455 _request_timeout=params.get('_request_timeout'), 1456 collection_formats=collection_formats) 1457 1458 def list_event_failure_logs(self, account_id, **kwargs): 1459 """ 1460 Gets the Connect failure log information. 1461 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1462 This method makes a synchronous HTTP request by default. To make an 1463 asynchronous HTTP request, please define a `callback` function 1464 to be invoked when receiving the response. 1465 >>> def callback_function(response): 1466 >>> pprint(response) 1467 >>> 1468 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1469 1470 :param callback function: The callback function 1471 for asynchronous request. (optional) 1472 :param str account_id: The external account number (int) or account ID Guid. (required) 1473 :param str from_date: 1474 :param str to_date: 1475 :return: ConnectLogs 1476 If the method is called asynchronously, 1477 returns the request thread. 1478 """ 1479 kwargs['_return_http_data_only'] = True 1480 if kwargs.get('callback'): 1481 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1482 else: 1483 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1484 return data 1485 1486 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1487 """ 1488 Gets the Connect failure log information. 1489 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1490 This method makes a synchronous HTTP request by default. To make an 1491 asynchronous HTTP request, please define a `callback` function 1492 to be invoked when receiving the response. 1493 >>> def callback_function(response): 1494 >>> pprint(response) 1495 >>> 1496 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1497 1498 :param callback function: The callback function 1499 for asynchronous request. (optional) 1500 :param str account_id: The external account number (int) or account ID Guid. (required) 1501 :param str from_date: 1502 :param str to_date: 1503 :return: ConnectLogs 1504 If the method is called asynchronously, 1505 returns the request thread. 1506 """ 1507 1508 all_params = ['account_id', 'from_date', 'to_date'] 1509 all_params.append('callback') 1510 all_params.append('_return_http_data_only') 1511 all_params.append('_preload_content') 1512 all_params.append('_request_timeout') 1513 1514 params = locals() 1515 for key, val in iteritems(params['kwargs']): 1516 if key not in all_params: 1517 raise TypeError( 1518 "Got an unexpected keyword argument '%s'" 1519 " to method list_event_failure_logs" % key 1520 ) 1521 params[key] = val 1522 del params['kwargs'] 1523 # verify the required parameter 'account_id' is set 1524 if ('account_id' not in params) or (params['account_id'] is None): 1525 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1526 1527 1528 collection_formats = {} 1529 1530 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1531 path_params = {} 1532 if 'account_id' in params: 1533 path_params['accountId'] = params['account_id'] 1534 1535 query_params = {} 1536 if 'from_date' in params: 1537 query_params['from_date'] = params['from_date'] 1538 if 'to_date' in params: 1539 query_params['to_date'] = params['to_date'] 1540 1541 header_params = {} 1542 1543 form_params = [] 1544 local_var_files = {} 1545 1546 body_params = None 1547 # HTTP header `Accept` 1548 header_params['Accept'] = self.api_client.\ 1549 select_header_accept(['application/json']) 1550 1551 # Authentication setting 1552 auth_settings = [] 1553 1554 return self.api_client.call_api(resource_path, 'GET', 1555 path_params, 1556 query_params, 1557 header_params, 1558 body=body_params, 1559 post_params=form_params, 1560 files=local_var_files, 1561 response_type='ConnectLogs', 1562 auth_settings=auth_settings, 1563 callback=params.get('callback'), 1564 _return_http_data_only=params.get('_return_http_data_only'), 1565 _preload_content=params.get('_preload_content', True), 1566 _request_timeout=params.get('_request_timeout'), 1567 collection_formats=collection_formats) 1568 1569 def list_event_logs(self, account_id, **kwargs): 1570 """ 1571 Gets the Connect log. 1572 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. 1573 This method makes a synchronous HTTP request by default. To make an 1574 asynchronous HTTP request, please define a `callback` function 1575 to be invoked when receiving the response. 1576 >>> def callback_function(response): 1577 >>> pprint(response) 1578 >>> 1579 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1580 1581 :param callback function: The callback function 1582 for asynchronous request. (optional) 1583 :param str account_id: The external account number (int) or account ID Guid. (required) 1584 :param str from_date: 1585 :param str to_date: 1586 :return: ConnectLogs 1587 If the method is called asynchronously, 1588 returns the request thread. 1589 """ 1590 kwargs['_return_http_data_only'] = True 1591 if kwargs.get('callback'): 1592 return self.list_event_logs_with_http_info(account_id, **kwargs) 1593 else: 1594 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1595 return data 1596 1597 def list_event_logs_with_http_info(self, account_id, **kwargs): 1598 """ 1599 Gets the Connect log. 1600 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. 1601 This method makes a synchronous HTTP request by default. To make an 1602 asynchronous HTTP request, please define a `callback` function 1603 to be invoked when receiving the response. 1604 >>> def callback_function(response): 1605 >>> pprint(response) 1606 >>> 1607 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1608 1609 :param callback function: The callback function 1610 for asynchronous request. (optional) 1611 :param str account_id: The external account number (int) or account ID Guid. (required) 1612 :param str from_date: 1613 :param str to_date: 1614 :return: ConnectLogs 1615 If the method is called asynchronously, 1616 returns the request thread. 1617 """ 1618 1619 all_params = ['account_id', 'from_date', 'to_date'] 1620 all_params.append('callback') 1621 all_params.append('_return_http_data_only') 1622 all_params.append('_preload_content') 1623 all_params.append('_request_timeout') 1624 1625 params = locals() 1626 for key, val in iteritems(params['kwargs']): 1627 if key not in all_params: 1628 raise TypeError( 1629 "Got an unexpected keyword argument '%s'" 1630 " to method list_event_logs" % key 1631 ) 1632 params[key] = val 1633 del params['kwargs'] 1634 # verify the required parameter 'account_id' is set 1635 if ('account_id' not in params) or (params['account_id'] is None): 1636 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1637 1638 1639 collection_formats = {} 1640 1641 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1642 path_params = {} 1643 if 'account_id' in params: 1644 path_params['accountId'] = params['account_id'] 1645 1646 query_params = {} 1647 if 'from_date' in params: 1648 query_params['from_date'] = params['from_date'] 1649 if 'to_date' in params: 1650 query_params['to_date'] = params['to_date'] 1651 1652 header_params = {} 1653 1654 form_params = [] 1655 local_var_files = {} 1656 1657 body_params = None 1658 # HTTP header `Accept` 1659 header_params['Accept'] = self.api_client.\ 1660 select_header_accept(['application/json']) 1661 1662 # Authentication setting 1663 auth_settings = [] 1664 1665 return self.api_client.call_api(resource_path, 'GET', 1666 path_params, 1667 query_params, 1668 header_params, 1669 body=body_params, 1670 post_params=form_params, 1671 files=local_var_files, 1672 response_type='ConnectLogs', 1673 auth_settings=auth_settings, 1674 callback=params.get('callback'), 1675 _return_http_data_only=params.get('_return_http_data_only'), 1676 _preload_content=params.get('_preload_content', True), 1677 _request_timeout=params.get('_request_timeout'), 1678 collection_formats=collection_formats) 1679 1680 def list_mobile_notifiers(self, account_id, **kwargs): 1681 """ 1682 Reserved 1683 Reserved: 1684 This method makes a synchronous HTTP request by default. To make an 1685 asynchronous HTTP request, please define a `callback` function 1686 to be invoked when receiving the response. 1687 >>> def callback_function(response): 1688 >>> pprint(response) 1689 >>> 1690 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 1691 1692 :param callback function: The callback function 1693 for asynchronous request. (optional) 1694 :param str account_id: The external account number (int) or account ID Guid. (required) 1695 :return: MobileNotifierConfigurationInformation 1696 If the method is called asynchronously, 1697 returns the request thread. 1698 """ 1699 kwargs['_return_http_data_only'] = True 1700 if kwargs.get('callback'): 1701 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1702 else: 1703 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1704 return data 1705 1706 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1707 """ 1708 Reserved 1709 Reserved: 1710 This method makes a synchronous HTTP request by default. To make an 1711 asynchronous HTTP request, please define a `callback` function 1712 to be invoked when receiving the response. 1713 >>> def callback_function(response): 1714 >>> pprint(response) 1715 >>> 1716 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1717 1718 :param callback function: The callback function 1719 for asynchronous request. (optional) 1720 :param str account_id: The external account number (int) or account ID Guid. (required) 1721 :return: MobileNotifierConfigurationInformation 1722 If the method is called asynchronously, 1723 returns the request thread. 1724 """ 1725 1726 all_params = ['account_id'] 1727 all_params.append('callback') 1728 all_params.append('_return_http_data_only') 1729 all_params.append('_preload_content') 1730 all_params.append('_request_timeout') 1731 1732 params = locals() 1733 for key, val in iteritems(params['kwargs']): 1734 if key not in all_params: 1735 raise TypeError( 1736 "Got an unexpected keyword argument '%s'" 1737 " to method list_mobile_notifiers" % key 1738 ) 1739 params[key] = val 1740 del params['kwargs'] 1741 # verify the required parameter 'account_id' is set 1742 if ('account_id' not in params) or (params['account_id'] is None): 1743 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 1744 1745 1746 collection_formats = {} 1747 1748 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1749 path_params = {} 1750 if 'account_id' in params: 1751 path_params['accountId'] = params['account_id'] 1752 1753 query_params = {} 1754 1755 header_params = {} 1756 1757 form_params = [] 1758 local_var_files = {} 1759 1760 body_params = None 1761 # HTTP header `Accept` 1762 header_params['Accept'] = self.api_client.\ 1763 select_header_accept(['application/json']) 1764 1765 # Authentication setting 1766 auth_settings = [] 1767 1768 return self.api_client.call_api(resource_path, 'GET', 1769 path_params, 1770 query_params, 1771 header_params, 1772 body=body_params, 1773 post_params=form_params, 1774 files=local_var_files, 1775 response_type='MobileNotifierConfigurationInformation', 1776 auth_settings=auth_settings, 1777 callback=params.get('callback'), 1778 _return_http_data_only=params.get('_return_http_data_only'), 1779 _preload_content=params.get('_preload_content', True), 1780 _request_timeout=params.get('_request_timeout'), 1781 collection_formats=collection_formats) 1782 1783 def list_users(self, account_id, connect_id, **kwargs): 1784 """ 1785 Returns users from the configured Connect service. 1786 Returns users from the configured Connect service. 1787 This method makes a synchronous HTTP request by default. To make an 1788 asynchronous HTTP request, please define a `callback` function 1789 to be invoked when receiving the response. 1790 >>> def callback_function(response): 1791 >>> pprint(response) 1792 >>> 1793 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 1794 1795 :param callback function: The callback function 1796 for asynchronous request. (optional) 1797 :param str account_id: The external account number (int) or account ID Guid. (required) 1798 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1799 :param str count: 1800 :param str email_substring: 1801 :param str list_included_users: 1802 :param str start_position: 1803 :param str status: 1804 :param str user_name_substring: 1805 :return: IntegratedUserInfoList 1806 If the method is called asynchronously, 1807 returns the request thread. 1808 """ 1809 kwargs['_return_http_data_only'] = True 1810 if kwargs.get('callback'): 1811 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 1812 else: 1813 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 1814 return data 1815 1816 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 1817 """ 1818 Returns users from the configured Connect service. 1819 Returns users from the configured Connect service. 1820 This method makes a synchronous HTTP request by default. To make an 1821 asynchronous HTTP request, please define a `callback` function 1822 to be invoked when receiving the response. 1823 >>> def callback_function(response): 1824 >>> pprint(response) 1825 >>> 1826 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 1827 1828 :param callback function: The callback function 1829 for asynchronous request. (optional) 1830 :param str account_id: The external account number (int) or account ID Guid. (required) 1831 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1832 :param str count: 1833 :param str email_substring: 1834 :param str list_included_users: 1835 :param str start_position: 1836 :param str status: 1837 :param str user_name_substring: 1838 :return: IntegratedUserInfoList 1839 If the method is called asynchronously, 1840 returns the request thread. 1841 """ 1842 1843 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 1844 all_params.append('callback') 1845 all_params.append('_return_http_data_only') 1846 all_params.append('_preload_content') 1847 all_params.append('_request_timeout') 1848 1849 params = locals() 1850 for key, val in iteritems(params['kwargs']): 1851 if key not in all_params: 1852 raise TypeError( 1853 "Got an unexpected keyword argument '%s'" 1854 " to method list_users" % key 1855 ) 1856 params[key] = val 1857 del params['kwargs'] 1858 # verify the required parameter 'account_id' is set 1859 if ('account_id' not in params) or (params['account_id'] is None): 1860 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 1861 # verify the required parameter 'connect_id' is set 1862 if ('connect_id' not in params) or (params['connect_id'] is None): 1863 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 1864 1865 1866 collection_formats = {} 1867 1868 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 1869 path_params = {} 1870 if 'account_id' in params: 1871 path_params['accountId'] = params['account_id'] 1872 if 'connect_id' in params: 1873 path_params['connectId'] = params['connect_id'] 1874 1875 query_params = {} 1876 if 'count' in params: 1877 query_params['count'] = params['count'] 1878 if 'email_substring' in params: 1879 query_params['email_substring'] = params['email_substring'] 1880 if 'list_included_users' in params: 1881 query_params['list_included_users'] = params['list_included_users'] 1882 if 'start_position' in params: 1883 query_params['start_position'] = params['start_position'] 1884 if 'status' in params: 1885 query_params['status'] = params['status'] 1886 if 'user_name_substring' in params: 1887 query_params['user_name_substring'] = params['user_name_substring'] 1888 1889 header_params = {} 1890 1891 form_params = [] 1892 local_var_files = {} 1893 1894 body_params = None 1895 # HTTP header `Accept` 1896 header_params['Accept'] = self.api_client.\ 1897 select_header_accept(['application/json']) 1898 1899 # Authentication setting 1900 auth_settings = [] 1901 1902 return self.api_client.call_api(resource_path, 'GET', 1903 path_params, 1904 query_params, 1905 header_params, 1906 body=body_params, 1907 post_params=form_params, 1908 files=local_var_files, 1909 response_type='IntegratedUserInfoList', 1910 auth_settings=auth_settings, 1911 callback=params.get('callback'), 1912 _return_http_data_only=params.get('_return_http_data_only'), 1913 _preload_content=params.get('_preload_content', True), 1914 _request_timeout=params.get('_request_timeout'), 1915 collection_formats=collection_formats) 1916 1917 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 1918 """ 1919 Republishes Connect information for the specified envelope. 1920 Republishes Connect information for the specified envelope. 1921 This method makes a synchronous HTTP request by default. To make an 1922 asynchronous HTTP request, please define a `callback` function 1923 to be invoked when receiving the response. 1924 >>> def callback_function(response): 1925 >>> pprint(response) 1926 >>> 1927 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 1928 1929 :param callback function: The callback function 1930 for asynchronous request. (optional) 1931 :param str account_id: The external account number (int) or account ID Guid. (required) 1932 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1933 :return: ConnectFailureResults 1934 If the method is called asynchronously, 1935 returns the request thread. 1936 """ 1937 kwargs['_return_http_data_only'] = True 1938 if kwargs.get('callback'): 1939 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1940 else: 1941 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1942 return data 1943 1944 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 1945 """ 1946 Republishes Connect information for the specified envelope. 1947 Republishes Connect information for the specified envelope. 1948 This method makes a synchronous HTTP request by default. To make an 1949 asynchronous HTTP request, please define a `callback` function 1950 to be invoked when receiving the response. 1951 >>> def callback_function(response): 1952 >>> pprint(response) 1953 >>> 1954 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 1955 1956 :param callback function: The callback function 1957 for asynchronous request. (optional) 1958 :param str account_id: The external account number (int) or account ID Guid. (required) 1959 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1960 :return: ConnectFailureResults 1961 If the method is called asynchronously, 1962 returns the request thread. 1963 """ 1964 1965 all_params = ['account_id', 'envelope_id'] 1966 all_params.append('callback') 1967 all_params.append('_return_http_data_only') 1968 all_params.append('_preload_content') 1969 all_params.append('_request_timeout') 1970 1971 params = locals() 1972 for key, val in iteritems(params['kwargs']): 1973 if key not in all_params: 1974 raise TypeError( 1975 "Got an unexpected keyword argument '%s'" 1976 " to method retry_event_for_envelope" % key 1977 ) 1978 params[key] = val 1979 del params['kwargs'] 1980 # verify the required parameter 'account_id' is set 1981 if ('account_id' not in params) or (params['account_id'] is None): 1982 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 1983 # verify the required parameter 'envelope_id' is set 1984 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1985 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 1986 1987 1988 collection_formats = {} 1989 1990 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 1991 path_params = {} 1992 if 'account_id' in params: 1993 path_params['accountId'] = params['account_id'] 1994 if 'envelope_id' in params: 1995 path_params['envelopeId'] = params['envelope_id'] 1996 1997 query_params = {} 1998 1999 header_params = {} 2000 2001 form_params = [] 2002 local_var_files = {} 2003 2004 body_params = None 2005 # HTTP header `Accept` 2006 header_params['Accept'] = self.api_client.\ 2007 select_header_accept(['application/json']) 2008 2009 # Authentication setting 2010 auth_settings = [] 2011 2012 return self.api_client.call_api(resource_path, 'PUT', 2013 path_params, 2014 query_params, 2015 header_params, 2016 body=body_params, 2017 post_params=form_params, 2018 files=local_var_files, 2019 response_type='ConnectFailureResults', 2020 auth_settings=auth_settings, 2021 callback=params.get('callback'), 2022 _return_http_data_only=params.get('_return_http_data_only'), 2023 _preload_content=params.get('_preload_content', True), 2024 _request_timeout=params.get('_request_timeout'), 2025 collection_formats=collection_formats) 2026 2027 def retry_event_for_envelopes(self, account_id, **kwargs): 2028 """ 2029 Republishes Connect information for multiple envelopes. 2030 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. 2031 This method makes a synchronous HTTP request by default. To make an 2032 asynchronous HTTP request, please define a `callback` function 2033 to be invoked when receiving the response. 2034 >>> def callback_function(response): 2035 >>> pprint(response) 2036 >>> 2037 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2038 2039 :param callback function: The callback function 2040 for asynchronous request. (optional) 2041 :param str account_id: The external account number (int) or account ID Guid. (required) 2042 :param ConnectFailureFilter connect_failure_filter: 2043 :return: ConnectFailureResults 2044 If the method is called asynchronously, 2045 returns the request thread. 2046 """ 2047 kwargs['_return_http_data_only'] = True 2048 if kwargs.get('callback'): 2049 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2050 else: 2051 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2052 return data 2053 2054 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2055 """ 2056 Republishes Connect information for multiple envelopes. 2057 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. 2058 This method makes a synchronous HTTP request by default. To make an 2059 asynchronous HTTP request, please define a `callback` function 2060 to be invoked when receiving the response. 2061 >>> def callback_function(response): 2062 >>> pprint(response) 2063 >>> 2064 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2065 2066 :param callback function: The callback function 2067 for asynchronous request. (optional) 2068 :param str account_id: The external account number (int) or account ID Guid. (required) 2069 :param ConnectFailureFilter connect_failure_filter: 2070 :return: ConnectFailureResults 2071 If the method is called asynchronously, 2072 returns the request thread. 2073 """ 2074 2075 all_params = ['account_id', 'connect_failure_filter'] 2076 all_params.append('callback') 2077 all_params.append('_return_http_data_only') 2078 all_params.append('_preload_content') 2079 all_params.append('_request_timeout') 2080 2081 params = locals() 2082 for key, val in iteritems(params['kwargs']): 2083 if key not in all_params: 2084 raise TypeError( 2085 "Got an unexpected keyword argument '%s'" 2086 " to method retry_event_for_envelopes" % key 2087 ) 2088 params[key] = val 2089 del params['kwargs'] 2090 # verify the required parameter 'account_id' is set 2091 if ('account_id' not in params) or (params['account_id'] is None): 2092 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2093 2094 2095 collection_formats = {} 2096 2097 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2098 path_params = {} 2099 if 'account_id' in params: 2100 path_params['accountId'] = params['account_id'] 2101 2102 query_params = {} 2103 2104 header_params = {} 2105 2106 form_params = [] 2107 local_var_files = {} 2108 2109 body_params = None 2110 if 'connect_failure_filter' in params: 2111 body_params = params['connect_failure_filter'] 2112 # HTTP header `Accept` 2113 header_params['Accept'] = self.api_client.\ 2114 select_header_accept(['application/json']) 2115 2116 # Authentication setting 2117 auth_settings = [] 2118 2119 return self.api_client.call_api(resource_path, 'PUT', 2120 path_params, 2121 query_params, 2122 header_params, 2123 body=body_params, 2124 post_params=form_params, 2125 files=local_var_files, 2126 response_type='ConnectFailureResults', 2127 auth_settings=auth_settings, 2128 callback=params.get('callback'), 2129 _return_http_data_only=params.get('_return_http_data_only'), 2130 _preload_content=params.get('_preload_content', True), 2131 _request_timeout=params.get('_request_timeout'), 2132 collection_formats=collection_formats) 2133 2134 def update_configuration(self, account_id, **kwargs): 2135 """ 2136 Updates a specified Connect configuration. 2137 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. 2138 This method makes a synchronous HTTP request by default. To make an 2139 asynchronous HTTP request, please define a `callback` function 2140 to be invoked when receiving the response. 2141 >>> def callback_function(response): 2142 >>> pprint(response) 2143 >>> 2144 >>> thread = api.update_configuration(account_id, callback=callback_function) 2145 2146 :param callback function: The callback function 2147 for asynchronous request. (optional) 2148 :param str account_id: The external account number (int) or account ID Guid. (required) 2149 :param ConnectCustomConfiguration connect_custom_configuration: 2150 :return: ConnectCustomConfiguration 2151 If the method is called asynchronously, 2152 returns the request thread. 2153 """ 2154 kwargs['_return_http_data_only'] = True 2155 if kwargs.get('callback'): 2156 return self.update_configuration_with_http_info(account_id, **kwargs) 2157 else: 2158 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2159 return data 2160 2161 def update_configuration_with_http_info(self, account_id, **kwargs): 2162 """ 2163 Updates a specified Connect configuration. 2164 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. 2165 This method makes a synchronous HTTP request by default. To make an 2166 asynchronous HTTP request, please define a `callback` function 2167 to be invoked when receiving the response. 2168 >>> def callback_function(response): 2169 >>> pprint(response) 2170 >>> 2171 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2172 2173 :param callback function: The callback function 2174 for asynchronous request. (optional) 2175 :param str account_id: The external account number (int) or account ID Guid. (required) 2176 :param ConnectCustomConfiguration connect_custom_configuration: 2177 :return: ConnectCustomConfiguration 2178 If the method is called asynchronously, 2179 returns the request thread. 2180 """ 2181 2182 all_params = ['account_id', 'connect_custom_configuration'] 2183 all_params.append('callback') 2184 all_params.append('_return_http_data_only') 2185 all_params.append('_preload_content') 2186 all_params.append('_request_timeout') 2187 2188 params = locals() 2189 for key, val in iteritems(params['kwargs']): 2190 if key not in all_params: 2191 raise TypeError( 2192 "Got an unexpected keyword argument '%s'" 2193 " to method update_configuration" % key 2194 ) 2195 params[key] = val 2196 del params['kwargs'] 2197 # verify the required parameter 'account_id' is set 2198 if ('account_id' not in params) or (params['account_id'] is None): 2199 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2200 2201 2202 collection_formats = {} 2203 2204 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2205 path_params = {} 2206 if 'account_id' in params: 2207 path_params['accountId'] = params['account_id'] 2208 2209 query_params = {} 2210 2211 header_params = {} 2212 2213 form_params = [] 2214 local_var_files = {} 2215 2216 body_params = None 2217 if 'connect_custom_configuration' in params: 2218 body_params = params['connect_custom_configuration'] 2219 # HTTP header `Accept` 2220 header_params['Accept'] = self.api_client.\ 2221 select_header_accept(['application/json']) 2222 2223 # Authentication setting 2224 auth_settings = [] 2225 2226 return self.api_client.call_api(resource_path, 'PUT', 2227 path_params, 2228 query_params, 2229 header_params, 2230 body=body_params, 2231 post_params=form_params, 2232 files=local_var_files, 2233 response_type='ConnectCustomConfiguration', 2234 auth_settings=auth_settings, 2235 callback=params.get('callback'), 2236 _return_http_data_only=params.get('_return_http_data_only'), 2237 _preload_content=params.get('_preload_content', True), 2238 _request_timeout=params.get('_request_timeout'), 2239 collection_formats=collection_formats) 2240 2241 def update_connect_o_auth_config(self, account_id, **kwargs): 2242 """ 2243 Updates the existing Connect OAuth Config for the account. 2244 This method makes a synchronous HTTP request by default. To make an 2245 asynchronous HTTP request, please define a `callback` function 2246 to be invoked when receiving the response. 2247 >>> def callback_function(response): 2248 >>> pprint(response) 2249 >>> 2250 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2251 2252 :param callback function: The callback function 2253 for asynchronous request. (optional) 2254 :param str account_id: The external account number (int) or account ID Guid. (required) 2255 :param ConnectOAuthConfig connect_o_auth_config: 2256 :return: ConnectOAuthConfig 2257 If the method is called asynchronously, 2258 returns the request thread. 2259 """ 2260 kwargs['_return_http_data_only'] = True 2261 if kwargs.get('callback'): 2262 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2263 else: 2264 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2265 return data 2266 2267 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2268 """ 2269 Updates the existing Connect OAuth Config for the account. 2270 This method makes a synchronous HTTP request by default. To make an 2271 asynchronous HTTP request, please define a `callback` function 2272 to be invoked when receiving the response. 2273 >>> def callback_function(response): 2274 >>> pprint(response) 2275 >>> 2276 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2277 2278 :param callback function: The callback function 2279 for asynchronous request. (optional) 2280 :param str account_id: The external account number (int) or account ID Guid. (required) 2281 :param ConnectOAuthConfig connect_o_auth_config: 2282 :return: ConnectOAuthConfig 2283 If the method is called asynchronously, 2284 returns the request thread. 2285 """ 2286 2287 all_params = ['account_id', 'connect_o_auth_config'] 2288 all_params.append('callback') 2289 all_params.append('_return_http_data_only') 2290 all_params.append('_preload_content') 2291 all_params.append('_request_timeout') 2292 2293 params = locals() 2294 for key, val in iteritems(params['kwargs']): 2295 if key not in all_params: 2296 raise TypeError( 2297 "Got an unexpected keyword argument '%s'" 2298 " to method update_connect_o_auth_config" % key 2299 ) 2300 params[key] = val 2301 del params['kwargs'] 2302 # verify the required parameter 'account_id' is set 2303 if ('account_id' not in params) or (params['account_id'] is None): 2304 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2305 2306 2307 collection_formats = {} 2308 2309 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2310 path_params = {} 2311 if 'account_id' in params: 2312 path_params['accountId'] = params['account_id'] 2313 2314 query_params = {} 2315 2316 header_params = {} 2317 2318 form_params = [] 2319 local_var_files = {} 2320 2321 body_params = None 2322 if 'connect_o_auth_config' in params: 2323 body_params = params['connect_o_auth_config'] 2324 # HTTP header `Accept` 2325 header_params['Accept'] = self.api_client.\ 2326 select_header_accept(['application/json']) 2327 2328 # Authentication setting 2329 auth_settings = [] 2330 2331 return self.api_client.call_api(resource_path, 'PUT', 2332 path_params, 2333 query_params, 2334 header_params, 2335 body=body_params, 2336 post_params=form_params, 2337 files=local_var_files, 2338 response_type='ConnectOAuthConfig', 2339 auth_settings=auth_settings, 2340 callback=params.get('callback'), 2341 _return_http_data_only=params.get('_return_http_data_only'), 2342 _preload_content=params.get('_preload_content', True), 2343 _request_timeout=params.get('_request_timeout'), 2344 collection_formats=collection_formats) 2345 2346 def update_mobile_notifiers(self, account_id, **kwargs): 2347 """ 2348 Reserved 2349 Reserved: 2350 This method makes a synchronous HTTP request by default. To make an 2351 asynchronous HTTP request, please define a `callback` function 2352 to be invoked when receiving the response. 2353 >>> def callback_function(response): 2354 >>> pprint(response) 2355 >>> 2356 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2357 2358 :param callback function: The callback function 2359 for asynchronous request. (optional) 2360 :param str account_id: The external account number (int) or account ID Guid. (required) 2361 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2362 :return: MobileNotifierConfigurationInformation 2363 If the method is called asynchronously, 2364 returns the request thread. 2365 """ 2366 kwargs['_return_http_data_only'] = True 2367 if kwargs.get('callback'): 2368 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2369 else: 2370 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2371 return data 2372 2373 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2374 """ 2375 Reserved 2376 Reserved: 2377 This method makes a synchronous HTTP request by default. To make an 2378 asynchronous HTTP request, please define a `callback` function 2379 to be invoked when receiving the response. 2380 >>> def callback_function(response): 2381 >>> pprint(response) 2382 >>> 2383 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2384 2385 :param callback function: The callback function 2386 for asynchronous request. (optional) 2387 :param str account_id: The external account number (int) or account ID Guid. (required) 2388 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2389 :return: MobileNotifierConfigurationInformation 2390 If the method is called asynchronously, 2391 returns the request thread. 2392 """ 2393 2394 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2395 all_params.append('callback') 2396 all_params.append('_return_http_data_only') 2397 all_params.append('_preload_content') 2398 all_params.append('_request_timeout') 2399 2400 params = locals() 2401 for key, val in iteritems(params['kwargs']): 2402 if key not in all_params: 2403 raise TypeError( 2404 "Got an unexpected keyword argument '%s'" 2405 " to method update_mobile_notifiers" % key 2406 ) 2407 params[key] = val 2408 del params['kwargs'] 2409 # verify the required parameter 'account_id' is set 2410 if ('account_id' not in params) or (params['account_id'] is None): 2411 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2412 2413 2414 collection_formats = {} 2415 2416 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2417 path_params = {} 2418 if 'account_id' in params: 2419 path_params['accountId'] = params['account_id'] 2420 2421 query_params = {} 2422 2423 header_params = {} 2424 2425 form_params = [] 2426 local_var_files = {} 2427 2428 body_params = None 2429 if 'mobile_notifier_configuration_information' in params: 2430 body_params = params['mobile_notifier_configuration_information'] 2431 # HTTP header `Accept` 2432 header_params['Accept'] = self.api_client.\ 2433 select_header_accept(['application/json']) 2434 2435 # Authentication setting 2436 auth_settings = [] 2437 2438 return self.api_client.call_api(resource_path, 'PUT', 2439 path_params, 2440 query_params, 2441 header_params, 2442 body=body_params, 2443 post_params=form_params, 2444 files=local_var_files, 2445 response_type='MobileNotifierConfigurationInformation', 2446 auth_settings=auth_settings, 2447 callback=params.get('callback'), 2448 _return_http_data_only=params.get('_return_http_data_only'), 2449 _preload_content=params.get('_preload_content', True), 2450 _request_timeout=params.get('_request_timeout'), 2451 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 delete_configuration(self, account_id, connect_id, **kwargs): 257 """ 258 Deletes the specified connect configuration. 259 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 260 This method makes a synchronous HTTP request by default. To make an 261 asynchronous HTTP request, please define a `callback` function 262 to be invoked when receiving the response. 263 >>> def callback_function(response): 264 >>> pprint(response) 265 >>> 266 >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function) 267 268 :param callback function: The callback function 269 for asynchronous request. (optional) 270 :param str account_id: The external account number (int) or account ID Guid. (required) 271 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 272 :return: None 273 If the method is called asynchronously, 274 returns the request thread. 275 """ 276 kwargs['_return_http_data_only'] = True 277 if kwargs.get('callback'): 278 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 279 else: 280 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 281 return data 282 283 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 284 """ 285 Deletes the specified connect configuration. 286 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 287 This method makes a synchronous HTTP request by default. To make an 288 asynchronous HTTP request, please define a `callback` function 289 to be invoked when receiving the response. 290 >>> def callback_function(response): 291 >>> pprint(response) 292 >>> 293 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 294 295 :param callback function: The callback function 296 for asynchronous request. (optional) 297 :param str account_id: The external account number (int) or account ID Guid. (required) 298 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 299 :return: None 300 If the method is called asynchronously, 301 returns the request thread. 302 """ 303 304 all_params = ['account_id', 'connect_id'] 305 all_params.append('callback') 306 all_params.append('_return_http_data_only') 307 all_params.append('_preload_content') 308 all_params.append('_request_timeout') 309 310 params = locals() 311 for key, val in iteritems(params['kwargs']): 312 if key not in all_params: 313 raise TypeError( 314 "Got an unexpected keyword argument '%s'" 315 " to method delete_configuration" % key 316 ) 317 params[key] = val 318 del params['kwargs'] 319 # verify the required parameter 'account_id' is set 320 if ('account_id' not in params) or (params['account_id'] is None): 321 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 322 # verify the required parameter 'connect_id' is set 323 if ('connect_id' not in params) or (params['connect_id'] is None): 324 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 if 'connect_id' in params: 334 path_params['connectId'] = params['connect_id'] 335 336 query_params = {} 337 338 header_params = {} 339 340 form_params = [] 341 local_var_files = {} 342 343 body_params = None 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'DELETE', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type=None, 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 collection_formats=collection_formats) 365 366 def delete_connect_o_auth_config(self, account_id, **kwargs): 367 """ 368 Sets the Connect OAuth Config for the account. 369 This method makes a synchronous HTTP request by default. To make an 370 asynchronous HTTP request, please define a `callback` function 371 to be invoked when receiving the response. 372 >>> def callback_function(response): 373 >>> pprint(response) 374 >>> 375 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 376 377 :param callback function: The callback function 378 for asynchronous request. (optional) 379 :param str account_id: The external account number (int) or account ID Guid. (required) 380 :return: None 381 If the method is called asynchronously, 382 returns the request thread. 383 """ 384 kwargs['_return_http_data_only'] = True 385 if kwargs.get('callback'): 386 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 387 else: 388 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 389 return data 390 391 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 392 """ 393 Sets the Connect OAuth Config for the account. 394 This method makes a synchronous HTTP request by default. To make an 395 asynchronous HTTP request, please define a `callback` function 396 to be invoked when receiving the response. 397 >>> def callback_function(response): 398 >>> pprint(response) 399 >>> 400 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 401 402 :param callback function: The callback function 403 for asynchronous request. (optional) 404 :param str account_id: The external account number (int) or account ID Guid. (required) 405 :return: None 406 If the method is called asynchronously, 407 returns the request thread. 408 """ 409 410 all_params = ['account_id'] 411 all_params.append('callback') 412 all_params.append('_return_http_data_only') 413 all_params.append('_preload_content') 414 all_params.append('_request_timeout') 415 416 params = locals() 417 for key, val in iteritems(params['kwargs']): 418 if key not in all_params: 419 raise TypeError( 420 "Got an unexpected keyword argument '%s'" 421 " to method delete_connect_o_auth_config" % key 422 ) 423 params[key] = val 424 del params['kwargs'] 425 # verify the required parameter 'account_id' is set 426 if ('account_id' not in params) or (params['account_id'] is None): 427 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 428 429 430 collection_formats = {} 431 432 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 433 path_params = {} 434 if 'account_id' in params: 435 path_params['accountId'] = params['account_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_event_failure_log(self, account_id, failure_id, **kwargs): 468 """ 469 Deletes a Connect failure log entry. 470 Deletes the Connect failure log information for the specified entry. 471 This method makes a synchronous HTTP request by default. To make an 472 asynchronous HTTP request, please define a `callback` function 473 to be invoked when receiving the response. 474 >>> def callback_function(response): 475 >>> pprint(response) 476 >>> 477 >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function) 478 479 :param callback function: The callback function 480 for asynchronous request. (optional) 481 :param str account_id: The external account number (int) or account ID Guid. (required) 482 :param str failure_id: The ID of the failed connect log entry. (required) 483 :return: ConnectDeleteFailureResult 484 If the method is called asynchronously, 485 returns the request thread. 486 """ 487 kwargs['_return_http_data_only'] = True 488 if kwargs.get('callback'): 489 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 490 else: 491 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 492 return data 493 494 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 495 """ 496 Deletes a Connect failure log entry. 497 Deletes the Connect failure log information for the specified entry. 498 This method makes a synchronous HTTP request by default. To make an 499 asynchronous HTTP request, please define a `callback` function 500 to be invoked when receiving the response. 501 >>> def callback_function(response): 502 >>> pprint(response) 503 >>> 504 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 505 506 :param callback function: The callback function 507 for asynchronous request. (optional) 508 :param str account_id: The external account number (int) or account ID Guid. (required) 509 :param str failure_id: The ID of the failed connect log entry. (required) 510 :return: ConnectDeleteFailureResult 511 If the method is called asynchronously, 512 returns the request thread. 513 """ 514 515 all_params = ['account_id', 'failure_id'] 516 all_params.append('callback') 517 all_params.append('_return_http_data_only') 518 all_params.append('_preload_content') 519 all_params.append('_request_timeout') 520 521 params = locals() 522 for key, val in iteritems(params['kwargs']): 523 if key not in all_params: 524 raise TypeError( 525 "Got an unexpected keyword argument '%s'" 526 " to method delete_event_failure_log" % key 527 ) 528 params[key] = val 529 del params['kwargs'] 530 # verify the required parameter 'account_id' is set 531 if ('account_id' not in params) or (params['account_id'] is None): 532 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 533 # verify the required parameter 'failure_id' is set 534 if ('failure_id' not in params) or (params['failure_id'] is None): 535 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 536 537 538 collection_formats = {} 539 540 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 541 path_params = {} 542 if 'account_id' in params: 543 path_params['accountId'] = params['account_id'] 544 if 'failure_id' in params: 545 path_params['failureId'] = params['failure_id'] 546 547 query_params = {} 548 549 header_params = {} 550 551 form_params = [] 552 local_var_files = {} 553 554 body_params = None 555 # HTTP header `Accept` 556 header_params['Accept'] = self.api_client.\ 557 select_header_accept(['application/json']) 558 559 # Authentication setting 560 auth_settings = [] 561 562 return self.api_client.call_api(resource_path, 'DELETE', 563 path_params, 564 query_params, 565 header_params, 566 body=body_params, 567 post_params=form_params, 568 files=local_var_files, 569 response_type='ConnectDeleteFailureResult', 570 auth_settings=auth_settings, 571 callback=params.get('callback'), 572 _return_http_data_only=params.get('_return_http_data_only'), 573 _preload_content=params.get('_preload_content', True), 574 _request_timeout=params.get('_request_timeout'), 575 collection_formats=collection_formats) 576 577 def delete_event_log(self, account_id, log_id, **kwargs): 578 """ 579 Deletes a specified Connect log entry. 580 Deletes a specified entry from the Connect Log. 581 This method makes a synchronous HTTP request by default. To make an 582 asynchronous HTTP request, please define a `callback` function 583 to be invoked when receiving the response. 584 >>> def callback_function(response): 585 >>> pprint(response) 586 >>> 587 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 588 589 :param callback function: The callback function 590 for asynchronous request. (optional) 591 :param str account_id: The external account number (int) or account ID Guid. (required) 592 :param str log_id: The ID of the connect log entry (required) 593 :return: None 594 If the method is called asynchronously, 595 returns the request thread. 596 """ 597 kwargs['_return_http_data_only'] = True 598 if kwargs.get('callback'): 599 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 600 else: 601 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 602 return data 603 604 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 605 """ 606 Deletes a specified Connect log entry. 607 Deletes a specified entry from the Connect Log. 608 This method makes a synchronous HTTP request by default. To make an 609 asynchronous HTTP request, please define a `callback` function 610 to be invoked when receiving the response. 611 >>> def callback_function(response): 612 >>> pprint(response) 613 >>> 614 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 615 616 :param callback function: The callback function 617 for asynchronous request. (optional) 618 :param str account_id: The external account number (int) or account ID Guid. (required) 619 :param str log_id: The ID of the connect log entry (required) 620 :return: None 621 If the method is called asynchronously, 622 returns the request thread. 623 """ 624 625 all_params = ['account_id', 'log_id'] 626 all_params.append('callback') 627 all_params.append('_return_http_data_only') 628 all_params.append('_preload_content') 629 all_params.append('_request_timeout') 630 631 params = locals() 632 for key, val in iteritems(params['kwargs']): 633 if key not in all_params: 634 raise TypeError( 635 "Got an unexpected keyword argument '%s'" 636 " to method delete_event_log" % key 637 ) 638 params[key] = val 639 del params['kwargs'] 640 # verify the required parameter 'account_id' is set 641 if ('account_id' not in params) or (params['account_id'] is None): 642 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 643 # verify the required parameter 'log_id' is set 644 if ('log_id' not in params) or (params['log_id'] is None): 645 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 646 647 648 collection_formats = {} 649 650 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 651 path_params = {} 652 if 'account_id' in params: 653 path_params['accountId'] = params['account_id'] 654 if 'log_id' in params: 655 path_params['logId'] = params['log_id'] 656 657 query_params = {} 658 659 header_params = {} 660 661 form_params = [] 662 local_var_files = {} 663 664 body_params = None 665 # HTTP header `Accept` 666 header_params['Accept'] = self.api_client.\ 667 select_header_accept(['application/json']) 668 669 # Authentication setting 670 auth_settings = [] 671 672 return self.api_client.call_api(resource_path, 'DELETE', 673 path_params, 674 query_params, 675 header_params, 676 body=body_params, 677 post_params=form_params, 678 files=local_var_files, 679 response_type=None, 680 auth_settings=auth_settings, 681 callback=params.get('callback'), 682 _return_http_data_only=params.get('_return_http_data_only'), 683 _preload_content=params.get('_preload_content', True), 684 _request_timeout=params.get('_request_timeout'), 685 collection_formats=collection_formats) 686 687 def delete_event_logs(self, account_id, **kwargs): 688 """ 689 Gets a list of Connect log entries. 690 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. 691 This method makes a synchronous HTTP request by default. To make an 692 asynchronous HTTP request, please define a `callback` function 693 to be invoked when receiving the response. 694 >>> def callback_function(response): 695 >>> pprint(response) 696 >>> 697 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 698 699 :param callback function: The callback function 700 for asynchronous request. (optional) 701 :param str account_id: The external account number (int) or account ID Guid. (required) 702 :return: None 703 If the method is called asynchronously, 704 returns the request thread. 705 """ 706 kwargs['_return_http_data_only'] = True 707 if kwargs.get('callback'): 708 return self.delete_event_logs_with_http_info(account_id, **kwargs) 709 else: 710 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 711 return data 712 713 def delete_event_logs_with_http_info(self, account_id, **kwargs): 714 """ 715 Gets a list of Connect log entries. 716 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. 717 This method makes a synchronous HTTP request by default. To make an 718 asynchronous HTTP request, please define a `callback` function 719 to be invoked when receiving the response. 720 >>> def callback_function(response): 721 >>> pprint(response) 722 >>> 723 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 724 725 :param callback function: The callback function 726 for asynchronous request. (optional) 727 :param str account_id: The external account number (int) or account ID Guid. (required) 728 :return: None 729 If the method is called asynchronously, 730 returns the request thread. 731 """ 732 733 all_params = ['account_id'] 734 all_params.append('callback') 735 all_params.append('_return_http_data_only') 736 all_params.append('_preload_content') 737 all_params.append('_request_timeout') 738 739 params = locals() 740 for key, val in iteritems(params['kwargs']): 741 if key not in all_params: 742 raise TypeError( 743 "Got an unexpected keyword argument '%s'" 744 " to method delete_event_logs" % key 745 ) 746 params[key] = val 747 del params['kwargs'] 748 # verify the required parameter 'account_id' is set 749 if ('account_id' not in params) or (params['account_id'] is None): 750 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 751 752 753 collection_formats = {} 754 755 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 756 path_params = {} 757 if 'account_id' in params: 758 path_params['accountId'] = params['account_id'] 759 760 query_params = {} 761 762 header_params = {} 763 764 form_params = [] 765 local_var_files = {} 766 767 body_params = None 768 # HTTP header `Accept` 769 header_params['Accept'] = self.api_client.\ 770 select_header_accept(['application/json']) 771 772 # Authentication setting 773 auth_settings = [] 774 775 return self.api_client.call_api(resource_path, 'DELETE', 776 path_params, 777 query_params, 778 header_params, 779 body=body_params, 780 post_params=form_params, 781 files=local_var_files, 782 response_type=None, 783 auth_settings=auth_settings, 784 callback=params.get('callback'), 785 _return_http_data_only=params.get('_return_http_data_only'), 786 _preload_content=params.get('_preload_content', True), 787 _request_timeout=params.get('_request_timeout'), 788 collection_formats=collection_formats) 789 790 def delete_mobile_notifiers(self, account_id, **kwargs): 791 """ 792 Reserved 793 Reserved: 794 This method makes a synchronous HTTP request by default. To make an 795 asynchronous HTTP request, please define a `callback` function 796 to be invoked when receiving the response. 797 >>> def callback_function(response): 798 >>> pprint(response) 799 >>> 800 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 801 802 :param callback function: The callback function 803 for asynchronous request. (optional) 804 :param str account_id: The external account number (int) or account ID Guid. (required) 805 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 806 :return: MobileNotifierConfigurationInformation 807 If the method is called asynchronously, 808 returns the request thread. 809 """ 810 kwargs['_return_http_data_only'] = True 811 if kwargs.get('callback'): 812 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 813 else: 814 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 815 return data 816 817 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 818 """ 819 Reserved 820 Reserved: 821 This method makes a synchronous HTTP request by default. To make an 822 asynchronous HTTP request, please define a `callback` function 823 to be invoked when receiving the response. 824 >>> def callback_function(response): 825 >>> pprint(response) 826 >>> 827 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 828 829 :param callback function: The callback function 830 for asynchronous request. (optional) 831 :param str account_id: The external account number (int) or account ID Guid. (required) 832 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 833 :return: MobileNotifierConfigurationInformation 834 If the method is called asynchronously, 835 returns the request thread. 836 """ 837 838 all_params = ['account_id', 'mobile_notifier_configuration_information'] 839 all_params.append('callback') 840 all_params.append('_return_http_data_only') 841 all_params.append('_preload_content') 842 all_params.append('_request_timeout') 843 844 params = locals() 845 for key, val in iteritems(params['kwargs']): 846 if key not in all_params: 847 raise TypeError( 848 "Got an unexpected keyword argument '%s'" 849 " to method delete_mobile_notifiers" % key 850 ) 851 params[key] = val 852 del params['kwargs'] 853 # verify the required parameter 'account_id' is set 854 if ('account_id' not in params) or (params['account_id'] is None): 855 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 856 857 858 collection_formats = {} 859 860 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 861 path_params = {} 862 if 'account_id' in params: 863 path_params['accountId'] = params['account_id'] 864 865 query_params = {} 866 867 header_params = {} 868 869 form_params = [] 870 local_var_files = {} 871 872 body_params = None 873 if 'mobile_notifier_configuration_information' in params: 874 body_params = params['mobile_notifier_configuration_information'] 875 # HTTP header `Accept` 876 header_params['Accept'] = self.api_client.\ 877 select_header_accept(['application/json']) 878 879 # Authentication setting 880 auth_settings = [] 881 882 return self.api_client.call_api(resource_path, 'DELETE', 883 path_params, 884 query_params, 885 header_params, 886 body=body_params, 887 post_params=form_params, 888 files=local_var_files, 889 response_type='MobileNotifierConfigurationInformation', 890 auth_settings=auth_settings, 891 callback=params.get('callback'), 892 _return_http_data_only=params.get('_return_http_data_only'), 893 _preload_content=params.get('_preload_content', True), 894 _request_timeout=params.get('_request_timeout'), 895 collection_formats=collection_formats) 896 897 def get_configuration(self, account_id, connect_id, **kwargs): 898 """ 899 Get a Connect Configuration Information 900 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 901 This method makes a synchronous HTTP request by default. To make an 902 asynchronous HTTP request, please define a `callback` function 903 to be invoked when receiving the response. 904 >>> def callback_function(response): 905 >>> pprint(response) 906 >>> 907 >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function) 908 909 :param callback function: The callback function 910 for asynchronous request. (optional) 911 :param str account_id: The external account number (int) or account ID Guid. (required) 912 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 913 :return: ConnectConfigResults 914 If the method is called asynchronously, 915 returns the request thread. 916 """ 917 kwargs['_return_http_data_only'] = True 918 if kwargs.get('callback'): 919 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 920 else: 921 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 922 return data 923 924 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 925 """ 926 Get a Connect Configuration Information 927 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 928 This method makes a synchronous HTTP request by default. To make an 929 asynchronous HTTP request, please define a `callback` function 930 to be invoked when receiving the response. 931 >>> def callback_function(response): 932 >>> pprint(response) 933 >>> 934 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 935 936 :param callback function: The callback function 937 for asynchronous request. (optional) 938 :param str account_id: The external account number (int) or account ID Guid. (required) 939 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 940 :return: ConnectConfigResults 941 If the method is called asynchronously, 942 returns the request thread. 943 """ 944 945 all_params = ['account_id', 'connect_id'] 946 all_params.append('callback') 947 all_params.append('_return_http_data_only') 948 all_params.append('_preload_content') 949 all_params.append('_request_timeout') 950 951 params = locals() 952 for key, val in iteritems(params['kwargs']): 953 if key not in all_params: 954 raise TypeError( 955 "Got an unexpected keyword argument '%s'" 956 " to method get_configuration" % key 957 ) 958 params[key] = val 959 del params['kwargs'] 960 # verify the required parameter 'account_id' is set 961 if ('account_id' not in params) or (params['account_id'] is None): 962 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 963 # verify the required parameter 'connect_id' is set 964 if ('connect_id' not in params) or (params['connect_id'] is None): 965 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 966 967 968 collection_formats = {} 969 970 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 971 path_params = {} 972 if 'account_id' in params: 973 path_params['accountId'] = params['account_id'] 974 if 'connect_id' in params: 975 path_params['connectId'] = params['connect_id'] 976 977 query_params = {} 978 979 header_params = {} 980 981 form_params = [] 982 local_var_files = {} 983 984 body_params = None 985 # HTTP header `Accept` 986 header_params['Accept'] = self.api_client.\ 987 select_header_accept(['application/json']) 988 989 # Authentication setting 990 auth_settings = [] 991 992 return self.api_client.call_api(resource_path, 'GET', 993 path_params, 994 query_params, 995 header_params, 996 body=body_params, 997 post_params=form_params, 998 files=local_var_files, 999 response_type='ConnectConfigResults', 1000 auth_settings=auth_settings, 1001 callback=params.get('callback'), 1002 _return_http_data_only=params.get('_return_http_data_only'), 1003 _preload_content=params.get('_preload_content', True), 1004 _request_timeout=params.get('_request_timeout'), 1005 collection_formats=collection_formats) 1006 1007 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1008 """ 1009 Returns all users from the configured Connect service. 1010 1011 This method makes a synchronous HTTP request by default. To make an 1012 asynchronous HTTP request, please define a `callback` function 1013 to be invoked when receiving the response. 1014 >>> def callback_function(response): 1015 >>> pprint(response) 1016 >>> 1017 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1018 1019 :param callback function: The callback function 1020 for asynchronous request. (optional) 1021 :param str account_id: The external account number (int) or account ID Guid. (required) 1022 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1023 :param str count: 1024 :param str domain_users_only: 1025 :param str email_substring: 1026 :param str start_position: 1027 :param str status: 1028 :param str user_name_substring: 1029 :return: IntegratedConnectUserInfoList 1030 If the method is called asynchronously, 1031 returns the request thread. 1032 """ 1033 kwargs['_return_http_data_only'] = True 1034 if kwargs.get('callback'): 1035 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1036 else: 1037 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1038 return data 1039 1040 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1041 """ 1042 Returns all users from the configured Connect service. 1043 1044 This method makes a synchronous HTTP request by default. To make an 1045 asynchronous HTTP request, please define a `callback` function 1046 to be invoked when receiving the response. 1047 >>> def callback_function(response): 1048 >>> pprint(response) 1049 >>> 1050 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1051 1052 :param callback function: The callback function 1053 for asynchronous request. (optional) 1054 :param str account_id: The external account number (int) or account ID Guid. (required) 1055 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1056 :param str count: 1057 :param str domain_users_only: 1058 :param str email_substring: 1059 :param str start_position: 1060 :param str status: 1061 :param str user_name_substring: 1062 :return: IntegratedConnectUserInfoList 1063 If the method is called asynchronously, 1064 returns the request thread. 1065 """ 1066 1067 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1068 all_params.append('callback') 1069 all_params.append('_return_http_data_only') 1070 all_params.append('_preload_content') 1071 all_params.append('_request_timeout') 1072 1073 params = locals() 1074 for key, val in iteritems(params['kwargs']): 1075 if key not in all_params: 1076 raise TypeError( 1077 "Got an unexpected keyword argument '%s'" 1078 " to method get_connect_all_users" % key 1079 ) 1080 params[key] = val 1081 del params['kwargs'] 1082 # verify the required parameter 'account_id' is set 1083 if ('account_id' not in params) or (params['account_id'] is None): 1084 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1085 # verify the required parameter 'connect_id' is set 1086 if ('connect_id' not in params) or (params['connect_id'] is None): 1087 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1088 1089 1090 collection_formats = {} 1091 1092 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1093 path_params = {} 1094 if 'account_id' in params: 1095 path_params['accountId'] = params['account_id'] 1096 if 'connect_id' in params: 1097 path_params['connectId'] = params['connect_id'] 1098 1099 query_params = {} 1100 if 'count' in params: 1101 query_params['count'] = params['count'] 1102 if 'domain_users_only' in params: 1103 query_params['domain_users_only'] = params['domain_users_only'] 1104 if 'email_substring' in params: 1105 query_params['email_substring'] = params['email_substring'] 1106 if 'start_position' in params: 1107 query_params['start_position'] = params['start_position'] 1108 if 'status' in params: 1109 query_params['status'] = params['status'] 1110 if 'user_name_substring' in params: 1111 query_params['user_name_substring'] = params['user_name_substring'] 1112 1113 header_params = {} 1114 1115 form_params = [] 1116 local_var_files = {} 1117 1118 body_params = None 1119 # HTTP header `Accept` 1120 header_params['Accept'] = self.api_client.\ 1121 select_header_accept(['application/json']) 1122 1123 # Authentication setting 1124 auth_settings = [] 1125 1126 return self.api_client.call_api(resource_path, 'GET', 1127 path_params, 1128 query_params, 1129 header_params, 1130 body=body_params, 1131 post_params=form_params, 1132 files=local_var_files, 1133 response_type='IntegratedConnectUserInfoList', 1134 auth_settings=auth_settings, 1135 callback=params.get('callback'), 1136 _return_http_data_only=params.get('_return_http_data_only'), 1137 _preload_content=params.get('_preload_content', True), 1138 _request_timeout=params.get('_request_timeout'), 1139 collection_formats=collection_formats) 1140 1141 def get_connect_o_auth_config(self, account_id, **kwargs): 1142 """ 1143 Sets the Connect OAuth Config for the account. 1144 This method makes a synchronous HTTP request by default. To make an 1145 asynchronous HTTP request, please define a `callback` function 1146 to be invoked when receiving the response. 1147 >>> def callback_function(response): 1148 >>> pprint(response) 1149 >>> 1150 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1151 1152 :param callback function: The callback function 1153 for asynchronous request. (optional) 1154 :param str account_id: The external account number (int) or account ID Guid. (required) 1155 :return: ConnectOAuthConfig 1156 If the method is called asynchronously, 1157 returns the request thread. 1158 """ 1159 kwargs['_return_http_data_only'] = True 1160 if kwargs.get('callback'): 1161 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1162 else: 1163 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1164 return data 1165 1166 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1167 """ 1168 Sets the Connect OAuth Config for the account. 1169 This method makes a synchronous HTTP request by default. To make an 1170 asynchronous HTTP request, please define a `callback` function 1171 to be invoked when receiving the response. 1172 >>> def callback_function(response): 1173 >>> pprint(response) 1174 >>> 1175 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1176 1177 :param callback function: The callback function 1178 for asynchronous request. (optional) 1179 :param str account_id: The external account number (int) or account ID Guid. (required) 1180 :return: ConnectOAuthConfig 1181 If the method is called asynchronously, 1182 returns the request thread. 1183 """ 1184 1185 all_params = ['account_id'] 1186 all_params.append('callback') 1187 all_params.append('_return_http_data_only') 1188 all_params.append('_preload_content') 1189 all_params.append('_request_timeout') 1190 1191 params = locals() 1192 for key, val in iteritems(params['kwargs']): 1193 if key not in all_params: 1194 raise TypeError( 1195 "Got an unexpected keyword argument '%s'" 1196 " to method get_connect_o_auth_config" % key 1197 ) 1198 params[key] = val 1199 del params['kwargs'] 1200 # verify the required parameter 'account_id' is set 1201 if ('account_id' not in params) or (params['account_id'] is None): 1202 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1203 1204 1205 collection_formats = {} 1206 1207 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1208 path_params = {} 1209 if 'account_id' in params: 1210 path_params['accountId'] = params['account_id'] 1211 1212 query_params = {} 1213 1214 header_params = {} 1215 1216 form_params = [] 1217 local_var_files = {} 1218 1219 body_params = None 1220 # HTTP header `Accept` 1221 header_params['Accept'] = self.api_client.\ 1222 select_header_accept(['application/json']) 1223 1224 # Authentication setting 1225 auth_settings = [] 1226 1227 return self.api_client.call_api(resource_path, 'GET', 1228 path_params, 1229 query_params, 1230 header_params, 1231 body=body_params, 1232 post_params=form_params, 1233 files=local_var_files, 1234 response_type='ConnectOAuthConfig', 1235 auth_settings=auth_settings, 1236 callback=params.get('callback'), 1237 _return_http_data_only=params.get('_return_http_data_only'), 1238 _preload_content=params.get('_preload_content', True), 1239 _request_timeout=params.get('_request_timeout'), 1240 collection_formats=collection_formats) 1241 1242 def get_event_log(self, account_id, log_id, **kwargs): 1243 """ 1244 Get the specified Connect log entry. 1245 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. 1246 This method makes a synchronous HTTP request by default. To make an 1247 asynchronous HTTP request, please define a `callback` function 1248 to be invoked when receiving the response. 1249 >>> def callback_function(response): 1250 >>> pprint(response) 1251 >>> 1252 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1253 1254 :param callback function: The callback function 1255 for asynchronous request. (optional) 1256 :param str account_id: The external account number (int) or account ID Guid. (required) 1257 :param str log_id: The ID of the connect log entry (required) 1258 :param str additional_info: When true, the connectDebugLog information is included in the response. 1259 :return: ConnectLog 1260 If the method is called asynchronously, 1261 returns the request thread. 1262 """ 1263 kwargs['_return_http_data_only'] = True 1264 if kwargs.get('callback'): 1265 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1266 else: 1267 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1268 return data 1269 1270 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1271 """ 1272 Get the specified Connect log entry. 1273 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. 1274 This method makes a synchronous HTTP request by default. To make an 1275 asynchronous HTTP request, please define a `callback` function 1276 to be invoked when receiving the response. 1277 >>> def callback_function(response): 1278 >>> pprint(response) 1279 >>> 1280 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1281 1282 :param callback function: The callback function 1283 for asynchronous request. (optional) 1284 :param str account_id: The external account number (int) or account ID Guid. (required) 1285 :param str log_id: The ID of the connect log entry (required) 1286 :param str additional_info: When true, the connectDebugLog information is included in the response. 1287 :return: ConnectLog 1288 If the method is called asynchronously, 1289 returns the request thread. 1290 """ 1291 1292 all_params = ['account_id', 'log_id', 'additional_info'] 1293 all_params.append('callback') 1294 all_params.append('_return_http_data_only') 1295 all_params.append('_preload_content') 1296 all_params.append('_request_timeout') 1297 1298 params = locals() 1299 for key, val in iteritems(params['kwargs']): 1300 if key not in all_params: 1301 raise TypeError( 1302 "Got an unexpected keyword argument '%s'" 1303 " to method get_event_log" % key 1304 ) 1305 params[key] = val 1306 del params['kwargs'] 1307 # verify the required parameter 'account_id' is set 1308 if ('account_id' not in params) or (params['account_id'] is None): 1309 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1310 # verify the required parameter 'log_id' is set 1311 if ('log_id' not in params) or (params['log_id'] is None): 1312 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1313 1314 1315 collection_formats = {} 1316 1317 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1318 path_params = {} 1319 if 'account_id' in params: 1320 path_params['accountId'] = params['account_id'] 1321 if 'log_id' in params: 1322 path_params['logId'] = params['log_id'] 1323 1324 query_params = {} 1325 if 'additional_info' in params: 1326 query_params['additional_info'] = params['additional_info'] 1327 1328 header_params = {} 1329 1330 form_params = [] 1331 local_var_files = {} 1332 1333 body_params = None 1334 # HTTP header `Accept` 1335 header_params['Accept'] = self.api_client.\ 1336 select_header_accept(['application/json']) 1337 1338 # Authentication setting 1339 auth_settings = [] 1340 1341 return self.api_client.call_api(resource_path, 'GET', 1342 path_params, 1343 query_params, 1344 header_params, 1345 body=body_params, 1346 post_params=form_params, 1347 files=local_var_files, 1348 response_type='ConnectLog', 1349 auth_settings=auth_settings, 1350 callback=params.get('callback'), 1351 _return_http_data_only=params.get('_return_http_data_only'), 1352 _preload_content=params.get('_preload_content', True), 1353 _request_timeout=params.get('_request_timeout'), 1354 collection_formats=collection_formats) 1355 1356 def list_configurations(self, account_id, **kwargs): 1357 """ 1358 Get Connect Configuration Information 1359 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. 1360 This method makes a synchronous HTTP request by default. To make an 1361 asynchronous HTTP request, please define a `callback` function 1362 to be invoked when receiving the response. 1363 >>> def callback_function(response): 1364 >>> pprint(response) 1365 >>> 1366 >>> thread = api.list_configurations(account_id, callback=callback_function) 1367 1368 :param callback function: The callback function 1369 for asynchronous request. (optional) 1370 :param str account_id: The external account number (int) or account ID Guid. (required) 1371 :return: ConnectConfigResults 1372 If the method is called asynchronously, 1373 returns the request thread. 1374 """ 1375 kwargs['_return_http_data_only'] = True 1376 if kwargs.get('callback'): 1377 return self.list_configurations_with_http_info(account_id, **kwargs) 1378 else: 1379 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1380 return data 1381 1382 def list_configurations_with_http_info(self, account_id, **kwargs): 1383 """ 1384 Get Connect Configuration Information 1385 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. 1386 This method makes a synchronous HTTP request by default. To make an 1387 asynchronous HTTP request, please define a `callback` function 1388 to be invoked when receiving the response. 1389 >>> def callback_function(response): 1390 >>> pprint(response) 1391 >>> 1392 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1393 1394 :param callback function: The callback function 1395 for asynchronous request. (optional) 1396 :param str account_id: The external account number (int) or account ID Guid. (required) 1397 :return: ConnectConfigResults 1398 If the method is called asynchronously, 1399 returns the request thread. 1400 """ 1401 1402 all_params = ['account_id'] 1403 all_params.append('callback') 1404 all_params.append('_return_http_data_only') 1405 all_params.append('_preload_content') 1406 all_params.append('_request_timeout') 1407 1408 params = locals() 1409 for key, val in iteritems(params['kwargs']): 1410 if key not in all_params: 1411 raise TypeError( 1412 "Got an unexpected keyword argument '%s'" 1413 " to method list_configurations" % key 1414 ) 1415 params[key] = val 1416 del params['kwargs'] 1417 # verify the required parameter 'account_id' is set 1418 if ('account_id' not in params) or (params['account_id'] is None): 1419 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1420 1421 1422 collection_formats = {} 1423 1424 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1425 path_params = {} 1426 if 'account_id' in params: 1427 path_params['accountId'] = params['account_id'] 1428 1429 query_params = {} 1430 1431 header_params = {} 1432 1433 form_params = [] 1434 local_var_files = {} 1435 1436 body_params = None 1437 # HTTP header `Accept` 1438 header_params['Accept'] = self.api_client.\ 1439 select_header_accept(['application/json']) 1440 1441 # Authentication setting 1442 auth_settings = [] 1443 1444 return self.api_client.call_api(resource_path, 'GET', 1445 path_params, 1446 query_params, 1447 header_params, 1448 body=body_params, 1449 post_params=form_params, 1450 files=local_var_files, 1451 response_type='ConnectConfigResults', 1452 auth_settings=auth_settings, 1453 callback=params.get('callback'), 1454 _return_http_data_only=params.get('_return_http_data_only'), 1455 _preload_content=params.get('_preload_content', True), 1456 _request_timeout=params.get('_request_timeout'), 1457 collection_formats=collection_formats) 1458 1459 def list_event_failure_logs(self, account_id, **kwargs): 1460 """ 1461 Gets the Connect failure log information. 1462 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1463 This method makes a synchronous HTTP request by default. To make an 1464 asynchronous HTTP request, please define a `callback` function 1465 to be invoked when receiving the response. 1466 >>> def callback_function(response): 1467 >>> pprint(response) 1468 >>> 1469 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1470 1471 :param callback function: The callback function 1472 for asynchronous request. (optional) 1473 :param str account_id: The external account number (int) or account ID Guid. (required) 1474 :param str from_date: 1475 :param str to_date: 1476 :return: ConnectLogs 1477 If the method is called asynchronously, 1478 returns the request thread. 1479 """ 1480 kwargs['_return_http_data_only'] = True 1481 if kwargs.get('callback'): 1482 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1483 else: 1484 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1485 return data 1486 1487 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1488 """ 1489 Gets the Connect failure log information. 1490 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1491 This method makes a synchronous HTTP request by default. To make an 1492 asynchronous HTTP request, please define a `callback` function 1493 to be invoked when receiving the response. 1494 >>> def callback_function(response): 1495 >>> pprint(response) 1496 >>> 1497 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1498 1499 :param callback function: The callback function 1500 for asynchronous request. (optional) 1501 :param str account_id: The external account number (int) or account ID Guid. (required) 1502 :param str from_date: 1503 :param str to_date: 1504 :return: ConnectLogs 1505 If the method is called asynchronously, 1506 returns the request thread. 1507 """ 1508 1509 all_params = ['account_id', 'from_date', 'to_date'] 1510 all_params.append('callback') 1511 all_params.append('_return_http_data_only') 1512 all_params.append('_preload_content') 1513 all_params.append('_request_timeout') 1514 1515 params = locals() 1516 for key, val in iteritems(params['kwargs']): 1517 if key not in all_params: 1518 raise TypeError( 1519 "Got an unexpected keyword argument '%s'" 1520 " to method list_event_failure_logs" % key 1521 ) 1522 params[key] = val 1523 del params['kwargs'] 1524 # verify the required parameter 'account_id' is set 1525 if ('account_id' not in params) or (params['account_id'] is None): 1526 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1527 1528 1529 collection_formats = {} 1530 1531 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1532 path_params = {} 1533 if 'account_id' in params: 1534 path_params['accountId'] = params['account_id'] 1535 1536 query_params = {} 1537 if 'from_date' in params: 1538 query_params['from_date'] = params['from_date'] 1539 if 'to_date' in params: 1540 query_params['to_date'] = params['to_date'] 1541 1542 header_params = {} 1543 1544 form_params = [] 1545 local_var_files = {} 1546 1547 body_params = None 1548 # HTTP header `Accept` 1549 header_params['Accept'] = self.api_client.\ 1550 select_header_accept(['application/json']) 1551 1552 # Authentication setting 1553 auth_settings = [] 1554 1555 return self.api_client.call_api(resource_path, 'GET', 1556 path_params, 1557 query_params, 1558 header_params, 1559 body=body_params, 1560 post_params=form_params, 1561 files=local_var_files, 1562 response_type='ConnectLogs', 1563 auth_settings=auth_settings, 1564 callback=params.get('callback'), 1565 _return_http_data_only=params.get('_return_http_data_only'), 1566 _preload_content=params.get('_preload_content', True), 1567 _request_timeout=params.get('_request_timeout'), 1568 collection_formats=collection_formats) 1569 1570 def list_event_logs(self, account_id, **kwargs): 1571 """ 1572 Gets the Connect log. 1573 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. 1574 This method makes a synchronous HTTP request by default. To make an 1575 asynchronous HTTP request, please define a `callback` function 1576 to be invoked when receiving the response. 1577 >>> def callback_function(response): 1578 >>> pprint(response) 1579 >>> 1580 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1581 1582 :param callback function: The callback function 1583 for asynchronous request. (optional) 1584 :param str account_id: The external account number (int) or account ID Guid. (required) 1585 :param str from_date: 1586 :param str to_date: 1587 :return: ConnectLogs 1588 If the method is called asynchronously, 1589 returns the request thread. 1590 """ 1591 kwargs['_return_http_data_only'] = True 1592 if kwargs.get('callback'): 1593 return self.list_event_logs_with_http_info(account_id, **kwargs) 1594 else: 1595 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1596 return data 1597 1598 def list_event_logs_with_http_info(self, account_id, **kwargs): 1599 """ 1600 Gets the Connect log. 1601 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. 1602 This method makes a synchronous HTTP request by default. To make an 1603 asynchronous HTTP request, please define a `callback` function 1604 to be invoked when receiving the response. 1605 >>> def callback_function(response): 1606 >>> pprint(response) 1607 >>> 1608 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1609 1610 :param callback function: The callback function 1611 for asynchronous request. (optional) 1612 :param str account_id: The external account number (int) or account ID Guid. (required) 1613 :param str from_date: 1614 :param str to_date: 1615 :return: ConnectLogs 1616 If the method is called asynchronously, 1617 returns the request thread. 1618 """ 1619 1620 all_params = ['account_id', 'from_date', 'to_date'] 1621 all_params.append('callback') 1622 all_params.append('_return_http_data_only') 1623 all_params.append('_preload_content') 1624 all_params.append('_request_timeout') 1625 1626 params = locals() 1627 for key, val in iteritems(params['kwargs']): 1628 if key not in all_params: 1629 raise TypeError( 1630 "Got an unexpected keyword argument '%s'" 1631 " to method list_event_logs" % key 1632 ) 1633 params[key] = val 1634 del params['kwargs'] 1635 # verify the required parameter 'account_id' is set 1636 if ('account_id' not in params) or (params['account_id'] is None): 1637 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1638 1639 1640 collection_formats = {} 1641 1642 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1643 path_params = {} 1644 if 'account_id' in params: 1645 path_params['accountId'] = params['account_id'] 1646 1647 query_params = {} 1648 if 'from_date' in params: 1649 query_params['from_date'] = params['from_date'] 1650 if 'to_date' in params: 1651 query_params['to_date'] = params['to_date'] 1652 1653 header_params = {} 1654 1655 form_params = [] 1656 local_var_files = {} 1657 1658 body_params = None 1659 # HTTP header `Accept` 1660 header_params['Accept'] = self.api_client.\ 1661 select_header_accept(['application/json']) 1662 1663 # Authentication setting 1664 auth_settings = [] 1665 1666 return self.api_client.call_api(resource_path, 'GET', 1667 path_params, 1668 query_params, 1669 header_params, 1670 body=body_params, 1671 post_params=form_params, 1672 files=local_var_files, 1673 response_type='ConnectLogs', 1674 auth_settings=auth_settings, 1675 callback=params.get('callback'), 1676 _return_http_data_only=params.get('_return_http_data_only'), 1677 _preload_content=params.get('_preload_content', True), 1678 _request_timeout=params.get('_request_timeout'), 1679 collection_formats=collection_formats) 1680 1681 def list_mobile_notifiers(self, account_id, **kwargs): 1682 """ 1683 Reserved 1684 Reserved: 1685 This method makes a synchronous HTTP request by default. To make an 1686 asynchronous HTTP request, please define a `callback` function 1687 to be invoked when receiving the response. 1688 >>> def callback_function(response): 1689 >>> pprint(response) 1690 >>> 1691 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 1692 1693 :param callback function: The callback function 1694 for asynchronous request. (optional) 1695 :param str account_id: The external account number (int) or account ID Guid. (required) 1696 :return: MobileNotifierConfigurationInformation 1697 If the method is called asynchronously, 1698 returns the request thread. 1699 """ 1700 kwargs['_return_http_data_only'] = True 1701 if kwargs.get('callback'): 1702 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1703 else: 1704 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1705 return data 1706 1707 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1708 """ 1709 Reserved 1710 Reserved: 1711 This method makes a synchronous HTTP request by default. To make an 1712 asynchronous HTTP request, please define a `callback` function 1713 to be invoked when receiving the response. 1714 >>> def callback_function(response): 1715 >>> pprint(response) 1716 >>> 1717 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1718 1719 :param callback function: The callback function 1720 for asynchronous request. (optional) 1721 :param str account_id: The external account number (int) or account ID Guid. (required) 1722 :return: MobileNotifierConfigurationInformation 1723 If the method is called asynchronously, 1724 returns the request thread. 1725 """ 1726 1727 all_params = ['account_id'] 1728 all_params.append('callback') 1729 all_params.append('_return_http_data_only') 1730 all_params.append('_preload_content') 1731 all_params.append('_request_timeout') 1732 1733 params = locals() 1734 for key, val in iteritems(params['kwargs']): 1735 if key not in all_params: 1736 raise TypeError( 1737 "Got an unexpected keyword argument '%s'" 1738 " to method list_mobile_notifiers" % key 1739 ) 1740 params[key] = val 1741 del params['kwargs'] 1742 # verify the required parameter 'account_id' is set 1743 if ('account_id' not in params) or (params['account_id'] is None): 1744 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 1745 1746 1747 collection_formats = {} 1748 1749 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1750 path_params = {} 1751 if 'account_id' in params: 1752 path_params['accountId'] = params['account_id'] 1753 1754 query_params = {} 1755 1756 header_params = {} 1757 1758 form_params = [] 1759 local_var_files = {} 1760 1761 body_params = None 1762 # HTTP header `Accept` 1763 header_params['Accept'] = self.api_client.\ 1764 select_header_accept(['application/json']) 1765 1766 # Authentication setting 1767 auth_settings = [] 1768 1769 return self.api_client.call_api(resource_path, 'GET', 1770 path_params, 1771 query_params, 1772 header_params, 1773 body=body_params, 1774 post_params=form_params, 1775 files=local_var_files, 1776 response_type='MobileNotifierConfigurationInformation', 1777 auth_settings=auth_settings, 1778 callback=params.get('callback'), 1779 _return_http_data_only=params.get('_return_http_data_only'), 1780 _preload_content=params.get('_preload_content', True), 1781 _request_timeout=params.get('_request_timeout'), 1782 collection_formats=collection_formats) 1783 1784 def list_users(self, account_id, connect_id, **kwargs): 1785 """ 1786 Returns users from the configured Connect service. 1787 Returns users from the configured Connect service. 1788 This method makes a synchronous HTTP request by default. To make an 1789 asynchronous HTTP request, please define a `callback` function 1790 to be invoked when receiving the response. 1791 >>> def callback_function(response): 1792 >>> pprint(response) 1793 >>> 1794 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 1795 1796 :param callback function: The callback function 1797 for asynchronous request. (optional) 1798 :param str account_id: The external account number (int) or account ID Guid. (required) 1799 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1800 :param str count: 1801 :param str email_substring: 1802 :param str list_included_users: 1803 :param str start_position: 1804 :param str status: 1805 :param str user_name_substring: 1806 :return: IntegratedUserInfoList 1807 If the method is called asynchronously, 1808 returns the request thread. 1809 """ 1810 kwargs['_return_http_data_only'] = True 1811 if kwargs.get('callback'): 1812 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 1813 else: 1814 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 1815 return data 1816 1817 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 1818 """ 1819 Returns users from the configured Connect service. 1820 Returns users from the configured Connect service. 1821 This method makes a synchronous HTTP request by default. To make an 1822 asynchronous HTTP request, please define a `callback` function 1823 to be invoked when receiving the response. 1824 >>> def callback_function(response): 1825 >>> pprint(response) 1826 >>> 1827 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 1828 1829 :param callback function: The callback function 1830 for asynchronous request. (optional) 1831 :param str account_id: The external account number (int) or account ID Guid. (required) 1832 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1833 :param str count: 1834 :param str email_substring: 1835 :param str list_included_users: 1836 :param str start_position: 1837 :param str status: 1838 :param str user_name_substring: 1839 :return: IntegratedUserInfoList 1840 If the method is called asynchronously, 1841 returns the request thread. 1842 """ 1843 1844 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 1845 all_params.append('callback') 1846 all_params.append('_return_http_data_only') 1847 all_params.append('_preload_content') 1848 all_params.append('_request_timeout') 1849 1850 params = locals() 1851 for key, val in iteritems(params['kwargs']): 1852 if key not in all_params: 1853 raise TypeError( 1854 "Got an unexpected keyword argument '%s'" 1855 " to method list_users" % key 1856 ) 1857 params[key] = val 1858 del params['kwargs'] 1859 # verify the required parameter 'account_id' is set 1860 if ('account_id' not in params) or (params['account_id'] is None): 1861 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 1862 # verify the required parameter 'connect_id' is set 1863 if ('connect_id' not in params) or (params['connect_id'] is None): 1864 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 1865 1866 1867 collection_formats = {} 1868 1869 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 1870 path_params = {} 1871 if 'account_id' in params: 1872 path_params['accountId'] = params['account_id'] 1873 if 'connect_id' in params: 1874 path_params['connectId'] = params['connect_id'] 1875 1876 query_params = {} 1877 if 'count' in params: 1878 query_params['count'] = params['count'] 1879 if 'email_substring' in params: 1880 query_params['email_substring'] = params['email_substring'] 1881 if 'list_included_users' in params: 1882 query_params['list_included_users'] = params['list_included_users'] 1883 if 'start_position' in params: 1884 query_params['start_position'] = params['start_position'] 1885 if 'status' in params: 1886 query_params['status'] = params['status'] 1887 if 'user_name_substring' in params: 1888 query_params['user_name_substring'] = params['user_name_substring'] 1889 1890 header_params = {} 1891 1892 form_params = [] 1893 local_var_files = {} 1894 1895 body_params = None 1896 # HTTP header `Accept` 1897 header_params['Accept'] = self.api_client.\ 1898 select_header_accept(['application/json']) 1899 1900 # Authentication setting 1901 auth_settings = [] 1902 1903 return self.api_client.call_api(resource_path, 'GET', 1904 path_params, 1905 query_params, 1906 header_params, 1907 body=body_params, 1908 post_params=form_params, 1909 files=local_var_files, 1910 response_type='IntegratedUserInfoList', 1911 auth_settings=auth_settings, 1912 callback=params.get('callback'), 1913 _return_http_data_only=params.get('_return_http_data_only'), 1914 _preload_content=params.get('_preload_content', True), 1915 _request_timeout=params.get('_request_timeout'), 1916 collection_formats=collection_formats) 1917 1918 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 1919 """ 1920 Republishes Connect information for the specified envelope. 1921 Republishes Connect information for the specified envelope. 1922 This method makes a synchronous HTTP request by default. To make an 1923 asynchronous HTTP request, please define a `callback` function 1924 to be invoked when receiving the response. 1925 >>> def callback_function(response): 1926 >>> pprint(response) 1927 >>> 1928 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 1929 1930 :param callback function: The callback function 1931 for asynchronous request. (optional) 1932 :param str account_id: The external account number (int) or account ID Guid. (required) 1933 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1934 :return: ConnectFailureResults 1935 If the method is called asynchronously, 1936 returns the request thread. 1937 """ 1938 kwargs['_return_http_data_only'] = True 1939 if kwargs.get('callback'): 1940 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1941 else: 1942 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1943 return data 1944 1945 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 1946 """ 1947 Republishes Connect information for the specified envelope. 1948 Republishes Connect information for the specified envelope. 1949 This method makes a synchronous HTTP request by default. To make an 1950 asynchronous HTTP request, please define a `callback` function 1951 to be invoked when receiving the response. 1952 >>> def callback_function(response): 1953 >>> pprint(response) 1954 >>> 1955 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 1956 1957 :param callback function: The callback function 1958 for asynchronous request. (optional) 1959 :param str account_id: The external account number (int) or account ID Guid. (required) 1960 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1961 :return: ConnectFailureResults 1962 If the method is called asynchronously, 1963 returns the request thread. 1964 """ 1965 1966 all_params = ['account_id', 'envelope_id'] 1967 all_params.append('callback') 1968 all_params.append('_return_http_data_only') 1969 all_params.append('_preload_content') 1970 all_params.append('_request_timeout') 1971 1972 params = locals() 1973 for key, val in iteritems(params['kwargs']): 1974 if key not in all_params: 1975 raise TypeError( 1976 "Got an unexpected keyword argument '%s'" 1977 " to method retry_event_for_envelope" % key 1978 ) 1979 params[key] = val 1980 del params['kwargs'] 1981 # verify the required parameter 'account_id' is set 1982 if ('account_id' not in params) or (params['account_id'] is None): 1983 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 1984 # verify the required parameter 'envelope_id' is set 1985 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1986 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 1987 1988 1989 collection_formats = {} 1990 1991 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 1992 path_params = {} 1993 if 'account_id' in params: 1994 path_params['accountId'] = params['account_id'] 1995 if 'envelope_id' in params: 1996 path_params['envelopeId'] = params['envelope_id'] 1997 1998 query_params = {} 1999 2000 header_params = {} 2001 2002 form_params = [] 2003 local_var_files = {} 2004 2005 body_params = None 2006 # HTTP header `Accept` 2007 header_params['Accept'] = self.api_client.\ 2008 select_header_accept(['application/json']) 2009 2010 # Authentication setting 2011 auth_settings = [] 2012 2013 return self.api_client.call_api(resource_path, 'PUT', 2014 path_params, 2015 query_params, 2016 header_params, 2017 body=body_params, 2018 post_params=form_params, 2019 files=local_var_files, 2020 response_type='ConnectFailureResults', 2021 auth_settings=auth_settings, 2022 callback=params.get('callback'), 2023 _return_http_data_only=params.get('_return_http_data_only'), 2024 _preload_content=params.get('_preload_content', True), 2025 _request_timeout=params.get('_request_timeout'), 2026 collection_formats=collection_formats) 2027 2028 def retry_event_for_envelopes(self, account_id, **kwargs): 2029 """ 2030 Republishes Connect information for multiple envelopes. 2031 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. 2032 This method makes a synchronous HTTP request by default. To make an 2033 asynchronous HTTP request, please define a `callback` function 2034 to be invoked when receiving the response. 2035 >>> def callback_function(response): 2036 >>> pprint(response) 2037 >>> 2038 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2039 2040 :param callback function: The callback function 2041 for asynchronous request. (optional) 2042 :param str account_id: The external account number (int) or account ID Guid. (required) 2043 :param ConnectFailureFilter connect_failure_filter: 2044 :return: ConnectFailureResults 2045 If the method is called asynchronously, 2046 returns the request thread. 2047 """ 2048 kwargs['_return_http_data_only'] = True 2049 if kwargs.get('callback'): 2050 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2051 else: 2052 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2053 return data 2054 2055 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2056 """ 2057 Republishes Connect information for multiple envelopes. 2058 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. 2059 This method makes a synchronous HTTP request by default. To make an 2060 asynchronous HTTP request, please define a `callback` function 2061 to be invoked when receiving the response. 2062 >>> def callback_function(response): 2063 >>> pprint(response) 2064 >>> 2065 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2066 2067 :param callback function: The callback function 2068 for asynchronous request. (optional) 2069 :param str account_id: The external account number (int) or account ID Guid. (required) 2070 :param ConnectFailureFilter connect_failure_filter: 2071 :return: ConnectFailureResults 2072 If the method is called asynchronously, 2073 returns the request thread. 2074 """ 2075 2076 all_params = ['account_id', 'connect_failure_filter'] 2077 all_params.append('callback') 2078 all_params.append('_return_http_data_only') 2079 all_params.append('_preload_content') 2080 all_params.append('_request_timeout') 2081 2082 params = locals() 2083 for key, val in iteritems(params['kwargs']): 2084 if key not in all_params: 2085 raise TypeError( 2086 "Got an unexpected keyword argument '%s'" 2087 " to method retry_event_for_envelopes" % key 2088 ) 2089 params[key] = val 2090 del params['kwargs'] 2091 # verify the required parameter 'account_id' is set 2092 if ('account_id' not in params) or (params['account_id'] is None): 2093 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2094 2095 2096 collection_formats = {} 2097 2098 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2099 path_params = {} 2100 if 'account_id' in params: 2101 path_params['accountId'] = params['account_id'] 2102 2103 query_params = {} 2104 2105 header_params = {} 2106 2107 form_params = [] 2108 local_var_files = {} 2109 2110 body_params = None 2111 if 'connect_failure_filter' in params: 2112 body_params = params['connect_failure_filter'] 2113 # HTTP header `Accept` 2114 header_params['Accept'] = self.api_client.\ 2115 select_header_accept(['application/json']) 2116 2117 # Authentication setting 2118 auth_settings = [] 2119 2120 return self.api_client.call_api(resource_path, 'PUT', 2121 path_params, 2122 query_params, 2123 header_params, 2124 body=body_params, 2125 post_params=form_params, 2126 files=local_var_files, 2127 response_type='ConnectFailureResults', 2128 auth_settings=auth_settings, 2129 callback=params.get('callback'), 2130 _return_http_data_only=params.get('_return_http_data_only'), 2131 _preload_content=params.get('_preload_content', True), 2132 _request_timeout=params.get('_request_timeout'), 2133 collection_formats=collection_formats) 2134 2135 def update_configuration(self, account_id, **kwargs): 2136 """ 2137 Updates a specified Connect configuration. 2138 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. 2139 This method makes a synchronous HTTP request by default. To make an 2140 asynchronous HTTP request, please define a `callback` function 2141 to be invoked when receiving the response. 2142 >>> def callback_function(response): 2143 >>> pprint(response) 2144 >>> 2145 >>> thread = api.update_configuration(account_id, callback=callback_function) 2146 2147 :param callback function: The callback function 2148 for asynchronous request. (optional) 2149 :param str account_id: The external account number (int) or account ID Guid. (required) 2150 :param ConnectCustomConfiguration connect_custom_configuration: 2151 :return: ConnectCustomConfiguration 2152 If the method is called asynchronously, 2153 returns the request thread. 2154 """ 2155 kwargs['_return_http_data_only'] = True 2156 if kwargs.get('callback'): 2157 return self.update_configuration_with_http_info(account_id, **kwargs) 2158 else: 2159 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2160 return data 2161 2162 def update_configuration_with_http_info(self, account_id, **kwargs): 2163 """ 2164 Updates a specified Connect configuration. 2165 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. 2166 This method makes a synchronous HTTP request by default. To make an 2167 asynchronous HTTP request, please define a `callback` function 2168 to be invoked when receiving the response. 2169 >>> def callback_function(response): 2170 >>> pprint(response) 2171 >>> 2172 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2173 2174 :param callback function: The callback function 2175 for asynchronous request. (optional) 2176 :param str account_id: The external account number (int) or account ID Guid. (required) 2177 :param ConnectCustomConfiguration connect_custom_configuration: 2178 :return: ConnectCustomConfiguration 2179 If the method is called asynchronously, 2180 returns the request thread. 2181 """ 2182 2183 all_params = ['account_id', 'connect_custom_configuration'] 2184 all_params.append('callback') 2185 all_params.append('_return_http_data_only') 2186 all_params.append('_preload_content') 2187 all_params.append('_request_timeout') 2188 2189 params = locals() 2190 for key, val in iteritems(params['kwargs']): 2191 if key not in all_params: 2192 raise TypeError( 2193 "Got an unexpected keyword argument '%s'" 2194 " to method update_configuration" % key 2195 ) 2196 params[key] = val 2197 del params['kwargs'] 2198 # verify the required parameter 'account_id' is set 2199 if ('account_id' not in params) or (params['account_id'] is None): 2200 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2201 2202 2203 collection_formats = {} 2204 2205 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2206 path_params = {} 2207 if 'account_id' in params: 2208 path_params['accountId'] = params['account_id'] 2209 2210 query_params = {} 2211 2212 header_params = {} 2213 2214 form_params = [] 2215 local_var_files = {} 2216 2217 body_params = None 2218 if 'connect_custom_configuration' in params: 2219 body_params = params['connect_custom_configuration'] 2220 # HTTP header `Accept` 2221 header_params['Accept'] = self.api_client.\ 2222 select_header_accept(['application/json']) 2223 2224 # Authentication setting 2225 auth_settings = [] 2226 2227 return self.api_client.call_api(resource_path, 'PUT', 2228 path_params, 2229 query_params, 2230 header_params, 2231 body=body_params, 2232 post_params=form_params, 2233 files=local_var_files, 2234 response_type='ConnectCustomConfiguration', 2235 auth_settings=auth_settings, 2236 callback=params.get('callback'), 2237 _return_http_data_only=params.get('_return_http_data_only'), 2238 _preload_content=params.get('_preload_content', True), 2239 _request_timeout=params.get('_request_timeout'), 2240 collection_formats=collection_formats) 2241 2242 def update_connect_o_auth_config(self, account_id, **kwargs): 2243 """ 2244 Updates the existing Connect OAuth Config for the account. 2245 This method makes a synchronous HTTP request by default. To make an 2246 asynchronous HTTP request, please define a `callback` function 2247 to be invoked when receiving the response. 2248 >>> def callback_function(response): 2249 >>> pprint(response) 2250 >>> 2251 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2252 2253 :param callback function: The callback function 2254 for asynchronous request. (optional) 2255 :param str account_id: The external account number (int) or account ID Guid. (required) 2256 :param ConnectOAuthConfig connect_o_auth_config: 2257 :return: ConnectOAuthConfig 2258 If the method is called asynchronously, 2259 returns the request thread. 2260 """ 2261 kwargs['_return_http_data_only'] = True 2262 if kwargs.get('callback'): 2263 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2264 else: 2265 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2266 return data 2267 2268 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2269 """ 2270 Updates the existing Connect OAuth Config for the account. 2271 This method makes a synchronous HTTP request by default. To make an 2272 asynchronous HTTP request, please define a `callback` function 2273 to be invoked when receiving the response. 2274 >>> def callback_function(response): 2275 >>> pprint(response) 2276 >>> 2277 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2278 2279 :param callback function: The callback function 2280 for asynchronous request. (optional) 2281 :param str account_id: The external account number (int) or account ID Guid. (required) 2282 :param ConnectOAuthConfig connect_o_auth_config: 2283 :return: ConnectOAuthConfig 2284 If the method is called asynchronously, 2285 returns the request thread. 2286 """ 2287 2288 all_params = ['account_id', 'connect_o_auth_config'] 2289 all_params.append('callback') 2290 all_params.append('_return_http_data_only') 2291 all_params.append('_preload_content') 2292 all_params.append('_request_timeout') 2293 2294 params = locals() 2295 for key, val in iteritems(params['kwargs']): 2296 if key not in all_params: 2297 raise TypeError( 2298 "Got an unexpected keyword argument '%s'" 2299 " to method update_connect_o_auth_config" % key 2300 ) 2301 params[key] = val 2302 del params['kwargs'] 2303 # verify the required parameter 'account_id' is set 2304 if ('account_id' not in params) or (params['account_id'] is None): 2305 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2306 2307 2308 collection_formats = {} 2309 2310 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2311 path_params = {} 2312 if 'account_id' in params: 2313 path_params['accountId'] = params['account_id'] 2314 2315 query_params = {} 2316 2317 header_params = {} 2318 2319 form_params = [] 2320 local_var_files = {} 2321 2322 body_params = None 2323 if 'connect_o_auth_config' in params: 2324 body_params = params['connect_o_auth_config'] 2325 # HTTP header `Accept` 2326 header_params['Accept'] = self.api_client.\ 2327 select_header_accept(['application/json']) 2328 2329 # Authentication setting 2330 auth_settings = [] 2331 2332 return self.api_client.call_api(resource_path, 'PUT', 2333 path_params, 2334 query_params, 2335 header_params, 2336 body=body_params, 2337 post_params=form_params, 2338 files=local_var_files, 2339 response_type='ConnectOAuthConfig', 2340 auth_settings=auth_settings, 2341 callback=params.get('callback'), 2342 _return_http_data_only=params.get('_return_http_data_only'), 2343 _preload_content=params.get('_preload_content', True), 2344 _request_timeout=params.get('_request_timeout'), 2345 collection_formats=collection_formats) 2346 2347 def update_mobile_notifiers(self, account_id, **kwargs): 2348 """ 2349 Reserved 2350 Reserved: 2351 This method makes a synchronous HTTP request by default. To make an 2352 asynchronous HTTP request, please define a `callback` function 2353 to be invoked when receiving the response. 2354 >>> def callback_function(response): 2355 >>> pprint(response) 2356 >>> 2357 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2358 2359 :param callback function: The callback function 2360 for asynchronous request. (optional) 2361 :param str account_id: The external account number (int) or account ID Guid. (required) 2362 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2363 :return: MobileNotifierConfigurationInformation 2364 If the method is called asynchronously, 2365 returns the request thread. 2366 """ 2367 kwargs['_return_http_data_only'] = True 2368 if kwargs.get('callback'): 2369 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2370 else: 2371 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2372 return data 2373 2374 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2375 """ 2376 Reserved 2377 Reserved: 2378 This method makes a synchronous HTTP request by default. To make an 2379 asynchronous HTTP request, please define a `callback` function 2380 to be invoked when receiving the response. 2381 >>> def callback_function(response): 2382 >>> pprint(response) 2383 >>> 2384 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2385 2386 :param callback function: The callback function 2387 for asynchronous request. (optional) 2388 :param str account_id: The external account number (int) or account ID Guid. (required) 2389 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2390 :return: MobileNotifierConfigurationInformation 2391 If the method is called asynchronously, 2392 returns the request thread. 2393 """ 2394 2395 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2396 all_params.append('callback') 2397 all_params.append('_return_http_data_only') 2398 all_params.append('_preload_content') 2399 all_params.append('_request_timeout') 2400 2401 params = locals() 2402 for key, val in iteritems(params['kwargs']): 2403 if key not in all_params: 2404 raise TypeError( 2405 "Got an unexpected keyword argument '%s'" 2406 " to method update_mobile_notifiers" % key 2407 ) 2408 params[key] = val 2409 del params['kwargs'] 2410 # verify the required parameter 'account_id' is set 2411 if ('account_id' not in params) or (params['account_id'] is None): 2412 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2413 2414 2415 collection_formats = {} 2416 2417 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2418 path_params = {} 2419 if 'account_id' in params: 2420 path_params['accountId'] = params['account_id'] 2421 2422 query_params = {} 2423 2424 header_params = {} 2425 2426 form_params = [] 2427 local_var_files = {} 2428 2429 body_params = None 2430 if 'mobile_notifier_configuration_information' in params: 2431 body_params = params['mobile_notifier_configuration_information'] 2432 # HTTP header `Accept` 2433 header_params['Accept'] = self.api_client.\ 2434 select_header_accept(['application/json']) 2435 2436 # Authentication setting 2437 auth_settings = [] 2438 2439 return self.api_client.call_api(resource_path, 'PUT', 2440 path_params, 2441 query_params, 2442 header_params, 2443 body=body_params, 2444 post_params=form_params, 2445 files=local_var_files, 2446 response_type='MobileNotifierConfigurationInformation', 2447 auth_settings=auth_settings, 2448 callback=params.get('callback'), 2449 _return_http_data_only=params.get('_return_http_data_only'), 2450 _preload_content=params.get('_preload_content', True), 2451 _request_timeout=params.get('_request_timeout'), 2452 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
delete_configuration(self, account_id, connect_id, **kwargs)
256 def delete_configuration(self, account_id, connect_id, **kwargs): 257 """ 258 Deletes the specified connect configuration. 259 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 260 This method makes a synchronous HTTP request by default. To make an 261 asynchronous HTTP request, please define a `callback` function 262 to be invoked when receiving the response. 263 >>> def callback_function(response): 264 >>> pprint(response) 265 >>> 266 >>> thread = api.delete_configuration(account_id, connect_id, callback=callback_function) 267 268 :param callback function: The callback function 269 for asynchronous request. (optional) 270 :param str account_id: The external account number (int) or account ID Guid. (required) 271 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 272 :return: None 273 If the method is called asynchronously, 274 returns the request thread. 275 """ 276 kwargs['_return_http_data_only'] = True 277 if kwargs.get('callback'): 278 return self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 279 else: 280 (data) = self.delete_configuration_with_http_info(account_id, connect_id, **kwargs) 281 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)
283 def delete_configuration_with_http_info(self, account_id, connect_id, **kwargs): 284 """ 285 Deletes the specified connect configuration. 286 Deletes the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 287 This method makes a synchronous HTTP request by default. To make an 288 asynchronous HTTP request, please define a `callback` function 289 to be invoked when receiving the response. 290 >>> def callback_function(response): 291 >>> pprint(response) 292 >>> 293 >>> thread = api.delete_configuration_with_http_info(account_id, connect_id, callback=callback_function) 294 295 :param callback function: The callback function 296 for asynchronous request. (optional) 297 :param str account_id: The external account number (int) or account ID Guid. (required) 298 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 299 :return: None 300 If the method is called asynchronously, 301 returns the request thread. 302 """ 303 304 all_params = ['account_id', 'connect_id'] 305 all_params.append('callback') 306 all_params.append('_return_http_data_only') 307 all_params.append('_preload_content') 308 all_params.append('_request_timeout') 309 310 params = locals() 311 for key, val in iteritems(params['kwargs']): 312 if key not in all_params: 313 raise TypeError( 314 "Got an unexpected keyword argument '%s'" 315 " to method delete_configuration" % key 316 ) 317 params[key] = val 318 del params['kwargs'] 319 # verify the required parameter 'account_id' is set 320 if ('account_id' not in params) or (params['account_id'] is None): 321 raise ValueError("Missing the required parameter `account_id` when calling `delete_configuration`") 322 # verify the required parameter 'connect_id' is set 323 if ('connect_id' not in params) or (params['connect_id'] is None): 324 raise ValueError("Missing the required parameter `connect_id` when calling `delete_configuration`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 if 'connect_id' in params: 334 path_params['connectId'] = params['connect_id'] 335 336 query_params = {} 337 338 header_params = {} 339 340 form_params = [] 341 local_var_files = {} 342 343 body_params = None 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'DELETE', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type=None, 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 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)
366 def delete_connect_o_auth_config(self, account_id, **kwargs): 367 """ 368 Sets the Connect OAuth Config for the account. 369 This method makes a synchronous HTTP request by default. To make an 370 asynchronous HTTP request, please define a `callback` function 371 to be invoked when receiving the response. 372 >>> def callback_function(response): 373 >>> pprint(response) 374 >>> 375 >>> thread = api.delete_connect_o_auth_config(account_id, callback=callback_function) 376 377 :param callback function: The callback function 378 for asynchronous request. (optional) 379 :param str account_id: The external account number (int) or account ID Guid. (required) 380 :return: None 381 If the method is called asynchronously, 382 returns the request thread. 383 """ 384 kwargs['_return_http_data_only'] = True 385 if kwargs.get('callback'): 386 return self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 387 else: 388 (data) = self.delete_connect_o_auth_config_with_http_info(account_id, **kwargs) 389 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)
391 def delete_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 392 """ 393 Sets the Connect OAuth Config for the account. 394 This method makes a synchronous HTTP request by default. To make an 395 asynchronous HTTP request, please define a `callback` function 396 to be invoked when receiving the response. 397 >>> def callback_function(response): 398 >>> pprint(response) 399 >>> 400 >>> thread = api.delete_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 401 402 :param callback function: The callback function 403 for asynchronous request. (optional) 404 :param str account_id: The external account number (int) or account ID Guid. (required) 405 :return: None 406 If the method is called asynchronously, 407 returns the request thread. 408 """ 409 410 all_params = ['account_id'] 411 all_params.append('callback') 412 all_params.append('_return_http_data_only') 413 all_params.append('_preload_content') 414 all_params.append('_request_timeout') 415 416 params = locals() 417 for key, val in iteritems(params['kwargs']): 418 if key not in all_params: 419 raise TypeError( 420 "Got an unexpected keyword argument '%s'" 421 " to method delete_connect_o_auth_config" % key 422 ) 423 params[key] = val 424 del params['kwargs'] 425 # verify the required parameter 'account_id' is set 426 if ('account_id' not in params) or (params['account_id'] is None): 427 raise ValueError("Missing the required parameter `account_id` when calling `delete_connect_o_auth_config`") 428 429 430 collection_formats = {} 431 432 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 433 path_params = {} 434 if 'account_id' in params: 435 path_params['accountId'] = params['account_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)
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_event_failure_log(self, account_id, failure_id, **kwargs)
467 def delete_event_failure_log(self, account_id, failure_id, **kwargs): 468 """ 469 Deletes a Connect failure log entry. 470 Deletes the Connect failure log information for the specified entry. 471 This method makes a synchronous HTTP request by default. To make an 472 asynchronous HTTP request, please define a `callback` function 473 to be invoked when receiving the response. 474 >>> def callback_function(response): 475 >>> pprint(response) 476 >>> 477 >>> thread = api.delete_event_failure_log(account_id, failure_id, callback=callback_function) 478 479 :param callback function: The callback function 480 for asynchronous request. (optional) 481 :param str account_id: The external account number (int) or account ID Guid. (required) 482 :param str failure_id: The ID of the failed connect log entry. (required) 483 :return: ConnectDeleteFailureResult 484 If the method is called asynchronously, 485 returns the request thread. 486 """ 487 kwargs['_return_http_data_only'] = True 488 if kwargs.get('callback'): 489 return self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 490 else: 491 (data) = self.delete_event_failure_log_with_http_info(account_id, failure_id, **kwargs) 492 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)
494 def delete_event_failure_log_with_http_info(self, account_id, failure_id, **kwargs): 495 """ 496 Deletes a Connect failure log entry. 497 Deletes the Connect failure log information for the specified entry. 498 This method makes a synchronous HTTP request by default. To make an 499 asynchronous HTTP request, please define a `callback` function 500 to be invoked when receiving the response. 501 >>> def callback_function(response): 502 >>> pprint(response) 503 >>> 504 >>> thread = api.delete_event_failure_log_with_http_info(account_id, failure_id, callback=callback_function) 505 506 :param callback function: The callback function 507 for asynchronous request. (optional) 508 :param str account_id: The external account number (int) or account ID Guid. (required) 509 :param str failure_id: The ID of the failed connect log entry. (required) 510 :return: ConnectDeleteFailureResult 511 If the method is called asynchronously, 512 returns the request thread. 513 """ 514 515 all_params = ['account_id', 'failure_id'] 516 all_params.append('callback') 517 all_params.append('_return_http_data_only') 518 all_params.append('_preload_content') 519 all_params.append('_request_timeout') 520 521 params = locals() 522 for key, val in iteritems(params['kwargs']): 523 if key not in all_params: 524 raise TypeError( 525 "Got an unexpected keyword argument '%s'" 526 " to method delete_event_failure_log" % key 527 ) 528 params[key] = val 529 del params['kwargs'] 530 # verify the required parameter 'account_id' is set 531 if ('account_id' not in params) or (params['account_id'] is None): 532 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_failure_log`") 533 # verify the required parameter 'failure_id' is set 534 if ('failure_id' not in params) or (params['failure_id'] is None): 535 raise ValueError("Missing the required parameter `failure_id` when calling `delete_event_failure_log`") 536 537 538 collection_formats = {} 539 540 resource_path = '/v2.1/accounts/{accountId}/connect/failures/{failureId}'.replace('{format}', 'json') 541 path_params = {} 542 if 'account_id' in params: 543 path_params['accountId'] = params['account_id'] 544 if 'failure_id' in params: 545 path_params['failureId'] = params['failure_id'] 546 547 query_params = {} 548 549 header_params = {} 550 551 form_params = [] 552 local_var_files = {} 553 554 body_params = None 555 # HTTP header `Accept` 556 header_params['Accept'] = self.api_client.\ 557 select_header_accept(['application/json']) 558 559 # Authentication setting 560 auth_settings = [] 561 562 return self.api_client.call_api(resource_path, 'DELETE', 563 path_params, 564 query_params, 565 header_params, 566 body=body_params, 567 post_params=form_params, 568 files=local_var_files, 569 response_type='ConnectDeleteFailureResult', 570 auth_settings=auth_settings, 571 callback=params.get('callback'), 572 _return_http_data_only=params.get('_return_http_data_only'), 573 _preload_content=params.get('_preload_content', True), 574 _request_timeout=params.get('_request_timeout'), 575 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)
577 def delete_event_log(self, account_id, log_id, **kwargs): 578 """ 579 Deletes a specified Connect log entry. 580 Deletes a specified entry from the Connect Log. 581 This method makes a synchronous HTTP request by default. To make an 582 asynchronous HTTP request, please define a `callback` function 583 to be invoked when receiving the response. 584 >>> def callback_function(response): 585 >>> pprint(response) 586 >>> 587 >>> thread = api.delete_event_log(account_id, log_id, callback=callback_function) 588 589 :param callback function: The callback function 590 for asynchronous request. (optional) 591 :param str account_id: The external account number (int) or account ID Guid. (required) 592 :param str log_id: The ID of the connect log entry (required) 593 :return: None 594 If the method is called asynchronously, 595 returns the request thread. 596 """ 597 kwargs['_return_http_data_only'] = True 598 if kwargs.get('callback'): 599 return self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 600 else: 601 (data) = self.delete_event_log_with_http_info(account_id, log_id, **kwargs) 602 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)
604 def delete_event_log_with_http_info(self, account_id, log_id, **kwargs): 605 """ 606 Deletes a specified Connect log entry. 607 Deletes a specified entry from the Connect Log. 608 This method makes a synchronous HTTP request by default. To make an 609 asynchronous HTTP request, please define a `callback` function 610 to be invoked when receiving the response. 611 >>> def callback_function(response): 612 >>> pprint(response) 613 >>> 614 >>> thread = api.delete_event_log_with_http_info(account_id, log_id, callback=callback_function) 615 616 :param callback function: The callback function 617 for asynchronous request. (optional) 618 :param str account_id: The external account number (int) or account ID Guid. (required) 619 :param str log_id: The ID of the connect log entry (required) 620 :return: None 621 If the method is called asynchronously, 622 returns the request thread. 623 """ 624 625 all_params = ['account_id', 'log_id'] 626 all_params.append('callback') 627 all_params.append('_return_http_data_only') 628 all_params.append('_preload_content') 629 all_params.append('_request_timeout') 630 631 params = locals() 632 for key, val in iteritems(params['kwargs']): 633 if key not in all_params: 634 raise TypeError( 635 "Got an unexpected keyword argument '%s'" 636 " to method delete_event_log" % key 637 ) 638 params[key] = val 639 del params['kwargs'] 640 # verify the required parameter 'account_id' is set 641 if ('account_id' not in params) or (params['account_id'] is None): 642 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_log`") 643 # verify the required parameter 'log_id' is set 644 if ('log_id' not in params) or (params['log_id'] is None): 645 raise ValueError("Missing the required parameter `log_id` when calling `delete_event_log`") 646 647 648 collection_formats = {} 649 650 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 651 path_params = {} 652 if 'account_id' in params: 653 path_params['accountId'] = params['account_id'] 654 if 'log_id' in params: 655 path_params['logId'] = params['log_id'] 656 657 query_params = {} 658 659 header_params = {} 660 661 form_params = [] 662 local_var_files = {} 663 664 body_params = None 665 # HTTP header `Accept` 666 header_params['Accept'] = self.api_client.\ 667 select_header_accept(['application/json']) 668 669 # Authentication setting 670 auth_settings = [] 671 672 return self.api_client.call_api(resource_path, 'DELETE', 673 path_params, 674 query_params, 675 header_params, 676 body=body_params, 677 post_params=form_params, 678 files=local_var_files, 679 response_type=None, 680 auth_settings=auth_settings, 681 callback=params.get('callback'), 682 _return_http_data_only=params.get('_return_http_data_only'), 683 _preload_content=params.get('_preload_content', True), 684 _request_timeout=params.get('_request_timeout'), 685 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)
687 def delete_event_logs(self, account_id, **kwargs): 688 """ 689 Gets a list of Connect log entries. 690 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. 691 This method makes a synchronous HTTP request by default. To make an 692 asynchronous HTTP request, please define a `callback` function 693 to be invoked when receiving the response. 694 >>> def callback_function(response): 695 >>> pprint(response) 696 >>> 697 >>> thread = api.delete_event_logs(account_id, callback=callback_function) 698 699 :param callback function: The callback function 700 for asynchronous request. (optional) 701 :param str account_id: The external account number (int) or account ID Guid. (required) 702 :return: None 703 If the method is called asynchronously, 704 returns the request thread. 705 """ 706 kwargs['_return_http_data_only'] = True 707 if kwargs.get('callback'): 708 return self.delete_event_logs_with_http_info(account_id, **kwargs) 709 else: 710 (data) = self.delete_event_logs_with_http_info(account_id, **kwargs) 711 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)
713 def delete_event_logs_with_http_info(self, account_id, **kwargs): 714 """ 715 Gets a list of Connect log entries. 716 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. 717 This method makes a synchronous HTTP request by default. To make an 718 asynchronous HTTP request, please define a `callback` function 719 to be invoked when receiving the response. 720 >>> def callback_function(response): 721 >>> pprint(response) 722 >>> 723 >>> thread = api.delete_event_logs_with_http_info(account_id, callback=callback_function) 724 725 :param callback function: The callback function 726 for asynchronous request. (optional) 727 :param str account_id: The external account number (int) or account ID Guid. (required) 728 :return: None 729 If the method is called asynchronously, 730 returns the request thread. 731 """ 732 733 all_params = ['account_id'] 734 all_params.append('callback') 735 all_params.append('_return_http_data_only') 736 all_params.append('_preload_content') 737 all_params.append('_request_timeout') 738 739 params = locals() 740 for key, val in iteritems(params['kwargs']): 741 if key not in all_params: 742 raise TypeError( 743 "Got an unexpected keyword argument '%s'" 744 " to method delete_event_logs" % key 745 ) 746 params[key] = val 747 del params['kwargs'] 748 # verify the required parameter 'account_id' is set 749 if ('account_id' not in params) or (params['account_id'] is None): 750 raise ValueError("Missing the required parameter `account_id` when calling `delete_event_logs`") 751 752 753 collection_formats = {} 754 755 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 756 path_params = {} 757 if 'account_id' in params: 758 path_params['accountId'] = params['account_id'] 759 760 query_params = {} 761 762 header_params = {} 763 764 form_params = [] 765 local_var_files = {} 766 767 body_params = None 768 # HTTP header `Accept` 769 header_params['Accept'] = self.api_client.\ 770 select_header_accept(['application/json']) 771 772 # Authentication setting 773 auth_settings = [] 774 775 return self.api_client.call_api(resource_path, 'DELETE', 776 path_params, 777 query_params, 778 header_params, 779 body=body_params, 780 post_params=form_params, 781 files=local_var_files, 782 response_type=None, 783 auth_settings=auth_settings, 784 callback=params.get('callback'), 785 _return_http_data_only=params.get('_return_http_data_only'), 786 _preload_content=params.get('_preload_content', True), 787 _request_timeout=params.get('_request_timeout'), 788 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)
790 def delete_mobile_notifiers(self, account_id, **kwargs): 791 """ 792 Reserved 793 Reserved: 794 This method makes a synchronous HTTP request by default. To make an 795 asynchronous HTTP request, please define a `callback` function 796 to be invoked when receiving the response. 797 >>> def callback_function(response): 798 >>> pprint(response) 799 >>> 800 >>> thread = api.delete_mobile_notifiers(account_id, callback=callback_function) 801 802 :param callback function: The callback function 803 for asynchronous request. (optional) 804 :param str account_id: The external account number (int) or account ID Guid. (required) 805 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 806 :return: MobileNotifierConfigurationInformation 807 If the method is called asynchronously, 808 returns the request thread. 809 """ 810 kwargs['_return_http_data_only'] = True 811 if kwargs.get('callback'): 812 return self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 813 else: 814 (data) = self.delete_mobile_notifiers_with_http_info(account_id, **kwargs) 815 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)
817 def delete_mobile_notifiers_with_http_info(self, account_id, **kwargs): 818 """ 819 Reserved 820 Reserved: 821 This method makes a synchronous HTTP request by default. To make an 822 asynchronous HTTP request, please define a `callback` function 823 to be invoked when receiving the response. 824 >>> def callback_function(response): 825 >>> pprint(response) 826 >>> 827 >>> thread = api.delete_mobile_notifiers_with_http_info(account_id, callback=callback_function) 828 829 :param callback function: The callback function 830 for asynchronous request. (optional) 831 :param str account_id: The external account number (int) or account ID Guid. (required) 832 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 833 :return: MobileNotifierConfigurationInformation 834 If the method is called asynchronously, 835 returns the request thread. 836 """ 837 838 all_params = ['account_id', 'mobile_notifier_configuration_information'] 839 all_params.append('callback') 840 all_params.append('_return_http_data_only') 841 all_params.append('_preload_content') 842 all_params.append('_request_timeout') 843 844 params = locals() 845 for key, val in iteritems(params['kwargs']): 846 if key not in all_params: 847 raise TypeError( 848 "Got an unexpected keyword argument '%s'" 849 " to method delete_mobile_notifiers" % key 850 ) 851 params[key] = val 852 del params['kwargs'] 853 # verify the required parameter 'account_id' is set 854 if ('account_id' not in params) or (params['account_id'] is None): 855 raise ValueError("Missing the required parameter `account_id` when calling `delete_mobile_notifiers`") 856 857 858 collection_formats = {} 859 860 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 861 path_params = {} 862 if 'account_id' in params: 863 path_params['accountId'] = params['account_id'] 864 865 query_params = {} 866 867 header_params = {} 868 869 form_params = [] 870 local_var_files = {} 871 872 body_params = None 873 if 'mobile_notifier_configuration_information' in params: 874 body_params = params['mobile_notifier_configuration_information'] 875 # HTTP header `Accept` 876 header_params['Accept'] = self.api_client.\ 877 select_header_accept(['application/json']) 878 879 # Authentication setting 880 auth_settings = [] 881 882 return self.api_client.call_api(resource_path, 'DELETE', 883 path_params, 884 query_params, 885 header_params, 886 body=body_params, 887 post_params=form_params, 888 files=local_var_files, 889 response_type='MobileNotifierConfigurationInformation', 890 auth_settings=auth_settings, 891 callback=params.get('callback'), 892 _return_http_data_only=params.get('_return_http_data_only'), 893 _preload_content=params.get('_preload_content', True), 894 _request_timeout=params.get('_request_timeout'), 895 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)
897 def get_configuration(self, account_id, connect_id, **kwargs): 898 """ 899 Get a Connect Configuration Information 900 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 901 This method makes a synchronous HTTP request by default. To make an 902 asynchronous HTTP request, please define a `callback` function 903 to be invoked when receiving the response. 904 >>> def callback_function(response): 905 >>> pprint(response) 906 >>> 907 >>> thread = api.get_configuration(account_id, connect_id, callback=callback_function) 908 909 :param callback function: The callback function 910 for asynchronous request. (optional) 911 :param str account_id: The external account number (int) or account ID Guid. (required) 912 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 913 :return: ConnectConfigResults 914 If the method is called asynchronously, 915 returns the request thread. 916 """ 917 kwargs['_return_http_data_only'] = True 918 if kwargs.get('callback'): 919 return self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 920 else: 921 (data) = self.get_configuration_with_http_info(account_id, connect_id, **kwargs) 922 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)
924 def get_configuration_with_http_info(self, account_id, connect_id, **kwargs): 925 """ 926 Get a Connect Configuration Information 927 Retrieves the information for the specified DocuSign Connect configuration. ###### Note: Connect must be enabled for your account to use this function. 928 This method makes a synchronous HTTP request by default. To make an 929 asynchronous HTTP request, please define a `callback` function 930 to be invoked when receiving the response. 931 >>> def callback_function(response): 932 >>> pprint(response) 933 >>> 934 >>> thread = api.get_configuration_with_http_info(account_id, connect_id, callback=callback_function) 935 936 :param callback function: The callback function 937 for asynchronous request. (optional) 938 :param str account_id: The external account number (int) or account ID Guid. (required) 939 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 940 :return: ConnectConfigResults 941 If the method is called asynchronously, 942 returns the request thread. 943 """ 944 945 all_params = ['account_id', 'connect_id'] 946 all_params.append('callback') 947 all_params.append('_return_http_data_only') 948 all_params.append('_preload_content') 949 all_params.append('_request_timeout') 950 951 params = locals() 952 for key, val in iteritems(params['kwargs']): 953 if key not in all_params: 954 raise TypeError( 955 "Got an unexpected keyword argument '%s'" 956 " to method get_configuration" % key 957 ) 958 params[key] = val 959 del params['kwargs'] 960 # verify the required parameter 'account_id' is set 961 if ('account_id' not in params) or (params['account_id'] is None): 962 raise ValueError("Missing the required parameter `account_id` when calling `get_configuration`") 963 # verify the required parameter 'connect_id' is set 964 if ('connect_id' not in params) or (params['connect_id'] is None): 965 raise ValueError("Missing the required parameter `connect_id` when calling `get_configuration`") 966 967 968 collection_formats = {} 969 970 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}'.replace('{format}', 'json') 971 path_params = {} 972 if 'account_id' in params: 973 path_params['accountId'] = params['account_id'] 974 if 'connect_id' in params: 975 path_params['connectId'] = params['connect_id'] 976 977 query_params = {} 978 979 header_params = {} 980 981 form_params = [] 982 local_var_files = {} 983 984 body_params = None 985 # HTTP header `Accept` 986 header_params['Accept'] = self.api_client.\ 987 select_header_accept(['application/json']) 988 989 # Authentication setting 990 auth_settings = [] 991 992 return self.api_client.call_api(resource_path, 'GET', 993 path_params, 994 query_params, 995 header_params, 996 body=body_params, 997 post_params=form_params, 998 files=local_var_files, 999 response_type='ConnectConfigResults', 1000 auth_settings=auth_settings, 1001 callback=params.get('callback'), 1002 _return_http_data_only=params.get('_return_http_data_only'), 1003 _preload_content=params.get('_preload_content', True), 1004 _request_timeout=params.get('_request_timeout'), 1005 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)
1007 def get_connect_all_users(self, account_id, connect_id, **kwargs): 1008 """ 1009 Returns all users from the configured Connect service. 1010 1011 This method makes a synchronous HTTP request by default. To make an 1012 asynchronous HTTP request, please define a `callback` function 1013 to be invoked when receiving the response. 1014 >>> def callback_function(response): 1015 >>> pprint(response) 1016 >>> 1017 >>> thread = api.get_connect_all_users(account_id, connect_id, callback=callback_function) 1018 1019 :param callback function: The callback function 1020 for asynchronous request. (optional) 1021 :param str account_id: The external account number (int) or account ID Guid. (required) 1022 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1023 :param str count: 1024 :param str domain_users_only: 1025 :param str email_substring: 1026 :param str start_position: 1027 :param str status: 1028 :param str user_name_substring: 1029 :return: IntegratedConnectUserInfoList 1030 If the method is called asynchronously, 1031 returns the request thread. 1032 """ 1033 kwargs['_return_http_data_only'] = True 1034 if kwargs.get('callback'): 1035 return self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1036 else: 1037 (data) = self.get_connect_all_users_with_http_info(account_id, connect_id, **kwargs) 1038 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)
1040 def get_connect_all_users_with_http_info(self, account_id, connect_id, **kwargs): 1041 """ 1042 Returns all users from the configured Connect service. 1043 1044 This method makes a synchronous HTTP request by default. To make an 1045 asynchronous HTTP request, please define a `callback` function 1046 to be invoked when receiving the response. 1047 >>> def callback_function(response): 1048 >>> pprint(response) 1049 >>> 1050 >>> thread = api.get_connect_all_users_with_http_info(account_id, connect_id, callback=callback_function) 1051 1052 :param callback function: The callback function 1053 for asynchronous request. (optional) 1054 :param str account_id: The external account number (int) or account ID Guid. (required) 1055 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1056 :param str count: 1057 :param str domain_users_only: 1058 :param str email_substring: 1059 :param str start_position: 1060 :param str status: 1061 :param str user_name_substring: 1062 :return: IntegratedConnectUserInfoList 1063 If the method is called asynchronously, 1064 returns the request thread. 1065 """ 1066 1067 all_params = ['account_id', 'connect_id', 'count', 'domain_users_only', 'email_substring', 'start_position', 'status', 'user_name_substring'] 1068 all_params.append('callback') 1069 all_params.append('_return_http_data_only') 1070 all_params.append('_preload_content') 1071 all_params.append('_request_timeout') 1072 1073 params = locals() 1074 for key, val in iteritems(params['kwargs']): 1075 if key not in all_params: 1076 raise TypeError( 1077 "Got an unexpected keyword argument '%s'" 1078 " to method get_connect_all_users" % key 1079 ) 1080 params[key] = val 1081 del params['kwargs'] 1082 # verify the required parameter 'account_id' is set 1083 if ('account_id' not in params) or (params['account_id'] is None): 1084 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_all_users`") 1085 # verify the required parameter 'connect_id' is set 1086 if ('connect_id' not in params) or (params['connect_id'] is None): 1087 raise ValueError("Missing the required parameter `connect_id` when calling `get_connect_all_users`") 1088 1089 1090 collection_formats = {} 1091 1092 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/all/users'.replace('{format}', 'json') 1093 path_params = {} 1094 if 'account_id' in params: 1095 path_params['accountId'] = params['account_id'] 1096 if 'connect_id' in params: 1097 path_params['connectId'] = params['connect_id'] 1098 1099 query_params = {} 1100 if 'count' in params: 1101 query_params['count'] = params['count'] 1102 if 'domain_users_only' in params: 1103 query_params['domain_users_only'] = params['domain_users_only'] 1104 if 'email_substring' in params: 1105 query_params['email_substring'] = params['email_substring'] 1106 if 'start_position' in params: 1107 query_params['start_position'] = params['start_position'] 1108 if 'status' in params: 1109 query_params['status'] = params['status'] 1110 if 'user_name_substring' in params: 1111 query_params['user_name_substring'] = params['user_name_substring'] 1112 1113 header_params = {} 1114 1115 form_params = [] 1116 local_var_files = {} 1117 1118 body_params = None 1119 # HTTP header `Accept` 1120 header_params['Accept'] = self.api_client.\ 1121 select_header_accept(['application/json']) 1122 1123 # Authentication setting 1124 auth_settings = [] 1125 1126 return self.api_client.call_api(resource_path, 'GET', 1127 path_params, 1128 query_params, 1129 header_params, 1130 body=body_params, 1131 post_params=form_params, 1132 files=local_var_files, 1133 response_type='IntegratedConnectUserInfoList', 1134 auth_settings=auth_settings, 1135 callback=params.get('callback'), 1136 _return_http_data_only=params.get('_return_http_data_only'), 1137 _preload_content=params.get('_preload_content', True), 1138 _request_timeout=params.get('_request_timeout'), 1139 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)
1141 def get_connect_o_auth_config(self, account_id, **kwargs): 1142 """ 1143 Sets the Connect OAuth Config for the account. 1144 This method makes a synchronous HTTP request by default. To make an 1145 asynchronous HTTP request, please define a `callback` function 1146 to be invoked when receiving the response. 1147 >>> def callback_function(response): 1148 >>> pprint(response) 1149 >>> 1150 >>> thread = api.get_connect_o_auth_config(account_id, callback=callback_function) 1151 1152 :param callback function: The callback function 1153 for asynchronous request. (optional) 1154 :param str account_id: The external account number (int) or account ID Guid. (required) 1155 :return: ConnectOAuthConfig 1156 If the method is called asynchronously, 1157 returns the request thread. 1158 """ 1159 kwargs['_return_http_data_only'] = True 1160 if kwargs.get('callback'): 1161 return self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1162 else: 1163 (data) = self.get_connect_o_auth_config_with_http_info(account_id, **kwargs) 1164 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)
1166 def get_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 1167 """ 1168 Sets the Connect OAuth Config for the account. 1169 This method makes a synchronous HTTP request by default. To make an 1170 asynchronous HTTP request, please define a `callback` function 1171 to be invoked when receiving the response. 1172 >>> def callback_function(response): 1173 >>> pprint(response) 1174 >>> 1175 >>> thread = api.get_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 1176 1177 :param callback function: The callback function 1178 for asynchronous request. (optional) 1179 :param str account_id: The external account number (int) or account ID Guid. (required) 1180 :return: ConnectOAuthConfig 1181 If the method is called asynchronously, 1182 returns the request thread. 1183 """ 1184 1185 all_params = ['account_id'] 1186 all_params.append('callback') 1187 all_params.append('_return_http_data_only') 1188 all_params.append('_preload_content') 1189 all_params.append('_request_timeout') 1190 1191 params = locals() 1192 for key, val in iteritems(params['kwargs']): 1193 if key not in all_params: 1194 raise TypeError( 1195 "Got an unexpected keyword argument '%s'" 1196 " to method get_connect_o_auth_config" % key 1197 ) 1198 params[key] = val 1199 del params['kwargs'] 1200 # verify the required parameter 'account_id' is set 1201 if ('account_id' not in params) or (params['account_id'] is None): 1202 raise ValueError("Missing the required parameter `account_id` when calling `get_connect_o_auth_config`") 1203 1204 1205 collection_formats = {} 1206 1207 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 1208 path_params = {} 1209 if 'account_id' in params: 1210 path_params['accountId'] = params['account_id'] 1211 1212 query_params = {} 1213 1214 header_params = {} 1215 1216 form_params = [] 1217 local_var_files = {} 1218 1219 body_params = None 1220 # HTTP header `Accept` 1221 header_params['Accept'] = self.api_client.\ 1222 select_header_accept(['application/json']) 1223 1224 # Authentication setting 1225 auth_settings = [] 1226 1227 return self.api_client.call_api(resource_path, 'GET', 1228 path_params, 1229 query_params, 1230 header_params, 1231 body=body_params, 1232 post_params=form_params, 1233 files=local_var_files, 1234 response_type='ConnectOAuthConfig', 1235 auth_settings=auth_settings, 1236 callback=params.get('callback'), 1237 _return_http_data_only=params.get('_return_http_data_only'), 1238 _preload_content=params.get('_preload_content', True), 1239 _request_timeout=params.get('_request_timeout'), 1240 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_event_log(self, account_id, log_id, **kwargs)
1242 def get_event_log(self, account_id, log_id, **kwargs): 1243 """ 1244 Get the specified Connect log entry. 1245 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. 1246 This method makes a synchronous HTTP request by default. To make an 1247 asynchronous HTTP request, please define a `callback` function 1248 to be invoked when receiving the response. 1249 >>> def callback_function(response): 1250 >>> pprint(response) 1251 >>> 1252 >>> thread = api.get_event_log(account_id, log_id, callback=callback_function) 1253 1254 :param callback function: The callback function 1255 for asynchronous request. (optional) 1256 :param str account_id: The external account number (int) or account ID Guid. (required) 1257 :param str log_id: The ID of the connect log entry (required) 1258 :param str additional_info: When true, the connectDebugLog information is included in the response. 1259 :return: ConnectLog 1260 If the method is called asynchronously, 1261 returns the request thread. 1262 """ 1263 kwargs['_return_http_data_only'] = True 1264 if kwargs.get('callback'): 1265 return self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1266 else: 1267 (data) = self.get_event_log_with_http_info(account_id, log_id, **kwargs) 1268 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)
1270 def get_event_log_with_http_info(self, account_id, log_id, **kwargs): 1271 """ 1272 Get the specified Connect log entry. 1273 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. 1274 This method makes a synchronous HTTP request by default. To make an 1275 asynchronous HTTP request, please define a `callback` function 1276 to be invoked when receiving the response. 1277 >>> def callback_function(response): 1278 >>> pprint(response) 1279 >>> 1280 >>> thread = api.get_event_log_with_http_info(account_id, log_id, callback=callback_function) 1281 1282 :param callback function: The callback function 1283 for asynchronous request. (optional) 1284 :param str account_id: The external account number (int) or account ID Guid. (required) 1285 :param str log_id: The ID of the connect log entry (required) 1286 :param str additional_info: When true, the connectDebugLog information is included in the response. 1287 :return: ConnectLog 1288 If the method is called asynchronously, 1289 returns the request thread. 1290 """ 1291 1292 all_params = ['account_id', 'log_id', 'additional_info'] 1293 all_params.append('callback') 1294 all_params.append('_return_http_data_only') 1295 all_params.append('_preload_content') 1296 all_params.append('_request_timeout') 1297 1298 params = locals() 1299 for key, val in iteritems(params['kwargs']): 1300 if key not in all_params: 1301 raise TypeError( 1302 "Got an unexpected keyword argument '%s'" 1303 " to method get_event_log" % key 1304 ) 1305 params[key] = val 1306 del params['kwargs'] 1307 # verify the required parameter 'account_id' is set 1308 if ('account_id' not in params) or (params['account_id'] is None): 1309 raise ValueError("Missing the required parameter `account_id` when calling `get_event_log`") 1310 # verify the required parameter 'log_id' is set 1311 if ('log_id' not in params) or (params['log_id'] is None): 1312 raise ValueError("Missing the required parameter `log_id` when calling `get_event_log`") 1313 1314 1315 collection_formats = {} 1316 1317 resource_path = '/v2.1/accounts/{accountId}/connect/logs/{logId}'.replace('{format}', 'json') 1318 path_params = {} 1319 if 'account_id' in params: 1320 path_params['accountId'] = params['account_id'] 1321 if 'log_id' in params: 1322 path_params['logId'] = params['log_id'] 1323 1324 query_params = {} 1325 if 'additional_info' in params: 1326 query_params['additional_info'] = params['additional_info'] 1327 1328 header_params = {} 1329 1330 form_params = [] 1331 local_var_files = {} 1332 1333 body_params = None 1334 # HTTP header `Accept` 1335 header_params['Accept'] = self.api_client.\ 1336 select_header_accept(['application/json']) 1337 1338 # Authentication setting 1339 auth_settings = [] 1340 1341 return self.api_client.call_api(resource_path, 'GET', 1342 path_params, 1343 query_params, 1344 header_params, 1345 body=body_params, 1346 post_params=form_params, 1347 files=local_var_files, 1348 response_type='ConnectLog', 1349 auth_settings=auth_settings, 1350 callback=params.get('callback'), 1351 _return_http_data_only=params.get('_return_http_data_only'), 1352 _preload_content=params.get('_preload_content', True), 1353 _request_timeout=params.get('_request_timeout'), 1354 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)
1356 def list_configurations(self, account_id, **kwargs): 1357 """ 1358 Get Connect Configuration Information 1359 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. 1360 This method makes a synchronous HTTP request by default. To make an 1361 asynchronous HTTP request, please define a `callback` function 1362 to be invoked when receiving the response. 1363 >>> def callback_function(response): 1364 >>> pprint(response) 1365 >>> 1366 >>> thread = api.list_configurations(account_id, callback=callback_function) 1367 1368 :param callback function: The callback function 1369 for asynchronous request. (optional) 1370 :param str account_id: The external account number (int) or account ID Guid. (required) 1371 :return: ConnectConfigResults 1372 If the method is called asynchronously, 1373 returns the request thread. 1374 """ 1375 kwargs['_return_http_data_only'] = True 1376 if kwargs.get('callback'): 1377 return self.list_configurations_with_http_info(account_id, **kwargs) 1378 else: 1379 (data) = self.list_configurations_with_http_info(account_id, **kwargs) 1380 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)
1382 def list_configurations_with_http_info(self, account_id, **kwargs): 1383 """ 1384 Get Connect Configuration Information 1385 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. 1386 This method makes a synchronous HTTP request by default. To make an 1387 asynchronous HTTP request, please define a `callback` function 1388 to be invoked when receiving the response. 1389 >>> def callback_function(response): 1390 >>> pprint(response) 1391 >>> 1392 >>> thread = api.list_configurations_with_http_info(account_id, callback=callback_function) 1393 1394 :param callback function: The callback function 1395 for asynchronous request. (optional) 1396 :param str account_id: The external account number (int) or account ID Guid. (required) 1397 :return: ConnectConfigResults 1398 If the method is called asynchronously, 1399 returns the request thread. 1400 """ 1401 1402 all_params = ['account_id'] 1403 all_params.append('callback') 1404 all_params.append('_return_http_data_only') 1405 all_params.append('_preload_content') 1406 all_params.append('_request_timeout') 1407 1408 params = locals() 1409 for key, val in iteritems(params['kwargs']): 1410 if key not in all_params: 1411 raise TypeError( 1412 "Got an unexpected keyword argument '%s'" 1413 " to method list_configurations" % key 1414 ) 1415 params[key] = val 1416 del params['kwargs'] 1417 # verify the required parameter 'account_id' is set 1418 if ('account_id' not in params) or (params['account_id'] is None): 1419 raise ValueError("Missing the required parameter `account_id` when calling `list_configurations`") 1420 1421 1422 collection_formats = {} 1423 1424 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 1425 path_params = {} 1426 if 'account_id' in params: 1427 path_params['accountId'] = params['account_id'] 1428 1429 query_params = {} 1430 1431 header_params = {} 1432 1433 form_params = [] 1434 local_var_files = {} 1435 1436 body_params = None 1437 # HTTP header `Accept` 1438 header_params['Accept'] = self.api_client.\ 1439 select_header_accept(['application/json']) 1440 1441 # Authentication setting 1442 auth_settings = [] 1443 1444 return self.api_client.call_api(resource_path, 'GET', 1445 path_params, 1446 query_params, 1447 header_params, 1448 body=body_params, 1449 post_params=form_params, 1450 files=local_var_files, 1451 response_type='ConnectConfigResults', 1452 auth_settings=auth_settings, 1453 callback=params.get('callback'), 1454 _return_http_data_only=params.get('_return_http_data_only'), 1455 _preload_content=params.get('_preload_content', True), 1456 _request_timeout=params.get('_request_timeout'), 1457 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)
1459 def list_event_failure_logs(self, account_id, **kwargs): 1460 """ 1461 Gets the Connect failure log information. 1462 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1463 This method makes a synchronous HTTP request by default. To make an 1464 asynchronous HTTP request, please define a `callback` function 1465 to be invoked when receiving the response. 1466 >>> def callback_function(response): 1467 >>> pprint(response) 1468 >>> 1469 >>> thread = api.list_event_failure_logs(account_id, callback=callback_function) 1470 1471 :param callback function: The callback function 1472 for asynchronous request. (optional) 1473 :param str account_id: The external account number (int) or account ID Guid. (required) 1474 :param str from_date: 1475 :param str to_date: 1476 :return: ConnectLogs 1477 If the method is called asynchronously, 1478 returns the request thread. 1479 """ 1480 kwargs['_return_http_data_only'] = True 1481 if kwargs.get('callback'): 1482 return self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1483 else: 1484 (data) = self.list_event_failure_logs_with_http_info(account_id, **kwargs) 1485 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)
1487 def list_event_failure_logs_with_http_info(self, account_id, **kwargs): 1488 """ 1489 Gets the Connect failure log information. 1490 Retrieves the Connect Failure Log information. It can be used to determine which envelopes failed to post, so a republish request can be created. 1491 This method makes a synchronous HTTP request by default. To make an 1492 asynchronous HTTP request, please define a `callback` function 1493 to be invoked when receiving the response. 1494 >>> def callback_function(response): 1495 >>> pprint(response) 1496 >>> 1497 >>> thread = api.list_event_failure_logs_with_http_info(account_id, callback=callback_function) 1498 1499 :param callback function: The callback function 1500 for asynchronous request. (optional) 1501 :param str account_id: The external account number (int) or account ID Guid. (required) 1502 :param str from_date: 1503 :param str to_date: 1504 :return: ConnectLogs 1505 If the method is called asynchronously, 1506 returns the request thread. 1507 """ 1508 1509 all_params = ['account_id', 'from_date', 'to_date'] 1510 all_params.append('callback') 1511 all_params.append('_return_http_data_only') 1512 all_params.append('_preload_content') 1513 all_params.append('_request_timeout') 1514 1515 params = locals() 1516 for key, val in iteritems(params['kwargs']): 1517 if key not in all_params: 1518 raise TypeError( 1519 "Got an unexpected keyword argument '%s'" 1520 " to method list_event_failure_logs" % key 1521 ) 1522 params[key] = val 1523 del params['kwargs'] 1524 # verify the required parameter 'account_id' is set 1525 if ('account_id' not in params) or (params['account_id'] is None): 1526 raise ValueError("Missing the required parameter `account_id` when calling `list_event_failure_logs`") 1527 1528 1529 collection_formats = {} 1530 1531 resource_path = '/v2.1/accounts/{accountId}/connect/failures'.replace('{format}', 'json') 1532 path_params = {} 1533 if 'account_id' in params: 1534 path_params['accountId'] = params['account_id'] 1535 1536 query_params = {} 1537 if 'from_date' in params: 1538 query_params['from_date'] = params['from_date'] 1539 if 'to_date' in params: 1540 query_params['to_date'] = params['to_date'] 1541 1542 header_params = {} 1543 1544 form_params = [] 1545 local_var_files = {} 1546 1547 body_params = None 1548 # HTTP header `Accept` 1549 header_params['Accept'] = self.api_client.\ 1550 select_header_accept(['application/json']) 1551 1552 # Authentication setting 1553 auth_settings = [] 1554 1555 return self.api_client.call_api(resource_path, 'GET', 1556 path_params, 1557 query_params, 1558 header_params, 1559 body=body_params, 1560 post_params=form_params, 1561 files=local_var_files, 1562 response_type='ConnectLogs', 1563 auth_settings=auth_settings, 1564 callback=params.get('callback'), 1565 _return_http_data_only=params.get('_return_http_data_only'), 1566 _preload_content=params.get('_preload_content', True), 1567 _request_timeout=params.get('_request_timeout'), 1568 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)
1570 def list_event_logs(self, account_id, **kwargs): 1571 """ 1572 Gets the Connect log. 1573 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. 1574 This method makes a synchronous HTTP request by default. To make an 1575 asynchronous HTTP request, please define a `callback` function 1576 to be invoked when receiving the response. 1577 >>> def callback_function(response): 1578 >>> pprint(response) 1579 >>> 1580 >>> thread = api.list_event_logs(account_id, callback=callback_function) 1581 1582 :param callback function: The callback function 1583 for asynchronous request. (optional) 1584 :param str account_id: The external account number (int) or account ID Guid. (required) 1585 :param str from_date: 1586 :param str to_date: 1587 :return: ConnectLogs 1588 If the method is called asynchronously, 1589 returns the request thread. 1590 """ 1591 kwargs['_return_http_data_only'] = True 1592 if kwargs.get('callback'): 1593 return self.list_event_logs_with_http_info(account_id, **kwargs) 1594 else: 1595 (data) = self.list_event_logs_with_http_info(account_id, **kwargs) 1596 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)
1598 def list_event_logs_with_http_info(self, account_id, **kwargs): 1599 """ 1600 Gets the Connect log. 1601 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. 1602 This method makes a synchronous HTTP request by default. To make an 1603 asynchronous HTTP request, please define a `callback` function 1604 to be invoked when receiving the response. 1605 >>> def callback_function(response): 1606 >>> pprint(response) 1607 >>> 1608 >>> thread = api.list_event_logs_with_http_info(account_id, callback=callback_function) 1609 1610 :param callback function: The callback function 1611 for asynchronous request. (optional) 1612 :param str account_id: The external account number (int) or account ID Guid. (required) 1613 :param str from_date: 1614 :param str to_date: 1615 :return: ConnectLogs 1616 If the method is called asynchronously, 1617 returns the request thread. 1618 """ 1619 1620 all_params = ['account_id', 'from_date', 'to_date'] 1621 all_params.append('callback') 1622 all_params.append('_return_http_data_only') 1623 all_params.append('_preload_content') 1624 all_params.append('_request_timeout') 1625 1626 params = locals() 1627 for key, val in iteritems(params['kwargs']): 1628 if key not in all_params: 1629 raise TypeError( 1630 "Got an unexpected keyword argument '%s'" 1631 " to method list_event_logs" % key 1632 ) 1633 params[key] = val 1634 del params['kwargs'] 1635 # verify the required parameter 'account_id' is set 1636 if ('account_id' not in params) or (params['account_id'] is None): 1637 raise ValueError("Missing the required parameter `account_id` when calling `list_event_logs`") 1638 1639 1640 collection_formats = {} 1641 1642 resource_path = '/v2.1/accounts/{accountId}/connect/logs'.replace('{format}', 'json') 1643 path_params = {} 1644 if 'account_id' in params: 1645 path_params['accountId'] = params['account_id'] 1646 1647 query_params = {} 1648 if 'from_date' in params: 1649 query_params['from_date'] = params['from_date'] 1650 if 'to_date' in params: 1651 query_params['to_date'] = params['to_date'] 1652 1653 header_params = {} 1654 1655 form_params = [] 1656 local_var_files = {} 1657 1658 body_params = None 1659 # HTTP header `Accept` 1660 header_params['Accept'] = self.api_client.\ 1661 select_header_accept(['application/json']) 1662 1663 # Authentication setting 1664 auth_settings = [] 1665 1666 return self.api_client.call_api(resource_path, 'GET', 1667 path_params, 1668 query_params, 1669 header_params, 1670 body=body_params, 1671 post_params=form_params, 1672 files=local_var_files, 1673 response_type='ConnectLogs', 1674 auth_settings=auth_settings, 1675 callback=params.get('callback'), 1676 _return_http_data_only=params.get('_return_http_data_only'), 1677 _preload_content=params.get('_preload_content', True), 1678 _request_timeout=params.get('_request_timeout'), 1679 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)
1681 def list_mobile_notifiers(self, account_id, **kwargs): 1682 """ 1683 Reserved 1684 Reserved: 1685 This method makes a synchronous HTTP request by default. To make an 1686 asynchronous HTTP request, please define a `callback` function 1687 to be invoked when receiving the response. 1688 >>> def callback_function(response): 1689 >>> pprint(response) 1690 >>> 1691 >>> thread = api.list_mobile_notifiers(account_id, callback=callback_function) 1692 1693 :param callback function: The callback function 1694 for asynchronous request. (optional) 1695 :param str account_id: The external account number (int) or account ID Guid. (required) 1696 :return: MobileNotifierConfigurationInformation 1697 If the method is called asynchronously, 1698 returns the request thread. 1699 """ 1700 kwargs['_return_http_data_only'] = True 1701 if kwargs.get('callback'): 1702 return self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1703 else: 1704 (data) = self.list_mobile_notifiers_with_http_info(account_id, **kwargs) 1705 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)
1707 def list_mobile_notifiers_with_http_info(self, account_id, **kwargs): 1708 """ 1709 Reserved 1710 Reserved: 1711 This method makes a synchronous HTTP request by default. To make an 1712 asynchronous HTTP request, please define a `callback` function 1713 to be invoked when receiving the response. 1714 >>> def callback_function(response): 1715 >>> pprint(response) 1716 >>> 1717 >>> thread = api.list_mobile_notifiers_with_http_info(account_id, callback=callback_function) 1718 1719 :param callback function: The callback function 1720 for asynchronous request. (optional) 1721 :param str account_id: The external account number (int) or account ID Guid. (required) 1722 :return: MobileNotifierConfigurationInformation 1723 If the method is called asynchronously, 1724 returns the request thread. 1725 """ 1726 1727 all_params = ['account_id'] 1728 all_params.append('callback') 1729 all_params.append('_return_http_data_only') 1730 all_params.append('_preload_content') 1731 all_params.append('_request_timeout') 1732 1733 params = locals() 1734 for key, val in iteritems(params['kwargs']): 1735 if key not in all_params: 1736 raise TypeError( 1737 "Got an unexpected keyword argument '%s'" 1738 " to method list_mobile_notifiers" % key 1739 ) 1740 params[key] = val 1741 del params['kwargs'] 1742 # verify the required parameter 'account_id' is set 1743 if ('account_id' not in params) or (params['account_id'] is None): 1744 raise ValueError("Missing the required parameter `account_id` when calling `list_mobile_notifiers`") 1745 1746 1747 collection_formats = {} 1748 1749 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 1750 path_params = {} 1751 if 'account_id' in params: 1752 path_params['accountId'] = params['account_id'] 1753 1754 query_params = {} 1755 1756 header_params = {} 1757 1758 form_params = [] 1759 local_var_files = {} 1760 1761 body_params = None 1762 # HTTP header `Accept` 1763 header_params['Accept'] = self.api_client.\ 1764 select_header_accept(['application/json']) 1765 1766 # Authentication setting 1767 auth_settings = [] 1768 1769 return self.api_client.call_api(resource_path, 'GET', 1770 path_params, 1771 query_params, 1772 header_params, 1773 body=body_params, 1774 post_params=form_params, 1775 files=local_var_files, 1776 response_type='MobileNotifierConfigurationInformation', 1777 auth_settings=auth_settings, 1778 callback=params.get('callback'), 1779 _return_http_data_only=params.get('_return_http_data_only'), 1780 _preload_content=params.get('_preload_content', True), 1781 _request_timeout=params.get('_request_timeout'), 1782 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)
1784 def list_users(self, account_id, connect_id, **kwargs): 1785 """ 1786 Returns users from the configured Connect service. 1787 Returns users from the configured Connect service. 1788 This method makes a synchronous HTTP request by default. To make an 1789 asynchronous HTTP request, please define a `callback` function 1790 to be invoked when receiving the response. 1791 >>> def callback_function(response): 1792 >>> pprint(response) 1793 >>> 1794 >>> thread = api.list_users(account_id, connect_id, callback=callback_function) 1795 1796 :param callback function: The callback function 1797 for asynchronous request. (optional) 1798 :param str account_id: The external account number (int) or account ID Guid. (required) 1799 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1800 :param str count: 1801 :param str email_substring: 1802 :param str list_included_users: 1803 :param str start_position: 1804 :param str status: 1805 :param str user_name_substring: 1806 :return: IntegratedUserInfoList 1807 If the method is called asynchronously, 1808 returns the request thread. 1809 """ 1810 kwargs['_return_http_data_only'] = True 1811 if kwargs.get('callback'): 1812 return self.list_users_with_http_info(account_id, connect_id, **kwargs) 1813 else: 1814 (data) = self.list_users_with_http_info(account_id, connect_id, **kwargs) 1815 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)
1817 def list_users_with_http_info(self, account_id, connect_id, **kwargs): 1818 """ 1819 Returns users from the configured Connect service. 1820 Returns users from the configured Connect service. 1821 This method makes a synchronous HTTP request by default. To make an 1822 asynchronous HTTP request, please define a `callback` function 1823 to be invoked when receiving the response. 1824 >>> def callback_function(response): 1825 >>> pprint(response) 1826 >>> 1827 >>> thread = api.list_users_with_http_info(account_id, connect_id, callback=callback_function) 1828 1829 :param callback function: The callback function 1830 for asynchronous request. (optional) 1831 :param str account_id: The external account number (int) or account ID Guid. (required) 1832 :param str connect_id: The ID of the custom Connect configuration being accessed. (required) 1833 :param str count: 1834 :param str email_substring: 1835 :param str list_included_users: 1836 :param str start_position: 1837 :param str status: 1838 :param str user_name_substring: 1839 :return: IntegratedUserInfoList 1840 If the method is called asynchronously, 1841 returns the request thread. 1842 """ 1843 1844 all_params = ['account_id', 'connect_id', 'count', 'email_substring', 'list_included_users', 'start_position', 'status', 'user_name_substring'] 1845 all_params.append('callback') 1846 all_params.append('_return_http_data_only') 1847 all_params.append('_preload_content') 1848 all_params.append('_request_timeout') 1849 1850 params = locals() 1851 for key, val in iteritems(params['kwargs']): 1852 if key not in all_params: 1853 raise TypeError( 1854 "Got an unexpected keyword argument '%s'" 1855 " to method list_users" % key 1856 ) 1857 params[key] = val 1858 del params['kwargs'] 1859 # verify the required parameter 'account_id' is set 1860 if ('account_id' not in params) or (params['account_id'] is None): 1861 raise ValueError("Missing the required parameter `account_id` when calling `list_users`") 1862 # verify the required parameter 'connect_id' is set 1863 if ('connect_id' not in params) or (params['connect_id'] is None): 1864 raise ValueError("Missing the required parameter `connect_id` when calling `list_users`") 1865 1866 1867 collection_formats = {} 1868 1869 resource_path = '/v2.1/accounts/{accountId}/connect/{connectId}/users'.replace('{format}', 'json') 1870 path_params = {} 1871 if 'account_id' in params: 1872 path_params['accountId'] = params['account_id'] 1873 if 'connect_id' in params: 1874 path_params['connectId'] = params['connect_id'] 1875 1876 query_params = {} 1877 if 'count' in params: 1878 query_params['count'] = params['count'] 1879 if 'email_substring' in params: 1880 query_params['email_substring'] = params['email_substring'] 1881 if 'list_included_users' in params: 1882 query_params['list_included_users'] = params['list_included_users'] 1883 if 'start_position' in params: 1884 query_params['start_position'] = params['start_position'] 1885 if 'status' in params: 1886 query_params['status'] = params['status'] 1887 if 'user_name_substring' in params: 1888 query_params['user_name_substring'] = params['user_name_substring'] 1889 1890 header_params = {} 1891 1892 form_params = [] 1893 local_var_files = {} 1894 1895 body_params = None 1896 # HTTP header `Accept` 1897 header_params['Accept'] = self.api_client.\ 1898 select_header_accept(['application/json']) 1899 1900 # Authentication setting 1901 auth_settings = [] 1902 1903 return self.api_client.call_api(resource_path, 'GET', 1904 path_params, 1905 query_params, 1906 header_params, 1907 body=body_params, 1908 post_params=form_params, 1909 files=local_var_files, 1910 response_type='IntegratedUserInfoList', 1911 auth_settings=auth_settings, 1912 callback=params.get('callback'), 1913 _return_http_data_only=params.get('_return_http_data_only'), 1914 _preload_content=params.get('_preload_content', True), 1915 _request_timeout=params.get('_request_timeout'), 1916 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)
1918 def retry_event_for_envelope(self, account_id, envelope_id, **kwargs): 1919 """ 1920 Republishes Connect information for the specified envelope. 1921 Republishes Connect information for the specified envelope. 1922 This method makes a synchronous HTTP request by default. To make an 1923 asynchronous HTTP request, please define a `callback` function 1924 to be invoked when receiving the response. 1925 >>> def callback_function(response): 1926 >>> pprint(response) 1927 >>> 1928 >>> thread = api.retry_event_for_envelope(account_id, envelope_id, callback=callback_function) 1929 1930 :param callback function: The callback function 1931 for asynchronous request. (optional) 1932 :param str account_id: The external account number (int) or account ID Guid. (required) 1933 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1934 :return: ConnectFailureResults 1935 If the method is called asynchronously, 1936 returns the request thread. 1937 """ 1938 kwargs['_return_http_data_only'] = True 1939 if kwargs.get('callback'): 1940 return self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1941 else: 1942 (data) = self.retry_event_for_envelope_with_http_info(account_id, envelope_id, **kwargs) 1943 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)
1945 def retry_event_for_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 1946 """ 1947 Republishes Connect information for the specified envelope. 1948 Republishes Connect information for the specified envelope. 1949 This method makes a synchronous HTTP request by default. To make an 1950 asynchronous HTTP request, please define a `callback` function 1951 to be invoked when receiving the response. 1952 >>> def callback_function(response): 1953 >>> pprint(response) 1954 >>> 1955 >>> thread = api.retry_event_for_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 1956 1957 :param callback function: The callback function 1958 for asynchronous request. (optional) 1959 :param str account_id: The external account number (int) or account ID Guid. (required) 1960 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1961 :return: ConnectFailureResults 1962 If the method is called asynchronously, 1963 returns the request thread. 1964 """ 1965 1966 all_params = ['account_id', 'envelope_id'] 1967 all_params.append('callback') 1968 all_params.append('_return_http_data_only') 1969 all_params.append('_preload_content') 1970 all_params.append('_request_timeout') 1971 1972 params = locals() 1973 for key, val in iteritems(params['kwargs']): 1974 if key not in all_params: 1975 raise TypeError( 1976 "Got an unexpected keyword argument '%s'" 1977 " to method retry_event_for_envelope" % key 1978 ) 1979 params[key] = val 1980 del params['kwargs'] 1981 # verify the required parameter 'account_id' is set 1982 if ('account_id' not in params) or (params['account_id'] is None): 1983 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelope`") 1984 # verify the required parameter 'envelope_id' is set 1985 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1986 raise ValueError("Missing the required parameter `envelope_id` when calling `retry_event_for_envelope`") 1987 1988 1989 collection_formats = {} 1990 1991 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/{envelopeId}/retry_queue'.replace('{format}', 'json') 1992 path_params = {} 1993 if 'account_id' in params: 1994 path_params['accountId'] = params['account_id'] 1995 if 'envelope_id' in params: 1996 path_params['envelopeId'] = params['envelope_id'] 1997 1998 query_params = {} 1999 2000 header_params = {} 2001 2002 form_params = [] 2003 local_var_files = {} 2004 2005 body_params = None 2006 # HTTP header `Accept` 2007 header_params['Accept'] = self.api_client.\ 2008 select_header_accept(['application/json']) 2009 2010 # Authentication setting 2011 auth_settings = [] 2012 2013 return self.api_client.call_api(resource_path, 'PUT', 2014 path_params, 2015 query_params, 2016 header_params, 2017 body=body_params, 2018 post_params=form_params, 2019 files=local_var_files, 2020 response_type='ConnectFailureResults', 2021 auth_settings=auth_settings, 2022 callback=params.get('callback'), 2023 _return_http_data_only=params.get('_return_http_data_only'), 2024 _preload_content=params.get('_preload_content', True), 2025 _request_timeout=params.get('_request_timeout'), 2026 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)
2028 def retry_event_for_envelopes(self, account_id, **kwargs): 2029 """ 2030 Republishes Connect information for multiple envelopes. 2031 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. 2032 This method makes a synchronous HTTP request by default. To make an 2033 asynchronous HTTP request, please define a `callback` function 2034 to be invoked when receiving the response. 2035 >>> def callback_function(response): 2036 >>> pprint(response) 2037 >>> 2038 >>> thread = api.retry_event_for_envelopes(account_id, callback=callback_function) 2039 2040 :param callback function: The callback function 2041 for asynchronous request. (optional) 2042 :param str account_id: The external account number (int) or account ID Guid. (required) 2043 :param ConnectFailureFilter connect_failure_filter: 2044 :return: ConnectFailureResults 2045 If the method is called asynchronously, 2046 returns the request thread. 2047 """ 2048 kwargs['_return_http_data_only'] = True 2049 if kwargs.get('callback'): 2050 return self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2051 else: 2052 (data) = self.retry_event_for_envelopes_with_http_info(account_id, **kwargs) 2053 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)
2055 def retry_event_for_envelopes_with_http_info(self, account_id, **kwargs): 2056 """ 2057 Republishes Connect information for multiple envelopes. 2058 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. 2059 This method makes a synchronous HTTP request by default. To make an 2060 asynchronous HTTP request, please define a `callback` function 2061 to be invoked when receiving the response. 2062 >>> def callback_function(response): 2063 >>> pprint(response) 2064 >>> 2065 >>> thread = api.retry_event_for_envelopes_with_http_info(account_id, callback=callback_function) 2066 2067 :param callback function: The callback function 2068 for asynchronous request. (optional) 2069 :param str account_id: The external account number (int) or account ID Guid. (required) 2070 :param ConnectFailureFilter connect_failure_filter: 2071 :return: ConnectFailureResults 2072 If the method is called asynchronously, 2073 returns the request thread. 2074 """ 2075 2076 all_params = ['account_id', 'connect_failure_filter'] 2077 all_params.append('callback') 2078 all_params.append('_return_http_data_only') 2079 all_params.append('_preload_content') 2080 all_params.append('_request_timeout') 2081 2082 params = locals() 2083 for key, val in iteritems(params['kwargs']): 2084 if key not in all_params: 2085 raise TypeError( 2086 "Got an unexpected keyword argument '%s'" 2087 " to method retry_event_for_envelopes" % key 2088 ) 2089 params[key] = val 2090 del params['kwargs'] 2091 # verify the required parameter 'account_id' is set 2092 if ('account_id' not in params) or (params['account_id'] is None): 2093 raise ValueError("Missing the required parameter `account_id` when calling `retry_event_for_envelopes`") 2094 2095 2096 collection_formats = {} 2097 2098 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/retry_queue'.replace('{format}', 'json') 2099 path_params = {} 2100 if 'account_id' in params: 2101 path_params['accountId'] = params['account_id'] 2102 2103 query_params = {} 2104 2105 header_params = {} 2106 2107 form_params = [] 2108 local_var_files = {} 2109 2110 body_params = None 2111 if 'connect_failure_filter' in params: 2112 body_params = params['connect_failure_filter'] 2113 # HTTP header `Accept` 2114 header_params['Accept'] = self.api_client.\ 2115 select_header_accept(['application/json']) 2116 2117 # Authentication setting 2118 auth_settings = [] 2119 2120 return self.api_client.call_api(resource_path, 'PUT', 2121 path_params, 2122 query_params, 2123 header_params, 2124 body=body_params, 2125 post_params=form_params, 2126 files=local_var_files, 2127 response_type='ConnectFailureResults', 2128 auth_settings=auth_settings, 2129 callback=params.get('callback'), 2130 _return_http_data_only=params.get('_return_http_data_only'), 2131 _preload_content=params.get('_preload_content', True), 2132 _request_timeout=params.get('_request_timeout'), 2133 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)
2135 def update_configuration(self, account_id, **kwargs): 2136 """ 2137 Updates a specified Connect configuration. 2138 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. 2139 This method makes a synchronous HTTP request by default. To make an 2140 asynchronous HTTP request, please define a `callback` function 2141 to be invoked when receiving the response. 2142 >>> def callback_function(response): 2143 >>> pprint(response) 2144 >>> 2145 >>> thread = api.update_configuration(account_id, callback=callback_function) 2146 2147 :param callback function: The callback function 2148 for asynchronous request. (optional) 2149 :param str account_id: The external account number (int) or account ID Guid. (required) 2150 :param ConnectCustomConfiguration connect_custom_configuration: 2151 :return: ConnectCustomConfiguration 2152 If the method is called asynchronously, 2153 returns the request thread. 2154 """ 2155 kwargs['_return_http_data_only'] = True 2156 if kwargs.get('callback'): 2157 return self.update_configuration_with_http_info(account_id, **kwargs) 2158 else: 2159 (data) = self.update_configuration_with_http_info(account_id, **kwargs) 2160 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)
2162 def update_configuration_with_http_info(self, account_id, **kwargs): 2163 """ 2164 Updates a specified Connect configuration. 2165 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. 2166 This method makes a synchronous HTTP request by default. To make an 2167 asynchronous HTTP request, please define a `callback` function 2168 to be invoked when receiving the response. 2169 >>> def callback_function(response): 2170 >>> pprint(response) 2171 >>> 2172 >>> thread = api.update_configuration_with_http_info(account_id, callback=callback_function) 2173 2174 :param callback function: The callback function 2175 for asynchronous request. (optional) 2176 :param str account_id: The external account number (int) or account ID Guid. (required) 2177 :param ConnectCustomConfiguration connect_custom_configuration: 2178 :return: ConnectCustomConfiguration 2179 If the method is called asynchronously, 2180 returns the request thread. 2181 """ 2182 2183 all_params = ['account_id', 'connect_custom_configuration'] 2184 all_params.append('callback') 2185 all_params.append('_return_http_data_only') 2186 all_params.append('_preload_content') 2187 all_params.append('_request_timeout') 2188 2189 params = locals() 2190 for key, val in iteritems(params['kwargs']): 2191 if key not in all_params: 2192 raise TypeError( 2193 "Got an unexpected keyword argument '%s'" 2194 " to method update_configuration" % key 2195 ) 2196 params[key] = val 2197 del params['kwargs'] 2198 # verify the required parameter 'account_id' is set 2199 if ('account_id' not in params) or (params['account_id'] is None): 2200 raise ValueError("Missing the required parameter `account_id` when calling `update_configuration`") 2201 2202 2203 collection_formats = {} 2204 2205 resource_path = '/v2.1/accounts/{accountId}/connect'.replace('{format}', 'json') 2206 path_params = {} 2207 if 'account_id' in params: 2208 path_params['accountId'] = params['account_id'] 2209 2210 query_params = {} 2211 2212 header_params = {} 2213 2214 form_params = [] 2215 local_var_files = {} 2216 2217 body_params = None 2218 if 'connect_custom_configuration' in params: 2219 body_params = params['connect_custom_configuration'] 2220 # HTTP header `Accept` 2221 header_params['Accept'] = self.api_client.\ 2222 select_header_accept(['application/json']) 2223 2224 # Authentication setting 2225 auth_settings = [] 2226 2227 return self.api_client.call_api(resource_path, 'PUT', 2228 path_params, 2229 query_params, 2230 header_params, 2231 body=body_params, 2232 post_params=form_params, 2233 files=local_var_files, 2234 response_type='ConnectCustomConfiguration', 2235 auth_settings=auth_settings, 2236 callback=params.get('callback'), 2237 _return_http_data_only=params.get('_return_http_data_only'), 2238 _preload_content=params.get('_preload_content', True), 2239 _request_timeout=params.get('_request_timeout'), 2240 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)
2242 def update_connect_o_auth_config(self, account_id, **kwargs): 2243 """ 2244 Updates the existing Connect OAuth Config for the account. 2245 This method makes a synchronous HTTP request by default. To make an 2246 asynchronous HTTP request, please define a `callback` function 2247 to be invoked when receiving the response. 2248 >>> def callback_function(response): 2249 >>> pprint(response) 2250 >>> 2251 >>> thread = api.update_connect_o_auth_config(account_id, callback=callback_function) 2252 2253 :param callback function: The callback function 2254 for asynchronous request. (optional) 2255 :param str account_id: The external account number (int) or account ID Guid. (required) 2256 :param ConnectOAuthConfig connect_o_auth_config: 2257 :return: ConnectOAuthConfig 2258 If the method is called asynchronously, 2259 returns the request thread. 2260 """ 2261 kwargs['_return_http_data_only'] = True 2262 if kwargs.get('callback'): 2263 return self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2264 else: 2265 (data) = self.update_connect_o_auth_config_with_http_info(account_id, **kwargs) 2266 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)
2268 def update_connect_o_auth_config_with_http_info(self, account_id, **kwargs): 2269 """ 2270 Updates the existing Connect OAuth Config for the account. 2271 This method makes a synchronous HTTP request by default. To make an 2272 asynchronous HTTP request, please define a `callback` function 2273 to be invoked when receiving the response. 2274 >>> def callback_function(response): 2275 >>> pprint(response) 2276 >>> 2277 >>> thread = api.update_connect_o_auth_config_with_http_info(account_id, callback=callback_function) 2278 2279 :param callback function: The callback function 2280 for asynchronous request. (optional) 2281 :param str account_id: The external account number (int) or account ID Guid. (required) 2282 :param ConnectOAuthConfig connect_o_auth_config: 2283 :return: ConnectOAuthConfig 2284 If the method is called asynchronously, 2285 returns the request thread. 2286 """ 2287 2288 all_params = ['account_id', 'connect_o_auth_config'] 2289 all_params.append('callback') 2290 all_params.append('_return_http_data_only') 2291 all_params.append('_preload_content') 2292 all_params.append('_request_timeout') 2293 2294 params = locals() 2295 for key, val in iteritems(params['kwargs']): 2296 if key not in all_params: 2297 raise TypeError( 2298 "Got an unexpected keyword argument '%s'" 2299 " to method update_connect_o_auth_config" % key 2300 ) 2301 params[key] = val 2302 del params['kwargs'] 2303 # verify the required parameter 'account_id' is set 2304 if ('account_id' not in params) or (params['account_id'] is None): 2305 raise ValueError("Missing the required parameter `account_id` when calling `update_connect_o_auth_config`") 2306 2307 2308 collection_formats = {} 2309 2310 resource_path = '/v2.1/accounts/{accountId}/connect/oauth'.replace('{format}', 'json') 2311 path_params = {} 2312 if 'account_id' in params: 2313 path_params['accountId'] = params['account_id'] 2314 2315 query_params = {} 2316 2317 header_params = {} 2318 2319 form_params = [] 2320 local_var_files = {} 2321 2322 body_params = None 2323 if 'connect_o_auth_config' in params: 2324 body_params = params['connect_o_auth_config'] 2325 # HTTP header `Accept` 2326 header_params['Accept'] = self.api_client.\ 2327 select_header_accept(['application/json']) 2328 2329 # Authentication setting 2330 auth_settings = [] 2331 2332 return self.api_client.call_api(resource_path, 'PUT', 2333 path_params, 2334 query_params, 2335 header_params, 2336 body=body_params, 2337 post_params=form_params, 2338 files=local_var_files, 2339 response_type='ConnectOAuthConfig', 2340 auth_settings=auth_settings, 2341 callback=params.get('callback'), 2342 _return_http_data_only=params.get('_return_http_data_only'), 2343 _preload_content=params.get('_preload_content', True), 2344 _request_timeout=params.get('_request_timeout'), 2345 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)
2347 def update_mobile_notifiers(self, account_id, **kwargs): 2348 """ 2349 Reserved 2350 Reserved: 2351 This method makes a synchronous HTTP request by default. To make an 2352 asynchronous HTTP request, please define a `callback` function 2353 to be invoked when receiving the response. 2354 >>> def callback_function(response): 2355 >>> pprint(response) 2356 >>> 2357 >>> thread = api.update_mobile_notifiers(account_id, callback=callback_function) 2358 2359 :param callback function: The callback function 2360 for asynchronous request. (optional) 2361 :param str account_id: The external account number (int) or account ID Guid. (required) 2362 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2363 :return: MobileNotifierConfigurationInformation 2364 If the method is called asynchronously, 2365 returns the request thread. 2366 """ 2367 kwargs['_return_http_data_only'] = True 2368 if kwargs.get('callback'): 2369 return self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2370 else: 2371 (data) = self.update_mobile_notifiers_with_http_info(account_id, **kwargs) 2372 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)
2374 def update_mobile_notifiers_with_http_info(self, account_id, **kwargs): 2375 """ 2376 Reserved 2377 Reserved: 2378 This method makes a synchronous HTTP request by default. To make an 2379 asynchronous HTTP request, please define a `callback` function 2380 to be invoked when receiving the response. 2381 >>> def callback_function(response): 2382 >>> pprint(response) 2383 >>> 2384 >>> thread = api.update_mobile_notifiers_with_http_info(account_id, callback=callback_function) 2385 2386 :param callback function: The callback function 2387 for asynchronous request. (optional) 2388 :param str account_id: The external account number (int) or account ID Guid. (required) 2389 :param MobileNotifierConfigurationInformation mobile_notifier_configuration_information: 2390 :return: MobileNotifierConfigurationInformation 2391 If the method is called asynchronously, 2392 returns the request thread. 2393 """ 2394 2395 all_params = ['account_id', 'mobile_notifier_configuration_information'] 2396 all_params.append('callback') 2397 all_params.append('_return_http_data_only') 2398 all_params.append('_preload_content') 2399 all_params.append('_request_timeout') 2400 2401 params = locals() 2402 for key, val in iteritems(params['kwargs']): 2403 if key not in all_params: 2404 raise TypeError( 2405 "Got an unexpected keyword argument '%s'" 2406 " to method update_mobile_notifiers" % key 2407 ) 2408 params[key] = val 2409 del params['kwargs'] 2410 # verify the required parameter 'account_id' is set 2411 if ('account_id' not in params) or (params['account_id'] is None): 2412 raise ValueError("Missing the required parameter `account_id` when calling `update_mobile_notifiers`") 2413 2414 2415 collection_formats = {} 2416 2417 resource_path = '/v2.1/accounts/{accountId}/connect/mobile_notifiers'.replace('{format}', 'json') 2418 path_params = {} 2419 if 'account_id' in params: 2420 path_params['accountId'] = params['account_id'] 2421 2422 query_params = {} 2423 2424 header_params = {} 2425 2426 form_params = [] 2427 local_var_files = {} 2428 2429 body_params = None 2430 if 'mobile_notifier_configuration_information' in params: 2431 body_params = params['mobile_notifier_configuration_information'] 2432 # HTTP header `Accept` 2433 header_params['Accept'] = self.api_client.\ 2434 select_header_accept(['application/json']) 2435 2436 # Authentication setting 2437 auth_settings = [] 2438 2439 return self.api_client.call_api(resource_path, 'PUT', 2440 path_params, 2441 query_params, 2442 header_params, 2443 body=body_params, 2444 post_params=form_params, 2445 files=local_var_files, 2446 response_type='MobileNotifierConfigurationInformation', 2447 auth_settings=auth_settings, 2448 callback=params.get('callback'), 2449 _return_http_data_only=params.get('_return_http_data_only'), 2450 _preload_content=params.get('_preload_content', True), 2451 _request_timeout=params.get('_request_timeout'), 2452 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.