def test_parsing_request_key_several_times(self):
"""Name: TestRequestParsing.test_parsing_request_key_several_times
"""
post = MultiDict([
('name', 'john2'),
('name', 'john1'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertTrue(result['name'][0] in ['john1', 'john2'])
self.assertTrue(result['name'][1] in ['john1', 'john2'])
post = MultiDict([
('name', 'john2'),
('name', 'john1'),
])
get = MultiDict([('name', 'john3')])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertTrue(result['name'][0] in ['john1', 'john2', 'john3'])
self.assertTrue(result['name'][1] in ['john1', 'john2', 'john3'])
self.assertTrue(result['name'][2] in ['john1', 'john2', 'john3'])
def test_various_edge_cases_unsuccessful(self):
"""Name: TestRequestParsing.test_various_edge_cases_unsuccessful
"""
post = MultiDict([
('user[].name', 'sigsmund'),
('user[].age', '30'),
('user[].name', 'zygrfyd'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
with self.assertRaises(exceptions.InvalidPayloadError):
tools.helpers.to_json(payload)
post = MultiDict([
('user[0].name', 'watson'),
('user.name', 'sherlock'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
with self.assertRaises(exceptions.InvalidPayloadError):
tools.helpers.to_json(payload)
def test_various_edge_cases_success(self):
"""Name: TestRequestParsing.test_various_edge_cases_success
"""
post = MultiDict([
('user.name[]', 'john'),
('user.age[]', '30'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertEqual(result['user']['name'], ['john'])
self.assertEqual(result['user']['age'], ['30'])
post = MultiDict([
('user.name[]', 'john'),
('user.name[]', 'emma'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertEqual(result['user']['name'], ['john', 'emma'])
def test_parsing_request_keys_an_object(self):
"""Name: TestRequestParsing.test_parsing_request_keys_an_object
"""
post = MultiDict([
('user.name', 'john'),
('user.age', '23'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertEqual(result['user']['name'], 'john')
self.assertEqual(result['user']['age'], '23')
post = MultiDict([])
get = MultiDict([
('user.name', 'john'),
('user.age', '23'),
])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertEqual(result['user']['name'], 'john')
self.assertEqual(result['user']['age'], '23')
def test_parsing_request_key_in_legacy_format(self):
"""Name: TestRequestParsing.test_parsing_request_key_in_legacy_format
"""
post = MultiDict([])
get = MultiDict([
('name[]', 'john1'),
('name[]', 'john2'),
])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertTrue(result['name'][0] in ['john1', 'john2'])
self.assertTrue(result['name'][1] in ['john1', 'john2'])
post = MultiDict([])
get = MultiDict([
('name[]', 'john2'),
])
payload = CombinedMultiDict([get, post])
result = tools.helpers.to_json(payload)
self.assertEqual(result['name'], ['john2'])
def __init__(self, uid=None, force=False):
"""
Keeps information about user.
"""
def on_update(self):
""" Changes own status when the user info is modified. """
self.modified = True
self.modified = False
self.uid = uid
self.req = self._get_request_info()
acc = {}
if uid > 0:
data = self._login(uid, force)
acc = self._precache(data, force)
else:
data = self._create_guest()
self.info = CallbackDict(data, on_update)
#FIXME remove req after everybody start using flask request.
CombinedMultiDict.__init__(
self, [self.req, self.info, acc,
dict(CFG_USER_DEFAULT_INFO)])
self.save()
def test_parsing_request_keys_an_object():
post = MultiDict([
('user.name', 'john'),
('user.age', '23'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['user']['name'] == 'john'
assert result['user']['age'] == '23'
post = MultiDict([])
get = MultiDict([
('user.name', 'john'),
('user.age', '23'),
])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['user']['name'] == 'john'
assert result['user']['age'] == '23'
def reload(self):
"""Reload user login information and saves them."""
data = self._login(self.uid, force=True)
acc = self._precache(data, force=True)
self.info.update(data)
CombinedMultiDict.__init__(self, [self.req, self.info, acc, dict(CFG_USER_DEFAULT_INFO)])
self.save()
def test_parsing_request_key_several_times():
post = MultiDict([
('name', 'john2'),
('name', 'john1'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['name'][0] in ['john1', 'john2']
assert result['name'][1] in ['john1', 'john2']
post = MultiDict([
('name', 'john2'),
('name', 'john1'),
])
get = MultiDict([('name', 'john3')])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['name'][0] in ['john1', 'john2', 'john3']
assert result['name'][1] in ['john1', 'john2', 'john3']
assert result['name'][2] in ['john1', 'john2', 'john3']
def get_environ(self):
"""Return the built environ."""
input_stream = self.input_stream
content_length = self.content_length
content_type = self.content_type
if input_stream is not None:
start_pos = input_stream.tell()
input_stream.seek(0, 2)
end_pos = input_stream.tell()
input_stream.seek(start_pos)
content_length = end_pos - start_pos
elif content_type == 'multipart/form-data':
values = CombinedMultiDict([self.form, self.files])
input_stream, content_length, boundary = \
stream_encode_multipart(values, charset=self.charset)
content_type += '; boundary="%s"' % boundary
elif content_type == 'application/x-www-form-urlencoded':
#py2v3 review
values = url_encode(self.form, charset=self.charset)
values = values.encode('ascii')
content_length = len(values)
input_stream = BytesIO(values)
else:
input_stream = _empty_stream
result = {}
if self.environ_base:
result.update(self.environ_base)
def _path_encode(x):
return wsgi_encoding_dance(url_unquote(x, self.charset),
self.charset)
qs = wsgi_encoding_dance(self.query_string)
result.update({
'REQUEST_METHOD': self.method,
'SCRIPT_NAME': _path_encode(self.script_root),
'PATH_INFO': _path_encode(self.path),
'QUERY_STRING': qs,
'SERVER_NAME': self.server_name,
'SERVER_PORT': str(self.server_port),
'HTTP_HOST': self.host,
'SERVER_PROTOCOL': self.server_protocol,
'CONTENT_TYPE': content_type or '',
'CONTENT_LENGTH': str(content_length or '0'),
'wsgi.version': self.wsgi_version,
'wsgi.url_scheme': self.url_scheme,
'wsgi.input': input_stream,
'wsgi.errors': self.errors_stream,
'wsgi.multithread': self.multithread,
'wsgi.multiprocess': self.multiprocess,
'wsgi.run_once': self.run_once
})
for key, value in self.headers.to_wsgi_list():
result['HTTP_%s' % key.upper().replace('-', '_')] = value
if self.environ_overrides:
result.update(self.environ_overrides)
return result
def test_start_page(self):
request_values = CombinedMultiDict([ImmutableMultiDict([('page', '2')]), ImmutableMultiDict([])])
expected = deepcopy(QueryBuilderSimple.DEFAULT_COMPONENTS)
expected['start'] = str((int(request_values.get('page')) - 1) * int(config.SEARCH_DEFAULT_ROWS))
actual = QueryBuilderSimple.build(request_values)
self.assertEqual(actual, expected)
def get_environ(self):
"""返回内置环境。"""
input_stream = self.input_stream
content_length = self.content_length
content_type = self.content_type
if input_stream is not None:
start_pos = input_stream.tell()
input_stream.seek(0, 2)
end_pos = input_stream.tell()
input_stream.seek(start_pos)
content_length = end_pos - start_pos
elif content_type == "multipart/form-data":
values = CombinedMultiDict([self.form, self.files])
input_stream, content_length, boundary = stream_encode_multipart(values, charset=self.charset)
content_type += '; boundary="%s"' % boundary
elif content_type == "application/x-www-form-urlencoded":
# py2v3 review
values = url_encode(self.form, charset=self.charset)
values = values.encode("ascii")
content_length = len(values)
input_stream = BytesIO(values)
else:
input_stream = _empty_stream
result = {}
if self.environ_base:
result.update(self.environ_base)
def _path_encode(x):
return wsgi_encoding_dance(url_unquote(x, self.charset), self.charset)
qs = wsgi_encoding_dance(self.query_string)
result.update(
{
"REQUEST_METHOD": self.method,
"SCRIPT_NAME": _path_encode(self.script_root),
"PATH_INFO": _path_encode(self.path),
"QUERY_STRING": qs,
"SERVER_NAME": self.server_name,
"SERVER_PORT": str(self.server_port),
"HTTP_HOST": self.host,
"SERVER_PROTOCOL": self.server_protocol,
"CONTENT_TYPE": content_type or "",
"CONTENT_LENGTH": str(content_length or "0"),
"wsgi.version": self.wsgi_version,
"wsgi.url_scheme": self.url_scheme,
"wsgi.input": input_stream,
"wsgi.errors": self.errors_stream,
"wsgi.multithread": self.multithread,
"wsgi.multiprocess": self.multiprocess,
"wsgi.run_once": self.run_once,
}
)
for key, value in self.headers.to_wsgi_list():
result["HTTP_%s" % key.upper().replace("-", "_")] = value
if self.environ_overrides:
result.update(self.environ_overrides)
return result
def movie_edit(id):
movie = Movie.query.get_or_404(id)
# 将file跟form表单内容整合
values = CombinedMultiDict([request.files, request.form])
# 强行加入id，让方便验证器验证唯一性
id_dict = MultiDict([('id', id)])
values = CombinedMultiDict([id_dict, values])
form = MovieEditForm(values)
if request.method == 'POST' and form.validate():
if form.url.data != "":
upload = Upload_file()
movie.url = upload.video(form.url.data)
if form.logo.data != "":
upload = Upload_file()
movie.logo = upload.video(form.logo.data)
data = form.data
# 存入url地址
data['url'] = movie.url
data['logo'] = movie.logo
# 将不是手动录入字段先保存修改
data['playnum'] = movie.playnum
data['commentnum'] = movie.commentnum
with db.auto_commit():
# 一键修改属性
movie.set_attr(data)
db.session.add(movie)
Oplog('修改电影:' + movie.title + ',id:' + str(movie.id))
flash('电影修改成功~', 'ok')
return redirect(url_for('admin.movie_edit', id=id))
tags = Tag.query.all()
return render_template('admin/movie_edit.html',
movie=movie,
tags=tags,
form=form)
def test_various_edge_cases_success():
post = MultiDict([
('user.name[]', 'john'),
('user.age[]', '30'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['user']['name'] == ['john']
assert result['user']['age'] == ['30']
post = MultiDict([
('user.name[]', 'john'),
('user.name[]', 'emma'),
])
get = MultiDict([])
payload = CombinedMultiDict([get, post])
result = request_parser.form_to_python(payload)
assert result['user']['name'] == ['john', 'emma']
def get_data(self,
with_view_args=True,
is_json=True,
copy=False,
use_args=False):
if is_json:
try:
data = request.get_json() or {}
if use_args:
data.update(request.args)
except Exception as exc:
raise InvalidUsage(
_('error decoding json from incoming request'))
else:
data = request.values
data = CombinedMultiDict([data, request.files])
output = {}
if copy:
# for some reason, following statement doesn't work
# output.update(data)
# so we have to use following statement
for k in data.keys():
output[k] = data[k]
if with_view_args:
output.update(request.view_args)
for key in self.field_names:
f = self.field_by_name[key]
f.validate(data, output)
return output
def get_environ(self):
"""Return the built environ."""
input_stream = self.input_stream
content_length = self.content_length
content_type = self.content_type
if input_stream is not None:
start_pos = input_stream.tell()
input_stream.seek(0, 2)
end_pos = input_stream.tell()
input_stream.seek(start_pos)
content_length = end_pos - start_pos
elif content_type == 'multipart/form-data':
values = CombinedMultiDict([self.form, self.files])
input_stream, content_length, boundary = \
stream_encode_multipart(values, charset=self.charset)
content_type += '; boundary="%s"' % boundary
elif content_type == 'application/x-www-form-urlencoded':
#py2v3 review
values = url_encode(self.form, charset=self.charset)
values = values.encode('ascii')
content_length = len(values)
input_stream = BytesIO(values)
else:
input_stream = _empty_stream
result = {}
if self.environ_base:
result.update(self.environ_base)
def _path_encode(x):
return wsgi_encoding_dance(url_unquote(x, self.charset), self.charset)
qs = wsgi_encoding_dance(self.query_string)
result.update({
'REQUEST_METHOD': self.method,
'SCRIPT_NAME': _path_encode(self.script_root),
'PATH_INFO': _path_encode(self.path),
'QUERY_STRING': qs,
'SERVER_NAME': self.server_name,
'SERVER_PORT': str(self.server_port),
'HTTP_HOST': self.host,
'SERVER_PROTOCOL': self.server_protocol,
'CONTENT_TYPE': content_type or '',
'CONTENT_LENGTH': str(content_length or '0'),
'wsgi.version': self.wsgi_version,
'wsgi.url_scheme': self.url_scheme,
'wsgi.input': input_stream,
'wsgi.errors': self.errors_stream,
'wsgi.multithread': self.multithread,
'wsgi.multiprocess': self.multiprocess,
'wsgi.run_once': self.run_once
})
for key, value in self.headers.to_wsgi_list():
result['HTTP_%s' % key.upper().replace('-', '_')] = value
if self.environ_overrides:
result.update(self.environ_overrides)
return result
def reload(self):
"""Reload user login information and saves them."""
data = self._login(self.uid, force=True)
acc = self._precache(data, force=True)
self.info.update(data)
CombinedMultiDict.__init__(self, [self.req, self.info, acc,
dict(CFG_USER_DEFAULT_INFO)])
self.save()
def url_map(self):
"""Build URL map."""
for handler_name, config in self.config.get('HANDLERS', {}).items():
if handler_name is None:
continue # we have already regitered default handler
self.register_handler(handler_name,
CombinedMultiDict([config, self.config]))
# Default handler at the end in case the weights are same.
self.register_handler(
None,
CombinedMultiDict(
[self.config.get('HANDLERS', {}).get(None, {}), self.config]))
return Map(self.rules, converters={'uri': URIConverter})
def payload():
""" Performs sanity checks or decoding depending on the Content-Type,
then returns the request payload as a dict. If request Content-Type is
unsupported, aborts with a 400 (Bad Request).
.. versionchanged:: 0.7
Allow 'multipart/form-data' form fields to be JSON encoded, once the
MULTIPART_FORM_FIELDS_AS_JSON setting was been set.
.. versionchanged:: 0.3
Allow 'multipart/form-data' content type.
.. versionchanged:: 0.1.1
Payload returned as a standard python dict regardless of request content
type.
.. versionchanged:: 0.0.9
More informative error messages.
request.get_json() replaces the now deprecated request.json
.. versionchanged:: 0.0.7
Native Flask request.json preferred over json.loads.
.. versionadded: 0.0.5
"""
content_type = request.headers.get('Content-Type', '').split(';')[0]
if content_type == 'application/json':
return request.get_json()
elif content_type == 'application/x-www-form-urlencoded':
return multidict_to_dict(request.form) if len(request.form) else \
abort(400, description='No form-urlencoded data supplied')
elif content_type == 'multipart/form-data':
# as multipart is also used for file uploads, we let an empty
# request.form go through as long as there are also files in the
# request.
if len(request.form) or len(request.files):
# merge form fields and request files, so we get a single payload
# to be validated against the resource schema.
formItems = MultiDict(request.form)
if config.MULTIPART_FORM_FIELDS_AS_JSON:
for key, lst in formItems.lists():
new_lst = []
for value in lst:
try:
new_lst.append(json.loads(value))
except ValueError:
new_lst.append(json.loads('"{0}"'.format(value)))
formItems.setlist(key, new_lst)
payload = CombinedMultiDict([formItems, request.files])
return multidict_to_dict(payload)
else:
abort(400, description='No multipart/form-data supplied')
else:
abort(400, description='Unknown or no Content-Type header supplied')
def upload():
if request.method == 'GET':
return render_template('upload.html')
else:
# desc = request.form.get('desc')
# image_file = request.files.get('image_file')
# # print(image_file)
# # print(type(image_file))
# # 参数：路径 文件名
# # images 1.jpg 木马文件 jpg png gig
# # 验证问题 重命名问题 文件名字+日期+随机数 uuid
# # image_file.save(upload_path, image_file.filename)
# filename = secure_filename(image_file.filename)
# image_file.save(os.path.join("images", filename))
# CombinedMultiDict 可以传入多个参数
form = UploadForm(CombinedMultiDict([request.form, request.files]))
if form.validate():
# desc = request.form.get('desc')
# image_file = request.files.get('image_file')
desc = form.desc.data
image_file = form.image_file.data
filename = secure_filename(image_file.filename)
image_file.save(os.path.join("images", filename))
return '文件上传成功'
else:
print(form.errors)
return "fail"
def user_profile_page():
# Initialize form
form = UserProfileForm(CombinedMultiDict((request.files, request.form)),
current_user)
# Process valid POST
if request.method == 'POST' and form.validate():
# Save photo
if form.photo.data.filename != "":
f = form.photo.data
img = process_profile_picture(f.stream)
orig_filename, file_extension = os.path.splitext(f.filename)
filename = str(uuid.uuid4()) + file_extension
img.save(os.path.join(app.instance_path, 'photos', filename))
current_user.photo_file_name = filename
# Copy form fields to user_profile fields
form.populate_obj(current_user)
# Save user_profile
db.session.commit()
flash('Profile updated successfully.', 'success')
# Process GET or invalid POST
return render_template('pages/user_profile_page.html', form=form)
def ledger():
form = forms.UploadLedgerCSVForm(
CombinedMultiDict((request.files, request.form)))
if form.validate_on_submit():
f = form.csv_file.data
file_uuid = str(uuid.uuid4())[0:8]
base_dir = "static/files/bank/"
if not os.path.exists(base_dir):
os.makedirs(base_dir)
file_path = f"{base_dir}/{file_uuid}.csv"
if not os.path.isfile(file_path):
f.save(file_path)
try:
google_sheets.import_bank_csv(file_path)
flash("Transactions uploaded successfully.", "success")
finally:
os.remove(file_path)
else:
flash("Failed to upload - File of same name already exists.",
"danger")
return redirect(url_for("trustee_routes.ledger"))
status, cookie = logins.validate_cookie(request.cookies.get('jam_login'))
volunteers = database.get_users(include_inactive=True)
base_transactions = google_sheets.get_transaction_table(logins=volunteers)
transactions = []
for transaction in base_transactions:
if transaction.bank_date:
transaction.user_id = cookie.user.user_id
transactions.append(transaction)
return render_template("trustee/ledger.html",
transactions=transactions,
trustees=volunteers,
container_name="container-wide",
form=form)
def feedback(self):
from werkzeug.datastructures import CombinedMultiDict
form = FeedbackForm(CombinedMultiDict((request.files, request.form)))
if request.method == "GET":
return template("support/feedback.html.j2", form=form)
elif request.method == "POST":
if not form.validate_on_submit():
return template("support/feedback.html.j2", form=form)
attachments = []
if form.feedback_file.data:
attachments = [form.feedback_file.data]
MailSender().send_email(
subject="[ketocalc] [{}]".format(form.option.data),
sender="ketocalc",
recipient_mails=["*****@*****.**"],
text_body="Message: {}\n Send by: {} [user: {}]".format(
form.message.data, form.email.data, current_user.username
),
html_body=None,
attachments=attachments,
)
flash("Vaše připomínka byla zaslána na vyšší místa.", "success")
return redirect(url_for("DashboardView:index"))
def post():
form = PhotoForm(CombinedMultiDict((request.files, request.form)))
if request.method == 'POST' and form.validate():
filename = '%s.%s' % (str(uuid.uuid4()),
secure_filename(form.input_photo.data.filename))
content_type = content_types[filename.split('.')[-1]]
write_retry_params = gcs.RetryParams(backoff_factor=1.1)
gcs_file = gcs.open('/%s/%s' % (bucket_name, filename), 'w',
retry_params=write_retry_params,
content_type=content_type,
options={'x-goog-acl': 'authenticated-read'})
for _ in form.input_photo.data.stream:
gcs_file.write(_)
gcs_file.close()
labels = get_labels(filename)
tags = [translate_text(label.description) for label in labels]
entity = Photo(id=filename, tags=tags,
parent=ndb.Key('User', 'default'))
entity.put()
for tag in tags:
entity = ndb.Key('User', 'default', 'Tags', tag).get()
if entity:
entity.count += 1
else:
entity = Tags(count=1, id=tag,
parent=ndb.Key('User', 'default'))
entity.put()
return render_template('post.html', storage_path=storage_path,
filename=filename, tags=tags)
else:
return redirect(url_for('photos'))
def yonetici_urunler_yeni():
if current_user.admin_mi:
form = forms.YeniUrunForm(
CombinedMultiDict((request.files, request.form)))
filename1 = ''
if form.validate_on_submit():
if form.image_1.data:
f = form.image_1.data
filename1 = secure_filename(f.filename)
f.save(
os.path.join(app.instance_path,
app.config['UPLOADED_IMAGES_DEST'],
filename1))
models.Urun.urun_ekle(ad=form.ad.data,
image_1=filename1,
adet=form.adet.data,
satis_fiyati=form.satis_fiyati.data,
kategori=form.kategori.data,
diger_detaylar=form.diger_detaylar.data)
return redirect(url_for('yonetici_urunler'))
return render_template("yonetici/html/urun/yeni.html",
user=current_user,
form=form)
else:
return redirect(url_for('index'))
def upload():
if request.method == 'GET':
return render_template('front/front_upload.html')
else:
form = UploadForm(CombinedMultiDict([request.form, request.files]))
if form.validate():
desc = request.form.get('desc', '这个人很懒，什么都没有留下！')
avator = request.files.get('avator')
filename = secure_filename(avator.filename)
timestamp = str(int(time.time()) * 1000)[:13]
filename = timestamp + '_' + filename
UPLOAD_PATH = os.path.join(os.getcwd(),
'utils/het_fiddler/datas/saz/')
avator.save(os.path.join(UPLOAD_PATH, filename))
exists_file = UploadFileForm.query.filter_by(
author_id=g.front_user.id).first()
if exists_file:
exists_file.file_url = UPLOAD_PATH
exists_file.file_name = filename
else:
_upload = UploadFileForm(desc=desc,
file_url=UPLOAD_PATH,
file_name=filename)
_upload.author = g.front_user
db.session.add(_upload)
db.session.commit()
return restful.success(message='文件上传成功！')
else:
return restful.params_error(message=form.get_error())
def newPost():
error = None
form = PostsForm(CombinedMultiDict((request.files, request.form)))
if request.method == 'POST' and form.validate_on_submit():
if form.photo.data:
photo = form.photo.data
caption = form.caption.data
if photo.filename == '':
error = 'No selected file'
if photo and allowed_file(photo.filename):
filename = secure_filename(photo.filename)
newpost = Posts(user_id=current_user.id,
image_URI=photo,
caption=caption)
photo.save(os.path.join(newpost.image_URI, filename))
db.session.add(newpost)
db.session.commit()
return jsonify({'messages': 'Photo Post successfully'})
else:
error = 'File not allowed'
return jsonify({'errors': error})
else:
caption = form.caption.data
newpost = Posts(user_id=current_user.id, caption=caption)
db.session.add(newpost)
db.session.commit()
return jsonify({'messages': 'Post successfully'})
else:
return jsonify({'errors': form_errors(form)})
def get_all(cls):
args = []
for d in request.args, request.form, request.json:
if not isinstance(d, MultiDict):
d = MultiDict(d)
args.append(d)
return CombinedMultiDict(args).to_dict()
def upload():
"""
上传图片用于训练
:return:
"""
form = CaptchaUploadForm(CombinedMultiDict([request.form, request.files]))
if form.validate():
# 公用项
img_bytes = form.captcha.data.stream.read()
# 自家验证码必备项
website = form.website.data
max_captcha = form.max_captcha.data
char_set = form.char_set.data
captcha_str = form.captcha_str.data
recognizer_key = make_recognizer_key(website, max_captcha, char_set)
file_name = make_pic_name_for_train(captcha_str)
train_path = os.path.join(CAPTCHA_TRAIN_FOLDER, recognizer_key)
if not os.path.isdir(train_path):
os.mkdir(train_path)
file_path = os.path.join(train_path, file_name)
with open(file_path, "wb") as f:
f.write(img_bytes)
return jsonify({"err_code": 200, "err_str": form.errors})
def post():
form = PhotoForm(CombinedMultiDict((request.files, request.form)))
if request.method == 'POST' and form.validate():
with tempfile.NamedTemporaryFile() as temp:
form.input_photo.data.save(temp)
temp.flush()
# print("............test one")
image = Image.open(temp.name).convert('RGB')
image.save("./static/images/" + "original.jpg")
# delete old output.png
if (os.path.isfile('/home/jetson/tensorpack/examples/FasterRCNN/output.png')):
os.remove('/home/jetson/tensorpack/examples/FasterRCNN/output.png')
#result_data = detect_objects(img)
#result= result_data['result']
while not os.path.isfile('/home/jetson/Documents/online_service/output.png'):
subprocess.call(['/home/jetson/Documents/online_service/web_predict.sh'])
result = cv2.imread('/home/jetson/tensorpack/examples/FasterRCNN/output.png',)
timestamp = str(time.time()) # add timestamp to image url to make Browser refresh without using cached image
result_img = result + "?" + timestamp # predict output image
img_timestamp = "./static/images/original.jpg?" + timestamp # uploaded original image
photo_form = PhotoForm(request.form)
return render_template('upload.html',photo_form=photo_form, result=result_img, color='red', original=img_timestamp)
def post():
form = MessageForm(CombinedMultiDict((request.files, request.form)))
if request.method == 'POST' and form.validate():
name = request.form['input_name']
message = request.form['input_message']
if form.input_photo.data.filename:
filename = '%s.%s' % (str(
uuid.uuid4()), secure_filename(form.input_photo.data.filename))
content_types = {
'jpg': 'image/jpeg',
'jpeg': 'image/jpeg',
'png': 'image/png',
'gif': 'image/gif'
}
content_type = content_types[filename.split('.')[-1]]
write_retry_params = gcs.RetryParams(backoff_factor=1.1)
gcs_file = gcs.open('/%s/%s' % (bucket_name, filename),
'w',
retry_params=write_retry_params,
content_type=content_type,
options={'x-goog-acl': 'public-read'})
for _ in form.input_photo.data.stream:
gcs_file.write(_)
gcs_file.close()
entry = Message(name=name, message=message, filename=filename)
else:
entry = Message(name=name, message=message, filename=None)
entry.put()
return render_template('post.html',
name=name,
timestamp=entry.timestamp)
else:
return redirect(url_for('messages'))
def workshop_files(workshop_id):
form = forms.UploadFileForm(CombinedMultiDict(
(request.files, request.form)),
csrf_enabled=False)
if form.validate_on_submit():
f = form.upload.data
print(f.filename)
filename = secure_filename(f.filename)
base_dir = "static/files/{}".format(workshop_id)
if not os.path.exists(base_dir):
os.makedirs(base_dir)
file_path = "{}/{}".format(base_dir, filename)
if not os.path.isfile(file_path):
f.save(file_path)
if request.form['file_title']:
file_title = request.form['file_title']
else:
file_title = secure_filename(f.filename)
database.add_workshop_file(file_title, file_path,
request.form['file_permission'],
workshop_id)
flash("File upload successful.", "success")
else:
flash("Failed to upload - File of same name already exists.",
"danger")
return redirect(
url_for('admin_routes.workshop_files', workshop_id=workshop_id))
workshop = database.get_workshop_from_workshop_id(workshop_id)
return render_template("admin/workshop_files.html",
workshop=workshop,
form=form)
def weixinpay():
"""微信支付"""
g.page_title = _(u'微信支付')
form = WeixinPayForm(CombinedMultiDict((request.files, request.form)))
ss = SysSetting.query.filter(
SysSetting.key == 'config_paymethod_weixin').first()
data = {}
try:
data = json.loads(ss.value)
except Exception as e:
data = {}
if request.method == 'GET':
form.fill_form(data=data)
form.apiclient_cert.data = data.get('apiclient_cert_url', '')
form.apiclient_key.data = data.get('apiclient_key_url', '')
return render_template('admin/config/weixinpay.html.j2', form=form)
data = {
'mch_id': form.mch_id.data,
'partner_key': form.partner_key.data,
'apiclient_cert': data.get('apiclient_cert', ''),
'apiclient_key': data.get('apiclient_key', '')
}
if not form.validate_on_submit():
form.apiclient_cert.data = data.get('apiclient_cert_url', '')
form.apiclient_key.data = data.get('apiclient_key_url', '')
return render_template('admin/config/weixinpay.html.j2', form=form)
# 证书文件cert上传
if form.apiclient_cert.data:
apiclient_cert = secure_filename(form.apiclient_cert.data.filename)
uploads_path = os.path.join(os.getcwd(), 'pem')
cert_filename = os.path.join(uploads_path, apiclient_cert)
if not os.path.exists(uploads_path):
os.makedirs(uploads_path)
form.apiclient_cert.data.save(cert_filename)
data['apiclient_cert'] = cert_filename
data['apiclient_cert_url'] = '/apiclient_cert.pem'
# 证书文件key上传
if form.apiclient_key.data:
apiclient_key = secure_filename(form.apiclient_key.data.filename)
uploads_path = os.path.join(os.getcwd(), 'pem')
key_filename = os.path.join(uploads_path, apiclient_key)
if not os.path.exists(uploads_path):
os.makedirs(uploads_path)
form.apiclient_key.data.save(key_filename)
data['apiclient_key'] = key_filename
data['apiclient_key_url'] = '/apiclient_key.pem'
if ss is None:
ss = SysSetting()
ss.key = 'config_paymethod_weixin'
db.session.add(ss)
ss.value = json.dumps(data)
db.session.commit()
return redirect(url_for('admin.index.success', title=_(u'设置微信支付成功')))
def sms_template():
"""短信模版"""
g.page_title = _(u'短信模版')
form = SmsTemplateForm(CombinedMultiDict((request.files, request.form)))
ss = SysSetting.query.\
filter(SysSetting.key == 'config_sms_template').first()
data = {}
try:
data = json.loads(ss.value)
except Exception as e:
log_info("[view.admin.config] [sms_template]:%s" % e.__str__())
if request.method == 'GET':
form.fill_form(data=data)
return render_template('admin/config/sms_template.html.j2', form=form)
if not form.validate_on_submit():
return render_template('admin/config/sms_template.html.j2', form=form)
data = {
'code_tpl': form.code_tpl.data,
'order_shipping_tpl': form.order_shipping_tpl.data
}
# 配置表中没该key,先添加该key
if ss is None:
ss = SysSetting()
ss.key = 'config_sms_template'
db.session.add(ss)
ss.value = json.dumps(data)
db.session.commit()
return redirect(url_for('admin.index.success', title=_(u'设置短信模版配置成功')))
def __init__(self, uid=None, force=False):
"""Retrieve information about user."""
def on_update(self):
"""Change own status when the user info is modified."""
self.modified = True
self.modified = False
self.uid = uid
self.req = self._get_request_info()
acc = {}
if uid is not None and uid > 0:
data = self._login(uid, force)
acc = self._precache(data, force)
else:
data = self._create_guest()
self.info = CallbackDict(data, on_update)
# FIXME remove req after everybody start using flask request.
CombinedMultiDict.__init__(self, [self.req, self.info, acc,
dict(CFG_USER_DEFAULT_INFO)])
self.save()
def test_combined_multidict():
"""Combined multidict behavior"""
d1 = MultiDict([("foo", "1")])
d2 = MultiDict([("bar", "2"), ("bar", "3")])
d = CombinedMultiDict([d1, d2])
# lookup
assert d["foo"] == "1"
assert d["bar"] == "2"
assert d.getlist("bar") == ["2", "3"]
assert sorted(d.items()) == [("bar", "2"), ("foo", "1")], d.items()
assert sorted(d.items(multi=True)) == [("bar", "2"), ("bar", "3"), ("foo", "1")]
assert "missingkey" not in d
assert "foo" in d
# type lookup
assert d.get("foo", type=int) == 1
assert d.getlist("bar", type=int) == [2, 3]
# get key errors for missing stuff
assert_raises(KeyError, lambda: d["missing"])
# make sure that they are immutable
def test_assign():
d["foo"] = "blub"
assert_raises(TypeError, test_assign)
# copies are immutable
d = d.copy()
assert_raises(TypeError, test_assign)
# make sure lists merges
md1 = MultiDict((("foo", "bar"),))
md2 = MultiDict((("foo", "blafasel"),))
x = CombinedMultiDict((md1, md2))
assert x.lists() == [("foo", ["bar", "blafasel"])]
def test_combined_multidict():
"""Combined multidict behavior"""
d1 = MultiDict([('foo', '1')])
d2 = MultiDict([('bar', '2'), ('bar', '3')])
d = CombinedMultiDict([d1, d2])
# lookup
assert d['foo'] == '1'
assert d['bar'] == '2'
assert d.getlist('bar') == ['2', '3']
assert sorted(d.items()) == [('bar', '2'), ('foo', '1')], d.items()
assert sorted(d.items(multi=True)) == [('bar', '2'), ('bar', '3'), ('foo', '1')]
assert 'missingkey' not in d
assert 'foo' in d
# type lookup
assert d.get('foo', type=int) == 1
assert d.getlist('bar', type=int) == [2, 3]
# get key errors for missing stuff
assert_raises(KeyError, lambda: d["missing"])
# make sure that they are immutable
def test_assign():
d['foo'] = 'blub'
assert_raises(TypeError, test_assign)
# copies are immutable
d = d.copy()
assert_raises(TypeError, test_assign)
# make sure lists merges
md1 = MultiDict((("foo", "bar"),))
md2 = MultiDict((("foo", "blafasel"),))
x = CombinedMultiDict((md1, md2))
assert x.lists() == [('foo', ['bar', 'blafasel'])]
if not isinstance(field, Field):
raise TypeError, 'field must be instance of class Field'
if field.name in self.field_by_name:
raise ValueError, 'a field named \'%s\' already exists' % field.name
self.field_names.append(field.name)
self.field_by_name[field.name] = field
def get_data(self, with_view_args=True, is_json=True, copy=False):
if is_json:
try:
data = request.get_json() or {}
except Exception, exc:
raise InvalidUsage(_('error decoding json from incoming request'))
else:
data = request.values
data = CombinedMultiDict([data, request.files])
output = {}
if copy:
# for some reason, following statement doesn't work
# output.update(data)
# so we have to use following statement
for k in data.keys():
output[k] = data[k]
if with_view_args:
output.update(request.view_args)
for key in self.field_names:
f = self.field_by_name[key]
f.validate(data, output)
return output
