def register_by_access_token(access_token):
''' registering user to the system if access toke is valid '''
ex = None
user = None
alreadyExist = False
try:
strategy = DjangoStrategy(None)
backend = GoogleOAuth2(strategy)
s = backend.get_scope()
userdata = backend.user_data(access_token)
if userdata is not None and userdata[
'email'] is not None and userdata['email'] != '':
user = Helper.build_user(userdata, access_token)
if user is not None:
alreadyExist = Helper.user_already_exist(user)
if not alreadyExist:
user.save()
else:
Helper.update_token(user, access_token)
except Exception as e:
''' todo: write exception to logger'''
user = None
ex = e
return user, ex, alreadyExist
def create_user(**user_details):
strategy = DjangoStrategy(DjangoStorage)
openstax = OpenStax(strategy=strategy)
result = openstax.run_pipeline(pipeline=settings.IMPORT_USER_PIPELINE,
details=user_details,
uid=user_details['uid'])
user = result['user']
return user
def update_user_details(hacker_id, user):
social_auth = DjangoUserMixin.get_social_auth_for_user(user)[0]
backend = social_auth.get_backend_instance()
social_auth.refresh_token(DjangoStrategy())
url = backend.HACKER_SCHOOL_ROOT + '/api/v1/people/%s?' % hacker_id + urlencode(
{'access_token': social_auth.extra_data['access_token']})
try:
response = backend.request(url, method='GET')
hacker_data = backend.get_user_details(response.json())
create_or_update_hacker(None, hacker_data, None,
User.objects.get(id=hacker_id))
except Exception:
# It's not very bad, if we are not able to update the userdata... we
# silently ignore it.
pass
def test_enroll_from_third_party_redirect(self):
"""
Test that, when a user visits the registration page *after* visiting a course,
if they go on to register and/or log in via third-party auth, they'll be enrolled
in that course.
The testing here is a bit hackish, since we just ping the registration page, then
directly call the step in the third party pipeline that registers the user if
`registration_course_id` is set in the session, but it should catch any major breaks.
"""
self.client.logout()
self.client.get(reverse('register_user'), {'course_id': self.course.id})
self.client.login(username=self.USERNAME, password=self.PASSWORD)
dummy_request = RequestFactory().request()
dummy_request.session = self.client.session
strategy = DjangoStrategy(RequestFactory, request=dummy_request)
change_enrollment_third_party(is_register=True, strategy=strategy, user=self.user)
self.assertTrue(CourseEnrollment.is_enrolled(self.user, self.course.id))
def test_no_prof_ed_third_party_autoenroll(self):
"""
Test that a user authenticating via third party auth while attempting to enroll
in a professional education course is not automatically enrolled in the course.
"""
self.client.logout()
# Create the course mode required for this test case
CourseModeFactory(course_id=self.course.id, mode_slug='professional')
self.client.get(reverse('register_user'), {'course_id': self.course.id})
self.client.login(username=self.USERNAME, password=self.PASSWORD)
dummy_request = RequestFactory().request()
dummy_request.session = self.client.session
strategy = DjangoStrategy(RequestFactory, request=dummy_request)
change_enrollment_third_party(is_register=True, strategy=strategy, user=self.user)
# Verify that the user has not been enrolled in the course
self.assertFalse(CourseEnrollment.is_enrolled(self.user, self.course.id))
def test_user_data(self):
"""
Tests that the server return a json with the expected schema and content.
"""
# get a valid access token from the server
access_token = self._get_test_access_token(
settings.TEST_INTEGRATION_CLIENT_ID)
# call oauth server to retrieve user data
# the server should define an user with the following profile info
from social.strategies.django_strategy import DjangoStrategy
from social.storage.django_orm import BaseDjangoStorage
user_data = OAuth2ioOAuth2(
DjangoStrategy(BaseDjangoStorage)).user_data(access_token)
self.assertDictContainsSubset(
{
'username': '******',
'first_name': 'Test',
'last_name': 'User',
'email': '*****@*****.**',
}, user_data)
def run_oauth(self, m, user=None):
strategy = DjangoStrategy(DjangoStorage)
backend = self.Backend_Class(strategy,
redirect_uri=self.client_complete_url)
start_url = do_auth(backend).url
start_query = parse_qs(urlparse(start_url).query)
# set 'state' in client
backend.data.update({'state': start_query['state']})
m.get(backend.USER_DATA_URL,
json={
"username": self.social_username,
"email": self.social_email
},
status_code=200)
m.post(backend.ACCESS_TOKEN_URL,
json={
'access_token': self.access_token,
'token_type': self.token_type,
'expires_in': self.expires_in,
'scope': self.scope,
'refresh_token': self.refresh_token
},
status_code=200)
def _login(backend, user, social_user):
backend.strategy.session_set('username', user.username)
do_complete(backend, user=user, login=_login)
social = backend.strategy.storage.user.get_social_auth(
backend.name, self.social_username)
return strategy.session_get('username'), social, backend
def setUp(self):
"""Setup the test"""
self.backend = BSDToolsOAuth2()
# We need to use the django strategy to get access to django settings
self.backend.strategy = DjangoStrategy(BaseDjangoStorage())
