def get(self):
template_data = {}
user = users.get_current_user()
if user == None:
self.redirect(users.CreateLoginURL(self.request.uri))
return
user_settings = settings.get(user)
if user_settings:
template_data = {
'auth_url': users.CreateLogoutURL(self.request.uri),
'auth_text': 'Sign out',
'user_email': user.email(),
'user_nickname': user.nickname(),
'default_location': user_settings.default_location,
'default_zoom': user_settings.default_zoom,
}
else:
template_data = {
'auth_url': users.CreateLogoutURL(self.request.uri),
'auth_text': 'Sign out',
'user_email': user.email(),
'user_nickname': user.nickname(),
}
template_path = os.path.join(os.path.dirname(__file__),
'settings.html')
self.response.headers['Content-Type'] = 'text/html'
self.response.out.write(template.render(template_path, template_data))
def Get(self, user):
template_values = {
'user' : user,
'logout' : users.CreateLogoutURL('/'),
'mainContentClass' : 'lobbyContent'
}
return template.render(LobbyPage.template_path, template_values)
def render_template(self, filename, template_values={}):
template_values['users'] = users
if (users.get_current_user()):
template_values['logout'] = users.CreateLogoutURL(
'/logout', _auth_domain=None)
template = jinja_environment.get_template(filename)
self.response.out.write(template.render(**template_values))
def get(self):
user = users.get_current_user()
# 1. Get the info from the request.
urlsafe_key = self.request.get('key')
# 2. Logic (interact w database)
key = ndb.Key(urlsafe=urlsafe_key)
note = key.get()
comments = Comment.query(
Comment.note_key == note.key).order(-Comment.date).fetch()
# 3. Render response
template_values = {'note': note, 'comments': comments}
template = jinja_environment.get_template('note.html')
if user:
email = user.email()
logout_url = users.CreateLogoutURL('/')
template1 = jinja_environment.get_template('sign-out.html')
template_values1 = {'email': email, 'logout_url': logout_url}
self.response.out.write(
template.render(template_values) +
template1.render(template_values1))
else:
login_url = users.CreateLoginURL('/')
template1 = jinja_environment.get_template('sign-in.html')
template_values1 = {'login_url': login_url}
# self.response.out.write(template.render(template_values) + template1.render(template_values1))
self.redirect(login_url)
def Get(self, user):
completed_games = gamemodel.completed_games_list(user)
wins = losses = draws = 0
for game in completed_games:
if game.is_victory(user):
wins += 1
elif game.is_loss(user):
loss += 1
else:
draws += 1
record_str = (pluralize(wins, "win, ", "wins, ") +
pluralize(losses, "loss, ", "losses, ") +
pluralize(draws, "draw, ", "draws, "))
template_values = {
'user' : user,
'completed_games_list' : completed_games,
'record_string' : record_str,
'logout_url' : users.CreateLogoutURL('/'),
'mainContentClass' : 'historyContent'
}
return template.render(HistoryPage.template_path, template_values)
def get(self):
template_data = {}
user = users.get_current_user()
if user:
user_settings = settings.get(user)
if user_settings == None:
self.redirect('/settings')
return
template_data = {
'auth_url': users.CreateLogoutURL(self.request.uri),
'auth_text': 'Sign out',
'user_email': user.email(),
'user_nickname': user.nickname(),
'default_location': user_settings.default_location,
'initial_latitude': 37.4221,
'initial_longitude': -122.0837,
}
else:
template_data = {
'auth_url': users.CreateLoginURL(self.request.uri),
'auth_text': 'Sign in',
'user_email': '',
'user_nickname': '',
'initial_latitude': 37.4221,
'initial_longitude': -122.0837,
}
template_path = os.path.join(os.path.dirname(__file__), 'geochat.html')
self.response.headers['Content-Type'] = 'text/html'
self.response.out.write(template.render(template_path, template_data))
def Respond(request, user, template_name, params=None):
"""Helper to render a response, passing standard stuff to the response.
Args:
request: The request object.
user: The User object representing the current user; or None if nobody
is logged in.
template_name: The template name; '.html' is appended automatically.
params: A dict giving the template parameters; modified in-place.
Returns:
Whatever render_to_response(template_name, params) returns.
Raises:
Whatever render_to_response(template_name, params) raises.
"""
if user is None:
user = users.GetCurrentUser()
if params is None:
params = {}
if user:
params['user'] = user
params['sign_out'] = users.CreateLogoutURL('/')
params['is_admin'] = (users.IsCurrentUserAdmin()
and 'Dev' in os.getenv('SERVER_SOFTWARE'))
else:
params['sign_in'] = users.CreateLoginURL(request.path)
params['help_contact'] = HELP_CONTACT
if not template_name.endswith('.html'):
template_name += '.html'
return shortcuts.render_to_response(template_name, params)
def Get(self, user):
completed_games = gamemodel.completed_games_list(user)
# Build up a string describing the user's record
wins = losses = draws = 0
for game in completed_games:
if game.is_victory(user):
wins += 1
elif game.is_loss(user):
losses += 1
else:
draws += 1
record_str = (pluralize(
wins, '\xd8\xa7\xd9\x86\xd8\xaa\xd8\xb5\xd8\xa7\xd8\xb1, ',
'\xd8\xa7\xd9\x86\xd8\xaa\xd8\xb5\xd8\xa7\xd8\xb1\xd8\xa7\xd8\xaa, '
) + pluralize(losses, '\xd8\xae\xd8\xb3\xd8\xa7\xd8\xb1\xd8\xa9, ',
'\xd8\xae\xd8\xb3\xd8\xa7\xd8\xb1\xd8\xa9, ') +
pluralize(draws,
'\xd8\xaa\xd8\xb9\xd8\xa7\xd8\xaf\xd9\x84, ',
'\xd8\xaa\xd8\xb9\xd8\xa7\xd8\xaf\xd9\x84, '))
template_values = {
'user': user,
'completed_games_list': completed_games,
'record_string': record_str,
'logout_url': users.CreateLogoutURL('/'),
'mainContentClass': 'historyContent'
}
return template.render(HistoryPage.template_path, template_values)
def Get(self, user):
template_values = {
'user': user,
'logout_url': users.CreateLogoutURL("/"),
'mainContentClass': 'mainContent'
}
return template.render(MainPage.template_path, template_values)
def Respond(request, template_name, params=None):
"""Helper to render a response, passing standard stuff to the response.
Args:
request: The request object.
template_name: The template name; '.html' is appended automatically.
params: A dict giving the template parameters; modified in-place.
Returns:
Whatever render_to_response(template_name, params) returns.
Raises:
Whatever render_to_response(template_name, params) raises.
"""
user, _, _ = GetUser(request)
if params is None:
params = {}
if user:
params['user'] = user
params['sign_out'] = users.CreateLogoutURL('/')
params['show_admin_link'] = (users.IsCurrentUserAdmin()
and 'Dev' in os.getenv('SERVER_SOFTWARE'))
params['show_dashboard_link'] = (users.IsCurrentUserAdmin() and 'Dev'
not in os.getenv('SERVER_SOFTWARE'))
else:
params['sign_in'] = users.CreateLoginURL(request.path)
params['help_contact'] = HELP_CONTACT
params['help_phone'] = HELP_PHONE
params['help_person'] = HELP_PERSON
if not template_name.endswith('.html'):
template_name += '.html'
return shortcuts.render_to_response(template_name, params)
def get(self):
user = users.get_current_user()
if user and self.check_email(user):
self.redirect('/')
else:
url = users.CreateLogoutURL('/logout?message=' + self.message,
_auth_domain=None)
self.redirect(url)
def Get(self, user):
template_values = {
'user': user,
'logout_url': users.CreateLogoutURL('/'),
'game_key': self.request.path.strip('/').split('/')[-1],
'mainContentClass': 'mainContent'
}
return template.render(GamePage.template_path, template_values)
def gaia(request):
try:
gaia_user = users.GetCurrentUser()
gaia_login = users.CreateLoginURL(request.META['PATH_INFO'])
gaia_logout = users.CreateLogoutURL('/logout')
except:
gaia_user = None
gaia_login = "******"
gaia_logout = "gaia_logout"
return locals()
def Get(self):
template_values = {
'user': users.GetCurrentUser(),
'logout_url': users.CreateLogoutURL("/"),
'logout_text': 'Выйти',
'page_title': 'Приложения',
'apps': get_apps()
}
return template.render(MainPage.template_path, template_values)
def post(self):
if users.get_current_user():
post_id = self.request.get("post_id")
post = db.get(post_id)
if post.blob_key:
blobstore.delete_async(post.blob_key.key())
post.blob_key = None
post.put()
else:
url = users.CreateLogoutURL('/logout?message=' + self.message,
_auth_domain=None)
self.redirect(url)
def get(self):
# Get the current user
self.current_user = users.GetCurrentUser()
if not self.current_user:
template_values = {
'login_url': users.CreateLoginURL(self.request.uri),
'app_name': APP_NAME,
'css_link': CSS_LINK,
'app_info': APP_INFO
}
template_file = 'login.html'
else:
self.token = self.request.get('token')
# Manage our Authentication for the user
self.ManageAuth()
self.LookupToken()
if self.client.GetAuthSubToken() is not None:
self.response.out.write('<div id="main">')
self.feed_url = 'http://www.google.com/calendar/feeds/default/private/full'
contacts = self.GetContacts()
template_values = {
'current_user': self.current_user,
'logout_url': users.CreateLogoutURL(self.request.uri),
'contacts': contacts,
'app_name': APP_NAME,
'css_link': CSS_LINK,
'todays_date': self.todays_date,
'sample_event_title': SAMPLE_EVENT_TITLE,
'sample_event_description': SAMPLE_EVENT_DESCRIPTION
}
template_file = 'CreateEventForm.html'
else:
template_values = {
'authsub_url':
self.client.GenerateAuthSubURL(
'http://%s/' % (HOST_NAME),
'%s %s' % ('http://www.google.com/m8/feeds/',
'http://www.google.com/calendar/feeds'),
secure=False,
session=True),
'app_name':
APP_NAME,
'css_link':
CSS_LINK
}
template_file = 'authorize_access.html'
path = os.path.join(os.path.dirname(__file__), 'main_templates',
template_file)
self.response.out.write(template.render(path, template_values))
def generate(self, template_name, template_values={}):
values = {
'request': self.request,
'user': users.GetCurrentUser(),
'login_url': users.CreateLoginURL(self.request.uri),
'logout_url': users.CreateLogoutURL('http://' + self.request.host + '/'),
'debug': self.request.get('deb'),
'application_name': 'Veji Multimedia Library',
}
values.update(template_values)
directory = os.path.dirname(__file__)
path = os.path.join(directory, os.path.join('templates', template_name))
self.response.out.write(template.render(path, values, debug=_DEBUG))
def respondWithTemplate(self, template_name, template_values={}):
values = {
'request': self.request,
'debug': self.request.get('debug'),
'application_name': 'Open Radar',
'user': users.GetCurrentUser(),
'login_url': users.CreateLoginURL(self.request.uri),
'logout_url': users.CreateLogoutURL('http://' + self.request.host + '/'),
}
values.update(template_values)
directory = os.path.dirname(__file__)
path = os.path.join(directory, os.path.join('../templates', template_name))
self.response.out.write(template.render(path, values))
def generate(self, template_name, template_values={}):
values = {
'request': self.request,
'user': users.GetCurrentUser(),
'login_url': users.CreateLoginURL(self.request.uri),
'logout_url': users.CreateLogoutURL(self.request.uri),
'debug': self.request.get('deb'),
'application_name': 'OpenScrum',
}
values.update(template_values)
directory = os.path.dirname(__file__)
path = os.path.join(directory, os.path.join('templates', template_name))
self.response.out.write(template.render(path, values, debug=True))
def root():
user = users.get_current_user()
return_path = request.args['return']
rv = dict()
if user:
rv['logoutUrl'] = users.CreateLogoutURL(return_path)
rv['loggedIn'] = True
rv['user'] = user
rv['admin'] = users.is_current_user_admin()
else:
rv['loginUrl'] = users.create_login_url(return_path)
rv['loggedIn'] = False
return jrg.util.to_json(rv)
def get(self):
user = users.get_current_user()
template = jinja_environment.get_template('mybooks.html')
if user:
email = user.email()
logout_url = users.CreateLogoutURL('/')
template1 = jinja_environment.get_template('sign-out.html')
template_values1 = {'email': email, 'logout_url': logout_url}
self.response.out.write(template.render() +
template1.render(template_values1))
else:
login_url = users.CreateLoginURL('/')
template1 = jinja_environment.get_template('sign-in.html')
template_values = {'login_url': login_url}
# self.response.out.write(template.render() + template1.render(template_values))
self.redirect(login_url)
def get(self):
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
user = users.get_current_user()
if not user:
self.response.write("you're not signed in")
else:
self.response.write("<p>hello, %s!" % user.nickname() + "</p>")
self.response.write("<p>email is %s!" % user.email() + "</p>")
self.response.write("<p>google user id is %s!" % user.user_id() +
"</p>")
self.response.write("<p>misterplanner user id is %s!" %
userIdFromGoogleId(user.user_id()) + "</p>")
self.response.write("<a href=\"" +
users.CreateLogoutURL("./googleuser") +
"\">Logout</a>")
def testCreateLogoutURL(self):
os.environ['HTTP_HOST'] = 'giggit.prom.corp.google.com'
os.environ['SERVER_NAME'] = 'badserver.prom.corp.google.com'
os.environ['SERVER_PORT'] = '666'
self._TestSimpleLogout('http://giggit.prom.corp.google.com',
'http://giggit.prom.corp.google.com')
self._TestSimpleLogout('http://giggit.prom.corp.google.com/',
'http://giggit.prom.corp.google.com/')
self._TestSimpleLogout('http://giggit.prom.corp.google.com/profile',
'http://giggit.prom.corp.google.com/profile')
self._TestSimpleLogout('http://othergiggit.com/profile',
'http://othergiggit.com/profile')
self._TestSimpleLogout('http://giggit.prom.corp.google.com/?a=b&c=d',
'http://giggit.prom.corp.google.com/?a=b&c=d')
self._TestSimpleLogout('', 'http://giggit.prom.corp.google.com/')
self._TestSimpleLogout('/', 'http://giggit.prom.corp.google.com/')
self._TestSimpleLogout('/profile',
'http://giggit.prom.corp.google.com/profile')
self._TestSimpleLogout(
'../profile', 'http://giggit.prom.corp.google.com/../profile')
self._TestSimpleLogout('/?a=b&c=d',
'http://giggit.prom.corp.google.com/?a=b&c=d')
self._TestSimpleLogout('http://giggit.prom.corp.google.com',
'http://giggit.prom.corp.google.com',
auth_domain='bar.com')
del os.environ['HTTP_HOST']
os.environ['SERVER_NAME'] = 'giggit.prom.corp.google.com'
os.environ['SERVER_PORT'] = '80'
self._TestSimpleLogout('', 'http://giggit.prom.corp.google.com/')
os.environ['SERVER_PORT'] = '9999'
self._TestSimpleLogout('', 'http://giggit.prom.corp.google.com:9999/')
os.environ['SERVER_PORT'] = '80'
logout_url = users.CreateLogoutURL('')
self.assertEqual((
user_service_stub._DEFAULT_LOGOUT_URL %
six.moves.urllib.parse.quote('http://giggit.prom.corp.google.com/')
), logout_url)
def generate(self, template_name, template_values={}):
values = {
'request':
self.request,
'user':
users.GetCurrentUser(),
'login_url':
users.CreateLoginURL(self.request.uri),
'logout_url':
users.CreateLogoutURL('http://' + self.request.host + '/'),
'application_name':
'MoneyLog Cloud',
'debug':
self.request.get('debug', False),
}
values.update(template_values)
template = env.get_template(template_name)
self.response.out.write(template.render(values, debug=_DEBUG))
def get(self):
"""GET handler that serves environment data."""
environment_variables_output = [
html_for_env_var(key) for key in sorted(os.environ)
]
cgi_arguments_output = []
if os.getenv('CONTENT_TYPE') == 'application/x-www-form-urlencoded':
# Note: a blank Content-type header will still sometimes
# (in dev_appserver) show up as 'application/x-www-form-urlencoded'
form = cgi.FieldStorage()
if not form:
cgi_arguments_output.append('No CGI arguments given...')
else:
for cgi_argument in form:
cgi_arguments_output.append(
html_for_cgi_argument(cgi_argument, form))
else:
data = sys.stdin.read()
cgi_arguments_output.append(STDIN_TEMPLATE.format(len(data)))
cgi_arguments_output.append(cgi.escape(data))
modules_api_output = [
html_for_modules_method('get_current_module_name'),
html_for_modules_method('get_current_version_name'),
html_for_modules_method('get_current_instance_id'),
html_for_modules_method('get_modules'),
html_for_modules_method('get_versions'),
html_for_modules_method('get_default_version'),
#html_for_modules_method('get_num_instances'),
html_for_modules_method('get_hostname'),
]
result = PAGE_TEMPLATE.format(
users.CreateLoginURL(self.request.url),
users.CreateLogoutURL(self.request.url),
'<br>\n'.join(environment_variables_output),
'<br>\n'.join(cgi_arguments_output),
'<br>\n'.join(modules_api_output),
)
self.response.write(result)
def getTemplateValues(self, title):
if users.GetCurrentUser():
login_url = users.CreateLogoutURL(self.request.uri)
login_linktext = 'Logout'
login_name = users.GetCurrentUser().email()
else:
login_url = users.CreateLoginURL(self.request.uri)
login_linktext = 'Login'
login_name = 'Not logged in'
template_values = {
'login': {
'url': login_url,
'linktext': login_linktext,
'name': login_name,
'admin': users.is_current_user_admin()
},
'title': title
}
return template_values
def respond(request, template, params=None):
"""Helper to render a response.
This function assumes that the user is logged in.
Args:
request: The request object
template: The template name; '.html' is appended automatically.
params: A dict giving the template parameters; modified in-place.
Returns:
Whatever render_to_response(template, params) returns.
Raises:
Whatever render_to_response(template, params) raises.
"""
if params is None:
params = {}
if request.user:
params['user'] = request.user
params['sign_out'] = users.CreateLogoutURL('/')
params['is_admin'] = users.is_current_user_admin()
else:
params['sign_in'] = users.CreateLoginURL(request.path)
if hasattr(request, 'profile') and request.profile is not None:
profile = request.profile
params['sidebar'] = models.Sidebar.render(profile)
params['is_superuser'] = profile.is_superuser
else:
params['is_superuser'] = False
params['sidebar'] = models.Sidebar.render(None)
params['configuration'] = configuration
if not template.endswith('.html'):
template += '.html'
return shortcuts.render_to_response(template, params)
def get(self):
template_data = {}
user = users.get_current_user()
if user:
template_data = {
'auth_url': users.CreateLogoutURL(self.request.uri),
'auth_text': 'Sign out',
'user_email': user.email(),
}
else:
template_data = {
'auth_url': users.CreateLoginURL(self.request.uri),
'auth_text': 'Sign in',
'user_email': '',
}
template_path = os.path.join(os.path.dirname(__file__), 'help.html')
self.response.headers['Content-Type'] = 'text/html'
self.response.out.write(template.render(template_path, template_data))
def get(self):
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
newPlanLink = '/createplanform'
userid = self.request.get("userid")
if userid is None or userid == "undefined":
userid = mpusers.userIdFromGoogleId(users.get_current_user().user_id())
# return self.redirect('/currentplans?userid=' + userid)
# Weird bug where after creating account (including one that was a shadow account),
# the userid is undefined. The next line of code is a TEMPORARY FIX.
# userid = mpusers.userIdFromGoogleId(users.get_current_user().user_id())
getPlansLink = '/getplansanduserresponses?userid=' # + userid
getPlanLink = '/viewoneplan?userid='
getPlanLink2 = '&planid='
respondToInviteLink = '/invitewasupdated?userid='
respondToInviteLink2 = '&planid='
respondToInviteLink3 = '&response='
template_values = {
'newPlanURL': newPlanLink,
'getPlansURL': getPlansLink,
'userId': userid,
'getOnePlanURL': getPlanLink,
'getOnePlanURL2': getPlanLink2,
'respondToInviteURL': respondToInviteLink,
'respondToInviteURL2': respondToInviteLink2,
'respondToInviteURL3': respondToInviteLink3
}
template = JINJA_ENVIRONMENT.get_template('currentplans.html')
self.response.write(template.render(template_values))
self.response.write('<a href="/creategroupform">Create A Friend Group</a><br>')
self.response.write("<a href=\"" + users.CreateLogoutURL("./googleuser") + "\">Logout</a>")
def get(self):
user = users.get_current_user()
id = self.request.get('id')
template = jinja_environment.get_template('book.html')
if user:
notes = Note.query(
ndb.AND(Note.book_id == id,
Note.user_key == user.user_id())).fetch()
template_values = {'id': id, 'notes': notes, 'user': user}
email = user.email()
logout_url = users.CreateLogoutURL('/book?id=' + id)
template1 = jinja_environment.get_template('sign-out.html')
template_values1 = {'email': email, 'logout_url': logout_url}
self.response.out.write(
template.render(template_values) +
template1.render(template_values1))
else:
login_url = users.CreateLoginURL('/book?id=' + id)
template1 = jinja_environment.get_template('sign-in.html')
template_values = {'login_url': login_url}
self.response.out.write(
template.render({'id': id}) +
template1.render(template_values))
