def get(self): id = get_user_id() jAson = models.getAllUserScores() userList = json.dumps(jAson) is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return newList = models.getCategoryList() page_params = { 'category': 'ALL', 'catList': newList, 'user_id': get_user_id(), 'list': jAson, 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'admin': is_admin, } render_template(self, 'leaderboard.html', page_params)
def get(self): id = get_user_id() trueList = models.getCategoryList(True) falseList = models.getCategoryList(False) is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return page_params = { 'user_id': get_user_id(), 'trueCatList': trueList, 'falseCatList': falseList, 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'admin': is_admin, } render_template(self, 'reviewCategories.html', page_params)
def get(self): questionID = self.request.get('id') id = get_user_id() review = models.getQuestionFromURL(questionID) is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return page_params = { 'upload_urlQE': blobstore.create_upload_url('/ReviewQuestion?id=' + questionID), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': id, 'review': review, 'admin' : is_admin } render_template(self, 'questionReview.html', page_params)
def get(self): id = get_user_id() #just loops and prints every question from query review = models.get_oldest_questions(True,False) is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return page_params = { 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': id, 'review': review, 'admin' : is_admin } render_template(self, 'viewDatabase.html', page_params)
def get(self): #user_email = get_email() user = users.get_current_user() if user: # fetch the user from the database user_key = ndb.Key("Account", user.user_id()) user_account = user_key.get() #If the user isn't found in the database, add to the database if not user_account: logging.info("USER NOT FOUND, ADDING NOW") user_account = Account(id=user.user_id(), name = user.nickname(), hobby_text = '') user_key = user_account.put() else: logging.info("USER FOUND") logging.info(user_account) # Redirect to the user's view profile page self.redirect('/viewprofile?id=' + user.user_id()) template_params = { "user":user.email(), "login":users.create_login_url(), "logout":users.create_logout_url('/'), "name":user_account.name, "hobby":user_account.hobby_text, "modified":user_account.modified } else: logging.info("NOT LOGGED IN") template_params = { "user":None, "login":users.create_login_url('/'), "logout":users.create_logout_url('/') } render_template(self, 'index.html', template_params)
def get(self): user = users.get_current_user() if user: # signed in already curr = ndb.Key('Stall', users.get_current_user().nickname()) person = curr.get() if person == None: template_values = { 'user_nickname': users.get_current_user().nickname(), 'logout': users.create_logout_url(self.request.host_url), } template = jinja_environment.get_template('stall1_page.html') self.response.out.write(template.render(template_values)) else: template_values = { 'user_nickname': users.get_current_user().nickname(), 'logout': users.create_logout_url(self.request.host_url), 'stall_name': person.name, 'stall_menu': person.menu, 'stall_time': person.time, 'food_description': person.description, 'food_price': person.price, 'waiting_time': person.waiting_time, } template = jinja_environment.get_template('stall1_page.html') self.response.out.write(template.render(template_values)) else: self.redirect(self.request.host_url)
def get(self): user = users.get_current_user() if user: # signed in already # Retrieve person curr = ndb.Key('Preference', users.get_current_user().nickname()) person = curr.get() if person == None: template_values = { 'user_nickname': users.get_current_user().nickname(), 'logout': users.create_logout_url(self.request.host_url), 'max_limit': max_days, } template = jinja_environment.get_template('reminder.html') self.response.out.write(template.render(template_values)) else: template_values = { 'user_nickname': users.get_current_user().nickname(), 'logout': users.create_logout_url(self.request.host_url), 'curr_psi_limit': person.psi_limit, 'curr_day_limit': person.day_limit, 'max_limit': max_days, } template = jinja_environment.get_template('reminder.html') self.response.out.write(template.render(template_values)) else: self.redirect(self.request.host_url)
def get(self): if users.get_current_user(): #url = users.create_logout_url(self.request.uri) emailAddress = users.get_current_user().email() admins_Query = Admin.query(ancestor=PARENT_KEY).fetch() alreadyAdmin = False for admin in admins_Query: if admin.email.encode('ascii','ignore') == emailAddress: alreadyAdmin = True if (alreadyAdmin): # if an approved user is logged in: games_query = Game.query(ancestor=PARENT_KEY).fetch() users_query = User.query(ancestor=PARENT_KEY).fetch() logoutURL = users.create_logout_url(self.request.uri) template = jinja_env.get_template("templates/superSecretAdminPage.html") self.response.out.write(template.render({"logoutURL":logoutURL, "emailAddress":emailAddress, "games":games_query, "users":users_query, "admins":admins_Query})) else: # they are not an approved admin logoutURL = users.create_logout_url(self.request.uri) template = jinja_env.get_template("templates/adminSignInPage.html") self.response.out.write(template.render({"loginURL":logoutURL, "buttonText":"Logout"})) else: # there isn't anyone logged in loginURL = users.create_login_url(self.request.uri) template = jinja_env.get_template("templates/adminSignInPage.html") self.response.out.write(template.render({"loginURL":loginURL,"buttonText":"Login"}))
def get_logout_url(self, from_referer=False): if from_referer: dst = self.referer if not dst : dst = '/m' return users.create_logout_url(dst) else: return users.create_logout_url(self.request.uri)
def profile_index(): currentUser = users.get_current_user() userProfile = UserRepository.get(currentUser) if userProfile == None: userProfile = UserRepository.new(currentUser) logging.info('userprofile %s' % userProfile) if(userProfile.services): isLatitudeInstalled = ServiceRepository.get('latitude', userProfile) != None isFoursquareInstalled = ServiceRepository.get('foursquare', userProfile) != None if(isLatitudeInstalled == False and isFoursquareInstalled == False): return render_template('setup_step1.html', user=currentUser, logout_url=users.create_logout_url("/")); if(isLatitudeInstalled == False and isFoursquareInstalled == True): return render_template('setup_step1.html', user=currentUser, logout_url=users.create_logout_url("/")); if(isLatitudeInstalled == True and isFoursquareInstalled == False): return render_template('setup_step2.html', user=currentUser, logout_url=users.create_logout_url("/")); if(userProfile.isPaused == True): return render_template('setup_off.html', user=currentUser, logout_url=users.create_logout_url("/")); return render_template('setup_on.html', user=currentUser, logout_url=users.create_logout_url("/"));
def import_shows(request): this_url = reverse("seriesly-shows-import_show") user = users.get_current_user() status = request.GET.get("status", None) if status is not None: status = "Shows are now being imported." nick = False if user: nick = user.nickname() if user and user.email() in settings.ADMIN_USERS: if request.method == "GET": return render_to_response("import_show.html", RequestContext(request, {"logged_in": True, "nick": nick, "status": status, "logout_url": users.create_logout_url(this_url)})) else: shows = request.POST["show"] try: shows = [int(s.strip()) for s in shows.split(",")] except ValueError: return HttpResponse("Error: there was an invalid ID", status=400) for show in shows: t = taskqueue.Task(url=reverse('seriesly-shows-import'), params={"show": str(show)}) t.add(queue_name='series') return HttpResponseRedirect(this_url+"?status=Done") else: return render_to_response("import_show.html", RequestContext(request, {"logged_in": False, "nick": nick, "login_url": users.create_login_url(this_url), "logout_url": users.create_logout_url(this_url)}))
def get(self): id = get_user_id() is_admin = 0 if users.is_current_user_admin(): is_admin = 1 if id is not None: q = models.check_if_user_exists(id) if q == None: page_params = { 'upload_url': blobstore.create_upload_url('/profile'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': get_user_id(), 'profile': models.getUser(id), 'admin': is_admin } render_template(self, 'createProfile.html' ,page_params) return newList = models.getCategoryList() page_params = { 'catList': newList, 'upload_urlQ': blobstore.create_upload_url('/NewQuestion'), 'user_email': get_user_email(), 'login_url': users.create_login_url(), 'logout_url': users.create_logout_url('/'), 'user_id': id, 'admin' : is_admin } render_template(self, 'newQuestionSubmit.html', page_params)
def get(self): """Index page. """ user = users.get_current_user() header = "" if users.is_current_user_admin(): header = ( "You have logged in as admin. Go to <a href='/admin'>" "admin page</a><br/><a href=%s>logout</a>" % users.create_logout_url(self.request.uri) ) else: header = ( "You have logged in as %s. <a href=%s>logout</a>" % ( user.nickname(), users.create_logout_url(self.request.uri), ) ) landing_page = """ <html><body> <h2>%s</h2> <a href="/static/index.html">AJAX Test GUI</a><br> <a href="/api/file">all files</a> <body/><html/> """ % header self.response.out.write(landing_page)
def admin(): def force_account_chooser(url): if 'ServiceLogin' in url: return url.replace('ServiceLogin', 'AccountChooser') return url user = users.get_current_user() params = {} if user is None: params['users_link'] = force_account_chooser( users.create_login_url('/#/loginLanding')) params['users_title'] = "Sign In" else: logging.info("Staff Login Attempt from %s", user.email()) userobj = models.User.get_by_id(user.email()) if userobj.is_admin: logging.info("Staff Login Success from %s", user.email()) params["user"] = {'email': user.email()} params["admin"] = {'email': user.email()} params['users_link'] = users.create_logout_url('/') params['users_title'] = "Log Out" params['relogin_link'] = users.create_logout_url( force_account_chooser( users.create_login_url('/#/loginLanding'))) return render_template("admin.html", **params) else: logging.info("Staff Login Failure from %s", user.email()) return redirect(url_for('dashboard'))
def get(self): useremail = users.get_current_user().email() if ('@chilmarkhill.com' in useremail or useremail == '*****@*****.**' or useremail == '*****@*****.**' or useremail == '*****@*****.**' or useremail == '*****@*****.**'): self.response.out.write(''' <html> <head> <title>Home</title> <style type="text/css"> body {font-family:arial} </style> </head> <body> <p style="text-align:right;"><a href="'''+users.create_logout_url("/")+'''">Sign Out</a></p> <h1 style="text-align:center;">Utilities</h1> <p style="text-align:center;"> <a href="/calculator">MBS Calculator</a><br /><br /> <a href="/grapher">Cash Flow Grapher</a><br /><br /> <a href="/price">CUSIP Price Finder</a><br /><br /> </p> </body> </html>''') else: self.response.out.write('''<html><head><title>Invalid Login</title> <script language="javascript"> alert('User Access Denied'); location.replace("'''+users.create_logout_url("/")+'''"); </script></head></html>''')
def get(self, page): logging.info(self.request.referer) user = users.get_current_user() template_page = page if page is None or page == "": if user and validUser(user.email()): template_page = 'dashboard' else: template_page = 'academy' page_template = get_template('templates/%s.html' % template_page) user_profile = None isInvalidUser = False if user and invalidUser(user.email()) and user.email().split('@')[1] == 'thegovlab.org': logging.error(user.email()) self.response.out.write(""" <html><body><h1>Hey class sudent,</h1> <p>We have made some changes to the website.</p> <p>You don't need a @thegovlab.org account anymore. You can use your regular email.</p> <p>You should <a href="%s">logout</a> and then visit the <a href="http://academy.thegovlab.org">site</a> again with your non @thegovlab.org identity.</p> <p>If it still does not work or you are confused, contact us.</p> </body> </html> """ % users.create_logout_url('/')) return if user: user_profile = getUserProfile(user.email()) if user_profile and user_profile.isDormant: user_profile.isDormant = False user_profile.put() isInvalidUser = invalidUser(user.email()) self.response.out.write(page_template.render({ 'logout_url': users.create_logout_url('/'), 'login_url': users.create_login_url('/'), 'me': user_profile, 'invalidUser': isInvalidUser }))
def get(self): user = users.get_current_user() currUser = db.get(db.Key.from_path('User', user.email())) if not currUser.required_complete: self.redirect('/profile/edit') if self.request.get('search_cat').rstrip() == "": template_values = { 'searchform': models.SearchForm(), 'search': False, 'email': user.email(), 'logout': users.create_logout_url(self.request.host_url), } template = jinja_environment.get_template('main.html') self.response.out.write(template.render(template_values)) else: search_form = models.SearchForm(self.request.GET) if self.request.method == 'GET' and search_form.validate(): search_cat = self.request.get('search_cat').rstrip() search_field = self.request.get('search_field').rstrip() tempResult = [] results = [] if search_cat == 'module_code': moduleList = models.Module.all() for module in moduleList: if search_field.upper() in module.module_code: tempResult.append(module) for records in tempResult: allRecords = models.Post.all().filter('module', records).filter('status !=', 'Pre-Completed').filter('status !=', 'Completed') for entry in allRecords: results.append(entry) else: bookList = models.Book.all() for book in bookList: if search_field.lower() in getattr(book, search_cat): tempResult.append(book) for records in tempResult: allRecords = models.Post.all().filter('book', records).filter('status !=', 'Pre-Completed').filter('status !=', 'Completed') for entry in allRecords: results.append(entry) template_values = { 'searchform': search_form, 'searchResult': results, 'search': True, 'email': user.email(), 'logout': users.create_logout_url(self.request.host_url), } template = jinja_environment.get_template('main.html') self.response.out.write(template.render(template_values)) else: template_values = { 'searchform': search_form, 'search': False, 'email': user.email(), 'logout': users.create_logout_url(self.request.host_url), } template = jinja_environment.get_template('main.html') self.response.out.write(template.render(template_values))
def get(self): user = users.get_current_user() currUser = db.get(db.Key.from_path('User', user.email())) url = self.request.url if not currUser.required_complete: self.redirect('/profile/edit') if "edit" in url: currPost = models.Post.get_by_id(int(url.split('/')[-1])) bookid = int(url.split('/')[-1]) stains = True if 'Stains' in currPost.condition else False highlights = True if 'Highlights' in currPost.condition else False writings = True if 'Writings' in currPost.condition else False dog_eared = True if 'Dog Eared' in currPost.condition else False torn = True if 'Torn' in currPost.condition else False wrapped = True if 'Wrapped' in currPost.condition else False not_used_once = True if 'Not Used Once' in currPost.condition else False sellform = models.SellForm(module_code=currPost.module.module_code.upper(), title=currPost.book.title, author=currPost.book.author, publisher=currPost.book.publisher, edition=currPost.book.edition, cost=currPost.cost, condition_highlights=highlights, condition_stains=stains, condition_writings=writings, condition_dog_eared=dog_eared, condition_torn=torn, condition_wrapped=wrapped, condition_not_used_once=not_used_once, comment=currPost.comment, book_pic=currPost.book_pic) template_values = { 'email': user.email(), 'sell_form': sellform, 'currPost': currPost, 'bookid': bookid, 'logout': users.create_logout_url(self.request.host_url), } else: sellform = models.SellForm() template_values = { 'email': user.email(), 'sell_form': sellform, 'logout': users.create_logout_url(self.request.host_url), } template = jinja_environment.get_template('sell.html') self.response.out.write(template.render(template_values))
def post(self): tag = str(self.request.get('tag')) author = str(urllib.url2pathname(self.request.get('author'))) user = users.get_current_user() if author: post_query = BlogPost.query(BlogPost.author == author, BlogPost.tag.IN([tag])).order(-BlogPost.creation, BlogPost.key) else: post_query = BlogPost.query(BlogPost.tag.IN([tag])).order(-BlogPost.creation, BlogPost.key) curs = Cursor(urlsafe=self.request.get('cursor')) posts, next_curs, more = post_query.fetch_page(10, start_cursor=curs) if author and user: url = users.create_logout_url('/') url_linktext = 'Logout' parent = user_key(author).get() tagList = parent.tagList blogList = parent.blogList if user.nickname() == author: edit = 'true' else: edit = '' template_values = { 'tagList': tagList, 'blogList': blogList, 'author': author, 'user': user.nickname(), 'postList': posts, 'url': url, 'url_linktext': url_linktext, 'edit':edit, } template = JINJA_ENVIRONMENT.get_template('templates/user_page.html') self.response.write(template.render(template_values)) if more and next_curs: self.response.out.write('<a href="/?cursor=%s">More...</a>' % next_curs.urlsafe()) self.response.out.write('</body></html>') else: if user: url = users.create_logout_url('/') url_linktext = 'Logout' else: url = users.create_login_url('/') url_linktext = 'Login' template_values = { 'query_tag': tag, 'postList': posts, 'url': url, 'url_linktext' : url_linktext, } template = JINJA_ENVIRONMENT.get_template('templates/tag_posts.html') self.response.write(template.render(template_values)) if more and next_curs: self.response.out.write('<a href="/?cursor=%s">More...</a>' % next_curs.urlsafe()) self.response.out.write('</body></html>')
def getOwnerDetails(handler, owner): mocklists = [] if owner: q = MockList.gql("WHERE owner = :1", owner).fetch(1000) for mocklist in q: mocklists.append({ 'id' : mocklist.get_id(), 'name' : mocklist.name }) return { 'mocklists' : mocklists, 'name' : str(owner.email), 'sign_in_url' : users.create_login_url("/signin/?d=" + handler.request.path), 'sign_out_url' : users.create_logout_url("/"), 'signed_in' : bool(users.get_current_user()), } else: return { 'mocklists' : [], 'name' : '', 'sign_in_url' : users.create_login_url("/signin/?d=" + handler.request.path), 'sign_out_url' : users.create_logout_url("/"), 'signed_in' : False, }
def get(self): user = users.get_current_user() if user: query = Users.query(user.nickname() == Users.email) userobjects = query.fetch() if len(userobjects) > 0: knownusername = userobjects[0].username form = False greeting = ('Welcome, <span id="username">%s</span>! (<a href="%s">Sign out</a>)' % (knownusername, users.create_logout_url('/'))) else: form = True greeting = ('Welcome, <span id="username">%s</span>! (<a href="%s">Sign out</a>)' % (user.nickname(), users.create_logout_url('/'))) else: form = False greeting = ('<a href="%s">Sign in</a>' % users.create_login_url('/')) loginlink = ( '<html><body>{}</body></html>'.format(greeting)) my_vars = { "loginlink": loginlink, "shoulddisplayform": form} template = jinja_environment.get_template('templates/index.html') self.response.write(template.render(my_vars))
def get(self): query = db.Query(Ride) query.filter("ToD > ", datetime.datetime.now()) ride_list = query.fetch(limit=100) aquery = db.Query(College) mycollege= aquery.get() user = self.current_user logging.debug(user) logging.debug(users.create_logout_url("/")) greeting = '' logout = '' if user: greeting = ("Welcome, %s! (<a href=\"%s\">sign out</a>) Go to your <a href='/home'>Home Page</a>" % (user.nickname(), users.create_logout_url("/"))) logout = users.create_logout_url("/") logging.debug(logout) else: self.redirect('/auth/login') return logging.debug(mycollege.address) path = os.path.join(os.path.dirname(__file__), 'templates/index.html') self.response.out.write(template.render(path, { 'ride_list': ride_list, 'greeting' : greeting, 'college': mycollege, 'address': mycollege.address, 'nick' : user.nickname(), 'user': user.id, 'logout':'/auth/logout', 'mapkey':MAP_APIKEY, }))
def get(self): user = users.get_current_user() #dURL = "/" if user: # signed in already self.response.out.write('Hello <em>%s</em>! [<a href="%s">sign out</a>]' % ( user.nickname(), users.create_logout_url(self.request.uri) )) else: # let user choose authenticator self.response.out.write('<a class="rpxnow" onclick="return false;" href="https://emplementation.rpxnow.com/openid/v2/signin?token_url=http%3A%2F%2Flocalhost:8082%2Frpx_response"> Sign In </a>') # self.response.out.write('Hello world! Sign in at: ') # pName = "Facebook" # pURL = "https://e75d3daf6e7141c1bd0be6a0d33c4d85.anyopenid.com/op" # self.response.out.write('[<a href="%s">%s</a>]' % # (users.create_login_url(dest_url=dURL, federated_identity=pURL), pName)) #=========================================================================== # # else: # self.response.out.write('Hello world! Sign in at: ') # for p in openIdProviders: # p_name = p.split('.')[0] # take "AOL" from "AOL.com" # p_url = p.lower() # "AOL.com" -> "aol.com" # self.response.out.write('[<a href="%s">%s</a>]' % (users.create_login_url(dest_url=dURL, federated_identity=p_url), p_name)) # #=========================================================================== greetings = Greeting.all().order('-date').fetch(20) value = {'user': user, 'greetings': greetings, 'logout': users.create_logout_url(self.request.uri)} self.response.out.write(template.render('main.html', value)) return
def getTemplateValues(self, cgiArgs): user = users.get_current_user() greeting = '' logoutUrl = '' loginUrl = '' email = '' isOnGoogleCode = self.request.path.find('apis/ajax/playground') if cgiArgs != '': cgiArgs = '?' + cgiArgs if user: greeting = '%s' % (user.nickname()) email = user.email() if isOnGoogleCode != -1: logoutUrl = users.create_logout_url('/apis/ajax/playground/' + cgiArgs) else: logoutUrl = users.create_logout_url('/' + cgiArgs) else: if isOnGoogleCode != -1: loginUrl = users.create_login_url('/apis/ajax/playground/' + cgiArgs) else: loginUrl = users.create_login_url('/' + cgiArgs) template_values = { 'loginUrl': loginUrl, 'greeting': greeting, 'logoutUrl': logoutUrl, 'userEmail': email } return template_values
def get(self): user = users.GetCurrentUser() login = users.CreateLoginURL(self.request.uri) logout = users.CreateLogoutURL(self.request.uri) if user: result = db.GqlQuery("SELECT * FROM SiteUser WHERE login_user = :1", user).get() if result: greeting = " Welcome, %s" % result.site_nickname else: greeting = "(<a href='%s'>Click here to get started as a site user</a>)" % "/newsiteuser" nick = user.nickname() logout_url = users.create_logout_url(self.request.uri) else: self.redirect(users.create_login_url(self.request.uri)) result = db.GqlQuery("SELECT * FROM SiteUser WHERE login_user = :1", user).get() self.response.out.write('%s' % repr(result)) user = users.GetCurrentUser() nick = "" try: greeting = " Welcome, %s" % result.site_nickname except: greeting = "" logout_url = users.create_logout_url(self.request.uri) template_file_name = 'templates/main.html' template_values = {'main': "hi", 'greeting': greeting, 'nick': nick, 'logout_url': logout_url} path = os.path.join(os.path.dirname(__file__), template_file_name) self.response.out.write(template.render(path, template_values))
def get(self): user = users.get_current_user() if user is None: login_url = users.create_login_url(self.request.path) self.redirect(login_url) return else: if user.email() in ADMIN_USER_IDS: userslist={}; q1= TestDetails.query(); q1.fetch(); count=0; for data in q1: lcenter=data.learningcenter; if not userslist.has_key(lcenter): count=1; userslist[lcenter]=count; else: count=int(userslist[lcenter]); userslist[lcenter]=count+1; template_values = {'tests':userslist} template = JINJA_ENVIRONMENT.get_template('admin.html') self.response.write(template.render(template_values)) else: users.create_logout_url('/') login_url = users.create_login_url(self.request.path) #self.redirect(login_url) self.response.write("<center><h3><font color='red'>Invalid Admin Credentials</font></h3><h3>Please <a href='%s'>Login</a> Again</h3></center>"% login_url);
def get(self): self.response.headers['Content-Type'] = 'text/html' user = users.get_current_user() admin = False if user: ausers = db.GqlQuery("SELECT * FROM AUser WHERE ANCESTOR IS :1 ORDER BY email", auser_db_key()) for auser in ausers: if user.email() == auser.email: template_values = { 'url': users.create_logout_url(self.request.uri), 'url_link_text': 'Logout', 'author': user.nickname(), 'title': 'Adding a pun.' } template = jinja_environment.get_template('templates/add_pun.html') admin = True pass if not admin: template_values = { 'url': users.create_logout_url(self.request.uri), 'url_link_text': 'Logout', 'author': user.nickname(), 'alert_type': 'alert-danger', 'alert_heading': 'Unauthorized Access!', 'alert_description': 'Not so fast! You are not authorized to add puns!', 'title': 'Unauthorized Access!' } template = jinja_environment.get_template('templates/alert_full.html') self.response.out.write(template.render(template_values)) else: self.redirect(users.create_login_url(self.request.uri))
def get(self): user = users.get_current_user() if user: # signed in already # Retrieve person person_key = db.Key.from_path('Persons', users.get_current_user().email()) person = db.get(person_key) if person == None: #the user has not complete the profile template_values = { 'user_mail': users.get_current_user().email(), 'logout': users.create_logout_url(self.request.host_url), 'complete': False, 'person': person, 'CCAs1': "", 'CCAs2': "", } template = jinja_environment.get_template('profile.html') self.response.out.write(template.render(template_values)) else: #if the user have completed the profile query1 = db.GqlQuery("SELECT * FROM miniCCA WHERE ANCESTOR IS :1 AND status='joined'", person_key) query2 = db.GqlQuery("SELECT * FROM miniCCA WHERE ANCESTOR IS :1 AND status='interested'", person_key) template_values = { 'user_mail': users.get_current_user().email(), 'logout': users.create_logout_url(self.request.host_url), 'complete': True, 'person': person, 'CCAs1': query1, 'CCAs2': query2, } template = jinja_environment.get_template('profile.html') self.response.out.write(template.render(template_values)) else: self.redirect(self.request.host_url)
def get(self): user = users.get_current_user() if user: query = Person.gql("WHERE email = :1", users.get_current_user().email()) result = query.fetch(1) template = jinja_environment.get_template('index.html') if result: # record exists student = result[0] person = student.name + "'s" url = users.create_logout_url(self.request.uri) url_linktext = "Logout" else: # not found person = False url = users.create_logout_url(self.request.uri) url_linktext = "Unauthorised" template = jinja_environment.get_template('404.html') else: # not logged in person = "" url = users.create_login_url(self.request.uri) url_linktext = "Login" template = jinja_environment.get_template('404.html') template_values = { 'person': person, 'url': url, 'url_linktext': url_linktext, } self.response.write(template.render(template_values))
def post(self): idea_key = ndb.Key('Authors', self.request.get('submitter'), 'Idea', self.request.get('index')) ideareal = idea_key.get() if ideareal is not None: idea_query = Idea.query(Idea.author == ideareal.author) idea_query2 = idea_query.filter(Idea.number == ideareal.number) idea = idea_query2.fetch() #Have to make it idea specific reply_query = Reply.query().order(Reply.date) reply_query2 = reply_query.filter(Reply.respond == ideareal.number) reply_info = reply_query2.fetch() template_values = { 'user_mail': users.get_current_user().email(), 'logout': users.create_logout_url(self.request.host_url), 'ideas': idea, 'replies': reply_info } template = jinja_environment.get_template('individual.html') self.response.out.write(template.render(template_values)) else: idea_query = Idea.query(Idea.author == users.get_current_user().email()) idea = idea_query.fetch() reply_query = Reply.query(Reply.author == users.get_current_user().email()) reply = reply_query.fetch() template_values = { 'user_mail': users.get_current_user().email(), 'logout': users.create_logout_url(self.request.host_url), 'ideas': idea, 'replies': reply } template = jinja_environment.get_template('deleted.html') self.response.out.write(template.render(template_values))
def get(self): if not self.have_access(): self.redirect(users.create_logout_url(config.ADMIN_URL)) return self.finish_get(self.get_template_values())
def google_logout(self): url = users.create_logout_url('/') self.response.delete_cookie('username') self.redirect(url, permanent=True)
def render(self, template, **kw): ''' Full render, with templating, user management system and paraments. This is what is going to be used most of the time. ''' user = users.get_current_user() if user: self.write(self.render_str(template, user_email = user.email(), logout_url = users.create_logout_url('/account/login'), **kw)) else: self.write(self.render_str(template, login_url = users.create_login_url('/cloud/main'), **kw))
def __init__(self, request): self.request = request self.user = users.get_current_user() self.logout_url = users.create_logout_url(self.request.url)
def get(self): """ HTTP GET Method to render the ``/groups`` page for the logged in Instructor. """ # First, check that the logged in user is an instructor instructor = utils.check_privilege(model.Role.instructor) if not instructor: # Send them home and short circuit all other logic return self.redirect('/') # end # Otherwise, create a logout url logout_url = users.create_logout_url(self.request.uri) # And get the course and section names from the page course_name = self.request.get('course') selected_section_name = self.request.get('section') # Grab all the courses and sections for the logged in instructor template_values = utils.get_template_all_courses_and_sections(instructor, course_name.upper(), selected_section_name.upper()) # Now check that the section from the webpage actually corresponded # to an actual section in this course, and that the template was set if 'selectedSectionObject' in template_values: # If so, grab that section from the template values current_section = template_values['selectedSectionObject'] # Check that the current section has at least one round if current_section.rounds > 0: # Grab the responses from the initial question response = model.Response.query( ancestor=model.Round.get_by_id(1, parent=current_section.key).key).fetch() no_answer_students = [] # And loop over the students in this section for stu in current_section.students: flag = True # Loop over the responses for res in response: # And check when the response matches the student if res.student == stu.email: # And set the group of the response to the # group of the student who made that response res.group = stu.group flag = False # end # end if flag: no_answer_students.append(stu) # end # Add the responses and current group to the template values template_values['no_answer_students'] = no_answer_students template_values['responses'] = response template_values['group'] = current_section.groups # end # end # Set the template and render the page template_values['logouturl'] = logout_url from src import config template_values['documentation'] = config.DOCUMENTATION template = utils.jinja_env().get_template('instructor/groups.html') self.response.write(template.render(template_values))
def get(self, str): site = memcache.get("site") if site is None: site = Site.all().get() memcache.add("site", site) if not site: self.redirect('/config') else: if str != '': if str == 'login': self.redirect(users.create_login_url('/')) else: self.redirect('/') else: q = self.request.get('q').strip() if q: posts = memcache.get("qposts-" + q) if posts is None: posts = getposts(PAGESIZE, None, q, 'next') memcache.add("qposts-" + q, posts) else: posts = memcache.get("posts") if posts is not None and len(posts) != PAGESIZE + 1: memcache.delete("posts") posts = None if posts is None: query = Post.gql('ORDER BY time DESC, __key__ ASC') posts = query.fetch(PAGESIZE + 1) memcache.add("posts", posts) if len(posts) == PAGESIZE + 1: posts = posts[:PAGESIZE] next = posts[-1].key() else: next = None for post in posts: post.content = re.sub( ur'<code(?P<index>.*)>(?P<content>[\s\S]*)</code(?P=index)>', lambda m: '<code>' + cgi.escape(m.group( 'content')) + '</code>', post.content) post.comment = memcache.get("postcommentcount-" + post.key().__str__()) if post.comment is None: post.comment = len( getcomments(post.key().__str__(), None)) memcache.add( "postcommentcount-" + post.key().__str__(), post.comment) post.time += timedelta(hours=+8) template_values = { 'site': site, 'posts': posts, 'previous': None, 'recentcomments': getrecentcomments(PAGESIZE), 'next': next, 'page': 'home' } user = users.get_current_user() if user: template_values['logout'] = users.create_logout_url( self.request.uri) template_values['user'] = users.get_current_user() if users.is_current_user_admin(): template_values['admin'] = True else: template_values['login'] = users.create_login_url( self.request.uri) if q: template_values['q'] = q if ismobile(self): template_values['mobile'] = True path = os.path.join(os.path.dirname(__file__), 'template/home.html') self.response.out.write(template.render(path, template_values))
def logout_html(): return '<div id = "user">Logged in as <span id = "user-email">' + users.get_current_user( ).email( ) + '</span> | <a id ="logout-link" href = "' + users.create_logout_url( "/") + '">sign out</a></div>'
def get(self): self.response.headers['content-type'] = 'text/html' # Declaration of required variables starts here. user_TaskBoards = [] TaskBoard_Count = 0 Total_Tasks = [] Active_Tasks = [] Complete_Tasks = [] Completed_Today = [] # Declaration of required variables ends here. userLoggedIn = users.get_current_user() # Fetching data of loggedin user. if userLoggedIn: # Checking if user is logged in. IF logged in, this variable will not be None. loginLink = users.create_logout_url(self.request.uri) loginStatus = 'Logout' user_Key = ndb.Key('UserDB', userLoggedIn.email()).get() # Fetching data from UserDB table for logged in user. if user_Key == None: # In case no data is fetched from UserDB table, insert below values to same. user_Key = UserDB(id=userLoggedIn.email()) # User id will be same as email id. user_Key.user_Email = userLoggedIn.email() # Email id will be given by user while loging in. user_Key.put() TaskBoardKeys = user_Key.TB_Key # Fetching all taskboard Keys for given user. It contains keys of taskboards if TaskBoardKeys != None: for i in TaskBoardKeys: # Fetching all taskboard data from Taskboard DataStore. user_TaskBoards.append(ndb.Key('TaskBoardDB',i).get()) TaskBoard_Count = len(TaskBoardKeys) # Getting count of number of taskboard keys this user have. for j in range(0,TaskBoard_Count): # Looping to fetch data of tasks from TaskDB for all task boards fetched in above loop. Task_DB_Data = ndb.Key('TaskDB',TaskBoardKeys[j]).get() if Task_DB_Data != None: Total_Tasks.append(len(Task_DB_Data.TaskTitle)) # Fetching total number of tasks in taskboard. ActiveCount = 0 # Initializing for each task. CompleteToday = 0 # Initializing for each task. for k in range(0,len(Task_DB_Data.TaskCompleteStatus)): # Fetching total number of tasks completed in taskboard. if Task_DB_Data.TaskCompleteStatus[k] == 0: # If TaskCompleteStatus is 0, task in incomplete. ActiveCount = ActiveCount + 1 # If task is incomplete, active task count will be increamented. DateTimeToday = datetime.now() # Fetching today's date and time. DateToday = DateTimeToday.strftime('%Y-%m-%d') # Separating date from datetime. if Task_DB_Data.TaskCompleteDate[k] == DateToday: # If task is completed, check if its completed today. CompleteToday = CompleteToday + 1 # If true for above condition, increment Completed Today count by 1. Active_Tasks.append(ActiveCount) # Appending in global variable. Completed_Today.append(CompleteToday) # Appending in global variable. Complete_Tasks.append(len(Task_DB_Data.TaskTitle) - ActiveCount) # Calculating completed task and appending in global variable. else: # In case there are no tasks in taskboard, append 0 to all. Total_Tasks.append(0) Active_Tasks.append(0) Complete_Tasks.append(0) Completed_Today.append(0) else: loginLink = users.create_login_url(self.request.uri) loginStatus = 'Login' template_values = { 'loginLink' : loginLink, 'loginStatus' : loginStatus, 'userLoggedIn' : userLoggedIn, 'user_TaskBoards' : user_TaskBoards, 'TaskBoard_Count' : TaskBoard_Count, 'Total_Tasks' : Total_Tasks, 'Active_Tasks' : Active_Tasks, 'Complete_Tasks' : Complete_Tasks, 'Completed_Today' : Completed_Today } template = JINJA_ENVIRONMENT.get_template('Main.html') self.response.write(template.render(template_values))
def logout(request): django_logout(request) return HttpResponseRedirect(users.create_logout_url("/"))
def dispatch(self): result = {'url': users.create_logout_url('/trade')} send_json(self, result)
def get(self, command=''): def lookup(dict_or_obj, member): try: # could be a dictionary or a NoneType member_value = dict_or_obj[member] except (KeyError, TypeError): try: # could have it as an attribute member_value = getattr(dict_or_obj, member) except AttributeError: member_value = False return member_value this_app = AppOpenLSH.get_or_insert('KeyOpenLSH') app_is_open = this_app.is_open frameinfo = getframeinfo(currentframe()) app_is_closed = False u = users.get_current_user() ulogged = 'User not logged in' if not u else 'User is %s' % u.nickname( ) app_status = 'App is Open' if app_is_open else "App is Closed" if u and u.user_id() == '108492098862327080451': frameinfo = getframeinfo(currentframe()) logging.info('file %s, line %s Admin User, %s', frameinfo.filename, frameinfo.lineno + 1, app_status) url = users.create_logout_url(self.request.uri) url_linktext = 'Google Logout' elif u and app_is_open: frameinfo = getframeinfo(currentframe()) logging.info('file %s, line %s %s %s', frameinfo.filename, frameinfo.lineno + 1, ulogged, app_status) url = users.create_logout_url(self.request.uri) url_linktext = 'Google Logout' elif not u: frameinfo = getframeinfo(currentframe()) logging.info('file %s, line %s %s %s', frameinfo.filename, frameinfo.lineno + 1, ulogged, app_status) url = users.create_login_url(self.request.uri) url_linktext = 'Google Login -- use your Gmail' else: frameinfo = getframeinfo(currentframe()) logging.info('file %s, line %s %s %s', frameinfo.filename, frameinfo.lineno + 1, ulogged, app_status) url = users.create_logout_url(self.request.uri) url_linktext = 'Google Logout' app_is_closed = not app_is_open tw_auth = False try: tw_auth = self.session['tw_auth'] except: pass tw_logged_in = False try: tw_logged_in = self.session['tw_logged_in'] except: pass tw_banner = '' if tw_logged_in: tw_banner = 'Ready for Tweets' tweet_display = '' if not app_is_closed: duik = lookup(self.session, 'duik') dui = ndb.Key(urlsafe=duik).get() if duik else None if not dui: dui = read_tweepy.DemoUserInfo.latest_for_user(u) self.session['duik'] = dui.key.urlsafe() if dui else None if dui: tweets = dui.tweets tw_banner = '%d Tweets as of %s' % ( len(tweets), dui.asof.isoformat(' ')[:19]) tweet_display = '<br/>\n— '.join(tweets) else: dui = None headline = '' try: if command == 'show_lsh_results': headline = self.session['lsh_results'][0] # matched_tweets = [tweets[twid] for twid in range(len(tweets)) if twid in self.session['lsh_results'][1]] other_tweets = [ tweets[twid] for twid in range(len(tweets)) if twid not in self.session['lsh_results'][1] ] tweet_display = '<br/>\n— '.join(other_tweets) except: pass template_values = { 'app_is_closed': app_is_closed, 'google_logged_in': u, 'url': url, 'url_linktext': url_linktext, 'tw_auth': tw_auth, 'tw_banner': tw_banner, 'headline': headline, 'tweet_display': tweet_display, 'fetching': lookup(dui, 'fetching'), 'calculating': lookup(dui, 'calculating'), 'calc_done': lookup(dui, 'calc_done'), 'showing_lsh_results': command == 'show_lsh_results', 'gaCode': settings.gaCode, } template = JINJA_ENVIRONMENT.get_template('tweets_index.html') try: self.response.write(template.render(template_values)) except UnicodeDecodeError: template_values['tweets'] = 'unreadable content' self.response.write(template.render(template_values))
def get(self): self.delete_cookie('ureg_id') self.redirect(users.create_logout_url(self.request_string("continue", default="/")))
def get(self): site = memcache.get("site") if site is None: site = Site.all().get() memcache.add("site", site) if not site: self.redirect('/config') else: try: outputcaptcha = captcha() if outputcaptcha: template_values = { 'site': site, 'captcha': outputcaptcha, 'page': 'guestbook', 'recentcomments': getrecentcomments(PAGESIZE) } user = users.get_current_user() if user: template_values['logout'] = users.create_logout_url( self.request.uri) template_values['user'] = users.get_current_user() if users.is_current_user_admin(): template_values['admin'] = True else: template_values['login'] = users.create_login_url( self.request.uri) comments = memcache.get("comments-none") if comments is None: comments = getcomments(None, None) memcache.add("comments-none", comments) for comment in comments: comment.email = hashlib.new('md5', comment.email).hexdigest() template_values['commentcount'] = len(comments) reply = None replykey = self.request.get('reply') if replykey: comment = memcache.get("comment-" + replykey) if comment is None: comment = Comment.all().order("-__key__").filter( '__key__ =', db.Key(replykey)).get() memcache.add("comment-" + replykey, comment) if comment and comment.post == None: reply = { 'key': str(replykey), 'captcha': outputcaptcha } template_values['reply'] = True commenthtml = outputcomment(None, comments, [], None, reply) template_values['commenthtml'] = commenthtml if ismobile(self): template_values['mobile'] = True path = os.path.join(os.path.dirname(__file__), 'template/guestbook.html') self.response.out.write( template.render(path, template_values)) else: self.redirect('/') except: self.redirect('/')
% (instrument, beginDate, endDate)) # Queue the strategy execution config and redirect. stratExecConfig = self.__buildStratExecConfig( strategyClassName, strategyParams, form) stratExecConfig.put() seproducer.SEProducerHandler.queue(stratExecConfig.key()) self.redirect(StrategyPage.getUrl(strategyClassName)) except Exception, e: templateValues["submit_error"] = str(e) # Template values strategyValues = {} strategyValues["class"] = strategyClassName templateValues["logout_url"] = users.create_logout_url("/") templateValues["user"] = users.get_current_user() templateValues["strategy"] = strategyValues templateValues["form"] = self.__getFormValues(strategyParams, form) # Build the response using the template. path = os.path.join(os.path.dirname(__file__), "..", "templates", 'queue_execution.html') self.response.out.write(template.render(path, templateValues)) def get(self): return self.__handleRequest(False) def post(self): return self.__handleRequest(True)
def get(self, key): site = memcache.get("site") if site is None: site = Site.all().get() memcache.add("site", site) if not site: self.redirect('/config') else: if key: try: q = self.request.get('q').strip() if q: posts = memcache.get("previousqposts-" + key + q) if posts is None: posts = getposts(PAGESIZE, db.Key(key), q, 'previous') memcache.add("previousqposts-" + key + q, posts) else: posts = memcache.get("previousposts-" + key) if posts is None: post = Post.all().order("-__key__").filter( '__key__ =', db.Key(key)).get() query = Post.gql( 'WHERE time = :time AND __key__ < :key ORDER BY __key__ DESC, time ASC', time=post.time, key=post.key()) posts = query.fetch(PAGESIZE + 1) if len(posts) < PAGESIZE + 1: remainder = PAGESIZE + 1 - len(posts) query = Post.gql( 'WHERE time > :time ORDER BY time ASC, __key__ DESC', time=post.time) moreposts = query.fetch(remainder) posts += moreposts memcache.add("previousposts-" + key, posts) if posts: next = posts[0].key() else: next = None if len(posts) == PAGESIZE + 1: posts = posts[:PAGESIZE] previous = posts[-1].key() else: previous = None for item in posts: item.content = re.sub( ur'<code(?P<index>.*)>(?P<content>[\s\S]*)</code(?P=index)>', lambda m: '<code>' + cgi.escape(m.group( 'content')) + '</code>', item.content) item.comment = len( getcomments(item.key().__str__(), None)) item.time += timedelta(hours=+8) posts = reversed(posts) template_values = { 'site': site, 'posts': posts, 'previous': previous, 'next': next, 'page': 'previous' } user = users.get_current_user() if user: template_values['logout'] = users.create_logout_url( self.request.uri) template_values['user'] = users.get_current_user() if users.is_current_user_admin(): template_values['admin'] = True else: template_values['login'] = users.create_login_url( self.request.uri) if q: template_values['q'] = q if ismobile(self): template_values['mobile'] = True path = os.path.join(os.path.dirname(__file__), 'template/home.html') self.response.out.write( template.render(path, template_values)) except: self.redirect('/') else: self.redirect('/')
def GatherBaseData(self, mr, nonce): """Return a dict of info used on almost all pages.""" project = mr.project project_summary = '' project_alert = None project_read_only = False project_home_page = '' project_thumbnail_url = '' if project: project_summary = project.summary project_alert = _CalcProjectAlert(project) project_read_only = project.read_only_reason project_home_page = project.home_page project_thumbnail_url = tracker_views.LogoView( project).thumbnail_url with work_env.WorkEnv(mr, self.services) as we: is_project_starred = False project_view = None if mr.project: if permissions.UserCanViewProject(mr.auth.user_pb, mr.auth.effective_ids, mr.project): is_project_starred = we.IsProjectStarred(mr.project_id) # TODO(jrobbins): should this be a ProjectView? project_view = template_helpers.PBProxy(mr.project) grid_x_attr = None grid_y_attr = None hotlist_view = None if mr.hotlist: users_by_id = framework_views.MakeAllUserViews( mr.cnxn, self.services.user, features_bizobj.UsersInvolvedInHotlists([mr.hotlist])) hotlist_view = hotlist_views.HotlistView( mr.hotlist, mr.perms, mr.auth, mr.viewed_user_auth.user_id, users_by_id, self.services.hotlist_star.IsItemStarredBy( mr.cnxn, mr.hotlist.hotlist_id, mr.auth.user_id)) grid_x_attr = mr.x.lower() grid_y_attr = mr.y.lower() app_version = os.environ.get('CURRENT_VERSION_ID') viewed_username = None if mr.viewed_user_auth.user_view: viewed_username = mr.viewed_user_auth.user_view.username issue_entry_url = 'entry' config = None if mr.project_id and self.services.config: with mr.profiler.Phase('getting config'): config = self.services.config.GetProjectConfig( mr.cnxn, mr.project_id) grid_x_attr = (mr.x or config.default_x_attr).lower() grid_y_attr = (mr.y or config.default_y_attr).lower() issue_entry_url = _LoginOrIssueEntryURL(mr, config) viewing_self = mr.auth.user_id == mr.viewed_user_auth.user_id offer_saved_queries_subtab = (viewing_self or mr.auth.user_pb and mr.auth.user_pb.is_site_admin) login_url = _SafeCreateLoginURL(mr) logout_url = _SafeCreateLogoutURL(mr) logout_url_goto_home = users.create_logout_url('/') version_base = _VersionBaseURL(mr.request) base_data = { # EZT does not have constants for True and False, so we pass them in. 'True': ezt.boolean(True), 'False': ezt.boolean(False), 'local_mode': ezt.boolean(settings.local_mode), 'site_name': settings.site_name, 'show_search_metadata': ezt.boolean(False), 'page_template': self._PAGE_TEMPLATE, 'main_tab_mode': self._MAIN_TAB_MODE, 'project_summary': project_summary, 'project_home_page': project_home_page, 'project_thumbnail_url': project_thumbnail_url, 'hotlist_id': mr.hotlist_id, 'hotlist': hotlist_view, 'hostport': mr.request.host, 'absolute_base_url': '%s://%s' % (mr.request.scheme, mr.request.host), 'project_home_url': None, 'link_rel_canonical': None, # For specifying <link rel="canonical"> 'projectname': mr.project_name, 'project': project_view, 'project_is_restricted': ezt.boolean(_ProjectIsRestricted(mr)), 'offer_contributor_list': ezt.boolean(permissions.CanViewContributorList(mr, mr.project)), 'logged_in_user': mr.auth.user_view, 'form_token': None, # Set to a value below iff the user is logged in. 'form_token_path': None, 'token_expires_sec': None, 'xhr_token': None, # Set to a value below iff the user is logged in. 'flag_spam_token': None, 'nonce': nonce, 'perms': mr.perms, 'warnings': mr.warnings, 'errors': mr.errors, 'viewed_username': viewed_username, 'viewed_user': mr.viewed_user_auth.user_view, 'viewed_user_pb': template_helpers.PBProxy(mr.viewed_user_auth.user_pb), 'viewing_self': ezt.boolean(viewing_self), 'viewed_user_id': mr.viewed_user_auth.user_id, 'offer_saved_queries_subtab': ezt.boolean(offer_saved_queries_subtab), 'currentPageURL': mr.current_page_url, 'currentPageURLEncoded': mr.current_page_url_encoded, 'login_url': login_url, 'logout_url': logout_url, 'logout_url_goto_home': logout_url_goto_home, 'continue_issue_id': mr.continue_issue_id, 'feedback_email': settings.feedback_email, 'category_css': None, # Used to specify a category of stylesheet 'category2_css': None, # specify a 2nd category of stylesheet if needed. 'page_css': None, # Used to add a stylesheet to a specific page. 'can': mr.can, 'query': mr.query, 'colspec': None, 'sortspec': mr.sort_spec, # Options for issuelist display 'grid_x_attr': grid_x_attr, 'grid_y_attr': grid_y_attr, 'grid_cell_mode': mr.cells, 'grid_mode': None, 'list_mode': None, 'chart_mode': None, 'issue_entry_url': issue_entry_url, 'is_cross_project': ezt.boolean(False), # for project search (some also used in issue search) 'start': mr.start, 'num': mr.num, 'groupby': mr.group_by_spec, 'q_field_size': (min( framework_constants.MAX_ARTIFACT_SEARCH_FIELD_SIZE, max(framework_constants.MIN_ARTIFACT_SEARCH_FIELD_SIZE, len(mr.query) + framework_constants.AUTOSIZE_STEP))), 'mode': None, # Display mode, e.g., grid mode. 'ajah': mr.ajah, 'table_title': mr.table_title, 'alerts': alerts.AlertsView(mr), # For alert.ezt 'project_alert': project_alert, 'title': None, # First part of page title 'title_summary': None, # Appended to title on artifact detail pages # TODO(jrobbins): make sure that the templates use # project_read_only for project-mutative actions and if any # uses of read_only remain. 'project_read_only': ezt.boolean(project_read_only), 'site_read_only': ezt.boolean(settings.read_only), 'banner_time': servlet_helpers.GetBannerTime(settings.banner_time), 'read_only': ezt.boolean(settings.read_only or project_read_only), 'site_banner_message': settings.banner_message, 'robots_no_index': None, 'analytics_id': settings.analytics_id, 'is_project_starred': ezt.boolean(is_project_starred), 'version_base': version_base, 'app_version': app_version, 'gapi_client_id': settings.gapi_client_id, 'viewing_user_page': ezt.boolean(False), 'old_ui_url': None, 'is_member': ezt.boolean(False), } if mr.project: base_data['project_home_url'] = '/p/%s' % mr.project_name # Always add xhr-xsrf token because even anon users need some # pRPC methods, e.g., autocomplete, flipper, and charts. base_data['token_expires_sec'] = xsrf.TokenExpiresSec() base_data['xhr_token'] = xsrf.GenerateToken(mr.auth.user_id, xsrf.XHR_SERVLET_PATH) # Always add other anti-xsrf tokens when the user is logged in. if mr.auth.user_id: form_token_path = self._FormHandlerURL(mr.request.path) base_data['form_token'] = xsrf.GenerateToken( mr.auth.user_id, form_token_path) base_data['form_token_path'] = form_token_path return base_data
def post(self): self.response.headers['Content-Type'] = 'text/html' user = users.get_current_user() gpu_data = '' gpu_key = '' if user: main_header = 'GPU Information' login_logout = 'Logout' login_logout_url = users.create_logout_url(self.request.uri) gpu_name = self.request.get('gpu_id') gpu_key = ndb.Key('GPUModel', gpu_name) print(gpu_key) print(gpu_name) gpu_data = gpu_key.get() if self.request.get("button") == "Submit": if self.request.get("geometryShader"): gpu_data.geometryShader = True else: gpu_data.geometryShader = False if self.request.get("tesselationShader"): gpu_data.tesselationShader = True else: gpu_data.tesselationShader = False if self.request.get("shaderInt16"): gpu_data.shaderInt16 = True else: gpu_data.shaderInt16 = False if self.request.get("sparseBinding"): gpu_data.sparseBinding = True else: gpu_data.sparseBinding = False if self.request.get("textureCompressionETC2"): gpu_data.textureCompressionETC2 = True else: gpu_data.textureCompressionETC2 = False if self.request.get("vertexPipelineStoresAndAtomics"): gpu_data.vertexPipelineStoresAndAtomics = True else: gpu_data.vertexPipelineStoresAndAtomics = False gpu_data.put() self.redirect('/') else: main_header = 'Please Login to Access This Page..!!' login_logout = 'Login' login_logout_url = users.create_login_url(self.request.uri) template_values = { 'main_header': main_header, 'login_logout': login_logout, 'login_logout_url': login_logout_url, 'user': user, 'gpu_data': gpu_data, 'gpu_name': gpu_name } template = JINJA_ENVIRONMENT.get_template('edit.html') self.response.write(template.render(template_values))
def get(self): if self.request.host.find("appspot") != -1 and self.request.url.find( "https") != 0: # if on appspot.com and not in ssl mode self.redirect("http://www.zen-wiki.com" + self.request.path) path = filter( lambda x: not not x, urllib.unquote(self.request.path).decode('utf8').split('/')) wikiurl = path[0] pageurl = '/'.join(path[1:]) wiki = Wiki.getByUrl(wikiurl) if not wiki: self.e404() return page = wiki.getPage(pageurl) if not page: page = Page(url=pageurl, content='', parent=wiki, private=False) # ---------- menu building pages = {} for p in wiki.allPages(): pages[p.url] = p urls = pages.keys() menu = {} for url in urls: if not url: continue # drop 'Root' _path = url.split('/') cur = menu cur_path = '' for step in _path: cur_path += ('/' if cur_path else '') + step if not step in cur.keys(): cur[step] = { 'is_page': cur_path in urls, 'private': cur_path in urls and pages[cur_path].private, 'current': (wiki.getUrl() + '/' + cur_path) == ('/' + '/'.join(path)), 'children': {} } cur = cur[step]['children'] cur_path = '' menu = { u'': { 'is_page': cur_path in urls, 'private': cur_path in urls and pages[cur_path].private, 'current': (wiki.getUrl() + cur_path) == ('/' + '/'.join(path)), 'children': menu } } def draw(root, url_prefix): result = '' for url_part in sorted(root.keys()): item = root[url_part] name = url_part or 'root' name = capfirst(name) name = escape(name) url = url_prefix + url_part class_name = '' if not item['is_page']: class_name += ' new' if item['current']: class_name += ' current' if item['private']: class_name += ' private' children = '' if item['children']: children = '<ul>%s</ul>' % draw( item['children'], url_prefix + url_part + '/') result += '<li><span class="name %s"><a href="%s">%s</a></span>%s</li>' % ( class_name, url, name, children) return result menu_html = draw(menu, wiki.getUrl()) # ---------- breadcrumbs = path[:-1] if len(breadcrumbs): breadcrumbs[0] = 'root' self.response.out.write( template.render( 'templates/main.html', { 'user': users.get_current_user(), 'logout_url': users.create_logout_url(self.request.path), 'login_url': users.create_login_url(self.request.path), 'wiki': wiki, 'page': page, 'path': breadcrumbs, 'menu_html': menu_html }))
def get(self): user = users.get_current_user() if users.get_current_user(): url = users.create_logout_url(self.request.uri) url_linktext = ‘Logout’ else: url = users.create_login_url(self.request.uri) Cloud Computing | 249 url_linktext = ‘Login’ template_values = { ‘url’: url, ‘url_linktext’: url_linktext, } path = os.path.join(os.path.dirname(__file__), ‘index.html') self.response.out.write(template.render(path, template_values)) class Recent(webapp.RequestHandler): """Query Last 10 Requests""" def get(self): #collection collection = [] #grab last 10 records from datastore query = ChangeModel.all().order('-date') records = query.fetch(limit=10) #formats decimal correctly for change in records: collection.append(decimal.Decimal(change.input)/100) template_values = { 'inputs': collection, 'records': records, } path = os.path.join(os.path.dirname(__file__), 'query.html') self.response.out.write(template.render(path,template_values)) class Result(webapp.RequestHandler): """Returns Page with Results""" def __init__(self): self.coins = [1,5,10,25] self.coin_lookup = {25: "quarters", 10: "dimes", 5: "nickels", 1: "pennies"} def get(self): #Just grab the latest post collection = {} #select the latest input from the datastore change = db.GqlQuery("SELECT * FROM ChangeModel ORDER BY date DESC LIMIT 1") for c in change: change_input = c.input #coin change logic coin = self.coins.pop() num, rem = divmod(change_input, coin) if num: collection[self.coin_lookup[coin]] = num while rem > 0: coin = self.coins.pop() num, rem = divmod(rem, coin) 250 | Chapter 8: OS Soup if num: collection[self.coin_lookup[coin]] = num template_values = { 'collection': collection, 'input': decimal.Decimal(change_input)/100, } #render template path = os.path.join(os.path.dirname(__file__), 'result.html') self.response.out.write(template.render(path, template_values)) class Change(webapp.RequestHandler): def post(self): """Printing Method For Recursive Results and While Results""" model = ChangeModel() try: change_input = decimal.Decimal(self.request.get('content')) model.input = int(change_input*100) model.put() self.redirect('/result') except decimal.InvalidOperation: path = os.path.join(os.path.dirname(__file__), 'submit_error.html') self.response.out.write(template.render(path,None)) def main(): application = webapp.WSGIApplication([('/', MainPage), ('/submit_form', Change), ('/result', Result), ('/recent', Recent)], debug=True) wsgiref.handlers.CGIHandler().run(application) if __name__ == "__main__": main()
health['taskqueue'] = FAILED logging.error("taskqueue API FAILED %s"%(str(e))) if capability == "all" or capability == "urlfetch": try: result = urlfetch.fetch("http://localhost") health['urlfetch'] = RUNNING except Exception, e: health['urlfetch'] = FAILED logging.error("urlfetch API FAILED %s"%(str(e))) if capability == "all" or capability == "users": try: user = users.get_current_user() users.create_login_url("/") users.create_logout_url("/") health['users'] = RUNNING except Exception, e: health['users'] = FAILED logging.error("users API FAILED %s"%(str(e))) if capability == "all" or capability == "xmpp": try: xmpp.get_presence("[email protected]") health['xmpp'] = RUNNING except Exception, e: health['xmpp'] = FAILED logging.error("xmpp API FAILED %s"%(str(e))) if capability == "all" or capability == "mapreduce":
def get(self): login_url = users.create_login_url(self.request.path) logout_url = users.create_logout_url(dest_url='/') template = template_env.get_template('templates/CloudComm.html') context = {'loginURL': login_url, 'logoutURL': logout_url} self.response.write(template.render(context))
def get(self): self.redirect(users.create_logout_url("/"))
def post(self): try: Guser = users.get_current_user() tComNames = self.request.get('vComNamesr') tComEmail = self.request.get('vComEmailr') tMainComment = self.request.get('vMainCommenter') tMessageHeading = self.request.get('vHeadingsr') tMessageBoard = MessageBoard() findrequest = db.Query(Profiles).order('-DateTimeCreated') tProfiles = findrequest.fetch(limit=self._featuredProfilesLimit) fjobs = FreelanceJobs.retrieveJobsByJobType( strinput='freelance jobs') if not (fjobs == self._JobsNotFound) and not ( fjobs == self._pkeyNotSet) and not (fjobs == self._generalError): fjobslist = fjobs else: fjobslist = [] if Guser: if isGoogleServer: ReferenceNum = Guser.user_id() else: ReferenceNum = self._tempCode findquery = db.Query(Reference).filter('strReferenceNum =', ReferenceNum) results = findquery.fetch(limit=self._maxQResults) login_url = '/login' logout_url = users.create_logout_url(dest_url='/') tMessageBoard.createBoardMessage( inSenderNames=tComNames, inSenderEmail=tComEmail, inBoardMessage=tMainComment, inMessageHeading=tMessageHeading, inMessageActivated=True) if len(results) > 0: result = results[0] username = result.readUsername() if username == self.undefined: username = Guser.nickname() logging.info('Username Found') errorMessage = self.undefined template = template_env.get_template( '/templates/index.html') if result.readIsValid(): UserNotSubscribed = result.NewsletterSubscription context = { 'user': username, 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'NewsLetterSubscription': UserNotSubscribed, 'vProfiles': tProfiles, 'freelancejobslist': fjobslist } else: context = { 'user': username, 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'vProfiles': tProfiles, 'freelancejobslist': fjobslist } self.response.write(template.render(context)) else: username = Guser.nickname() errorMessage = self._CompleteSubscriptionForm ActivateSub = 'Yes' template = template_env.get_template( '/templates/index.html') context = { 'user': username, 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'ActivateSub': ActivateSub, 'vProfiles': tProfiles, 'freelancejobslist': fjobslist } self.response.write(template.render(context)) else: login_url = '/login' logout_url = users.create_logout_url(dest_url='/') tMessageBoard.createBoardMessage(inSenderNames=tComNames, inSenderEmail=tComEmail, inBoardMessage=tMainComment, inMessageActivated=True) username = self.undefined errorMessage = self._userNotLoggedin ActivateLogin = '******' template = template_env.get_template('/templates/index.html') context = { 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'ActivateLogin': ActivateLogin, 'vProfiles': tProfiles, 'freelancejobslist': fjobslist } self.response.write(template.render(context)) except: errorMessage = 'There was an error accessing our database please try again in a minute' doRender(self, 'index.html', {'errorMessage': errorMessage})
def get(self): template = env.get_template('workouts.html') redirect = users.create_logout_url('/') self.response.write(template.render({'redirect': redirect}))
def get(self): stream_key = self.request.get("Stream_id") usr = users.get_current_user() logout_url = users.create_logout_url('/') myStream_qurey = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1) if len(myStream_qurey) == 0: self.redirect("/myhtml/Errorpage.html?Error_code=404") return myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1)[0] owner = myStream.streamOwner # increase the view by 1 if not view by owner if owner != usr: myStream.numOfViews = myStream.numOfViews +1 # get the view Time queue viewTimeQueue = myStream.viewTimeQueue currentTime = datetime.datetime.now() while len(viewTimeQueue)> 0 and (currentTime - viewTimeQueue[0]).seconds > 3600: del viewTimeQueue[0] viewTimeQueue.append(datetime.datetime.now()) myStream.viewTimeQueue = viewTimeQueue myStream.put() # test to see if this is the stream usr sub streamIOwn_query = stream_bundle.stream_bundles.query(ancestor=management.stream_key(usr)).fetch(1) stream_bundles_entity = streamIOwn_query[0] # get the list I sub listIsub = stream_bundles_entity.stream_isublist IsubthisStream = False for key in listIsub: if(key.get() is not None and key.get().streamname == stream_key): IsubthisStream = True break template = JINJA_ENVIRONMENT.get_template('myhtml/viewSingleStream.html') # step1 Create an upload URL if user want to upload pages upload_url = blobstore.create_upload_url('/viewSingleAfterUpload') # get image if any if(len(myStream.blob_key) > 0): image_bolb_key_list = myStream.blob_key image_url = [""]*3 counter = 0 for bbkey in image_bolb_key_list: image_url[counter]= images.get_serving_url(bbkey) counter = counter +1 if(counter == 3): break weHaveImage = True else: weHaveImage = False image_url = [""]*3 template_values = { 'owner': str(owner), 'usr': str(usr), 'blobstore_url': upload_url, 'stream_key': stream_key, 'haveImage': weHaveImage, 'imageUrl': image_url, 'IsubThisStream': IsubthisStream, 'logout_url': logout_url, } self.response.write(template.render(template_values))
def get(self): try: Guser = users.get_current_user() findrequest = db.Query(Profiles).order('-DateTimeCreated') tProfiles = findrequest.fetch(limit=self._featuredProfilesLimit) reQuestURL = self.request.url login_url = "/login" logout_url = users.create_logout_url(dest_url='/') logging.info('MAIN PAGE NEW GET METHOD') fjobs = FreelanceJobs() fjobs = fjobs.retrieveJobsByJobType(strinput='freelance jobs') if not (fjobs == self._JobsNotFound) and not ( fjobs == self._pkeyNotSet) and not (fjobs == self._generalError): fjobslist = fjobs else: fjobslist = [] logging.info('RETRIEVE FREELANCE JOBS DONE') if Guser: if isGoogleServer: ReferenceNum = Guser.user_id() else: ReferenceNum = self._tempCode findquery = db.Query(Reference).filter('strReferenceNum =', ReferenceNum) results = findquery.fetch(limit=self._maxQResults) #Get firstname and surname and vProfession and vDateTimeVerified and vTasks and vNotifications and vNumMessages if len(results) > 0: result = results[0] username = result.readUsername() if username == self.undefined: username = Guser.nickname() logging.info('USERNAME FOUND') errorMessage = self.undefined template = template_env.get_template( '/templates/index.html') if result.readIsValid(): UserNotSubscribed = result.NewsletterSubscription recNames = User.getNamesbyRefNum(strinput=ReferenceNum) if not (recNames == self.undefined) and not ( recNames == self._generalError): context = { 'user': username, 'vFirstname': recNames.readFirstname(), 'vSurname': recNames.readSurname(), 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'NewsLetterSubscription': UserNotSubscribed, 'vProfiles': tProfiles, 'reQuestURL': reQuestURL, 'freelancejobslist': fjobslist } else: context = { 'user': username, 'vFirstname': "John", 'vSurname': "Doe", 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'NewsLetterSubscription': UserNotSubscribed, 'vProfiles': tProfiles, 'reQuestURL': reQuestURL, 'freelancejobslist': fjobslist } else: context = { 'user': username, 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'vProfiles': tProfiles, 'reQuestURL': reQuestURL } self.response.write(template.render(context)) else: logging.info('USER NAME NICKNAME') username = Guser.nickname() errorMessage = self._CompleteSubscriptionForm ActivateSub = 'Yes' template = template_env.get_template( '/templates/index.html') context = { 'user': username, 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'ActivateSub': ActivateSub, 'vProfiles': tProfiles, 'reQuestURL': reQuestURL, 'freelancejobslist': fjobslist } self.response.write(template.render(context)) else: logging.info('Username Home') username = '' errorMessage = self._userNotLoggedin ActivateLogin = '******' template = template_env.get_template('/templates/index.html') context = { 'loginURL': login_url, 'logoutURL': logout_url, 'errorMessage': errorMessage, 'ActivateLogin': ActivateLogin, 'vProfiles': tProfiles, 'reQuestURL': reQuestURL, 'freelancejobslist': fjobslist } self.response.write(template.render(context)) except: errorMessage = 'There was an error accessing our database please try again in a minute' doRender(self, 'index.html', {'errorMessage': errorMessage})
def get(self): """Show the main page.""" template = jinja_environment.get_template('templates/index.html') logout_url = users.create_logout_url('/') self.response.out.write(template.render({'logout_url': logout_url}))
def get(self, key): site = memcache.get("site") if site is None: site = Site.all().get() memcache.add("site", site) if not site: self.redirect('/config') else: if key: try: post = memcache.get("post-" + key) if post is None: post = Post.all().order("-__key__").filter('__key__ = ', db.Key(key)).get() memcache.add("post-" + key, post) outputcaptcha = captcha() if post and outputcaptcha: template_values = { 'site': site, 'captcha': outputcaptcha, 'recentcomments': getrecentcomments(PAGESIZE), 'recentposts': getrecentposts(PAGESIZE) } user = users.get_current_user() if user: template_values['logout'] = users.create_logout_url(self.request.uri) template_values['user'] = users.get_current_user() if users.is_current_user_admin(): template_values['admin'] = True else: template_values['login'] = users.create_login_url(self.request.uri) previouspost = memcache.get("previouspost-" + key) if previouspost is None: previouspost = Post.gql('WHERE time = :time AND __key__ < :key ORDER BY __key__ DESC, time ASC', time = post.time, key = post.key()).get() if not previouspost: previouspost = Post.gql('WHERE time > :time ORDER BY time ASC, __key__ DESC', time = post.time).get() memcache.add("previouspost-" + key, previouspost) if previouspost: template_values['previouspost'] = previouspost nextpost = memcache.get("nextpost-" + key) if nextpost is None: nextpost = Post.gql('WHERE time = :time AND __key__ > :key ORDER BY __key__ ASC, time DESC', time = post.time, key = post.key()).get() if not nextpost: nextpost = Post.gql('WHERE time < :time ORDER BY time DESC, __key__ ASC', time = post.time).get() memcache.add("nextpost-" + key, nextpost) if nextpost: template_values['nextpost'] = nextpost comments = memcache.get("comments-" + key) if comments is None: comments = getcomments(key, None) memcache.add("comments-" + key, comments) for comment in comments: comment.email = hashlib.new('md5', comment.email).hexdigest() template_values['commentcount'] = len(comments) reply = None replykey = self.request.get('reply') if replykey: comment = memcache.get("comment-" + replykey) if comment is None: comment = Comment.all().order("-__key__").filter('__key__ =', db.Key(replykey)).get() memcache.add("comment-" + replykey, comment) if comment and comment.post == key: reply = { 'key': str(replykey), 'captcha': outputcaptcha } template_values['reply'] = True commenthtml = outputcomment(key, comments, [], None, reply) template_values['commenthtml'] = commenthtml if ismobile(self): template_values['mobile'] = True post.content = re.sub(ur'<code(?P<index>.*)>(?P<content>[\s\S]*)</code(?P=index)>', lambda m: '<code>' + cgi.escape(m.group('content')) + '</code>', post.content) post.time += timedelta(hours=+8) template_values['post'] = post path = os.path.join(os.path.dirname(__file__), 'templates/post.html') self.response.out.write(template.render(path, template_values)) else: self.redirect('/') except: self.redirect('/') else: self.redirect('/')
def get(self): if users.get_current_user(): self.redirect(users.create_logout_url('/')) else: self.redirect(users.create_login_url('/'))
def getLogout(self): user = users.get_current_user() if user: urlLogout = users.create_logout_url('/') return urlLogout