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 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): 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): 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 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 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): OAuthBaseHandler.get(self) if not self.auth_token: return competition_id = self.handler_data response = self.GetWcaApi('/api/v0/competitions/%s/wcif' % competition_id) if response.status != 200: self.redirect(webapp2.uri_for('index', unknown=1)) return response_json = json.loads(response.read()) competition = (ScheduleCompetition.get_by_id(competition_id) or ScheduleCompetition(id=competition_id)) competition.name = response_json['name'] competition.wca_competition = ndb.Key(Competition, competition_id) current_editors = ScheduleStaff.query( ndb.AND(ScheduleStaff.competition == competition.key, ScheduleStaff.roles == StaffRoles.EDITOR)).fetch() for person in response_json['persons']: staff_id = ScheduleStaff.Id(competition_id, person['wcaUserId']) staff = ScheduleStaff.get_by_id(staff_id) or ScheduleStaff( id=staff_id) if StaffRoles.EDITOR not in staff.roles: staff.competition = competition.key staff.user = ndb.Key(User, str(person['wcaUserId'])) staff.roles.append(StaffRoles.EDITOR) staff.put() competition.put() self.redirect( webapp2.uri_for('edit_competition', competition_id=competition_id))
def test_escaping(self): def get_req(uri): req = webapp2.Request.blank(uri) app.set_globals(app=app, request=req) handler = webapp2.RequestHandler(req, None) handler.app = req.app = app return req, handler req, handler = get_req("http://localhost:80/") uri = webapp2.uri_for("escape", name="with space") req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, "with space") req, handler = get_req("http://localhost:80/") uri = webapp2.uri_for("escape", name="with+plus") req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, "with plus") req, handler = get_req("http://localhost:80/") uri = webapp2.uri_for("escape", name="with/slash") req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, "with/slash")
def get(self, hours=12): self.response.headers['Content-Type'] = 'text/html' title = "Games active in the last %s hours" % hours body = "" games = Game.query(Game.last_update > datetime.now() - timedelta(hours=hours)).fetch() if not len(games): games = Game.query().fetch() if not len(games): title = "No active games found!" else: title = "All active games" for game in sorted(games, key=lambda x: x.last_update, reverse=True): id = game.key.id() game_link = uri_for('game-show-history', game_id=id) map_link = uri_for('map-render', game_id=id) body += "<li><a href='%s'>Game #%s</a> (<a href='%s'>(Map)</a>)<ul><li>\t%s (Last update: %s ago)</li></ul></li>" % ( game_link, id, map_link, game.summary, datetime.now() - game.last_update) out = "<html><head><title>%s - ORCS</title></head><body>" % title if body: out += "<h4>%s:</h4><ul>%s</ul></body</html>" % (title, body) else: out += "<h4>%s</h4></body></html>" % title self.response.write(out)
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 test_escaping(self): def get_req(uri): req = webapp2.Request.blank(uri) app.set_globals(app=app, request=req) handler = webapp2.RequestHandler(req, None) handler.app = req.app = app return req, handler req, handler = get_req('http://localhost:80/') uri = webapp2.uri_for('escape', name='with space') req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, 'with space') req, handler = get_req('http://localhost:80/') uri = webapp2.uri_for('escape', name='with+plus') req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, 'with plus') req, handler = get_req('http://localhost:80/') uri = webapp2.uri_for('escape', name='with/slash') req, handler = get_req(uri) rsp = req.get_response(app) self.assertEqual(rsp.status_int, 200) self.assertEqual(rsp.body, 'with/slash')
def redirect_to_server(self, route_name): servers = Server.query_all().fetch(2) if servers and len(servers) == 1: self.redirect( webapp2.uri_for(route_name, server_key=servers[0].url_key)) else: self.redirect(webapp2.uri_for('main'))
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 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 handle_get(self, **kwargs): stream_id = kwargs["id"] api_kwargs = { "id": stream_id, "n": 3 } self.data["mainPage"] = self.base_uri + webapp2.uri_for("Web-ViewStream", id=stream_id) print self.request.params print self.request.params.get("cursor") cursor = self.request.params.get("cursor") if cursor is not None: api_kwargs["cursor"] = cursor api_req = self.get_internal_api_request('GET', 'API-StreamView', api_kwargs) api_resp = api_req.send() if api_resp is None: raise WebException("error.html", "Could not view the supplied stream") self.data["stream"] = api_resp tag_list = api_resp["tags"] tag_str = '' for tag in tag_list: tag_str += "#" + tag + " " self.data["stream"]["tags"] = tag_str if self.get_param("geoView", required=False): self.data["resources"]["js"].append("view_stream_geo.js") self.render_template("view_stream_geo.html", self.data) return #api_req = self.get_internal_api_request('GET', 'API-UploadUrl') #api_resp = api_req.send() #self.data["imageUploadUrl"] = api_resp["url"] self.data["upload_url_endpoint"] = webapp2.uri_for("API-UploadUrl") api_req = self.get_internal_api_request('GET', 'API-SubscriptionExists') api_req.params = { "userId": self.get_user_id(), "streamId": self.data["stream"]["id"] } api_resp = api_req.send() if api_resp: if not api_resp["exists"]: self.data["subscribeUrl"] = self.base_uri + webapp2.uri_for("API-Subscription") else: self.data["subscribeUrl"] = "NotSignedIn" next_url = self.base_uri + webapp2.uri_for("Web-ViewStream", id=self.data["stream"]["id"]) self.data["nextUrl"] = next_url self.data["resources"]["js"].append("view_stream.js") #self.data["resources"]["css"].append("//netdna.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css") self.data["resources"]["css"].append("//blueimp.github.io/Gallery/css/blueimp-gallery.min.css") #self.data["resources"]["css"].append(self.base_uri + "/web/js/jQuery-File-Upload-9.8.0/css/style.css") self.data["resources"]["css"].append(self.base_uri + "/web/js/jQuery-File-Upload-9.8.0/css/jquery.fileupload.css") self.data["resources"]["css"].append(self.base_uri + "/web/js/jQuery-File-Upload-9.8.0/css/jquery.fileupload-ui.css") self.data["file_upload_lib"] = self.base_uri + "/web/js/jQuery-File-Upload-9.8.0" self.render_template("view_stream.html", self.data)
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 get(self): OAuthBaseHandler.get(self) if not self.auth_token: return competition_id = self.handler_data if not self.SetCompetition(competition_id): return response = self.GetWcaApi('/api/v0/competitions/%s/wcif' % competition_id) if response.status != 200: self.redirect(webapp2.uri_for('index', unknown=1)) return response_json = json.loads(response.read()) objects_to_put = [] schedule = Schedule() schedule.competition = self.competition.key schedule.creation_time = datetime.datetime.now() schedule.last_update_time = schedule.creation_time schedule.is_live = False schedule.put() for event in response_json['events']: event_key = ndb.Key(Event, event['id']) round_num = 0 next_round_count = 0 for round_json in event['rounds']: round_num += 1 round_object = ScheduleRound(id=ScheduleRound.Id( schedule.key.id(), event['id'], round_num)) round_object.schedule = schedule.key round_object.event = event_key round_object.number = round_num round_object.is_final = len(event['rounds']) == round_num round_object.format = ndb.Key(Format, round_json['format']) if round_json['cutoff']: round_object.cutoff = round_json['cutoff']['attemptResult'] if round_json['timeLimit'] and round_json['timeLimit'][ 'centiseconds']: round_object.time_limit = round_json['timeLimit'][ 'centiseconds'] round_object.wcif = json.dumps(round_json) if next_round_count: round_object.num_competitors = next_round_count objects_to_put.append(round_object) advancement_condition = round_json['advancementCondition'] if advancement_condition and advancement_condition[ 'type'] == 'ranking': next_round_count = advancement_condition['level'] else: next_round_count = 0 ndb.put_multi(objects_to_put) self.redirect( webapp2.uri_for('edit_schedule', schedule_version=schedule.key.id()))
def get(self, competition_id): admin_override = False # This verifies intra-appengine requests. See comment above FetchUrl for # explanation. if self.request.get('token'): token = RefreshToken.get_by_id(competition_id) if token and token.token == self.request.get('token'): admin_override = True else: self.response.set_status(400) self.response.write('mismatched token') return if not self.SetCompetition(competition_id, fail_if_not_found=False, edit_access_needed=(not admin_override), login_required=(not admin_override)): return if not self.GetToken(): return response = self.GetWcaApi('/api/v0/competitions/%s/wcif' % competition_id) if response.status != 200: self.redirect(webapp2.uri_for('index', unknown=1)) return response_json = json.loads(response.read()) self.competition.name = response_json['name'] self.competition.wca_competition = ndb.Key(Competition, competition_id) people = SchedulePerson.query( SchedulePerson.competition == self.competition.key).fetch() country_iso2s = set(person_data['countryIso2'] for person_data in response_json['persons']) countries = { country.iso2: country.key.id() for country in Country.query(Country.iso2.IN(country_iso2s)) } out = ImportOutput() out.entities_to_put.append(self.competition) for person_data in response_json['persons']: ImportPerson(person_data, self.competition, out, people, countries) if out.errors: template = JINJA_ENVIRONMENT.get_template( 'scheduling/import_error.html') self.response.write( template.render({ 'c': common.Common(self), 'errors': out.errors })) return ndb.put_multi(out.entities_to_put) ndb.delete_multi(out.entities_to_delete) if not admin_override: self.redirect( webapp2.uri_for('edit_competition', competition_id=competition_id))
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 render_page(self, template, mode, relname, site, pagename, v1, v2): pages = dict([(i.key, i) for i in ndb.get_multi(site.pages)]) basedir = 'themes/%s/' % site.theme page = pages[site.pages[0]] if pagename: for k, v in pages.items(): if v.name == pagename: page = v break if page.type == models.PAGE_TYPE_GALLERY: images = ndb.get_multi(page.images) else: images = ndb.get_multi( page.images[:len(page.spec().get('images', []))]) all_images = models.ImageBlob.query(ancestor=site.key).fetch() self.render( template, { 'all_images': all_images, 'base': '/static/' + basedir, 'defaults': models.TYPE_DEFAULTS, 'get': self.request.GET, 'images': images, 'mode': mode, 'page': page, 'pages': pages, 'pagetemplate': basedir + page.type + '.html', 'published_url': 'http://' + settings.BUCKET_NAME + '/' + site.key.id(), 'rel': webapp2.uri_for(relname, sitename=site.name) + '/', 'site': site, 'template': basedir + 'index.html', 'upload_url': webapp2.uri_for( 'upload-url', sitename=site.name, pageid=page.key.id()), 'v1': v1, 'v2': v2, 'view_url': webapp2.uri_for('view', sitename=site.name, pagename=page.name), })
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): self.cache_must_revalidate() values = dict() # values['edit_url'] = uri_for('calendar-new') values['sync_url'] = uri_for('cron-sync') values['calendar_admin_url'] = uri_for('calendar-admin') values['calendar'] = self.get_events() values['abstract_intro'] = config.abstract_intro self.render_response(self.get_template(), **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 obstasks_url(obstask, user2view, area_name, page=1): if page > 1: return webapp2.uri_for('view-obstasks', area_name=area_name, user2view=user2view, page=page) else: return webapp2.uri_for('view-obstasks', area_name=area_name, user2view=user2view)
def get(self): current_user = users.get_current_user() user, registered = self.process_credentials(current_user.email(), models.USER_SOURCE_GOOGLE, current_user.user_id()) if not registered: self.redirect(webapp2.uri_for('register')) else: self.redirect(webapp2.uri_for('main'))
def url(self, page=1): if page > 1: return webapp2.uri_for('view-journal', username=self.key().parent().name(), journal_name=self.name, page=page) else: return webapp2.uri_for('view-journal', username=self.key().parent().name(), journal_name=self.name)
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))
def uri_for_pagination(name, server_key=None, cursor=None): if server_key is None: uri = webapp2.uri_for(name) else: uri = webapp2.uri_for(name, server_key=server_key) if cursor is not None and cursor != 'START': if cursor.startswith('PAGE_0'): uri = u"{0}{1}{2}".format(uri, '&' if '?' in uri else '?', cursor[7:]) else: uri = u"{0}{1}cursor={2}".format(uri, '&' if '?' in uri else '?', cursor) return uri
def get_article(filename): year = filename[:4] month = filename[4:6] day = filename[6:8] key = 'article-' + filename[:-5] article = MemcacheManager.get(key) if article is not None: return article else: html = JINJA_ENVIRONMENT.get_template('articles/' + year + '/' + month + '/' + filename).render() title = re.findall('<h1>(.+?)</h1>', html)[0] html = re.sub('<h1>(.+?)</h1>', '', html, count=1) name = filename[9:-5] metadata = re.findall('@metadata: ({.+?})', html, re.DOTALL) metadata = json.loads(metadata[0]) if len(metadata) == 1 else None if metadata is not None: html = re.sub('@metadata: ({.+?})', '', html, count=1, flags=re.DOTALL) if "tags" in metadata: metadata["tags"] = [tag.strip() for tag in metadata["tags"].split(',')] else: metadata["tags"] = [] if "summary" not in metadata: metadata["summary"] = title if "lang" not in metadata: metadata["lang"] = "en" else: metadata = { "summary": title, "tags": [], "lang": "en" } article = { 'id': key, 'filename': filename, 'url2': urllib.quote_plus(webapp2.uri_for('post', _full=True, year=year, month=month, day=day, page=name)), 'html': html, 'formattedLongDate': calendar.month_name[int(month)] + ' ' + str(int(day)) + ', ' + year, 'formattedShortDate': month + '/' + day + '/' + year, 'dateTime': datetime.datetime(int(year), int(month), int(day)), 'title': title, 'link': '/' + year + '/' + month + '/' + day + '/' + name, 'url': webapp2.uri_for('post', _full=True, year=year, month=month, day=day, page=name), 'summary': metadata["summary"], 'lang': metadata["lang"], 'tags': metadata["tags"] } MemcacheManager.add(key, article) return article
def sysadmin_callback(request, response): logged_in_user = users.get_current_user() if not logged_in_user or not users.is_current_user_admin(): redirect_url = webapp2.uri_for('component.authentication.login.ui') webapp2.redirect(uri=redirect_url, request=request, response=response) return response registered_user = appapi.Users.get_by_auth_id(auth_id=logged_in_user.user_id()) if registered_user: # Sync user with the Google UserAPI modified = False if registered_user.email_address != logged_in_user.email(): registered_user.email_address = logged_in_user.email() modified = True if 'admin' not in registered_user.permissions.roles: registered_user.permissions.add_role('admin') modified = True if 'sysadmin' not in registered_user.permissions.roles: registered_user.permissions.add_role('sysadmin') modified = True if modified: appapi.Users.update(resource_object=registered_user) registered_user_uid = registered_user.uid else: random_password = koalacore.generate_random_string(20) user = appapi.Users.new(username=logged_in_user.user_id(), email_address=logged_in_user.email(), email_address_verified=True, first_name=u'Sys', raw_password=random_password, last_name=u'Admin', language_preference=u'en', roles={'user', 'admin', 'sysadmin'}) try: user_uid = appapi.Users.insert(resource_object=user) except koalacore.UniqueValueRequired: redirect_url = webapp2.uri_for('component.authentication.login.ui', status_code='16') webapp2.redirect(uri=redirect_url, request=request, response=response) return response registered_user_uid = user_uid request.environ['beaker.session']['user_uid'] = registered_user_uid redirect_url = webapp2.uri_for('default') webapp2.redirect(uri=redirect_url, request=request, response=response) return response
def get(self): if 'code' in self.request.GET and 'local_redirect' in self.request.GET: local_redirect = self.request.get('local_redirect') access_dict = facebook.access_dict( self.request.get('code'), {'local_redirect': local_redirect}) if access_dict: self.session['access_token'] = access_dict['access_token'] self.redirect( webapp2.uri_for(local_redirect, callback='callback')) return self.redirect(webapp2.uri_for('main'))
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))
def get(self, tower_id): 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') _log.debug('Get tower %s' % tower_id) tower = Tower.get_by_id(int(tower_id)) if tower is None: self.abort(404) else: self.write_json(tower)
def get(self): user = users.get_current_user() self.response.out.write(template.render( 'templates/json-api-post-login-password-reset.html', { 'user': user, 'login_url': users.create_login_url( webapp2.uri_for('documentation')), 'logout_url': users.create_logout_url( webapp2.uri_for('documentation')), 'password_forgot_url': users.create_password_forgot_url( webapp2.uri_for('documentation')), 'password_change_url': users.create_password_change_url( webapp2.uri_for('documentation')) }))
def get(self): """ Serve the homepage. """ user = users.get_current_user() self.response.out.write(template.render( 'templates/index.html', { 'user': user, 'login_url': users.create_login_url(webapp2.uri_for('protected')), 'logout_url': users.create_logout_url(webapp2.uri_for('home')), 'password_forgot_url': users.create_password_forgot_url( webapp2.uri_for('protected')), 'password_change_url': users.create_password_change_url( webapp2.uri_for('home')) } ))
def get(self): try: context = {} context['question'] = u'Kill the GCE instance?' context['confirmed_url'] = webapp2.uri_for('instance_stop') context['cancelled_url'] = webapp2.uri_for('admin') self.render_template('confirm.html', context=context) except webapp2.HTTPException: pass except Exception as e: message = u'GCE instance could not be killed (Reason: {0}).'.format(e) logging.error(message) self.session.add_flash(message, level='error') self.redirect(webapp2.uri_for('admin'))
def get(self): """ Restrict this page to logged in users only! """ user = users.get_current_user() if not user: self.abort(401) else: self.response.out.write(template.render( 'templates/protected-page.html', { 'user': user, 'logout_url': users.create_logout_url(webapp2.uri_for('home')), 'password_change_url': users.create_password_change_url( webapp2.uri_for('protected')) } ))
def post(self, event_id): event = Event.get_by_id(event_id) if not event: self.redirect(uri_for('home')) manual_seed = self.request.POST.get('manual_seeding') bracket_id = self.request.POST.get('bracket_id') if not bracket_id: weightclass = Weightclass.get_by_code( self.request.POST['weightclass']) if not weightclass: raise ValueError("bad weightclass") format = FORMATS.get(self.request.POST['format']) if not format: raise ValueError("bad format") if format.get('code') == 'roundrobin': manual_seed = False name = self.request.POST['name'] bracket = Bracket(event_id=event.id, match_length=weightclass.default_match_length, format_code=format['code'], weightclass_code=weightclass.code, name=name, manual_seed=manual_seed or False, generated=False) bracket.put() else: bracket = Bracket.get_by_id(bracket_id) seeding = self.request.POST.getall('seeding[]') if manual_seed and not seeding: self.redirect( uri_for('manual-seed', event_id=event_id, bracket_id=bracket.id)) else: result = bracket.generate(seeding) if result: bracket.generated = True bracket.put() else: bracket.delete() self.redirect(uri_for('single-bracket', event_id=event_id, bracket_id=bracket.id), abort=False)
def get(self): page_title = 'testapp - The CrowdFunding Portal' page_description = 'testapp - The CrowdFunding Portal' context = {'page_title': page_title, \ 'page_description': page_description, \ 'form_contact': self.form_contact, \ 'form_waiting': self.form_waiting, \ 'waiting_action': webapp2.uri_for('waiting_list_submit', _full=True), \ 'contact_action': webapp2.uri_for('contact_submit', _full=True), \ } self.render_response('public/splash.html', **context)
def login_auth_id(self, auth_id, is_admin=False, email=None, nickname=None, username=None): next_url = self.request.params.get('next_url', None) if self.logged_in: self.redirect(next_url or webapp2.uri_for('main')) return user = self.auth.store.user_model.get_by_auth_id(auth_id) if user: self.auth.set_session(self.auth.store.user_to_dict(user), remember=True) else: ok = False if username is not None: user = User.lookup(username=username) if user is not None: user.add_auth_id(auth_id) ok = True if not ok: ok, user = self.auth.store.user_model.create_user( auth_id, email=email, nickname=nickname) if ok: send_new_user_email(user) if ok: self.auth.set_session(self.auth.store.user_to_dict(user), remember=True) next_url = webapp2.uri_for('user_profile', next_url=next_url or webapp2.uri_for('main')) else: self.auth.unset_session() user = None next_url = None if user: if is_admin and not (user.active and user.admin): user.active = True user.admin = True user.last_login = datetime.datetime.utcnow() if username is not None: user.add_username(username) user.put() if ON_SERVER: time.sleep(2) if not user.active: next_url = webapp2.uri_for('main') self.redirect(next_url or webapp2.uri_for('main'))
def ImportWcif(self, wcif_data, data_to_import, deletion_confirmed=False): out = ImportOutput() if 'events' in data_to_import: ImportEvents(wcif_data, self.schedule.key, out) if 'schedule' in data_to_import: ImportSchedule(wcif_data, self.schedule, out) if out.errors: template = JINJA_ENVIRONMENT.get_template( 'scheduling/import_error.html') self.response.write( template.render({ 'c': common.Common(self), 'errors': out.errors })) elif out.entities_to_delete and not deletion_confirmed: template = JINJA_ENVIRONMENT.get_template( 'scheduling/confirm_deletion.html') self.response.write( template.render({ 'c': common.Common(self), 'entities_to_delete': out.entities_to_delete, 'entity_to_string': EntityToString, 'wcif_data': json.dumps(wcif_data), 'target_uri': webapp2.uri_for('confirm_deletion', schedule_version=self.schedule.key.id()), 'data_to_import': data_to_import, })) else: self.schedule.last_update_time = datetime.datetime.now() out.entities_to_put.append(self.schedule) ndb.put_multi(out.entities_to_put) ndb.delete_multi([e.key for e in out.entities_to_delete]) template = JINJA_ENVIRONMENT.get_template('success.html') self.response.write( template.render({ 'c': common.Common(self), 'target_uri': webapp2.uri_for('edit_schedule', competition_id=self.competition.key.id(), schedule_version=self.schedule.key.id()) }))
def get(self): amount = self.request.GET.get('amount', 1) # The first step, after a checkout request # is to generate a database record. # Doing this gives us a unique key (automatically # generated by the database) that we will use # when requesting a payment token from KNET order = Transaction() order.total_amount = amount key = order.put() # Save the unique key # Read the resource file, and generate a payment request file_path = os.path.join(os.path.split(__file__)[0], 'resource.cgn') pgw = Gateway(file_path, ALIAS) pgw.error_url = webapp2.uri_for('error', _full=True) pgw.response_url = webapp2.uri_for('gw', _full=True) pgw.amount = amount pgw.trackid = key.urlsafe() # You must supply a tracking ID # which has to be unique per transaction # the Python version of the integration library # will automatically generate a key if you do not # provide one, but its best to give a value # explicity. This key is returned back as "trackid" # This line contacts KNET to get the payment token # and redirect URI. Any exception raised at this stage # should stop the application going forward. gw_info = pgw.get_payment_url() payment_token = gw_info['paymentID'] payment_url = gw_info['paymentURL'] if payment_url[-1] == '&': template_url = '{}PaymentID={}' else: template_url = '{}?PaymentID={}' order.payment_id = payment_token # Save the payment token as part of the # transaction record order.put() # Redirect the user to the payment page return webapp2.redirect(template_url.format(payment_url, payment_token))
def get_mailgun_email_footer_template(self, newsletter=''): link_home = webapp2.uri_for('home', _full=True) link_unsubscribe_all = webapp2.uri_for( 'emailunsubscribe', unsubscribetoken='PLACEHOLDER_MAILGUN_RECIPIENT_TOKEN', _full=True).replace('PLACEHOLDER_MAILGUN_RECIPIENT_TOKEN', '%recipient.token%') link_unsubscribe_newsletter = link_unsubscribe_all + '?newsletter=' + newsletter text = u'''\n\n\nThis newsletter was sent to you by {organisation}. Visit our website {link_home} or contact us at {contact}\nTo unsubscribe from this newsletter follow this link: {link_unsubscribe_newsletter}\nTo unsubscribe from all newsletters follow this link: {link_unsubscribe_all} (click or copy and paste in your browser)\n\nCette lettre d'information vous a été envoyée par {organisation}. Visitez notre site {link_home} ou contactez-nous à {contact}\nPour vous désabonner de cette lettre suivez ce lien : {link_unsubscribe_newsletter}\nPour vous désabonner de toutes les lettres d'information suivez ce lien : {link_unsubscribe_all} (cliquez ou copiez-collez le lien dans votre navigateur)'''.format( organisation=settings.ORGANISATION_NAME, link_home=link_home, contact=settings.ORGANISATION_CONTACT, link_unsubscribe_newsletter=link_unsubscribe_newsletter, link_unsubscribe_all=link_unsubscribe_all) return text
def get(self): """ Serves the JSON API page. """ user = users.get_current_user() self.response.out.write(template.render( 'templates/json-api.html', { 'user': user, 'login_url': users.create_login_url( webapp2.uri_for('documentation')), 'logout_url': users.create_logout_url( webapp2.uri_for('documentation')), 'password_forgot_url': users.create_password_forgot_url( webapp2.uri_for('documentation')), 'password_change_url': users.create_password_change_url( webapp2.uri_for('documentation')) }))
def buildURI(self, target, collection=None): if isinstance(target, db.Key): if collection: return webapp2.uri_for("rest-model-collection", modelname=target.kind(), itemid=target.id(), collectionname=collection, _full=True) else: return webapp2.uri_for("rest-model-item", modelname=target.kind(), itemid=target.id(), _full=True) else: return webapp2.uri_for("rest-model-list", modelname=target.__name__, _full=True)
def get(self, *args, **kwargs): # RSSフィード一覧取得 urlLogout = users.create_logout_url('/') urlStoreFeed = webapp2.uri_for('store-feed') urlListBlogs = webapp2.uri_for('list-blogs') # logging.info(super(DefaultHandler, self).get_module_name()) feed_key = NdbFeed.get_ancestor() feeds = NdbFeed.query_feed(feed_key) template_values = { 'feeds': feeds, 'urlLogout': urlLogout, 'urlStoreFeed': urlStoreFeed, 'urlListBlogs': urlListBlogs, } template = self.JINJA_ENVIRONMENT.get_template('blogs.html') self.response.write(template.render(template_values))
def push_notification2(self, to_email, subject, template, notifcation_type, event, user, only_once=False, **template_val): if only_once and self._already_notified(notifcation_type, event, user): return if self._handler is None: email_body = jinja2.get_jinja2( factory=jinja2.Jinja2(webapp2.get_app()), app=webapp2.get_app()).render_template(template, **template_val) email_url = webapp2.uri_for('taskqueue-send-email') else: email_body = self._handler.jinja2.render_template( template, **template_val) email_url = self._handler.uri_for('taskqueue-send-email') taskqueue.add(url=email_url, params={ 'to': to_email, 'subject': subject, 'body': email_body }) notification = Notification() notification.type = notifcation_type notification.event = event.key notification.user = user.key notification.put()
def ssh_keys_add(request, user_id): """Handles the form to allow adding SSH keys. """ # normalize user ID ouid = user_id if not aeusers.is_current_user_admin() and not user_id == 'me': return webapp2.redirect_to('users-profile', user_id='me') if user_id == 'me': user_id = request.user.user_id() user = users.get(user_id) # if form validates then save the object to the datastore form = forms.SSHKeyForm(request.POST) if request.method == 'POST' and form.validate(): _err = False # ensure this key doesn't already exist in the system if ssh_keys.check_exists(form.ssh_key.data): _err = True _msg = 'SSH key already exists in the system.' try: form.errors['ssh_key'].append(_msg) except KeyError: form.errors['ssh_key'] = [_msg] if not _err: ssh_keys.add_for_user(user, form.title.data, form.ssh_key.data) session = request.session() session.add_flash('SSH key added: {0}'.format(form.title.data), level='success') return webapp2.redirect_to('users-profile', user_id=ouid) # render template with the form in the context return {'form': form, 'cancel_url': webapp2.uri_for('users-profile', user_id=ouid), 'user': user}