class MainPage(webapp2.RequestHandler):
def get(self):
template = JINJA_ENVIRONMENT.get_template('home.html')
template_values = {}
self.response.write(template.render(template_values))
class SecondPage(webapp2.RequestHandler):
def post(self):
self.response.write(
'<!doctype html><html><body>Running simulation.<pre>')
num_trials = int(cgi.escape(self.request.get('numTrials')))
price, volatility, option_data = main.run(num_trials)
template = JINJA_ENVIRONMENT.get_template('results.html')
template_values = {
'option_data': option_data,
'price': price,
'volatility': volatility
}
self.response.write(template.render(template_values))
application = webapp2.WSGIApplication([
('/', MainPage),
('/run', SecondPage),
],
debug=True)
#!/usr/bin/env python
import webapp2
from InterstitialEndpoint import InterstitialEndpoint
from OauthCallbackEndpoint import OauthCallbackEndpoint
from MergeEndpoint import MergeEndpoint
from ErrorLogEndpoint import ErrorLogEndpoint
from MainPageEndpoint import MainPageEndoint
app = webapp2.WSGIApplication([
('/interstitial', InterstitialEndpoint),
(r'/oauth_callback/(.*)', OauthCallbackEndpoint),
('/merge', MergeEndpoint),
('/errorlog', ErrorLogEndpoint),
('/', MainPageEndoint),
],
debug=True)
self.redirect('https://www.gdgkl.org')
else:
self.redirect('//' + self.request.host + '/io/' +
'/'.join(path[2:]))
class Io2018(webapp2.RequestHandler):
def get(self, *args, **kwargs):
path = self.request.path_qs.split('/')
if (path[1] != 'io2018'):
self.redirect('https://www.gdgkl.org')
else:
self.redirect('//' + self.request.host + '/io/' +
'/'.join(path[2:]))
class Io18(webapp2.RequestHandler):
def get(self, *args, **kwargs):
path = self.request.path_qs.split('/')
if (path[1] != 'io18'):
self.redirect('https://www.gdgkl.org')
else:
self.redirect('//' + self.request.host + '/io/' +
'/'.join(path[2:]))
app = webapp2.WSGIApplication([('/io.*', SlashRedirect),
('/ioxkl18.*', Ioxkl18),
('/io18extended.*', Io18extended),
('/io2018.*', Io2018), ('/io18.*', Io18)],
debug=True)
app = webapp2.WSGIApplication([
('/', MainPage),
('/character',Character),
('/cat',CatStory),
('/cat1',Cat1),
('/cat2',Cat2),
('/catB', CatB),
('/catA', CatA),
('/panda',PandaStory),
('/panda1', Panda1),
('/pandaA', PandaA),
('/pandaB', PandaB),
('/pandapostA', PandaPostA),
('/pandapostB', PandaPostB),
('/dog',DogStory),
('/dog1', Dog1),
('/dogpreA', DogpreA),
('/dogpreB', DogpreB),
('/dog2A', Dog2A),
('/dog2B', Dog2B),
], debug=True)
except Exception:
logging.error('%s', traceback.format_exc())
self.error(500)
#Configurations des différentes routes
app = webapp2.WSGIApplication(
#Test du serveur web
[webapp2.Route(r'/', handler=MainPageHandler,
methods=['GET']),
#Chargement et suppression de des jeux videos ainsi que les heros
webapp2.Route(r'/jeux', handler=ChargementHandler,
methods=['PUT', 'DELETE']),
webapp2.Route(r'/jeux', handler=JeuxHandler,
methods=['GET', 'DELETE']),
webapp2.Route(r'/jeux/<idJeu>', handler=JeuxHandler,
methods=['GET', 'PUT', 'DELETE']),
webapp2.Route(r'/jeux/<idJeu>/hero', handler=HeroHandler,
methods=['GET'])
],
debug=True)
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import webapp2
import json
class MainHandler(webapp2.RequestHandler):
def get(self):
self.response.write('Hello world!')
class JobHandler(webapp2.RequestHandler):
def get(self):
self.response.headers['Content-type'] = 'application/json'
obj = {
'success': 'hogehoge',
'test': 'fugafuga',
}
self.response.out.write(json.dumps(obj))
app = webapp2.WSGIApplication([('/', JobHandler)], debug=True)
items = Item.query().fetch()
your_items = Item.query().filter(Item.user_id == my_user.user_id()).order(-Item.created_on).fetch()
others_items = Item.query().order(-Item.created_on).fetch()
my_dict = {
'auth_url': auth_url,
'greeting': greeting,
'your_own_items': your_items,
'everyones_items': others_items,
}
self.response.write(main_temp.render(my_dict))
class AboutUsHandler(webapp2.RequestHandler):
def get(self):
aboutuspage = jinja_current_dir.get_template("templates/aboutus.html")
my_user, auth_url, greeting = get_user_info()
my_dict = {
'auth_url': auth_url,
'greeting': greeting
}
self.response.write(aboutuspage.render(my_dict))
app = webapp2.WSGIApplication([
('/', MainPage),
('/new-post', ItemHandler),
('/my-posts', MyPostsHandler),
('/details', DetailItemHandler),
('/aboutus', AboutUsHandler)
], debug=True)
import webapp2
class MainHandler(webapp2.RequestHandler):
def get(self):
self.response.write(
'hello from some random URL! <br> Here is a picture of a turtle: <br><img src="/img/Turtles.jpg">'
)
class CatchAllHandler(webapp2.RequestHandler):
def get(self):
self.response.write('hello from some random URL after /one/')
app = webapp2.WSGIApplication([('/one/?', MainHandler),
('/one.*', CatchAllHandler)],
debug=True)
deal.deal_type = "bundle"
tags.extend(levr.tagger(secondary_name))
deal.secondary_name = secondary_name
else:
deal.deal_type = "single"
deal.businessID = business.key().__str__()
deal.business_name = business_name
deal.date_start = datetime.now()
deal.deal_status = "active"
deal.address_string = full_address
deal.tags = tags
logging.debug(tags)
logging.debug(deal)
logging.debug(business)
deal.put()
business.put()
self.response.set_status(200)
self.response.out.write('we good.')
self.redirect('/new')
except:
levr.log_error()
self.response.set_status(500)
self.response.out.write('exception')
app = webapp2.WSGIApplication([('/merchants/deal', DealHandler),
('/merchants/deal/upload', DealUploadHandler)],
debug=True)
commented_post = post_id.get()
comment = Comment()
comment.comment_text = comment_text
comment.owner_user = myuser_key
comment_key = comment.put()
commented_post.comments.insert(0,comment_key)
commented_post.put()
self.redirect('/')
# starts the web application we specify the full routing table here as well
app = webapp2.WSGIApplication([
('/', MainPage,),
('/upload', UploadHandler),
('/download', DownloadHandler),
('/profile', Profile),
('/search', Search),
('/display', Display),
('/view', View)
], debug=True)
super(FeatureObserverPopularityHandler, self).get()
class FeatureBucketsHandler(common.BaseHandler):
def get(self, type):
if type == 'cssprops':
properties = sorted(
models.CssPropertyHistogram.get_all().iteritems(),
key=lambda x: x[1])
else:
properties = sorted(
models.FeatureObserverHistogram.get_all().iteritems(),
key=lambda x: x[1])
self.response.headers[
'Content-Type'] = 'application/json;charset=utf-8'
return self.response.write(
json.dumps(properties, separators=(',', ':')))
app = webapp2.WSGIApplication([
('/data/timeline/cssanimated', AnimatedTimelineHandler),
('/data/timeline/csspopularity', PopularityTimelineHandler),
('/data/timeline/featurepopularity', FeatureObserverTimelineHandler),
('/data/csspopularity', CSSPopularityHandler),
('/data/cssanimated', CSSAnimatedHandler),
('/data/featurepopularity', FeatureObserverPopularityHandler),
('/data/blink/(.*)', FeatureBucketsHandler),
],
debug=settings.DEBUG)
<div><input type="submit" value="Sign Guestbook"></div>
</form>
<hr>
<form>Guestbook name: <input value="%s" name="guestbook_name">
<input type="submit" value="switch"></form>
</body>
</html>""" % (urllib.urlencode({'guestbook_name': guestbook_name}),
cgi.escape(guestbook_name)))
class Guestbook(webapp2.RequestHandler):
def post(self):
# We set the same parent key on the 'Greeting' to ensure each greeting is in
# the same entity group. Queries across the single entity group will be
# consistent. However, the write rate to a single entity group should
# be limited to ~1/second.
guestbook_name = self.request.get('guestbook_name')
greeting = Greeting(parent=guestbook_key(guestbook_name))
if users.get_current_user():
greeting.author = users.get_current_user()
greeting.content = self.request.get('content')
greeting.put()
self.redirect('/?' + urllib.urlencode({'guestbook_name': guestbook_name}))
app = webapp2.WSGIApplication([('/', MainPage),
('/sign', Guestbook)],
debug=True)
<input value="{guestbook_name}" name="guestbook_name">
<input type="submit" value="switch">
</form>
</body>
</html>""").format(
blockquotes='\n'.join(greeting_blockquotes),
sign=urllib.urlencode({'guestbook_name': guestbook_name}),
guestbook_name=cgi.escape(guestbook_name)))
# [START submit]
class SubmitForm(webapp2.RequestHandler):
def post(self):
# We set the parent key on each 'Greeting' to ensure each guestbook's
# greetings are in the same entity group.
guestbook_name = self.request.get('guestbook_name')
greeting = Greeting(parent=ndb.Key("Book",
guestbook_name or "*notitle*"),
content=self.request.get('content'))
greeting.put()
# [END submit]
self.redirect('/?' + urllib.urlencode(
{'guestbook_name': guestbook_name}))
app = webapp2.WSGIApplication([
('/', MainPage),
('/sign', SubmitForm)
])
# [END all]
template_dir = os.path.join(os.path.dirname(__file__), "templates")
jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(template_dir),
autoescape=False)
class BaseHandler(webapp2.RequestHandler):
def write(self, *a, **kw):
return self.response.out.write(*a, **kw)
def render_str(self, template, **params):
t = jinja_env.get_template(template)
return t.render(params)
def render(self, template, **kw):
return self.write(self.render_str(template, **kw))
def render_template(self, view_filename, params=None):
if params is None:
params = {}
template = jinja_env.get_template(view_filename)
return self.response.out.write(template.render(params))
class MainHandler(BaseHandler):
def get(self):
return self.render_template("fakebook.html")
app = webapp2.WSGIApplication([webapp2.Route('/', MainHandler)], debug=True)
list2=0
if mytwitter!=None:
for i in mytwitter.followers:
list1=list1+1
for j in mytwitter.following:
list2=list2+1
module_part = ndb.Key('TweetAll', 'master')
module = module_part.get()
tweetlist=[]
tweetname=[]
if module!=None:
for i in reversed(module.alltweets):
tweetlist.append(i)
tweetlist = tweetlist[:50]
for j in reversed(module.uname):
tweetname.append(j)
tweetname=tweetname[:50]
tweetz=zip(tweetname,tweetlist)
www=zip(z,list3)
template_values = {'url' : url,'url_string' : url_string,'user' : user,'welcome' : welcome,'mytwitter' : mytwitter,'first':first,'lastman':lastman,'second':second,'list3':list3,'list1':list1,'list2':list2,'tweetz':tweetz,"www":www}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
app = webapp2.WSGIApplication([('/', MainPage),('/name', Name),('/edit',Edit),('/userprofile/(.*)',UserProfile),('/update/(.*)',Update)], debug=True)
if u:
self.login(u)
self.redirect('/')
else:
msg = 'Invalid login'
self.render('login-form.html', error=msg)
class Logout(BlogHandler):
def get(self):
self.logout()
self.redirect('/')
app = webapp2.WSGIApplication([
('/', BlogFront),
('/([0-9]+)/editpost', EditPost),
('/([0-9]+)/deletepost', DeletePost),
('/([0-9]+)/addcomment', AddComment),
('/([0-9]+)/togglelike', ToggleLike),
('/([0-9]+)/([0-9]+)/editcomment', EditComment),
('/([0-9]+)/([0-9]+)/deletecomment', DeleteComment),
('/([0-9]+)', PostPage),
('/newpost', NewPost),
('/signup', Register),
('/login', Login),
('/logout', Logout),
('/deletepostmessage', DeleteCommentMsg),
],
debug=True)
app = webapp2.WSGIApplication([
webapp2.Route(r'/', landing_handler[tba_config.CONFIG['landing_handler']],
'landing'),
webapp2.Route(r'/about', AboutHandler, 'about'),
webapp2.Route(r'/account', AccountOverview, 'account-overview'),
webapp2.Route(r'/account/edit', AccountEdit, 'account-edit'),
webapp2.Route(r'/account/register', AccountRegister, 'account-register'),
webapp2.Route(r'/apidocs', ApiDocumentationHandler, 'api-documentation'),
webapp2.Route(r'/contact', ContactHandler, 'contact'),
webapp2.Route(r'/event/<event_key>', EventDetail, 'event-detail'),
webapp2.Route(r'/event/<event_key>/feed', EventRss, 'event-rss'),
webapp2.Route(r'/events', EventList, 'event-list'),
webapp2.Route(r'/events/<year:[0-9]+>', EventList, 'event-list'),
webapp2.Route(r'/gameday', GamedayHandler, 'gameday'),
webapp2.Route(r'/gameday2', Gameday2Controller, 'gameday2'),
webapp2.Route(r'/hashtags', HashtagsHandler, 'hashtags'),
webapp2.Route(r'/insights', InsightsOverview, 'insights'),
webapp2.Route(r'/insights/<year:[0-9]+>', InsightsDetail,
'insights-detail'),
webapp2.Route(r'/logout', AccountLogout, 'account-logout'),
webapp2.Route(r'/match/<match_key>', MatchDetail, 'match-detail'),
webapp2.Route(r'/opr', OprHandler, 'opr'),
webapp2.Route(r'/record', RecordHandler, 'record'),
webapp2.Route(r'/search', SearchHandler, 'search'),
webapp2.Route(r'/suggest/event/webcast', SuggestEventWebcastController,
'suggest-event-webcast'),
webapp2.Route(r'/suggest/match/video', SuggestMatchVideoController,
'suggest-match-video'),
webapp2.Route(r'/suggest/team/media', SuggestTeamMediaController,
'suggest-team-media'),
webapp2.Route(r'/team/<team_number:[0-9]+>', TeamCanonical,
'team-canonical'),
webapp2.Route(r'/team/<team_number:[0-9]+>/<year:[0-9]+>', TeamDetail,
'team-detail'),
webapp2.Route(r'/team/<team_number:[0-9]+>/history', TeamHistory,
'team-history'),
webapp2.Route(r'/teams', TeamList, 'team-list'),
webapp2.Route(r'/teams/<page:[0-9]+>', TeamList, 'team-list'),
webapp2.Route(r'/thanks', ThanksHandler, 'thanks'),
webapp2.Route(r'/webcasts', WebcastsHandler, 'webcasts'),
webapp2.Route(r'/_/live-event/<event_key>/<timestamp:[0-9]+>',
LiveEventHandler, 'ajax-live-event'),
webapp2.Route(r'/_/typeahead/<search_key>', TypeaheadHandler,
'ajax-typeahead'),
webapp2.Route(r'/_/webcast/<event_key>/<webcast_number>', WebcastHandler,
'ajax-webcast'),
webapp2.Route(r'/<:.*>', PageNotFoundHandler, 'page-not-found'),
],
debug=tba_config.DEBUG)
holding1 = len(hold1)
holding2 = len(hold2)
test = myDictBasic
player1move = moves[len(moves)-2]
player2move = moves[-1]
if len(player1q) > 0:
show1 = '/cards/'+str(player1q[0][1])+'.png'
if len(player1q) > 1:
show2 = '/cards/'+str(player1q[1][1])+'.png'
img1 = '/cards/'+str(player1move[1]) + '.png'
img2 = '/cards/'+str(player2move[1])+'.png'
print("won:",won)
replaces={'won': won,"moves": moves, "player1":deck1, "player2":deck2, "player1hold":holding1, "player2hold":holding2, "test":test, "lost": lost, "p1move":player1move[0], "p2move":player2move[0], "img1":img1, "img2":img2, "show1" : show1, "show2":show2}
self.response.write(template.render(replaces))
# Route mapping
app = webapp2.WSGIApplication([
# This line routes the main url ('/') - also know as
# The root route - to the Fortune Handler
('/', Main),
('/playBasic', playBasic),
('/playShort', playShort),
('/playCool', coolwar)
#('/farewell', GoodbyeHandler) #maps '/predict' to the FortuneHandler
], debug=True)
#!/usr/bin/env python
#
# Copyright 2016 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import webapp2
class MainHandler(webapp2.RequestHandler):
def get(self):
self.redirect("/devsummit/", permanent=True)
app = webapp2.WSGIApplication([('/devsummit', MainHandler)], debug=True)
content_type = 'application/octet-stream'
elif file_name.endswith(THUMB_SUFFIX):
content_type = 'image/png'
self.response.headers['Content-Type'] = content_type
# Cache for the expiration time:
self.response.headers['Cache-Control'] = 'public,max-age=%d' \
% EXPIRATION_TIME
self.response.write(data)
def delete(self, content_type, data_hash, file_name):
content_type = self.normalize(content_type)
file_name = self.normalize(file_name)
key = content_type + '/' + data_hash + '/' + file_name
result = {key: memcache.delete(key)}
content_type = urllib.unquote(content_type)
if IMAGE_TYPES.match(content_type):
thumbnail_key = key + THUMB_SUFFIX
result[thumbnail_key] = memcache.delete(thumbnail_key)
if 'application/json' in self.request.headers.get('Accept'):
self.response.headers['Content-Type'] = 'application/json'
s = self.json_stringify(result)
self.response.write(s)
app = webapp2.WSGIApplication(
[
('/', UploadHandler),
('/(.+)/([^/]+)/([^/]+)', FileHandler)
],
debug=DEBUG
)
import os
import utils
import webapp2
from wiki import WikiPage
from signup import Register
from login import Login
from logout import Logout
from edit_page import EditPage
#PAGE_RE = '^[/]?[\S]+?$'
PAGE_RE = '^[/]?(?!.*favicon\.ico).*[\S]+?$'
DEBUG = bool(os.environ['SERVER_SOFTWARE'].startswith('Development'))
app = webapp2.WSGIApplication([('/signup', Register), ('/login', Login),
('/logout', Logout),
('^/_edit/[\S]*?$', EditPage),
(PAGE_RE, WikiPage)],
debug=DEBUG)
# app = webapp2.WSGIApplication([('/signup', Signup),
# ('/login', Login),
# ('/logout', Logout),
# ('/_edit' + PAGE_RE, EditPage),
# (PAGE_RE, WikiPage), ],
# debug=DEBUG)
# class TestHandler(webapp2.RequestHandler):
# def get(self):
# self.response.write('Hello')
# # Your Account SID from twilio.com/console
# account_sid = "AC421e208e540df7fc2f79ece8da7ef47a"
# # Your Auth Token from twilio.com/console
# auth_token = ""
#
# url = 'https://api.twilio.com/2010-04-01/Accounts/%s/Messages' % account_sid
# payload_dict = {'To': '', 'From': '', 'Body': 'Hello'}
# payload = urllib.urlencode(payload_dict)
# authorization_header = "Basic %s" % base64.b64encode("%s:%s" % (account_sid, auth_token))
# urlfetch.fetch(url, payload=payload, headers={
# "Authorization": authorization_header
# }, method="POST", validate_certificate=True)
app = webapp2.WSGIApplication([
('/', MainHandler),
('/create_goal', CreateGoals),
('/create_profile', CreateProfile),
('/create_user',CreateUser),
# ('/test', TestHandler),
('/feed', Feed),
('/sign_up', SignUpHandler),
('/add_friend', FriendHandler),
('/goal_complete', GoalComplete)
], debug=True)
if not user:
self.render_login_form(error="Invalid username")
elif hashutils.valid_pw(submitted_username, submitted_password, user.pw_hash):
self.login_user(user)
self.redirect('/blog/newpost')
else:
self.render_login_form(error="Invalid password")
class LogoutHandler(BlogHandler):
def get(self):
self.logout_user()
self.redirect('/blog')
app = webapp2.WSGIApplication([
('/', IndexHandler),
('/blog', BlogIndexHandler),
('/blog/newpost', NewPostHandler),
webapp2.Route('/blog/<id:\d+>', ViewPostHandler),
webapp2.Route('/blog/<username:[a-zA-Z0-9_-]{3,20}>', BlogIndexHandler),
('/signup', SignupHandler),
('/login', LoginHandler),
('/logout', LogoutHandler)
], debug=True)
# A list of paths that a user must be logged in to access
auth_paths = [
'/blog/newpost'
]
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import webapp2
import re
class MainHandler(webapp2.RequestHandler):
def __init__(self, request=None, response=None):
self.initialize(request, response)
self.temperature = self.request.get('temperature', 'anonymous')
def post(self):
if re.match('^[0-9]+(.[0-9]+)*$', self.temperature) == None:
self.response.write('Has introducido un valor incorrecto')
else:
celsius = int(self.temperature) + 1
farenheit = int(self.temperature) * 1.8 + 32
self.response.write('Celsius: ' + str(celsius) + ' , Farenheit: ' +
str(farenheit))
app = webapp2.WSGIApplication([('/convert', MainHandler)], debug=True)
c = Comment()
c.commenter = users.get_current_user()
c.message = db.Text(self.request.get('message'))
c.date = datetime.datetime.now()
c.put()
self.redirect('/')
class CommentFormHandler(webapp2.RequestHandler):
def get(self):
self.response.out.write('<p>Comments:</p><ul>')
# Borrowing a bit from chapter 5...
for c in Comment.all().order('-date'):
self.response.out.write(
'<li>%s<br />posted by %s on %s</li>' % (cgi.escape(
c.message), cgi.escape(c.commenter.nickname()), c.date))
self.response.out.write('</ul>')
self.response.out.write('''<p>Post a comment:</p>
<form action="/post" method="POST">
<textarea name="message"></textarea><br />
<input type="submit" />
</form>
''')
app = webapp2.WSGIApplication([('/', CommentFormHandler),
('/post', CommentHandler)],
debug=True)
def get(self):
if self.user: #user is set up in the BlogHandler initialize function
self.render('welcome.html', username=self.user.name)
else:
self.redirect('/signup')
# class Welcome(BlogHandler):
# def get(self):
# username = self.request.get('username')
# if valid_username(username):
# self.render('welcome.html', username = username)
# else:
# self.redirect('/unit2/signup')
app = webapp2.WSGIApplication(
[
('/', MainPage),
# ('/unit2/rot13', Rot13),
# ('/unit2/signup', Unit2Signup),
# ('/unit2/welcome', Welcome),
('/blog/?', BlogFront),
('/blog/([0-9]+)', PostPage),
('/blog/newpost', NewPost),
('/signup', Register),
('/login', Login),
('/logout', Logout),
('/unit3/welcome', Unit3Welcome),
],
debug=True)
class MainPage(webapp.RequestHandler):
def get(self):
# Disable the reflected XSS filter for demonstration purposes
self.response.headers.add_header("X-XSS-Protection", "0")
if not self.request.get('timer'):
# Show main timer page
self.response.out.write(render('index.html'))
else:
# Show the results page
timer = self.request.get('timer', 0)
safeTimer = sanitize_html(timer)
self.response.out.write(
render('timer-safe.html', {'timer': safeTimer}))
return
application = webapp.WSGIApplication([
('.*', MainPage),
], debug=False)
def main():
from paste import httpserver
httpserver.serve(application, host='127.0.0.1', port='8080')
if __name__ == '__main__':
main()
def setUp(self):
app = webapp2.WSGIApplication([('/', GlyphRequest)])
self.testapp = webtest.TestApp(app)
current_player.score += 1
current_player.put()
templateVars = {
'players': players,
'current_player': current_player,
}
template = env.get_template('templates/game.html')
self.response.write(template.render(templateVars))
app = webapp2.WSGIApplication([
('/', LoginPage),
('/game', GamePage),
],
debug=True)
#INTERACTIVE CONSOLE
# patches_query = Patch.query()
# patches_query = Patch.query().filter(Patch.inner_color == "blue") <-- filter + order oldest to newest
#patches_query = patches_query.order(-Patch.created_time) <--- normally oldest to newest, - for reverse
# first_patch = patches_query.get() #gets one
#
# patches = patches_query.fetch() #gets all the data, ORDER before fetching
# first_patch.inner_color = "lightblue"
# first_patch.put() <--- saves it into the database
# first_patch.key.delete() <--- key is like SSN
#CRUD - Create(call the class and then save with .put()), Read(get, fetch), Update(.put), Delete(.key.delete)
# limitations under the License.
#
import webapp2
import os
import jinja2
template_dir = os.path.join(os.path.dirname(__file__), 'templates')
jinja_env = jinja2.Environment(loader = jinja2.FileSystemLoader(template_dir),
autoescape = True)
class Handler(webapp2.RequestHandler):
def write(self, *a, **kw):
self.response.out.write(*a, **kw)
def render_str(self, template, **params):
t = jinja_env.get_template(template)
return t.render(params)
def render(self, template, **kw):
self.write(self.render_str(template, **kw))
class MainPage(Handler):
def get(self):
self.render("index.html")
app = webapp2.WSGIApplication([
('/', MainPage),], debug=True)
