Python utils.get_current_user函数代码示例

def inject_global_template_variables():
    return dict(
        idle=status.idle,
        current_status=status.current_status,
        now_building=status.now_building,
        rev_pending=status.pending_review,
        user=get_current_user(),
        current_user=get_current_user(),
        _all_packages=status.all_packages,
        pkg_groups=status.package_groups,
    )

    def post(self):
        """ Changes the current users nickname """
        new_nickname = self.request.get('nickname')
        if not new_nickname:
            self.error(409)
            return
        new_nickname_lower = new_nickname.lower()

        user = utils.get_current_user()
        if not user:
            self.error(403)
            return

        if new_nickname != user.nickname:
            others = User.all().filter('nickname_lower =', new_nickname_lower).get()
            if others and others.key() != user.key():
                self.error(409)
                return
            user.nickname_lower = new_nickname_lower
            user.nickname = new_nickname
            user.save()

        self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
        self.response.headers['Access-Control-Allow-Origin'] = '*'
        self.response.out.write(json.dumps(user.to_struct()))

    def delete(self, title):
        """Delete the specified tag for the current user"""
        user = utils.get_current_user()
        
        title = title.decode('utf-8')
        
        if not user:
            self.error(403)
            return
            
        m = Tag.all().ancestor(user).filter('title_lower =', title.lower()).get()
        if not m:
            # Original tag not found
            self.error(404)
            return

        entries = Entry.all().filter('tags =', m.key())

        # Remove tag from entries
        for entry in entries:
            logging.info(entry)
            entry.tags.remove(m.key())
            entry.save()
        
        m.delete()

        self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
        self.response.headers['Access-Control-Allow-Origin'] = '*'
        self.response.out.write('ok')

 def get(self):
     """ Return info about current logged in user
     
     Automatically create internal user models for admin google users.
     """
     user = utils.get_current_user()
     
     if not user:
         google_user = users.get_current_user()
         
         if not google_user:
             self.error(403)
             return
         
         if users.is_current_user_admin():
             user = utils.create_user(google_user)
         else:
             self.error(401)
             return
     
     data = user.to_struct()
     data['is_admin'] = users.is_current_user_admin()
     
     self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
     self.response.headers['Access-Control-Allow-Origin'] = '*'
     self.response.out.write(json.dumps(data))

 def post(self):
     """Send an invitation mail to the provided email address"""
     
     user = utils.get_current_user()
     
     if not user:
         self.error(403)
         return
     
     email = self.request.get('email')
     token = uuid.uuid1().hex
     
     mail.send_invite_email(email, token)
 
     m = InviteToken(
         sender=user.key().id(),
         email=email,
         token=token
     )
     m.put()
     
     self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
     self.response.headers['Access-Control-Allow-Origin'] = '*'
     self.response.out.write(json.dumps({
         'message': 'An invitation email was sent to %s' % email,
         'email': email,
         'token': token,
     }))

 def put(self, id):
   self.response.headers['Content-Type'] = 'application/json'
   user = get_current_user()
   if user:
     url = self.request.get('url')
     title = self.request.get('title')
     description = self.request.get('description')
     id = int(self.request.get('id'))
     domain = reg.search(url)
     if domain:
       domain = domain.group()
       bookmark = Bookmark.get_by_id(id)
       if bookmark:
         if bookmark.user.email == user.email:
           bookmark.url=url
           bookmark.title=title
           bookmark.domain=domain
           bookmark.description=unicode(description)
           bookmark.changedate=int(time()*1000)
           bookmark.put()
           self.response.out.write(json.dumps({'status':'success', 'b':description, 'item':bookmark.to_dict()}))
         else:
           self.response.out.write(json.dumps({'status':'error', 'error_type':'Not allowed', "u1":bookmark.user.email, "u2":user.email}))
       else:
         self.response.out.write(json.dumps({'status':'error', 'error_type':'Bad id'}))
     else:
       self.response.out.write(json.dumps({'status':'error', 'error_type':'Bad link'})) 
   else:
     self.response.out.write(json.dumps({'status':'error', 'error_type':'Not authorized'})) 

 def get(self):
   google_user = users.get_current_user()
   app_user = utils.get_current_user()
   if google_user and not app_user:
     app_user = utils.init_new_user(google_user)
   
   self.response.out.write(template.render('player.html', {'user':app_user,'rando': random.random(), 'login_url': users.create_login_url("/"), 'logout_url':users.create_logout_url("/"), 'in_development_enviroment':utils.in_development_enviroment()}))

 def get_token(self):
     user = get_current_user()
     if user:
         oauth_info = get_oauth_by(oauth_type=self.name, uid=g.session['user_id'])
         if not oauth_info:
             return
         return oauth_info.oauth_token

def current_user():
    user = utils.get_current_user()

    if not user:
        return flask.Response(status=401)

    return user.to_dict()

    def handle_send_command(self, data, sender):
        ''' Handle send_command event.
            
            @type data: Packet
            @param data:  First packet of the communication.
            @type sender: utils.IPv4Address
            @param sender:  Sender IP address.
        '''
        # 1. packet
        (task_id, user, cmd) = send_command.parse_packet_1(data)

        if not user:
            user = utils.get_current_user()

        sudo_cmd = self.config.get_sudo_cmd()
        cmd = "%s -u '%s' %s" % (sudo_cmd, user, cmd)

        ### Create task
        task = Task(task_id, user, cmd)

        # 2. packet
        packet2 = send_command.make_packet_2()
        self.network.write(packet2, sender)

        ### Run task and add task to the running task list
        task.run()
        self.tasklist.add_task(sender, task)

        # 3. packet
        packet3 = send_command.make_packet_3(task.get_task_id())
        self.network.write(packet3, sender)

        # 4. packet
        packet4_data = self.network.read_from(sender)
        packet4 = send_command.parse_packet_4(packet4_data)

 def post(self, user_id, feed_id, entry_id):
     """Updates a specific entry"""
     current_user = utils.get_current_user()
     
     if not current_user:
         self.error(403)
         return
     
     user = User.get_by_id(int(user_id))
     
     if user == None:
         self.error(404)
         return
     
     if current_user.key() != user.key():
         self.error(401)
         return
     
     feed = InputFeed.get_by_id(int(feed_id), parent=user)
     
     if feed == None:
         self.error(404)
         return
     
     entry = Entry.get_by_id(int(entry_id), parent=feed)
     
     published = self.request.get('published')
     
     if published != None:
         entry.published = bool(int(published))
         entry.save()
     
     self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
     self.response.headers['Access-Control-Allow-Origin'] = '*'
     self.response.out.write(json.dumps(entry.to_struct()))

 def latest_issue(self):
     user = get_current_user()
     # Staff can see non-live issues
     if user and user.is_staff:
         return self.all()[0]
     # Otherwise, only show live issues
     return self.filter(is_live=True)[0]

 def post(self):
     """Creates a new feed for the logged in user"""
     user = utils.get_current_user()
     url = self.request.get('url')
     
     if not user:
         self.error(403)
         return
     
     feed = feedparser.parse(url)
     feed = feed.get('feed')
     
     id = feed.get('id')
     logo = feed.get('gd_image', {'src': '/img/rss-placeholder.png'}).get('src')
     title = feed.get('title')
     link = feed.get('link')
     
     m = InputFeed(
         parent=user,
         logo=logo,
         url=url,
         title=title,
         link=link,
     )
     
     m.put()
     m.fetch_entries(fetch_all=True)
     
     self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
     self.response.headers['Access-Control-Allow-Origin'] = '*'
     self.response.out.write(json.dumps(m.to_struct()))

 def get(self):
   self.response.headers['Content-Type'] = 'application/json'
   user = get_current_user()
   if user:
     self.response.out.write(json.dumps(user.to_dict()))
   else:
     self.response.out.write(json.dumps({'status':'error', 'error_type':'Not authorized'})) 

def add_comment(**kwargs):
    start=0
    end=DEFAULT_ITEMS
    post=Post.objects.get(id=kwargs['post_id'])
    user=get_current_user()
    comment=Comment(author=user,post=post,content=kwargs['content'])
    comment.save()
    comments=[obj for obj in Comment.objects(post=post)[start:end]]
    return comments