docusign_esign.apis.bulk_process_data_send_api

  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 BulkProcessDataSendApi(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_bulk_process_request_to_queue(self, account_id, bulk_process_list_id, process_action, **kwargs):
 44        """
 45        Uses the specified bulk envelopes list to update the envelopes specified in the payload
 46        
 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_bulk_process_request_to_queue(account_id, bulk_process_list_id, process_action, 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 str bulk_process_list_id: (required)
 59        :param str process_action: (required)
 60        :param BulkProcessRequest bulk_process_request:
 61        :return: BulkProcessResponse
 62                 If the method is called asynchronously,
 63                 returns the request thread.
 64        """
 65        kwargs['_return_http_data_only'] = True
 66        if kwargs.get('callback'):
 67            return self.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
 68        else:
 69            (data) = self.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
 70            return data
 71
 72    def create_bulk_process_request_to_queue_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
 73        """
 74        Uses the specified bulk envelopes list to update the envelopes specified in the payload
 75        
 76        This method makes a synchronous HTTP request by default. To make an
 77        asynchronous HTTP request, please define a `callback` function
 78        to be invoked when receiving the response.
 79        >>> def callback_function(response):
 80        >>>     pprint(response)
 81        >>>
 82        >>> thread = api.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
 83
 84        :param callback function: The callback function
 85            for asynchronous request. (optional)
 86        :param str account_id: The external account number (int) or account ID Guid. (required)
 87        :param str bulk_process_list_id: (required)
 88        :param str process_action: (required)
 89        :param BulkProcessRequest bulk_process_request:
 90        :return: BulkProcessResponse
 91                 If the method is called asynchronously,
 92                 returns the request thread.
 93        """
 94
 95        all_params = ['account_id', 'bulk_process_list_id', 'process_action', 'bulk_process_request']
 96        all_params.append('callback')
 97        all_params.append('_return_http_data_only')
 98        all_params.append('_preload_content')
 99        all_params.append('_request_timeout')
100
101        params = locals()
102        for key, val in iteritems(params['kwargs']):
103            if key not in all_params:
104                raise TypeError(
105                    "Got an unexpected keyword argument '%s'"
106                    " to method create_bulk_process_request_to_queue" % key
107                )
108            params[key] = val
109        del params['kwargs']
110        # verify the required parameter 'account_id' is set
111        if ('account_id' not in params) or (params['account_id'] is None):
112            raise ValueError("Missing the required parameter `account_id` when calling `create_bulk_process_request_to_queue`")
113        # verify the required parameter 'bulk_process_list_id' is set
114        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
115            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `create_bulk_process_request_to_queue`")
116        # verify the required parameter 'process_action' is set
117        if ('process_action' not in params) or (params['process_action'] is None):
118            raise ValueError("Missing the required parameter `process_action` when calling `create_bulk_process_request_to_queue`")
119
120
121        collection_formats = {}
122
123        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}/send'.replace('{format}', 'json')
124        path_params = {}
125        if 'account_id' in params:
126            path_params['accountId'] = params['account_id']
127        if 'bulk_process_list_id' in params:
128            path_params['bulkProcessListId'] = params['bulk_process_list_id']
129        if 'process_action' in params:
130            path_params['processAction'] = params['process_action']
131
132        query_params = {}
133
134        header_params = {}
135
136        form_params = []
137        local_var_files = {}
138
139        body_params = None
140        if 'bulk_process_request' in params:
141            body_params = params['bulk_process_request']
142        # HTTP header `Accept`
143        header_params['Accept'] = self.api_client.\
144            select_header_accept(['application/json'])
145
146        # Authentication setting
147        auth_settings = []
148
149        return self.api_client.call_api(resource_path, 'POST',
150                                        path_params,
151                                        query_params,
152                                        header_params,
153                                        body=body_params,
154                                        post_params=form_params,
155                                        files=local_var_files,
156                                        response_type='BulkProcessResponse',
157                                        auth_settings=auth_settings,
158                                        callback=params.get('callback'),
159                                        _return_http_data_only=params.get('_return_http_data_only'),
160                                        _preload_content=params.get('_preload_content', True),
161                                        _request_timeout=params.get('_request_timeout'),
162                                        collection_formats=collection_formats)
163
164    def delete_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
165        """
166        Deletes a specific bulk process list
167        
168        This method makes a synchronous HTTP request by default. To make an
169        asynchronous HTTP request, please define a `callback` function
170        to be invoked when receiving the response.
171        >>> def callback_function(response):
172        >>>     pprint(response)
173        >>>
174        >>> thread = api.delete_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
175
176        :param callback function: The callback function
177            for asynchronous request. (optional)
178        :param str account_id: The external account number (int) or account ID Guid. (required)
179        :param str bulk_process_list_id: (required)
180        :param str process_action: (required)
181        :return: BulkProcessResult
182                 If the method is called asynchronously,
183                 returns the request thread.
184        """
185        kwargs['_return_http_data_only'] = True
186        if kwargs.get('callback'):
187            return self.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
188        else:
189            (data) = self.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
190            return data
191
192    def delete_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
193        """
194        Deletes a specific bulk process list
195        
196        This method makes a synchronous HTTP request by default. To make an
197        asynchronous HTTP request, please define a `callback` function
198        to be invoked when receiving the response.
199        >>> def callback_function(response):
200        >>>     pprint(response)
201        >>>
202        >>> thread = api.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
203
204        :param callback function: The callback function
205            for asynchronous request. (optional)
206        :param str account_id: The external account number (int) or account ID Guid. (required)
207        :param str bulk_process_list_id: (required)
208        :param str process_action: (required)
209        :return: BulkProcessResult
210                 If the method is called asynchronously,
211                 returns the request thread.
212        """
213
214        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
215        all_params.append('callback')
216        all_params.append('_return_http_data_only')
217        all_params.append('_preload_content')
218        all_params.append('_request_timeout')
219
220        params = locals()
221        for key, val in iteritems(params['kwargs']):
222            if key not in all_params:
223                raise TypeError(
224                    "Got an unexpected keyword argument '%s'"
225                    " to method delete_bulk_process_list" % key
226                )
227            params[key] = val
228        del params['kwargs']
229        # verify the required parameter 'account_id' is set
230        if ('account_id' not in params) or (params['account_id'] is None):
231            raise ValueError("Missing the required parameter `account_id` when calling `delete_bulk_process_list`")
232        # verify the required parameter 'bulk_process_list_id' is set
233        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
234            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `delete_bulk_process_list`")
235        # verify the required parameter 'process_action' is set
236        if ('process_action' not in params) or (params['process_action'] is None):
237            raise ValueError("Missing the required parameter `process_action` when calling `delete_bulk_process_list`")
238
239
240        collection_formats = {}
241
242        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}/send'.replace('{format}', 'json')
243        path_params = {}
244        if 'account_id' in params:
245            path_params['accountId'] = params['account_id']
246        if 'bulk_process_list_id' in params:
247            path_params['bulkProcessListId'] = params['bulk_process_list_id']
248        if 'process_action' in params:
249            path_params['processAction'] = params['process_action']
250
251        query_params = {}
252
253        header_params = {}
254
255        form_params = []
256        local_var_files = {}
257
258        body_params = None
259        # HTTP header `Accept`
260        header_params['Accept'] = self.api_client.\
261            select_header_accept(['application/json'])
262
263        # Authentication setting
264        auth_settings = []
265
266        return self.api_client.call_api(resource_path, 'DELETE',
267                                        path_params,
268                                        query_params,
269                                        header_params,
270                                        body=body_params,
271                                        post_params=form_params,
272                                        files=local_var_files,
273                                        response_type='BulkProcessResult',
274                                        auth_settings=auth_settings,
275                                        callback=params.get('callback'),
276                                        _return_http_data_only=params.get('_return_http_data_only'),
277                                        _preload_content=params.get('_preload_content', True),
278                                        _request_timeout=params.get('_request_timeout'),
279                                        collection_formats=collection_formats)
280
281    def get_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
282        """
283        Gets a specific bulk process list
284        
285        This method makes a synchronous HTTP request by default. To make an
286        asynchronous HTTP request, please define a `callback` function
287        to be invoked when receiving the response.
288        >>> def callback_function(response):
289        >>>     pprint(response)
290        >>>
291        >>> thread = api.get_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
292
293        :param callback function: The callback function
294            for asynchronous request. (optional)
295        :param str account_id: The external account number (int) or account ID Guid. (required)
296        :param str bulk_process_list_id: (required)
297        :param str process_action: (required)
298        :return: None
299                 If the method is called asynchronously,
300                 returns the request thread.
301        """
302        kwargs['_return_http_data_only'] = True
303        if kwargs.get('callback'):
304            return self.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
305        else:
306            (data) = self.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
307            return data
308
309    def get_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
310        """
311        Gets a specific bulk process list
312        
313        This method makes a synchronous HTTP request by default. To make an
314        asynchronous HTTP request, please define a `callback` function
315        to be invoked when receiving the response.
316        >>> def callback_function(response):
317        >>>     pprint(response)
318        >>>
319        >>> thread = api.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
320
321        :param callback function: The callback function
322            for asynchronous request. (optional)
323        :param str account_id: The external account number (int) or account ID Guid. (required)
324        :param str bulk_process_list_id: (required)
325        :param str process_action: (required)
326        :return: None
327                 If the method is called asynchronously,
328                 returns the request thread.
329        """
330
331        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
332        all_params.append('callback')
333        all_params.append('_return_http_data_only')
334        all_params.append('_preload_content')
335        all_params.append('_request_timeout')
336
337        params = locals()
338        for key, val in iteritems(params['kwargs']):
339            if key not in all_params:
340                raise TypeError(
341                    "Got an unexpected keyword argument '%s'"
342                    " to method get_bulk_process_list" % key
343                )
344            params[key] = val
345        del params['kwargs']
346        # verify the required parameter 'account_id' is set
347        if ('account_id' not in params) or (params['account_id'] is None):
348            raise ValueError("Missing the required parameter `account_id` when calling `get_bulk_process_list`")
349        # verify the required parameter 'bulk_process_list_id' is set
350        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
351            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `get_bulk_process_list`")
352        # verify the required parameter 'process_action' is set
353        if ('process_action' not in params) or (params['process_action'] is None):
354            raise ValueError("Missing the required parameter `process_action` when calling `get_bulk_process_list`")
355
356
357        collection_formats = {}
358
359        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}/send'.replace('{format}', 'json')
360        path_params = {}
361        if 'account_id' in params:
362            path_params['accountId'] = params['account_id']
363        if 'bulk_process_list_id' in params:
364            path_params['bulkProcessListId'] = params['bulk_process_list_id']
365        if 'process_action' in params:
366            path_params['processAction'] = params['process_action']
367
368        query_params = {}
369
370        header_params = {}
371
372        form_params = []
373        local_var_files = {}
374
375        body_params = None
376        # HTTP header `Accept`
377        header_params['Accept'] = self.api_client.\
378            select_header_accept(['application/json'])
379
380        # Authentication setting
381        auth_settings = []
382
383        return self.api_client.call_api(resource_path, 'GET',
384                                        path_params,
385                                        query_params,
386                                        header_params,
387                                        body=body_params,
388                                        post_params=form_params,
389                                        files=local_var_files,
390                                        response_type=None,
391                                        auth_settings=auth_settings,
392                                        callback=params.get('callback'),
393                                        _return_http_data_only=params.get('_return_http_data_only'),
394                                        _preload_content=params.get('_preload_content', True),
395                                        _request_timeout=params.get('_request_timeout'),
396                                        collection_formats=collection_formats)
397
398    def update_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
399        """
400        Updates a specific bulk process list
401        
402        This method makes a synchronous HTTP request by default. To make an
403        asynchronous HTTP request, please define a `callback` function
404        to be invoked when receiving the response.
405        >>> def callback_function(response):
406        >>>     pprint(response)
407        >>>
408        >>> thread = api.update_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
409
410        :param callback function: The callback function
411            for asynchronous request. (optional)
412        :param str account_id: The external account number (int) or account ID Guid. (required)
413        :param str bulk_process_list_id: (required)
414        :param str process_action: (required)
415        :return: None
416                 If the method is called asynchronously,
417                 returns the request thread.
418        """
419        kwargs['_return_http_data_only'] = True
420        if kwargs.get('callback'):
421            return self.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
422        else:
423            (data) = self.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
424            return data
425
426    def update_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
427        """
428        Updates a specific bulk process list
429        
430        This method makes a synchronous HTTP request by default. To make an
431        asynchronous HTTP request, please define a `callback` function
432        to be invoked when receiving the response.
433        >>> def callback_function(response):
434        >>>     pprint(response)
435        >>>
436        >>> thread = api.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
437
438        :param callback function: The callback function
439            for asynchronous request. (optional)
440        :param str account_id: The external account number (int) or account ID Guid. (required)
441        :param str bulk_process_list_id: (required)
442        :param str process_action: (required)
443        :return: None
444                 If the method is called asynchronously,
445                 returns the request thread.
446        """
447
448        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
449        all_params.append('callback')
450        all_params.append('_return_http_data_only')
451        all_params.append('_preload_content')
452        all_params.append('_request_timeout')
453
454        params = locals()
455        for key, val in iteritems(params['kwargs']):
456            if key not in all_params:
457                raise TypeError(
458                    "Got an unexpected keyword argument '%s'"
459                    " to method update_bulk_process_list" % key
460                )
461            params[key] = val
462        del params['kwargs']
463        # verify the required parameter 'account_id' is set
464        if ('account_id' not in params) or (params['account_id'] is None):
465            raise ValueError("Missing the required parameter `account_id` when calling `update_bulk_process_list`")
466        # verify the required parameter 'bulk_process_list_id' is set
467        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
468            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `update_bulk_process_list`")
469        # verify the required parameter 'process_action' is set
470        if ('process_action' not in params) or (params['process_action'] is None):
471            raise ValueError("Missing the required parameter `process_action` when calling `update_bulk_process_list`")
472
473
474        collection_formats = {}
475
476        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}/send'.replace('{format}', 'json')
477        path_params = {}
478        if 'account_id' in params:
479            path_params['accountId'] = params['account_id']
480        if 'bulk_process_list_id' in params:
481            path_params['bulkProcessListId'] = params['bulk_process_list_id']
482        if 'process_action' in params:
483            path_params['processAction'] = params['process_action']
484
485        query_params = {}
486
487        header_params = {}
488
489        form_params = []
490        local_var_files = {}
491
492        body_params = None
493        # HTTP header `Accept`
494        header_params['Accept'] = self.api_client.\
495            select_header_accept(['application/json'])
496
497        # Authentication setting
498        auth_settings = []
499
500        return self.api_client.call_api(resource_path, 'PUT',
501                                        path_params,
502                                        query_params,
503                                        header_params,
504                                        body=body_params,
505                                        post_params=form_params,
506                                        files=local_var_files,
507                                        response_type=None,
508                                        auth_settings=auth_settings,
509                                        callback=params.get('callback'),
510                                        _return_http_data_only=params.get('_return_http_data_only'),
511                                        _preload_content=params.get('_preload_content', True),
512                                        _request_timeout=params.get('_request_timeout'),
513                                        collection_formats=collection_formats)