docusign_esign.apis.authentication_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 AuthenticationApi(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 delete_social_login(self, account_id, user_id, **kwargs):
 44        """
 45        Deletes user's social account.
 46        Deletes a social account from a use's account.
 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.delete_social_login(account_id, user_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 str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 59        :param SocialAccountInformation social_account_information:
 60        :return: None
 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.delete_social_login_with_http_info(account_id, user_id, **kwargs)
 67        else:
 68            (data) = self.delete_social_login_with_http_info(account_id, user_id, **kwargs)
 69            return data
 70
 71    def delete_social_login_with_http_info(self, account_id, user_id, **kwargs):
 72        """
 73        Deletes user's social account.
 74        Deletes a social account from a use's account.
 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.delete_social_login_with_http_info(account_id, user_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 str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
 87        :param SocialAccountInformation social_account_information:
 88        :return: None
 89                 If the method is called asynchronously,
 90                 returns the request thread.
 91        """
 92
 93        all_params = ['account_id', 'user_id', 'social_account_information']
 94        all_params.append('callback')
 95        all_params.append('_return_http_data_only')
 96        all_params.append('_preload_content')
 97        all_params.append('_request_timeout')
 98
 99        params = locals()
100        for key, val in iteritems(params['kwargs']):
101            if key not in all_params:
102                raise TypeError(
103                    "Got an unexpected keyword argument '%s'"
104                    " to method delete_social_login" % key
105                )
106            params[key] = val
107        del params['kwargs']
108        # verify the required parameter 'account_id' is set
109        if ('account_id' not in params) or (params['account_id'] is None):
110            raise ValueError("Missing the required parameter `account_id` when calling `delete_social_login`")
111        # verify the required parameter 'user_id' is set
112        if ('user_id' not in params) or (params['user_id'] is None):
113            raise ValueError("Missing the required parameter `user_id` when calling `delete_social_login`")
114
115
116        collection_formats = {}
117
118        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/social'.replace('{format}', 'json')
119        path_params = {}
120        if 'account_id' in params:
121            path_params['accountId'] = params['account_id']
122        if 'user_id' in params:
123            path_params['userId'] = params['user_id']
124
125        query_params = {}
126
127        header_params = {}
128
129        form_params = []
130        local_var_files = {}
131
132        body_params = None
133        if 'social_account_information' in params:
134            body_params = params['social_account_information']
135        # HTTP header `Accept`
136        header_params['Accept'] = self.api_client.\
137            select_header_accept(['application/json'])
138
139        # Authentication setting
140        auth_settings = []
141
142        return self.api_client.call_api(resource_path, 'DELETE',
143                                        path_params,
144                                        query_params,
145                                        header_params,
146                                        body=body_params,
147                                        post_params=form_params,
148                                        files=local_var_files,
149                                        response_type=None,
150                                        auth_settings=auth_settings,
151                                        callback=params.get('callback'),
152                                        _return_http_data_only=params.get('_return_http_data_only'),
153                                        _preload_content=params.get('_preload_content', True),
154                                        _request_timeout=params.get('_request_timeout'),
155                                        collection_formats=collection_formats)
156
157    def get_o_auth_token(self, **kwargs):
158        """
159        Creates an authorization token.
160        Creates an OAuth2 authorization server token endpoint.
161        This method makes a synchronous HTTP request by default. To make an
162        asynchronous HTTP request, please define a `callback` function
163        to be invoked when receiving the response.
164        >>> def callback_function(response):
165        >>>     pprint(response)
166        >>>
167        >>> thread = api.get_o_auth_token(callback=callback_function)
168
169        :param callback function: The callback function
170            for asynchronous request. (optional)
171        :return: OauthAccess
172                 If the method is called asynchronously,
173                 returns the request thread.
174        """
175        kwargs['_return_http_data_only'] = True
176        if kwargs.get('callback'):
177            return self.get_o_auth_token_with_http_info(**kwargs)
178        else:
179            (data) = self.get_o_auth_token_with_http_info(**kwargs)
180            return data
181
182    def get_o_auth_token_with_http_info(self, **kwargs):
183        """
184        Creates an authorization token.
185        Creates an OAuth2 authorization server token endpoint.
186        This method makes a synchronous HTTP request by default. To make an
187        asynchronous HTTP request, please define a `callback` function
188        to be invoked when receiving the response.
189        >>> def callback_function(response):
190        >>>     pprint(response)
191        >>>
192        >>> thread = api.get_o_auth_token_with_http_info(callback=callback_function)
193
194        :param callback function: The callback function
195            for asynchronous request. (optional)
196        :return: OauthAccess
197                 If the method is called asynchronously,
198                 returns the request thread.
199        """
200
201        all_params = []
202        all_params.append('callback')
203        all_params.append('_return_http_data_only')
204        all_params.append('_preload_content')
205        all_params.append('_request_timeout')
206
207        params = locals()
208        for key, val in iteritems(params['kwargs']):
209            if key not in all_params:
210                raise TypeError(
211                    "Got an unexpected keyword argument '%s'"
212                    " to method get_o_auth_token" % key
213                )
214            params[key] = val
215        del params['kwargs']
216
217        collection_formats = {}
218
219        resource_path = '/v2.1/oauth2/token'.replace('{format}', 'json')
220        path_params = {}
221
222        query_params = {}
223
224        header_params = {}
225
226        form_params = []
227        local_var_files = {}
228
229        body_params = None
230        # HTTP header `Accept`
231        header_params['Accept'] = self.api_client.\
232            select_header_accept(['application/json'])
233
234        # Authentication setting
235        auth_settings = []
236
237        return self.api_client.call_api(resource_path, 'POST',
238                                        path_params,
239                                        query_params,
240                                        header_params,
241                                        body=body_params,
242                                        post_params=form_params,
243                                        files=local_var_files,
244                                        response_type='OauthAccess',
245                                        auth_settings=auth_settings,
246                                        callback=params.get('callback'),
247                                        _return_http_data_only=params.get('_return_http_data_only'),
248                                        _preload_content=params.get('_preload_content', True),
249                                        _request_timeout=params.get('_request_timeout'),
250                                        collection_formats=collection_formats)
251
252    def list_social_logins(self, account_id, user_id, **kwargs):
253        """
254        Gets a list of a user's social accounts.
255        Retrieves a list of social accounts linked to a user's account.
256        This method makes a synchronous HTTP request by default. To make an
257        asynchronous HTTP request, please define a `callback` function
258        to be invoked when receiving the response.
259        >>> def callback_function(response):
260        >>>     pprint(response)
261        >>>
262        >>> thread = api.list_social_logins(account_id, user_id, callback=callback_function)
263
264        :param callback function: The callback function
265            for asynchronous request. (optional)
266        :param str account_id: The external account number (int) or account ID Guid. (required)
267        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
268        :return: UserSocialIdResult
269                 If the method is called asynchronously,
270                 returns the request thread.
271        """
272        kwargs['_return_http_data_only'] = True
273        if kwargs.get('callback'):
274            return self.list_social_logins_with_http_info(account_id, user_id, **kwargs)
275        else:
276            (data) = self.list_social_logins_with_http_info(account_id, user_id, **kwargs)
277            return data
278
279    def list_social_logins_with_http_info(self, account_id, user_id, **kwargs):
280        """
281        Gets a list of a user's social accounts.
282        Retrieves a list of social accounts linked to a user's account.
283        This method makes a synchronous HTTP request by default. To make an
284        asynchronous HTTP request, please define a `callback` function
285        to be invoked when receiving the response.
286        >>> def callback_function(response):
287        >>>     pprint(response)
288        >>>
289        >>> thread = api.list_social_logins_with_http_info(account_id, user_id, callback=callback_function)
290
291        :param callback function: The callback function
292            for asynchronous request. (optional)
293        :param str account_id: The external account number (int) or account ID Guid. (required)
294        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
295        :return: UserSocialIdResult
296                 If the method is called asynchronously,
297                 returns the request thread.
298        """
299
300        all_params = ['account_id', 'user_id']
301        all_params.append('callback')
302        all_params.append('_return_http_data_only')
303        all_params.append('_preload_content')
304        all_params.append('_request_timeout')
305
306        params = locals()
307        for key, val in iteritems(params['kwargs']):
308            if key not in all_params:
309                raise TypeError(
310                    "Got an unexpected keyword argument '%s'"
311                    " to method list_social_logins" % key
312                )
313            params[key] = val
314        del params['kwargs']
315        # verify the required parameter 'account_id' is set
316        if ('account_id' not in params) or (params['account_id'] is None):
317            raise ValueError("Missing the required parameter `account_id` when calling `list_social_logins`")
318        # verify the required parameter 'user_id' is set
319        if ('user_id' not in params) or (params['user_id'] is None):
320            raise ValueError("Missing the required parameter `user_id` when calling `list_social_logins`")
321
322
323        collection_formats = {}
324
325        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/social'.replace('{format}', 'json')
326        path_params = {}
327        if 'account_id' in params:
328            path_params['accountId'] = params['account_id']
329        if 'user_id' in params:
330            path_params['userId'] = params['user_id']
331
332        query_params = {}
333
334        header_params = {}
335
336        form_params = []
337        local_var_files = {}
338
339        body_params = None
340        # HTTP header `Accept`
341        header_params['Accept'] = self.api_client.\
342            select_header_accept(['application/json'])
343
344        # Authentication setting
345        auth_settings = []
346
347        return self.api_client.call_api(resource_path, 'GET',
348                                        path_params,
349                                        query_params,
350                                        header_params,
351                                        body=body_params,
352                                        post_params=form_params,
353                                        files=local_var_files,
354                                        response_type='UserSocialIdResult',
355                                        auth_settings=auth_settings,
356                                        callback=params.get('callback'),
357                                        _return_http_data_only=params.get('_return_http_data_only'),
358                                        _preload_content=params.get('_preload_content', True),
359                                        _request_timeout=params.get('_request_timeout'),
360                                        collection_formats=collection_formats)
361
362    def login(self, **kwargs):
363        """
364        Gets login information for a specified user.
365        Retrieves login information for a specified user. Each account that is associated with the login credentials is listed. You can use the returned information to determine whether a user is authenticated and select an account to use in future operations.    The `baseUrl` property, returned in the response, is used in all future API calls as the base of the request URL. The `baseUrl` property contains the DocuSign server, the API version, and the `accountId` property that is used for the login. This request uses your DocuSign credentials to retrieve the account information.
366        This method makes a synchronous HTTP request by default. To make an
367        asynchronous HTTP request, please define a `callback` function
368        to be invoked when receiving the response.
369        >>> def callback_function(response):
370        >>>     pprint(response)
371        >>>
372        >>> thread = api.login(callback=callback_function)
373
374        :param callback function: The callback function
375            for asynchronous request. (optional)
376        :param str api_password: When set to **true**, shows the account API password in the response.
377        :param str embed_account_id_guid:
378        :param str include_account_id_guid: When set to **true**, shows the account ID GUID in the response.
379        :param str login_settings: Determines whether login settings are returned in the response.  Valid Values:  * all -  All the login settings are returned.  * none - no login settings are returned.
380        :return: LoginInformation
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.login_with_http_info(**kwargs)
387        else:
388            (data) = self.login_with_http_info(**kwargs)
389            return data
390
391    def login_with_http_info(self, **kwargs):
392        """
393        Gets login information for a specified user.
394        Retrieves login information for a specified user. Each account that is associated with the login credentials is listed. You can use the returned information to determine whether a user is authenticated and select an account to use in future operations.    The `baseUrl` property, returned in the response, is used in all future API calls as the base of the request URL. The `baseUrl` property contains the DocuSign server, the API version, and the `accountId` property that is used for the login. This request uses your DocuSign credentials to retrieve the account information.
395        This method makes a synchronous HTTP request by default. To make an
396        asynchronous HTTP request, please define a `callback` function
397        to be invoked when receiving the response.
398        >>> def callback_function(response):
399        >>>     pprint(response)
400        >>>
401        >>> thread = api.login_with_http_info(callback=callback_function)
402
403        :param callback function: The callback function
404            for asynchronous request. (optional)
405        :param str api_password: When set to **true**, shows the account API password in the response.
406        :param str embed_account_id_guid:
407        :param str include_account_id_guid: When set to **true**, shows the account ID GUID in the response.
408        :param str login_settings: Determines whether login settings are returned in the response.  Valid Values:  * all -  All the login settings are returned.  * none - no login settings are returned.
409        :return: LoginInformation
410                 If the method is called asynchronously,
411                 returns the request thread.
412        """
413
414        all_params = ['api_password', 'embed_account_id_guid', 'include_account_id_guid', 'login_settings']
415        all_params.append('callback')
416        all_params.append('_return_http_data_only')
417        all_params.append('_preload_content')
418        all_params.append('_request_timeout')
419
420        params = locals()
421        for key, val in iteritems(params['kwargs']):
422            if key not in all_params:
423                raise TypeError(
424                    "Got an unexpected keyword argument '%s'"
425                    " to method login" % key
426                )
427            params[key] = val
428        del params['kwargs']
429
430
431        collection_formats = {}
432
433        resource_path = '/v2.1/login_information'.replace('{format}', 'json')
434        path_params = {}
435
436        query_params = {}
437        if 'api_password' in params:
438            query_params['api_password'] = params['api_password']
439        if 'embed_account_id_guid' in params:
440            query_params['embed_account_id_guid'] = params['embed_account_id_guid']
441        if 'include_account_id_guid' in params:
442            query_params['include_account_id_guid'] = params['include_account_id_guid']
443        if 'login_settings' in params:
444            query_params['login_settings'] = params['login_settings']
445
446        header_params = {}
447
448        form_params = []
449        local_var_files = {}
450
451        body_params = None
452        # HTTP header `Accept`
453        header_params['Accept'] = self.api_client.\
454            select_header_accept(['application/json'])
455
456        # Authentication setting
457        auth_settings = []
458
459        return self.api_client.call_api(resource_path, 'GET',
460                                        path_params,
461                                        query_params,
462                                        header_params,
463                                        body=body_params,
464                                        post_params=form_params,
465                                        files=local_var_files,
466                                        response_type='LoginInformation',
467                                        auth_settings=auth_settings,
468                                        callback=params.get('callback'),
469                                        _return_http_data_only=params.get('_return_http_data_only'),
470                                        _preload_content=params.get('_preload_content', True),
471                                        _request_timeout=params.get('_request_timeout'),
472                                        collection_formats=collection_formats)
473
474    def revoke_o_auth_token(self, **kwargs):
475        """
476        Revokes an authorization token.
477        Revokes an OAuth2 authorization server token. After the revocation is complete, a caller must re-authenticate to restore access.
478        This method makes a synchronous HTTP request by default. To make an
479        asynchronous HTTP request, please define a `callback` function
480        to be invoked when receiving the response.
481        >>> def callback_function(response):
482        >>>     pprint(response)
483        >>>
484        >>> thread = api.revoke_o_auth_token(callback=callback_function)
485
486        :param callback function: The callback function
487            for asynchronous request. (optional)
488        :return: None
489                 If the method is called asynchronously,
490                 returns the request thread.
491        """
492        kwargs['_return_http_data_only'] = True
493        if kwargs.get('callback'):
494            return self.revoke_o_auth_token_with_http_info(**kwargs)
495        else:
496            (data) = self.revoke_o_auth_token_with_http_info(**kwargs)
497            return data
498
499    def revoke_o_auth_token_with_http_info(self, **kwargs):
500        """
501        Revokes an authorization token.
502        Revokes an OAuth2 authorization server token. After the revocation is complete, a caller must re-authenticate to restore access.
503        This method makes a synchronous HTTP request by default. To make an
504        asynchronous HTTP request, please define a `callback` function
505        to be invoked when receiving the response.
506        >>> def callback_function(response):
507        >>>     pprint(response)
508        >>>
509        >>> thread = api.revoke_o_auth_token_with_http_info(callback=callback_function)
510
511        :param callback function: The callback function
512            for asynchronous request. (optional)
513        :return: None
514                 If the method is called asynchronously,
515                 returns the request thread.
516        """
517
518        all_params = []
519        all_params.append('callback')
520        all_params.append('_return_http_data_only')
521        all_params.append('_preload_content')
522        all_params.append('_request_timeout')
523
524        params = locals()
525        for key, val in iteritems(params['kwargs']):
526            if key not in all_params:
527                raise TypeError(
528                    "Got an unexpected keyword argument '%s'"
529                    " to method revoke_o_auth_token" % key
530                )
531            params[key] = val
532        del params['kwargs']
533
534        collection_formats = {}
535
536        resource_path = '/v2.1/oauth2/revoke'.replace('{format}', 'json')
537        path_params = {}
538
539        query_params = {}
540
541        header_params = {}
542
543        form_params = []
544        local_var_files = {}
545
546        body_params = None
547        # HTTP header `Accept`
548        header_params['Accept'] = self.api_client.\
549            select_header_accept(['application/json'])
550
551        # Authentication setting
552        auth_settings = []
553
554        return self.api_client.call_api(resource_path, 'POST',
555                                        path_params,
556                                        query_params,
557                                        header_params,
558                                        body=body_params,
559                                        post_params=form_params,
560                                        files=local_var_files,
561                                        response_type=None,
562                                        auth_settings=auth_settings,
563                                        callback=params.get('callback'),
564                                        _return_http_data_only=params.get('_return_http_data_only'),
565                                        _preload_content=params.get('_preload_content', True),
566                                        _request_timeout=params.get('_request_timeout'),
567                                        collection_formats=collection_formats)
568
569    def update_password(self, login_part, **kwargs):
570        """
571        Updates the password for a specified user.
572        Updates the password for a specified user.
573        This method makes a synchronous HTTP request by default. To make an
574        asynchronous HTTP request, please define a `callback` function
575        to be invoked when receiving the response.
576        >>> def callback_function(response):
577        >>>     pprint(response)
578        >>>
579        >>> thread = api.update_password(login_part, callback=callback_function)
580
581        :param callback function: The callback function
582            for asynchronous request. (optional)
583        :param str login_part: Currently, only the value **password** is supported. (required)
584        :param UserPasswordInformation user_password_information:
585        :return: None
586                 If the method is called asynchronously,
587                 returns the request thread.
588        """
589        kwargs['_return_http_data_only'] = True
590        if kwargs.get('callback'):
591            return self.update_password_with_http_info(login_part, **kwargs)
592        else:
593            (data) = self.update_password_with_http_info(login_part, **kwargs)
594            return data
595
596    def update_password_with_http_info(self, login_part, **kwargs):
597        """
598        Updates the password for a specified user.
599        Updates the password for a specified user.
600        This method makes a synchronous HTTP request by default. To make an
601        asynchronous HTTP request, please define a `callback` function
602        to be invoked when receiving the response.
603        >>> def callback_function(response):
604        >>>     pprint(response)
605        >>>
606        >>> thread = api.update_password_with_http_info(login_part, callback=callback_function)
607
608        :param callback function: The callback function
609            for asynchronous request. (optional)
610        :param str login_part: Currently, only the value **password** is supported. (required)
611        :param UserPasswordInformation user_password_information:
612        :return: None
613                 If the method is called asynchronously,
614                 returns the request thread.
615        """
616
617        all_params = ['login_part', 'user_password_information']
618        all_params.append('callback')
619        all_params.append('_return_http_data_only')
620        all_params.append('_preload_content')
621        all_params.append('_request_timeout')
622
623        params = locals()
624        for key, val in iteritems(params['kwargs']):
625            if key not in all_params:
626                raise TypeError(
627                    "Got an unexpected keyword argument '%s'"
628                    " to method update_password" % key
629                )
630            params[key] = val
631        del params['kwargs']
632        # verify the required parameter 'login_part' is set
633        if ('login_part' not in params) or (params['login_part'] is None):
634            raise ValueError("Missing the required parameter `login_part` when calling `update_password`")
635
636
637        collection_formats = {}
638
639        resource_path = '/v2.1/login_information/{loginPart}'.replace('{format}', 'json')
640        path_params = {}
641        if 'login_part' in params:
642            path_params['loginPart'] = params['login_part']
643
644        query_params = {}
645
646        header_params = {}
647
648        form_params = []
649        local_var_files = {}
650
651        body_params = None
652        if 'user_password_information' in params:
653            body_params = params['user_password_information']
654        # HTTP header `Accept`
655        header_params['Accept'] = self.api_client.\
656            select_header_accept(['application/json'])
657
658        # Authentication setting
659        auth_settings = []
660
661        return self.api_client.call_api(resource_path, 'PUT',
662                                        path_params,
663                                        query_params,
664                                        header_params,
665                                        body=body_params,
666                                        post_params=form_params,
667                                        files=local_var_files,
668                                        response_type=None,
669                                        auth_settings=auth_settings,
670                                        callback=params.get('callback'),
671                                        _return_http_data_only=params.get('_return_http_data_only'),
672                                        _preload_content=params.get('_preload_content', True),
673                                        _request_timeout=params.get('_request_timeout'),
674                                        collection_formats=collection_formats)
675
676    def update_social_login(self, account_id, user_id, **kwargs):
677        """
678        Adds social account for a user.
679        Adds a new social account to a user's account.
680        This method makes a synchronous HTTP request by default. To make an
681        asynchronous HTTP request, please define a `callback` function
682        to be invoked when receiving the response.
683        >>> def callback_function(response):
684        >>>     pprint(response)
685        >>>
686        >>> thread = api.update_social_login(account_id, user_id, callback=callback_function)
687
688        :param callback function: The callback function
689            for asynchronous request. (optional)
690        :param str account_id: The external account number (int) or account ID Guid. (required)
691        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
692        :param SocialAccountInformation social_account_information:
693        :return: None
694                 If the method is called asynchronously,
695                 returns the request thread.
696        """
697        kwargs['_return_http_data_only'] = True
698        if kwargs.get('callback'):
699            return self.update_social_login_with_http_info(account_id, user_id, **kwargs)
700        else:
701            (data) = self.update_social_login_with_http_info(account_id, user_id, **kwargs)
702            return data
703
704    def update_social_login_with_http_info(self, account_id, user_id, **kwargs):
705        """
706        Adds social account for a user.
707        Adds a new social account to a user's account.
708        This method makes a synchronous HTTP request by default. To make an
709        asynchronous HTTP request, please define a `callback` function
710        to be invoked when receiving the response.
711        >>> def callback_function(response):
712        >>>     pprint(response)
713        >>>
714        >>> thread = api.update_social_login_with_http_info(account_id, user_id, callback=callback_function)
715
716        :param callback function: The callback function
717            for asynchronous request. (optional)
718        :param str account_id: The external account number (int) or account ID Guid. (required)
719        :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required)
720        :param SocialAccountInformation social_account_information:
721        :return: None
722                 If the method is called asynchronously,
723                 returns the request thread.
724        """
725
726        all_params = ['account_id', 'user_id', 'social_account_information']
727        all_params.append('callback')
728        all_params.append('_return_http_data_only')
729        all_params.append('_preload_content')
730        all_params.append('_request_timeout')
731
732        params = locals()
733        for key, val in iteritems(params['kwargs']):
734            if key not in all_params:
735                raise TypeError(
736                    "Got an unexpected keyword argument '%s'"
737                    " to method update_social_login" % key
738                )
739            params[key] = val
740        del params['kwargs']
741        # verify the required parameter 'account_id' is set
742        if ('account_id' not in params) or (params['account_id'] is None):
743            raise ValueError("Missing the required parameter `account_id` when calling `update_social_login`")
744        # verify the required parameter 'user_id' is set
745        if ('user_id' not in params) or (params['user_id'] is None):
746            raise ValueError("Missing the required parameter `user_id` when calling `update_social_login`")
747
748
749        collection_formats = {}
750
751        resource_path = '/v2.1/accounts/{accountId}/users/{userId}/social'.replace('{format}', 'json')
752        path_params = {}
753        if 'account_id' in params:
754            path_params['accountId'] = params['account_id']
755        if 'user_id' in params:
756            path_params['userId'] = params['user_id']
757
758        query_params = {}
759
760        header_params = {}
761
762        form_params = []
763        local_var_files = {}
764
765        body_params = None
766        if 'social_account_information' in params:
767            body_params = params['social_account_information']
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, 'PUT',
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)