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 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, 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):
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 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 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):
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))
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 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 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}
