def upload():
user = User.query.get(session['userID'])
files = request.files.getlist("inputFiles")
url = request.form.get('url', False)
if len(files):
for file in files:
f = File.query.filter(
and_(File.owner == user, File.url == url, File.isFile == True,
File.filename == file.filename))
if f.count():
continue
newFile = File(filename=file.filename, url=url, owner=user)
db.session.add(newFile)
path = app.config['UPLOADS'] + "/" + user.username + url
file.save(os.path.join(path, file.filename))
else:
folderName = request.form.get('folderName', False)
if len(folderName):
newFolder = File(filename=folderName,
url=url,
owner=user,
isFile=False)
db.session.add(newFolder)
try:
os.mkdir(app.config['UPLOADS'] + "/" + user.username + url +
"/" + folderName)
except:
return "Folder already exists!"
else:
return "Please enter name"
db.session.commit()
return "1"
def uploadFile(f, comment=None, groups=None):
''' Storing file and writing information into database.
:param f: storing file.
:param comment: comments for file.
:param group: share with group.
:return: True if ok, otherwise False.
'''
checksum = hashlib.md5(f.read()).hexdigest()
# getting file size
f.seek(0, os.SEEK_END)
file_size = f.tell()
# save file ot disk
path = os.path.join(application.config.get('WEB_UPLOAD_DIR'), checksum)
if not os.path.exists(path):
f.seek(0)
f.save(path)
if not groups:
upload_file = File(name=secure_filename(f.filename),
checksum=checksum,
timestamp=datetime.now(),
comment=comment,
size=file_size)
upload_file.account = current_user
try:
db.session.add(upload_file)
db.session.commit()
except IntegrityError as ex:
application.logger.error(ex)
db.session.rollback()
else:
for group in groups:
upload_file = File(name=secure_filename(f.filename),
checksum=checksum,
timestamp=datetime.now(),
comment=comment,
size=file_size)
# owner & group
upload_file.account = current_user
upload_file.group = group
try:
db.session.add(upload_file)
db.session.commit()
except IntegrityError as ex:
application.logger.error(ex)
db.session.rollback()
return checksum
def upload():
"""
upload file and save file in local disk.
http-request's form should have [file] part
:return:
"""
if request.files:
try:
file_name = request.files['file'].filename
#无需考虑文件名重复的问题
hex = secure_name(file_name)
cate = auto_category(hex)
file.save(request.files['file'], name=hex)
try:
f = File(name=file_name, hex=hex, category=cate)
db.session.add(f)
db.session.commit()
except OperationalError:
db.session.rollback()
return http_response(250, 'bad', 'database not exist')
return http_response(200, 'ok', 'file uploaded')
except UploadNotAllowed:
http_response(250, 'bad', 'file ext not allowed')
return http_response(250, 'bad', 'file upload filed')
def sendRequestgetSB2(idProject):
"""First request to getSB2"""
getRequestSb2 = "http://getsb2-drscratch.herokuapp.com/" + idProject
fileURL = idProject + ".sb2"
# Create DB of files
now = datetime.now()
fileName = File(filename=fileURL, method="url", time=now)
fileName.save()
dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/"
fileSaved = dir_zips + str(fileName.id) + ".sb2"
pathLog = os.path.dirname(os.path.dirname(__file__)) + "/log/"
logFile = open(pathLog + "logFile.txt", "a")
logFile.write("FileName: " + str(fileName.filename) + "\t\t\t" + "ID: " + \
str(fileName.id) + "\t\t\t" + "Method: " + str(fileName.method) + "\t\t\t" + \
"Time: " + str(fileName.time) + "\n")
# Save file in server
counter = 0
file_name = handler_upload(fileSaved, counter)
outputFile = open(file_name, 'wb')
sb2File = urllib2.urlopen(getRequestSb2)
outputFile.write(sb2File.read())
outputFile.close()
return (file_name, fileName)
def post(self):
file = request.files['file']
f = File()
f.set_file(file)
db.session.add(f)
db.session.commit()
return f, 201
def setUp(self):
app.config.from_object(TestConfig)
db.session.remove()
db.drop_all()
self.app = app.test_client()
db.create_all()
data = []
data.append(File(filename="default.png"))
data.append(Rol(descripcion="administrador"))
db.session.add_all(data)
db.session.commit()
rolAdm = Rol.query.filter_by(descripcion="administrador").first()
administrador = User(username="******",
nombre="Super",
apellido="admin",
email="*****@*****.**",
rol_id=rolAdm.id,
ultimo_acceso=datetime.utcnow())
administrador.set_password("admin")
db.session.add(administrador)
db.session.commit()
self.user_data = self.login_refresh()
headers = {
'Authorization': 'Bearer {}'.format(self.user_data["access_token"])
}
self.headers = headers
def upload_file():
form=UploadForm()
if form.validate_on_submit():
if form.file.data is None or form.file.data.filename =='':
flash('No selected file.')
return redirect(url_for('upload'))
file=request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
filetype=filename.rsplit('.',1)[1].lower()
directory=app.config['UPLOAD_FOLDER'] + hashlib.md5(current_user.username).hexdigest()
if not os.path.exists(directory):
os.mkdir(directory)
file.save(os.path.join(directory,filename))
filehash=None
with open(os.path.join(directory,filename)) as f:
filehash = hashlib.md5(f.read(400)).hexdigest()
f.close()
os.rename(os.path.join(directory,filename),os.path.join(directory,filehash+'.'+filetype))
f=File(file_name=filename,file_hash=filehash,file_type=filetype,uploader=current_user.get_id())
db.session.add(f)
db.session.commit()
current_user.set_hashed_name()
db.session.add(current_user)
db.session.commit()
if(form.prof_pic.data is True):
current_user.set_profile_image(f.id)
db.session.add(current_user)
db.session.commit()
return redirect(url_for('user',username=current_user.username))
return render_template('upload.html',title='Upload',form=form)
def upload():
form = UploadForm()
if form.validate_on_submit():
f = form.file.data
file_name = f.filename
file_name = secure_filename(f.filename) # Real filename
file = File.query.filter_by(file_name=file_name).first()
if file in File.query.all():
flash('Ya existe un archivo con ese nombre.')
return render_template('500.html'), 500
upload_folder = app.config['UPLOAD_FOLDER']
if os.path.isdir(upload_folder) == False:
os.makedirs(upload_folder)
file_path = os.path.join(upload_folder, file_name) # filename
f.save(file_path)
new_file = File(file_name=file_name, upload_date=datetime.utcnow())
new_file.path = os.path.abspath(file_path)
new_file.size = os.path.getsize(file_path)
new_file.user_id = current_user.id
new_file.description = form.description.data
new_file.hash_sha = new_file.encrypt_string(new_file.file_name)
db.session.add(new_file)
db.session.commit()
flash(f'{file_name} was successfully uploaded!!')
return redirect(url_for('index'))
return render_template('upload.html', form=form)
def upload_files():
user = token_auth.current_user()
if not user.verified:
return error_response(403, 'Email not confirmed')
if 'files' not in request.files:
return bad_request('No files to upload')
uploaded = []
errors = []
files = request.files.getlist('files')
for file in files:
file_data = upload_file(user, file)
if 'error' in file_data:
errors.append(file_data['error'])
continue
file_model = File()
file_model.from_dict(file_data)
db.session.add(file_model)
db.session.commit()
uploaded.append(file_model.to_dict())
response = jsonify({'uploaded_files': uploaded, 'errors': errors})
response.status_code = 201
return response
def upload_group_file(path):
form = UploadForm()
user = User.query.get(current_user.id)
if form.validate_on_submit():
f = request.files['upload']
emails = form.email.data
users = [user]
for email in emails.split(","):
u = User.query.filter_by(email=email).first()
if not u or u not in currentFolder.AccessFolder:
flash(
"Please enter correct user emails and users with rights to the directory"
)
return render_template(
'fileModification/upload_group/upload_group_file.html',
title='Upload Group File',
form=form,
path=path)
users.append(u)
currentFolder = Folder.query.filter_by(id=path).first()
fileDb = File(name=f.filename,
parent=currentFolder,
AccessFile=users,
groupFile=True)
fileDb.lastRequest = "upload"
fileDb.idAcceptance = str(user.id)
db.session.add(fileDb)
f.save(os.path.join(returnPathOfFolder(currentFolder.id), f.filename))
db.session.commit()
return redirect(url_for('index'))
return render_template(
'fileModification/upload_group/upload_group_file.html',
title='Upload Group File',
form=form,
path=path)
def upload_normal_file(path):
form = UploadForm()
user = User.query.get(current_user.id)
if form.validate_on_submit():
f = request.files['upload']
emails = form.email.data
users = [user]
for email in emails.split(","):
u = User.query.filter_by(email=email).first()
if u and u in currentFolder.AccessFolder:
users.append(u)
currentFolder = Folder.query.filter_by(id=path).one()
fileDb = File(name=f.filename, parent=currentFolder, AccessFile=users)
db.session.add(fileDb)
path = returnPathOfFolder(currentFolder.id)
name = f.filename
files = f.read()
key = Fernet.generate_key()
fernet = Fernet(key)
fileDb.encryptionKey = key
encrypted = fernet.encrypt(files)
with open(os.path.join(path, name), 'wb') as fa:
fa.write(encrypted)
db.session.commit()
return redirect(url_for('index'))
return render_template(
'fileModification/upload_normal/upload_normal_file.html',
title='Upload Normal file',
form=form,
path=path)
def route_v2_project_project_id_files_add(project_id):
project = Project.query.get(project_id)
if project is None:
abort(404)
form = CreateFileForm()
if form.validate_on_submit():
try:
filename = form.filename.data
file_content = open(filename, encoding='utf-8').read()
file = File(filename=filename,
content=file_content,
project_id=project.id)
db.session.add(file)
db.session.commit()
flash('File <samp>{filename}</samp> successfully added to project.'.format(filename=file.filename),
category='message')
return redirect(url_for('route_v2_project_project_id', project_id=project.id))
except FileNotFoundError:
flash('File <samp>{filename}</samp> not found.'.format(filename=form.filename.data), category='error')
for field, error_msg in form.errors.items():
flash('Error in field "{field}": {error_msg}'.format(
field=field,
error_msg=' '.join(error_msg)
), category='error')
return render_template('v2_add_file_to_project.html', form=form, project=project)
def sendRequestgetJSON(idProject):
"""First request to getJSON"""
fileURL = idProject + ".json"
# Create DB of files
now = datetime.now()
fileName = File(filename=fileURL, method="url", time=now)
fileName.save()
dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/"
fileSaved = dir_zips + str(fileName.id) + ".json"
pathLog = os.path.dirname(os.path.dirname(__file__)) + "/log/"
logFile = open(pathLog + "logFile.txt", "a")
logFile.write("FileName: " + str(fileName.filename) + "\t\t\t" + "ID: " + \
str(fileName.id) + "\t\t\t" + "Method: " + str(fileName.method) + "\t\t\t" + \
"Time: " + str(fileName.time) + "\n")
# Save file in server
counter = 0
file_name = handler_upload(fileSaved, counter)
outputFile = open(file_name, 'wb')
print "Retrieving: ", idProject
jsonFile = urllib2.urlopen(idProject)
outputFile.write(jsonFile.read())
outputFile.close()
return (file_name, fileName)
def uploadFile(self, file):
file = self.request.FILES[file]
fsys = FileSystemStorage()
fullfilename = os.getcwd() + settings.MEDIA_DIR + str(
self.id) + "\\" + file.name
if os.path.isfile(fullfilename):
fsys.delete(fullfilename)
filename = fsys.save(fullfilename, file)
upload_file_url = fsys.url(filename)
scanned = self.scanfileforvirus(file, fullfilename)
if scanned['response_code'] == 1:
if len(File.objects.filter(path=fullfilename).values()) < 1:
f = File()
f.path = fullfilename
f.virusscan_resource = scanned['resource']
f.file_type = 't'
f.client_id = Client.objects.filter(id=self.id)[0]
f.save()
else:
self.getReports()
else:
print('deleted')
fsys.delete(fullfilename)
def create():
"""File creating"""
if request.method == 'POST':
if 'file' not in request.files:
flash('No file part', 'warning')
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No file selected', 'warning')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = file.filename
if request.form['title']:
title = request.form['title']
url = quote(title.strip().lower().replace(" ", "_"))
filename = secure_filename('%s.%s' %
(url, filename.rsplit('.', 1)[1]))
else:
title = filename.rsplit('.', 1)[0]
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
db_file = File()
db_file.title = title
db_file.user_id = current_user.id
db_file.path = filename
db.session.add(db_file)
db.session.commit()
flash('File "%s" successfully uploaded' % db_file.title, 'success')
return redirect(url_for('backend_file.view', file_id=db_file.id))
return render_template('file/create.j2')
def upload():
form = UploadForm()
# form.validate_on_submit()
# 无错误或者不出售价钱为空
# if form.is_submitted() and \
# (len(form.errors) == 0 or (len(form.errors) == 1 and form.price.data is None and not form.for_sell.data)):
price = form.price.data
if form.is_submitted() and not price:
price = 0
if form.validate_on_submit():
hash = keccak_256(form.file.data.stream.read()).hexdigest()
filename = form.filename.data.encode('utf-8')
description = form.description.data.encode('utf-8')
for_sell = form.for_sell.data
file = File(hash=hash, filename=filename, description=description, for_sell=for_sell, price=price)
# file.owner_user = current_user
file.owner = current_user.username
# file.time = datetime.now()
file.txhash = submit_file(current_user, file)
db.session.add(file)
# print(file)
# reset stream index
form.file.data.stream.seek(0)
saved_filename = app.upload_files.save(form.file.data, name=hash + '.')
file_url = app.upload_files.url(saved_filename)
return redirect(url_for('showcase.show_file', hash=file.hash))
else:
file_url = None
return render_template('upload.html', form=form, file_url=file_url)
def save_attachment(f, mediatype, db_object, folder):
filename = secure_filename(f.filename)
filename = '%s_%s' % (datetime.now(
app.config['TZ']).isoformat()[:19], filename)
filepath = os.path.join(
os.path.abspath(
os.path.join(app.instance_path,
'../%s/%s' % (app.config['UPLOAD_FOLDER'], folder))),
filename)
f.save(filepath)
new_file = File(filename=filename,
mimetype=f.headers[1][1],
mediatype=mediatype)
db.session.add(new_file)
db.session.commit()
# Link attachment to payment in the database
# If the db object is a User, then save as FK and store the id
if isinstance(db_object, User):
db_object.image = new_file.id
db.session.commit()
# Elif this is a Payment, then save as many-to-many and we need to append
elif isinstance(db_object, Payment):
db_object.attachments.append(new_file)
db.session.commit()
def submit_task(request, team_name_t):
if logged_in(request):
if read_access(request,team_name_t):
if request.method=="POST":
task_object=Task.objects.get(task_id=request.POST['task_id'])
task_object.submittion_time=timezone.localtime(timezone.now())
task_object.last_modified_time=timezone.localtime(timezone.now())
task_object.submitted=True
task_object.save()
uploaded_file = request.FILES['file_submit']
file_text = uploaded_file.read()
file_object=File(file_name=uploaded_file.name,task=task_object)
with open('files/'+str(file_object.file_id),'w') as f:
f.write(file_text)
file_object.save()
return HttpResponse("<html><h1>Successfully submitted</h1></html>")
else:
all_tasks = Task.objects.filter(assigned_to=User.objects.get(uname=request.COOKIES.get("username")))
context = {
"tasks": all_tasks,
"team": str(team_name_t),
"round": get_formatted_team_name(team_name_t),
}
return render(request, 'home/tasks.html', context)
else:
raise Http404
else:
return redirect("/")
def upload_file():
if request.method == 'POST':
file = request.files['file']
query = File(name=file.filename)
if not re.search(r"\.txt", file.filename):
return "error: wrong file format"
if File.query.filter_by(name=file.filename).first():
return 'error: file already exists'
else:
file.save(file.filename)
with open('./' + file.filename) as text:
lines = [line.rstrip() for line in text]
os.remove('./' + file.filename)
for line in lines:
print(line)
reg = re.search(r"\A\+[0-9]{11}\z", line)
if not reg:
return "error: wrong number " + line
db.session.add(query)
db.session.commit()
for line in lines:
filename = File.query.filter_by(name=file.filename).first()
query = FileData(number=line, file_id=filename.id)
db.session.add(query)
db.session.commit()
return 'file uploaded successfully'
def upload_file():
user = current_user
if request.method == 'POST':
new_file = request.files['file']
# if file and allowed_file(file.filename):
if new_file:
insecure_filename = new_file.filename
filename = secure_filename(new_file.filename)
upload_folder = app.config['UPLOAD_FOLDER']
user_id = str(current_user.id)
unique_part = str(uuid.uuid4())
save_dir = os.path.join(upload_folder, user_id, unique_part)
full_path = os.path.join(save_dir, filename)
#filename = file.filename
if not os.path.exists(save_dir):
os.makedirs(save_dir)
new_file.save(os.path.join(save_dir, filename))
url = ''.join(['/', full_path])
file = File(filename=insecure_filename,
url=url,
user_id=current_user.id)
db.session.add(file)
db.session.commit()
# url='/static/uploads/'user.id'/'
return render_template('file_uploaded.html',
filename=full_path,
user=user)
else:
return render_template('file_upload.html', user=user)
return render_template('file_upload.html', user=user)
def files():
"""
Uploads a new file if the filename does not exist
in the current users filenames.
"""
if request.method == 'POST':
try:
file_text = request.form['text']
file = request.files['file']
file_date = request.form['date']
except KeyError:
return jsonify({'msg': 'Missing part of your form'}), 400
if file.filename == '':
return jsonify({'msg': 'missing file name'}), 400
# Must secure filename before checking if it already exists
filename = secure_filename(file.filename)
file_names = [file.name for file in current_user.files]
if filename in file_names:
return jsonify({
'msg':
'You already have a file with that name. \
File names must be unique'
}), 400
if len(file_text) > MAX_FILE_DESC_LEN:
return jsonify({
'msg':
'File description must be less than {} characters'.format(
MAX_FILE_DESC_LEN)
}), 400
if not allowed_file(file.filename):
return jsonify({'msg': 'Invalid file type'}), 400
key_str = "{0}/{1}".format(current_user.username, filename)
s3.Bucket(current_app.config['S3_BUCKET']).put_object(
Key=key_str, Body=request.files['file'].stream.read())
# Add a new file
new_file = File(name=filename,
body=file_text,
date=file_date,
key=key_str,
author=current_user)
db.session.add(new_file)
db.session.commit()
return jsonify({'msg': 'Uploaded {0}'.format(filename)})
user_files = [{
'name': file.name,
'body': file.body,
"id": file.id
} for file in current_user.files]
user_files.reverse()
return jsonify({'files': user_files})
def saveFile(f, comment=None, groups=None):
checksum = hashlib.md5(f.read()).hexdigest()
file_size = writeFile(f, checksum)
uploaded = File.query.filter_by(checksum=checksum).first()
if not uploaded:
uploaded = File(name=secure_filename(f.filename),
checksum=checksum,
timestamp=datetime.now(),
comment=comment,
size=file_size)
uploaded.account = current_user
db.session.add(uploaded)
uploaded.groups.extend(groups)
try:
db.session.commit()
except IntegrityError as ex:
application.logger.error(ex)
db.session.rollback()
return False
return True
def drive():
if not current_user.verified:
return render_template('main/unverified.html')
form = FileUploadForm()
if form.validate_on_submit():
errors = []
files = request.files.getlist('files')
for file in files:
file_data = upload_file(current_user, file)
if 'error' in file_data:
errors.append(file_data['error'])
continue
file_model = File()
file_model.from_dict(file_data)
db.session.add(file_model)
db.session.commit()
for error in errors:
flash(error)
return redirect(url_for('main.drive'))
files = File.query.filter_by(user_id=current_user.id).all()
print(files)
return render_template('main/drive.html', form=form, files=files)
def create_file(user_id, folder_id, name, text):
# Make sure user and folder exist
user = User.objects.filter(id=user_id).first()
folder = Folder.objects.filter(id=folder_id).first()
if not user or not folder:
return None
# Ensure that the input folder is owned by the input user
if folder.owner.id != user.id:
return None
# Validate that a file with this name does not already exist
owned_file_names = [folder.name for folder in folder.owned_files.all()]
if name in owned_file_names:
return None
# Create the new file
with transaction.atomic():
new_file = File(name=name, belong=folder)
new_file.save()
new_content = Content(text=text, version=0, file=new_file)
new_content.save()
# Serialize new file and content to JSON
return FileRepo.to_json(new_file, new_content)
def upload_normal_directory(path):
form = UploadDirectoryForm()
user = User.query.get(current_user.id)
currentFolder = Folder.query.filter_by(id=path).first()
if form.validate_on_submit():
emails = form.email.data
users = [user]
for email in emails.split(","):
u = User.query.filter_by(email=email).first()
if u and u in currentFolder.AccessFolder:
users.append(u)
uploaded_files = request.files.getlist("files")
for f in uploaded_files:
filename = secure_filename(f.filename.split("/")[-1])
uploadFile = File(name=filename,
parent=currentFolder,
AccessFile=users)
db.session.add(uploadFile)
db.session.commit()
f.save(os.path.join(returnPathOfFolder(currentFolder.id),
filename))
return redirect(url_for('index'))
return render_template(
'fileModification/upload_normal/upload_normal_directory.html',
title='Upload Normal file',
form=form,
path=path)
def post(self):
title = self.request.get('title')
link = self.request.get('link')
comment = self.request.get('comment')
file_post = File(title=title, link=link, comment=comment)
file_post.put()
self.redirect('/')
async def add_to_db(self):
file = File(file_id=self.file_id,
file_name=self.file_name,
file_key=self.__key)
self.__session = self.scoped_session()
self.__session.add(file)
self.__session.commit()
self.scoped_session.remove()
def new_file(file, path, selected_size=None):
# We save it
file.seek(0)
file.save(path)
# Convert whatever format this has to UTF-8
convert_file_to_utf8(path)
fix_file(path)
hash = utils.hash(file)
if selected_size is not None:
# We get the amount of sentences we want
crop_path = "{}.crop".format(path)
if offset:
crop_proccess = subprocess.Popen(
"cat {} "
"| head -n {} "
"| tail -n {} > {}".format(
path,
int(offset) + int(selected_size), selected_size,
crop_path),
shell=True)
crop_proccess.wait()
else:
crop_proccess = subprocess.Popen(
"cat {} | head -n {} > {}".format(path, selected_size,
crop_path),
shell=True)
crop_proccess.wait()
os.remove(path)
shutil.move(crop_path, path)
with open(path, 'r') as crop_file:
hash = utils.hash(crop_file)
# Get file stats
wc_output = subprocess.check_output('wc -lwc {}'.format(path),
shell=True)
wc_output_search = re.search(r'^(\s*)(\d+)(\s+)(\d+)(\s+)(\d+)(.*)$',
wc_output.decode("utf-8"))
lines, words, chars = wc_output_search.group(
2), wc_output_search.group(4), wc_output_search.group(6)
# Save in DB
db_file = File(path=path,
name=file.filename,
user_language_id=language,
hash=hash,
uploader_id=user_id,
lines=lines,
words=words,
chars=chars,
uploaded=datetime.datetime.utcnow())
return db_file
def upload_file(self, file):
"""
Accepts FileStorage object
Saves original uploaded file and serialized DataFrame for this file.
Creates records in database
:param file: FileStorage
:return: IDs of created data set and file
"""
# Get check sum of file
hashed_file_name = f'{self.get_file_checksum(file)}'
# Change file name and save it under this name
file_extension = self.get_file_extension(file.filename)
file_full_name = f'{hashed_file_name}.{file_extension}'
file_path = os.path.join(self.files_dir, file_full_name)
# Send existing file instead of uploading a new one
if file_full_name in self.files:
_file = File.query.filter(File.path == file_full_name).first()
_dataset = Dataset.query.filter(
Dataset.file_id == _file.id).first()
logger.info(
'User {0} uploaded which already existed under id {1}'.format(
self.user_id, _file.id))
return 'Uploaded', _file.id, _dataset.id
file.seek(0)
file.save(file_path)
# Serialize uploaded file as DataFrame (Update when DataFrame interface is ready)
shape = self.serialize(file_full_name)
# Get attributes of file
file_attributes = self.get_attributes(file_path)
file_attributes['name'] = file.filename
file_attributes['rows'] = shape[0]
file_attributes['cols'] = shape[1]
# Save to db, update when dbm is ready
new_file = File(path=file_full_name, attributes=file_attributes)
db.session.add(new_file)
db.session.flush()
new_dataset = Dataset(user_id=self.user_id, file_id=new_file.id)
db.session.add(new_dataset)
db.session.commit()
logger.info('User {0} uploaded a new file {1}'.format(
self.user_id, new_file.id))
response = {
'file': {
'id': new_file.id,
'name': new_file.attributes['name'],
'size': new_file.attributes['size'],
'rows': new_file.attributes['rows']
},
'dataset_id': new_dataset.id
}
return response
def uploaded_file(fileID):
file = File().query.get(int(fileID))
if file is None or file.user_id != current_user.id:
flash("You don't have permission to view this page !", 'error')
else:
fileurl = 'https://chemicallocha.herokuapp.com/site/uploads/' + file.filename
return render_template('site/fileupload.html',
title='File Uploaded Successfully',
filename=file.filename,
fileurl=fileurl)
