def callback():
client = OAuth2Session(
self.client_id,
state=session["oauth_state"],
redirect_uri=url_for(".callback", _external=True),
)
if self.name == "facebook":
facebook_compliance_fix(client)
self.token = client.fetch_token(
self.token_url,
client_secret=self.client_secret,
authorization_response=request.url,
)
# Get additional data for the user
user_data = self.get_user_info()
# Ensure the user is registered
user = self.get_or_create_user(user_data)
# Store the (serialized) user info on the sessions
session["user"] = self.serialize_user(user)
# Redirect the user to the requested page
if session.get("next") is not None:
url = session["next"]
del session["next"]
return redirect(url)
# Default is to redirect to the root
return redirect("/")
def __init__(self):
super(FacebookGraph, self).__init__(
app.config['FACEBOOK_APP_ID'],
redirect_uri=url_for('facebook_auth_return', _external=True),
token=runtime_config.get('facebook_token'),
)
facebook_compliance_fix(self)
def start_facebook_session():
global facebook_session
# 0 - get token from cache
try:
token = get_saved_token()
except FileNotFoundError:
token = None
if token:
facebook_initial_session = OAuth2Session(APP_ID, token=token)
facebook_session = facebook_compliance_fix(facebook_initial_session)
else:
# 1 - session
facebook_initial_session = OAuth2Session(APP_ID, redirect_uri=REDIRECT_URI, scope=scope)
facebook_session = facebook_compliance_fix(facebook_initial_session)
# 2 - authorization
authorization_url, state = facebook_session.authorization_url(AUTHORIZATION_BASE_URL)
print('Opening browser to {} for authorization'.format(authorization_url))
webbrowser.open(authorization_url)
# 3 - token
redirect_response = input('Paste the full redirect URL here: ')
token = facebook_session.fetch_token(TOKEN_URL, client_secret=APP_SECRET,
authorization_response=redirect_response.strip())
# 4 - save token
save_token(token)
def get_session(self):
fb = OAuth2Session(
self.settings['client_id'],
scope=self.settings['scope'],
redirect_uri=self.callback_url()
)
facebook_compliance_fix(fb)
return fb
def start_flow(request: Request, redirect_uri: str = None) -> dict:
"""
Starts the oauth flow. This will return a dict which causes a redirect to the providers page.
:param request: The Pyramid Request associated with the OAuth request.
:param redirect_uri: The URL to redirect to.
:return:
"""
next_url = request.application_url + '/discuss' if not redirect_uri else redirect_uri
LOG.debug("Read OAuth id/secret: none? %s/%s", CLIENT_ID is None,
CLIENT_SECRET is None)
oauth_session = OAuth2Session(CLIENT_ID,
scope=','.join(SCOPE),
redirect_uri=(request.application_url +
REDIRECT_PATH))
oauth_session = facebook_compliance_fix(oauth_session)
authorization_url, state = oauth_session.authorization_url(
AUTHORIZATION_BASE_URL)
request.session['oauth_session'] = oauth_session
request.session['csrf'] = state
request.session['next'] = next_url
LOG.debug("Please go to %s and authorize access", authorization_url)
return {'authorization_url': authorization_url, 'error': ''}
def get(self, request, *args, **kwargs):
facebook = OAuth2Session(settings.FACEBOOK_CLIENT_ID,
redirect_uri=settings.FACEBOOK_REDIRECT_URI)
facebook = facebook_compliance_fix(facebook)
if 'code' not in self.request.GET:
authorization_url, state = facebook.authorization_url(
self.authorization_base_url)
return HttpResponseRedirect(authorization_url)
else:
auth_code = self.request.GET['code']
facebook.fetch_token(
self.token_url.format(version=self.graph_api_version),
client_secret=settings.FACEBOOK_CLIENT_SECRET,
code=auth_code)
user_info = json.loads(
facebook.get(
self.me_url.format(version=self.graph_api_version,
fields=self.fields)).text)
username = "******".format(user_info['id'])
email = user_info['email'] or ''
ott = self.save_user(username, email, user_info)
context = {'ott': ott, 'redirect_url': '/stations/list'}
return self.render_to_response(context)
def start_flow(redirect_uri):
"""
:param redirect_uri:
:return:
"""
client_id = os.environ.get('OAUTH_FACEBOOK_CLIENTID', None)
client_secret = os.environ.get('OAUTH_FACEBOOK_CLIENTKEY', None)
logger(
'Facebook OAuth',
'Read OAuth id/secret: none? {}/{}'.format(client_id is None,
client_secret is None))
if 'service=facebook' not in redirect_uri:
bind = '#' if '?' in redirect_uri else '?'
redirect_uri = '{}{}{}'.format(redirect_uri, bind, 'service=facebook')
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
logger('Facebook OAuth',
'Please go to {} and authorize access'.format(authorization_url))
return {'authorization_url': authorization_url, 'error': ''}
def callback():
facebook = requests_oauthlib.OAuth2Session(FB_CLIENT_ID,
scope=FB_SCOPE,
redirect_uri=URL +
"/fb-callback")
# we need to apply a fix for Facebook here
facebook = facebook_compliance_fix(facebook)
facebook.fetch_token(
FB_TOKEN_URL,
client_secret=FB_CLIENT_SECRET,
authorization_response=flask.request.url,
)
# Fetch a protected resource, i.e. user profile, via Graph API
facebook_user_data = facebook.get(
"https://graph.facebook.com/me?fields=id,name,email,picture{url}"
).json()
# Fb user data
email = facebook_user_data["email"]
name = facebook_user_data["name"]
picture_url = facebook_user_data.get("picture", {}).get("data",
{}).get("url")
#login details
return f"""
def get_authorization_url(self, request, config, callback_url):
oauth = OAuth2Session(
config.client_id, scope=config.scope, redirect_uri=callback_url
)
oauth = facebook_compliance_fix(oauth)
authorization_url, _ = oauth.authorization_url(config.authorize_url)
return authorization_url
def makeFacebookRequest(baseURL, params={}):
global facebook_session
if not facebook_session:
#OAuth endpoints given in the Facebook API documentation
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
token_url = 'https://graph.facebook.com/oauth/access_token'
redirect_uri = 'https://www.programsinformationpeople.org/runestone/oauth'
scope = [
'user_posts', 'pages_messaging', 'user_managed_groups',
'user_status', 'user_likes'
]
facebook = OAuth2Session(APP_ID,
redirect_uri=redirect_uri,
scope=scope)
facebook_session = facebook_compliance_fix(facebook)
authorization_url, state = facebook_session.authorization_url(
authorization_base_url)
print('Opening browser to {} for authorization'.format(
authorization_url))
webbrowser.open(authorization_url)
redirect_response = input('Paste the full redirect URL here: ')
facebook_session.fetch_token(
token_url,
client_secret=APP_SECRET,
authorization_response=redirect_response.strip())
return facebook_session.get(baseURL, params=params)
def __call__(self):
oauthWorkFlow = OauthWorkFlow(oauthServerName="facebook")
client_id, client_secret, scope, redirect_uri = oauthWorkFlow.getRegistryValue()
code = getattr(self.request, 'code', None)
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri, scope=scope)
facebook = facebook_compliance_fix(facebook)
if code == None:
if hasattr(self.request, 'error'):
self.request.response.redirect("/")
return
authorization_url, state = facebook.authorization_url(self.authorization_base_url)
self.request.response.redirect(authorization_url)
return
user = oauthWorkFlow.getUserInfo(facebook, self.token_url, client_secret, code, self.getUrl).json()
# check has id, if True, is a relogin user, if False, is a new user
userid = safe_unicode("fb%s") % user["id"]
if api.user.get(userid=userid) is not None:
self.context.acl_users.session._setupSession(userid.encode("utf-8"), self.context.REQUEST.RESPONSE)
self.request.RESPONSE.redirect("/")
return
userInfo = dict(
fullname=safe_unicode(user.get("name", "")),
description=safe_unicode(user.get("about", "")),
location=safe_unicode(user.get("locale", "")),
fbGender=safe_unicode(user.get("gender", "")),
home_page=safe_unicode(user.get("link", "")),
)
oauthWorkFlow.createUser(userid, safe_unicode((user.get("email", ""))), userInfo)
self.context.acl_users.session._setupSession(userid.encode("utf-8"), self.context.REQUEST.RESPONSE)
self.request.RESPONSE.redirect("/")
return
def process_fb_login_callback_sync(code):
conf = load_fb_login_configuration()
fb_app_id = conf['app_id']
fb_app_secret = conf['app_secret']
callback_url = conf['callback_url']
token_url = 'https://graph.facebook.com/oauth/access_token'
from requests_oauthlib import OAuth2Session
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
facebook = OAuth2Session(fb_app_id, redirect_uri=callback_url)
facebook = facebook_compliance_fix(facebook)
token = facebook.fetch_token(token_url,
client_secret=fb_app_secret,
code=code)
r = facebook.get('https://graph.facebook.com/me')
logger.debug('facebook /me without fields: %s', r.content)
r = facebook.get('https://graph.facebook.com/me?fields=id,name,email')
logger.debug('facebook /me with fields: %s', r.content)
# response:{"id":"102...61723","name":"Pe...er","email":"pe...com"}
me = r.json()
user_info = {
'fb_id': me['id'],
'name': me['name'],
'email': me['email'],
}
return token, user_info
def get_authorization_url(self, request, config, callback_url):
oauth = OAuth2Session(config.client_id,
scope=config.scope,
redirect_uri=callback_url)
oauth = facebook_compliance_fix(oauth)
authorization_url, _ = oauth.authorization_url(config.authorize_url)
return authorization_url
def facebook_auth(request):
oauth = OAuth2Session(client_id,
redirect_uri=redirect_uri,
scope='user_posts')
oauth = facebook_compliance_fix(oauth)
authorization_url, state = oauth.authorization_url(authorization_base_url)
return redirect(authorization_url)
def callback():
URL = request.url_root.strip("/")
print(URL)
facebook = requests_oauthlib.OAuth2Session(FB_CLIENT_ID,
scope=FB_SCOPE,
redirect_uri=URL +
"/fb-callback")
facebook = facebook_compliance_fix(facebook)
facebook.fetch_token(
FB_TOKEN_URL,
client_secret=FB_CLIENT_SECRET,
authorization_response=flask.request.url,
)
facebook_user_data = facebook.get(
"https://graph.facebook.com/me?fields=id,name,email,picture{url}"
).json()
email = facebook_user_data["email"]
name = facebook_user_data["name"]
picture_url = facebook_user_data.get("picture", {}).get("data",
{}).get("url")
result = get_products()
session["USERNAME"] = email
return render_template('index.html', data=result, user_data=email)
def __init__(self, user):
self.fb = OAuth2Session(
settings.SOCIAL_AUTH_FACEBOOK_KEY,
redirect_uri=redirect_uri
)
self.fb = facebook_compliance_fix(self.fb)
self.accounts = user.social_auth.filter(provider="facebook")
def get_fb_oauth2_session(conf):
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
if not conf.client_id:
raise web.HTTPInternalServerError(text='credentials not configured')
sess = OAuth2Session(client_id=conf.client_id, redirect_uri=conf.callback_url)
sess = facebook_compliance_fix(sess)
return sess
def fb_callback():
facebook = requests_oauthlib.OAuth2Session(
FB_CLIENT_ID, scope=FB_SCOPE, redirect_uri=URL + "/fb-callback"
)
# we need to apply a fix for Facebook here
facebook = facebook_compliance_fix(facebook)
facebook.fetch_token(
FB_TOKEN_URL,
client_secret=FB_CLIENT_SECRET,
authorization_response=URL + flask.request.full_path,
)
# Fetch a protected resource, i.e. user profile, via Graph API
facebook_user_data = facebook.get(
"https://graph.facebook.com/me?fields=id,name,email,picture{url}"
).json()
email = facebook_user_data.get("email")
name = facebook_user_data["name"]
avatar_url = facebook_user_data.get("picture", {}).get("data", {}).get("url")
return flask.render_template(
"user_info.html",
name=name,
email=email,
avatar_url=avatar_url,
provider="Facebook",
)
def _get_oauth2_info(client_id, client_secret, scope, redirect_uri, token_url, user_info_url, request, params, is_facebook=False):
headers = dict(request.headers)
cookies = dict(request.cookies)
cfg.logger.debug('params: %s headers: %s cookies: %s', params, headers, cookies)
the_auth = OAuth2Session(client_id, scope=scope, redirect_uri=redirect_uri)
if is_facebook:
the_auth = facebook_compliance_fix(the_auth)
# fetch token
#the_path = params.get('url', '')
qs = urllib.urlencode(params)
redirect_url = redirect_uri + '?' + qs
token = the_auth.fetch_token(token_url, client_secret=client_secret,
authorization_response=redirect_url)
cfg.logger.debug('after fetch_token: token: (%s, %s)', token, token.__class__.__name__)
# get user info
r = the_auth.get(user_info_url)
return r.content
def get_fb_oauth2_session(conf):
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
if not conf.client_id:
raise web.HTTPInternalServerError(text='credentials not configured')
sess = OAuth2Session(client_id=conf.client_id,
redirect_uri=conf.callback_url)
sess = facebook_compliance_fix(sess)
return sess
def __init__(self):
super().__init__(
'facebook',
authorization_url='https://www.facebook.com/v2.1/dialog/oauth',
get_token_url='https://graph.facebook.com/v2.1/oauth/access_token',
)
self.oauth = facebook_compliance_fix(self.oauth)
def __init__(self):
super().__init__(
"facebook",
authorization_url="https://www.facebook.com/v2.1/dialog/oauth",
get_token_url="https://graph.facebook.com/v2.1/oauth/access_token",
)
self.oauth = facebook_compliance_fix(self.oauth)
def fblogin(request):
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
facebook = OAuth2Session(fb_client_id, redirect_uri=fb_redirect_uri)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
return HttpResponseRedirect(authorization_url)
def facebook_login(request):
client_id = settings.FB_OAUTH_CLIENT_ID
client_secret = settings.FB_OAUTH_CLIENT_SECRET
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
token_url = 'https://graph.facebook.com/oauth/access_token'
redirect_uri = '%s://%s/user/facebook-login' % (request.scheme,
request.get_host())
if settings.DEBUG:
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
try:
oauth_state = request.session['oauth_state']
del request.session['oauth_state']
except KeyError:
oauth_state = None
facebook = OAuth2Session(client_id,
scope='email',
redirect_uri=redirect_uri,
state=oauth_state)
facebook = facebook_compliance_fix(facebook)
if request.GET.get('error') == 'access_denied':
return redirect('/user/login/')
elif not request.GET.get('code'):
authorization_url, state = facebook.authorization_url(
authorization_base_url)
request.session['oauth_state'] = state
return redirect(authorization_url)
else:
facebook.fetch_token(
token_url,
client_secret=client_secret,
authorization_response=request.build_absolute_uri())
r = facebook.get(
'https://graph.facebook.com/me?fields=first_name,last_name,email')
data = r.json()
try:
profile = UserProfile.objects.get(facebook_user_id=data.get('id'))
login(request,
profile.user,
backend='allauth.account.auth_backends.AuthenticationBackend')
return redirect('/')
except UserProfile.DoesNotExist:
pass
return render(
request, 'account/signup.html', {
'facebook_user_id': data.get('id'),
'first_name': data.get('first_name'),
'last_name': data.get('last_name'),
'email': data.get('email'),
'date_of_birth': data.get('birthday'),
})
def get_auth_link(self, user_manager):
facebook = OAuth2Session(self._client_id,
redirect_uri=web.ctx.home +
self._callback_page)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
user_manager.set_session_oauth_state(state)
return authorization_url
def get_oauth2session(self):
"""
Returns a Facebook requests_oauthlib OAuth2Session
"""
self.oauth = OAuth2Session(client_id = self.client_id,
redirect_uri = self.redirect_uri)
self.oauth = facebook_compliance_fix(self.oauth)
return self.oauth
def get_access_token(provider, authorization_response, redirect_uri):
if provider == Provider.GOOGLE:
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['GOOGLE']['client_id'],
redirect_uri=redirect_uri
)
ret = p.fetch_token(
GOOGLE_TOKEN_URL,
client_secret=settings.STORMPATH_SOCIAL['GOOGLE']['client_secret'],
authorization_response=authorization_response
)
return ret['access_token']
elif provider == Provider.FACEBOOK:
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['FACEBOOK']['client_id'],
redirect_uri=redirect_uri
)
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
p = facebook_compliance_fix(p)
ret = p.fetch_token(
FACEBOOK_TOKEN_URL,
client_secret=settings.STORMPATH_SOCIAL['FACEBOOK']['client_secret'],
authorization_response=authorization_response
)
return ret['access_token']
elif provider == Provider.GITHUB or provider.upper() == Provider.GITHUB:
p = OAuth2Session(client_id=settings.STORMPATH_SOCIAL['GITHUB']['client_id'])
ret = p.fetch_token(
GITHUB_TOKEN_URL,
client_secret=settings.STORMPATH_SOCIAL['GITHUB']['client_secret'],
authorization_response=authorization_response
)
return ret['access_token']
elif provider == Provider.LINKEDIN:
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['LINKEDIN']['client_id'],
redirect_uri=redirect_uri
)
from requests_oauthlib.compliance_fixes import linkedin_compliance_fix
p = linkedin_compliance_fix(p)
ret = p.fetch_token(
LINKEDIN_TOKEN_URL,
client_secret=settings.STORMPATH_SOCIAL['LINKEDIN']['client_secret'],
authorization_response=authorization_response
)
return ret['access_token']
else:
return None
def get_auth_link(self, auth_storage, share=False):
facebook = OAuth2Session(
self._client_id,
scope=scope + (["publish_actions"] if share else []),
redirect_uri=web.ctx.home + self._callback_page)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
auth_storage["oauth_state"] = state
return authorization_url
def login():
client = OAuth2Session(
self.client_id,
scope=self.scopes,
redirect_uri=url_for(".callback", _external=True),
)
if self.name == "facebook":
facebook_compliance_fix(client)
authorization_url, state = client.authorization_url(
self.authorization_base_url,
access_type="offline",
prompt="select_account",
)
# State is used to prevent CSRF, keep this for later.
session["oauth_state"] = state
return redirect(authorization_url)
def request_auth(self, request):
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
self.session = OAuth2Session(self.client_id,
redirect_uri=self.redirect_uri,
scope=self.scope)
self.session = facebook_compliance_fix(self.session)
authorization_url, state = self.session.authorization_url(
self.authorization_base_url)
return authorization_url
def get_facebook(session=None):
if session:
facebook = OAuth2Session(FACEBOOK_CLIENT_ID, token=session['oauth_token'])
else:
facebook = OAuth2Session(
FACEBOOK_CLIENT_ID,
redirect_uri=FACEBOOK_REDIRECT_URI,
scope=['user_photos']
)
return facebook_compliance_fix(facebook)
def login_fb(request):
q=request.GET.get("url",None)
if q:
request.session["url"]=q
authorization_base_url = 'https://www.facebook.com/dialog/oauth/?scope=user_friends,email,public_profile'
token_url = 'https://graph.facebook.com/oauth/access_token'
#redirect_uri = 'https://pacific-shelf-88987.herokuapp.com/redirect_facebook/'
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(authorization_base_url)
return HttpResponseRedirect(authorization_url)
def fbCallback():
facebook = requests_oauthlib.OAuth2Session(FB_CLIENT_ID,
scope=FB_SCOPE,
redirect_uri=URL +
"/fb-callback")
# we need to apply a fix for Facebook here
facebook = facebook_compliance_fix(facebook)
facebook.fetch_token(
FB_TOKEN_URL,
client_secret=FB_CLIENT_SECRET,
authorization_response=request.url,
)
# Fetch a protected resource, i.e. user profile, via Graph API
facebook_user_data = facebook.get(
"https://graph.facebook.com/me?fields=id,name,email,picture{url}"
).json()
unique_id = facebook_user_data["id"]
email = facebook_user_data["email"]
name = facebook_user_data["name"]
picture_url = facebook_user_data.get("picture", {}).get("data",
{}).get("url")
# Create a user in your db with the information provided
# by Facebook
id = unique_id
profile_pic = picture_url
user = User(id, name, email, profile_pic)
# Doesn't exist? Add it to the database.
if not db.session.query(User).filter(User.id == id).count():
db.session.add(user)
db.session.commit()
# Begin user session by logging the user in
login_user(user)
# Send user to dance page
if current_user.is_authenticated:
return redirect("/")
# else:
dances = db.session.query(Dance).filter(Dance.user_id == id).all()
# Send user to dance page
return render_template('dance.html',
name=name,
email=email,
avatar_url=profile_pic,
dances=dances)
def logfb(request):
authorization_base_url = (
"https://www.facebook.com/dialog/oauth/?scope=user_friends,email,public_profile"
)
token_url = "https://graph.facebook.com/oauth/access_token/"
# redirect_uri = 'https://pacific-shelf-88987.herokuapp.com/redirect_facebook/'
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(
authorization_base_url)
return HttpResponseRedirect(authorization_url)
def setUp(self):
mocker = requests_mock.Mocker()
mocker.post(
"https://graph.facebook.com/oauth/access_token",
text="access_token=urlencoded",
headers={"Content-Type": "text/plain"},
)
mocker.start()
self.addCleanup(mocker.stop)
facebook = OAuth2Session("someclientid", redirect_uri="https://i.b")
self.session = facebook_compliance_fix(facebook)
def facebook_oauth(self, **kw):
Oauth = request.env['oauth.oauth']
facebook = Oauth.sudo().get_provider('Facebook')
callback_uri = self.get_callback_url('facebook')
scope = ["email"]
oauth_session = OAuth2Session(facebook.client_id,
scope=scope,
redirect_uri=callback_uri)
oauth_session = facebook_compliance_fix(oauth_session)
authorization_url, state = oauth_session.authorization_url(
facebook.auth_endpoint)
return http.redirect_with_hash(authorization_url)
def facebook():
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
facebook = OAuth2Session(facebook_client_id,
redirect_uri=facebook_redirect_uri)
facebook = facebook_compliance_fix(facebook)
facebook_authorization_url, state = facebook.authorization_url(
facebook_authorization_base_url)
session['oauth_state'] = state
return redirect(facebook_authorization_url)
def setUp(self):
mocker = requests_mock.Mocker()
mocker.post(
"https://graph.facebook.com/oauth/access_token",
text="access_token=urlencoded",
headers={"Content-Type": "text/plain"},
)
mocker.start()
self.addCleanup(mocker.stop)
facebook = OAuth2Session('foo', redirect_uri='https://i.b')
self.session = facebook_compliance_fix(facebook)
def __init__(self,
client_id=creds['CLIENT_ID'],
scope=_SCOPE,
redirect_uri=_REDIRECT_URI,
token=None,
state=None):
super().__init__(client_id=cred['CLIENT_ID'],
scope=scope,
redirect_uri=redirect_uri,
token=token,
state=state)
self = facebook_compliance_fix(self)
def get_user_info(self) -> Dict:
"""Method to get user info for the logged in user.
Raises:
UnauthorizedException: When the user is not authenticated
Returns:
Dict: The user profile
"""
try:
# Get the token
token = self.token
# Helper method to update the token in the session
def token_updater(token):
self.token = token
# Get a session with auto-refresh of the token
client = OAuth2Session(
self.client_id,
token=token,
auto_refresh_kwargs={
"client_id": self.client_id,
"client_secret": self.client_secret,
},
auto_refresh_url=self.refresh_url,
token_updater=token_updater,
)
if self.name == "facebook":
facebook_compliance_fix(client)
# Return the user info
return client.get(self.user_profile_endpoint + "fields=" +
",".join(self.fields)).json()
except Exception:
raise UnauthorizedException()
def fbauth(request):
redirect_response = request.GET.get("code")
facebook = OAuth2Session(fb_client_id, redirect_uri=fb_redirect_uri)
facebook = facebook_compliance_fix(facebook)
token_url = 'https://graph.facebook.com/oauth/access_token'
token = facebook.fetch_token(token_url,
client_secret=fb_client_secret,
code=redirect_response)
print("*" * 100)
access_token = token.get("access_token")
resp = requests.get('https://graph.facebook.com/me?access_token=%s' %
access_token)
return HttpResponse(resp.content)
def test_fetch_access_token(self):
facebook = OAuth2Session('foo', redirect_uri='https://i.b')
facebook = facebook_compliance_fix(facebook)
facebook.post = mock.MagicMock()
response = requests.Response()
response.status_code = 200
response._content = 'access_token=urlencoded'.encode('UTF-8')
response.headers['Content-Type'] = 'text/plain'
facebook.post.return_value = response
token = facebook.fetch_token('https://mocked.out',
client_secret='bar',
authorization_response='https://i.b/?code=hello')
self.assertEqual(token, {'access_token': 'urlencoded', 'token_type': 'Bearer'})
def get_user(self, request, config, callback_url):
oauth = OAuth2Session(
config.client_id, scope=config.scope, redirect_uri=callback_url
)
oauth = facebook_compliance_fix(oauth)
oauth.fetch_token(
config.access_token_url,
client_secret=config.secret,
authorization_response=request.url,
)
response = oauth.get(config.request_url)
data = response.json()
uid = data["id"]
display_name = data.get("name")
return User(uid, display_name, data)
def fbredirect():
"""
:URL: /login_with_facebook
:Methods: GET, POST
Redirects the user to a Facebook login page
"""
facebook = OAuth2Session(FB_CLIENT_ID, redirect_uri=redirect_uri())
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(authorization_base_url)
logger.info('Facebook redirect for ip {}, referrer was {}'.format(request.remote_addr, request.referrer))
session['facebook_state'] = state
return redirect('{}&scope=public_profile,email'.format(authorization_url))
def authorization_url(self):
try:
redirect_uri = ''.join(('http://', IN.APP.config.app_domain, '/', 'social/callback/!', self.__type__))
fb = OAuth2Session(self.config['client_id'], scope = self.config['scope'], redirect_uri = redirect_uri)
fb = facebook_compliance_fix(fb)
authorization_url, state = fb.authorization_url(self.config['authorization_url'])
return authorization_url
except Exception as e:
IN.logger.debug()
def test_fetch_access_token(self):
facebook = OAuth2Session("foo", redirect_uri="https://i.b")
facebook = facebook_compliance_fix(facebook)
facebook.post = mock.MagicMock()
response = requests.Response()
response.status_code = 200
response.request = mock.MagicMock()
response._content = "access_token=urlencoded".encode("UTF-8")
response.headers["Content-Type"] = "text/plain"
facebook.post.return_value = response
token = facebook.fetch_token(
"https://mocked.out", client_secret="bar", authorization_response="https://i.b/?code=hello"
)
self.assertEqual(token, {"access_token": "urlencoded", "token_type": "Bearer"})
def fb_login(request):
'''Facebook login request call.'''
url = 'https://www.facebook.com/dialog/oauth'
facebook = OAuth2Session(
settings.FACEBOOK_ID,
redirect_uri='http://localhost:8000/fb-callback/',
)
facebook = facebook_compliance_fix(facebook)
authorization_url, _ = facebook.authorization_url(
url,
verify=False
)
return redirect(authorization_url)
def get_authorization_url(provider, redirect_uri):
if provider == Provider.GOOGLE:
scope = ['email', "profile"]
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['GOOGLE']['client_id'],
scope=scope,
redirect_uri=redirect_uri
)
authorization_url, state = p.authorization_url(GOOGLE_AUTHORIZATION_BASE_URL)
return authorization_url, state
elif provider == Provider.FACEBOOK:
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['FACEBOOK']['client_id'],
redirect_uri=redirect_uri
)
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
p = facebook_compliance_fix(p)
authorization_url, state = p.authorization_url(FACEBOOK_AUTHORIZATION_BASE_URL)
return authorization_url, state
elif provider == Provider.GITHUB or provider.upper() == Provider.GITHUB:
p = OAuth2Session(client_id=settings.STORMPATH_SOCIAL['GITHUB']['client_id'])
authorization_url, state = p.authorization_url(GITHUB_AUTHORIZATION_BASE_URL)
return authorization_url, state
elif provider == Provider.LINKEDIN:
p = OAuth2Session(
client_id=settings.STORMPATH_SOCIAL['LINKEDIN']['client_id'],
redirect_uri=redirect_uri
)
from requests_oauthlib.compliance_fixes import linkedin_compliance_fix
p = linkedin_compliance_fix(p)
authorization_url, state = p.authorization_url(LINKEDIN_AUTHORIZATION_BASE_URL)
return authorization_url, state
else:
raise RuntimeError('Invalid Provider {}'.format(provider))
def fetch_token(self, key, authorization_response):
try:
client_id = self.config['client_id']
token_url = self.config['token_url']
client_secret = self.config['client_secret']
redirect_uri = ''.join(('http://', IN.APP.config.app_domain, '/', 'social/callback/!', self.__type__))
self.session = OAuth2Session(client_id, state = key, redirect_uri = redirect_uri)
self.session = facebook_compliance_fix(self.session)
token = self.session.fetch_token(token_url, client_secret = client_secret, authorization_response = authorization_response)
return token
except Exception as e:
IN.logger.debug()
def get(self, request, *args, **kwargs):
facebook = OAuth2Session(settings.FACEBOOK_CLIENT_ID, redirect_uri=settings.FACEBOOK_REDIRECT_URI)
facebook = facebook_compliance_fix(facebook)
if 'code' not in self.request.GET:
authorization_url, state = facebook.authorization_url(self.authorization_base_url)
return HttpResponseRedirect(authorization_url)
else:
auth_code = self.request.GET['code']
facebook.fetch_token(self.token_url, client_secret=settings.FACEBOOK_CLIENT_SECRET, code=auth_code)
user_info = json.loads(
facebook.get("https://graph.facebook.com/v2.5/me?fields={0}".format(self.fields)).text)
username = "******".format(user_info['id'])
email = user_info['email'] or ''
ott = self.save_user(username, email, user_info)
context = {
'ott': ott,
'redirect_url': '/stations/list'
}
return self.render_to_response(context)
def fblogin():
"""
:URL: /fbauth
:Methods: GET
Facebook auth callback URI
"""
logger.info('Started Facebook auth for {}, referrer was {}'.format(request.remote_addr, request.referrer))
try:
facebook = OAuth2Session(FB_CLIENT_ID, redirect_uri=redirect_uri(), state=session['facebook_state'])
facebook = facebook_compliance_fix(facebook)
except KeyError:
flash('Unable to log in via Facebook, do you have cookies enabled for this site?')
logger.info('Failed to find Facebook state information for {}'.format(request.remote_addr))
return redirect_back(url_for('index'))
try:
token = facebook.fetch_token(token_url, client_secret=FB_SECRET_ID, authorization_response=request.url)
response = facebook.get('https://graph.facebook.com/v2.5/me?fields=id,name,email').content
except (MismatchingStateError, MissingTokenError) as e:
flash('Facebook was not able to provide us with the information we need to authenticate your account.')
logger.info('Facebook auth exception for {}: {}'.format(request.remote_addr, e))
return redirect_back(url_for('index'))
decoded = json.loads(response)
user_key = 'oauth-facebook-{}'.format(decoded['id'])
try:
username = SiteKey(user_key)
user = SiteUser(username.value)
if user.accesslevel is 0:
flash('Your account has been banned')
logger.info('Successful Facebook auth for {} but user is banned'.format(user.username))
session.pop('username', None)
session.pop('facebook_id', None)
username.delete()
return redirect_back(url_for('index'))
user.seen()
session['username'] = user.username
session['facebook_token'] = token
session['facebook_id'] = decoded['id']
session['facebook_name'] = decoded['name']
session['facebook_email'] = decoded['email']
session.permanent = True
# This profile update block won't be needed out of testing
profile = user.profile()
profile.profile['facebook_id'] = session['facebook_id']
profile.update()
# end block
flash('You were successfully logged in')
logger.info('Successful Facebook auth for {} (ID {})'.format(user.username, decoded['id']))
return redirect_back(url_for('index'))
except NoKey:
session['facebook_token'] = token
session['facebook_id'] = decoded['id']
session['facebook_name'] = decoded['name']
session['facebook_email'] = decoded['email']
pd = PageData();
pd.title = "Log in with Facebook"
logger.info('Successful Facebook auth for ID {} but this person has no linked account'.format(decoded['id']))
return render_template('new_facebook_user.html', pd=pd)
flash('Facebook authentication failed :(')
logger.info('Facebook auth error for {}'.format(request.remote_addr))
return redirect_back(url_for('index'))
# Credentials of APP
import ssl
client_id = '1184399584913921'
client_secret = 'e5634ae345fdda136e251cae7e31091e'
# OAuth endpoints given in the Facebook API documentation
authorization_base_url = 'https://www.facebook.com/dialog/oauth'
token_url = 'https://graph.facebook.com/oauth/access_token'
redirect_uri = 'https://tdas4-ece9065-lab3-cloned-tdas4.c9users.io/'
from requests_oauthlib import OAuth2Session
from requests_oauthlib.compliance_fixes import facebook_compliance_fix
facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
facebook = facebook_compliance_fix(facebook)
# Redirect user to Facebook for authorization
authorization_url, state = facebook.authorization_url(authorization_base_url)
print 'Please go here and authorize,', authorization_url
# Get the authorization verifier code from the callback url
redirect_response = raw_input('Paste the full redirect URL here:')
# Fetch the access token
facebook.fetch_token(token_url, client_secret=client_secret,authorization_response=redirect_response)
# Fetch a protected resource, i.e. user profile
r = facebook.get('https://graph.facebook.com/me?')
print r.content
def _compliance_fix(self, oauth_sex):
"""
Add a compliance fix to the `OAuth2Session` in order to make it work with Facebook.
"""
return facebook_compliance_fix(oauth_sex)
def __init__(self):
self._facebook = OAuth2Session(client_id, redirect_uri=redirect_uri)
self._facebook = facebook_compliance_fix(self._facebook)
def fb_connect(request):
context = {
"user": request.user,
"site_settings": get_settings(),
"sections": Section.objects.all(),
}
# Process after selecting section/page
if request.method == "POST" and request.POST.get("action", None) == "connect":
try:
pages_info = request.session.pop("fb_pages_info")
page_id = request.POST.get("page_id")
for page_info in pages_info:
if page_info["id"] == page_id:
page_token = page_info["access_token"]
page_name = page_info["name"]
section = Section.objects.get(
pk=request.POST.get("section_id", None))
section.facebook_page_id = page_id
section.facebook_account_handle = page_name
section.facebook_key = page_token
section.save()
except:
# TODO: make this have a red color
request.session["message"] = "ERROR: Could not connect. Try again"
request.session["message"] = "Successfully linked Facebook page " + \
page_name + " to section " + section.name
request.session.save()
return redirect("/")
# Print an error or print the form
else:
# code = request.GET.get("code", None)
# fb_app_id = MeowSetting.objects.get(
# setting_key="fb_app_id").setting_value
# site_url = MeowSetting.objects.get(
# setting_key="site_url").setting_value
# fb_app_secret = MeowSetting.objects.get(
# setting_key="fb_app_secret").setting_value
# request_endpoint = "https://graph.facebook.com/oauth/access_token?client_id=" + fb_app_id + \
# "&redirect_uri=" + site_url + "/manage/fb-connect/&client_secret=" + \
# fb_app_secret + "&code=" + code
# response = requests.get(request_endpoint).text
# regex = re.search("access_token=([^&]*)($|&$|&.+)$", response)
# token = regex.group(1)
token = ""
pages_info = {}
fb_app_id = MeowSetting.objects.get(
setting_key="fb_app_id").setting_value
fb_app_secret = MeowSetting.objects.get(
setting_key="fb_app_secret").setting_value
fb_token_url = 'https://graph.facebook.com/oauth/access_token'
redirect_uri = MeowSetting.objects.get(
setting_key="site_url").setting_value + '/manage/fb-connect'
fb_code = request.GET.get('code', None)
fb_permissions = ["manage_pages", "publish_pages"]
facebook = OAuth2Session(fb_app_id,
redirect_uri=redirect_uri,
scope=fb_permissions)
facebook = facebook_compliance_fix(facebook)
fb_token = facebook.fetch_token(
fb_token_url,
client_secret=fb_app_secret,
code=fb_code)
token = fb_token['access_token']
extended_token = facepy.utils.get_extended_access_token(
token, fb_app_id, fb_app_secret)
api = facepy.GraphAPI(oauth_token=extended_token[0])
raw_pages_info = api.get("/me/accounts/")
pages_info = []
for page in raw_pages_info[u'data']:
page_info = {
'access_token': page[u'access_token'],
'name': page[u'name'],
'id': page[u'id'],
}
pages_info.append(page_info)
request.session["fb_pages_info"] = pages_info
request.session.save()
message = {}
if not (pages_info):
message["mtype"] = "alert"
message["mtext"] = "Connection to Facebook failed; try again and be sure to authorize the application and all its permissions and be sure your account is an administrator on the page."
context["message"] = message
context["pages"] = pages_info
return render(request, 'scheduler/fb_connect.html', context)
def get_auth_link(self, auth_storage, share=False):
facebook = OAuth2Session(self._client_id, scope=scope + (["publish_actions"] if share else []), redirect_uri=web.ctx.home + self._callback_page)
facebook = facebook_compliance_fix(facebook)
authorization_url, state = facebook.authorization_url(authorization_base_url)
auth_storage["oauth_state"] = state
return authorization_url
def oauth(provider, start_oauth_login=False):
oauth_verify = True
oauth_provider = oauth_conf.get(provider)
oauth_access_type = ''
oauth_approval_prompt = ''
if oauth_live is False:
print('offline testing')
oauth_verify = False
oauth_access_type = 'offline'
oauth_approval_prompt = "force"
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
if start_oauth_login:
oauth_session = OAuth2Session(
oauth_provider.get('client_id'),
scope=oauth_provider.get('scope'),
redirect_uri=request.url_root + oauth_provider.get('redirect_uri'))
if provider == 'facebook':
oauth_session = facebook_compliance_fix(oauth_session)
authorization_url, state = oauth_session.authorization_url(
oauth_provider.get('auth_uri'),
access_type=oauth_access_type,
approval_prompt=oauth_approval_prompt)
# State is used to prevent CSRF, keep this for later, make sure oauth returns to the same url.
# if testing and oauth_state errors make sure you logged in with localhost and not 127.0.0.1
session['oauth_state'] = state
session.modified = True
return redirect(authorization_url)
if session.get('oauth_state', None) is None:
flash('Something went wrong, oauth session not started')
return redirect('/login')
# allready authorised so lets handle the callback
oauth_session = OAuth2Session(
oauth_provider.get('client_id'),
state=session['oauth_state'],
redirect_uri=request.url_root + oauth_provider.get('redirect_uri'))
if provider == 'facebook':
oauth_session = facebook_compliance_fix(oauth_session)
# code error is todo with authorisation response
oauth_session.fetch_token(
oauth_provider.get('token_uri'),
client_secret=oauth_provider.get('client_secret'),
authorization_response=request.url,
verify=oauth_verify)
# Fetch a protected resource, i.e. user profile
response = oauth_session.get(oauth_provider.get('user_uri'))
oauth_response = response.json()
oauth_id = oauth_response.get('login') or oauth_response.get('id')
provider_id = oauth_lookup_id.get(provider)
oauth_user = site_user.fetch_oauth_login({
'username': oauth_id or '',
'provider': provider_id
}).get()
if oauth_user:
user_details = site_user.get_user_details({
'id': oauth_user.get('user_id')
}).get()
# we have matched a user so login and redirect
if user_details:
login_user(User(user_details.get('user_id')))
# no E-Mail so lets ask the user to set there email before allowing login
if not user_details.get('email'):
return redirect('/profile/change_email')
return redirect('/profile')
flash('Your new profile has been created, and your now logged in')
if current_user.get_id():
# link oauth to users account
site_user.create_oauth_login().execute({
'user_id': current_user.get_id(),
'username': oauth_id or '',
'provider': provider_id})
return redirect('/profile')
# create new user from oauth information
new_user_details = {
'password': '******',
'profile_image': oauth_response.get('picture'),
'username': oauth_id,
'first_name': oauth_response.get('given_name') or '',
'last_name': oauth_response.get('family_name') or ''}
if oauth_response.get('email'):
new_user_details['email']= oauth_response.get('email')
user_id = site_user.create().execute(new_user_details)
# register oauth login creation
site_user.create_oauth_login().execute({
'user_id': user_id,
'username': oauth_id or '',
'provider': provider_id})
login_user(User(user_id))
site_user.update_last_login().execute({'id': user_id})
if not user_id:
flash('Failed to create user')
return redirect('/login')
return redirect('/profile')
def manage(request):
message = {}
old_fields = {}
error = False
action = None
if request.method == "POST":
action = request.POST.get('action', None)
if request.method == "POST" and action == "meow-switch":
send_posts = request.POST.get('switch-x', None)
if send_posts:
s = MeowSetting.objects.get(setting_key="send_posts")
old = s.setting_value
s.setting_value = send_posts
s.save()
if send_posts != old:
message = {
"mtype": "success",
"mtext": "Meow status successfully changed. Be careful out there.",
}
if request.method == "POST" and action == "post-site-message":
site_message = request.POST.get('site-message', None)
s = MeowSetting.objects.get(setting_key="site_message")
old = s.setting_value
s.setting_value = site_message
s.save()
if site_message != old:
message = {
"mtype": "success",
"mtext": "Site message successfully changed",
}
if request.method == "POST" and action == "add-user":
try:
old_fields['first_name'] = request.POST['first_name']
old_fields['last_name'] = request.POST['last_name']
old_fields['email'] = request.POST['email']
old_fields['username'] = request.POST['username']
old_fields['permission'] = request.POST['permission']
password = User.objects.make_random_password()
u = User(username=old_fields['username'], first_name=old_fields['first_name'],
last_name=old_fields['last_name'], email=old_fields['email'], password="******")
u.save()
u.set_password(password)
u.groups.add(Group.objects.get(name=old_fields['permission']))
u.save()
message = {
"mtype": "success",
"mtext": "User added successfully!",
}
except KeyError as e:
message = {
"mtype": "alert",
"mtext": "User not added; please fill out all fields!",
}
error = True
except IntegrityError as e:
message = {
"mtype": "alert",
"mtext": "Username " + old_fields['username'] + " already exists",
}
error = True
# Now send them an email with the username/pass
if not error:
try:
email_message = """
Hey {first_name},
Your new Meow account is ready. Log in with:
Username: {username}
Password: {password}
at {site_url} and change your password.
Thanks,
{organization_name}
"""
site_url = MeowSetting.objects.get(
setting_key='site_url').setting_value
organization_name = MeowSetting.objects.get(
setting_key='organization_name').setting_value
from_email = MeowSetting.objects.get(
setting_key='from_email').setting_value
email_message = email_message.format(
first_name=old_fields['first_name'], username=old_fields['username'], password=password, site_url=site_url, organization_name=organization_name)
send_mail('[' + organization_name + '] Your new meow account',
email_message, from_email, [old_fields['email']], fail_silently=False)
old_fields = {}
except:
print(sys.exc_info()[0])
message = {
"mtype": "alert",
"mtext": "Account created but couldn't send password to " + old_fields['email'] + ".",
}
old_fields = {}
error = True
send_posts = MeowSetting.objects.get(
setting_key='send_posts').setting_value
site_message = MeowSetting.objects.get(
setting_key='site_message').setting_value
TWITTER_CONSUMER_KEY = MeowSetting.objects.get(
setting_key='twitter_consumer_key').setting_value
TWITTER_CONSUMER_SECRET = MeowSetting.objects.get(
setting_key='twitter_consumer_secret').setting_value
twitter_auth = tweepy.OAuthHandler(
TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET,
MeowSetting.objects.get(
setting_key="site_url").setting_value + "/manage/twitter-connect/"
)
twitter_auth.secure = True
twitter_auth_url = twitter_auth.get_authorization_url()
request.session["twitter_auth_token"] = twitter_auth.request_token
request.session.save()
fb_app_id = MeowSetting.objects.get(setting_key="fb_app_id").setting_value
fb_app_secret = MeowSetting.objects.get(
setting_key="fb_app_secret").setting_value
# TODO: find a better place for these constants
fb_authorization_base_url = 'https://www.facebook.com/v2.10/dialog/oauth'
fb_token_url = 'https://graph.facebook.com/oauth/access_token'
redirect_uri = MeowSetting.objects.get(
setting_key="site_url").setting_value + '/manage/fb-connect'
fb_permissions = ["manage_pages", "publish_pages"]
facebook = OAuth2Session(fb_app_id,
redirect_uri=redirect_uri,
scope=fb_permissions)
facebook = facebook_compliance_fix(facebook)
facebook_auth_url, state = facebook.authorization_url(
fb_authorization_base_url)
context = {
"user": request.user,
"message": message,
"old_fields": old_fields,
"send_posts": send_posts,
"site_settings": get_settings(),
"twitter_auth_url": twitter_auth_url,
"facebook_auth_url": facebook_auth_url,
"fb_app_id": fb_app_id
}
return render(request, 'scheduler/manage.html', context)
def compliance_wrapper(oauth): from requests_oauthlib.compliance_fixes import facebook_compliance_fix return facebook_compliance_fix(oauth)
