def _q_index(self):
     cookie = get_cookie('user')
     if cookie == 'Peter':
         this_session = get_session()
         this_session.set_user('Peter')
     if not get_user():
         body = Template.Kind_Body % (Template.Kind_Top,"Not Login!","")
         html = Template.HTML % ("Not login!",body)
         return html
     get_response().set_cookie('user','Peter',path='/',expires="Thu 01-Jan-2020 00:00:00 GMT")
     sql = """SELECT * FROM kind"""
     count,res = execute_sql_in_4bbs(sql,"SHOW")
     list = ""
     for e in res:
         list += "<div>"
         list += "Kind_id:<span>" + str(e[0]) + "</span><span>----</span>"
         list += "Kind_name:<span>" + str(e[1]) + "</span><span>----</span>"
         list += "Kind_count:<span>" + str(e[2]) + "</span><span>----</span>"
         list += "Kind_shortname:<span>" + str(e[3]) + "</span><span>----</span>"
         list += '<a href="/kind/delete?kind_id=' + str(e[0]) + '">Delete</a><span>----</span>'
         list += '<a href="/kind/edit?kind_id=' + str(e[0]) + '">Edit</a>'
         list += "</div>"
     body = Template.Kind_Body %(Template.Kind_Top,list,"")
     html = Template.HTML % ("Kind Index",body)
     return html 

    def _q_lookup(self, component):
        if component == 'all':
            snooper = rss.PackageSnooper(self.package, register=False)
        elif component == 'failed':
            snooper = rss.PackageSnooper(self.package, only_failures=True,
                                         register=False)
#        elif component == 'no_recent_build':
#            pass
        else:
            response = quixote.get_response()
            response.set_status(404)
            return "No such feed"

        package_url = urls.base_url + '/' + urls.package_url_template
        per_result_url = urls.base_url + '/' + urls.per_result_url_template
        source_url = urls.base_url + '/rss2/_generic/%s/%s' % \
                     (self.package, component)

        xml = snooper.generate_rss(self.coord, package_url, per_result_url,
                                   source_url=source_url)

        response = quixote.get_response()
        response.set_content_type('text/xml')
        
        return xml

 def create_account(self):
     request = quixote.get_request()
     user = request.form['username']
     password = request.form['password']
     account = Account(user, password)
     if accountmanager.exists_username(user):
         return self.account_name_taken()
     accountmanager.add_account(account)
     quixote.get_response().set_cookie('user', user, path='/')
     return quixote.redirect('./')

 def _set_cookie(self, value, **attrs):
     config = get_publisher().config
     name = config.session_cookie_name
     if config.session_cookie_path:
         path = config.session_cookie_path
     else:
         path = get_request().get_environ('SCRIPT_NAME')
         if not path.endswith("/"):
             path += "/"
     domain = config.session_cookie_domain
     get_response().set_cookie(name, value, domain=domain,
                               path=path, **attrs)
     return name

 def add_comment(self):
     response = quixote.get_response()
     request = quixote.get_request()
     number = request.form['id']
     comment = request.form['comment']
     image.add_comment(number, comment)
     return quixote.redirect('./image?id='+str(number))

    def _q_index(self, request):
        """ Returns the raw data of a Picture """
        request = quixote.get_request()
        response = quixote.get_response()

        p = self.pic()
        
        if not self.collection.mayViewOrig(p):
            raise AccessError('You may not view this original image')

        etag = self.etag('orig')

        response.buffered = False
        response.set_content_type(p.mimetype)
        response.set_header('Content-Disposition',
                            'inline; filename="%d-orig.%s"' % \
                            (self.id, ImageTransform.extmap[p.mimetype]))
        response.set_header('Content-MD5',
                            p.md5hash.decode('hex').encode('base64')[:-1])
        response.set_header('ETag', etag)

        if self.if_none_match(etag):
            response.set_status(304)    # not modified
            return ''

        return Stream(p.getimagechunks(), p.datasize)

    def _q_lookup(self, request, component):
        request = quixote.get_request()
        response = quixote.get_response()

        if component not in self.get_fields:
            raise TraversalError('No meta key "%s"' % component)

        http.json_response()
        
        if request.get_method() in ('POST', 'PUT'):
            if '_json' in request.form:
                data = json.read(request.form['_json'])
                
                # Return a callable thing
                def set_a_meta(request):
                    ret = self.set_meta(component, data)
                    ref = request.get_environ('HTTP_REFERER')
                    if ref is not None:
                        p = self.image.pic()
                        response.redirect(ref + '#pic%d' % p.id)

                    http.json_response()
                    return json.write(ret)

                return set_a_meta
            
            respose.set_status(204)     # no content
            return ''
        
        p = self.image.pic()
        return json.write(self.get_fields[component](p))

    def handle_upload(self):
        request = quixote.get_request()
        response = quixote.get_response()
        
        user = auth.login_user()
        perm = self.db.permissions(user)

        mayupload = (user and user.mayUpload) or (perm and perm.mayUpload)

        if not mayupload:
            raise AccessError('You may not upload images')

        if 'image' not in request.form:
            response.set_status(204)    # no content
            return ''

        added = []
        skipped = {}
        if isinstance(request.form['image'], list):
            for img in request.form['image']:
                self.do_upload(img, user, added, skipped)
        else:
            img = request.form['image']
            self.do_upload(img, user, added, skipped)
            
        added = [ image.Image(self, id) for id in added ]
        added = [ (p.path(), p.meta.get_meta()) for p in added ]

        http.json_response()
        response.set_status(201)        # created
        
        return json.write({ 'added': added, 'skipped': skipped })

    def get_comments(self):
        response = quixote.get_response()
        request = quixote.get_request()

        try:
            i = int(request.form['num'])
        except:
            i = -1

        all_comments = []
        for comment in image.get_comments(i):
            all_comments.append("""\
    <comment>
     <text>%s</text>
    </comment>
    """ % (comment))

        xml = """
    <?xml version="1.0"?>
    <comments>
    %s
    </comments>
    """ % ("".join(all_comments))

        return xml

    def _q_traverse(self, paths):
        # can't use _q_lookup; quixote unescapes %2F in paths before '?'
        if len(paths) == 1 and paths[0] == "":
            return self._q_index()

        filename = "/".join(paths)

        print "LOOKING FOR:", filename

        response = quixote.get_response()
        for fileobj in self.file_list:
            if fileobj.filename == filename:
                enc_filename = filename.replace("\\", "\\\\").replace('"', '\\"')
                response.set_content_type("application/binary")
                response.set_header("Content-Disposition", "filename=%s" % enc_filename)

                fp = fileobj.open()
                data = fp.read()
                fp.close()

                response.set_body(data)
                return

        response.set_status(404)
        response.set_body("not found")

    def __call__(self):
        if not self.follow_symlinks and os.path.islink(self.path):
            raise errors.TraversalError(private_msg="Path %r is a symlink"
                                        % self.path)
        request = quixote.get_request()
        response = quixote.get_response()

        if self.cache_time is None:
            response.set_expires(None) # don't set the Expires header
        else:
            # explicitly allow client to cache page by setting the Expires
            # header, this is even more efficient than the using
            # Last-Modified/If-Modified-Since since the browser does not need
            # to contact the server
            response.set_expires(seconds=self.cache_time)

        try:
            stat = os.stat(self.path)
        except OSError:
            raise errors.TraversalError
        last_modified = formatdate(stat.st_mtime)
        if last_modified == request.get_header('If-Modified-Since'):
            # handle exact match of If-Modified-Since header
            response.set_status(304)
            return ''

        # Set the Content-Type for the response and return the file's contents.
        response.set_content_type(self.mime_type)
        if self.encoding:
            response.set_header("Content-Encoding", self.encoding)

        response.set_header('Last-Modified', last_modified)

        return FileStream(open(self.path, 'rb'), stat.st_size)

    def add_bookmark(self):
        request = quixote.get_request()
        response = quixote.get_response()
        form = request.form

        sequence = form.get('sequence')
        start = int(form.get('start'))
        stop = int(form.get('stop'))
        color = form.get('color', 'green')
        
        name = form.get('name', '')
        if not name:
            template = env.get_template('BasicView/add_bookmark.html')
            return template.render(locals())

        ###

        bookmarks.add_bookmark(name, self.genome_name, sequence, start, stop,
                               +1, color)

        self._load_bookmarks()

        url = request.get_url(1)
        url += '/go?sequence=%s&start=%d&stop=%d' % (quote_plus(sequence),
                                                    start, stop)
        return response.redirect(url)

 def image_raw(self):
     response = quixote.get_response()
     request = quixote.get_request()
     i = request.form['i']
     img = image.get_image(int(i))
     response.set_content_type('image/%s' % img[1])
     return img[0]

 def image_thumbnail(self):
     request = quixote.get_request()
     i = request.form['i']
     img, contentType = image.get_thumbnail_from_form(i)
     response = quixote.get_response()
     response.set_content_type(contentType)
     return img

 def get_score(self):
 	request = quixote.get_request()
 	response = quixote.get_response()
 	
 	the_int = int(request.form['special'])
 	score   = image.get_score(the_int)
 	return score

 def image_raw(self):
     response = quixote.get_response()
     img = image.get_latest_image()
     print img[1]
     response.set_content_type('image/%s' % img[1])
     
     return img[0]

    def image_raw_id(self):
        response = quixote.get_response()
        request = quixote.get_request()
        imageId = request.form['id']

        img = image.get_image_by_id(imageId)
        response.set_content_type('image/{0}'.format(img[1]))
        return img[0]

 def image_raw(self):
     request = quixote.get_request()
     key = request.form['key']
     response = quixote.get_response()
     img = image.get_image(key)
     response.set_content_type('image/%s' % img.filetype)
     
     return img.data

 def get_thumb(self):
     request = quixote.get_request()
     response = quixote.get_response()        
     number = int(request.form['id'])
     img = image.get_image(number)
     thumb = image.generate_thumbnail(img[0])
     response.set_content_type('image/png')        
     return thumb

 def __call__(self, req):
     # Add an ETag header for better caching.
     response = quixote.get_response()
     stat = os.stat(self.path)
     goo=str(stat.st_mtime)+self.path
     response.set_header('ETag', sha.sha(goo).digest().encode('hex'))
     
     return StaticFile.__call__(self)