def oauth_callback(request):
if not xsrfutil.validate_token(
settings.SECRET_KEY, request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
http = httplib2.Http()
http = credential.authorize(http)
user_info_service = build(
serviceName='oauth2', version='v2',
http=http)
user_info = user_info_service.userinfo().get().execute()
try:
user = User.objects.get(username=user_info['id'])
except ObjectDoesNotExist:
user = None
if not user:
user = User.objects.create_user(
user_info['id'], user_info['email'], '')
user.first_name = user_info['name']
user.save()
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
user.backend = 'django.contrib.auth.backends.ModelBackend'
if user is not None:
login(request, user)
return redirect('/')
else:
# Return an 'invalid login' error message.
return render_to_response('gmail/thread.html', {
'threads': 'Try again later some problem',
})
def auth_return(request):
if 'state' not in request.REQUEST or not xsrfutil.validate_token(
settings.SECRET_KEY, str(request.REQUEST['state']), request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
http = httplib2.Http()
http = credential.authorize(http)
(resp_headers,
content) = http.request('https://www.googleapis.com/oauth2/v1/userinfo',
'GET')
content = loads(content)
try:
profile = Profile.objects.get(google_plus_id=content['id'])
request_profile = request.get_user().profile
if request.user.is_authenticated():
request.log_action('google_plus.merge', {'id': content['id']},
profile)
profile.merge_from_other(request_profile)
user = profile.user
request.set_user(user)
except Profile.DoesNotExist:
user = request.get_user()
profile = user.profile
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
profile.update_from_google_plus_data(credential, content)
request.log_action('google_plus.connect', {'data': content}, profile)
next_uri = '/'
if 'google_plus_next' in request.session:
next_uri = request.session['google_plus_next']
del request.session['google_plus_next']
request.session.modified = True
return HttpResponseRedirect(next_uri)
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.GET.get('state')), request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET.get('code'))
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/api/create")
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def auth_return(request):
code=request.GET["code"]
credential=flow.step2_exchange(code)
storage=Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
def oauth_callback(request):
from oauth2client.client import OAuth2WebServerFlow
from auth.models import CredentialsModel
from oauth2client.django_orm import Storage
#Get query code from auth request
code = request.GET.get('code')
#create flow object
flow = OAuth2WebServerFlow(
client_id=
'940056909424-57b143selist3s7uj8rnpcmt7f2s0g7u.apps.googleusercontent.com',
client_secret='mgHATY9kYzp3HEHg2xKrYzmh',
scope=[
'https://www.googleapis.com/auth/calendar',
'https://www.googleapis.com/auth/drive'
],
redirect_uri='http://localhost:8000/oauth2callback')
#retrieve and store credentials
credentials = flow.step2_exchange(code)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credentials)
#mark user has having been validated
user = request.user
user_profile = user.get_profile()
user_profile.google_validated = True
user_profile.save()
return HttpResponseRedirect('/index.html')
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
storage.delete()
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
storage.put(credential)
userP = userProfile.objects.get(user=request.user)
if userP.id_drive_folder is None:
try:
storage = Storage(CredentialsModel, 'id_user', request.user, 'credential')
credential = storage.get()
http = httplib2.Http()
http = credential.authorize(http)
drive_service = build('drive', 'v2', http=http, developerKey="hbP6_4UJIKe-m74yLd8tQDfT")
body = {
'title': 'Soft System Manager',
'mimeType': "application/vnd.google-apps.folder"
}
folder = drive_service.files().insert(body = body).execute()
userP.id_drive_folder = folder.get('id')
userP.save()
except:
return redirect('vista_logout')
return HttpResponseRedirect("/principal")
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
user_info = get_user_info(credential)
google_email = user_info.get('email')
firstName = user_info.get('given_name')
lastName = user_info.get('family_name')
emailEnding = google_email.split("@")[1]
userName = "******"+google_email.split("@")[0]
if User.objects.filter(username=userName):
# Make sure that the e-mail is unique.
user = User.objects.get(username=userName)
#userInfo = UserInfo.objects.get(user=user)
else:
if 'alvaradoisd.net' in emailEnding:
if 'student' in emailEnding:
bTeacher = False
else:
bTeacher = True
user = User.objects.create(
username = userName,
first_name = firstName,
last_name = lastName,
email = google_email,
password = '******',
)
userInfo = UserInfo.objects.create(
user = user,
teacher = bTeacher,
readOnly = False,
)
else:
return HttpResponse('Please sign in with your Alvarado ISD account.')
if user:
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
if UserInfo.objects.filter(user=user):
userInfo = UserInfo.objects.get(user=user)
else:
userInfo = UserInfo.objects.create(
user = user,
teacher = bTeacher,
readOnly = False,
)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return HttpResponseRedirect('/dashboard/')
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = settings.FLOW.step2_exchange(request.REQUEST)
storage = Storage(Credential, 'id', request.user, 'credential')
storage.put(credential)
mail_box=MiliBox.objects.create(name="MiliBox", user=request.user)
return HttpResponseRedirect("/")
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("gtasks/")
def update_user_credentials(self, new_credential):
from orders_manager.models import CredentialsModel, User
user = User.objects.get(
email=self.get_google_user_email(new_credential))
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(new_credential)
return storage.get()
def auth_return(request):
ans = xsrfutil.validate_token(settings.SECRET_KEY, str(request.REQUEST['state']), request.user)
if not ans:
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect(reverse('contactos:registrar_recordatorio'))
def update_user_credentials(self, new_credential):
from orders_manager.models import CredentialsModel, User
user = User.objects.get(
email=self.get_google_user_email(new_credential))
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(new_credential)
return storage.get()
def get(self, *args, **kwargs):
if not xsrfutil.validate_token(
settings.SECRET_KEY, self.request.GET['state'], self.request.user):
return HttpResponseBadRequest()
credential = self.FLOW.step2_exchange(self.request.GET)
storage = Storage(Credential, 'id', self.request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect(reverse("adsense"))
def oauth_callback(request):
code = request.GET['code']
flow = FlowModel.objects.get(id = request.user).flow
credentials = flow.step2_exchange(code)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credentials)
messages.add_message(request, messages.INFO, 'Google Authentication Successful')
return redirect('user_setup')
def oauth2callback(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(GoogleCredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
#print(credential.to_json())
return HttpResponseRedirect("/")
def callback(request):
# if not xsrfutil.validate_token(settings.SECRET_KEY, request.GET['state'],
# request.user):
# return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET)
print credential
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return redirect('/utube')
def auth_return(request):
f = FlowModel.objects.get(id=request.user)
credential = f.flow.step2_exchange(request.REQUEST) #Zica aqui...
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
f.delete()
return HttpResponseRedirect("/g_cal/")
def callback(request):
# if not xsrfutil.validate_token(settings.SECRET_KEY, request.GET['state'],
# request.user):
# return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET)
print credential
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return redirect('/utube')
def syncGoogleAccount(request):
if request.method == 'POST':
oldUserID = request.POST['oldUserID']
newUserID = request.POST['newUserID']
if User.objects.filter(id=oldUserID):
resetThisUser = User.objects.get(id=oldUserID)
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
if User.objects.filter(id=newUserID):
deleteThisUser = User.objects.get(id=newUserID)
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
#reset google account to oldUserID and delete newUserID
if GoogleUserInfo.objects.filter(user=deleteThisUser):
googleAccount = GoogleUserInfo.objects.get(user=deleteThisUser)
#get the storage from deleteUser
oldStorage = Storage(CredentialsModel, 'id', deleteThisUser, 'credential')
credential = oldStorage.get()
#create a new storage for resetUser
newStorage = Storage(CredentialsModel, 'id', resetThisUser, 'credential')
newStorage.put(credential)
#delete old credential for deleteUser
oldStorage.delete()
#reset email from deleteUser to resetUser to make them the same
resetThisUser.email = deleteThisUser.email
resetThisUser.save()
#log in resetUser
resetThisUser.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, resetThisUser)
#set new userID for session
request.session['user_id'] = resetThisUser.id
request.session.set_expiry(604800)
#set to old account
googleAccount.user = resetThisUser
googleAccount.save()
#delete deleteUser
deleteThisUser.delete()
data = {'success':'success'}
else:
return HttpResponse(json.dumps({'error':'Sorry, we are having an issue linking your google account.'}))
else:
data = {'error':'Did not post correctly'}
return HttpResponse(json.dumps(data))
def OAuthReturn(request):
master = f.get_youtube_master()
if not xsrfutil.validate_token(settings.SECRET_KEY.encode('latin1'), request.REQUEST['state'].encode('latin1'),
master):
return HttpResponseBadRequest()
credential = f.get_flow().step2_exchange(request.REQUEST)
storage = Storage(CredentialsYoutubeModel, 'id', master, 'credential')
storage.put(credential)
return redirect('spamusic:index')
def store(self):
"""
stores credentials in the Credentials Model
"""
flow = self.get_flow()
credential = flow.flow.step2_exchange(self.request.REQUEST)
storage = Storage(Credentials, 'id', self.request.user, 'credential')
storage.put(credential)
self.delete_flow(flow)
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.GET['state']),
request.user):
return HttpResponseBadRequest()
FLOW = models.FlowModel.objects.get(id=request.user).flow
credential = FLOW.step2_exchange(request.GET)
storage = Storage(models.CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect(reverse('app_home'))
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(Credentials, 'id', request.user, 'credential')
storage.put(credential)
# TODO this shouldn't be hardcoded
return HttpResponseRedirect("/POSTman/index")
def auth_return(request):
ans = xsrfutil.validate_token(settings.SECRET_KEY,
str(request.REQUEST['state']), request.user)
if not ans:
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect(reverse('contactos:registrar_recordatorio'))
def google_auth(request):
"""
Handles Google oauth flow. For details, visit
https://developers.google.com/api-client-library/python/guide/aaa_oauth#OAuth2WebServerFlow
https://developers.google.com/api-client-library/python/guide/django
"""
flow = None
default_flow = OAuth2WebServerFlow(
client_id=settings.GOOGLE_CALENDAR_API_CLIENT_ID,
client_secret=settings.GOOGLE_CALENDAR_API_CLIENT_SECRET,
scope=['https://www.googleapis.com/auth/calendar', 'profile', 'email'],
redirect_uri=settings.BASE_URL + '/auth/google')
default_flow.params['access_type'] = 'offline'
default_flow.params['include_granted_scopes'] = 'true'
default_flow.params['prompt'] = 'consent'
# Try to retrieve an existing flow, or create one if it doesn't exist
gflow = GoogleFlow.objects.filter(id=request.user).last()
if gflow and gflow.flow.params.get('prompt') != 'consent':
# Delete any flows that don't have the prompt parameter set, since that will
# prevent the credentials from getting a refresh token
gflow.delete()
gflow = None
if not gflow:
# print "Could not retrieve existing flow"
gflow = GoogleFlow(id=request.user, flow=default_flow)
gflow.save()
flow = gflow.flow
code = request.GET.get('code', None)
error = request.GET.get('error', None)
if error:
# TODO eventually make this prettier, like redirect to some landing page
return HttpResponseBadRequest(
"Authentication failed. Reason: {}".format(error))
elif code:
credential = flow.step2_exchange(code)
# Save the credentials
storage = Storage(GoogleCredentials, 'user', request.user,
'credential')
storage.put(credential)
profile, _ = Profile.get_or_create(user=request.user)
profile.authed = True
profile.save()
# TODO improve the latency over here
request.user.googlecredentials.import_calendars()
return HttpResponseRedirect("/")
else:
auth_uri = flow.step1_get_authorize_url()
return HttpResponseRedirect(auth_uri)
def obtain_credential(cls, request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.GET['state'], request.user):
return False
credential = cls.FLOW.step2_exchange(request.GET)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return True
def google_return(request):
f = FlowModel.objects.get(id=request.session.session_key)
credential = f.flow.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.session.session_key, 'credential')
storage.put(credential)
google_login_url = reverse('sqlshare.views.require_google_login')
google_login_url = "%s?next=%s" % (google_login_url, request.GET['state'])
return redirect(google_login_url)
def auth_return(request):
try:
f = FlowModel.objects.get(id=request.user)
credential = f.flow.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
f.delete()
return HttpResponseRedirect(request.GET.get('state', '/'))
except FlowModel.DoesNotExist:
pass
def oauth2callback(request):
try:
credentials = flow.step2_exchange(request.REQUEST)
except FlowExchangeError:
return HttpResponse("Access denied", status=401)
user = authenticate(id_token=credentials.id_token)
login(request, user)
storage = Storage(UserProfile, "user", user, "credential")
storage.put(credentials)
return redirect(reverse("event_creator.views.index"))
def auth_return(request):
user = request.user
if not xsrfutil.validate_token(
settings.SECRET_KEY, str(request.GET['state']), user):
return HttpResponseBadRequest()
FLOW = FlowModel.objects.get(id=user).flow
credential = FLOW.step2_exchange(request.GET)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/oauth2")
def auth_return(request):
try:
f = FlowModel.objects.get(id=request.user)
credential = f.flow.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
f.delete()
return HttpResponseRedirect("/")
except FlowModel.DoesNotExist:
pass
def oauth2callback(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.GET['state']), request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.GET)
storage = Storage(GoogleCredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
#print(credential.to_json())
redirect_url = request.session['redirect_uri_after_step2']
return HttpResponseRedirect(redirect_url)
def auth_return(request):
if not validate_token(settings.SECRET_KEY, request.REQUEST['state'], request.user):
# used to be xsrfutil.validate_token but apparently problems in source code
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
cred_json = json.loads(credential.to_json())
email_from_id_token = cred_json["id_token"]["email"]
url = 'https://www.googleapis.com/oauth2/v1/userinfo?access_token=' + cred_json["access_token"]
# or https://www.googleapis.com/plus/v1/people/me?access_token=
req = urllib2.Request(url)
response = urllib2.urlopen(req)
# from response get id, email, verified_email, name, given_name, family_name, link, picture, hd
user_info = {}
for line in response.readlines():
line = line.strip()
if not line or line is '{' or line is '}':
pass
else:
(key, val) = line.split(': ')
key = key[key.find('"')+1:key.rfind('"')]
val = val[val.find('"')+1:val.rfind('"')]
if val == 'true':
val = True
if val == 'false':
val = False
if key == 'id':
val = int(val)
user_info[key] = val
# print 'user_info is ' + str(user_info)
id_from_user_info = user_info['id']
# print '\nid is ' + str(id_from_user_info)
if cred_json["id_token"]["email_verified"]:
if request.user.is_authenticated():
logout(request)
user = User.objects.get(username=email_from_id_token)
if user is None:
print '\nhere'
User.objects.create_user(username=email_from_id_token, email=email_from_id_token, password=id_from_user_info)
user.set_password(id_from_user_info)
user.first_name = user_info['given_name']
user.last_name = user_info['family_name']
user.email = email_from_id_token
user.save()
user = authenticate(username=email_from_id_token, password=id_from_user_info)
login(request, user)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return render(request, "/testing_app/")
else:
return HttpResponse('email not verified')
def auth_return(request):
user = request.user
secret = request.REQUEST['state'].split('___')[0]
group_name = request.REQUEST['state'].split('___')[1]
if not xsrfutil.validate_token(settings.SECRET_KEY, str(secret), user):
return HttpResponseBadRequest()
FLOW = FlowModel.objects.get(id=user).flow
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/gmail_setup?group=" + group_name)
def callback(request):
"""Callback from Google OAuth2"""
try:
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(GCal, 'id', request.user.service_provider, 'credential')
storage.put(credential)
except FlowExchangeError:
return HttpResponseRedirect(reverse('myreservations_calendar'))
return HttpResponseRedirect(reverse(edit))
def auth_return(request):
state = request.REQUEST['state']
user = str(request.user)
if not xsrfutil.validate_token(SECRET_KEY, str(state), user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect('/admin')
def auth_return(request):
# use dummy_user
user = dummy_user
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
user):
return http.HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(gcal_models.CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return http.HttpResponseRedirect('/')
def auth_end(self, request):
from oauth2client.django_orm import Storage
from apiclient.discovery import build
auth_flow = models.FlowModel.objects.get(id=request.user).flow
credentials = auth_flow.step2_exchange(request.data.get('code'))
http = httplib2.Http()
http = credentials.authorize(http)
drive_service = build('drive', 'v2', http=http)
try:
account_info = drive_service.about().get().execute()
user_info = account_info['user']
quota_info = account_info['quotaBytesByService']
drive_quota = [
drive['bytesUsed'] for drive in quota_info
if drive['serviceName'] == 'DRIVE'
]
drive_bytes_used = drive_quota.pop()
quota_bytes_total = account_info['quotaBytesTotal']
try:
account_check = models.AccountModel.objects.get(
type='GOOGLEDRIVE', email=user_info['emailAddress'])
account_check.is_active = 1
account_check.status = 1
account_check.save()
except models.AccountModel.DoesNotExist:
account = models.AccountModel()
account.owner = request.user
account.email = user_info['emailAddress']
account.access_token = credentials.to_json()
account.description = user_info[
'displayName'] + '(' + user_info['emailAddress'] + ')'
account.type = 'GOOGLEDRIVE'
account.quota = quota_bytes_total
account.assigned_space = quota_bytes_total
account.used_space = drive_bytes_used
account.is_active = 1
body = {
'title': 'crowdresearch',
'mimeType': 'application/vnd.google-apps.folder'
}
account.root = drive_service.files().insert(
body=body).execute()['id']
account.name = 'Google Drive'
account.status = 1
account.save()
storage = Storage(models.CredentialsModel, 'account', account,
'credential')
storage.put(credentials)
except Exception:
Response({"message": "Failed to add account, please retry"},
status.HTTP_400_BAD_REQUEST)
return Response({"message": "OK"}, status.HTTP_201_CREATED)
def auth_return(request):
print ("in authentication return")
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
print ("before exchange the credential")
credential = FLOW.step2_exchange(request.REQUEST)
print ("After exchange credential")
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def oauth2_callback(request):
""" Callback page user lands on after authenticating to google"""
try:
f = FlowModel.objects.get(id=request.user)
credential = f.flow.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, "id", request.user, "credential")
storage.put(credential)
f.delete()
return HttpResponseRedirect(reverse("captricity_cloud_io.views.dataset_export"))
except FlowModel.DoesNotExist:
pass
def oauth2callback(request):
if not xsrfutil.validate_token(
settings.SECRET_KEY.encode("utf-8"),
request.GET.get("state").encode("utf-8"),
request.user.username.encode("utf-8"),
):
return HttpResponse("Bad Request")
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, "id", request.user, "credential")
storage.put(credential)
return redirect("/")
def callback(request):
"""Callback from Google OAuth2"""
try:
if not xsrfutil.validate_token(settings.SECRET_KEY,
request.REQUEST['state'], request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(GCal, 'id', request.user.service_provider,
'credential')
storage.put(credential)
except FlowExchangeError:
return HttpResponseRedirect(reverse('myreservations'))
return HttpResponseRedirect(reverse(edit))
def auth_return(request):
"""Google OAuth exchange, step 2"""
user = request.user
if not xsrfutil.validate_token(
settings.SECRET_KEY, request.GET['state'], user):
return HttpResponseBadRequest()
try:
FLOW = FlowModel.objects.get(id=user).flow
credential = FLOW.step2_exchange(request.GET)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return HttpResponseRedirect(reverse('checkAuth'))
except FlowExchangeError:
return redirect(reverse('profile'))
def oauth2callback(request):
"""
Handles the callback request from Google
"""
# select the flow object corresponding to the value of temp variable
# which will be the user's id in database
flow_object = FlowModel.objects.get(id=request.session['temp'])
user_flow = flow_object.flow
# get the 'code' sent by Google
auth_code = request.GET.get('code', '')
try:
credentials = user_flow.step2_exchange(auth_code)
# handle any errors in the auth code incase user tries to modify it explicitly
except client.FlowExchangeError:
return render(
request, "homepage.html", {
"Error":
"A problem occured wihle creating a new account. Please register again"
})
http_auth = credentials.authorize(httplib2.Http())
# build the API service object. All Google API calls will be made using this
service = build('gmail', 'v1', http=http_auth)
try:
response = service.users().getProfile(userId='me').execute()
except httplib2.BadStatusLine:
# return to homepage with error message incase authentication flow was interrupted
# by connection problems
flow_object.delete()
return render(
request, "homepage.html", {
"Error":
"A problem occured wihle creating a new account. Please register again"
})
# create new user only if the user has not registered earlier
if not User.objects.filter(username=response['emailAddress']).exists():
user = User.objects.create_user(response['emailAddress'])
# user entry in database should be inactive until proper credentials are provided later
user.is_active = False
user.save()
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credentials)
flow_object.delete()
return render(request, 'signup.html',
{'email_id': response['emailAddress']})
# send an error message if an account with this email id already exists
return render(
request, "homepage.html", {
"Error":
"You have already created an account with this email id. Please login using your credentials"
})
def store_new_credential(request, http, credential):
user_info_service = build(serviceName='oauth2', version='v2', http=http)
user_info = None
try:
user_info = user_info_service.userinfo().get().execute()
except:
logging.error('An error occurred: %s', e)
if (user_info and user_info.get('id')):
##We can now use this user id to check whether the page can be rendered/store it in a cookie.
request.session['google_id'] = str(user_info.get('id'))
storage = Storage(CredentialsModel, 'id',
str(request.session['google_id']), 'credential')
storage.put(credential)
def auth_return(request):
error = request.GET.get('error', False)
if error == 'access_denied':
return render_to_response('oauth_access/oauth_error.html', {
'error': 'Access Denied',
}, context_instance=RequestContext(request))
if not xsrfutil.validate_token(settings.SECRET_KEY, str(request.REQUEST['state']),
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(Credentials, 'id', request.user, 'google_credential')
storage.put(credential)
redirect_url = request.session.pop('oauth_callback_redirect', 'google_calendar_sync_run')
return redirect(redirect_url)
def complete_with_token(request, backend):
# This view expects an access_token POST parameter, if it's needed,
# request.backend and request.strategy will be loaded with the current
# backend and strategy.
token = request.POST.get('access_token')
print "Token: {}".format(token)
user = request.backend.do_auth(token)
if user:
login(request, user)
# The user agent is only used for logs
credential = AccessTokenCredentials(token, 'dummy-user-agent/1.0')
storage = Storage(GoogleCredentials, 'user', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def wrapped_func(request, *args, **kwargs):
storage = Storage(models.Credentials, 'user', request.user,
'credential')
credential = storage.get()
if not credential or credential.invalid:
flow = flow_from_clientsecrets(
settings.OAUTH2_CLIENT_SECRET_FILE,
redirect_uri=settings.OAUTH2_REDIRECT_URI,
scope=scope)
flow.params['state'] = xsrfutil.generate_token(
settings.SECRET_KEY, request.user)
# store per-user flow objects before the first redirection
storage = Storage(models.Flow, 'user', request.user, 'flow')
storage.put(flow)
authorize_url = flow.step1_get_authorize_url()
return HttpResponseRedirect(authorize_url)
else:
return func(request, *args, **kwargs)
def analytics_youtube_channel_oauth(request):
"""
View to request token and save it in our base.
It'll return 404 if token doesn't exist.
URI: /social/analytics/youtube-channel/oauth/
"""
code = request.GET.get('code', None)
if code:
filename = os.path.join(settings.PROJECT_ROOT_PATH, 'event_horizon',
'client_secrets.json')
flow = flow_from_clientsecrets(
filename,
scope=[
'https://www.googleapis.com/auth/youtube.readonly',
'https://www.googleapis.com/auth/yt-analytics.readonly',
'https://www.googleapis.com/auth/userinfo.profile',
'https://www.googleapis.com/auth/userinfo.email',
],
redirect_uri=settings.YT_ANALYTICS_REDIRECT_URI,
)
credentials = flow.step2_exchange(code)
http = httplib2.Http()
http = credentials.authorize(http)
service = build('oauth2', 'v2', http=http)
user_info = service.userinfo().get().execute()
storage = Storage(AnalyticsYoutubeChannel, 'email',
user_info[u'email'], 'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
storage = Storage(AnalyticsYoutubeChannel, 'email',
user_info[u'email'], 'credential')
storage.put(credentials)
return redirect('/admin/social/analyticsyoutubechannel/')
else:
raise Http404
def auth_return(request):
print "xxxxxxxxxxxxPSTATE ", request.REQUEST['state']
print "xxxxxxxxxxxxU ", request.user
print "xxxxxxxxxxxxS ", settings.SECRET_KEY
print "xxxxxxxxxxxxV ", xsrfutil.validate_token(settings.SECRET_KEY,
request.REQUEST['state'],
request.user)
print "xxxxxxxxxxxxG ", xsrfutil.generate_token(settings.SECRET_KEY,
request.user)
if not xsrfutil.validate_token(
settings.SECRET_KEY, str(request.REQUEST['state']), request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
storage = Storage(CredentialsModel, 'id', request.user, 'credential')
storage.put(credential)
return HttpResponseRedirect("/")
def create_account(credentials, user):
# Setup service to retrieve email address
service = build_gmail_service(credentials)
response = service.users().getProfile(userId='me').execute()
# Create account based on email address
account = EmailAccount.objects.get_or_create(
owner=user,
email_address=response.get('emailAddress'))[0]
# Store credentials based on new email account
storage = Storage(GmailCredentialsModel, 'id', account, 'credentials')
storage.put(credentials)
# Set account as authorized
account.is_authorized = True
account.is_deleted = False
account.save()
return account
def adwords_connection_oauth(request):
"""
View to request token and save it in our base.
It'll return 404 if token doesn't exist.
URI: /services/media/adwords-connection/oauth/
"""
code = request.GET.get('code', None)
if code:
filename = os.path.join(settings.PROJECT_ROOT_PATH, 'event_horizon',
'client_secrets.json')
flow = flow_from_clientsecrets(
filename,
scope=[
'https://adwords.google.com/api/adwords/',
'https://www.googleapis.com/auth/userinfo.profile',
'https://www.googleapis.com/auth/userinfo.email',
],
redirect_uri=settings.ADWORDS_REDIRECT_URI,
)
credentials = flow.step2_exchange(code)
http = httplib2.Http()
http = credentials.authorize(http)
service = build('oauth2', 'v2', http=http)
user_info = service.userinfo().get().execute()
storage = Storage(AdwordsConnection, 'email', user_info[u'email'],
'credential')
credential = storage.get()
if credential is None or credential.invalid == True:
storage = Storage(AdwordsConnection, 'email', user_info[u'email'],
'credential')
storage.put(credentials)
return redirect('/admin/services_media/adwordsconnection/')
else:
raise Http404
def oauth2callback(request):
redirect_uri = request.build_absolute_uri(reverse('oauth2callback'))
flow = OAuth2WebServerFlow(settings.GOOGLE_CLIENT_ID,
settings.GOOGLE_CLIENT_SECRET,
settings.GOOGLE_SCOPE,
redirect_uri=redirect_uri,
access_type='offline')
code = request.GET['code']
credentials = flow.step2_exchange(code)
oauth2 = services.oauth2(credentials)
userinfo_request = oauth2.userinfo().get()
userinfo = userinfo_request.execute()
storage = Storage(Authorization, 'email', userinfo.get('email'),
'credentials')
storage.put(credentials)
response = {'status': 'ok'}
return HttpResponse(json.dumps(response), content_type="application/json")
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest('oops')
credential = FLOW.step2_exchange(request.REQUEST)
user_info = get_user_info(credential)
google_email = user_info.get('email')
firstName = user_info.get('given_name')
lastName = user_info.get('family_name')
google_id = user_info.get('id')
googlePlus = user_info.get('link')
language = user_info.get('locale')
googleAvatar = user_info.get('picture')
gender = user_info.get('gender')
emailEnding = google_email.split("@")[1]
userName = "******"+google_email.split("@")[0]
if User.objects.filter(username=userName):
# Make sure that the e-mail is unique.
user = User.objects.get(username=userName)
#userInfo = UserInfo.objects.get(user=user)
elif User.objects.filter(email=google_email):
user = User.objects.get(email=google_email)
else:
if 'alvaradoisd.net' in emailEnding:
if 'student' in emailEnding:
bTeacher = False
else:
bTeacher = True
user = User.objects.create(
username = userName,
first_name = firstName,
last_name = lastName,
email = google_email,
password = '******',
)
userInfo = UserInfo.objects.create(
user = user,
teacher = bTeacher,
)
ClassUser.objects.create(
user = user,
teacher = bTeacher,
)
else:
return HttpResponse('Please sign in with your Alvarado ISD account.')
#Update the User model with changes in google
if not user.first_name:
user.first_name = firstName
user.last_name = lastName
user.save()
#Check to see if a google account has been setup yet
if not GoogleUserInfo.objects.filter(google_id=google_id):
newGoogleUser = GoogleUserInfo.objects.create(
user = user,
google_id = google_id,
googlePlus = googlePlus,
language = language,
googleAvatar = googleAvatar,
gender = gender,
)
#check to see if user is logged in
if user:
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
request.session['user_id'] = user.id
request.session.set_expiry(604800)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
'''
orgUnit = getUsersOrgUnit(user_info.get('email'))
if orgUnit:
pass
#put this into students userInfo
'''
#return HttpResponseRedirect(settings.LOGIN_SUCCESS)
#return HttpResponse('<script>window.close();</script>')
return redirect('/dashboard/')
def auth_return(request):
if not xsrfutil.validate_token(settings.SECRET_KEY, request.REQUEST['state'],
request.user):
return HttpResponseBadRequest()
credential = FLOW.step2_exchange(request.REQUEST)
user_info = get_user_info(credential)
google_email = user_info.get('email')
firstName = user_info.get('given_name')
lastName = user_info.get('family_name')
google_id = user_info.get('id')
googlePlus = user_info.get('link')
googleAvatar = user_info.get('picture')
emailEnding = google_email.split("@")[1]
userName = "******"+google_email.split("@")[0]
bTeacher = True
if 'alvaradoisd.net' in emailEnding and 'student' in emailEnding:
bTeacher = False
if User.objects.filter(username=userName):
# Make sure that the e-mail is unique.
user = User.objects.get(username=userName)
elif User.objects.filter(email=google_email):
user = User.objects.get(email=google_email)
else:
if 'alvaradoisd.net' in emailEnding or not ALLOW_ONLY_USERS:
user = User.objects.create(
username = userName,
first_name = firstName,
last_name = lastName,
email = google_email,
password = userName+google_id[:5],
)
else:
return HttpResponse('Please sign in with a Alvarado ISD account.')
if not ClassUser.objects.filter(user=user):
userInfo = ClassUser.objects.create(
user = user,
teacher = bTeacher,
)
else:
userInfo = ClassUser.objects.get(user=user)
userInfo.teacher = bTeacher
userInfo.save()
#Update the User model with changes in google
user.first_name = firstName
user.last_name = lastName
user.save()
#Check to see if a google account has been setup yet
if not GoogleUserInfo.objects.filter(google_id=google_id):
newGoogleUser = GoogleUserInfo.objects.create(
user = user,
google_id = google_id,
googlePlus = googlePlus,
googleAvatar = googleAvatar,
)
#check to see if user is logged in
if user:
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
request.session['user_id'] = user.id
request.session.set_expiry(604800)
storage = Storage(CredentialsModel, 'id', user, 'credential')
storage.put(credential)
return HttpResponseRedirect(settings.LOGIN_SUCCESS)
