def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = GITHUB_USER_DATA_URL + "?" + urlencode({"access_token": access_token}) try: data = simplejson.load(dsa_urlopen(url)) except ValueError: data = None # if we have a github organization defined, test that the current users # is a member of that organization. if data and self.GITHUB_ORGANIZATION: member_url = GITHUB_ORGANIZATION_MEMBER_OF_URL.format( org=self.GITHUB_ORGANIZATION, username=data.get("login") ) try: response = dsa_urlopen(member_url) except HTTPError: data = None else: # if the user is a member of the organization, response code # will be 204, see: # http://developer.github.com/v3/orgs/members/#response-if-requester-is-an-organization-member-and-user-is-a-member if not response.code == 204: data = None return data
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = GITHUB_USER_DATA_URL + '?' + urlencode({ 'access_token': access_token }) try: data = simplejson.load(dsa_urlopen(url)) except ValueError: data = None # if we have a github organization defined, test that the current users # is a member of that organization. if data and self.GITHUB_ORGANIZATION: member_url = GITHUB_ORGANIZATION_MEMBER_OF_URL.format( org=self.GITHUB_ORGANIZATION, username=data.get('login') ) + '?' + urlencode({ 'access_token': access_token }) try: response = dsa_urlopen(member_url) except HTTPError: data = None else: # if the user is a member of the organization, response code # will be 204, see http://bit.ly/ZS6vFl if response.code != 204: raise AuthFailed('User doesn\'t belong to the ' 'organization') return data
def refresh_token(cls, token, redirect_uri): data = cls.refresh_token_params(token) data['redirect_uri'] = redirect_uri request = Request(cls.ACCESS_TOKEN_URL, data=urlencode(data), headers=cls.auth_headers()) return cls.process_refresh_token_response(dsa_urlopen(request).read())
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" if self.data.get('error'): error = self.data.get('error_description') or self.data['error'] raise AuthFailed(self, error) state = self.validate_state() client_id, client_secret = self.get_key_and_secret() params = { 'grant_type': 'authorization_code', # request auth code 'code': self.data.get('code', ''), # server response code 'client_id': client_id, 'client_secret': client_secret, 'redirect_uri': self.get_redirect_uri(state) } headers = {'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json'} request = Request(self.ACCESS_TOKEN_URL, data=urlencode(params), headers=headers) try: response = simplejson.loads(dsa_urlopen(request).read()) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise
def user_data(self, access_token, *args, **kwargs): """ Grab user profile information from facebook. returns: dict or None """ data = None params = backend_setting(self, self.EXTRA_PARAMS_VAR_NAME, {}) params['access_token'] = access_token url = FACEBOOK_ME + urlencode(params) try: response = dsa_urlopen(url) data = json.load(response) except ValueError: extra = {'access_token': sanitize_log_data(access_token)} log('error', 'Could not load user data from Facebook.', exc_info=True, extra=extra) except HTTPError: extra = {'access_token': sanitize_log_data(access_token)} log('error', 'Error validating access token.', exc_info=True, extra=extra) raise AuthTokenError(self) else: log('debug', 'Found user data for token %s', sanitize_log_data(access_token), extra={'data': data}) return data
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" if self.data.get("error"): error = self.data.get("error_description") or self.data["error"] raise AuthFailed(self, error) state = self.validate_state() client_id, client_secret = self.get_key_and_secret() params = { "grant_type": "authorization_code", # request auth code "code": self.data.get("code", ""), # server response code "client_id": client_id, "client_secret": client_secret, "redirect_uri": self.get_redirect_uri(state), } headers = {"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"} request = Request(self.ACCESS_TOKEN_URL, data=urlencode(params), headers=headers) try: response = simplejson.loads(dsa_urlopen(request).read()) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" data = None params = backend_setting(self, self.EXTRA_PARAMS_VAR_NAME, {}) params['access_token'] = access_token url = FACEBOOK_ME + urlencode(params) try: data = simplejson.load(dsa_urlopen(url)) except ValueError: extra = {'access_token': sanitize_log_data(access_token)} log('error', 'Could not load user data from Facebook.', exc_info=True, extra=extra) except HTTPError: extra = {'access_token': sanitize_log_data(access_token)} log('error', 'Error validating access token.', exc_info=True, extra=extra) raise AuthTokenError(self) else: log('debug', 'Found user data for token %s', sanitize_log_data(access_token), extra={'data': data}) mandatory = backend_setting(self, self.MANDATORY_PERMISSIONS_VAR_NAME, []) for permission in mandatory: if not data.get(permission, False): raise AuthIncomplete(self, 'Missing mandatory permission %s' % permission) return data
def user_data(self, access_token): """Return user data provided""" # Bitbucket has a bit of an indirect route to obtain user data from an # authenticated query: First obtain the user's email via an # authenticated GET url = BITBUCKET_EMAIL_DATA_URL request = self.oauth_request(access_token, url) response = self.fetch_response(request) try: # Then retrieve the user's primary email address or the top email email_addresses = simplejson.loads(response) for email_address in reversed(email_addresses): if email_address['active']: email = email_address['email'] if email_address['primary']: break # Then return the user data using a normal GET with the # BITBUCKET_USER_DATA_URL and the user's email response = dsa_urlopen(BITBUCKET_USER_DATA_URL + email) user_details = simplejson.load(response)['user'] user_details['email'] = email return user_details except ValueError: return None return None
def response(self): if not hasattr(self, '_response'): if self.data.get('error'): error = self.data.get('error_description') or self.data['error'] raise AuthFailed(self, error) state = self.validate_state() client_id, client_secret = self.get_key_and_secret() params = { 'grant_type': 'authorization_code', # request auth code 'code': self.data.get('code', ''), # server response code 'client_id': client_id, 'client_secret': client_secret, 'redirect_uri': self.get_redirect_uri(state) } headers = {'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json'} request = Request(self.ACCESS_TOKEN_URL, data=urlencode(params), headers=headers) try: self._response = simplejson.loads(dsa_urlopen(request).read()) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise except (ValueError, KeyError): raise AuthUnknownError(self)
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" if not 'assertion' in self.data: raise AuthMissingParameter(self, 'assertion') data = urlencode({ 'assertion': self.data['assertion'], 'audience': self.request.get_host() }) try: response = simplejson.load(dsa_urlopen(BROWSER_ID_SERVER, data=data)) except ValueError: log('error', 'Could not load user data from BrowserID.', exc_info=True) else: if response.get('status') == 'failure': log('debug', 'Authentication failed.') raise AuthFailed(self) kwargs.update({ 'auth': self, 'response': response, self.AUTH_BACKEND.name: True }) return authenticate(*args, **kwargs)
def refresh_token(cls, token): request = Request( cls.REFRESH_TOKEN_URL or cls.ACCESS_TOKEN_URL, data=urlencode(cls.refresh_token_params(token)), headers=cls.auth_headers() ) return cls.process_refresh_token_response(dsa_urlopen(request).read())
def vk_api(method, data, is_app=False): """Calls VK OpenAPI method https://vk.com/apiclub, https://vk.com/pages.php?o=-1&p=%C2%FB%EF%EE%EB%ED%E5%ED%E8%E5%20%E7' %E0%EF%F0%EE%F1%EE%E2%20%EA%20API """ # We need to perform server-side call if no access_token if not 'access_token' in data: if not 'v' in data: data['v'] = VK_API_VERSION if not 'api_id' in data: data['api_id'] = setting('VKAPP_APP_ID' if is_app else 'VK_APP_ID') data['method'] = method data['format'] = 'json' url = VK_SERVER_API_URL secret = setting('VKAPP_API_SECRET' if is_app else 'VK_API_SECRET') param_list = sorted(list(item + '=' + data[item] for item in data)) data['sig'] = md5(''.join(param_list) + secret).hexdigest() else: url = VK_API_URL + method params = urlencode(data) url += '?' + params try: return json.load(dsa_urlopen(url)) except (TypeError, KeyError, IOError, ValueError, IndexError): log('error', 'Could not load data from vk.com', exc_info=True, extra=dict(data=data)) return None
def odnoklassniki_api(data, api_url, public_key, client_secret, request_type='oauth'): ''' Calls Odnoklassniki REST API method http://dev.odnoklassniki.ru/wiki/display/ok/Odnoklassniki+Rest+API ''' data.update({ 'application_key': public_key, 'format': 'JSON' }) if request_type == 'oauth': data['sig'] = odnoklassniki_oauth_sig(data, client_secret) elif request_type == 'iframe_session': data['sig'] = odnoklassniki_iframe_sig(data, data['session_secret_key']) elif request_type == 'iframe_nosession': data['sig'] = odnoklassniki_iframe_sig(data, client_secret) else: msg = 'Unknown request type {0}. How should it be signed?' raise AuthFailed(msg.format(request_type)) params = urlencode(data) request = Request('{0}fb.do?{1}'.format(api_url, params)) try: return simplejson.loads(dsa_urlopen(request).read()) except (TypeError, KeyError, IOError, ValueError, IndexError): log('error', 'Could not load data from Odnoklassniki.', exc_info=True, extra=dict(data=params)) return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" try: data = dsa_urlopen(DAILYMOTION_SERVER + access_token).read() return simplejson.loads(data) except (ValueError, HTTPError): return None
def vkontakte_api(method, data): """Calls VKontakte OpenAPI method http://vkontakte.ru/apiclub, http://vkontakte.ru/pages.php?o=-1&p=%C2%FB%EF%EE%EB%ED%E5%ED%E8%E5%20 %E7%E0%EF%F0%EE%F1%EE%E2%20%EA%20 API """ # We need to perform server-side call if no access_token if not "access_token" in data: if not "v" in data: data["v"] = VKONTAKTE_API_VERSION if not "api_id" in data: data["api_id"] = _api_get_val_fun("id", "VKONTAKTE_APP_ID") data["method"] = method data["format"] = "json" url = VKONTAKTE_SERVER_API_URL secret = _api_get_val_fun("key", "VKONTAKTE_APP_SECRET") param_list = sorted(list(item + "=" + data[item] for item in data)) data["sig"] = md5("".join(param_list) + secret).hexdigest() else: url = VKONTAKTE_API_URL + method params = urlencode(data) url += "?" + params try: return simplejson.load(dsa_urlopen(url)) except (TypeError, KeyError, IOError, ValueError, IndexError): log("error", "Could not load data from VKontakte.", exc_info=True, extra=dict(data=data)) return None
def mixcloud_profile(access_token): data = {'access_token': access_token, 'alt': 'json'} request = Request(MIXCLOUD_PROFILE_URL + '?' + urlencode(data)) try: return simplejson.loads(dsa_urlopen(request).read()) except (ValueError, KeyError, IOError): return None
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" access_token = None expires = None if 'code' in self.data: state = self.validate_state() url = ACCESS_TOKEN + urlencode({ 'client_id': backend_setting(self, self.SETTINGS_KEY_NAME), 'redirect_uri': self.get_redirect_uri(state), 'client_secret': backend_setting( self, self.SETTINGS_SECRET_NAME ), 'code': self.data['code'] }) try: payload = dsa_urlopen(url) except HTTPError: raise AuthFailed(self, 'There was an error authenticating ' 'the app') response = payload.read() #parsed_response = cgi.parse_qs(response) parsed_response = json.loads(response) # print('***********************************************') # print(url) # print(response) # print(parsed_response) # print(parsed_response['access_token']) # print(parsed_response['expires_in']) # print('***********************************************') access_token = parsed_response['access_token'] if 'expires' in parsed_response: expires = parsed_response['expires'] if 'signed_request' in self.data: response = load_signed_request( self.data.get('signed_request'), backend_setting(self, self.SETTINGS_SECRET_NAME) ) if response is not None: access_token = response.get('access_token') or\ response.get('oauth_token') or\ self.data.get('access_token') if 'expires' in response: expires = response['expires'] if access_token: return self.do_auth(access_token, expires=expires, *args, **kwargs) else: if self.data.get('error') == 'access_denied': raise AuthCanceled(self) else: raise AuthException(self)
def vkontakte_api(method, data): """Calls VKontakte OpenAPI method http://vkontakte.ru/apiclub, http://vkontakte.ru/pages.php?o=-1&p=%C2%FB%EF%EE%EB%ED%E5%ED%E8%E5%20 %E7%E0%EF%F0%EE%F1%EE%E2%20%EA%20 API """ # We need to perform server-side call if no access_token if not 'access_token' in data: if not 'v' in data: data['v'] = VKONTAKTE_API_VERSION if not 'api_id' in data: data['api_id'] = _api_get_val_fun('id', 'VKONTAKTE_APP_ID') data['method'] = method data['format'] = 'json' url = VKONTAKTE_SERVER_API_URL secret = _api_get_val_fun('key', 'VKONTAKTE_APP_SECRET') param_list = sorted(list(item + '=' + data[item] for item in data)) data['sig'] = md5(''.join(param_list) + secret).hexdigest() else: url = VKONTAKTE_API_URL + method params = urlencode(data) url += '?' + params try: return simplejson.load(dsa_urlopen(url)) except (TypeError, KeyError, IOError, ValueError, IndexError): log('error', 'Could not load data from VKontakte.', exc_info=True, extra=dict(data=data)) return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = LIVE_USER_DATA_URL + "?" + urlencode({"access_token": access_token}) try: return simplejson.load(dsa_urlopen(url)) except (ValueError, IOError): raise AuthUnknownError("Error during profile retrieval, " "please, try again later")
def response(self): if not hasattr(self, '_response'): access_token = None expires = None if 'code' in self.data: state = self.validate_state() url = ACCESS_TOKEN + urlencode({ 'client_id': backend_setting(self, self.SETTINGS_KEY_NAME), 'redirect_uri': self.get_redirect_uri(state), 'client_secret': backend_setting(self, self.SETTINGS_SECRET_NAME), 'code': self.data['code'] }) try: self._response = cgi.parse_qs(dsa_urlopen(url).read()) except HTTPError: raise AuthFailed(self, 'There was an error authenticating ' 'the app') if 'signed_request' in self.data: self._response = load_signed_request(self.data.get('signed_request'), backend_setting( self, self.SETTINGS_SECRET_NAME)) return self._response
def user_data(self, access_token, *args, **kwargs): uid = kwargs.get('response', {}).get('uid') data = {'access_token': access_token, 'uid': uid} url = 'https://api.weibo.com/2/users/show.json?' + urlencode(data) try: return simplejson.loads(dsa_urlopen(url).read()) except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): uid = kwargs.get('response', {}).get('id') data = {'access_token': access_token} url = 'https://app.asana.com/api/1.0/users/me?' + urlencode(data) try: return simplejson.loads(dsa_urlopen(url).read()) except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = {'oauth_token': access_token} url = FOURSQUARE_CHECK_AUTH + '?' + urlencode(params) try: return json.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = {"access_token": access_token} url = STOCKTWITS_CHECK_AUTH + "?" + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = {'access_token': access_token} url = INSTAGRAM_CHECK_AUTH + '?' + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = {'oauth_token': access_token, 'v': date.today().strftime("%Y%m%d")} url = FOURSQUARE_CHECK_AUTH + '?' + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): uid = args[0]["uid"] data = {"access_token": access_token, "uid": uid} url = "https://api.weibo.com/2/users/show.json?" + urlencode(data) try: return simplejson.loads(dsa_urlopen(url).read()) except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" url = 'https://api.douban.com/v2/user/~me' headers = {'Authorization': 'Bearer %s' % access_token} request = Request(url, headers=headers) try: return simplejson.loads(dsa_urlopen(request).read()) except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = GITHUB_USER_DATA_URL + '?' + urlencode({ 'access_token': access_token }) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" request = self.oauth_request(access_token, DAILYMOTION_CHECK_AUTH) url = 'https://api.dailymotion.com/me/?access_token=' + access_token data = dsa_urlopen(url).read() try: return simplejson.loads(data) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = LIVE_USER_DATA_URL + '?' + urlencode( {'access_token': access_token}) try: return simplejson.load(dsa_urlopen(url)) except (ValueError, IOError): raise AuthUnknownError('Error during profile retrieval, ' 'please, try again later')
def refresh_token(cls, token): request = Request( cls.REFRESH_TOKEN_URL or cls.ACCESS_TOKEN_URL, data=urlencode(cls.refresh_token_params(token)), headers=cls.auth_headers() ) return cls.process_refresh_token_response( dsa_urlopen(request).read() )
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = SOUNDCLOUD_USER_DATA_URL + '?' + urlencode( {'oauth_token': access_token}) try: value = simplejson.load(dsa_urlopen(url)) return value except ValueError: return None
def _fetch_emails(self, access_token): """Fetch private emails from Github account""" url = GITHUB_USER_DATA_URL + '/emails?' + urlencode( {'access_token': access_token}) try: data = simplejson.load(dsa_urlopen(url)) except (ValueError, HTTPError): data = [] return data
def user_data(self, access_token, *args, **kwargs): uid = kwargs.get('response', {}).get('uid') data = {'access_token': access_token, 'uid': uid} url = 'https://pcs.baidu.com/rest/2.0/pcs/quota' try: result = dsa_urlopen(url).read() print result return simplejson.loads(result) except (ValueError, KeyError, IOError): return None
def _fetch_emails(self, access_token): """Fetch private emails from Github account""" req = Request(GITHUB_USER_DATA_URL + "/emails", headers={"Authorization": "token %s" % access_token}) try: data = json.load(dsa_urlopen(req)) except (ValueError, HTTPError): data = [] return data
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" url = OPENWISP_USER_DATA_URL + '?' + urlencode( {'access_token': access_token}) try: data = json.load(dsa_urlopen(url)) except ValueError: data = None return data
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" uid = kwargs.get('response', {}).get('user').get('id') data = {'access_token': access_token, 'userId': uid} url = 'https://api.renren.com/v2/user/get?' + urlencode(data) try: response = simplejson.loads(dsa_urlopen(url).read()) response['response']['avatar'] = response['response']['avatar'][0]['url'] return response['response'] except (Error, ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Grab user profile information from Bratabase.""" try: request = Request( self.ME_URL, headers={'Authorization': 'bearer %s' % access_token}) return simplejson.load(dsa_urlopen(request)) except ValueError: return None except HTTPError: raise AuthTokenError(self)
def user_data(self, access_token, *args, **kwargs): params = { 'method': 'currentUser', 'extras': 'username,displayName,streamRegion', 'access_token': access_token, } response = dsa_urlopen(self.RDIO_API_BASE, urllib.parse.urlencode(params)) try: return simplejson.load(response)['result'] except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = { 'access_token': access_token, 'api_secret': backend_setting(self, self.SETTINGS_SECRET_NAME), } url = DISQUS_CHECK_AUTH + '?' + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Grab user profile information from reddit.""" try: request = Request( 'https://oauth.reddit.com/api/v1/me.json', headers={'Authorization': 'bearer %s' % access_token}) return simplejson.load(dsa_urlopen(request)) except ValueError: return None except HTTPError: raise AuthTokenError(self)
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" params = {'oauth_token': access_token} url = FOURSQUARE_CHECK_AUTH + '?' + urlencode(params) try: results = json.load(dsa_urlopen(url)) # Foursquare doesn't return access_token or oauth_token so we need to add it for saving on UserSocialAuth results['access_token'] = access_token return results except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" fields_selectors = LINKEDIN_FIELD_SELECTORS + \ setting('LINKEDIN_EXTRA_FIELD_SELECTORS', []) url = LINKEDIN_CHECK_AUTH + ':(%s)' % ','.join(set(fields_selectors)) data = {'oauth2_access_token': access_token, 'format': 'json'} request = Request(url + '?' + urlencode(data)) try: return simplejson.loads(dsa_urlopen(request).read()) except (ExpatError, KeyError, IndexError): return None
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" access_token = None expires = None if 'code' in self.data: state = self.validate_state() url = ACCESS_TOKEN + urlencode({ 'client_id': backend_setting(self, self.SETTINGS_KEY_NAME), 'redirect_uri': self.get_redirect_uri(state), 'client_secret': backend_setting(self, self.SETTINGS_SECRET_NAME), 'code': self.data['code'] }) try: payload = dsa_urlopen(url) except HTTPError: raise AuthFailed( self, 'There was an error authenticating ' 'the app') response = payload.read() parsed_response = simplejson.loads(response) print 'parsed_response', parsed_response access_token = parsed_response['access_token'] if 'expires' in parsed_response: expires = parsed_response['expires'] if 'signed_request' in self.data: response = load_signed_request( self.data.get('signed_request'), backend_setting(self, self.SETTINGS_SECRET_NAME)) if response is not None: access_token = response.get('access_token') or\ response.get('oauth_token') or\ self.data.get('access_token') if 'expires' in response: expires = response['expires'] if access_token: return self.do_auth(access_token, expires=expires, *args, **kwargs) else: if self.data.get('error') == 'access_denied': raise AuthCanceled(self) else: raise AuthException(self)
def user_data(self, access_token, *args, **kwargs): """Loads user data from service""" token = access_token.key params = { "token": token, "key": backend_setting(self, self.SETTINGS_KEY_NAME) } url = TRELLO_USER_DETAILS_URL + "?" + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except ValueError: return None
def consumer_oauth_url_request(backend, url, user_or_id, redirect_uri='/', json=True): """Builds and retrieves an OAuth signed response.""" user = UserSocialAuth.resolve_user_or_id(user_or_id) oauth_info = user.social_auth.filter(provider=backend.AUTH_BACKEND.name)[0] token = Token.from_string(oauth_info.tokens['access_token']) request = build_consumer_oauth_request(backend, token, url, redirect_uri) response = '\n'.join(dsa_urlopen(request.to_url()).readlines()) if json: response = simplejson.loads(response) return response
def get_open_id(self, access_token): data = {'access_token': access_token} url = 'https://graph.qq.com/oauth2.0/me?' + urlencode(data) res = dsa_urlopen(url).read() #obj = res.read() if res.find('callback') > -1: pos_lb = res.find('{') pos_rb = res.find('}') res = res[pos_lb:pos_rb + 1] openid_dict = simplejson.loads(res, encoding='utf-8') openid = openid_dict['openid'] return openid
def googleapis_profile(url, access_token): """ Loads user data from googleapis service, such as name, given_name, family_name, etc. as it's described in: https://developers.google.com/accounts/docs/OAuth2Login """ data = {'access_token': access_token, 'alt': 'json'} request = Request(url + '?' + urlencode(data)) try: return simplejson.loads(dsa_urlopen(request).read()) except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, response, *args, **kwargs): """Loads user data from service""" params = {'oauth_token': access_token, 'format': 'json', 'text': 1, } url = self.get_api_url() + '?' + urlencode(params) try: return simplejson.load(dsa_urlopen(url)) except (ValueError, IndexError): log('error', 'Could not load data from Yandex.', exc_info=True, extra=dict(data=params)) return None
def auth_complete(self, *args, **kwargs): """Completes loging process, must return user instance""" self.process_error(self.data) params = self.auth_complete_params(self.validate_state()) request = Request(self.ACCESS_TOKEN_URL, data=urlencode(params), headers=self.auth_headers()) try: response = simplejson.loads(dsa_urlopen(request).read()) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise
def googleapis_email(url, params): """Loads user data from googleapis service, only email so far as it's described in http://sites.google.com/site/oauthgoog/Home/emaildisplayscope Parameters must be passed in queryset and Authorization header as described on Google OAuth documentation at: http://groups.google.com/group/oauth/browse_thread/thread/d15add9beb418ebc and: http://code.google.com/apis/accounts/docs/OAuth2.html#CallingAnAPI """ request = Request(url + '?' + params, headers={'Authorization': params}) try: return simplejson.loads(dsa_urlopen(request).read())['data'] except (ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" params = { 'method': 'currentUser', 'extras': 'username,displayName,streamRegion', } request = self.oauth_post_request(access_token, self.RDIO_API_BASE, params=params) response = dsa_urlopen(request.url, request.to_postdata()) json = '\n'.join(response.readlines()) try: return simplejson.loads(json)['result'] except ValueError: return None
def user_data(self, access_token, *args, **kwargs): """Return user data provided""" openid = self.get_open_id(access_token) data = { 'access_token': access_token, 'openid': openid, 'format': 'JSON', 'oauth_consumer_key': setting('QQ_CLIENT_ID') } url = 'https://graph.qq.com/user/get_simple_userinfo?' + urlencode( data) # + urlencode(data) try: return simplejson.loads(dsa_urlopen(url).read()) except (Error, ValueError, KeyError, IOError): return None
def user_data(self, access_token, *args, **kwargs): """Load user data from yammer""" params = { 'client_id': setting(self.SETTINGS_KEY_NAME, ''), 'client_secret': setting(self.SETTINGS_SECRET_NAME, ''), 'code': access_token } url = '%s?%s' % (self.ACCESS_TOKEN_URL, urlencode(params)) try: return simplejson.load(dsa_urlopen(url)) except Exception as e: logging.exception(e) return None
def mailru_api(data): """ Calls Mail.ru REST API method http://api.mail.ru/docs/guides/restapi/ """ data.update({'app_id': settings.MAILRU_OAUTH2_CLIENT_KEY, 'secure': '1'}) data['sig'] = mailru_sig(data) params = urlencode(data) request = Request(MAILRU_API_URL, params) try: return simplejson.loads(dsa_urlopen(request).read()) except (TypeError, KeyError, IOError, ValueError, IndexError): log('error', 'Could not load data from Mail.ru.', exc_info=True, extra=dict(data=params)) return None