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 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 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 _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 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 _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 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 testformaction(self):
request = get_request()
keys = [ k for k in request.form.keys() if request.form[k] ]
keys.sort()
return "==" + " AND ".join(keys) + "=="
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 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 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 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 _q_lookup(self, lang):
request = get_request()
request.session['language'] = lang
referer = request.get_environ('HTTP_REFERER')
if not referer:
referer = config.site_url
return request.response.redirect(referer)
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 handle(self, request):
self.request = get_request()
if self.isNew():
user = self.newUser()
redir = AdminPage.handle(self, request)
if redir:
return redir
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 t(text):
"""Return translated text.
This is a standard hook to gettext, but with a twist: since our
Quixote app runs in an app server, the typical global gettext
approach doesn't work, because requests come in from different users
and languages.
We therefore have to check the HTTPRequest object to find the
appropriate translator.
"""
publisher = get_publisher()
if not publisher:
return text
try:
request = get_request()
except AttributeError:
# publisher has no request during import/load of this module
return text
if not request or not hasattr(request, 'gettext'):
# gettext attr is installed by QonPublisher
return text
return request.gettext(text)
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 clear_errors(self):
"""Ensure that all components of the form have parsed themselves.
Clear any errors that might have occured during parsing.
"""
request = get_request()
for widget in self.get_all_widgets():
widget.clear_error(request)
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 finish_failed_request(self):
"""Called near the end of a failed request (i.e. a exception that was
not a PublisherError was raised.
"""
request = get_request()
self.clear_session(request)
def _attempt_record_ip(self, user):
try:
request = get_request()
except:
pass
else:
user.record_ip_access(request.get_environ('REMOTE_ADDR'))
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 result(self):
response = quixote.get_request()
info = response.form['query']
results = image.search(info)
return html.render('result.html', results)
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'
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 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 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 formpostredirect(self):
"""
Test redirect after a form POST. This tests a specific bug in
mechanize...
"""
request = get_request()
if not request.form:
return """\
<form method=POST enctype=multipart/form-data>
<input type=text name=test>
<input type=submit value=submit name=submit>
</form>
"""
redirect(get_path(1) + '/')
def testform(self):
request = get_request()
s = ""
if not request.form:
s = "NO FORM"
if request.form and request.form.has_key('selecttest'):
vals = request.form['selecttest']
if isinstance(vals, str):
vals = [
vals,
]
s += "SELECTTEST: ==%s==<p>" % " AND ".join(vals, )
if request.form:
l = []
for name in ('item', 'item_a', 'item_b', 'item_c'):
if request.form.get(name):
val = request.form[name]
l.append('%s=%s' % (name, val))
s += "NAMETEST: ==%s==<p>" % " AND ".join(l)
return """\
%s
<form method=POST id=the_form>
<select name=selecttest multiple>
<option> val
<option value='selvalue1'> value1 </option>
<option value='selvalue2'> value2 </option>
<option value='selvalue3'> value3 </option>
<option value='test.value3'> testme.val </option>
<option value=Test.Value4> testme4.val </option>
</select>
<input type=text name=item>
<input type=text name=item_a>
<input type=text name=item_b>
<input type=text name=item_c>
<input type=text id=some_id>
<input type=submit value=post id=submit_button>
</form>
""" % (s, )
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 get_submit(self):
"""() -> string | bool
Get the name of the submit button that was used to submit the
current form. If the form is submitted but not by any known
SubmitWidget then return True. Otherwise, return False.
"""
request = get_request()
for button in self.submit_widgets:
if button.parse(request):
return button.name
else:
if self.is_submitted():
return True
else:
return False
def get_next_bus(self):
request = quixote.get_request()
response = quixote.get_response()
response.set_content_type('application/json')
form = request.form
#return """{"route_num": "22", "stop_number": 2586, "route_name": "HASLETT-MERIDIAN MALL-MSU", "time": "6:17a"}"""
lat = form['lat']
lon = form['lon']
stop_number = get_closest_stop(lat, lon)
data = get_next_bus_time(stop_number)
data['stop_number'] = stop_number
x = json.dumps(data)
return x
def _q_access(self):
r = get_request()
print '======================== NEW REQUEST'
for k, v in r.environ.items():
print '***', k, ':', v
ha = r.get_environ('HTTP_AUTHORIZATION', None)
if ha:
auth_type, auth_string = ha.split()
login, passwd = base64.decodestring(auth_string).split(':')
if login == 'test' and passwd == 'password':
return
raise UnauthorizedError
def expire_session(self):
"""
Expire the current session, ie. revoke the session cookie from
the client and remove the session object from the session
manager and from the current request.
"""
self.revoke_session_cookie()
request = get_request()
try:
del self[request.session.id]
except KeyError:
# This can happen if the current session hasn't been saved
# yet, eg. if someone tries to leave a session with no
# interesting data. That's not a big deal, so ignore it.
pass
request.session = None
def dump_request(request=None):
if request is None:
request = quixote.get_request()
"""Dump an HTTPRequest object as HTML."""
row_fmt = htmltext('<tr><th>%s</th><td>%s</td></tr>')
r = TemplateIO(html=True)
r += htmltext('<h3>form</h3>' '<table>')
for k, v in request.form.items():
r += row_fmt % (k, v)
r += htmltext('</table>' '<h3>cookies</h3>' '<table>')
for k, v in request.cookies.items():
r += row_fmt % (k, v)
r += htmltext('</table>' '<h3>environ</h3>' '<table>')
for k, v in request.environ.items():
r += row_fmt % (k, v)
r += htmltext('</table>')
return r.getvalue()
def is_submitted(self):
"""() -> bool
Return true if a form was submitted. If the form method is 'POST'
and the page was not requested using 'POST', then the form is not
considered to be submitted. If the form method is 'GET' then the
form is considered submitted if there is any form data in the
request.
"""
request = get_request()
if self.method == 'post':
if request.get_method() == 'POST':
return True
else:
return False
else:
return bool(request.form)
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'
def test_checkboxes(self):
request = get_request()
s = ""
if request.form and request.form.has_key('checkboxtest'):
val = request.form['checkboxtest']
if not isinstance(val, str) or isinstance(val, unicode):
val = ','.join(val)
s += "CHECKBOXTEST: ==%s==<p>" % val
return """\
%s
<form method=POST>
<input type="checkbox" name="checkboxtest" value="one">
<input type="checkbox" name="checkboxtest" value="two">
<input type="checkbox" name="checkboxtest" value="three">
<input type=submit value=post>
</form>
""" % (s, )
def set_session_cookie(session_id, **attrs):
"""Create a cookie in the HTTP response for 'session_id'.
"""
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
attrs = attrs.copy()
if config.session_cookie_secure:
attrs['secure'] = 1
if config.session_cookie_httponly:
attrs['httponly'] = 1
get_response().set_cookie(name, session_id, domain=domain, path=path,
**attrs)
return name
def test_checkbox(self):
request = get_request()
s = ""
if request.form and request.form.has_key('checkboxtest'):
val = request.form['checkboxtest']
if not isinstance(val, str) and not isinstance(val, unicode):
val = val[0]
s += "CHECKBOXTEST: ==%s==<p>" % val
return """\
%s
<form method=POST>
<input type="checkbox" name="checkboxtest" value="True">
<input type="hidden" name="checkboxtest" value="False">
<input type=submit value=post>
</form>
""" % (s, )
def parse(self, request=None):
if not self._parsed:
self._parsed = True
if request is None:
request = get_request()
if self._form is not None:
# use the form to determine if form data was submitted. It
# is possible that there is a query string, the request method
# is GET and the form method is POST. In that case the form
# should not be considered submitted.
submitted = self._form.is_submitted()
else:
submitted = request.form or request.get_method() == 'POST'
if submitted:
try:
self._parse(request)
except WidgetValueError, exc:
self.set_error(stringify(exc))
if (self.required and self.value is None
and not self.has_error()):
self.set_error(self.REQUIRED_ERROR)
def test_simple_checkbox(self):
request = get_request()
s = ""
if request.form and 'checkboxtest' in request.form:
val = request.form['checkboxtest']
if not isinstance(val, str) or isinstance(val, str):
val = val[0]
s += "CHECKBOXTEST: ==%s==<p>" % val
return """\
%s
<form method=POST>
<input type="checkbox" name="checkboxtest">
<input type=submit value=post>
</form>
""" % (s,)
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 buy360(self):
request = quixote.get_request()
identify = CaptchaIdentifier()
try:
if request.form.get("url") == None:
return '0'
else:
index = request.form.get("url").find("http://", 0)
if index == -1:
return '0'
CAPTHA = request.form.get("url")
cookie = cookielib.CookieJar()
opener = urllib2.build_opener(
urllib2.HTTPCookieProcessor(cookie))
img_file = opener.open(CAPTHA)
tmp = StringIO.StringIO(img_file.read())
image = Image.open(tmp)
numbers = identify.parse(image)
if numbers == None:
return '0'
else:
return numbers
except IOError:
return '0'
def _q_index(self):
request = quixote.get_request()
response = quixote.get_response()
response.redirect(request.get_url(2))
def _q_index(self):
request = quixote.get_request()
return quixote.redirect('./html/index.html')
def testformaction(self):
request = get_request()
keys = [k for k in request.form.keys() if request.form[k]]
keys.sort()
return "==" + " AND ".join(keys) + "=="
def get_current_value(self):
request = get_request()
if request.form:
return self.parse(request)
else:
return self.value
def set_current_value(self, value):
self.value = value
request = get_request()
if request.form:
request.form[self.name] = value
def is_submitted(self):
return self.parse(get_request())
def process(self):
values = {}
request = get_request()
for name, widget in self._names.items():
values[name] = widget.parse()
return values
def get_action_url(self):
action_url = url_quote(get_path())
query = get_request().get_query()
if query:
action_url += "?" + query
return action_url
def echo(self):
request = get_request()
if request.form and request.form.has_key('q'):
return request.form['q']
return "<html><body>No Content</body></html>"
def format(self):
request = get_request()
request.response.set_header('WWW-Authenticate',
'Basic realm="%s"' % self.realm)
return AccessError.format(self)
def __init__(self, id):
self.id = id
self.user = None
self._remote_address = get_request().get_environ("REMOTE_ADDR")
self._creation_time = self._access_time = time()
self._form_tokens = [] # queue
def _get_default_action(self):
query = get_request().get_query()
if query:
return "?" + query
else:
return ""
