我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用google.appengine.api.users.create_login_url()。
def check_credentials(request, other_application='admin', expiration=60 * 60, gae_login=True): """Checks that user is authorized to access other_application""" if request.env.web2py_runtime_gae: from google.appengine.api import users if users.is_current_user_admin(): return True elif gae_login: login_html = '<a href="%s">Sign in with your google account</a>.' \ % users.create_login_url(request.env.path_info) raise HTTP(200, '<html><body>%s</body></html>' % login_html) else: return False else: t0 = time.time() dt = t0 - expiration s = get_session(request, other_application) r = (s.authorized and s.last_time and s.last_time > dt) if r: s.last_time = t0 set_session(request, s, other_application) return r
def main(): """CGI-style request handler to dump the configuration. Put this in your app.yaml to enable (you can pick any URL): - url: /lib_config script: $PYTHON_LIB/google/appengine/api/lib_config.py Note: unless you are using the SDK, you must be admin. """ if not os.getenv('SERVER_SOFTWARE', '').startswith('Dev'): from google.appengine.api import users if not users.is_current_user_admin(): if users.get_current_user() is None: print 'Status: 302' print 'Location:', users.create_login_url(os.getenv('PATH_INFO', '')) else: print 'Status: 403' print print 'Forbidden' return print 'Content-type: text/plain' print _default_registry._dump()
def sys_processor(): def _get_app_var(key): if key in constants.APPVAR_DISPLAY_LIST: return models.ApplicationVariable.get_app_var(key) return None def _is_logged_in(): if users.get_current_user(): return True return False def _is_admin(): return users.is_current_user_admin() def _login_link(endpoint): return users.create_login_url(endpoint) return dict(get_app_var=_get_app_var, is_logged_in=_is_logged_in, is_admin=_is_admin, login_link=_login_link)
def login_required(handler_method): """A decorator to require that a user be logged in to access a handler. To use it, decorate your get() method like this: @login_required def get(self): user = users.get_current_user(self) self.response.out.write('Hello, ' + user.nickname()) We will redirect to a login page if the user is not logged in. We always redirect to the request URI, and Google Accounts only redirects back as a GET request, so this should not be used for POSTs. """ def check_login(self, *args): if self.request.method != 'GET': raise webapp.Error('The check_login decorator can only be used for GET ' 'requests') user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) return else: handler_method(self, *args) return check_login
def check_credentials(request, other_application='admin', expiration=60 * 60, gae_login=True): """Checks that user is authorized to access other_application""" if request.env.web2py_runtime_gae: from google.appengine.api import users if users.is_current_user_admin(): return True elif gae_login: login_html = '<a href="%s">Sign in with your google account</a>.' \ % users.create_login_url(request.env.path_info) raise HTTP(200, '<html><body>%s</body></html>' % login_html) else: return False else: t0 = time.time() dt = t0 - expiration s = get_session(request, other_application) r = (s.authorized and s.last_time and s.last_time > dt) if r: s.last_time = t0 set_session(request,s,other_application) return r
def oauth_aware(self, method): """Decorator that sets up for OAuth 2.0 dance, but doesn't do it. Does all the setup for the OAuth dance, but doesn't initiate it. This decorator is useful if you want to create a page that knows whether or not the user has granted access to this application. From within a method decorated with @oauth_aware the has_credentials() and authorize_url() methods can be called. Args: method: callable, to be decorated method of a webapp.RequestHandler instance. """ def setup_oauth(request_handler, *args, **kwargs): if self._in_error: self._display_error_message(request_handler) return user = users.get_current_user() # Don't use @login_decorator as this could be used in a # POST request. if not user: request_handler.redirect(users.create_login_url( request_handler.request.uri)) return self._create_flow(request_handler) self.flow.params['state'] = _build_state_value(request_handler, user) self.credentials = self._storage_class( self._credentials_class, None, self._credentials_property_name, user=user).get() try: resp = method(request_handler, *args, **kwargs) finally: self.credentials = None return resp return setup_oauth
def oauth_aware(self, method): """Decorator that sets up for OAuth 2.0 dance, but doesn't do it. Does all the setup for the OAuth dance, but doesn't initiate it. This decorator is useful if you want to create a page that knows whether or not the user has granted access to this application. From within a method decorated with @oauth_aware the has_credentials() and authorize_url() methods can be called. Args: method: callable, to be decorated method of a webapp.RequestHandler instance. """ def setup_oauth(request_handler, *args, **kwargs): if self._in_error: self._display_error_message(request_handler) return user = users.get_current_user() # Don't use @login_decorator as this could be used in a POST request. if not user: request_handler.redirect(users.create_login_url( request_handler.request.uri)) return self._create_flow(request_handler) self.flow.params['state'] = _build_state_value(request_handler, user) self.credentials = self._storage_class( self._credentials_class, None, self._credentials_property_name, user=user).get() try: resp = method(request_handler, *args, **kwargs) finally: self.credentials = None return resp return setup_oauth
def user_required(func): @wraps(func) def decorated_view(*args, **kwargs): if not users.get_current_user(): return redirect(users.create_login_url(request.url)) return func(*args, **kwargs) return decorated_view
def admin_required(func): @wraps(func) def decorated_view(*args, **kwargs): if users.get_current_user(): if not users.is_current_user_admin(): abort(401) # Unauthorized return func(*args, **kwargs) return redirect(users.create_login_url(request.url)) return decorated_view
def oauth_required(self, method): """Decorator that starts the OAuth 2.0 dance. Starts the OAuth dance for the logged in user if they haven't already granted access for this application. Args: method: callable, to be decorated method of a webapp.RequestHandler instance. """ def check_oauth(request_handler, *args, **kwargs): if self._in_error: self._display_error_message(request_handler) return user = users.get_current_user() # Don't use @login_decorator as this could be used in a POST request. if not user: request_handler.redirect(users.create_login_url( request_handler.request.uri)) return self._create_flow(request_handler) # Store the request URI in 'state' so we can use it later self.flow.params['state'] = _build_state_value(request_handler, user) self.credentials = StorageByKeyName( CredentialsModel, user.user_id(), 'credentials').get() if not self.has_credentials(): return request_handler.redirect(self.authorize_url()) try: return method(request_handler, *args, **kwargs) except AccessTokenRefreshError: return request_handler.redirect(self.authorize_url()) return check_oauth
def oauth_aware(self, method): """Decorator that sets up for OAuth 2.0 dance, but doesn't do it. Does all the setup for the OAuth dance, but doesn't initiate it. This decorator is useful if you want to create a page that knows whether or not the user has granted access to this application. From within a method decorated with @oauth_aware the has_credentials() and authorize_url() methods can be called. Args: method: callable, to be decorated method of a webapp.RequestHandler instance. """ def setup_oauth(request_handler, *args, **kwargs): if self._in_error: self._display_error_message(request_handler) return user = users.get_current_user() # Don't use @login_decorator as this could be used in a POST request. if not user: request_handler.redirect(users.create_login_url( request_handler.request.uri)) return self._create_flow(request_handler) self.flow.params['state'] = _build_state_value(request_handler, user) self.credentials = StorageByKeyName( CredentialsModel, user.user_id(), 'credentials').get() return method(request_handler, *args, **kwargs) return setup_oauth
def login_url(self, next="/"): return users.create_login_url(next)
def CheckSignIn(): user = users.get_current_user() if not user: login_url = users.create_login_url('/') greeting = '<a href="{}">Sign in</a>'.format(login_url) return render_template('splash.html', login=login_url) else: profile = check_if_user_profile(user.user_id()) return redirect('/predictions')
def login_required(handler_method): """A decorator to require that a user be logged in to access a handler. To use it, decorate your get() method like this:: @login_required def get(self): user = users.get_current_user(self) self.response.out.write('Hello, ' + user.nickname()) We will redirect to a login page if the user is not logged in. We always redirect to the request URI, and Google Accounts only redirects back as a GET request, so this should not be used for POSTs. """ def check_login(self, *args, **kwargs): if self.request.method != 'GET': self.abort(400, detail='The login_required decorator ' 'can only be used for GET requests.') user = users.get_current_user() if not user: return self.redirect(users.create_login_url(self.request.url)) else: handler_method(self, *args, **kwargs) return check_login
def admin_required(handler_method): """A decorator to require that a user be an admin for this application to access a handler. To use it, decorate your get() method like this:: @admin_required def get(self): user = users.get_current_user(self) self.response.out.write('Hello, ' + user.nickname()) We will redirect to a login page if the user is not logged in. We always redirect to the request URI, and Google Accounts only redirects back as a GET request, so this should not be used for POSTs. """ def check_admin(self, *args, **kwargs): if self.request.method != 'GET': self.abort(400, detail='The admin_required decorator ' 'can only be used for GET requests.') user = users.get_current_user() if not user: return self.redirect(users.create_login_url(self.request.url)) elif not users.is_current_user_admin(): self.abort(403) else: handler_method(self, *args, **kwargs) return check_admin
def user_view(): """ User interface (only shows the token). :return: An http response with the submitted information. """ user = users.get_current_user() if not user: return redirect(users.create_login_url("/user")) email = user.email() doctors = tesis_bd.Doctor.query(tesis_bd.Doctor.email == email).fetch() if len(doctors) == 0: return render_template('error.html', message="User not found in the DB.") doctor = doctors[0] name = doctor.name if not doctor.token: doctor.token = "%016x" % random.getrandbits(64) code = doctor.token doctor.put() logout_url = users.create_logout_url("/") return render_template('user_view.html', login=doctor.name, name=name, email=email, code=code, logout_url=logout_url)
def get(self): current_user = users.get_current_user() logout_url= users.create_logout_url('/') login_url= users.create_login_url('/') template = jinja_environment.get_template("templates/daytravel.html") template_vars = { 'current_user': current_user, 'logout_url': logout_url, 'login_url': login_url, } self.response.write(template.render(template_vars))
def post(self): city= self.request.get('city') current_user = users.get_current_user() logout_url= users.create_logout_url('/') login_url= users.create_login_url('/') self.redirect('/plan?city=' + city)
def signin_gae(): auth.save_request_params() gae_url = users.create_login_url(flask.url_for('gae_authorized')) return flask.redirect(gae_url)
def google_login(request, template_name=None, redirect_field_name=REDIRECT_FIELD_NAME): redirect_to = get_redirect_to(request, redirect_field_name) return HttpResponseRedirect(users.create_login_url(redirect_to))
def google_redirect_to_login(next, login_url=None, redirect_field_name=None): return HttpResponseRedirect(users.create_login_url(next))
def google_login_url(redirect=settings.LOGIN_REDIRECT_URL): return escape(users.create_login_url(redirect))
def logout(): logout_url = gae_users.create_login_url("/") return dict(logout_url=logout_url, demo=config.GetConfig(current).demo)
def demo(): return dict(login_url=gae_users.create_login_url("/"))
def get(self): ''' Redirect to Google login page, followed by another redirect to the URL specified by [then] argument. See api for request and response documentation. ''' url = users.create_login_url(dest_url=self.request.get('then')) self.redirect(url)
def get_login_url(self): return users.create_login_url(self.request.uri)
