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):
"""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):
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):
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):
"""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"""
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):
"""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 = 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):
"""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
