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 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 ""