Python webapp2.uri_for函数代码示例

    def handle_get(self):
        if not self.user:
            raise WebException("error.html", "Yo dude, must be signed in to mange your streams.")

        #query for streams
        api_req_kwargs = {
            "user_id": self.user.user_id()
        }
        api_req = self.get_internal_api_request('GET', 'API-StreamByUser', api_req_kwargs)
        api_resp = api_req.send()
        if api_resp is None:
            raise WebException("error.html", "There was a problem getting your streams")
        self.data["streams"] = api_resp

        for stream in self.data["streams"]:
            stream["linkUrl"] = self.base_uri + webapp2.uri_for('Web-ViewStream', id=stream["id"])
            stream["deleteUrl"] = self.base_uri + webapp2.uri_for('API-Stream', id=stream["id"])

        #query for subscriptions
        api_req = self.get_internal_api_request('GET', 'API-StreamBySubscription', api_req_kwargs)
        api_resp = api_req.send()
        if api_resp is None:
            raise WebException("error.html", "There was a problem getting your subscriptions")

        self.data["subscriptions"] = api_resp
        for sub in self.data["subscriptions"]:
            sub["linkUrl"] = self.base_uri + webapp2.uri_for('Web-ViewStream', id=sub["id"])
            sub["deleteUrl"] = self.base_uri + webapp2.uri_for('API-Subscription')

        self.data["active_page"] = "manage"
        self.data["resources"]["js"].append("manage.js")
        self.render_template("manage.html", self.data)

    def render(self, template_name, template_values={}):
        #Let's turn of GCF for those poor lost souls with IE
        self.response.headers['X-UA-Compatible'] = 'chrome=1'

        # Routes common to all templates
        nav_bar = {
            'home':webapp2.uri_for('home'),
            'login': webapp2.uri_for('login'),
            'logout': webapp2.uri_for('logout'),
            'account': webapp2.uri_for('account')
        }
        # Preset values for the template
        values = {
          'request': self.request,
          'prefs': self.userprefs,
          'login_url': users.create_login_url(self.request.uri),
          'logout_url': users.create_logout_url(self.request.uri),
          'is_testenv':tools.common.is_testenv(),
          'nav_bar': nav_bar
        }

        # Add manually supplied template values
        values.update(template_values)

        template_dir = os.path.join(os.path.dirname(__file__),
            '../%s' % webapp2.get_app().config.get('template.dir'))

        # Render template
        fn = os.path.join(template_dir, template_name)
        self.response.out.write(template.render(fn, values,
                debug=tools.common.is_testenv()))

	def get(self):
		if users.is_current_user_admin():

			user = users.get_current_user()
			logout_url = users.create_logout_url("/admin")
			waitinglist = wl_models.WaitingList.get()
			add_waitinglist_action = webapp2.uri_for('admin_add_waitinglist', _full=True)
			delete_waitinglist_action = webapp2.uri_for('admin_delete_waitinglist', _full=True)

			context = {
						'user': user, \
						'logout_url': logout_url, \
						'waitinglist': waitinglist, \
						'add_waitinglist_action': add_waitinglist_action, \
						'delete_waitinglist_action': delete_waitinglist_action, \
						'form_add_waitinglist': self.form, \
						}

			self.render_response('admin/admin.html', **context)

		else:
			login_url = users.create_login_url("/admin")

			context = {'login_url': login_url}

			self.render_response('admin/login.html', **context)

 def get(self):
     if not self.logged_in:
         self.session['referer'] = webapp2.uri_for('posmon')
         return self.redirect_to('login')
     if self.session['alliance_id'] != self.config.alliance_id:
         _log.debug('Alliance: %s != %s' % (self.session['alliance_id'], self.config.alliance_id))
         self.session['referer'] = webapp2.uri_for('posmon')
         return self.redirect_to('logout')
     corps = Corporation.query().fetch_async()
     towers = Tower.query(Tower.deleted == False).fetch()
     corps = corps.get_result()
     if 'corp' in self.request.GET:
         corp = self.request.get('corp')
         corpIds = [t.corp_id for t in corps if str(t.corp_id) == corp or t.corp_name == corp or t.corp_ticker == corp]
         towers = filter(lambda t: t.corp_id in corpIds, towers)
     corps = { c.corp_id: c for c in corps }
     if 'system' in self.request.GET:
         system = self.request.get('system')
         towers = filter(lambda t: str(t.system_id) == system or t.system_name == system, towers)
     if 'owner' in self.request.GET:
         def roman(n):
             if n == 0:
                 return ''
             if n >= 10:
                 return 'X' + roman(n-10)
             if n == 9 or n == 4:
                 return 'I' + roman(n+1)
             if n == 5:
                 return 'V'
             return roman(n-1) + 'I'
         owner = self.request.get('owner')
         owned = set(PosOwner.query(PosOwner.owner == owner).map(lambda o: o.location))
         towers = filter(lambda t: ('%s %s-%d' % (t.system_name, roman(t.planet), t.moon)) in owned, towers)
     self.write_json(towers)

 def get(self, key):
     try:
         server_key = ndb.Key(urlsafe=key)
         server = server_key.get()
         if server is None:
             self.abort(404)
         if not server.is_gce:
             self.redirect(webapp2.uri_for('server', key=server.key.urlsafe()))
         versions = gcs.get_versions(server.key.urlsafe())
         current_version = versions[0] if versions else None
         if current_version:
             current_version_name = "{0} ({1})".format(
                 human_date(current_version['updated'], self.request.user.timezone),
                 human_size(current_version['size'])
             )
         form = ServerRestoreForm(
             versions=versions,
             timezone=self.request.user.timezone
         )
         url = webapp2.uri_for('server_uploaded', key=server.key.urlsafe())
         upload_url = blobstore.create_upload_url(
             url, gs_bucket_name="{0}/uploads/".format(gcs.get_default_bucket_name())
         )
     except Exception, e:
         logging.error(u"Error GETting GCE server restore: {0}".format(e))
         self.abort(404)

 def post(self, key):
     try:
         server_key = ndb.Key(urlsafe=key)
         server = server_key.get()
         if server is None:
             self.abort(404)
         if not server.is_gce:
             self.redirect(webapp2.uri_for('home', server_key=server.url_key))
         form = ServerRestoreForm(
             formdata=self.request.POST,
             versions=gcs.get_versions(server.key.urlsafe()),
             timezone=self.request.user.timezone
         )
         if form.validate():
             gcs.restore_generation(server.key.urlsafe(), form.generation.data)
             name = None
             for choice in form.generation.choices:
                 if choice[0] == form.generation.data:
                     name = choice[1]
                     break
             message = u"Saved game restored."
             if name:
                 message = u"Saved game {0} restored.".format(name)
             logging.info(message)
             self.session.add_flash(message, level='info')
             time.sleep(1)
             self.redirect(webapp2.uri_for('home', server_key=server.url_key))
     except Exception, e:
         message = "Problem restoring game: {0}".format(e)
         logging.error(message)
         self.session.add_flash(message, level='error')

    def get(self):
        rss = MemcacheManager.get('rss')
        if rss is None:
            items = []
            files = ArticleManager.get_files()[:NUMBER_OF_POSTS_ON_RSS_FEED]
            for filename in files:
                article = ArticleManager.get_article(filename)

                item = PyRSS2Gen.RSSItem(
                    title = article['title'],
                    link = article['url'],                    
                    description = article['html'],
                    content = article['html'],
                    guid = PyRSS2Gen.Guid(article['url']),
                    pubDate = article['dateTime'])

                items.append(item)

            rss = PyRSS2Gen.RSS2(
                title = "Opposite Reasons",
                link = webapp2.uri_for('home', _full=True),
                feedLink = webapp2.uri_for('rss', _full=True),
                description = "Opposite Reasons RSS feed",
                lastBuildDate = datetime.datetime.now(),
                items = items).to_xml()

            MemcacheManager.add('rss', rss)

        self.response.content_type = 'application/rss+xml'    
        self.response.charset = 'iso-8859-1'    
        self.response.write(rss)   

    def get(self):
        _LATEST_COUNT = 6

        channels = globalconfig.getChannels()
        for channel in channels:
            slug = channel.get('slug')
            channel['url'] = webapp2.uri_for('channel', channel=slug)

            events = heapi.getEventPages(slug)
            for page in events:
                if page['event']['exposed']:
                    eventUrlType = 'event'
                else:
                    eventUrlType = 'hidden-event'
                # if eventId=0, error happens: 'Missing argument "eventId" to build URI.'
                page['event']['url'] = webapp2.uri_for(eventUrlType, eventScope=slug, eventId=page['event']['id'])
            events.sort(key=lambda page: page['weight'], reverse=True)
            events = events[:_LATEST_COUNT]
            globalutil.populateSourceUrl(events)
            channel['events'] = events

        chartses = snapi.getChartses()
        chartses.sort(key=lambda charts: charts['source']['added'], reverse=True)
        for charts in chartses:
            charts['url'] = webapp2.uri_for('charts', charts=charts['source']['slug'])
            charts['pages'] = charts['pages'][:_LATEST_COUNT]

        templateValues = {
            'channels': channels,
            'chartses': chartses,
        }
        self.render(templateValues, 'home.html')

 def get(self):
     self.cache_must_revalidate()
     values = dict()
     values['sync_url'] = uri_for('cron-sync')
     values['full_url'] = uri_for('calendar-admin')
     values['calendar_admin_url'] = self.request.uri
     values['calendar'] = self.get_events()
     self.render_response('calendar_admin.html', **values)

 def buildURI(self, target, collection=None):
     if isinstance(target, db.Model):
         if collection:
             return webapp2.uri_for("rest-model-collection", modelname=target.__class__.__name__, itemid=target.key().id_or_name(), collectionname=collection, _full=True)
         else:
             return webapp2.uri_for("rest-model-item", modelname=target.__class__.__name__, itemid=target.key().id_or_name(), _full=True)
     else:
         return webapp2.uri_for("rest-model-list", modelname=target.__name__, _full=True)

 def _init_handler(cls, rrequest):
     rrequest.add_parameter('title', 'Glass Notifier')
     rrequest.add_breadcrumb('Home', uri_for('home'))
     brand = model.Link('Glass Notifications', uri_for('home'))
     nav_links = list()
     nav_links.append(model.Link('About', '#'))
     nav_links.append(model.Link('Contact', '#'))
     rrequest.add_parameter('brand', brand)
     rrequest.add_parameter('nav_links', nav_links)

 def get(self, name='index.html'):
     self.cache_must_revalidate()
     page = self.load_page(name)
     values = dict()
     values['content'] = self.markdown(page.source)
     values['edit_url'] = uri_for('editor', name=name)
     values['history_url'] = uri_for('history', name=name)
     self.render_response('wiki_page.html', **values)
     self.response.md5_etag()

	def get(self):
		id = self.request.get('id')
		
		deleted = db.run_in_transaction(self.delete, id)
		
		if (deleted):
			self.redirect(uri_for('greek-admin-main'))
		else:
			query_params = { 'error': 'Could not find chapter with that ID!' }
			self.redirect(uri_for('greek-admin-main') + '?' + urllib.urlencode(query_params))

    def get(self):
        users = UserPrefs.query().fetch()

        context = {
            'users': users,
            'user_delete_url': webapp2.uri_for('users-delete'),
            'user_create_url': webapp2.uri_for('users-create'),
        }
        template = JINJA_ENVIRONMENT.get_template('users.html')
        self.response.write(template.render(**context))

    def get(self, event_id, bracket_id):
        event = Event.get_by_id(event_id)
        if not event:
            self.redirect(uri_for('home'))

        bracket = Bracket.get_by_id(bracket_id)
        if not bracket:
            self.redirect(uri_for('brackets', event_id=event_id))

        bracket.regenerate(bracket.format_code)
        self.redirect(uri_for('single-bracket', event_id=event_id, bracket_id=bracket.id))