Example #1
0
 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)
Example #2
0
 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)
Example #3
0
 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)
Example #4
0
 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)
Example #5
0
    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)
Example #6
0
 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)
Example #7
0
    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"}))
Example #9
0
 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)
Example #10
0
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("/"));
Example #11
0
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)}))
Example #12
0
 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)
Example #13
0
    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)
Example #14
0
File: urls.py Project: hpec/ok
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'))
Example #15
0
 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>''')
Example #16
0
	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 }))
Example #17
0
    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))
Example #18
0
    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))
Example #19
0
    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>')
Example #20
0
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,
    }
Example #21
0
    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))
Example #22
0
    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,
            }))
Example #23
0
    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
Example #24
0
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
Example #25
0
File: main.py Project: stumm/z-cube
  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))
Example #26
0
 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);
Example #27
0
	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))
Example #28
0
 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)
Example #29
0
    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))
Example #30
0
    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))
Example #31
0
 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())
Example #32
0
 def google_logout(self):
     url = users.create_logout_url('/')
     self.response.delete_cookie('username')
     self.redirect(url, permanent=True)
Example #33
0
    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))
Example #34
0
 def __init__(self, request):
     self.request = request
     self.user = users.get_current_user()
     self.logout_url = users.create_logout_url(self.request.url)
Example #35
0
    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))
Example #36
0
    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))
Example #37
0
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>'
Example #38
0
    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))
Example #39
0
def logout(request):
    django_logout(request)
    return HttpResponseRedirect(users.create_logout_url("/"))
Example #40
0
 def dispatch(self):
     result = {'url': users.create_logout_url('/trade')}
     send_json(self, result)
Example #41
0
    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&mdash; '.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&mdash; '.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))
Example #42
0
 def get(self):
     self.delete_cookie('ureg_id')
     self.redirect(users.create_logout_url(self.request_string("continue", default="/")))
Example #43
0
    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('/')
Example #44
0
                        % (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)
Example #45
0
    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('/')
Example #46
0
    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
Example #47
0
    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))
Example #48
0
    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
                }))
Example #49
0
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()
Example #50
0
File: repo.py Project: rca/appscale
        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":
Example #51
0
 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))
Example #52
0
 def get(self):
     self.redirect(users.create_logout_url("/"))
Example #53
0
    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})
Example #54
0
 def get(self):
     template = env.get_template('workouts.html')
     redirect = users.create_logout_url('/')
     self.response.write(template.render({'redirect': redirect}))
Example #55
0
    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))
Example #56
0
    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})
Example #57
0
 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}))
Example #58
0
	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('/'))
Example #60
0
 def getLogout(self):
     user = users.get_current_user()
     if user:
         urlLogout = users.create_logout_url('/')
         return urlLogout