def test_multiple_attachments():
test_file1 = FieldStorage()
test_file1.name = 'file_info'
test_file1.filename = 'test1.txt'
test_file1.type = 'text/plain'
test_file1.file = StringIO('test file1\n')
test_file2 = FieldStorage()
test_file2.name = 'file_info'
test_file2.filename = 'test2.txt'
test_file2.type = 'text/plain'
test_file2.file = StringIO('test file2\n')
d = M.Discussion(shortname='test', name='test')
t = M.Thread.new(discussion_id=d._id, subject='Test Thread')
test_post = t.post('test post')
test_post.add_multiple_attachments([test_file1, test_file2])
ThreadLocalORMSession.flush_all()
assert_equals(len(test_post.attachments), 2)
attaches = test_post.attachments
assert 'test1.txt' in [attaches[0].filename, attaches[1].filename]
assert 'test2.txt' in [attaches[0].filename, attaches[1].filename]
def form(self, name):
if self._form is None:
safe_env = {'QUERY_STRING': ''}
for key in ('REQUEST_METHOD', 'CONTENT_TYPE', 'CONTENT_LENGTH'):
if key in self.env:
safe_env[key] = self.env[key]
fs = FieldStorage(fp=self.body,
environ=safe_env,
keep_blank_values=True)
self._form = fs
return self._form.getfirst(name)
def test_valid_file_upload(self):
from adhocracy.forms.common import ValidFileUpload
from formencode import Invalid
from cgi import FieldStorage
from io import BytesIO
ValidFileUpload.max_size = 1
value = FieldStorage()
value.file = BytesIO(b"bi")
value.filename = u"test.png"
value.name = u"thumbs"
self.assertRaises(Invalid, ValidFileUpload.to_python, value)
def setUp(self):
self.form = FieldStorage()
self.client = MockNull()
self.client.db = db = MockDatabase()
db.security.hasPermission = lambda *args, **kw: True
self.client.form = self.form
# add client props for testing anti_csrf_nonce
self.client.session_api = MockNull(_sid="1234567890")
self.client.db.getuid = lambda : 10
self.client.db.config = {'WEB_CSRF_TOKEN_LIFETIME': 10 }
def go(self): # determine which page to return
self.cookies = {}
self.error = ''
form = FieldStorage()
# come in from the null or return
if form.keys() == []:
self.showForm()
return
# come in from the form only
# get the person
if form.has_key('person'):
self.who = capwords(strip(form['person'].value))
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
# the cookie field
if form.has_key('cookie'):
self.cookies['user'] = unquote(strip(form['cookie'].value))
else:
self.cookies['user'] = ''
# the language
self.langs = []
if form.has_key('lang'):
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
# resolve the file
if form.has_key('upfile'):
upfile = form["upfile"]
self.fn = upfile.filename or ''
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
# error or not
if not self.error:
self.doResults()
else:
self.showError()
def request_body(self) -> Dict[str, str]:
headers = {
"content-type": self.env["CONTENT_TYPE"],
"content-length": self.env["CONTENT_LENGTH"],
}
fs = FieldStorage(
fp=self.env["wsgi.input"],
headers=headers,
environ={"REQUEST_METHOD": "POST"},
)
return {f.name: f.value for f in fs.list}
def go(self): # determine which page to return
try:
self.cookies = {}
self.error = ''
form = FieldStorage()
if form.keys() == []:
self.showForm()
return
if form.has_key('person'):
logger.info("form['person'].value is:%s" %
(form['person'].value, ))
self.who = capwords(strip(form['person'].value))
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
if form.has_key('cookie'):
logger.info("form['cookie'].value is:%s" %
(form['cookie'].value, ))
self.cookies['user'] = unquote(strip(\
form['cookie'].value))
else:
self.cookies['user'] = ''
self.langs = []
if form.has_key('lang'):
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
if form.has_key('upfile'):
upfile = form["upfile"]
self.fn = upfile.filename or ''
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
if not self.error:
self.doResult()
else:
self.showError()
except:
logger.exception("Error!!!")
def tokenizer(self, spin, header, fd, resource, version):
data = ''
try:
resource, data = resource.split('?', 1)
except ValueError:
pass
spawn(spin, 'POST %s' % resource, header,
FieldStorage(fp=fd, environ=get_env(header)),
parse_qs(data), version)
def actualizar(self):
form = FieldStorage()
propiedad_id = form["datodecontacto_id"].value
denominacion = form["denominacion"].value
valor = form["valor"].value
self.model.datodecontacto_id = propiedad_id
self.model.denominacion = denominacion
self.model.valor = valor
self.model.update()
self.redirect()
def go(self): # determine which page to return
self.cookies = {}
self.error = ''
form = FieldStorage()
if form.keys() == []:
self.showForm()
return
# if form.has_key('person'):
if 'person' in form:
# self.who = capwords(strip(form['person'].value))
self.who=form['person'].value.strip().title()
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
# if form.has_key('cookie'):
if 'cookie' in form:
self.cookies['user'] = unquote(form['cookie'].value.strip())
else:
self.cookies['user'] = ''
self.langs = []
# if form.has_key('lang'):
if 'lang' in form:
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
# if form.has_key('upfile'):
if 'upfile' in form:
upfile = form["upfile"]
# print(AdvCGI.header+upfile.filename)
self.fn = upfile.filename or ''
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
if not self.error:
self.doResults()
else:
self.showError()
def form(self):
""" use cgi fieldstorage 解析 multipart body and return a FileStorage object"""
if self.method.upper() == 'POST' and \
(self.content_type.upper().startswith('MULTIPART/') or
self.content_type.upper().startswith('APPLICATION/')):
form = FieldStorage(fp=self.body,
environ=self.environ,
keep_blank_values=True)
return form
else:
raise AttributeError(
"Can not parse form data. May form not exists.")
def _parse_multipart(self:HTTPContext, content_params: Dict[str, str], charset: codecs.CodecInfo) -> None:
storage = FieldStorage(fp=BytesIO(self._params['raw_body']), headers=self.headers, keep_blank_values=True, encoding=charset)
self._params['post_data'] = {}
for key in storage:
if storage[key].file:
self._params['post_data'][key] = storage[key].file
self._params['post_data'][key].filename = storage[key].filename
self._params['post_data'][key].type = storage[key].type
elif storage[key].list:
self._params['post_data'][key] = storage[key].list
else:
self._params['post_data'][key] = storage[key].value
def actualizar(self):
form = FieldStorage()
producto_id = form["producto_id"].value
denominacion = form["denominacion"].value
precio = form["precio"].value
self.model.producto_id = producto_id
self.model.denominacion = denominacion
self.model.precio = precio
self.model.update()
self.redirect()
def GetQuery(QueryString, BlankIfMissing =0 ):
if not InGlobals("FormFieldStorage"):
from cgi import FieldStorage
global FormFieldStorage
FormFieldStorage = FieldStorage()
if FormFieldStorage.has_key(QueryString):
retVal = FormFieldStorage[QueryString].value
else:
retVal = iif(BlankIfMissing,"",None)
return retVal
def __init__(self, environ):
"""
constructor
"""
self.q = {}
if isinstance(environ, (dict, )) and not "REQUEST_METHOD" in environ:
self.q = environ
elif environ and "REQUEST_METHOD" in environ and environ[
"REQUEST_METHOD"] == "GET":
request_body = environ['QUERY_STRING']
q = parse_qs(request_body)
for key in q:
self.q[key] = [escape(item) for item in q[key]]
elif environ and "REQUEST_METHOD" in environ and environ[
"REQUEST_METHOD"] == "POST":
env_copy = environ.copy()
env_copy['QUERY_STRING'] = ''
q = FieldStorage(fp=environ["wsgi.input"],
environ=env_copy,
keep_blank_values=True)
for key in q:
self.q[key] = q.getvalue(key)
# print(key, "=", len(q.getvalue(key)))
# load extra query string info:
request_body = environ['QUERY_STRING']
q = parse_qs(request_body)
for key in q:
self.q[key] = [escape(item) for item in q[key]]
if environ and "DOCUMENT_ROOT" in environ:
self.q["DOCUMENT_ROOT"] = environ["DOCUMENT_ROOT"]
environ["DOCUMENT_WWW"] = os.path.abspath(
environ["DOCUMENT_ROOT"] + "/var/www")
self.q["DOCUMENT_WWW"] = environ["DOCUMENT_WWW"]
if environ and "HTTP_COOKIE" in environ:
if isinstance(environ["HTTP_COOKIE"], (str, )):
self.q["HTTP_COOKIE"] = mapify(environ["HTTP_COOKIE"], ";")
else:
self.q["HTTP_COOKIE"] = environ["HTTP_COOKIE"]
if "encoded" in self.q and self.q["encoded"] in ("true", "1", 1):
for key in q:
if not key in ("encoded", "encrypted"):
try:
self.q[key] = base64.b64decode(self.q[key])
except:
pass
def contactUs():
# Function to take in user information from contact us and insert it into a database
from cgi import FieldStorage, escape
import pymysql as db
from os import environ
result = ''
url = environ.get('SCRIPT_NAME')
try:
connection = db.connect('cs1.ucc.ie', 'cgg1', 'weeS2dih', '2021_cgg1')
cursor = connection.cursor(db.cursors.DictCursor)
form_data = FieldStorage()
if len(form_data) != 0:
if form_data.getfirst('name') != None and form_data.getfirst(
'phone') != None and form_data.getfirst('comment') != None:
name = escape(form_data.getfirst('name')).strip()
phone = escape(form_data.getfirst('phone')).strip()
comment = escape(form_data.getfirst('comment')).strip()
comment = profanity(comment)
if not phone.isnumeric() or len(phone) != 10:
result += '<p class="error">Please enter a valid phone number.</p>'
else:
cursor.execute(
"""INSERT INTO contact_us (name, url, phone, comment)
VALUES (%s, %s, %s, %s)""",
(name, url, phone, comment))
connection.commit()
result += "<p>Message successfully sent.</p>"
else:
result += '<p class="error">Please fill in all the text boxes.</p>'
cursor.close()
connection.close()
except db.Error:
result += '<p class="error">Sorry! We are experiencing problems at the moment. Please call back later.</p>'
return """
<h1>Contact Us</h1>
<form action="%s" method="post">
<fieldset>
<legend>Send A Message</legend>
<label for="name">Name: </label>
<input type="text" name="name" id="name" maxlength="40"/>
<label for="phone">Phone: </label>
<input type="text" name="phone" id="phone" maxlength="10"/>
<label for="comment">Comment:</label>
<textarea name="comment" id="comment" rows="4" cols="30"></textarea>
<input type="submit" value="Send"/>
</fieldset>
</form>
%s""" % (url, result)
def do_POST(self):
form = FieldStorage(fp=self.rfile,
headers=self.headers,
environ={
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers['Content-Type'],
})
self.post = {}
for name in form.keys():
self.post[name] = form[name].value
return self.do_GET()
def print_env(environ, start_response):
"""list environ items"""
import os
print(os.environ)
from cgi import FieldStorage
form = FieldStorage(environ=environ)
#print(form.keys())
for k in form.keys():
print ('k: %s' % k)
f = form[k]
print (f)
start_response('200 OK', [('Content-Type', 'text/plain')])
return ['\n'.join(['%s: %r' % item for item in environ.items()])]
def web_loader(environ, start_response):
headers = [('Content-type', 'application/json; charset=UTF-8'),
("Access-Control-Allow-Origin", "*")]
start_response('200 OK', headers)
form = FieldStorage()
pid = os.fork()
if pid == 0: # new process
os.system("philoload4 %s %s &" %
(form.getvalue("dbname"), form.getvalue("files")))
exit()
yield dumps({"success": True})
def parse_body(request, response, params):
if "Content-Type" not in request.headers:
request.headers["Content-Type"] = ""
form = FieldStorage(environ={"REQUEST_METHOD": "POST"},
fp=TextIOWrapper(request.body),
headers=request.headers,
keep_blank_values=True)
if form.file:
request.body = form.file
else:
params.update(dictform(form))
def parse_multi_part_response(response):
parsed_response = {}
fs = FieldStorage(
fp=BytesIO(response.content),
headers=response.headers,
environ={"REQUEST_METHOD": "POST", "CONTENT_TYPE": response.headers["Content-Type"],},
)
for child in fs.list:
key = child.name
value = child.file.read()
parsed_response.update({key: value})
return parsed_response
def main():
# parse query string
arguments = FieldStorage(keep_blank_values=True)
json = arguments.getvalue('payload')
content = loads(json)
if 'commits' in content:
repo = content['repository']['name']
if repo in VALID_UPDATE_REPOSITORIES:
handle_repository_update(repo)
process_commit_mails(content)
def _createBinaryFile():
from cgi import FieldStorage
from ZPublisher.HTTPRequest import FileUpload
from tempfile import TemporaryFile
fp = TemporaryFile('w+b')
fp.write('\x00' + 'x' * (1 << 19))
fp.seek(0)
env = {'REQUEST_METHOD':'PUT'}
headers = {'content-type':'application/msword',
'content-length': 1 << 19,
'content-disposition':'attachment; filename=test.doc'}
fs = FieldStorage(fp=fp, environ=env, headers=headers)
return FileUpload(fs)
def run_brat_direct(self):
"""Execute brat server directly."""
remote_addr = self.client_address[0]
remote_host = self.address_string()
cookie_data = ', '.join(filter(None,
self.headers.getheaders('cookie')))
query_string = ''
i = self.path.find('?')
if i != -1:
query_string = self.path[i + 1:]
saved = sys.stdin, sys.stdout, sys.stderr
sys.stdin, sys.stdout = self.rfile, self.wfile
# set env to get FieldStorage to read params
env = {}
env['REQUEST_METHOD'] = self.command
content_length = self.headers.getheader('content-length')
if content_length:
env['CONTENT_LENGTH'] = content_length
if query_string:
env['QUERY_STRING'] = query_string
os.environ.update(env)
params = FieldStorage()
# Call main server
cookie_hdrs, response_data = serve(params, remote_addr, remote_host,
cookie_data)
sys.stdin, sys.stdout, sys.stderr = saved
# Package and send response
if cookie_hdrs is not None:
response_hdrs = [hdr for hdr in cookie_hdrs]
else:
response_hdrs = []
response_hdrs.extend(response_data[0])
self.send_response(200)
self.wfile.write('\n'.join('%s: %s' % (k, v)
for k, v in response_hdrs))
self.wfile.write('\n')
self.wfile.write('\n')
# Hack to support binary data and general Unicode for SVGs and JSON
if isinstance(response_data[1], unicode):
self.wfile.write(response_data[1].encode('utf-8'))
else:
self.wfile.write(response_data[1])
return 0
def go(self):
"""
Dynamic generate the HTML page
"""
self.cookies = {}
self.error = ""
form = FieldStorage()
if not form.keys():
self.show_form()
return
if form.has_key('person'):
self.who = form['person'].value.strip().title()
if self.who == "":
self.error = "Your name is required. (blank)"
else:
self.error = "Your name is required. (missing)"
if form.has_key('cookie'):
self.cookies['user'] = unquote(form['cookie'].value.strip())
else:
self.cookies['user'] = ""
self.langs = []
if form.has_key('lang'):
lang_data = form['lang']
if isinstance(lang_data, list):
for eachLang in lang_data:
self.langs.append(eachLang.value)
else:
self.langs.append(lang_data)
else:
self.error = 'At least one language required.'
if form.has_key('upfile'):
upfile = form['upfile']
self.fn = upfile.filename or ""
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ""
if not self.error:
self.do_results()
else:
self.show_error()
def go(self):
self.error = ''
form = FieldStorage()
if form.keys() == []:
#s('calling showForm()\n')
self.showForm()
return
if form.has_key('person'):
self.who = capwords(strip(form['person'].value))
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
if form.has_key('cookie'):
self.cookies['user'] = unquote(strip(form['cookie'].value))
else:
self.cookies['user'] = ''
self.langs = []
if form.has_key('lang'):
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
if form.has_key('upfile'):
upfile = form["upfile"]
self.fn = upfile.filename or ''
#s('filename is %s??\n' % self.fn)
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
if not self.error:
#s('calling doResults()\n')
self.doResults()
else:
#s('calling showError()\n')
self.showError()
def apply_model(self, model):
self.title.data = model.title
self.portrait.data = model.portrait
self.export_fields.data = model.export_fields
if model.organigram_file:
fs = FieldStorage()
fs.file = BytesIO(model.organigram_file.read())
fs.type = model.organigram_file.content_type
fs.filename = model.organigram_file.filename
self.organigram.data = self.organigram.process_fieldstorage(fs)
if hasattr(self, 'is_hidden_from_public'):
self.is_hidden_from_public.data = model.is_hidden_from_public
self.reorder_export_fields()
def main():
"""
Script entry-point, reads from github.com request and processes the
event.
"""
# parse query string
arguments = FieldStorage(keep_blank_values=True)
json = arguments.getvalue('payload')
content = loads(json)
if 'commits' in content:
repo = content['repository']['name']
if repo in config['git']['repositories']:
handle_irc_message(repo, content)
def createFileUpload(data, filename):
fp = TemporaryFile('w+b')
fp.write(data)
fp.seek(0)
env = {'REQUEST_METHOD': 'PUT'}
headers = {'content-type':'text/plain',
'content-length': len(data),
'content-disposition':'attachment; filename=%s' % \
filename}
fs = FieldStorage(fp=fp, environ=env, headers=headers)
result = FileUpload(fs)
fp.close()
return result
def _prepareFormTarball(self):
"""we could use our @@export-easyform view,
but we want a more atomic test, so we make
a tarfile for our test. the approach to making
a tarfile is a bit strange, but does the job
"""
in_fname = 'test_form_1_easyform.tar.gz'
test_dir = os.path.dirname(__file__)
def _add_form_structure_to_archive(archive):
form_relative_path = os.path.join('profiles', 'testing',
'structure', 'Members',
'test_user_1_',
'test_form_1_easyform')
abs_path = os.path.join(test_dir, form_relative_path)
# add structure folder
os.chdir(os.path.join(test_dir, 'profiles', 'testing'))
archive.add('structure', recursive=False)
for f in os.listdir(abs_path):
os.chdir(abs_path) # add form data w/o full directory tree
archive.add(f, arcname=os.path.join('structure', f))
# Capture the current working directory for later when we need to
# clean up the environment.
working_directory = os.path.abspath(os.curdir)
# make me a tarfile in the current dir
os.chdir(test_dir)
archive = TarFile.open(name=in_fname, mode='w:gz')
_add_form_structure_to_archive(archive)
archive.close()
# Change back to the working directory in case something tries to
# write files (e.g. collective.xmltestreport).
os.chdir(working_directory)
# get it and upload
in_file = open(os.path.join(test_dir, in_fname))
env = {'REQUEST_METHOD': 'PUT'}
headers = {
'content-type': 'text/html',
'content-length': len(in_file.read()),
'content-disposition':
'attachment; filename={0}'.format(in_file.name)
}
in_file.seek(0)
fs = FieldStorage(fp=in_file, environ=env, headers=headers)
return FileUpload(fs)
