def check_register():
try:
check_code = session.get('check_code')
if check_code != request.form['check_code']:
return '<script>alert("验证码错误!");location.href="/driver/register"</script>'
user_id = request.form['userID']
phone = session['register_phone']
user_name = request.form['user_name']
password = request.form['password']
ID_card_image = request.files['ID_card_image']
permit_card_image = request.files['permit_card_image']
car_image = request.files['car_image']
ID_filename = secure_filename(ID_card_image.filename)
permit_filename = secure_filename(permit_card_image.filename)
car_pic_filename = secure_filename(car_image.filename)
filename = []
filename.append(ID_filename)
filename.append(permit_filename)
filename.append(car_pic_filename)
for f in filename:
if '.' not in f or f.rsplit('.', 1)[1] not in app.config['ALLOW_FILE']:
return '<script>alert("非法后缀!");location.href="/driver/register"</script>'
ID_card_image.save(os.path.join(app.root_path, 'static/image/ID_card', ID_filename))
permit_card_image.save(os.path.join(app.root_path, 'static/image/permit_card', permit_filename))
car_image.save(os.path.join(app.root_path, 'static/image/car', car_pic_filename))
u = driver_account(phone, password, user_name, user_id, ID_filename, permit_filename, car_pic_filename)
db.session.add(u)
db.session.commit()
session.clear()
return '<script>alert("注册成功!");location.href="/driver/login"</script>'
except:
return '<script>alert("未知错误,请重试!");location.href="/driver/register"</script>'
def edit_file():
if request.method == 'GET':
fname = request.args.get('n')
fsize = "%d kB" % math.trunc(os.path.getsize(os.path.join(files_dir_os, fname)) / 1024)
events = TennisEvent.get_events_with_att(fname)
src = EventSource.get(os.path.join(fname[:4], fname[5:])) # Todo: od klicu sestavim z '/', ne glede na OS
title = src['desc'] if src else ""
view = src['view'] if src and src in ['0', '1'] else "1"
# log_info("view=%s." % view)
players = src['players_on_pic'] if src else ""
return render_template("editFile.html", year=fname[:4], fname=fname[5:], fsize=fsize,
years=TennisEvent.Years, events=events, title=title, view=view, players=players)
elif request.method == 'POST':
old_year, old_fname = request.form['old_year'], request.form['old_fname']
new_year = secure_filename(request.form.get('new_year') or old_year)
new_fname = secure_filename(request.form['new_fname'])
old_title, new_title = request.form['old_title'], request.form['new_title']
old_view, new_view = request.form['old_view'], request.form['new_view']
old_players, new_players = request.form['old_players'], request.form['new_players']
old_att = os.path.join(files_dir_os, old_year, old_fname)
new_att = os.path.join(files_dir_os, new_year, new_fname)
if request.form["Status"][:5] == unicode("Popravi"[:5]):
log_info("Audit: rename file %s/%s to %s/%s" % (old_year, old_fname, new_year, new_fname))
os.rename(old_att, new_att)
TennisEvent.update_all_atts(old_year, old_fname, new_fname)
# ToDo: delete old entry, if necessary (year | file_name changes)
s = EventSource(file_name=os.path.join(new_year, new_fname),
desc=new_title, view=new_view, players_on_pic=new_players)
s.update()
elif request.form["Status"][:5] == unicode("Kopiraj"[:5]):
log_info("Audit: copy file %s/%s to %s/%s" % (old_year, old_fname, new_year, new_fname))
shutil.copyfile(old_att, new_att)
return redirect(request.args.get("next") or url_for("tennis_events_old"))
def uploadBathymetry(region):
if not isAuth(request.headers):
return jsonify(success=False, message="Forbidden"), 403
if not ("dataFile" in request.files):
return jsonify(success=False, message="No input file provided"), 400
bathyFile = request.files["dataFile"]
result = False
if bathyFile and not (bathyFile.filename == ""):
try:
fullPath = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename("{}_{}".format(int(time.time()), bathyFile.filename)))
bathyFile.save(fullPath)
try:
result = importBathymetry(fullPath, os.path.join("data", secure_filename("{}.json".format(region))))
except:
pass
os.remove(fullPath)
except:
pass
try:
bathyFile.close()
except:
pass
return jsonify(success=result, message="Bathymetry added" if result else "Could not parse/add input file"), 200 if result else 500
def shapefile_upload():
shapefiles = request.files.getlist('shapefile[]')
if len(shapefiles) == 0:
# todo -- not supposed to come here; if this is keeps not being printed out, remove the whole if-clause
print('Apparently uploaded empty list of files...?')
return '200'
shapefile_name = secure_filename(shapefiles[0].filename)
shapefile_name = shapefile_name[:shapefile_name.index('.')] + '.shp'
path = str(os.path.join(get_shape_path(), shapefile_name))
already_registered = Shapefile.query.filter(Shapefile.path == path).count() > 0
if already_registered:
print('Shapefile \''+ shapefile_name + '\' has already been uploaded before.')
return '200'
if not os.path.exists(get_shape_path()):
os.makedirs(get_shape_path())
for file in shapefiles:
filename = secure_filename(file.filename)
target = os.path.join(get_shape_path(), filename)
file.save(target)
print('Successfully uploaded file \'' + target + '\'')
persist(shapefile_name, path)
return '200'
def test_secure_filename():
assert utils.secure_filename('My cool movie.mov') == 'My_cool_movie.mov'
assert utils.secure_filename('../../../etc/passwd') == 'etc_passwd'
assert utils.secure_filename(u'i contain cool \xfcml\xe4uts.txt') == \
'i_contain_cool_umlauts.txt'
assert utils.secure_filename('__filename__') == 'filename'
assert utils.secure_filename('foo$&^*)bar') == 'foobar'
def get_ldd(campaign_model):
env = dict(os.environ)
if 'LD_LIBRARY_PATH' in env:
env['LD_LIBRARY_PATH'] = ':' + env['LD_LIBRARY_PATH']
else:
env['LD_LIBRARY_PATH'] = ''
env['LD_LIBRARY_PATH'] = os.path.join(current_app.config['DATA_DIRECTORY'], secure_filename(campaign_model.name), 'libraries') + env['LD_LIBRARY_PATH']
try:
p = subprocess.Popen(['ldd', os.path.join(current_app.config['DATA_DIRECTORY'], secure_filename(campaign_model.name), 'executable')], env=env, stdout=subprocess.PIPE)
process_output = p.communicate()
except FileNotFoundError:
ldd = None
else:
ldd = []
for line in process_output[0].decode('ascii').split('\n'):
if not line or line[0] != '\t':
continue
parts = line.split()
if len(parts) < 3:
continue
found = 'not found' not in line
if found:
path = parts[2]
if path.startswith(current_app.config['DATA_DIRECTORY']):
ldd_row = (parts[0], 'info', path.rsplit(os.path.sep, 1)[-1])
else:
ldd_row = (parts[0], '', path)
else:
ldd_row = (parts[0], 'danger', 'Not Found')
if ldd_row not in ldd:
ldd.append(ldd_row)
return ldd
def test_secure_filename(self):
self.assert_equal(utils.secure_filename('My cool movie.mov'),
'My_cool_movie.mov')
self.assert_equal(utils.secure_filename('../../../etc/passwd'),
'etc_passwd')
self.assert_equal(utils.secure_filename(u'i contain cool \xfcml\xe4uts.txt'),
'i_contain_cool_umlauts.txt')
def upload(app, url):
if 'file' not in request.files:
raise InvalidUsage('No file attached')
file = request.files['file']
if secure_filename(file.filename)[-4:] !='.zip':
raise InvalidUsage('The uploaded file is not a zipfile.')
target_folder = join(app.projects_path(), secure_filename(file.filename)[:-4])
if not commonprefix([target_folder, app.projects_path()]) == app.projects_path(): # out of the server folder
raise InvalidUsage('Invalid filename')
if not exists(target_folder):
makedirs(target_folder)
else:
raise InvalidUsage('Project of the same name already exists.')
try:
zip_ref = zipfile.ZipFile(file, 'r')
except:
raise InvalidUsage('The file ' + file + ' is not recognised as a zip file.')
try:
zip_ref.extractall(target_folder)
except:
raise InvalidUsage('The extraction of the file ' + file + ' failed.')
if not exists(join(target_folder, configure_filename)):
shutil.rmtree(target_folder)
raise InvalidUsage('The file does not contain a tremppi project.')
write_projects(app.projects_path())
return 'upload successful'
def stl_upload_temp():
f = request.files['the_file']
f.save(os.path.join(TEMPORARY_UPLOAD_PATH, secure_filename(f.filename)))
stl_object = stlutils.get_stl_object_by_name(os.path.join(TEMPORARY_UPLOAD_PATH, secure_filename(f.filename)))
scale_dict = stlutils.get_object_scale(stl_object)
os.remove(os.path.join(TEMPORARY_UPLOAD_PATH, secure_filename(f.filename)))
return json.dumps(scale_dict)
def upload_image():
if request.method == "POST":
f = request.files["file"]
bf = request.files["blurred_file"]
if f and bf:
filename = os.path.join(app.config["UPLOAD_FOLDER"],
secure_filename(f.filename))
blurred_filename = os.path.join(app.config["UPLOAD_FOLDER"],
secure_filename(bf.filename))
f.save(filename)
bf.save(blurred_filename)
if query_db("select * from images where title = ?",
[request.form["title"]], one=True) is None:
db = get_db()
# TODO: We should actually have a check box for has nudity and
# also accept a second file upload for the blurred file
db.execute("""insert into images (title, artist, work_type,
culture, has_nudity, filename, blurred_filename)
values (?, ?, ?, ?, ?, ?, ?)""", [request.form["title"],
request.form["artist"], request.form["work_type"],
request.form["culture"], False, filename, blurred_filename])
db.commit()
return redirect("/upload")
return """
def upload():
""" File uploading handler. """
url = request.args.get('url', None)
delete = request.args.get('delete', None)
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(safe_join(app.config['UPLOAD_FOLDER'], filename))
flash('File ' + filename + ' was uploaded!', 'info')
else:
flash('File was not uploaded!', 'error')
if url is not None:
file = file_from_url(url)
if file and allowed_file(file['name']):
file_name = secure_filename(file['name'])
file_path = safe_join(app.config['UPLOAD_FOLDER'], file_name)
with open(file_path, 'wb') as f:
f.write(file['content'])
flash('File ' + file_name + ' was uploaded!', 'info')
else:
flash('Can not download file!', 'error')
if delete is not None:
file = safe_join(app.config['UPLOAD_FOLDER'], delete)
try:
os.remove(file)
flash('Success!', 'info')
except FileNotFoundError:
flash('File not found!', 'error')
except Exception:
abort(500)
files = show_files()
return render_template('upload.html', context={"files": files})
def tugas_create():
form = TugasForm(request.form)
if form.validate_on_submit():
tugas = Tugas()
form.populate_obj(tugas)
user = g.user
matkul = MataKuliah.get(MataKuliah.dosen == user)
tugas.mata_kuliah = matkul
tugas.save()
file_list = request.files.getlist('file_pendukung')
for f in file_list:
if isinstance(f, FileStorage) and len(f.filename) != 0:
import os
path = generate_path()
save_to = os.path.join(path, secure_filename(user.email))
if not os.path.exists(save_to):
os.makedirs(save_to)
tujuan = os.path.join(save_to, secure_filename(f.filename))
f.save(tujuan)
p = Phile.create(
filename=f.filename,
filepath=tujuan,
filetype=f.mimetype
)
TugasFile.create(tugas=tugas, phile=p)
flash('Sukses membuat tugas')
return redirect(url_for('dosen:tugas:list'))
return render_template('dosen/tugas/create.html', form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR"]):
os.makedirs(app.config["UP_DIR"])
os.chmod(app.config["UP_DIR"], "rw")
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie = Movie(
title=data['title'],
url=url,
info=data["info"],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"],
)
db.session.add(movie)
db.session.commit()
flash("添加电影成功!", "ok")
return redirect(url_for('admin.movie_add'))
return render_template("admin/movie_add.html", form=form)
def post():
"""
Upload new wallet
"""
parser = reqparse.RequestParser()
parser.add_argument('filename', required=True, help='File name', location="form")
parser.add_argument('file', type=FileStorage, required=True, help='File', location='files')
args = parser.parse_args()
file_path = os.path.join(current_app.config['UPLOAD_FOLDER'], secure_filename(args['filename']))
args['file'].save(file_path)
bsd_db = db.DB()
try:
bsd_db.open(file_path, flags=db.DB_RDONLY)
except db.DBError:
os.unlink(file_path)
return {'result_status': False, 'message': 'File damaged or incorrect'}, 500
new_wallet = Wallets(user_id=current_user.id,
name=secure_filename(args['filename']),
path=file_path)
connection.session.add(new_wallet)
connection.session.commit()
return {'result_status': True, 'result': 'Uploaded'}, 201
def import_bookmarks():
"""Import bookmarks from file with json format."""
if request.method == 'POST':
filefile = request.files['file']
if filefile:
secure_filename(filefile.filename)
data = filefile.read()
try:
decoded_data = data.decode('unicode_escape')
json_data = json.loads(decoded_data)
for category_name, value in json_data.items():
category = Category(name=category_name.lower())
db.session.add(category)
db.session.flush()
db.session.refresh(category)
if isinstance(value, list):
for link in value:
bookmark = Bookmark(
title=urlparse(link).netloc, url=link,
category_id=category.id, user_id=g.user.id)
db.session.add(bookmark)
elif isinstance(value, dict):
for title, link in value.items():
bookmark = Bookmark(title=title, url=link,
category_id=category.id,
user_id=g.user.id)
db.session.add(bookmark)
db.session.commit()
except Exception as e:
db.session.rollback()
with open('my_error_log.txt') as fob:
fob.write(str(e))
return render_template('bookmarks/import_bookmarks.html')
def upload(upload_file, image_data, user):
"""Upload a photo to the blobstore and create a photo entity to index it.
Args:
upload_file: the file the user uploaded.
image_data: the raw file data to be stored as a blob.
user: the user who uploaded the file.
Returns:
the photo entity for the uploaded file.
"""
filename = secure_filename(upload_file.filename)
blob_key = _write_to_blobstore(filename, image_data,
upload_file.content_type)
image = Image.open(StringIO(image_data))
thumbnail = _create_circle_thumbnail(image)
thumb_filename = secure_filename('%s_thumb' % upload_file.filename)
thumb_key = _write_to_blobstore(thumb_filename, thumbnail, 'image/png')
exif_data = exif.get_exif_data(image)
lat, lon = exif.get_lat_lon(exif_data)
coordinates = None if not lat or not lon else ndb.GeoPt(lat, lon)
timestamp = exif.get_datetime(exif_data)
photo = Photo(name=filename, owner=user.key, primary_blob_key=blob_key,
thumb_blob_key=thumb_key, coordinates=coordinates,
timestamp=timestamp)
photo.put()
return photo
def check_register():
driver = driver_account.query.filter(driver_account.phone == session['register_phone'])
if driver != []:
return json.dumps({'status': '310'})
try:
user_id = request.values.get('userID') # 身份证号
phone = session['register_phone']
user_name = request.values.get('user_name') # 用户名
password = request.values.get('password') # 密码
ID_card_image = request.files['ID_card_image'] # 身份证照片
permit_card_image = request.files['permit_card_image'] # 驾驶证照片
car_image = request.files['car_image'] # 行驶证照片
ID_filename = secure_filename(ID_card_image.filename)
permit_filename = secure_filename(permit_card_image.filename)
car_pic_filename = secure_filename(car_image.filename)
filename = []
filename.append(ID_filename)
filename.append(permit_filename)
filename.append(car_pic_filename)
for f in filename:
if '.' not in f or f.rsplit('.', 1)[1] not in app.config['ALLOW_FILE']:
return json.dumps({'status': '404'})
ID_card_image.save(os.path.join(app.root_path, 'static/image/ID_card', ID_filename))
permit_card_image.save(os.path.join(app.root_path, 'static/image/permit_card', permit_filename))
car_image.save(os.path.join(app.root_path, 'static/image/car', car_pic_filename))
u = driver_account(phone, password, user_name, user_id, ID_filename, permit_filename, car_pic_filename)
db.session.add(u)
db.session.commit()
return json.dumps({'status': '340'})
except:
return json.dumps({'status': '350'})
def upload_file():
if not session.get('logged_in'):
abort(404)
# List images os.listdir(os.path.join(getcwd(),'static/'))
images = os.listdir(app.config['UPLOAD_FOLDER'])
if request.method == 'POST':
try:
file = request.files['file']
except RequestEntityTooLarge:
abort(413)
if not file:
error = u'Select a file please.'
return render_template('upload.html', **locals())
# file ok, type ok
elif file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
info = u'The file {} has been successfully uploaded.'.format(filename)
return render_template('upload.html', **locals())
# file ok, type ko
elif file and not allowed_file(file.filename):
filename = secure_filename(file.filename)
error = u'File extension {} not allowed'.format(filename)
return render_template('upload.html', **locals())
return render_template('upload.html', images=images)
def edit_waterproofing(id):
report = Report.query.get(id)
form = ReportForm(obj=report)
if request.method == 'POST':
if request.form['action'] == 'Upload':
form.populate_obj(report)
bim_file = form.bimimg.data
if bim_file and allowed_file(bim_file.filename):
bim_filename = secure_filename(str(uuid.uuid4()) + bim_file.filename)
bim_file.save(os.path.join(app.config['UPLOAD_FOLDER'], bim_filename))
report.bimimg_filename = bim_filename
site_file = form.siteimg.data
if site_file and allowed_file(site_file.filename):
site_filename = secure_filename(str(uuid.uuid4()) + site_file.filename)
site_file.save(os.path.join(app.config['UPLOAD_FOLDER'], site_filename))
report.siteimg_filename = site_filename
report.site_caption = form.site_caption.data
report.date = form.date.data
report.note = form.note.data
report.summary = form.summary.data
db.session.commit()
return redirect(url_for('report_waterproofing'))
elif request.form['action'] == 'Edit Previous':
id_object = form.edit_date.data
r = Report.query.get(id_object.id)
id = r.id
return redirect(url_for('edit_waterproofing', id=id))
elif request.method == 'GET':
return render_template('create_waterproofing.html', form=form, data_type=report.date, action="Edit")
def _make_zip(self, project, ty):
name = self._project_name_latin_encoded(project)
dataframe = self._respond_csv(ty, project.id)
if dataframe is not None:
info_dataframe = self._respond_csv(ty, project.id, info_only=True)
datafile = tempfile.NamedTemporaryFile()
info_datafile = tempfile.NamedTemporaryFile()
try:
dataframe.to_csv(datafile, index=False,
encoding='utf-8')
info_dataframe.to_csv(
info_datafile, index=False, encoding='utf-8')
datafile.flush()
info_datafile.flush()
zipped_datafile = tempfile.NamedTemporaryFile()
try:
_zip = self._zip_factory(zipped_datafile.name)
_zip.write(
datafile.name, secure_filename('%s_%s.csv' % (name, ty)))
_zip.write(
info_datafile.name, secure_filename('%s_%s_info_only.csv' % (name, ty)))
_zip.close()
container = "user_%d" % project.owner_id
_file = FileStorage(
filename=self.download_name(project, ty), stream=zipped_datafile)
uploader.upload_file(_file, container=container)
finally:
zipped_datafile.close()
finally:
datafile.close()
info_datafile.close()
def create_waterproofing():
#figure out how to resize the image
form = ReportForm()
if request.method == 'POST':
if request.form['action'] == 'Upload':
bim_file = form.bimimg.data
if bim_file and allowed_file(bim_file.filename):
bim_filename = secure_filename(str(uuid.uuid4()) + bim_file.filename)
bim_file.save(os.path.join(app.config['UPLOAD_FOLDER'], bim_filename))
else:
bim_filename = ""
site_file = form.siteimg.data
if site_file and allowed_file(site_file.filename):
site_filename = secure_filename(str(uuid.uuid4()) + site_file.filename)
site_file.save(os.path.join(app.config['UPLOAD_FOLDER'], site_filename))
else:
site_filename = ""
f = Report(bimimg_filename = bim_filename, siteimg_filename = site_filename, site_caption = form.site_caption.data, date = form.date.data, note = form.note.data, summary = form.summary.data)
db.session.add(f)
db.session.commit()
return redirect(url_for('report_waterproofing'))
elif request.form['action'] == 'Edit Previous':
id_object = form.edit_date.data
r = Report.query.get(id_object.id)
id = r.id
return redirect(url_for('edit_waterproofing', id=id))
elif request.method == 'GET':
return render_template('create_waterproofing.html', form=form, data_type="Weekly Report", action="Add a")
def upload():
if request.method == 'POST':
# try:
pid = request.form["pid"]
file_synonym = request.files["file1"]
file_knowledge = request.files["file2"]
print(file_synonym.filename)
print(file_knowledge.filename)
print(">>>>>>>")
basepath = os.path.dirname(__file__)
upload_path_synonyms = os.path.join(basepath, "load_file", "synonyms",
secure_filename(file_synonym.filename))
upload_path_knowledge = os.path.join(basepath, "load_file", "knowledge",
secure_filename(file_knowledge.filename))
upload_path_knowledge = os.path.join('/home/xp/work/upload_file/load_file/knowledge', file_knowledge.filename)
print('------------', upload_path_synonyms)
print('------------', upload_path_knowledge)
file_synonym.save(upload_path_synonyms)
file_knowledge.save(upload_path_knowledge)
redirect(url_for('upload',file_name=file_synonym.filename))
redirect(url_for('upload', file_name=file_knowledge.filename))
print("保存成功")
# except Exception as e:
# print("失败",e)
# print(">>>MMMM")
return render_template('index.html')
def upload_game_file(platform_id): """Upload a game rom file to the platforms rom folder.""" try: f = request.files['file'] platform = models.Platform.query.get_or_404(platform_id) file_type = os.path.splitext(utils.secure_filename(f.filename))[1][1:] filename_noExtension = os.path.splitext(utils.secure_filename(f.filename))[0] full_filename = utils.secure_filename(f.filename) if file_type == platform.extension: # is this the file type we are using for roms? if not os.path.exists(platform.roms_path): os.makedirs(platform.roms_path) f.save(os.path.join(platform.roms_path, full_filename)) game_id = ScanRoms.addGameRom(str(platform.id), filename_noExtension) return jsonify(result='OK', file_name=filename_noExtension, file_type=file_type, game_id=game_id) else: return jsonify(result='ERROR', file_name=filename_noExtension, file_type=file_type, msg='Wrong file extension for platforms settings. Received ' + file_type + ' should be ' + platform.extension) except Exception, e: return jsonify(result='ERROR', file_name=filename_noExtension, file_type=file_type, msg=str(e))
def upload_site_images():
if request.files and len(request.files) > 0 and request.files['file']:
file_body = request.files['file']
if allowed_files(secure_filename(file_body.filename)):
filename = secure_filename(str(uuid4()) + "." + file_body.filename.split('.')[1])
file_body.save(os.path.join(upload_folder, filename))
return json.dumps({"status": "success", "id": filename, "filename": filename})
return '', 404
def section(chapter, section):
chapter = secure_filename(chapter)
section = secure_filename(section)
path = os.path.join(BOOK_DIR, chapter, section)
with codecs.open(path, 'r', 'utf-8') as f:
content = f.read()
content = Markup(markdown(content))
return render_template('page.html', **locals())
def save_mp3():
newfile = request.files['newmp3']
filename = secure_filename(newfile.filename)
## Bijzondere situatie: een geloade soundfile kan niet worden overschreven
if currenttrack == filename:
filename = "_" + secure_filename(newfile.filename)
logger.info("Saving new sound file " + filename)
newfile.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return redirect("/")
def test_secure_filename():
assert utils.secure_filename("My cool movie.mov") == "My_cool_movie.mov"
assert utils.secure_filename("../../../etc/passwd") == "etc_passwd"
assert (
utils.secure_filename(u"i contain cool \xfcml\xe4uts.txt")
== "i_contain_cool_umlauts.txt"
)
assert utils.secure_filename("__filename__") == "filename"
assert utils.secure_filename("foo$&^*)bar") == "foobar"
def upload_video():
if current_user.is_anonymous():
return '{"state":"fail"}'
postBody = request.form
live = postBody.get("live", "0") == "0"
if live:
# video
try:
UPLOAD_FOLDER = "youmu/static/uploads/videos/"
ALLOWED_MIMETYPES = ("video/mp4", "video/x-matroska", "audio/mpeg")
f = request.files["video"]
ascii_name = f.filename.encode("ascii", "xmlcharrefreplace")
fname = mktemp(suffix='_', prefix='u', dir=UPLOAD_FOLDER) + secure_filename(ascii_name)
f.save(fname)
mime_type = mimetypes.guess_type(fname)[0]
if mime_type not in ALLOWED_MIMETYPES:
os.remove(fname)
return json.dumps({"state":"fail", "content":"wrong mime type"}, ensure_ascii = False)
fname = str(fname)
fname = fname[fname.find("/"):]
media_type = "audio" if mime_type.find("mp3") != -1 else "video"
except:
return json.dumps({"state":"fail", "content":"video/audio upload failed"}, ensure_ascii = False)
url = ""
else:
media_type = "live"
url = postBody.get("rtmp", "")
fname = ""
# cover
try:
UPLOAD_FOLDER = "youmu/static/uploads/images/"
ALLOWED_MIMETYPES = ("image/png", "image/jpeg", "image/jpg", "image/bmp")
f = request.files["cover"]
ascii_name = f.filename.encode("ascii", "xmlcharrefreplace")
pname = mktemp(suffix='_', prefix='u', dir=UPLOAD_FOLDER) + secure_filename(ascii_name)
f.save(pname)
if mimetypes.guess_type(pname)[0] not in ALLOWED_MIMETYPES:
os.remove(pname)
return json.dumps({"state":"fail", "content":"wrong mime type"}, ensure_ascii = False)
pname = str(pname)
pname = pname[pname.find("/"):]
except:
pname = ""
# other information
category = postBody.get("category", "")
if not category in VideoService.get_categories(): category = ""
obj = Video(owner_id = current_user.id,
title = postBody["title"],
upload_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())),
cover = pname,
category = category,
description = postBody["description"],
media_type = media_type,
url = url)
VideoService.insert_video(obj, fname)
return json.dumps({"state":"success"}, ensure_ascii = False)
def index():
form = ProcessForm(request.form)
# If there are form errors it will not pass form.validate() and
# will fall through to the "GET" handler, passing along the errors
# to the template.
# This means we don't have to check the presence of (most) options
if request.method == 'POST' and form.validate():
schema_language = request.form.get('schema_language', None)
source_option = request.form.get('source_options', None)
canonicalized_source = request.files.get('source_canonical_file', None)
customization_option = request.form.get('customization_options', None)
local_customization = request.files.get('local_customization_file', None)
verbose_output = request.form.get('verbose_output', None)
uploaded_customization = None
# at this point the form will have been checked to make sure the local customization
# file is present if the local customization option is selected,
# but we'll do another sanity check here just to make sure.
if customization_option == 'z-local-customization' and local_customization is not None:
tmpdir = tempfile.mkdtemp()
filename = secure_filename(local_customization.filename)
uploaded_customization = os.path.join(tmpdir, filename)
local_customization.save(uploaded_customization)
uploaded_source = None
if source_option == 'local-source' and canonicalized_source is not None:
tmpdir = tempfile.mkdtemp()
filename = secure_filename(canonicalized_source.filename)
uploaded_source = os.path.join(tmpdir, filename)
canonicalized_source.save(uploaded_source)
verbose = False
if verbose_output == "y":
verbose = True
res = None
res = package_files.apply_async(args=[schema_language, source_option, customization_option],
kwargs={"uploaded_customization": uploaded_customization,
"uploaded_source": uploaded_source,
"verbose": verbose})
return redirect(url_for('process_and_download') + "?cid=" + str(res))
latest_git_revisions = None
with open(os.path.join(app.root_path, 'info.json'), 'r') as info:
js = json.load(info)
latest_git_revisions = js.get('mei_git_revisions', None)
tei_stylesheets_version = js.get('tei_stylesheets_version', None)
d = {
'latest_revisions': latest_git_revisions,
'tei_stylesheets_version': tei_stylesheets_version,
}
return render_template("index.html", form=form, **d)
def _path_to_image(self, name, extension, mode=None, size=None):
if mode:
filename = secure_filename('%s-%dx%d.%s' % (mode, size[0], size[1], extension))
directory = self._manipulated_directory(name, extension)
else:
filename = secure_filename(name + '.' + extension)
directory = self._image_dir
if not op.isdir(directory):
os.makedirs(directory)
return safe_join(directory, filename)
def submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.SubmitStartForm(request.POST)
if request.method == 'POST' and submit_form.validate():
if not (request.POST.has_key('file')
and isinstance(request.POST['file'], FieldStorage)
and request.POST['file'].file):
submit_form.file.errors.append(
u'You must provide a file.')
elif not security.check_filetype(request.POST['file']):
submit_form.file.errors.append(
u'The file doesn\'t seem to be an image!')
else:
filename = request.POST['file'].filename
# create entry and save in database
entry = request.db.MediaEntry()
entry['title'] = (
request.POST['title']
or unicode(splitext(filename)[0]))
entry['description'] = request.POST.get('description')
entry['description_html'] = cleaned_markdown_conversion(
entry['description'])
entry['media_type'] = u'image' # heh
entry['uploader'] = request.user['_id']
# Save, just so we can get the entry id for the sake of using
# it to generate the file path
entry.save(validate=False)
# Generate a slug from the title
entry.generate_slug()
# Now store generate the queueing related filename
queue_filepath = request.app.queue_store.get_unique_filepath(
['media_entries',
unicode(entry['_id']),
secure_filename(filename)])
# queue appropriately
queue_file = request.app.queue_store.get_file(
queue_filepath, 'wb')
with queue_file:
queue_file.write(request.POST['file'].file.read())
# Add queued filename to the entry
entry['queued_media_file'] = queue_filepath
entry.save(validate=True)
# queue it for processing
process_media_initial.delay(unicode(entry['_id']))
return redirect(request, "mediagoblin.submit.success")
return render_to_response(
request,
'mediagoblin/submit/start.html',
{'submit_form': submit_form})
def get_basename(self, filename):
return lowercase_ext(secure_filename(filename))
def namegen_filename(obj, file_data):
"""
Generate secure filename for uploaded file.
"""
return secure_filename(file_data.filename)
def update_tool_submit(token):
"""
Update tool page, takes care of the form submission
"""
payload = verify_email_token(token)
if not payload:
flash('Link expired, try again')
return redirect(url_for('index'))
paper = Paper.query.get(payload['paper_id'])
form = toolUpdate()
if form.validate_on_submit():
paper.tool_name = form.toolname.data
paper.paper_name = form.papername.data
paper.author_name = form.authorname.data
paper.author_email = form.authoremail.data
paper.description = form.description.data
paper.bibtex = form.bibtex.data
paper.category = form.category.data
paper.link_to_pdf = form.linktopdf.data
paper.link_to_demo = form.linktodemo.data
paper.link_to_tool_webpage = form.linktotoolwebpage.data
paper.link_to_archive = form.linktoarchive.data
paper.year = form.year.data
paper.conference = form.conference.data
paper.tags = []
for tag in form.tags.data.split(","):
tag_obj = db.session.query(Tag).filter(
Tag.tagname == tag.strip()).first()
if tag_obj is None:
tag_obj = Tag(tagname=tag.strip())
paper.tags.append(tag_obj)
db.session.flush()
db.session.commit()
filenames = []
fileurls = []
filetypes = form.file_types.data.split(',')
for file in form.all_files.data:
if not isinstance(file, str):
filenames.append(secure_filename(file.filename))
filename = '{}/{}'.format(paper.id,
secure_filename(file.filename))
file.filename = filename # updating the name with paper.id for easy access
bucket_location = s3.get_bucket_location(
Bucket=app.config['S3_BUCKET'])
s3_url = "https://s3.{0}.amazonaws.com/{1}/{2}".format(
bucket_location['LocationConstraint'],
app.config['S3_BUCKET'], filename)
upload_file_to_s3(s3, file, app.config['S3_BUCKET'])
fileurls.append(s3_url)
# print("Uploaded files below for paper: {}".format(paper.id))
# print(fileurls)
existing_files = [x.filename for x in paper.files]
for filename, fileurl, filetype in zip(filenames, fileurls, filetypes):
if filename not in existing_files:
paper.files.append(
File(filename=filename, filetype=filetype,
fileurl=fileurl))
db.session.flush()
db.session.commit()
flash('Tool information update successfully')
return render_template('index.html')
return render_template('tool_update.html',
title="Update your tool here",
form=form)
def delete_user_picture(filename):
delete_file = secure_filename(filename)
os.remove(os.path.join(app.config['USER_UPLOAD_FOLDER'], delete_file))
return
def add_admin():
res = {}
file = request.files['image']
if 'firstname' in request.form and 'lastname' in request.form and 'email' in request.form and 'password' in request.form:
firstname = request.form['firstname']
lastname = request.form['lastname']
email = request.form['email']
password = request.form['password']
position = request.form['position']
phone = request.form['phone']
role = request.form['role']
user_type = request.form['user_type']
print(request.files['image'])
get_filename = secure_filename(file.filename)
filename, file_extension = os.path.splitext(get_filename)
today = datetime.date.today()
today = str(today)
#encodedBytes = base64.b64encode(today.encode("utf-8"))
#encodedStr = str(encodedBytes, "utf-8")
filename = today + '-' + firstname + file_extension
filename = filename.replace(' ', '-').lower()
print(filename)
else:
if not 'image' in request.files: res["error"] = "No Image"
if not allowed_file(file.filename):
res["error"] = "File type not supported"
return jsonify({"data": res})
filename = os.path.join(app.config['UPLOAD_FOLDER'], filename)
#Cropp image
#img = Image.open(filename)
#area =(200, 100, 700,400)
#new_sizeed_file = img.crop(area)
#new_sizeed_file.show(new_sizeed_file)
print(filename)
if not os.path.exists(UPLOAD_FOLDER):
os.makedirs(UPLOAD_FOLDER)
temp_file = os.path.join(app.config['UPLOAD_FOLDER'], "temp.jpg")
file.save(temp_file)
storage.child(filename).put(temp_file)
# Get image url from firebase
img_url = storage.child(filename).get_url(None)
#res["msg"] = "Valid_Image"
shutil.copy(temp_file, filename)
file = request.files['image']
res["media"] = filename
print(request.files)
req_data = request.get_json()
print(req_data)
hashed_password = generate_password_hash(request['password'],
method='sha256')
data = {
'firstname': firstname,
'lastname': lastname,
'avatar_thumbnail': img_url,
'email': email,
'password': hashed_password,
'position': position,
'phone': phone,
'role': role,
}
data['_id'] = str(ObjectId())
x = database["admins"].insert_one(data)
#memberID = request.form['memberID']
#database['users'].update({'_id': memberID}, {"$set": {'profile_bg':profile_bg}})
os.remove(temp_file)
return jsonify({"data": res})
def compression():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
#### check for file name validation
file = request.files['file']
if file.filename == '':
flash('No file selected for uploading')
return redirect(request.url)
### validation on file extention
if file and allowed_file(file.filename):
##### clean up the environment
os.system('rm -f /myAllProjects/new_bigdata/extracted/*')
os.system('rm -f /myAllProjects/new_bigdata/file_chunk/*')
os.system('rm -f /myAllProjects/new_bigdata/uploaded/*')
os.system('rm -f /myAllProjects/new_bigdata/decompressed/*')
os.system('rm -f /myAllProjects/new_bigdata/selective.zip')
filename = secure_filename(file.filename)
file.save('/myAllProjects/new_bigdata/'+filename)
df=pd.read_csv('/myAllProjects/new_bigdata/'+filename)
df1=df.drop_duplicates(subset=None, inplace=False)
df1.to_csv('/myAllProjects/new_bigdata/'+filename)
csvfilename = open('/myAllProjects/new_bigdata/'+filename, 'r').readlines()
filesize=60000
#header = csvfilename[0]
csvfilename.pop(0)
count=0
l=[]
for i in range(len(csvfilename)):
if i % filesize == 0:
### folder name
folder=app.config['UPLOAD_FOLDER']
### file chunk created
write_file = csvfilename[i:i+filesize]
#if(i==0):
# write_file.insert(0,header)
### filename which is to be compress is written inside number.txt
open(folder+str(count)+filename, 'w+').writelines(write_file)
file=open('/myAllProjects/new_bigdata/number.txt','w+')
file.write(str(count)+filename)
file.close()
### dockerfile created and run in background
check=subprocess.getoutput('docker ps -a | grep container{}'.format(count))
if(check!=''):
os.system('docker rm -f container{}'.format(count))
os.system('docker build -t "dockerfile" /myAllProjects/new_bigdata/')
os.system('docker run -dit -v /myAllProjects/new_bigdata/file_chunk/:/usr/local/bigdata/file -v /myAllProjects/new_bigdata/uploaded/:/usr/local/bigdata/compressed/ --name container{} dockerfile'.format(count))
count += 1
while True:
#### check for existence of docker container
output=subprocess.getoutput('docker ps | wc -l')
if(output=='2'):
for i in range(count):
ps=subprocess.getoutput('docker ps | grep container{}'.format(i))
psa=subprocess.getoutput('docker ps -a| grep container{}'.format(i))
if(ps=='' and psa!=''):
os.system('docker rm -f container{}'.format(str(i)))
gzip()
return send_file('/myAllProjects/new_bigdata/selective.zip',attachment_filename='selective.zip')
flash('File successfully uploaded')
return redirect('/')
else:
flash('Allowed file types are txt, pdf, png, jpg, jpeg, gif')
return redirect(request.url)
def img_u():
if "type" in session:
if request.method == 'POST':
f = request.files['pic']
f.save(os.path.join(img_path, secure_filename(f.filename)))
return "done"
def generate():
uploaded_file = request.files['file']
filename = secure_filename(uploaded_file.filename)
if filename != '':
file_ext = os.path.splitext(filename)[1]
if file_ext not in app.config['UPLOAD_EXTENSIONS']:
return "Invalid file", 400
data = json.loads(request.form['data'])
file_path = os.path.join('documentation/' + data['pilot'] + '/',
filename)
uploaded_file.save(file_path)
# Instantiate PathwayGeneration object
if 'model' in data:
pgr = PathwayGenerator(
file_path=file_path,
pilot=data['pilot'],
service=data['service'],
use_cuda=True,
cuda_device=0,
annotation_model=data['model'],
section_split_model=
'section_split/models/training_unfolding_structure-2020-12-22_11-07-07_distilroberta-base'
)
else:
pgr = PathwayGenerator(
file_path=file_path,
pilot=data['pilot'],
service=data['service'],
use_cuda=True,
cuda_device=0,
section_split_model=
'section_split/models/training_unfolding_structure-2020-12-22_11-07-07_distilroberta-base'
)
# Check for projects
generation_project = get_project_by_name('ER ' +
pilots_legend[data['pilot']] +
' Pathways')
annotation_project = get_project_by_name('ER ' +
pilots_legend[data['pilot']] +
' Annotated Documents')
#app.config['logger'].log()
# Check if document already exists: if so, return annotations. Otherwise, create a new one
document_annotation = get_document(pgr.annotation_metadata,
annotation_project['id'])
document_generation = get_document(pgr.generation_metadata,
generation_project['id'])
if document_generation:
#document_where = get_document(pgr.generation_metadata['where'], generation_project['id'])
#document_when = get_document(pgr.generation_metadata['when'], generation_project['id'])
#document_how = get_document(pgr.generation_metadata['how'], generation_project['id'])
document_generation = sorted(
document_generation,
key=lambda x: int("".join(
[i for i in x['text'] if i.isdigit()])))
#document_generation = sorted(document_generation, key = lambda x: x['text'])
return refactor_export_generations(document_generation)
# Check if document already exists: if so, return annotations. Otherwise, create a new one
if document_annotation:
annotations = doccano_client.get_annotation_list(
annotation_project['id'], document_annotation[0]['id'])
pgr.ner_dict = doccano_to_dict_format(annotations,
document_annotation[0],
annotation_project['id'])
converted_file = pgr.do_convert()
#app.config['logger'].log()
ner_dict = pgr.do_annotate(pgr.to_list())
doccano_dict, ner_path = pgr.export_annotation_to_doccano()
try:
doccano_client.post_doc_upload(project_id=annotation_project['id'],
file_format='json',
file_name=ner_path)
except json.decoder.JSONDecodeError:
pass
sections = pgr.do_split()
full_ner_dict = {}
count = 1
for section in sections:
pgr.annotation_model.reset_preprocesser()
ner_dict = pgr.do_annotate(section)
pathway = pgr.do_generate()
label = 'Step' + str(count)
full_ner_dict[label] = pathway
count = count + 1
pathway_dict, pathway_path = pgr.export_generation_to_doccano(
full_ner_dict)
#print(pathway_dict)
#app.config['logger'].log()
#pathway = pgr.do_generate()
#app.config['logger'].log()
try:
#print('Uploading documents')
if count < 50:
doccano_client.post_doc_upload(
project_id=generation_project['id'],
file_format='json',
file_name=pathway_path)
except json.decoder.JSONDecodeError:
pass
return pathway_dict
return 'NOK', 400
def get_new_file_name(image_file):
timestamp = datetime.datetime.utcnow().strftime("%s.%f")
timestamped_filename = hashlib.md5(os.path.join(timestamp + '_' + image_file.filename).encode()).hexdigest() + '.'\
+ image_file.filename.rsplit('.', 1)[1].lower()
return secure_filename(timestamped_filename)
def account():
form = UpdateAccountForm(request.form)
if request.method == 'GET':
if session.get('logged_in') is None:
session['logged_in'] = False
if session['logged_in']:
conn = mysql.connect()
cur = conn.cursor()
cur.execute("SELECT username,email_id,dob,address,phone,work,education,about,profile_picture FROM user WHERE email_id = %s", (session['logged_user_id']))
result = cur.fetchall()
results = [list(i) for i in result]
for item in results:
form.name.data = item[0]
form.email.data = item[1]
form.dob.data = item[2]
form.address.data = item[3]
form.phone.data = item[4]
form.work.data = item[5]
form.education.data = item[6]
form.details.data = item[7]
form.picture.data = item[8]
if item[8]:
full_profilepic_path = "..\\static\\profile_pics\\" + item[8]
else:
full_profilepic_path = "..\\static\\profile_pics\\default.jpg"
# print(full_profilepic_path)
return render_template('account.html', title='My Profile', form=form, full_profilepic_path=full_profilepic_path)
else:
return render_template('index.html', title='Home')
if request.method == 'POST':
# print("YAY")
name = form.name.data
dob = form.dob.data
address = form.address.data
phone = form.phone.data
work = form.work.data
education = form.education.data
details = form.details.data
conn = mysql.connect()
cur = conn.cursor()
cur.execute("SELECT profile_picture FROM user WHERE email_id = %s", (session['logged_user_id']))
results = cur.fetchall()
for item in results:
form.picture.data = item[0]
conn.commit()
cur.close()
if form.picture.data is None:
full_profilepic_path = "..\\static\\profile_pics\\default.jpg"
filename = "default.jpg"
else:
full_profilepic_path = "..\\static\\profile_pics\\" + form.picture.data
filename = form.picture.data
# uploading pic
if 'file' not in request.files:
flash('No file part')
else:
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
flash('No selected file')
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
#print(os.path.join(app.config['UPLOAD_FOLDER'], filename))
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
full_profilepic_path = "..\\static\\profile_pics\\" + filename
conn = mysql.connect()
cur = conn.cursor()
if len(form.password.data) > 0:
password = form.password.data
cur.execute("""UPDATE user SET username = %s,password = %s, dob = %s, address = %s, phone = %s, work = %s, education = %s, about = %s, profile_picture = %s WHERE email_id = %s""", (name, password, dob, address, phone, work, education, details, filename, session['logged_user_id']))
form.password.data = ""
else:
cur.execute("""UPDATE user SET username = %s, dob = %s, address = %s, phone = %s, work = %s, education = %s, about = %s, profile_picture = %s WHERE email_id = %s""", (name, dob, address, phone, work, education, details, filename, session['logged_user_id']))
conn.commit()
cur.close()
return render_template('account.html', title='Account', form=form, full_profilepic_path=full_profilepic_path)
def uploader():
if ('user' in session and session['user'] == params['admin_user']):
if (request.method == 'POST'):
f= request.files['file1']
f.save(os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f.filename) ))
return "Uploaded successfully"
def upload():
if request.method == 'POST':
# Get the file from post request
f = request.files['file']
# Save the file to ./uploads
basepath = os.path.dirname(__file__)
file_path = os.path.join(basepath, 'uploads',
secure_filename(f.filename))
f.save(file_path)
# Make prediction
output_class = [
"batteries", "cloth", "e-waste", "glass", "light bulbs",
"metallic", "organic", "paper", "plastic"
]
preds = model_predict(file_path, model)
print(preds)
pred_class = output_class[np.argmax(preds)]
pred_class_percent = round(np.max(preds) * 100, 2)
result = 'It is ' + pred_class + ' waste' # Convert to string
pred_class = ' with ' + str(pred_class_percent) + '% confidence'
#k-nn for recommending
filelist.sort()
featurelist = []
for i, imagepath in enumerate(filelist):
print(" Status: %s / %s" % (i, len(filelist)), end="\r")
img = image.load_img(imagepath, target_size=(224, 224))
img_data = image.img_to_array(img)
img_data = np.expand_dims(img_data, axis=0)
img_data = preprocess_input(img_data)
features = np.array(model.predict(img_data))
featurelist.append(features.flatten())
nei_clf = NearestNeighbors(metric="euclidean")
nei_clf.fit(featurelist)
code = model_predict(file_path, model)
(distances, ), (idx, ) = nei_clf.kneighbors(code, n_neighbors=3)
#all images are loaded as np arrays
images = []
labels = []
j = 1
for i, image_path in enumerate(filelist):
images.append(load_data(image_path))
images = np.asarray(
images
) # all of the images are converted to np array of (1360,224,224,3)
print(distances, images[idx])
print(images[idx].shape)
final_result = result + pred_class
image_save = Image.fromarray(
(np.array(images[0]) * 255).astype(np.uint8))
#image_save = Image.fromarray(images[idx], "RGB")
image_save.save('out.jpg')
image_output = os.path.join(basepath, 'out.jpg')
immg = '<img src="' + image_output + '" style="height: 132px; width: 132px;">'
#return render_template('index.html', filename=image_output)
return final_result
return None
def edit_covenants():
"""Render covenant editing form."""
allowed_extensions = ['jpg', 'png']
form = EditInstitutionsWithCovenantsForm()
pfactory = PosGraduationFactory(current_user.pg_initials)
dao = pfactory.integrations_infos_dao()
json = pfactory.integrations_infos_dao().find_one()
json = dict(json)
json = dumps(json)
if form.validate_on_submit() and form.create.data:
index = str(form.index.data)
if form.logo.data and allowedFile(form.logo.data.filename,
allowed_extensions):
photo = form.logo.data
path = os.path.normpath("static/assets")
filename = secure_filename(photo.filename)
if filename.count('.') > 1:
return redirect(
url_for(
'admin.edit_covenants',
integrations=json,
success_msg=
'Nome da logo contem mais de um . por favor corrija isso'
))
name, extension = filename.split('.')
logoFile = 'logo-' + form.initials.data.lower() + '.' + extension
logo = uploadFiles(photo, path, logoFile)
new_covenant = {
'name': form.name.data,
'initials': form.initials.data.upper(),
'logoFile': logo
}
dao.find_one_and_update(
None,
{'$set': {
'institutionsWithCovenant.' + index: new_covenant
}})
else:
dao.find_one_and_update(
None, {
'$set': {
'institutionsWithCovenant.' + index + '.initials':
form.initials.data.upper()
}
})
dao.find_one_and_update(
None, {
'$set': {
'institutionsWithCovenant.' + index + '.name':
form.name.data
}
})
return redirect(
url_for('admin.edit_covenants',
integrations=json,
success_msg='Convênio editado com sucesso.'))
return render_template('admin/edit_covenants.html',
form=form,
integrations=json,
success_msg=request.args.get('success_msg'))
def upload_file():
if request.form.getlist('obs'):
ff=request.form.getlist('obs')
if len(ff) == 0:
return render_template("objres.html", name = urls,data=fin,user="******")
for objects in ff:
hashtags=HashSearch(objects)
ss=[]
single=[]
for w in hashtags:
if detect(w)=="en":
ss.append(w)
for q in ss:
if q not in single:
single.append(q)
allt.append(single)
str1 = ""
uu=""
for tt in urls:
uu=uu+" "+tt+", "
pic_urls=str.format(uu)
for ele in fin:
for e in ele:
str1=str1+" #"+e+" "
dis=str.format(str1)
allhash=""
for r in allt:
for t in r:
allhash=allhash+" #"+e+" "
oos=""
for ty in res:
oos=oos+" "+ty+", "
data = {
u'user': "******",
u'time': dt_string,
u'hashtag_g': dis,
u'hashtag_obj_twitter':allhash,
u'obj_identified':oos,
u'img_urls':pic_urls
}
mydata.set(data)
return render_template("result.html", name = urls,data=fin,hashes=allt,user="******")
if request.method == 'POST':
fin.clear()
res.clear()
urls.clear()
allt.clear()
fff.clear()
tts.clear()
files = request.files.getlist('files[]')
r=request.form.get('radio')
print(r)
if request.form.get('radio') == '1':
for file in files:
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
fff.append(filename)
file.save(os.getcwd()+"/static/uploads/"+filename)
p=os.getcwd()+"/static/uploads/"+filename
global bucket_name
ur=upload_blob(bucket_name,p,filename)
urls.append(ur)
with io.open(p, 'rb') as image_file:
content = image_file.read()
image = vision.types.Image(content=content)
response = client.label_detection(image=image)
labels = response.label_annotations
print('Labels:')
for label in labels:
temp=label.description
y=temp.replace(" ","")
tts.append(y)
print(tts)
fin.append(tts)
vals=run_detector(detector, p)
for o in vals:
if o not in res:
res.append(o)
else:
for file in files:
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
fff.append(filename)
file.save(os.getcwd()+"/static/uploads/"+filename)
p=os.getcwd()+"/static/uploads/"+filename
global bucket_name
ur=upload_blob(bucket_name,p,filename)
urls.append(ur)
with io.open(p, 'rb') as image_file:
content = image_file.read()
image = vision.types.Image(content=content)
response = client.label_detection(image=image)
labels = response.label_annotations
print('Labels:')
for label in labels:
temp=label.description
y=temp.replace(" ","")
tts.append(y)
print(tts)
fin.append(tts)
str1 = ""
uu=""
for tt in urls:
uu=uu+" "+tt+", "
pic_urls=str.format(uu)
for ele in fin:
for e in ele:
str1=str1+" #"+e+" "
dis=str.format(str1)
data = {
u'user': "******",
u'time': dt_string,
u'hashtag_g': dis,
u'pic_urls':pic_urls
}
mydata.set(data)
return render_template("result.html", name = urls,f=fin,user="******")
return render_template("result.html", name = urls,f=res,user="******")
def annotate():
uploaded_file = request.files['file']
filename = secure_filename(uploaded_file.filename)
if filename != '':
file_ext = os.path.splitext(filename)[1]
if file_ext not in app.config['UPLOAD_EXTENSIONS']:
return "Invalid file", 400
app.config['logger'].log({'file': 'test'})
data = json.loads(request.form['data'])
file_path = os.path.join('documentation/' + data['pilot'] + '/',
filename)
uploaded_file.save(file_path)
# Instantiate PathwayGeneration object
if 'model' in data:
pgr = PathwayGenerator(file_path=file_path,
pilot=data['pilot'],
service=data['service'],
use_cuda=True,
cuda_device=0,
annotation_model=data['model'])
else:
pgr = PathwayGenerator(file_path=file_path,
pilot=data['pilot'],
service=data['service'],
use_cuda=True,
cuda_device=0)
# Check for annotation project
project = get_project_by_name('ER ' + pilots_legend[data['pilot']] +
' Annotated Documents')
#app.config['logger'].log()
# Check if document already exists: if so, return annotations. Otherwise, create a new one
document = get_document(pgr.annotation_metadata, project['id'])
if document:
return refactor_export_annotations(document[0], project['id'])
converted_file = pgr.do_convert()
#app.config['logger'].log()
ner_dict = pgr.do_annotate(pgr.to_list())
#app.config['logger'].log()
print(ner_dict)
doccano_dict, ner_path = pgr.export_annotation_to_doccano()
#app.config['logger'].log()
# WARNING: current issue of file upload/download Response -> https://github.com/doccano/doccano-client/issues/13
try:
doccano_client.post_doc_upload(project_id=project['id'],
file_format='json',
file_name=ner_path)
except json.decoder.JSONDecodeError:
pass
return doccano_dict
return 'NOK', 400
def item_posting():
# cursor = db.cursor()
print(request.form)
formsLen = len(request.form)
images_path = []
if 'lazyRegistration' in session:
print('session file is: ', session_file)
insertItemPost(session['item_name'], session['item_category'],
session['item_desc'], session['item_price'],
session['is_tradable'], session['item_images'],
session['sessionUser'], True)
session_file.clear()
session.pop('lazyRegistration')
session.pop('lazyPage')
print('Rediret from lazy login to home')
# return render_template('home.html', sessionUser=session['sessionUser'], id=-1,categoryName="Catogory")
return redirect("/")
sessionUser = "" if 'sessionUser' not in session else session['sessionUser']
# print("Session user", sessionUser)
if request.method == "POST":
if request.form:
print("printing request form", request.form)
if formsLen > 0:
item_name = str(bleach.clean(request.form['item_title']))
item_category = request.form['category']
item_desc = str(bleach.clean(request.form['item_desc']))
item_price = request.form['item_price']
is_tradable = '0' if 'isTradable' not in request.form else request.form[
'isTradable'] #str(1) if 'isTradable' in request.form else str(0)
item_images = []
if sessionUser == "":
session['item_images'] = []
# store image in separate folder as per category
UPLOAD_FOLDER = 'static/images/' + item_category
session['UPLOAD_FOLDER'] = UPLOAD_FOLDER
for file in request.files.getlist('file'):
if file.filename == '':
print('No file selected for uploading')
else:
# session['item_image'].append(base64.b64encode(file.read()).decode('ascii'))
if sessionUser == "":
# session_file.append(file)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
# unique filename
uuid_val = uuid.uuid1()
filename = str(uuid_val) + '.' + \
filename.rsplit('.', 1)[1].lower()
print(os.path.curdir)
file_path = os.path.join(session['UPLOAD_FOLDER'],
filename)
print("file path from item-posting post req is:",
file_path)
# file = open(file,"wr")
file.save(file_path)
session['item_images'].append(file_path)
else:
item_images.append(file)
if sessionUser == "":
session['lazyRegistration'] = True
session['lazyPage'] = 'item-posting'
session['item_name'] = item_name
session['item_category'] = item_category
session['item_desc'] = item_desc
session['item_price'] = item_price
session['is_tradable'] = is_tradable
# session['item_userid'] =
# session['item_images'] = None #item_images
print("going to login?")
return redirect("/login")
else:
# sessionUser = session['sessionUser']
insertItemPost(item_name, item_category, item_desc, item_price,
is_tradable, item_images, sessionUser, False)
if request.method == "GET":
cursor = getCursor()[1]
cursor.execute(query().fetchAllCategories())
allCategories = cursor.fetchall()
cursor.close()
categories = [allCategories[i][0] for i in range(len(allCategories))]
return render_template("item-posting.html", categories=categories)
flash("Item Posted Successfully")
return redirect('/')
def upload_file():
if 'email' not in session:
return render_template('please_login_first.html')
else:
if session['level'] == 0:
return render_template('Users_cannot_publish_tasks.html')
else:
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
print('no file')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
print('no filename')
return redirect(request.url)
if file and allowed_file(file.filename):
# Save file
filename = secure_filename(file.filename)
save_path = os.path.join(app.config['UPLOAD_FOLDER'],
filename)
file.save(save_path)
# Unzip file to the 'EXTRACT_FOLDER/projectName_timeStamp'
zip_ref = zipfile.ZipFile(save_path, 'r')
final_path = os.path.join(
EXTRACT_FOLDER,
filename.split(".zip")[0] + "_" +
datetime.datetime.today().strftime('%Y-%m-%d_%H:%M:%S')
)
if not os.path.exists(final_path):
print(final_path)
os.makedirs(final_path)
zip_ref.extractall(final_path)
zip_ref.close()
# Only keep Json files
for filename in os.listdir(final_path):
if not os.path.join(final_path,
filename).endswith(".json"):
if os.path.isdir(os.path.join(
final_path, filename)):
shutil.rmtree(
os.path.join(final_path, filename))
else:
os.remove(os.path.join(final_path, filename))
elif filename == "meta.json":
with open(os.path.join(final_path, filename)) as f:
meta = json.load(f)
sourcename = meta['projectName']
description = meta['description']
fault_level = meta['fault_level']
f.close()
os.remove(os.path.join(final_path, filename))
root_path = os.path.join(
EXTRACT_FOLDER, sourcename + "_" +
datetime.datetime.today().strftime('%Y-%m-%d_%H:%M:%S')
)
shutil.move(final_path, root_path)
admin_email = session['email']
c = init_cnx()
admin_id = c.get_adminid(email_addr=admin_email)
c.close()
result = {"code": 0}
c = init_cnx()
insert = c.insert_source(sourcename=sourcename,
publisher=admin_id,
description=description,
publish_time=get_timestamp(),
priority=1,
ft_degree=fault_level)
c.close()
if insert == -1:
result = {
"code": 1,
"message": "Task insertion failed!"
}
return jsonify(result)
else:
c = init_cnx()
load = c.load_data(root_path=root_path,
sourcename=sourcename)
c.close()
if load == 0:
result = {
"code": 1,
"message": "Data insertion failed!"
}
return jsonify(result)
else:
if session['level'] == 1:
return render_template('indexA1.html')
elif session['level'] == 2:
return render_template('indexAX.html')
return render_template('publish.html')
def muti_scan():
search_hostlist = ''
if request.method == 'POST':
file = request.files['input_list']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
search_hostlist = str(filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
scan_mode_list = [{
'id': '1',
'arg': '-sT',
'name': 'TCP Connect Scan',
'text': u'利用TCP協定，建立完整的3向交握連線後在進行掃描，雖然準確率比較高，但易留下紀錄。'
}, {
'id': '2',
'arg': '-sS',
'name': 'SYN Stealth Scan',
'text': u'半開放掃描，若對方有開啟TCP端口就會回應封包，不會留下紀錄。'
}, {
'id': '3',
'arg': '-sA',
'name': 'ACK Scan ',
'text': u'探測目標是否有防火牆阻擋。'
}, {
'id': '4',
'arg': '-sM',
'name': 'Mainmon Scan',
'text': u'判斷那些端口是開啟狀態。'
}, {
'id': '5',
'arg': '-sF',
'name': 'FIN Scan',
'text': u'正常連線型態，隱密性較高。'
}, {
'id': '6',
'arg': '-sN',
'name': 'NULL Scan',
'text': u'類似-sF，但對Windows無作用。'
}, {
'id': '7',
'arg': '-sX',
'name': 'XMas Tree Scan',
'text': u'利用送出三個控制封包探測目標主機，對Windows無作用。'
}, {
'id': '8',
'arg': '-sU',
'name': 'UDP Scan',
'text': u'探測目標是否提供UDP服務。'
}, {
'id': '9',
'arg': '-sO',
'name': 'IP Protocol Scan',
'text': u'偵測目標系統哪些IP協定。'
}, {
'id': '10',
'arg': '-sP',
'name': 'Ping Sweep',
'text': u'單純Ping掃描。'
}]
ping_list = [{
'id': '1',
'arg': '-P0',
'name': 'Don\'t Ping',
'text': u'執行掃描前，不目標主機。'
}, {
'id': '2',
'arg': '-PI',
'name': 'ICMP Echo',
'text': u'查詢目標是否正在運行。'
}, {
'id': '3',
'arg': '-PE',
'name': 'Use ICMP Ping Host',
'text': u'利用ICMP封包Ping目標。'
}, {
'id': '4',
'arg': '-PR',
'name': 'ARP Ping',
'text': u'只能使用同區段的區域網路。'
}, {
'id': '5',
'arg': '-PS',
'name': 'TCP SYN Ping',
'text': u'發出TCP SYN封包，需指定端口，預設端口80。'
}, {
'id': '6',
'arg': '-PA',
'name': 'TCP ACK Ping',
'text': u'發出TCP ACK封包，需指定端口，預設端口80。'
}, {
'id': '7',
'arg': '-PU',
'name': 'UDP Ping',
'text': u'發出空的UDP封包，需指定端口，預設端口31338。'
}]
speed_list = [{
'id': '1',
'arg': '-T0',
'name': 'Paranoid',
'text': u'每五秒鐘發送一個封包。'
}, {
'id': '2',
'arg': '-T1',
'name': 'Sneaky',
'text': u'每十五秒鐘發送一個封包。'
}, {
'id': '3',
'arg': '-T2',
'name': 'Polite',
'text': u'每0.4秒鐘發送一個封包。'
}, {
'id': '4',
'arg': '-T3',
'name': 'Normal',
'text': u'預設及不指定速度的掃描。'
}, {
'id': '5',
'arg': '-T4',
'name': 'Aggressive',
'text': u'每十毫秒鐘發送一個封包。'
}, {
'id': '6',
'arg': '-T5',
'name': 'Insane',
'text': u'每五毫秒鐘發送一個封包。'
}]
other_list = [
{
'id': '1',
'arg': '-f',
'name': 'Fragmentation',
'text': u'發送碎片封包，資料長度為8byte，增加封包過濾器、防火牆與IDS的檢查難度。'
},
{
'id': '2',
'arg': '-6',
'name': 'IPv6',
'text': u'支援掃描IPv6TAT。'
},
]
task_list = mon.toybox.task_list.find()
return render_template('muti_scan.html',
search_hostlist=search_hostlist,
scan_mode_list=scan_mode_list,
ping_list=ping_list,
speed_list=speed_list,
other_list=other_list,
task_list=task_list)
def upload_file():
if request.method == 'POST':
# Removing Files
# Pfiles = glob.glob('uploads/*')
# for f in Pfiles:
# os.remove(f)
# Pfiles2 = glob.glob('uploads2/*')
# for f in Pfiles2:
# os.remove(f)
req = request.form
# check if the post request has the file part
if req['form-name'] == 'form1':
text_area = req['txtarea']
percent = int(req['percent'])
percent = percent / 100
print(percent)
sum_text = summarize(text_area, percent)
return render_template('upload_file.html',
in_text=text_area,
sum_text=sum_text)
if 'file' not in request.files:
print('no file')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
print('no filename')
return redirect(request.url)
else:
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
text = " ".join((line for line in open(os.path.join(
app.config['UPLOAD_FOLDER'], filename),
encoding='utf-8')))
# os.remove(os.path.join(app.config['UPLOAD_FOLDER'], filename))
percent = int(req['percent'])
percent = percent / 100
print(text)
text2 = summarize(text, percent)
print("after summary.....")
# file_path = app.config['UPLOAD_FOLDER2']
print(filename)
# filename= "SUM_" + filename
# files = open(file_path+ sum_file, 'w')
# files.write(text2)
# files.close()
with open(os.path.join(app.config['UPLOAD_FOLDER2'], filename),
'w') as f:
f.write(text2)
print("here is the filename : ", filename)
print("saved file successfully")
#send file name as parameter to downlad
# file_path = os.path.join(app.config['UPLOAD_FOLDER2'], filename)
# print("file for sent is ::: ")
# return send_file(file_path, as_attachment=True, attachment_filename='')
# file_path = os.path.join(app.config['UPLOAD_FOLDER2'], filename)
return redirect('/downloadfile/' + filename)
return render_template('upload_file.html',
in_text="Text area for input ...")
def upload_file():
# check if the post request has the file part
if 'file' not in request.files:
resp = jsonify({'message' : 'No file part in the request'})
resp.status_code = 400
return resp
file = request.files['file']
if file.filename == '':
resp = jsonify({'message' : 'No file selected for uploading'})
resp.status_code = 400
return resp
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file_name= file.filename
file_name = file_name.split(".")
if file_name[1] == 'txt':
metadata_txt = {}
data_txt={}
file_tmp = request.files['file'].read()
file_tmp = file_tmp.decode("utf8")
metadata_txt['file name']=file_name[0]
file.seek(0, os.SEEK_END)
file_length = file.tell()
metadata_txt['file size']=file_length
metadata_txt['file type']=file_name[1]
output['File Data']= file_tmp
output['File MetaData'] = metadata_txt
return jsonify(output)
elif file_name[1] == 'csv':
metadata_csv={}
fileString = file.read().decode('utf-8')
datafile = [{k: v for k, v in row.items()} for row in csv.DictReader(fileString.splitlines(), skipinitialspace=True)]
metadata_csv['file name']=file_name[0]
metadata_csv['file type']=file_name[1]
file.seek(0, os.SEEK_END)
file_length = file.tell()
metadata_csv['file size']= file_length
output['File Data']= datafile
output['File MetaData'] = metadata_csv
return jsonify(output)
elif file_name[1]=='png':
metadata_png={}
encoded_string = base64.b64encode(file.read())
encoded_string = encoded_string.decode('utf-8')
metadata_png['file name']=file_name[0]
file.seek(0,os.SEEK_END)
file_length = file.tell()
metadata_png['file type']=file_name[1]
metadata_png['file size']= file_length
#encoded_string = base64.b64encode(file.read().decode('utf-8'))
output['File data']=encoded_string
output['File Metadata']=metadata_png
return jsonify(output)
else:
resp = jsonify({'message' : 'Allowed file types are txt, csv, png'})
resp.status_code = 400
return resp
def upload():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
print(request.form['token'])
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
ext = filename.split(".")[1]
file.save(
os.path.join(app.config['UPLOAD_FOLDER'],
"input_image" + "." + "jpg"))
tempfile = os.path.join(app.config['UPLOAD_FOLDER'],
"input_image" + "." + "jpg")
# imagedataFile = open('/app/public/imagedataFile.txt','w')
# imagedataFile.write(tempfile)
# imagedataFile.close()
img = open(tempfile, 'rb') # reading file from glitch's local
bitimage = base64.b64encode(img.read())
img.close()
req_data = {
"requests": [{
"image": {
"content": bitimage
},
"features": [{
"type": "LABEL_DETECTION",
"maxResults": 10
}]
}]
}
rt = requests.post("%s?key=%s" %
(GOOGLE_CLOUD_VISION_URL, GOOGLE_API_KEY),
json.dumps(req_data),
headers={'content-type': 'application/json'})
# print(r.text)
r = rt.json()
for i in range(len(r["responses"][0]["labelAnnotations"])):
keyword = r["responses"][0]["labelAnnotations"][i][
"description"]
result = sp.search(keyword, limit=1, type='playlist')
if (len(result["playlists"]["items"]) > 0):
print(result["playlists"]["items"][0]["name"].encode(
'utf-8').strip())
if (i < 1):
resulttrack = result["playlists"]["items"][0][
"name"].encode('utf-8').strip()
requestBody = {
"context_uri":
result["playlists"]["items"][0]["uri"].encode(
'utf-8').strip()
}
print(requestBody)
token = request.form['token']
auth = {"Authorization": "Bearer {0}".format(token)}
auth["Content-Type"] = "application/json"
print(auth)
req = requests.put(
"https://api.spotify.com/v1/me/player/play",
data=json.dumps(requestBody),
headers=auth)
print(req.text)
return render_template("show-snapmusic.html")
def wrapper(content_path, **kwargs):
return f(secure_filename(content_path), **kwargs)
def upload():
file = request.files['imagem']
savePath = os.path.join(UPLOAD_FOLDER, secure_filename(file.filename))
file.save(savePath)
return 'Upload feito com sucesso'
def wrapper(chapter, page, **kwargs):
return f(secure_filename(chapter),
secure_filename(page) if page is not None else page, **kwargs)
def setPath(file):
filename = secure_filename(file.filename)
path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(path)
return path
def tool_upload(token):
"""
tool upload form takes GET and POST methods
renders the form for GET
form submission handling for POST
"""
payload = verify_email_token(token)
if not payload:
flash('Link expired or invalid, try again')
return redirect(url_for('index'))
form = toolUpload()
form.authoremail.data = payload['authoremail']
form.papername.data = payload['papername']
if form.validate_on_submit():
paper = Paper(paper_name=form.papername.data,
author_name=form.authorname.data,
author_email=form.authoremail.data,
tool_name=form.toolname.data,
link_to_pdf=form.linktopdf.data,
link_to_archive=form.linktoarchive.data,
link_to_tool_webpage=form.linktotoolwebpage.data,
link_to_demo=form.linktodemo.data,
bibtex=form.bibtex.data,
description=form.description.data,
year=form.year.data,
conference=form.conference.data,
category=form.category.data,
view_count=0)
# print(form.tags.data)
for tag in form.tags.data.split(","):
tag_obj = db.session.query(Tag).filter(
Tag.tagname == tag.strip()).first()
if tag_obj is None:
tag_obj = Tag(tagname=tag.strip())
paper.tags.append(tag_obj)
db.session.add(paper)
db.session.flush()
filenames = []
fileurls = []
filetypes = form.file_types.data.split(',')
for file in form.all_files.data:
if not isinstance(file, str):
filenames.append(secure_filename(file.filename))
filename = '{}/{}'.format(paper.id,
secure_filename(file.filename))
file.filename = filename # updating the name with paper.id for easy access
s3_url = "{0}/{1}/{2}".format(app.config['S3_ENDPOINT'],
app.config['S3_BUCKET'],
filename)
upload_file_to_s3(s3, file, app.config['S3_BUCKET'])
fileurls.append(s3_url)
# print("Uploaded files below for paper: {}".format(paper.id))
# print(fileurls)
for filename, fileurl, filetype in zip(filenames, fileurls, filetypes):
paper.files.append(
File(filename=filename, filetype=filetype, fileurl=fileurl))
db.session.flush()
db.session.commit()
flash('Tool submission success!')
return redirect(url_for('specific_paper', id=paper.id))
# print(form.errors)
return render_template('tool_upload.html',
title="Upload your tool here",
form=form)
def upload():
"""
This function basically parses a .csv or .xlsx or .txt or a file from a url and saves to the database.
"""
# UPLOADED FILE
uploaded_file = request.files["file"]
filename = secure_filename(uploaded_file.filename)
if not uploaded_file:
return make_response({
"message" : "Please upload a .csv or .xlsx file or enter the file's URL."
}, 400
)
if filename != "":
extension = os.path.splitext(filename)[-1].lower()
if extension not in app.config["UPLOAD_EXTENSIONS"]:
return make_response({
"message" : f"Cannot process .{extension} files. Please upload a valid file with extension .csv, .xlsx, or enter the URL."
}), 500
uploaded_file.save(os.path.join(app.config["UPLOADS_DIR"], filename))
if filename.endswith(".csv"):
data = readCSV(os.path.join(app.config["UPLOADS_DIR"], filename))
elif filename.endswith(".xlsx"):
data = readXLSX(os.path.join(app.config["UPLOADS_DIR"], filename))
for record in data:
d = json.dumps({
"phone_number" : record["phone_number"],
"run_time" : record["run_time"],
"created_at" : datetime.now()
}, cls = DateTimeEncoder)
d = data_schema_single.loads(d)
d = Data(
phone_number = d["phone_number"],
run_time = d["run_time"],
created_at = d["created_at"]
)
db.session.add(d)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
pass
# result = data_schema_multiple.dump(data)
return make_response(
{ "message" : f"{len(data)} row(s) added successfully !."},
201
)
def addVideo():
file = request.files['video']
timestamp = request.form.get("time")
location = request.form.get("location")
name = file.filename
name = os.path.splitext(name)[0]
if file and allowed_file(file.filename):
if file.filename == None:
filename = "Unknown_video"
else:
filename = secure_filename(file.filename)
tmz_str = ' GMT+0530 (India Standard Time)'
if timestamp.endswith(tmz_str):
timestamp = timestamp.replace(tmz_str, '')
date_time_obj = None
try:
date_time_obj = datetime.strptime(timestamp, '%a %b %d %Y %H:%M:%S')
except Exception as e:
pass
if date_time_obj == None:
return jsonify({
"success": False,
"message": "Timestamp is invalid. Please try again!"
}), 403
oid = fs.upload_from_stream(filename, file)
video_name = 'saves/' + randomString() + '.mp4'
f = open(video_name, 'wb+')
fs.download_to_stream(oid, f)
f.close()
try:
metadata = getFirstFrame(video_name)
thumbnail = metadata[0]
duration = time.strftime("%H:%M:%S", time.gmtime(metadata[1]))
except Exception as e:
print(e)
if os.path.exists(video_name):
os.remove(video_name)
return jsonify({"success": False, "message": "Failed to process video"}), 500
thumbnail_oid = fs.upload_from_stream(str(oid), thumbnail)
# To check if image is saved
# f_img = open('saves/frame2.jpg','wb+')
# fs.download_to_stream(thumbnail_oid, f_img)
# f_img.close()
# insert video details
db.video.insert_one({
"name": name,
"date": str(date_time_obj.date()),
"time": str(date_time_obj.time()),
"location_id": location,
"file_id": str(oid),
"thumbnail_id": str(thumbnail_oid),
"duration": duration,
"processing": False,
"prepared": False
})
if os.path.exists(video_name):
os.remove(video_name)
return jsonify({
"success": True,
"message": "Video successfully uploaded"
}), 200
def delete_blog_picture(filename):
delete_file = secure_filename(filename)
os.remove(os.path.join(app.config['BLOG_UPLOAD_FOLDER'], delete_file))
return
