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