示例#1
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)
示例#2
0
    def get(self, bandid):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        logging.info('bandid: ' + bandid)
        try:
            namespace_manager.set_namespace(bandid)
        except:
            self.error(400);
            return

        conf = Configuration.get_by_id("singleton")
        if user not in conf.users:
            conf.users.append(user)
            # TODO: For now users are authenticated by default.  This should
            # probably be a configuration parameter.
            conf.auth_users.append(user)
            conf.put()
        ranking_query = SongNode.query().order(-SongNode.vote_cnt)
        ranking_query = ranking_query.filter(SongNode.vote_cnt < conf.votes_to_graduate)
        songs = ranking_query.fetch(50)

        template_values = {
            'is_admin': conf.admin == user,
            'songs': songs,
            'band_name': conf.name,
            'bandid': bandid,
            'logout_uri': users.create_login_url(self.request.uri),
            'votes_to_graduate': conf.votes_to_graduate
        }

        template = JINJA_ENVIRONMENT.get_template('ranking.html')
        self.response.write(template.render(template_values))
示例#3
0
    def get(self):

        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)
            url_linktext = 'Login'
            return self.redirect(users.create_login_url(self.request.uri))

        locations = OwnerLocations.all().filter('owner = ', users.get_current_user())

        user=users.get_current_user()
        if locations.count() == 0:
            locations = {}

        message_body = """
          Welcome to the miingle app
        """
        mail.send_mail(
              sender='*****@*****.**',
              to='*****@*****.**',
              subject='welcome to miingle',
              body=message_body)

        template_values = {
            'locations': locations,
            'userdisplay' : user.nickname(),
            'url': url,
            'url_linktext': url_linktext,
        }

        path = os.path.join(os.path.dirname(__file__), 'searchlocations.html')
        self.response.out.write(template.render(path, template_values))
示例#4
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)
示例#5
0
 def get(self):
   continue_url = self.request.GET.get('continue')
   openid_url = self.request.GET.get('openid')
   if openid_url:
     self.redirect(users.create_login_url(continue_url, None, openid_url))
   else:    
     self.redirect(users.create_login_url(continue_url, None, federated_identity='https://openid.nus.edu.sg/'))
示例#6
0
文件: main.py 项目: skid/fofou
  def get(self):
    forum = Forum.from_url(self.request.path_info)
    user = users.get_current_user()
    is_admin = users.is_current_user_admin()
    
    if not forum or (forum.is_disabled and not is_admin):
      return self.redirect("/")
    
    if not is_admin and not self.settings.check_ip(self.request.remote_addr):
      return self.response.out.write('Your IP address has been banned')

    if not is_admin and not self.settings.check_user( user ):
      return self.redirect( users.create_login_url("/") )

    offset, topics = Topic.getlist(forum, is_admin=is_admin, offset=self.request.get("from") or None)
    for topic in topics:
      topic.excerpt = Post.gql("WHERE topic = :1 ORDER BY created_on", topic)[0].get_excerpt()

    tvals = {
      'user': user,
      'analytics_code': forum.analytics_code or "",
      'siteurl': self.request.url,
      'isadmin': is_admin,
      'forum' : forum,
      'forum_urls': [f.url for f in Forum.all()],
      'topics': topics,
      'offset': offset,
      'login_url': users.create_login_url(forum.root()),
      'logout_url': users.create_logout_url(forum.root())
    }

    self.template_out("skins/default/topic_list.html", tvals)
示例#7
0
文件: main.py 项目: romaklimenko/ping
	def get(self):
		if not users.get_current_user():
			self.redirect(users.create_login_url(self.request.uri))
		
		query = UrlItem.all()
		query.filter("owner =", users.get_current_user())
		query.order("-date")
		url_items = query.fetch(10)

		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)
			url_linktext = 'Login'

		template_values = {
			'current_user': users.get_current_user(),
			'url_items': url_items,
			'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))
示例#8
0
    def get(self):
        user = users.get_current_user()
        if user:
            all_clients_query = Clients.all()
            all_clients = all_clients_query.fetch(100)
            services_query = Services.all()
            # TODO: make the filter below work, and 
            # add UI to disable services
            #services_query.filter('active =', 'True')
            services = services_query.fetch(100)
            k = db.Key(self.request.get('clientkey'))
            clients_query = Clients.all()
            clients_query.filter('__key__ = ', k)
            client = clients_query.fetch(1)
            
            time_query = Time.all()
            time_query.filter('client =', k)
            time_query.order('-project')
            times = time_query.fetch(100)

            projects_query = Projects.all()
            projects_query.filter('client =', k)
            projects = projects_query.fetch(100)
            

            statuses = ["draft", "invoiced", "paid", "sent", "deleted"]
            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)
                url_linktext = 'Login'
            template_values = {
                'statuses': statuses,
                'title': settings.APP['title'],
                'author': settings.APP['author'],
                'times': times,
                'allclients': all_clients,
                'client': client,
                'foo': projects,
                'businessname': client[0].business,
                'services': services,
                'projectkeys': projects,
                'clientname': self.request.get('clientname'),
                'clientkey': self.request.get('clientkey'),
                'url': url,
                'url_linktext': url_linktext,
                }
            path = os.path.join(os.path.dirname(__file__), 
                                'views/projects.html')
            self.response.out.write(template.render(path, template_values))
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'
            template_values = {
                'url': url,
                'url_linktext': url_linktext,
            }
            path = os.path.join(os.path.dirname(__file__), 'views/index.html')
            self.response.out.write(template.render(path, template_values))
示例#9
0
    def _handler(self, expense_key, post=False):
        user = users.get_current_user()

        if user:
            instance = Transaction.get(expense_key)
            if instance.user != user:
                self.redirect(users.create_login_url(self.request.uri))

            if post:
                form = IncomeForm(user, instance=instance, data=self.request.POST)
                if form.is_valid():
                    transaction = form.save(commit=False)
                    transaction.account = transaction.customer.account
                    transaction.put()
                    self.redirect("/receitas/")

            form = IncomeForm(user, instance=instance)
            path = os.path.join(os.path.dirname(__file__), 'templates/income.html')
            self.response.out.write(template.render(path, {
                'form': form,
                'user': user,
                'logout_url': users.create_logout_url("/")
            }))
        else:
            self.redirect(users.create_login_url(self.request.uri))
示例#10
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
示例#11
0
    def get(self):
        template = jinja_environment.get_template('templates/supplement-info.html')
        name = self.request.get('name')
        company = CompanyInfo.query().filter(CompanyInfo.company_name == name).fetch()[0]
        stringOfQuestions = company.required_supplement
        listOfQuestions = stringOfQuestions.split("?")
        listOfSupplements = [];
        for sentence in listOfQuestions:
            if sentence != "":
                newSentence = sentence + "?"
                logging.info(newSentence)
                logging.info(sentence)
                logging.info(stringOfQuestions)
                listOfSupplements.append(newSentence)

        user = users.get_current_user()
        if user:
            user_id = user.user_id()
            greeting = ('<a href="%s">Sign out!</a>.' %
                    users.create_login_url('/'))
        else:
            greeting = ('<a id="login" href="%s">Sign in with your gmail account!</a>.' %
                users.create_login_url('/'))

        template_list = {"listOfSupplements" : listOfSupplements, "login" : greeting}
        self.response.write(template.render(template_list))
示例#12
0
文件: main.py 项目: abhimir/dropmocks
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,
    }
示例#13
0
文件: main.py 项目: abhimir/dropmocks
  def get(self):
    user = users.get_current_user()
    if user:
      # Use existing user or generate a new one if they don't exist.
      owner = Owner.gql("WHERE user_id = :1", user.user_id()).get()
      if not owner:
        owner = Owner()
      owner.name = user.nickname()
      owner.email = user.email()
      owner.user_id = user.user_id()
      owner.hobo_id = ''
      owner.put()

      # Migrate not-signed-in mocks to account.
      old_owner = None
      if 'hobo_id' in self.request.cookies:
        old_owner = Owner.gql("WHERE hobo_id = :1", self.request.cookies['hobo_id']).get()
      if old_owner and owner != old_owner:
        mocklists = MockList.gql("WHERE owner = :1", old_owner).fetch(1000)
        for mocklist in mocklists:
          mocklist.owner = owner
          mocklist.put()
        old_owner.delete()

      if self.request.get("d"):
        self.redirect(self.request.get("d"))
      else:
        self.redirect("/")
    else:
      users.create_login_url("/signin/")
示例#14
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);
示例#15
0
def checkAuth(self): 
  user = users.get_current_user()
  if not user:
    self.redirect(users.create_login_url(self.request.uri))
  else:
    if not (user.email() == "*****@*****.**" or user.email() == "*****@*****.**"):
      self.redirect(users.create_login_url(self.request.uri))
示例#16
0
  def get(self):
    #get user and login
    usr = users.get_current_user()
    if not usr:
      url = users.create_login_url(self.request.uri)
      url_linktext = 'Login'
      self.redirect(users.create_login_url(self.request.uri))
    else:
      url = users.create_logout_url(self.request.uri)
      url_linktext = 'Logout'

      #get the client key to start a channel
      key = self.request.get('client_key')
      if not key:
        key = usr.email()

      #create token to use on channel with client
      token = channel.create_channel(str(key))

      #send template values
      template_values = {'user': usr,
                         'token': token,
                         'client_key': key,
                         'url': url,
                         'url_linktext': url_linktext,
                        }
      template = JINJA_ENVIRONMENT.get_template('index.html')
      self.response.write(template.render(template_values))
示例#17
0
  def get(self):
 
    #login
    usr = users.get_current_user()
    if not usr:
      url = users.create_login_url(self.request.uri)
      url_linktext = 'Login'
      self.redirect(users.create_login_url(self.request.uri))
    else:
      url = users.create_logout_url(self.request.uri)
      url_linktext = 'Logout'
      
      #testing users deb model
      userlist = User.query().fetch(5)
      
      #get files from bucket for the user
      bucket_name = "/"+os.environ.get('BUCKET_NAME',app_identity.get_default_gcs_bucket_name())+"/"+str(usr)
      l_files=gcs.listbucket(bucket_name)

      #get shared files of the user
      sh_files = SharedFile.query(SharedFile.recipients == usr.email())
      result = sh_files.fetch(1000)

      template_values = {
        'url': url,
        'url_linktext': url_linktext,
        'user_name': usr,
        'files': l_files,
        'users': userlist,
        'shared_files': sh_files,
      }

      template = JINJA_ENVIRONMENT.get_template('index.html')
      self.response.write(template.render(template_values))
示例#18
0
    def get(self):


        if users.get_current_user():


            staff = (str(users.get_current_user().email()))
            #check if user is admin method goes here
            domain = re.search("(?<=@)[\w.]+", staff)
            mydomain = domain.group()

            if mydomain == 'intellisoftplus.com':

                url = "https://crm.zoho.com/crm/private/json/Leads/getRecords?authtoken=b72f0f5ed3d2afa9b8a314649d3cf66f&scope=crmapi"
                response = urllib.urlopen(url)
                leads = json.loads(response.read())


                url_accounts = "https://crm.zoho.com/crm/private/json/Accounts/getRecords?authtoken=b72f0f5ed3d2afa9b8a314649d3cf66f&scope=crmapi"
                response_accounts = urllib.urlopen(url_accounts)
                accounts = json.loads(response_accounts.read())


                template_values = {
                    'leads':leads,
                    'accounts':accounts
                }
                template = jinja2_env.get_template('main/records.html')
                self.response.out.write(template.render(template_values))

            else:
                    self.redirect(users.create_login_url(self.request.uri))

        else:
            self.redirect(users.create_login_url(self.request.uri))
示例#19
0
    def get(self):


        if users.get_current_user():


            staff = (str(users.get_current_user().email()))
            #check if user is admin method goes here
            domain = re.search("(?<=@)[\w.]+", staff)
            mydomain = domain.group()

            if mydomain == 'intellisoftplus.com':

                url = "https://books.zoho.com/api/v3/customerpayments?authtoken=640df7b6237bec6ccc0101aec2a1605d&organization_id=8470645"
                response = urllib.urlopen(url)
                data = json.loads(response.read())

                url_invoice = "https://books.zoho.com/api/v3/invoices?authtoken=640df7b6237bec6ccc0101aec2a1605d&organization_id=8470645"
                response_invoice = urllib.urlopen(url_invoice)
                data_invoice = json.loads(response_invoice.read())


                template_values = {
                    'data':data,
                    'data_invoice':data_invoice
                }
                template = jinja2_env.get_template('main/zbooks.html')
                self.response.out.write(template.render(template_values))

            else:
                    self.redirect(users.create_login_url(self.request.uri))

        else:
            self.redirect(users.create_login_url(self.request.uri))
  def testMakeStaticHandler(self):
    dummy_template = object()
    dummy_path = object()
    dummy_url = object()
    handler_class = base.MakeStaticHandler(dummy_template)
    handler = handler_class()
    handler.request = self.mox.CreateMockAnything()
    handler.request.path = dummy_path
    self.mox.StubOutWithMock(users, 'get_current_user')
    self.mox.StubOutWithMock(users, 'create_login_url')
    self.mox.StubOutWithMock(handler, 'RenderTemplate')
    self.mox.StubOutWithMock(handler, 'redirect')

    # Logged in; render.
    users.get_current_user().AndReturn(True)
    handler.RenderTemplate(None, '', dummy_template, {})

    # Not logged in; redirect.
    users.get_current_user().AndReturn(None)
    users.create_login_url(dummy_path).AndReturn(dummy_url)
    handler.redirect(dummy_url)

    self.mox.ReplayAll()
    handler.get()
    handler.get()
示例#21
0
    def get(self):

        if users.get_current_user():


            staff = (str(users.get_current_user().email()))
            #check if user is admin method goes here

            if validate_staff_email(staff):

                url_invoice = "https://books.zoho.com/api/v3/invoices?authtoken=640df7b6237bec6ccc0101aec2a1605d&organization_id=8470645"
                invoices = []
                try:
                    response_invoice = urllib.urlopen(url_invoice)
                    data_invoice = json.loads(response_invoice.read())
                    present_keys = []
                    for invoice in data_invoice['invoices']:
                        name = invoice['customer_name']
                        if name not in present_keys:
                            present_keys.append(name)
                            invoices.append(invoice)
                except IOError:
                    pass

                template_values = {
                    'data_invoice':invoices,
                    'logout': users.create_logout_url(self.request.uri)
                }
                template = jinja2_env.get_template('main/customerinfo.html')
                self.response.out.write(template.render(template_values))
            else:
                self.redirect(users.create_login_url(self.request.uri))

        else:
            self.redirect(users.create_login_url(self.request.uri))
 def handle_openid(self, continue_url=None, openid_url=None):
     if openid_url:
         self.redirect(users.create_login_url(continue_url, None,
             openid_url))
     else:
         self.response.out.write(template.render(
             'templates/login.html', { 'google_url': users.create_login_url(federated_identity=providers.get('Google')) }))
示例#23
0
    def get(self):
        #user_param = self.request.get('user_param')

        #if (user_param == 'admin'):
        user = users.get_current_user()
        if user:
            if users.is_current_user_admin():
                logout_url = users.create_logout_url(self.request.uri)
                logout = 'Welcome! (<a href="{}">sign out</a>)'.format(logout_url)

                to_confirm = Startup.query(Startup.accettato == 0)
                to_confirm_list = to_confirm.fetch()
                confirm_param = {
                    'to_confirm_list': to_confirm_list,
                    'logout': logout,
                }
                template = JINJA_ENVIRONMENT.get_template('confirm.html')
                out = template.render(confirm_param)
            else:
                login_url = users.create_login_url(self.request.uri)
                out = '<html><body><a style="color: #428bca; text-decoration: none;" href="{}">SIGN IN</a></body></html>'.format(login_url)

        else:
            login_url = users.create_login_url(self.request.uri)
            out = '<html><body><a style="color: #428bca; text-decoration: none;" href="{}">SIGN IN</a></body></html>'.format(login_url)
        
        self.response.write(out)
示例#24
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)
示例#25
0
    def get(self):
        user = users.get_current_user()
        url = users.create_login_url(self.request.uri)
        url_linktext = 'Login'
                    
        if user:
            url = users.create_logout_url(self.request.uri)
            url_linktext = 'Logout'
        else:
            self.redirect(users.create_login_url(self.request.uri))
# GQL is similar to SQL
       
        
        id = self.request.get('id')
        selectionsview = SelectionSujetModel.getSelectionByEspaceID(id)
            
            
        
        values = {
            'selections' : selectionsview,
            
	    'id':id,
           
            'user': user,
            'url': url,
            'url_linktext': url_linktext,
        }
        self.response.out.write(template.render('templates/selectionsujet.html', values))           
示例#26
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)
示例#27
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)
示例#28
0
    def test_switch_to_same_account(self):
        gcu = 'djangae.contrib.gauth.middleware.users.get_current_user'
        final_destination = '/death/'
        switch_accounts_url = get_switch_accounts_url(next=final_destination)
        any_url = '/_ah/warmup'
        jekyll = users.User(email='*****@*****.**', _user_id='1')

        with sleuth.switch(gcu, lambda: jekyll):
            response = self.client.get(any_url)
            # Check that the user is logged in
            expected_user_query = GaeDatastoreUser.objects.filter(username=jekyll.user_id())
            self.assertEqual(len(expected_user_query), 1)

            self.assertEqual(int(self.client.session['_auth_user_id']), expected_user_query[0].pk)
            # Call switch_accounts view, which should give a redirect to login url
            response = self.client.get(switch_accounts_url, follow=False)
            self.assertEqual(response.status_code, 302)
            self.assertEqual(response['location'], users.create_login_url(switch_accounts_url))
            # Assume the user is signed in to one account, so it should redirect to logout url
            response = self.client.get(switch_accounts_url)
            self.assertEqual(response.status_code, 302)
            self.assertEqual(
                response['location'],
                users.create_logout_url(users.create_login_url(switch_accounts_url))
            )
            # Now the user decides against switching accounts and comes back with the same account
            response = self.client.get(switch_accounts_url)
            redirect_path = urlparse(response['location']).path
            self.assertEqual(redirect_path, final_destination)
            expected_user_query = GaeDatastoreUser.objects.filter(username=jekyll.user_id())
            self.assertEqual(len(expected_user_query), 1)
            self.assertEqual(int(self.client.session['_auth_user_id']), expected_user_query[0].pk)
示例#29
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)
示例#30
0
文件: scripts.py 项目: tonyin/chifx
def check_user(view):
    c_user = users.get_current_user()
    if c_user:
        log = users.create_logout_url(url_for('index'))
    else:
        if view[0] in ('security'):
            log = users.create_login_url(url_for(view[0], pos=view[1]))
        elif view[0] in ('sec_info', 'edit_security'):
            log = users.create_login_url(url_for(view[0], pos=view[1], sec_id=view[2]))
        else:
            log = users.create_login_url(url_for(view[0]))
    
    # Create a new portfolio if new user
    if c_user:
        ptfs = Portfolio.query(Portfolio.user == c_user)
        ptfs = list(ptfs)
        if len(ptfs) == 0:
            ptf = Portfolio(
                user = c_user,
                points = START_POINTS
            )
            ptf.put()
            ptf_id = ptf.key.id()
            flash(u'Portfolio %s successfully created.' % ptf_id, 'success')
    
    return [c_user, log]
示例#31
0
 def get(self):
     return self.render("login.html",
                        googleurl=users.create_login_url("/profile"))
    def post(self):
        for blob_info in self.get_uploads():
            if not users.get_current_user():
                #if they are not logged in then delete all the upload data and redirect them to login
                for blob in self.get_uploads():
                    blob.delete()
                self.redirect(users.create_login_url("/"))
                return

            #if uploading a csv file, update the datastore to match records in file
            if blob_info.content_type == "application/vnd.ms-excel":
                blobdata = blobstore.BlobReader(blob_info)
                reader = csv.DictReader(blobdata, dialect='excel')
                self.response.headers['Content-Type'] = 'text/plain'

                for row in reader:
                    artist = row["Artist"]
                    categories = row["Categories"]
                    name = row["Name of Piece"]
                    price = row["Price($)"]
                    itemNumber = row["Item Number"]
                    width = row["Width(in)"]
                    height = row["Height(in)"]
                    depth = row["Depth(in)"]
                    weight = row["Weight"]
                    width = row["Width(in)"]
                    description = row["Product Description"]
                    colors = row["Colors"]
                    mediums = row["Mediums"]
                    masterNum = row["Master Art Piece (Item Number)"]
                    pictureName = row["Picture Name"]

                    #check if artpiece with this item number already exists
                    qry = ArtPiece.query(ArtPiece.itemNumber == itemNumber)
                    existingArtPiece = qry.get()

                    #if existingArtPiece:
                    #if an artpiece with that itemNumber is already stored then update the record with the new information

                #delete and skip to the next file, we don't save excel files nor do we perform photo related code
                blob_info.delete()
                continue

            #otherwise we assume it is a photo (since it only allows jpg, png, gif, and csv)
            else:
                #check to see if a photo with that name already exists
                qry = File.query(File.file_name == blob_info.filename.upper())
                existingPhoto = qry.get()

                if existingPhoto:
                    #if a file with that name is already stored then replace the blob with the new uploaded file
                    blobstore.delete(existingPhoto.blob)
                    existingPhoto.blob = blob_info.key()
                    existingPhoto.uploaded_by = users.get_current_user()
                    existingPhoto.thumbnail = images.get_serving_url(
                        blob_info.key(), size=200)
                    existingPhoto.url = images.get_serving_url(blob_info.key())

                    existingPhoto.put()
                else:
                    #add a new file entry if no file with that name already exists
                    file = File(blob=blob_info.key(),
                                file_name=blob_info.filename.upper(),
                                uploaded_by=users.get_current_user(),
                                url=images.get_serving_url(blob_info.key()),
                                thumbnail=images.get_serving_url(
                                    blob_info.key(), size=200))
                    file.put()

                self.redirect("/admin/photos/%s/success" % blob_info.key())
示例#33
0
 def get(self, identity):
     url = users.create_login_url(dest_url='/', federated_identity=identity)
     self.redirect(url)
示例#34
0
文件: blog.py 项目: genelee/anzu
 def get_login_url(self):
     return users.create_login_url(self.request.uri)
示例#35
0
    def get(self):
        # データブックの名前を取得
        databook_name = get_databook_name(self.request.get('db'))
        # データブックの表示タイトルを取得
        databook_title = get_databook_title(self.request.get('db'))
        # 全文検索用インデックスの名前を取得
        databook_indexname = get_databook_indexname(self.request.get('db'))
        # 表示メッセージの初期化
        message_data = ''

        # 管理者ログインのチェック
        admin_login = False
        if users.is_current_user_admin():
            admin_login = True

        # 管理者ログイン中の表示
        admin_message = ''
        if users.get_current_user():
            if admin_login:
                admin_message = '(管理者としてログインしています)'
            else:
                admin_message = '(管理者ではありません)'

        # ログイン/ログアウトURL設定
        if users.get_current_user():
            login_url = users.create_logout_url(self.request.uri)
            login_text = '[ログアウト]'
        else:
            login_url = users.create_login_url(self.request.uri)
            # login_text = '[ログイン]'
            login_text = '[管理]'

        # 書き込み禁止の判定
        write_disabled_message = ''
        if not capabilities.CapabilitySet('datastore_v3',
                                          ['write']).is_enabled():
            write_disabled_message = '【現在書き込みは禁止しています】'

        # 全文検索の単語を取得
        search_flag = False
        search_count = 0
        search_word = self.request.get('word').strip()
        # 全文検索の単語の先頭が「=」のときは特別扱い
        show_all_flag = False
        show_offset = 0
        if search_word.startswith('='):
            i = 1
            while i < len(search_word):
                ch = search_word[i]
                # 「*」のときは表示フラグを無視して全て表示する
                if ch == '*':
                    i += 1
                    show_all_flag = True
                    continue
                # 数字のときは表示件数のオフセットとする
                if ch.isdigit():
                    i += 1
                    j = i - 1
                    while i < len(search_word):
                        ch = search_word[i]
                        if ch.isdigit():
                            i += 1
                            continue
                        break
                    k = i
                    if (k - j) > 5: k = j + 5
                    show_offset = int(search_word[j:k])
                    continue
                # その他のときは抜ける
                break
            search_word2 = search_word[i:]
        else:
            search_word2 = search_word
        # 全文検索の単語をチェック
        if search_word2:
            # 全文検索を行うとき
            articles = []
            # 検索結果を日付の降順でソートする指定
            expr_list = [
                search.SortExpression(
                    expression='date',
                    default_value=datetime.datetime.min,
                    direction=search.SortExpression.DESCENDING)
            ]
            # ソートオプションに設定する
            sort_opts = search.SortOptions(expressions=expr_list)
            # クエリーオプションに設定する
            # (表示件数指定、ソートオプション指定、検索結果はタイトルのみ取得)
            query_opts = search.QueryOptions(limit=mainpage_show_num,
                                             offset=show_offset,
                                             sort_options=sort_opts,
                                             returned_fields=['title'])
            try:
                # 単語とクエリーオプションを指定して全文検索実行
                query_obj = search.Query(query_string=search_word2,
                                         options=query_opts)
                search_results = search.Index(name=databook_indexname).search(
                    query=query_obj)
                # 検索結果から記事のタイトルを取得する
                req_titles = []
                for scored_doc in search_results:
                    req_titles.append(scored_doc.field('title').value)
                if len(req_titles) >= 1:
                    # 記事を検索(タイトルで表示件数まで)
                    if show_all_flag:
                        articles_query = Article.query(
                            Article.title.IN(req_titles),
                            ancestor=databook_key(databook_name)).order(
                                -Article.date)
                    else:
                        articles_query = Article.query(
                            Article.title.IN(req_titles),
                            Article.show_flag == 1,
                            ancestor=databook_key(databook_name)).order(
                                -Article.date)
                    articles = articles_query.fetch(mainpage_show_num)
            except (search.QueryError, search.InvalidRequest), e:
                # クエリーエラーのとき
                message_data = message_data + '(クエリーエラー:検索文字列に記号が含まれると発生することがあります)'
            search_flag = True
            search_count = len(articles)
示例#36
0
                if self.errorMsg is not '':
                    self.set_cookie('error', str(self.errorMsg))

                self.response.out.write(json.dumps(material))
            elif self.request.get('unit'):
                material = self.get_material(
                    int(self.request.get('unit')),
                    self.request.get('stage') == 'review')
                self.response.out.write(material)
            elif self.request.get('recent'):
                disciple = Disciple.get_current(user)
                material = self.dictionary.prepare_for_quiz(
                    json.loads(disciple.recent_mastered))
                self.response.out.write(json.dumps(material))
        else:
            self.redirect(users.create_login_url(self.request.uri))

    def get_material(self, unitIndex, isCumulative):
        stuff = LESSONS[unitIndex]["quiz"]
        if (isCumulative and unitIndex > 0):
            stuff = LESSONS[unitIndex]["quiz"]
            for i in reversed(range(0, unitIndex)):
                stuff = dict(stuff.items() + LESSONS[i]["quiz"].items())

        stuff = [int(i) for i in stuff.keys()]
        return stuff


app = webapp2.WSGIApplication([('/quiz/?', QuizPage),
                               ('/quiz/data', QuizData)],
                              debug=True)
示例#37
0
    def get(self):

        user = users.get_current_user()
        if user:
            log_out_url = users.create_logout_url("/")
            coach = Coach.all().filter("user ="******"schedule").split("-")

                if not season or not week:
                    season, week = misc.get_ofl_season_and_week()
                    season += 3
                else:
                    season = int(season)
                    week = int(week)

                parser = OFLScheduleParser()
                ofl_info = urlfetch.fetch(
                    "http://www.shalkith.com/bloodbowl/processSchedule.php?s=%s&w=%s"
                    % (season, week))
                parser.feed(ofl_info.content)
                update_schedule_entries(coach, season, week, parser.data)
                sort_wagers(coach, season, week)

                def logoA_getter(match):
                    html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
                        match.teamAlogo)
                    return html

                def logoB_getter(match):
                    html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
                        match.teamBlogo)
                    return html

                def nameA_getter(prediction):
                    match = OFL_Match.get_by_key_name(prediction.key().name())
                    html = "%s (%s)" % (match.teamA, match.teamAcoach)
                    return html

                def nameB_getter(prediction):
                    match = OFL_Match.get_by_key_name(prediction.key().name())
                    html = "%s (%s)" % (match.teamB, match.teamBcoach)
                    return html

                def key_name_getter(prediction):
                    return prediction.key().name()

                def choice_getter(prediction):
                    match = OFL_Match.get_by_key_name(prediction.key().name())
                    html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
                        match.teamAlogo)
                    if not match.gamePlayed:
                        html += "<input type='radio' name='%schoice' value='-1' %s>" % (
                            match.key().name(), prediction.isChecked(-1))
                        html += "<input type='radio' name='%schoice' value='0' %s>" % (
                            match.key().name(), prediction.isChecked(0))
                        html += "<input type='radio' name='%schoice' value='1' %s>" % (
                            match.key().name(), prediction.isChecked(1))
                    else:
                        html += "<input type='radio' name='%schoice' value='-1' disabled %s>" % (
                            match.key().name(), prediction.isChecked(-1))
                        html += "<input type='radio' name='%schoice' value='0' disabled %s>" % (
                            match.key().name(), prediction.isChecked(0))
                        html += "<input type='radio' name='%schoice' value='1' disabled %s>" % (
                            match.key().name(), prediction.isChecked(1))
                    html += "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
                        match.teamBlogo)
                    return html

                # Bypassing table.html Django template to create this table
                # Table requires Jquery code for sortable entires and wagers
                # Hidden input tags are also used with form.
                prediction_list = OFL_Prediction.all().filter(
                    "season =",
                    season).filter("week =", week).ancestor(coach).filter(
                        "gameScored =", False).order("-wager")
                columns = ["Wager", "Away Team", "Prediction", "Home Team"]
                table_html = []
                table_html.append('''
        <table class="ofl_pickem schedule_table">
        <thead>
            <tr>''')
                for column in columns:
                    table_html.append(
                        '<th style="text-align: center;"> %s </th>' % column)
                table_html.append('''
            </tr>
        </thead>
        <tbody id="sortable">''')
                k = 0
                for prediction in prediction_list:
                    table_html.append('<tr class="row_%s">' % k)
                    table_html.append(
                        '<input type="hidden" name="row_%s" value="%s">' %
                        (k, prediction.key().name()))
                    table_html.append(
                        "<input type='hidden' class='row_%s' name='%svalue' value='%s'>"
                        % (k, prediction.key().name(), prediction.wager))
                    table_html.append(
                        '<td class="row_%s" style="text -align: center;">%s</td>'
                        % (k, prediction.wager))
                    table_html.append(
                        '<td style="text-align: center;">%s</td>' %
                        nameA_getter(prediction))
                    table_html.append(
                        '<td style="text-align: center;">%s</td>' %
                        choice_getter(prediction))
                    table_html.append(
                        '<td style="text-align: center;">%s</td>' %
                        nameB_getter(prediction))
                    k += 1
                table_html.append('</tbody>\n</table>')
                table_html = "\n".join(table_html)

                played_table = Table(
                    columns=[
                        # profile
                        Column("Points", "Points Earned",
                               attrgetter("points")),
                        Column("Wager", "Wager Placed", attrgetter("wager")),
                        Column("Away Team",
                               "Away Team",
                               nameA_getter,
                               center=True),
                        Column("Prediction",
                               "Your Prediction",
                               choice_getter,
                               center=True),
                        Column("Home Team",
                               "Home Team",
                               nameB_getter,
                               center=True),
                    ],
                    query=OFL_Prediction.all().filter(
                        "season =",
                        season).filter("week =", week).ancestor(coach).filter(
                            "gameScored =", True).order("-points"),
                    id="played_table",
                    cls="tablesorter",
                )

        else:
            log_in_url = users.create_login_url("/")

        # render and update
        #--------------------------------------------------------------------#

        ofl_pickem_page = misc.render('ofl_pickem_box.html', locals())
        self.update(ofl_pickem_page)

        self.response.out.write(ofl_pickem_page)
示例#38
0
 def get(self):
     if users.get_current_user():
         self.redirect(users.create_logout_url('/'))
     else:
         self.redirect(users.create_login_url('/'))
示例#39
0
    def post(self):
        user = users.get_current_user()

        if not user:
            self.redirect(users.create_login_url(self.request.uri))

        # Cleanup any old movies that have timed out from all users
        self.cleanup()

        filename = self.request.headers['Content-Disposition']
        filename = re.search('^attachment; filename=\"([^\"]*)\"$',
                             filename).groups()[0]

        # Get what byte range we are dealing with
        byteRange = self.request.headers['Content-Range']
        matches = re.search('^bytes ([^\-]*)\-([^\/]*)\/(.*)$', byteRange)
        start = long(matches.group(1))
        end = long(matches.group(2))
        total = long(matches.group(3))

        # Get any location information
        geoAddress = None
        if self.request.get('geoAddress') != '':
            geoAddress = self.request.get('geoAddress')

        # Delete old completed entries that match this filename
        query = Movie.gql('WHERE filename = :1 AND owner = :2', filename, user)
        m = None
        if query.count() > 0:
            m = query[0]
            if m.length != None and m.bytes_uploaded != None and m.length == m.bytes_uploaded:
                db.delete(query)
                m = Movie(owner=user, filename=filename)

        # Get old partially uploaded data already saved
        query = Movie.gql('WHERE filename = :1 AND owner = :2 LIMIT 1',
                          filename, user)
        if query.count() == 1:
            m = query[0]

        # Will uploading this full file put the user over their quota?
        quotaUsed = total
        for entry in Movie.gql('WHERE owner = :1', user):
            if entry.filename != filename:
                quotaUsed += entry.length
        if quotaUsed >= self.TOTAL_QUOTA:
            self.error(413)  # 413 = Request Too Large
            return

        # If we are just starting, create an entry; else if
        # there is nothing in the database and we _aren't_
        # the first range chunk, return an error
        if m == None and start == 0:
            m = Movie(owner=user, filename=filename)
        elif m == None and start > 0:
            self.error(500)
            return

        # If there is something in the db, but our chunk is earlier than that
        # delete what is in the db
        if m != None and m.bytes_uploaded != 0 and start < m.bytes_uploaded:
            m.delete()
            m = Movie(owner=user, filename=filename)

        # Update Movie with new range and geographic information
        if m.blob != None:
            m.blob = db.Blob(m.blob + self.request.body)
        else:
            m.blob = db.Blob(self.request.body)
        m.length = total
        m.bytes_uploaded = end + 1
        m.geoAddress = geoAddress
        if m.bytes_uploaded == m.length:
            m.uploaded = True
        m.put()

        # Look at our total length so far for this file; if its greater than
        # ~20 megabytes reject and delete this movie
        if m.bytes_uploaded > self.MAX_FILE_SIZE:
            m.delete()
            self.error(413)  # 413 = Request Too Large
            return

        self.response.headers['Content-Type'] = 'text/plain'
        self.response.out.write('200 OK')
示例#40
0
    def get(self):

        login_template = the_jinja_env.get_template('templates/login.html')
        the_variable_dict = {"login_url": users.create_login_url('/')}

        self.response.write(login_template.render(the_variable_dict))
示例#41
0
def get_user(page):
    user = users.get_current_user()  # used for online use
    # user = users.User("*****@*****.**") # only used for local server
    if user: return user
    page.redirect(users.create_login_url(page.request.uri))
    return None
示例#42
0
 def build_url(self, request):
     from google.appengine.api import users
     url = users.create_login_url(redirect_to)
     return url
    def get(self):
        self.response.headers['Content-Type'] = 'text/html'

        # pull the current user from the Request
        user = users.get_current_user()
        tb_list = []
        tb_id_list = []
        tb_userslist = []
        invited_list = []

        user = users.get_current_user()

        if user == None:
            url_string = 'login'
            url = users.create_login_url(self.request.uri)
            template_values = {
                'url_string': url_string,
                'url': url,
                'login_url': users.create_login_url(self.request.uri)
            }

            template = JINJA_ENVIRONMENT.get_template('main.html')
            self.response.write(template.render(template_values))
            return

        url_string = 'logout'
        url = users.create_logout_url(self.request.uri)

        id = user.user_id()
        myuser_key = ndb.Key('MyUser', id)
        myuser = myuser_key.get()

        print(myuser.tb_key)

        for n in myuser.tb_key:
            tboard = n.get()
            #if tboard == None:
            #tboard = TaskBoard()
            #tboard.put()

            logging.info("Debug message")
            print(n)
            logging.info("END")

            #tb_list.append(tboard)
            #tb_id_list.append(tboard.key.id())

        query = MyUser.query(
            ndb.AND(MyUser.email_address != myuser.email_address))

        #for n in query:
        #logging.info("START message")
        #print(n.email_address)
        #logging.info("End message")

        #for n in myuser.tb_key:
        #logging.info("Debug message")
        #print(n.get().tbd_name)
        #logging.info("END")
        #tb_userslist.append(n.get().tbd_name)

        #for n in myuser.invited_tb_list:
        #TaskBoard = n.get()
        #invited_list.append(TaskBoard)
        #invited_list.append(n.get().tbd_name)

        template_values = {
            'myuser': myuser,
            'user': user,
            #'tb_list' : tb_list,
            #'tboard' : tboard,
            'url_string': url_string,
            'url': url,
        }

        # pull the template file and ask jinja to render
        # it with the given template values
        template = JINJA_ENVIRONMENT.get_template('viewtaskboard.html')
        self.response.write(template.render(template_values))
示例#44
0
 def loginurl(self, url):
     return self.redirect(users.create_login_url(url))
示例#45
0
 def decorated_view(*args, **kwargs):
     if users.get_current_user():
         if not users.is_current_user_admin():
             abort(401)  # Unauthorized
         return func(*args, **kwargs)
     return redirect(users.create_login_url(request.url))
示例#46
0
    def get(self):

        noDates = False
        errmsg = ''

        try:
            # get list of datetimes in DECENDING ORDER
            q = db.GqlQuery("SELECT DISTINCT tdate\
                            FROM systemData \
                            ORDER BY tdate DESC")

            # Container of unique dates
            dates = []

            # add most recent date first to the list
            latest = datetime.date(q.get().tdate)
            dates.append(latest)

            # check if any of the following dates already exist
            # in our list. the list of datetimes will have multiple
            # entries # of the same date but we want to have a list of
            # unique dates
            for p in q:
                # create date object
                newDate = datetime.date(p.tdate)

                if not (newDate == latest):
                    dates.append(newDate)
                    latest = newDate

        except:
            noDates = True
            errmsg = 'There\'s no data to download. Come back ' \
            'another time'

        user_name = active_user()
        active = False if (user_name == '') else True
        login = users.create_login_url(self.request.uri)

        template_values = {
            'user_name': user_name,
            'active_user': active,
            'login_url': login,
            'dates': dates,
            'noDates': noDates,
            'errmsg': errmsg
        }

        template = JINJA_ENVIRONMENT.get_template('/pages/downloads.html')
        self.response.write(template.render(template_values))

        # check if user submitted the download form
        down = cgi.escape(self.request.get('downloading'))

        if down == '1':

            # retrieve form arguments
            start = cgi.escape(self.request.get('startDate'))
            end = cgi.escape(self.request.get('endDate'))
            c = cgi.escape(self.request.get('checkbox'))

            #self.response.out.write( "1389979974")

            buf = self.fetch_data(c, start, end)

            # write download content into a buffer
            size = 56

            # clear all data written to the output stream
            self.response.clear()

            # set HTTP headers to notify server of download
            self.response.headers["Content-Type"] = "text/csv"
            self.response.headers["Cache-Control"] = "no-cache"
            self.response.headers[
                "Content-Disposition"] = "attachment; filename=kioskData.csv"
            self.response.headers["Content-Transfer-Encoding"] = "binary"
            self.response.headers["Pragma"] = "no-cache"
            self.response.write(buf)

        else:
            logging.info("No download\n")
示例#47
0
 def get(self):
     if users.get_current_user() is None:
         self.response.headers['Content-Type'] = 'text/plain'
         self.response.out.write('ok\n')
     else:
         self.redirect(users.create_login_url('/logout'))
示例#48
0
 def get(self, request):
     index = reverse('index')
     url = users.create_login_url(index)
     return HttpResponseRedirect(url)
示例#49
0
文件: main.py 项目: JanezVP/mail
    def get(self):
        login_url = users.create_login_url("/")

        params = {"login_url": login_url}
        return self.render_template("login.html", params=params)
示例#50
0
 def decorated_view(*args, **kwargs):
     if not users.get_current_user():
         return redirect(users.create_login_url(request.url))
     return func(*args, **kwargs)
示例#51
0
 def get(self):
     user = users.get_current_user()
     if not user:
         self.redirect(users.create_login_url(self.request.uri))
     else:
         self.redirect('/')
示例#52
0
def create_login_url(slug):
    """Creates a login url."""
    return users.create_login_url(slug)
示例#53
0
	def get(self):
		self.redirect(users.create_login_url())
示例#54
0
def signin_google():
    save_request_params()
    google_url = users.create_login_url(flask.url_for('google_authorized'))
    return flask.redirect(google_url)
    def get(self, stock_symbol):

        #make symbol all caps
        stock_symbol = stock_symbol.upper()

        # Checks for active Google account session
        user = users.get_current_user()

        #Only commit to ndb if we need to
        need_to_commit = False

        #Do we have a loged in user
        if user:

            #Get the users list of favorite stocks
            up = UserProfile.query(UserProfile.user_id == str(user.user_id()))

            # If new user, make profile
            if up.count() == 0:
                UserProfile(nickname=str(user.nickname()),
                            email=str(user.email()),
                            user_id=str(user.user_id()),
                            federated_identity=str(user.federated_identity()),
                            federated_provider=str(user.federated_provider()),
                            favorite_list=[]).put()
                up = UserProfile.query(
                    UserProfile.user_id == str(user.user_id()))
                need_to_commit = True
            else:
                for u in up:
                    #Update last login date
                    u.last_login_date = datetime.now()
                    #update user email if changed
                    if user.email != u.email:
                        u.email = str(user.email())
                        need_to_commit = True

            #optinal:Remove the stock if its in the list, otherwise add it
            for u in up:
                if stock_symbol != '':
                    need_to_commit = True
                    if stock_symbol in u.favorite_list:
                        u.favorite_list.remove(stock_symbol)
                    else:
                        u.favorite_list.append(stock_symbol)

            #commit the changes
            if need_to_commit:
                for u in up:
                    u.put()

            #return to where the user was
            if stock_symbol != '':
                try:
                    self.redirect(self.request.referer)
                except:
                    self.redirect('./')
        #no user
        else:
            #A non user tried to favorite something, lets log them in so they get the action still after login
            if stock_symbol != '':
                self.redirect(users.create_login_url(self.request.uri))

        #Form the symbol list to query
        queryList = []
        if user:
            for u in up:
                for item in u.favorite_list:
                    queryList.append(item)

        #Get the time, make a string of format:
        #Tue, Jan 6, 2014, 12:00AM EST - US MARKETS CLOSED
        now = datetime.now(tz=timezone('US/Eastern'))
        #Construct the EST time for the top of page
        if ((now.time() >= time(9, 30) and now.time() <= time(16, 30))
                and (now.weekday() <= 4)):
            timeString = "{0:s} EST  - US Markets Are Open".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        else:
            timeString = "{0:s} EST  - US Markets Are Closed".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        #

        stockList = Forecast.query(Forecast.symbol.IN(queryList)).order(
            Forecast.rank)

        #prevent empty query from causing crashes
        if len(queryList) == 0:
            stockList = []

        #Get computed values
        if len(queryList) != 0:
            computedCloseValues = np.zeros((stockList.count(), 2), float)
        else:
            computedCloseValues = np.zeros((0, 2), float)
        i = 0
        if len(queryList) != 0:
            for stock in stockList:
                #computedCloseValues[i][0] = stock.forecastedPrice-stock.currentPrice
                #computedCloseValues[i][1] = (stock.forecastedPrice-stock.currentPrice)/abs(stock.currentPrice)*100.0
                computedCloseValues[i][
                    0] = stock.closePredPrice[-1] - stock.closePriceHistory[-1]
                computedCloseValues[i][1] = (
                    stock.closePredPrice[-1] - stock.closePriceHistory[-1]
                ) / abs(stock.closePriceHistory[-1]) * 100.0
                i += 1

        #Init items using info from forecast, just use the first item
        dayOfForecast = now.strftime("%A, %B %d %Y")
        dof = now
        #if stockList.count() > 0:
        for stock in stockList:
            dayOfForecast = stock.date.strftime("%A, %B %d %Y")
            #dof = forecast.date
            break
        #Form the login/logout url and a name to id the state in jinja2
        if user:
            url = users.create_logout_url(self.request.uri)
            url_linktext = 'Logout'
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'

        template_values = {
            'stock_list': stockList,
            'computed_values': computedCloseValues,
            #'forecast_count':forecastCount,
            'timeStr': timeString,
            'dayOfForecast': dayOfForecast,
            'url': url,
            'url_linktext': url_linktext,
        }

        #Show mystock page
        template = JINJA_ENVIRONMENT.get_template('mystocks.html')
        self.response.write(template.render(template_values))
示例#56
0
 def get(self, resource=''):
     admin_url = users.create_login_url("/blog")
     self.redirect(admin_url)
示例#57
0
def signin(ruri):
    try:
        from google.appengine.api import users
        return users.create_login_url(ruri)
    except:
        return None
    def get(self):

        #Get total nubmer of predictions
        #global_stat = stats.GlobalStat.query().get()
        #forecastCount = global_stat.count

        #Get the time, make a string of format:
        #Tue, Jan 6, 2014, 12:00AM EST - US MARKETS CLOSED
        now = datetime.now(tz=timezone('US/Eastern'))
        #Construct the EST time for the top of page
        if ((now.time() >= time(9, 30) and now.time() <= time(16, 30))
                and (now.weekday() <= 4)):
            timeString = "{0:s} EST  - US Markets Are Open".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        else:
            timeString = "{0:s} EST  - US Markets Are Closed".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        #

        stockList = StockList.query(StockList.rank.IN(list(np.arange(1, 26))))

        computedCloseValues = np.zeros((stockList.count(), 3), float)

        #createa  binary list of stock list vs user favorite list
        user = users.get_current_user()
        if user:
            up = UserProfile.query(UserProfile.user_id == str(user.user_id()))
            favBinary = []
            for u in up:
                for stock in stockList:
                    if stock.symbol in u.favorite_list:
                        favBinary.append(1)
                    else:
                        favBinary.append(0)
                break
            #case where user exists(like admin) but no profile yet
            if stockList.count() != len(favBinary):
                favBinary = np.zeros((stockList.count(), ))
        else:
            favBinary = np.zeros((stockList.count(), ))
        #

        i = 0
        for stock in stockList:
            computedCloseValues[i][
                0] = stock.forecastedPrice - stock.currentPrice
            computedCloseValues[i][1] = (stock.forecastedPrice -
                                         stock.currentPrice) / abs(
                                             stock.currentPrice) * 100.0
            computedCloseValues[i][2] = favBinary[i]
            i += 1

        #Init items using info from forecast, just use the first item
        dayOfForecast = now.strftime("%A, %B %d %Y")
        dof = now
        for stock in stockList:
            dayOfForecast = stock.date.strftime("%A, %B %d %Y")
            #dof = forecast.date
            break

        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)
            url_linktext = 'Sign Up for Updates'

        template_values = {
            'stock_list': stockList,
            'computed_values': computedCloseValues,
            #'forecast_count':forecastCount,
            'timeStr': timeString,
            'dayOfForecast': dayOfForecast,
            'url': url,
            'url_linktext': url_linktext,
        }

        template = JINJA_ENVIRONMENT.get_template('index.html')
        self.response.write(template.render(template_values))
示例#59
0
def createloginurl():
    return users.create_login_url('/')
    def get(self, stock_symbol):

        #Request the market and prepare its data for plotting

        #Reqest the stock and prepare its data for plotting
        #Get total nubmer of predictions
        #global_stat = stats.GlobalStat.query().get()
        #forecastCount = global_stat.count

        if stock_symbol == '':
            symbol_search = self.request.get("symbol_search")

        #Get the time, make a string of format:
        #Tue, Jan 6, 2014, 12:00AM EST - US MARKETS CLOSED
        now = datetime.now(tz=timezone('US/Eastern'))
        #Construct the EST time for the top of page
        if ((now.time() >= time(9, 30) and now.time() <= time(16, 30))
                and (now.weekday() <= 4)):
            timeString = "{0:s} EST  - US Markets Are Open".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        else:
            timeString = "{0:s} EST  - US Markets Are Closed".format(
                now.strftime("%a, %b %d %Y, %I:%M%p"))
        #

        #query to get the top 10 stocks for newest forecast round
        #stockList = Forecast.query(Forecast.rank.IN(list(np.arange(1,11))))
        stockList = Forecast.query(Forecast.symbol == stock_symbol.upper())

        #createa  binary list of stock list vs user favorite list
        user = users.get_current_user()
        if user:
            up = UserProfile.query(UserProfile.user_id == str(user.user_id()))
            favBinary = []
            for u in up:
                for stock in stockList:
                    if stock.symbol in u.favorite_list:
                        favBinary.append(1)
                    else:
                        favBinary.append(0)
                break
            #case where user exists(like admin) but no profile yet
            if stockList.count() != len(favBinary):
                favBinary = np.zeros((stockList.count(), ))
        else:
            favBinary = np.zeros((stockList.count(), ))
        #

        #3d array of the candlestick plots
        # stock, list of L, list of O, list of C, list of H, list of V
        #stocks, history, category
        forecastPlotData = np.zeros((stockList.count(), 10, 6), object)
        #3d array of the validation plots
        #Stocks, history, category
        validationPlotData = []
        #3d array of computed values nstock, 10
        computedValued = np.zeros((stockList.count(), 11), float)

        #Init items using info from forecast, just use the first item
        dayOfForecast = now.strftime("%A, %B %d %Y")
        dof = now
        for forecast in stockList:
            validationPlotData = np.zeros(
                (stockList.count(), len(forecast.lowPriceHistory), 10), object)
            dayOfForecast = forecast.date.strftime("%A, %B %d %Y")
            dof = forecast.date
            break

        i = 0
        for forecast in stockList:
            forecastPlotData[i, :, 0] = [
                x.encode('utf-8').replace("'", "")
                for x in forecast.dayOfPred[-10:]
            ]
            #forecastPlotData[i,-1,0]   = str(forecast.dayOfPred[-1]).replace("'","")#.encode('utf-8')#.replace('&#39;','')
            forecastPlotData[i, :-1, 1] = forecast.lowPriceHistory[-9:]
            forecastPlotData[i, -1, 1] = forecast.lowPredPrice[-1]
            forecastPlotData[i, :-1, 2] = forecast.openPriceHistory[-9:]
            forecastPlotData[i, -1, 2] = forecast.openPredPrice[-1]
            forecastPlotData[i, :-1, 3] = forecast.closePriceHistory[-9:]
            forecastPlotData[i, -1, 3] = forecast.closePredPrice[-1]
            forecastPlotData[i, :-1, 4] = forecast.highPriceHistory[-9:]
            forecastPlotData[i, -1, 4] = forecast.highPredPrice[-1]
            forecastPlotData[i, :-1, 5] = forecast.volumeHistory[-9:]
            forecastPlotData[i, -1, 5] = forecast.volumePred[-1]

            validationPlotData[i, :, 0] = forecast.openPriceHistory
            validationPlotData[i, :, 1] = forecast.openPredPrice[:-1]
            validationPlotData[i, :, 2] = forecast.closePriceHistory
            validationPlotData[i, :, 3] = forecast.closePredPrice[:-1]
            validationPlotData[i, :, 4] = forecast.highPriceHistory
            validationPlotData[i, :, 5] = forecast.highPredPrice[:-1]
            validationPlotData[i, :, 6] = forecast.lowPriceHistory
            validationPlotData[i, :, 7] = forecast.lowPredPrice[:-1]
            validationPlotData[i, :, 8] = forecast.volumeHistory
            validationPlotData[i, :, 9] = forecast.volumePred[:-1]

            computedValued[i][
                0] = forecast.openPredPrice[-1] - forecast.openPriceHistory[-1]
            computedValued[i][1] = (forecast.openPredPrice[-1] -
                                    forecast.openPriceHistory[-1]) / abs(
                                        forecast.openPriceHistory[-1]) * 100.0
            computedValued[i][2] = forecast.closePredPrice[
                -1] - forecast.closePriceHistory[-1]
            computedValued[i][3] = (forecast.closePredPrice[-1] -
                                    forecast.closePriceHistory[-1]) / abs(
                                        forecast.closePriceHistory[-1]) * 100.0
            computedValued[i][
                4] = forecast.highPredPrice[-1] - forecast.highPriceHistory[-1]
            computedValued[i][5] = (forecast.highPredPrice[-1] -
                                    forecast.highPriceHistory[-1]) / abs(
                                        forecast.highPriceHistory[-1]) * 100.0
            computedValued[i][
                6] = forecast.lowPredPrice[-1] - forecast.lowPriceHistory[-1]
            computedValued[i][7] = (forecast.lowPredPrice[-1] -
                                    forecast.lowPriceHistory[-1]) / abs(
                                        forecast.lowPriceHistory[-1]) * 100.0
            computedValued[i][
                8] = forecast.volumePred[-1] - forecast.volumeHistory[-1]
            computedValued[i][9] = (forecast.volumePred[-1] -
                                    forecast.volumeHistory[-1]) / abs(
                                        forecast.volumeHistory[-1]) * 100.0
            computedValued[i][10] = favBinary[i]
            #Count for filling arrays
            i += 1

        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)
            url_linktext = 'Sign Up for Updates'

        template_values = {
            'stock_list': stockList,
            'forecast_data': forecastPlotData,
            'validation_data': validationPlotData,
            'computed_values': computedValued,
            #'forecast_count':forecastCount,
            'timeStr': timeString,
            'dayOfForecast': dayOfForecast,
            'url': url,
            'url_linktext': url_linktext,
        }

        template = JINJA_ENVIRONMENT.get_template('symbol.html')
        self.response.write(template.render(template_values))