def process(self, resource_id, *args, **kwargs):
from voluptuous import Schema
from google.appengine.api import namespace_manager
namespace_manager.set_namespace('_x_')
session_store = sessions.get_store(request=self.request)
session = session_store.get_session()
if not 'u' in session:
self.about(403)
return
obj = json.loads(self.request.body)
schema = Schema(self.schema, extra=True)
try:
obj = schema(obj)
except:
logging.exception('validation failed')
session_store = sessions.get_store()
session = session_store.get_session()
school_key = ndb.Key(urlsafe = session.get('s'))
obj['school'] = school_key
entity = self.entity.from_dict(obj)
entity.put()
self.write_json_response(entity.to_dict())
def dispatch(self):
# by default, the session ID is set in the Cookie header, but we can't rely on
# cookies because of 3rd party cookie restrictions. so we pass the session ID through GET
# parameters and unset the cookie before the response is sent
self.session_id = self.request.get("SESSION")
if self.session_id:
self.request.cookies["session"] = self.session_id
self.session_store = sessions.get_store(request=self.request)
self.session # touch the object to guarantee its instantiation
else:
self.session_store = sessions.get_store(request=self.request)
try:
# there was no session yet, so we assume a valid signed request from Speakap
# if the signed request is not valid, an exception is raised
signed_params = dict(self.request.params)
speakap_api.validate_signature(signed_params)
# we copy all parameters from the signed request to a new user session (the session
# is created implicitly), so the params are available on follow-up requests
for key in signed_params:
self.session[key] = signed_params[key]
self.session_store.save_sessions(self.response)
# ugly method to get the session ID from the Set-Cookie header
self.session_id = self.response.headers["Set-Cookie"].split(";")[0].split("=", 2)[1]
except speakap.SignatureValidationError, exception:
print exception
self.show_auth_error()
return
def dispatch(self):
self.session_store = sessions.get_store(factory=sessions.SessionStore, key='webapp2_extras.sessions.SessionStore', request=self.request)
self.session_flash = sessions.get_store(factory=sessions.SessionDict, key='webapp2_extras.sessions.SessionDict', request=self.request)
try:
RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def post_logout(self): self.auth.unset_session() # User is logged out, let's try redirecting to login page #try: # self.redirect(self.default_uri) #except (AttributeError, KeyError), e: # return "User is logged out" #finally: self.redirect(self.default_uri) sessions.get_store(request=self.request).save_sessions(self.response)
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
try:
webapp2.RequestHandler.dispatch(self)
except Exception, e:
logging.error(e)
self.redirect("/logout/")
def dispatch(self):
# get a session store for this request
self.session_store = sessions.get_store(request=self.request)
# always check CSRF if this is a post unless explicitly disabled
if self.request.method == 'POST' and not self.SKIP_CSRF:
if not self.checkCSRF():
return self.renderError(412)
if hasattr(self, "before"):
try:
self.before(*self.request.route_args, **self.request.route_kwargs)
except Exception as e:
self.handle_exception(e, False)
# only run the regular action if there isn't already an error or redirect
if self.response.status_int == 200:
webapp2.RequestHandler.dispatch(self)
if hasattr(self, "after"):
try:
self.after(*self.request.route_args, **self.request.route_kwargs)
except Exception as e:
self.handle_exception(e, False)
# save all sessions
self.session_store.save_sessions(self.response)
def session_store(self):
try:
store = sessions.get_store(request=self.request)
return store
except Exception as e:
print "Session_store"
print e
def __init__(self, request, response):
""" constructor """
main.log('Initializing base page.')
self.initialize(request, response)
self.session_store = sessions.get_store(request=request)
self._initialize_login()
def post(self):
username = self.request.get('username')
password = self.request.get('password')
try:
database = gdbm.open('database.gdbm','cf')
except:
time.sleep(0.1)
database = gdbm.open('database.gdbm','cf')
if ('usr'+username).encode('ascii','ignore') in database:
auth_info = json.loads(
database[('usr'+username).encode('ascii','ignore')]
)
if auth_info['password'] == password:
session_store = sessions.get_store(request=self.request)
session = session_store.get_session()
session['key'] = auth_info['key']
session['username'] = username
session_store.save_sessions(self.response)
database.close()
self.redirect('/jj70/abstracts')
else:
database.close()
self.redirect('/jj70/login')
else:
database.close()
self.redirect('/jj70/login')
def dispatch(self):
self.session_store = sessions.get_store(request = self.request)
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def get(self):
session_store = sessions.get_store(request=self.request)
session = session_store.get_session()
username = session.get('username')
key = session.get('key')
try:
database = gdbm.open('database.gdbm','cf')
except:
time.sleep(1.0)
database = gdbm.open('database.gdbm','cf')
if username:
if ('usr'+username).encode('ascii','ignore') in database:
auth_info = json.loads(
database[('usr'+username).encode('ascii','ignore')]
)
if auth_info['key'] == key:
template_values = {'auth':auth_info}
template = JINJA_ENVIRONMENT.get_template('ko.html')
database.close()
self.response.write(template.render(template_values))
else:
database.close()
self.redirect('/jj70/login')
else:
database.close()
self.redirect('/jj70/login')
else:
database.close()
self.redirect('/jj70/login')
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try: # Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally: # Save all sessions.
self.session_store.save_sessions(self.response)
def get(self, *args, **kwargs):
session_store = sessions.get_store()
session = session_store.get_session()
if session:
# TODO: Is there a better way to do this?
for key in session.keys():
del session[key]
federated_identity = OPENID_ENDPOINT_GOOGLE
token = self.request.get('tk')
if token:
session['tk'] = token
session_store.save_sessions(self.response)
school = self.request.get('sc')
params = {}
if school:
params['sc'] = school
dest_url = '/_userconfig?' + urllib.urlencode(params)
login_url = users.create_login_url(
dest_url=dest_url,
federated_identity=federated_identity)
self.redirect(login_url)
def dispatch(self):
log.debug('starting dispatch')
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
self.request.registry['session'] = self.session
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
except suds.WebFault as e:
if e.message == authentication_failed:
self.response.write(json.dumps({'logged_in': False}))
self.response.status = 401
elif e.message == access_denied:
self.response.write(json.dumps({'logged_in': True,
'message': "Access Denied"}))
self.response.status = 403
else:
self.response.write(json.dumps({
'logged_in': True,
'message': 'WebFault: {}. See logs'.format(e.message)}))
self.response.status = 500
log.exception('Got an unhandled WebFault. Sent a 500 message.')
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
log.debug('ending dispatch')
def dispatch(self):
self.user = User()
'''
Method dispatcher for wrapping method calls within the context of 'self'
Any variables created here are given to the method handlers as 'self'
:return:
'''
self.session_store = sessions.get_store(request=self.request)
try:
# call method handler
results = _webapp.RequestHandler.dispatch(self)
if results is True:
self.response.set_status(200)
elif results is False:
self.response.set_status(501)
elif results is dict or results is list:
# nah -- it's another type, it's JSON
self.response.content_type = "application/json"
self.response.out.write(json.dumps(results))
elif results is None:
self.response.set_status(200)
logging.info("null response from handler")
else:
self.response.out.write(results)
finally:
# store session
self.session_store.save_sessions(self.response)
def dispatch(self):
""" 需要管理員身份才可執行 """
self.session_store = sessions.get_store(request=self.request)
user = users.get_current_user()
if user is not None and users.is_current_user_admin() is False:
from application.database import DBAdministrator
from google.appengine.ext import db
ds = db.Query(DBAdministrator)
ds.filter('email =', str(user.email()))
record = ds.get()
if record is not None and record.is_enable == True :
self.session["administrator_email"] = record.email
if self.session["administrator_email"] is None or self.session["administrator_email"] == "":
self.login_message = u'此帳號權限不足，請使用別的帳號 <a href="' + users.create_login_url("/admin") + u'" class="register">重新登入</a>'
self.e403()
return
else:
if user is not None:
self.session["administrator_email"] = user.email()
if self.session.has_key("administrator_email") is False:
self.session["administrator_email"] = u""
if self.session["administrator_email"] is u"":
self.login_message = u"請先登入系統，您也可以使用 Google 帳號登入"
self.e403()
return
self.administrator_email = self.session["administrator_email"]
self.size = Pagination.get_int_param(self,"size",50)
self.page = Pagination.get_int_param(self,"page",1)
self.page_now = self.page
super(BaseHandler, self).dispatch()
self.session_store.save_sessions(self.response)
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
try:
super(BaseApiHandler, self).dispatch()
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Wraps the dispatch method to add session handling."""
self.session_store = sessions.get_store(request=self.request)
self.decorator = decorator
# Add the user's credentials to the decorator if we have them.
if self.me:
self.decorator.credentials = self.decorator._storage_class(
model=self.decorator._credentials_class,
key_name='user:{}'.format(self.me.user_id()),
property_name=self.decorator._credentials_property_name).get()
else:
# Create a session ID for the session if it does not have one already.
# This is used to create an opaque string that can be passed to the OAuth2
# authentication server via the 'state' parameter.
if not self.session.get('sid'):
self.session['sid'] = security.generate_random_string(entropy=128)
# Store the state for the session user in a parameter on the flow.
# We only need to do this if we're not logged in.
self.decorator._create_flow(self)
session_user = SessionUser(self.session['sid'])
logging.info(self.decorator.flow.params)
self.decorator.flow.params['state'] = appengine._build_state_value(
self, session_user)
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
self.request.mobile = False
try:
if self.request.headers.has_key("X-OperaMini-Features"):
#Then it's running opera mini. 'Nuff said.
#Reference from:
# http://dev.opera.com/articles/view/opera-mini-request-headers/
self.request.mobile = True
if self.request.headers.has_key("Accept"):
s = self.request.headers["Accept"].lower()
if 'application/vnd.wap.xhtml+xml' in s:
# Then it's a wap browser
self.request.mobile = True
if self.request.headers.has_key("User-Agent"):
# This takes the most processing. Surprisingly enough, when I
# Experimented on my own machine, this was the most efficient
# algorithm. Certainly more so than regexes.
# Also, Caching didn't help much, with real-world caches.
s = self.request.headers["User-Agent"].lower()
for ua in search_strings:
if ua in s:
self.request.mobile = True
#Otherwise it's not a mobile
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def get(self, resource_id, *args, **kwargs):
session_store = sessions.get_store()
session = session_store.get_session()
session['tz'] = resource_id
session_store.save_sessions(self.response)
self.response.write(resource_id)
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
session = self.session_store.get_session()
User.setCurrentUser(session.get('user'))
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
# logging.info('BaseHandler:dispatch %s', self.request)
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
try:
super(BaseHandler, self).dispatch()
if self.__is_render__ is False:
self.render(None)
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Override dispatch to initialize and persist session data."""
self.session_store = sessions.get_store(request=self.request)
try:
super(BaseHandler, self).dispatch()
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Dispatch the request."""
self.session_store = sessions.get_store(request=self.request)
try:
super(BaseHandler, self).dispatch()
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def post(self):
presentation = Presentation(parent=self.get_group_key())
presentation.name = self.request.get("presentation_name")
presentation.outline = self.request.get("presentation_outline")
presentation.put()
session_store = sessions.get_store(request=self.request)
session_store.get_session().add_flash("Presentation Created", level="alert")
self.redirect(self.url_for("presentations"))
def setup_session(self, school_key):
"""Setup the session vars."""
session_store = sessions.get_store()
session = session_store.get_session()
session['u'] = self.user.user_id()
session['n'] = str(school_key.id())
session['s'] = school_key.urlsafe()
session_store.save_sessions(self.response)
def dispatch(self):
self._session_store = sessions.get_store(request=self.request)
try:
#super(RequestHandler, self).dispatch()
pass
finally:
self._session_store.save_sessions(self.response)
def dispatch(self, *args, **kwargs): #retrieve session session_store = sessions.get_store(request=self.request) self.session = session_store.get_session() try: webapp2.RequestHandler.dispatch(self, *args, **kwargs) finally: session_store.save_sessions(self.response)
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
super(BaseHandler, self).dispatch()
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def get_session(self, request):
"""Returns an auth session.
:param request:
A :class:`webapp2.Request` instance.
:returns:
A session dict.
"""
store = sessions.get_store(request=request)
return store.get_session(self.config['cookie_name'],
backend=self.config['session_backend'])
def dispatch(self):
if self.request.host == 'dev.trot.to':
if not users.get_current_user():
self.redirect(users.create_login_url('/'))
return
elif not users.is_current_user_admin():
self.abort(403)
self.is_local_env = not os.getenv('SERVER_SOFTWARE',
'').startswith('Google App Engine/')
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
self.login_error = None
self.user_email = None
self.user = None
if not self.user_email:
self.user_email = self.session.get('user_email')
self.user_org = get_organization_id_for_email(
self.user_email) if self.user_email else None
if not self.user_email:
self.attempt_auth_by_emailed_link()
if not self.user_email and env.current_env_is_local():
self.attempt_auth_by_user_header()
self.session['already_accepted_terms'] = False
if self.user_email:
self.user = get_or_create_user(self.user_email, self.user_org)
self.session[
'already_accepted_terms'] = not not self.user.accepted_terms_at
if not self.session.get('csrf_token'):
self.session['csrf_token'] = utils.generate_secret(32)
try:
self.redirect_to = None
self.check_authorization()
if self.redirect_to:
self.response.write(
json.dumps({'redirect_to': self.redirect_to}))
return
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions, IFF secure connection
if self.request.scheme == 'https' or self.is_local_env:
self.session_store.save_sessions(self.response)
def dispatch(self):
# pylint: disable=attribute-defined-outside-init
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
"""
This snippet of code is taken from the webapp2 framework documentation.
See more at
http://webapp-improved.appspot.com/api/webapp2_extras/sessions.html
"""
self.session_store = sessions.get_store(request=self.request)
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
# get a session store for this request
self.session_store = sessions.get_store(request=self.request)
if hasattr(self, "headers"):
self.headers()
webapp2.RequestHandler.dispatch(self)
# save all sessions
self.session_store.save_sessions(self.response)
def dispatch(self):
if (self._required_credentials > Credentials.NONE
and GetUserCredentialsLevel() < self._required_credentials):
self.abort(httplib.UNAUTHORIZED)
return
self.session_store = sessions.get_store(request=self.request)
try:
super(RestHandler, self).dispatch()
finally:
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Initialize and manage sessions."""
if self.naked_domain_redirect():
return
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
# esegue il dispatch della richiesta e tiene traccia della sessione
# metodo richiesto dal modulo sessions di webapp2
self.session_store = sessions.get_store(request=self.request)
try:
webapp2.RequestHandler.dispatch(self)
finally:
self.session_store.save_sessions(self.response)
pass
def dispatch(self):
self.template_values = {}
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
self.assert_is_allowed()
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Intercepts default request dispatching to ensure that an HTTP session
has been created before calling dispatch in the base type.
"""
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
"""Crea un almacén de sesión para la petición actual. Permite mantener parámetros a través de las diferentes peticiones y almacena las cookies generadas que hayan usado la misma instancia de Session.
"""
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def test_get_session_store(self):
app = webapp2.WSGIApplication(config={
"webapp2_extras.sessions": {
"secret_key": "my-super-secret",
}
})
req = webapp2.Request.blank("/")
req.app = app
self.assertEqual(len(req.registry), 0)
s = sessions.get_store(request=req)
self.assertEqual(len(req.registry), 1)
self.assertTrue(isinstance(s, sessions.SessionStore))
def __init__(self, *args, **kwargs):
super(BaseView, self).__init__(*args, **kwargs)
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
self.user = self.getCurrentUser()
self.template_values = {'settings': settings, 'signin_url': '',
'signout_url': '', 'alerts': []}
self.template_values['signout_url'] = context.get_signout_url()
self.template_values['google_signin_url'] = context.google_signin_url
self.template_values['reCAPTCHA_site_key'] = settings.reCAPTCHA_SITEKEY
self.template_values['user'] = self.user
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
# Set the loale
i18n.get_i18n().set_locale(self.locale)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def post(self):
try:
database = gdbm.open('database.gdbm','cf')
except:
time.sleep(1.0)
database = gdbm.open('database.gdbm','cf')
session_store = sessions.get_store(request=self.request)
session = session_store.get_session()
username = session.get('username')
key = session.get('key')
database['abstract'+key.encode('ascii','ignore')] = self.request.body
database.close()
def dispatch(self):
self.session_store = sessions.get_store(request=self.request)
try:
if self.is_unsafe_request() and not self.is_task_queue_request():
if self.request.params[CSRF_TOKEN_DICT_KEY] != self.csrf_token:
del self.session[CSRF_TOKEN_DICT_KEY]
self.abort(403, 'CSRF token missing')
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
# todo may need to check what page you are going to before sending them to login
if not (self.request.path_info == "/login"
or self.request.path_info == "/"):
self.checkLogin()
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
# for requests still going to appspot, redirect
request = self.request
if request.host.startswith("gig-o-matic.appspot.com") or request.host.startswith("gig-o-matic.com"):
import urlparse
scheme, netloc, path, query, fragment = urlparse.urlsplit(request.url)
# the cron stuff should not redirect
if not path.startswith("/admin_"):
url = urlparse.urlunsplit([scheme, "www.gig-o-matic.com", path, query, fragment])
# Send redirect
self.redirect(url, permanent=True, abort=True)
if request.host.startswith("127.0.0.1"):
import urlparse
scheme, netloc, path, query, fragment = urlparse.urlsplit(request.url)
# the cron stuff should not redirect
if not path.startswith("/admin_"):
url = urlparse.urlunsplit([scheme, "localhost:8080", path, query, fragment])
# Send redirect
self.redirect(url, permanent=True, abort=True)
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
# Set locale on each request right away, to make it available to both
# templates and backend Python code
if self.request.get("locale"):
locale = self.request.get("locale")
elif self.user and self.user.preferences.locale:
locale = self.user.preferences.locale
else:
locale = None
i18n.get_i18n().set_locale(locale)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
except gigoexceptions.GigoException as error:
logging.error( "Exception: %s" % error )
self.render_template('error.html', [])
except gigoexceptions.GigoRestException as error:
logging.error( "Rest Exception: %s" % error )
self.abort(401)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
"""
Calls startup, checks authorization, and then the controller method.
If a view is set and auto rendering is enabled, then it will try to automatically
render the view if the action doesn't return anything.
If the controller method returns anything other than None, auto-rendering is skipped
and the result is transformed into a response using the :mod:`~ferris.core.response_handlers`.
"""
# Setup everything, the session, etc.
self._init_meta()
self.session_store = sessions.get_store(request=self.request)
self.context.set_dotted('this.session', self.session)
self.events.before_startup(controller=self)
self.startup()
self.events.after_startup(controller=self)
# Authorization
self._is_authorized()
# Dispatch to the method
self.events.before_dispatch(controller=self)
result = super(Controller, self).dispatch()
self.events.after_dispatch(response=result, controller=self)
# Return value handlers.
# Response has highest precendence, the view class has lowest.
response_handler = response_handlers.factory(type(result))
if response_handler:
self.response = response_handler(self, result)
# View rendering works similar to the string mode above.
elif self.meta.view.auto_render:
self._clear_redirect()
self.response = self.meta.view.render()
else:
self.abort(
500, 'Nothing was able to handle the response %s (%s)' %
(result, type(result)))
self.events.dispatch_complete(controller=self)
self.session_store.save_sessions(self.response)
self.events.clear()
return self.response
def check_login(self, *args, **kwargs):
"""
If handler has no login_url specified invoke a 403 error
"""
session_store = sessions.get_store()
session = session_store.get_session()
try:
if not 'u' in session:
try:
self.redirect('/school')
except (AttributeError, KeyError), e:
self.abort(403)
else:
def dispatch(self):
# Get a session store for this request.
# See this for more info on webapp2 sessions:
# http://webapp-improved.appspot.com/api/webapp2_extras/sessions.html
self.session_store = sessions.get_store(request=self.request)
i18n.get_i18n().set_locale('en')
try:
# Dispatch the request.
RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def dispatch(self):
# activate session store.
self.session_store = sessions.get_store(request=self.request)
# dispatch handler.
out = webapp2.RequestHandler.dispatch(self)
# Let angular know about our XSRF-TOKEN
self.response.set_cookie("XSRF-TOKEN", self.get_csrf_token())
# save session.
self.session_store.save_sessions(self.response)
return out
def dispatch(self):
"""
Override dispatch() to provide session support
"""
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def get(self, *args, **kwargs):
from google.appengine.api import namespace_manager
namespace_manager.set_namespace('_x_')
session_store = sessions.get_store(request=self.request)
session = session_store.get_session()
if not 'u' in session:
self.abort(403)
return
self.request.GET['feq_school'] = session.get('s')
super(SchoolRestApiListHandler, self).get(self, *args, **kwargs)
def dispatch(self):
"""Wraps the other request handlers.
* Manages sessions
* Manages request profiling
"""
# ** Code to run before all handlers goes here. ** #
# Mark the start time of the request. You can add events to this
# profiler in any request handler like this:
# util.profiler.add_event("this is my event")
util.profiler.clear()
util.profiler.add_event('START')
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
if (False and app_engine_users.is_current_user_admin()
and not self.get_current_user()
and self.request.path != '/logout'):
# Admins/devs are sometimes logged in through google, but not our
# site, if they visit /admin pages. This is because app.yaml
# requires admin login, and directs them to google sign in without
# talking to our normal /login process. We can clean up this
# situation by logging them in here.
user = self.authenticate('google')
else:
user = self.get_current_user()
# Give every request handler an api in the context of the current user.
# Don't do this when a user isn't present.
logging.info("BaseHandler:Dispatch with user: {}".format(user))
self.api = Api(user)
try:
# Call the overridden dispatch(), which has the effect of running
# the get() or post() etc. of the inheriting class.
webapp2.RequestHandler.dispatch(self)
except webapp2.exc.HTTPMethodNotAllowed as error:
trace = traceback.format_exc()
logging.info("{}\n{}".format(error, trace))
self.error(405)
self.response.write('405 Method Not Allowed: {}'.format(error))
return
finally:
# ** Code to run after all handlers goes here. ** #
# Save all sessions.
self.session_store.save_sessions(self.response)
def my_get_dispatch(self, *args, **kwargs):
''' A Fake dispatch method that you want to call inside your Route()
Just an imitation of the webapp2 style dispatch() with limited functions
'''
self.session_store = sessions.get_store(request=self.request)
try:
if self.request.method == 'GET':
self.get(*args,
**kwargs) # this is the real get method we want here
else:
self.error(405)
self.response.out.write('Method not allowed')
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def GetOrMakeSession(request):
session_store = sessions.get_store(request=request)
session = session_store.get_session()
if not session:
session['xsrf'] = security.generate_random_string(entropy=128)
user = users.get_current_user()
if user:
if _ANON_USER_KEY in session:
AdoptAnonymousProjects(user.email(), session[_ANON_USER_KEY])
else:
if _ANON_USER_KEY not in session:
session[_ANON_USER_KEY] = MakeAnonUserKey()
return session
def test_set_session_store(self):
app = webapp2.WSGIApplication(config={
'webapp2_extras.sessions': {
'secret_key': 'my-super-secret',
}
})
req = webapp2.Request.blank('/')
req.app = app
store = sessions.SessionStore(req)
self.assertEqual(len(req.registry), 0)
sessions.set_store(store, request=req)
self.assertEqual(len(req.registry), 1)
s = sessions.get_store(request=req)
self.assertTrue(isinstance(s, sessions.SessionStore))
