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 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 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 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)