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

 def post(self):
   app_user = utils.get_current_user()
   
   if(self.request.get('nickname')):
     app_user.nickname = self.request.get('nickname')
   
   app_user.put()
   
   self.response.out.write(utils.status_code_json(200))

  def post(self):
    method = self.request.get("_method")
    key = utils.url_to_entity_key(self.request.uri)
    if key:
      playlist = db.get(db.Key(key))
      if playlist:
        current_user = utils.get_current_user()
    
        #Get corresponding link
        library_item = playlist.library_item_for_user(current_user)
    
        if method == "PUT":
          need_version_control = False
          playlist_changed = False
      
          if(self.request.get('position')): #Rights: Can always update this
            current_user.re_sort_playlists(library_item, int(self.request.get('position')))        

          if (playlist.collaborative or library_item.is_owner): #Rights: Owner or collaborators can update this
            if playlist.smart:
              utils.parse_smart_filters(playlist, self.request)
              playlist_changed = True
            if self.request.get('tracks'):
              playlist.tracks = self.request.get('tracks')
              playlist_changed = True

            need_version_control = playlist.collaborative

          if library_item.is_owner: #Rights: Only owner can update this
            if(self.request.get('name') and len(self.request.get('name')) > 0):
              playlist.name = utils.strip_html(self.request.get('name'))
              playlist_changed = True
            if(self.request.get('collaborative')):
              playlist.collaborative = utils.convert_javascript_bool_to_python(self.request.get('collaborative'))
              playlist_changed = True
      
          if playlist_changed:
            if need_version_control: 
              if self.request.get('version') and not int(self.request.get('version')) < playlist.version:
                playlist.version += 1
                playlist.put()
                self.response.out.write(utils.status_code_json(200))
              else:
                self.response.out.write(library_item.serialize())
            else:
              playlist.put()
              self.response.out.write(utils.status_code_json(200))
          else:
            self.response.out.write(utils.status_code_json(200))
            
        elif method == "DELETE":
          library_item.delete()
          current_user.re_index_playlists()
          if not playlist.has_user():
            playlist.delete()
          self.response.out.write(utils.status_code_json(200))

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

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

    return {
        'email': user.email.id() if user.email else '',
        'group': user.group.id()
    }

 def get(self, dir=None):
   user = get_current_user()
   if user is None:
       self.redirect('/login')
   else:
       template = jinja_environment.get_template('main.html')
       params = {"username":user.name, "logout": users.create_logout_url('/')}
       params['header'] = { 'stream':True }
       params['dir'] = dir
       self.response.out.write(template.render(params))

 def login(self):
     next_url = url_for('account.register')
     user = get_current_user()
     if user:
         oauth_info = get_oauth_by(oauth_type=self.name, uid=g.session['user_id'])
         if oauth_info:
             return redirect(request.referrer or url_for('index'))
         next_url = url_for('account.bind')
     callback = '%s%s' % (config.OAUTH_REDIRECT_DOMAIN, url_for('%s_oauth.authorized' % self.name))
     return self.oauth_obj.authorize(callback, next_url)