def delete(self):
     current_user = quixote.get_request().get_cookie('user')
     if (current_user is not None):
         request = quixote.get_request()
         key = request.form['key']
         if (current_user == image.get_owner(key)[0]):
             image.delete_image(key)
     return quixote.redirect('./')

    def _q_index(self):
        url_path = quixote.get_request().get_path()

        url_qs = quixote.get_request().get_query()

        txt = 'Quixote: |{}{}|'.format(url_path, '?'+url_qs if url_qs else '')

        return txt

    def search_results(self):
        request = quixote.get_request()
        query = request.form['query']
        data = {'image_keys':image.search_metadata(query)}
        current_user = quixote.get_request().get_cookie('user')
        if (current_user is not None):
            data['user'] = current_user

        return html.render('search_results.html', values = data)

    def image_with_key(self):
        request = quixote.get_request()
        key = request.form['key']
        data = image.get_image(key).metadata
        data['key'] = key
        data['image_comments'] = image.get_comments(key)
        current_user = quixote.get_request().get_cookie('user')
        if (current_user is not None):
            data['user'] = current_user
            if (current_user == image.get_owner(key)[0]):
                data['can_delete'] = True

        return html.render('image_with_key.html', values = data)

 def _render_finish(self):
     r = TemplateIO(html=True)
     r += htmltext('</form><br class="quixoteform" />')
     code = get_request().response.javascript_code
     if code:
         r += self._render_javascript(code)
     return r.getvalue()

 def _get_default_action_url(self):
     request = get_request()
     action_url = url_quote(request.get_path())
     query = request.get_environ("QUERY_STRING")
     if query:
         action_url += "?" + query
     return action_url

 def result(self):
 	response = quixote.get_request()
 	
 	info = response.form['query']
 	
 	results = image.search(info)
 	return html.render('result.html', results)

 def upload_file(self):
     request = get_request()
     if request.form:
         contents = request.form['upload'].fp.read()
         return contents
     else:
         return "<form enctype=multipart/form-data method=POST> <input type=file name=upload> <input type=submit value=submit> </form>"

    def multisubmitform(self):
        request = get_request()
        
        submit1 = widget.SubmitWidget('sub_a', value='sub_a')
        submit2 = widget.SubmitWidget('sub_b', value='sub_b')

        s = ""
        if request.form:
            used = False
            if submit1.parse(request):
                used = True
                s += "used_sub_a"
            if submit2.parse(request):
                used = True
                s += "used_sub_b"

            if not used:
                assert 0

            # print out the referer, too.
            referer = request.environ.get('HTTP_REFERER')
            if referer:
                s += "<p>referer: %s" % (referer,)

        return "<form method=POST>%s %s %s</form>" % (s,
                                                      submit1.render(),
                                                      submit2.render())

    def do_blast(self):
        request = quixote.get_request()
        form = request.form

        seq = form['seq']
        seq_type = sequtil.guess_seqtype(seq)
        db_type = self.db._seqtype
        prog = blast.blast_program(seq_type, db_type)
        
        do_translate = form.get('do_translate', 0)
        if do_translate:
            do_translate = int(do_translate)
        
        if prog == 'blastn' and do_translate:
            prog = 'tblastx'

        cmd = ['blastall', '-p', prog, '-d', self.db.filepath, '-e', '1']
        p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        (stdout, stderr) = p.communicate(">query\n" + seq)

        try:
            record = blastparser.parse_string(stdout).next()
        except StopIteration:
            template = env.get_template('BlastView/no-results.html')
            return template.render(locals())
            
        genome_name = self.genome_name
        filepath = self.db.filepath
        
        template = env.get_template('BlastView/results.html')
        return template.render(locals())

    def _set_cookie(self, value, **attrs):
        """(session_id : string)

        Ensure that a session cookie with value 'session_id' will be
        returned to the client via the response object.

        Since Mod_Python has its own Cookie management system, we use it.
        """
        config = get_publisher().config
        name = config.session_cookie_name
        domain = config.session_cookie_domain

        if config.session_cookie_path:
            path = config.session_cookie_path
        else:
            path = get_request().get_environ('SCRIPT_NAME')
            if not path.endswith("/"):
                path += "/"

        expires = -1

        options = {'expires': expires,
                   'path': path }

        if domain is not None:
            options.update({'domain':domain})

        if value:
            Cookie.add_cookie(self.modpython_request, name, value, **options)

        return name

 def parse(self, request=None):
     if not self._parsed:
         if request is None:
             request = get_request()
         self._parse(request)
         self._parsed = True
     return self.value

    def _q_traverse(self, path):
        # Initialize the publisher's namespace_stack
        del self.namespace_stack[:]

        request = get_request()

        # Traverse package to a (hopefully-) callable object
        object = _traverse_url(self.root_namespace, path, request, self.namespace_stack)

        # None means no output -- traverse_url() just issued a redirect.
        if object is None:
            return None

        # Anything else must be either a string...
        if isstring(object):
            output = object

        # ...or a callable.
        elif hasattr(object, "__call__"):
            output = object(request)
            if output is None:
                raise RuntimeError, "callable %s returned None" % repr(object)

        # Uh-oh: 'object' is neither a string nor a callable.
        else:
            raise RuntimeError("object is neither callable nor a string: %s" % repr(object))

        return output

 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(self):
     request = quixote.get_request()
     i = request.form['i']
     img = image.get_image(int(i))
     metadata = img[2]
     metadata['index'] = int(i)
     return html.render('image.html', values = metadata)

    def _q_index(self):
        request = quixote.get_request()
        package = self.package
        package_exists = self.package in self.coord.get_all_packages()

        template = env.get_template("feed_generic_package_index.html")
        return template.render(locals()).encode("latin-1", "replace")

 def _attempt_record_ip(self, user):
     try:
         request = get_request()
     except:
         pass
     else:
         user.record_ip_access(request.get_environ('REMOTE_ADDR'))

    def suning(self):
	try :
	    request = quixote.get_request()
	    if request.form.get("url") == None:
		return '0'
	    urlString = request.form.get("url")
	    newegg = md5.new()
	    newegg.update(urlString)
	    cookie = cookielib.CookieJar()
	    opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
	    req = Request(urlString)
	    f = urlopen(req)
	    local_file = open("%s/%s.%s" %(_tesseract_temp_path,newegg.hexdigest(),_suning_filename_flag), "w" + "b")
	    local_file.write(f.read())
	    local_file.close()
	    os.system("convert -compress none -depth 8 -alpha off %s/%s.%s %s/%s-convert.tiff" % (_tesseract_temp_path,newegg.hexdigest(),_suning_filename_flag,_tesseract_temp_path,newegg.hexdigest()))
	    os.system("tesseract %s/%s-convert.tiff %s/%s" % (_tesseract_temp_path,newegg.hexdigest(),_tesseract_temp_path,newegg.hexdigest()))
	    numbers = retrieve_text("%s/%s" %(_tesseract_temp_path,newegg.hexdigest()) );
	    os.remove("%s/%s.%s" %(_tesseract_temp_path,newegg.hexdigest(),_suning_filename_flag))
	    os.remove("%s/%s-convert.tiff" %(_tesseract_temp_path,newegg.hexdigest()))
	    os.remove("%s/%s.txt" %(_tesseract_temp_path,newegg.hexdigest()))
	    return numbers
	    if numbers == None:
		return '0'
	    else:
		return numbers
	except IOError:
	    return '0'        

    def login(self):
        request = get_request()

        username_widget = widget.StringWidget(name='username',
                                              value='')
        submit_widget = widget.SubmitWidget(name='submit',
                                            value='submit me')
        submit_widget2 = widget.SubmitWidget(name='nosubmit2',
                                             value="don't submit")
        
        if request.form:
            assert not submit_widget2.parse(request)
            username = username_widget.parse(request)
            if username:
                session = get_session()
                session.set_user(username)
                return redirect('./')

        image_submit = '''<input type=image name='submit you' src=DNE.gif>'''
                
        return "<form method=POST>Log in: %s<p>%s<p>%s<p>%s</form>" % \
               (username_widget.render(),
                submit_widget2.render(),
                submit_widget.render(),
                image_submit)

    def newegg(self):
	try :
	    request = quixote.get_request()
	    if request.form.get("url") == None:
		return '0'
	    newegg_url = request.environ.get('QUERY_STRING', '')
	    newegg_list = newegg_url.split('=')
	    if len(newegg_list) < 3 :
		return '0'
	    urlString = "%s=%s" % (newegg_list[1],newegg_list[2])
	    #url_params = url.decode_url_string(newegg_url)
	    #urlString = "".join(["%s=%s" % (k, v) for k, v in url_params.items()])
	    newegg = md5.new()
	    newegg.update(urlString)
	    
	    req = Request(urlString)
	    f = urlopen(req)
	    local_file = open("%s/%s.%s" %(_tesseract_temp_path,newegg.hexdigest(),_newegg_filename_flag), "w" + "b")
	    local_file.write(f.read())
	    local_file.close()
	    os.system("convert -compress none -alpha off %s/%s.%s %s/%s-convert.tiff" % (_tesseract_temp_path,newegg.hexdigest(),_newegg_filename_flag,_tesseract_temp_path,newegg.hexdigest()))
	    os.system("tesseract %s/%s-convert.tiff %s/%s" % (_tesseract_temp_path,newegg.hexdigest(),_tesseract_temp_path,newegg.hexdigest()))
	    numbers = retrieve_text("%s/%s" %(_tesseract_temp_path,newegg.hexdigest()) );
	    os.remove("%s/%s.%s" %(_tesseract_temp_path,newegg.hexdigest(),_newegg_filename_flag))
	    os.remove("%s/%s-convert.tiff" %(_tesseract_temp_path,newegg.hexdigest()))
	    os.remove("%s/%s.txt" %(_tesseract_temp_path,newegg.hexdigest()))
	    return numbers
	    if numbers == None:
		return '0'
	    else:
		return numbers
	except IOError:
	    return '0'