def __init__(self, *args, **kw):
     super(LoggedInHandler, self).__init__(*args, **kw)
     self.user_bundle = UserBundle()
     self.template_values = {"user_bundle": self.user_bundle}
     self.response.headers[
         'Cache-Control'] = 'no-cache, no-store, must-revalidate'
     self.response.headers['Pragma'] = 'no-cache'
     self.response.headers['Expires'] = '0'
    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        if type(self.request) == webapp2.Request:
            trace_context.request = self.request

        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'
        self.response.headers['X-Robots-Tag'] = 'noindex'
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """

    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, target_url="/"):
        if not self.user_bundle.user:
            return self.redirect(
                self.user_bundle.create_login_url(target_url),
                abort=True
            )

    def _require_registration(self, target_url="/"):
        if not self.user_bundle.account.registered:
            return self.redirect(
                target_url,
                abort=True
            )
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """
    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {"user_bundle": self.user_bundle}
        self.response.headers[
            'Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, target_url="/"):
        if not self.user_bundle.user:
            return self.redirect(self.user_bundle.create_login_url(target_url),
                                 abort=True)

    def _require_registration(self, target_url="/"):
        if not self.user_bundle.account.registered:
            return self.redirect(target_url, abort=True)
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """

    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'

    def _get_login_url(self, target_url):
        return self.user_bundle.create_login_url(target_url)

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, redirect_url=None):
        import urllib

        if not self.user_bundle.user:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/login_required?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )

    def _require_permission(self, permission):
        self._require_registration()
        if permission not in self.user_bundle.account.permissions:
            return self.redirect(
                "/",
                abort=True
            )

    def _require_registration(self, redirect_url=None):
        import urllib

        self._require_login()
        if not self.user_bundle.account.registered:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/register?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )
    def createMatchVideoSuggestion(self):
        user_bundle = UserBundle()
        match = Match.query().fetch(1)[0]  #probably a cleaner way to do this

        suggestion = Suggestion(author=user_bundle.account.key,
                                target_key=match.key_name,
                                target_model="match")
        suggestion.contents = {"youtube_videos": [self.YOUTUBE_ID]}
        suggestion.put()
    def createTeamMediaSuggestion(self):
        user_bundle = UserBundle()
        team = Team.query().fetch(1)[0]

        SuggestionCreator.createTeamMediaSuggestion(
            author_account_key=user_bundle.account.key,
            media_url=self.YOUTUBE_URL,
            team_key=team.key_name,
            year_str="2016")
 def __init__(self, *args, **kw):
     super(LoggedInHandler, self).__init__(*args, **kw)
     self.user_bundle = UserBundle()
     self.template_values = {
         "user_bundle": self.user_bundle
     }
     self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
     self.response.headers['Pragma'] = 'no-cache'
     self.response.headers['Expires'] = '0'
    def createEventWebcastSuggestion(self):
        user_bundle = UserBundle()
        event = Event.query().fetch(1)[0]

        suggestion = Suggestion(
            author=user_bundle.account.key,
            target_key=event.key_name,
            target_model="event",
        )
        suggestion.contents = {"webcast_url": self.YOUTUBE_URL}
        suggestion.put()
Example #10
0
 def __init__(self, *args, **kw):
     super(CacheableHandler, self).__init__(*args, **kw)
     self._cache_expiration = 0
     self._last_modified = None  # A datetime object
     self._user_bundle = UserBundle()
     self._is_admin = self._user_bundle.is_current_user_admin
     if not hasattr(self, '_partial_cache_key'):
         self._partial_cache_key = self.CACHE_KEY_FORMAT
     self.template_values = {}
     if self.response:
         self.response.headers['Vary'] = 'Accept-Encoding'
Example #11
0
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """
    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {"user_bundle": self.user_bundle}
        self.response.headers[
            'Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'

    def _get_login_url(self, target_url):
        return self.user_bundle.create_login_url(target_url)

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, redirect_url=None):
        import urllib

        if not self.user_bundle.user:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect('/account/login_required?redirect={}'.format(
                urllib.quote(redirect_url)),
                                 abort=True)

    def _require_permission(self, permission):
        self._require_registration()
        if permission not in self.user_bundle.account.permissions:
            return self.redirect("/", abort=True)

    def _require_registration(self, redirect_url=None):
        import urllib

        self._require_login()
        if not self.user_bundle.account.registered:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect('/account/register?redirect={}'.format(
                urllib.quote(redirect_url)),
                                 abort=True)
    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        if type(self.request) == webapp2.Request:
            trace_context.request = self.request

        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'
        self.response.headers['X-Robots-Tag'] = 'noindex'
    def __init__(self, *args, **kw):
        super(CacheableHandler, self).__init__(*args, **kw)
        if type(self.request) == webapp2.Request:
            trace_context.request = self.request

        with TraceContext(sendTrace=False) as root:
            with root.span("CacheableHandler.__init__"):
                self._cache_expiration = 0
                self._last_modified = None  # A datetime object
                self._user_bundle = UserBundle()
                self._is_admin = self._user_bundle.is_current_user_admin
                if not hasattr(self, '_partial_cache_key'):
                    self._partial_cache_key = self.CACHE_KEY_FORMAT
                self.template_values = {}
                if self.response:
                    self.response.headers['Vary'] = 'Accept-Encoding'
Example #14
0
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """
    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {"user_bundle": self.user_bundle}

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, target_url="/"):
        if not self.user_bundle.user:
            return self.redirect(self.user_bundle.create_login_url(target_url),
                                 abort=True)
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """

    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, target_url="/"):
        if not self.user_bundle.user:
            return self.redirect(
                self.user_bundle.create_login_url(target_url),
                abort=True
            )
Example #16
0
 def __init__(self, *args, **kw):
     super(ApiTrustedBaseController, self).__init__(*args, **kw)
     self.response.headers[
         'content-type'] = 'application/json; charset="utf-8"'
     self.response.headers['Access-Control-Allow-Origin'] = '*'
     self._user_bundle = UserBundle()
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """

    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        if type(self.request) == webapp2.Request:
            trace_context.request = self.request

        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'
        self.response.headers['X-Robots-Tag'] = 'noindex'

    def _get_login_url(self, target_url):
        return self.user_bundle.create_login_url(target_url)

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, redirect_url=None):
        import urllib

        if not self.user_bundle.user:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/login_required?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )

    def _require_permission(self, permission):
        self._require_registration()
        if permission not in self.user_bundle.account.permissions:
            return self.redirect(
                "/",
                abort=True
            )

    def _require_registration(self, redirect_url=None):
        import urllib

        self._require_login()
        if not self.user_bundle.account.registered:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/register?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )

    def _require_team_admin_access(self, team_number, redirect_url=None):
        self._require_login(redirect_url)
        if self.user_bundle.is_current_user_admin:
            # Admins have this granted
            return

        user = self.user_bundle.account.key
        now = datetime.datetime.now()
        existing_access = existing_access = TeamAdminAccess.query(
            TeamAdminAccess.account == user,
            TeamAdminAccess.team_number == team_number,
            TeamAdminAccess.expiration > now).fetch()
        if not existing_access:
            return self.abort(403)

    def _require_request_user_is_bundle_user(self):
        current_user_account_id = self.user_bundle.account.key.id()

        target_account_id = self.request.get('account_id')
        if not target_account_id:
            return self.abort(403)

        if target_account_id != current_user_account_id:
            return self.abort(403)
class LoggedInHandler(webapp2.RequestHandler):
    """
    Provides a base set of functionality for pages that need logins.
    Currently does not support caching as easily as CacheableHandler.
    """

    def __init__(self, *args, **kw):
        super(LoggedInHandler, self).__init__(*args, **kw)
        if type(self.request) == webapp2.Request:
            trace_context.request = self.request

        self.user_bundle = UserBundle()
        self.template_values = {
            "user_bundle": self.user_bundle
        }
        self.response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        self.response.headers['Pragma'] = 'no-cache'
        self.response.headers['Expires'] = '0'
        self.response.headers['Vary'] = 'Accept-Encoding'
        self.response.headers['X-Robots-Tag'] = 'noindex'

    def _get_login_url(self, target_url):
        return self.user_bundle.create_login_url(target_url)

    def _require_admin(self):
        self._require_login()
        if not self.user_bundle.is_current_user_admin:
            return self.redirect(self.user_bundle.login_url, abort=True)

    def _require_login(self, redirect_url=None):
        import urllib

        if not self.user_bundle.user:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/login_required?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )

    def _require_permission(self, permission):
        self._require_registration()
        if permission not in self.user_bundle.account.permissions:
            return self.redirect(
                "/",
                abort=True
            )

    def _require_registration(self, redirect_url=None):
        import urllib

        self._require_login()
        if not self.user_bundle.account.registered:
            if not redirect_url:
                redirect_url = self.request.get('redirect')
            if not redirect_url:
                redirect_url = self.request.url
            return self.redirect(
                '/account/register?redirect={}'.format(urllib.quote(redirect_url)),
                abort=True
            )

    def _require_team_admin_access(self, team_number, redirect_url=None):
        self._require_login(redirect_url)
        if self.user_bundle.is_current_user_admin:
            # Admins have this granted
            return

        user = self.user_bundle.account.key
        now = datetime.datetime.now()
        existing_access = existing_access = TeamAdminAccess.query(
            TeamAdminAccess.account == user,
            TeamAdminAccess.team_number == team_number,
            TeamAdminAccess.expiration > now).fetch()
        if not existing_access:
            return self.abort(403)
 def __init__(self, *args, **kw):
     super(BaseHandler, self).__init__(*args, **kw)
     self.user_bundle = UserBundle()
     self.template_values = {
         "user_bundle": self.user_bundle
     }
 def __init__(self, *args, **kw):
     super(LoggedInHandler, self).__init__(*args, **kw)
     self.user_bundle = UserBundle()
     self.template_values = {
         "user_bundle": self.user_bundle
     }