def addFile(fileLocation, fileType):
# save new file
newFile = Files(file_location=fileLocation, file_type=fileType)
fileKey = newFile.put()
return fileKey
def create_file(): #encapsular accion
body = request.form # encapsula el paquete enviado del postman, recibe json y lo convierte al lenguaje del diccionario
instrument = body["instrument"]
type_file = body["typeFile"]
level = body["level"]
language = body["language"]
url = body["url"]
user_id = body['userId']
title = body['title']
file_upload = body['file_upload']
print(request.form["instrument"])
single_file = Files(instrument=instrument,
type_file=type_file,
level=level,
language=language,
url=url,
user_id=user_id,
title=title)
# single_file = Files(instrument=body['instrument'], type_file=body['typeFile'], level=body['level'], language=body['language'], url=body['url'], user_id=body['userId'], title=body['title'], file_upload=request.files['file_upload'])
if file_upload is not None:
# upload to cloudinary
print('picture attached')
file_upload_result = cloudinary.uploader.upload(
file_upload, options={"use_filename": True})
single_file.file_upload = file_upload_result['secure_url']
print("singlefile:", single_file)
db.session.add(single_file) # adding user
db.session.commit() # commiting what we add
return jsonify(body, 200)
def addFile(fileLocation, fileType):
# save new file
newFile = Files(file_location=fileLocation, file_type=fileType)
fileKey = newFile.put()
return fileKey
def number_of_online_players(update, context):
online_users_count = Minecraft_Status().get_online_users_count()
path_of_gifs_related_to_online_users_count = Files().get_path_directory_of_videos(online_users_count)
gifs_related_to_online_users_count = Files().get_files_names_path_in_directory(path_of_gifs_related_to_online_users_count)
update.message.reply_text(f'There are {online_users_count} online players in minecraft.')
if is_not_empty(gifs_related_to_online_users_count):
respone_gif_path = Files().random_choice_from_list(gifs_related_to_online_users_count)
update.message.reply_animation(open(respone_gif_path, "rb"))
def file_upload(request):
if request.is_ajax():
if request.method == 'POST':
form = FileUploadForm(files=request.FILES)
instance = Files(user=request.user, file=request.FILES['file'])
instance.save()
return HttpResponse(json.dumps(list_files(request.user)))
else:
return HttpResponse(json.dumps(list_files(request.user)))
def save_files(request):
"""
Call p_add_file_to_release for list of files
"""
_files = request.POST.items()
files = []
for file_name in _files:
if not file_name[0] in ['csrfmiddlewaretoken', 'task_num', 'repo']:
files.append(file_name)
task_num = request.POST.get('task_num')
repo = request.POST.get('repo')
model = Files()
for file_name in files:
model.callProc('p_add_file_to_release', (task_num, file_name[0], file_name[1], repo), user=request.user)
return {'files': files, 'task_num': task_num}
def add_files():
name = request.json['name']
title = request.json['title']
new_file = Files(name, title)
db.session.add(new_file)
db.session.commit()
return file_schema.jsonify(new_file)
def index():
sql_session = SqlSession()
if 'file' in request.files:
upload_file = request.files['file']
if upload_file:
li = sql_session.query(Files).count()
if li > 0:
count = sql_session.query(Files).order_by(
Files.id.desc()).first().id
else:
count = 0
filename = str(count + 1) + ".wav"
upload_file.save(os.path.join(app.config['UPLOAD_DIR'], filename))
the_file = Files(upload_file.filename, filename, 1)
sql_session.add(the_file)
sql_session.commit()
return "success"
page = request.args.get('page') or 1
page = int(page)
count = sql_session.query(Files).count()
total_page = count / 25
if count % 25:
total_page += 1
items = sql_session.query(Files).order_by(Files.id.desc()).offset(
(page - 1) * 25).limit(25).all()
return render_template('index.html',
items=items,
cur_page=page,
total_page=total_page)
def import2project(modeladmin, request, queryset):
for project in queryset:
pid = project.id
project_dir = os.path.dirname(__file__) + '/games/%s/jp/'%project.project_name
fl = Pluto.walk(project_dir)
for fn in fl:
if not fnmatch.fnmatch(fn,'*.pickle'):
continue
fp = open(fn,'rb')
sid_list = cPickle.load(fp)
fp.close()
length = len(set(sid_list))
fn = fn.replace(project_dir,'').replace('.pickle','')
if Files.objects.filter(item=pid, filename=fn):
continue
f = Files(item_id=pid, filename=fn, length=length, length_tran=0, rate=0)
f.save()
def upload(request):
file = upload_receive(request)
instance = Files(user=request.user, file=file)
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload():
file = request.files['inputFile']
# saving it in uploads folder
file.save(os.path.join(app.config['UPLOAD_FOLDER'], file.filename))
# saving it in database
newFile = Files(filename=file.filename, data=file.read())
db.session.add(newFile)
db.session.commit()
return redirect(url_for('index'))
def add_problem(title,
category,
description,
value,
grader_contents,
pid=utils.generate_string(),
hint="",
bonus=0,
autogen=0):
grader_contents = str(grader_contents)
pid = str(pid)
value = int(value)
title_exists = Problems.query.filter_by(title=title).first()
if title_exists:
raise WebException("Problem name already taken.")
while Problems.query.filter_by(pid=pid).first():
pid = utils.generate_string()
if category == "Programming":
programming.validate_judge(grader_contents)
else:
validate_grader(grader_contents, autogen=int(autogen))
grader_folder = os.path.join(app.config["GRADER_FOLDER"], pid)
if not os.path.exists(grader_folder):
os.makedirs(grader_folder)
grader_path = os.path.join(grader_folder, "grader.py")
grader_file = open(grader_path, "w")
grader_file.write(grader_contents)
grader_file.close()
problem = Problems(pid,
title,
category,
description,
value,
grader_path,
bonus=bonus,
hint=hint,
autogen=autogen)
db.session.add(problem)
files = request.files.getlist("files[]")
for _file in files:
filename = secure_filename(_file.filename)
if len(filename) == 0:
continue
file_path = os.path.join(app.config["UPLOAD_FOLDER"], filename)
_file.save(file_path)
db_file = Files(problem.pid, "/".join(file_path.split("/")[2:]))
db.session.add(db_file)
db.session.commit()
db.session.close()
def add_file(auth, project_id):
if 'payload' in auth:
client_id = auth['payload']['sub']
file_name = request.form.get('file_name')
file_content = request.form.get('file_content')
# project_id = request.form.get('project_id') # hidden field, use URL instead
# user owns project
if Project.query.filter_by(id=project_id, user_id=client_id):
# check if filename is free
if Files.query.filter_by(project_id=project_id,
name=file_name).first() is None:
timestamp = datetime.datetime.now()
new_file = Files(project_id=project_id,
name=file_name,
timestamp=timestamp,
content=file_content)
db.session.add(new_file)
try:
db.session.commit()
except:
error = 'Cannot register file'
return make_response(
render_template('files.html',
title='Projects',
error=error,
project=''))
# show update
files = Files.query.filter_by(project_id=project_id).all()
project = Project.query.filter_by(id=project_id).first()
response = make_response(
render_template('files.html',
title=project.name,
files=files,
project=project))
return response
else:
error = 'File name already in use'
return make_response(
render_template('files.html',
title='Projects',
error=error))
else:
error = 'Error: Cannot add to project not owned by client'
return make_response(
render_template('files.html', title='Projects', error=error))
else:
response = make_response(
render_template('error.html', error=auth['message']))
return response
def upload(workshopID):
# Check workshop exists:
result = Workshops.query.filter_by(id=workshopID).first()
if result is None:
abort(404)
workshop = result.workshop
# Prepare form:
form = UploadForm(request.form)
form.type.choices = get_type_list(workshop)
# If user tries to upload a file
if request.method == 'POST':
if form.validate():
if app.config['S3_OR_DBX'] == 'S3': # Get filename only
filename = request.form['filename_s3']
else: # Also get file
file = request.files['file']
filename = str(randint(10000, 99999)) + '_' + \
secure_filename(file.filename)
# Get fields from web-form
title = form.title.data
description = form.description.data
type = form.type.data
who = form.who.data
author = session['username']
# Insert into files database:
db_row = Files(filename=filename,
title=title,
description=description,
workshop=workshop,
type=type,
who=who,
author=author)
id = psql_insert(db_row)
if app.config['S3_OR_DBX'] == 'DBX': # Save file to dropbox
upload_file_to_dbx(file, filename)
# flash success message and reload page
flash('File uploaded successfully', 'success')
return redirect(url_for('upload', workshopID=workshopID))
else:
if app.config['S3_OR_DBX'] == 'S3': # Delete file from S3
filename_s3 = request.form['filename_s3']
delete_file_from_s3(filename_s3)
# Flash error message:
flash('Fix form errors and try again', 'danger')
# If user just navigates to page
return render_template('upload.html',
form=form,
workshop=workshop,
workshopID=workshopID,
S3_OR_DBX=app.config['S3_OR_DBX'])
def files():
if request.method == "POST":
if current_user.is_authenticated == True:
try:
pic_file = request.files['file']
print(pic_file)
new_file = Files(name=pic_file.filename,
data=pic_file.read(),
user=current_user)
db.session.add(new_file)
db.session.commit()
print(pic_file.filename + 'saved!')
return succesful_response({'message': 'Great Success!'})
except:
return succesful_response({'message': 'No picture selected'})
return "Bad things"
def save_file(cls, file):
"""
File name is created in this way:
file.name + _ + utc.now()
:param file: File that is going to be saved
:return: Saved file
"""
now = datetime.now()
fname = file.filename + "_" + str(now)
cls.my_bucket.Object(fname).put(Body=file)
newFile = Files(title=request.form.get("title"), name=fname)
db.session.add(newFile)
db.session.commit()
return newFile
def upload(workshopID):
# Check workshop exists:
result = Workshops.query.filter_by(id=workshopID).first()
if result is None:
abort(404)
workshop = result.workshop
# Prepare form:
form = UploadForm(request.form)
form.type.choices = get_type_list(workshop)
# If user tries to upload a file
if request.method == 'POST':
if form.validate():
# dropbox
file = request.files['file']
filename = (str(randint(10000, 99999)) + '_' +
secure_filename(file.filename))
# Get fields from web-form
title = form.title.data
description = form.description.data
type = form.type.data
who = form.who.data
author = session['username']
# Insert into files database:
db_row = Files(filename=filename,
title=title,
description=description,
workshop=workshop,
type=type,
who=who,
author=author)
id = psql_insert(db_row)
# Save file to dropbox
gcf.upload_blob('wcssp-fortis', file, workshop + '/' + filename)
# flash success message and reload page
flash('File uploaded successfully', 'success')
return redirect(url_for('upload', workshopID=workshopID))
else:
# Flash error message:
flash('Fix form errors and try again', 'danger')
# If user just navigates to page
return render_template('upload.html.j2',
form=form,
workshop=workshop,
workshopID=workshopID)
def upload():
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
if request.method == "POST":
# ================= #
url_data = request.form['url']
name_data = request.form['name']
#
url = url_data
name_for_file = name_data
# ================= #
apiKey = "afbada1181d7849d6650fd27bc8fc655861fe954f781f393f4a99a5bb2754c26"
linkRequests = "https://api.html2pdf.app/v1/generate?url={0}&apiKey={1}".format(
url, apiKey)
#
result = requests.get(linkRequests).content
#
rand_doc_id = ''.join(
random.choice(string.ascii_uppercase) for _ in range(20))
# ================= #
with open(f"{rand_doc_id}.pdf", "wb") as handler:
handler.write(result)
# ================= #
upload_file(f"{rand_doc_id}.pdf", BUCKET)
new_file = Files(file_url=f"{rand_doc_id}.pdf",
files_name=name_for_file,
files_id=g.user.id)
db.session.add(new_file)
db.session.commit()
# ================= #
if os.path.exists(f"{rand_doc_id}.pdf"):
os.remove(f"{rand_doc_id}.pdf")
else:
print("The file does not exist")
# ================= #
return redirect("users/account")
def create_document(destination, filename, email, db: Session):
#inserts a document in the given location of a server
#Adds record to the File table and Collaborator's table.
try:
email_id = get_email_id(email, db)
if email_id is None:
email_id = add_email_id(email, db).id
print(email_id)
else:
email_id = email_id.id
print(email_id)
doc_det = Files(name=filename,
filepath=destination,
created_on=str(dt.datetime.now()),
owner=email_id,
modified_on=dt.datetime.now(),
file_status='saved')
print(doc_det)
db.add(doc_det)
db.commit()
#db.refresh(doc_det)
db.flush()
print(doc_det.id)
shared_status = Collaborators(collaborator_id=email_id,
file_id=doc_det.id,
access_level="owner",
access_date=dt.datetime.now(),
downloaded_on=dt.datetime.now())
db.add(shared_status)
db.commit()
db.refresh(shared_status)
return True
except Exception as e:
return False
def upload():
appHandler.config['UPLOADS_FOLDER'] = 'app/uploads/' + g.user.username
file = request.files['file']
print file
if file and allowed_file(file.filename):
if not os.path.exists(appHandler.config['UPLOADS_FOLDER']):
os.makedirs(appHandler.config['UPLOADS_FOLDER'])
filename = secure_filename(file.filename)
file.save(os.path.join(appHandler.config['UPLOADS_FOLDER'], filename))
path = appHandler.config['UPLOADS_FOLDER'] + "/" + filename
print path
size = os.path.getsize(path)
print size
files = Files(filename, g.user.username, size, 0, "Active")
db.session.add(files)
db.session.commit()
return redirect(url_for('index', filename=filename))
else:
flash('No file Uploaded')
return redirect(url_for('index'))
def social_media_redirecter(target_name):
social_urls = Files().get_social_urls()
target_name = target_name.lower()
if target_name in social_urls:
return redirect(social_urls[target_name], code=302)
abort(404)
def post(self):
if len(request.files) == 0:
return jsonify({'error': 'no file'})
numUploaded = 0
auth_header = request.headers.get('Authorization')
# see if properly authorized
if auth_header:
auth_token = ''
try:
auth_token = auth_header.split(" ")[1]
except IndexError:
responseObject = {
'status': 'fail',
'message': 'Bearer token malformed'
}
res = make_response(jsonify(responseObject))
return res, 401
if auth_token:
# verify token
try:
userID = User.decode_auth_token(auth_token)
user = User.query.filter_by(id=userID)
fileName = fileObj = None
for fn, fo in request.files.items():
# print(fn)
# print(fo)
fileName = fn
fileObj = fo
newFile = Files(filename=fileName, user_id=userID)
# upload file
if fileObj and fileName:
fileObj.save(f"../uploads/{fileName}")
numUploaded += 1
# insert new file
db.session.add(newFile)
db.session.commit()
# success
responseObject = {
'status': 'success',
'message': 'file successfully uploaded',
}
return make_response(jsonify(responseObject)), 201
except:
responseObject = {
'status': 'fail',
'message':
'Error decoding auth token or creating file.'
}
return make_response(jsonify(responseObject)), 404
else:
responseObject = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'No auth token provided.'
}
return make_response(jsonify(responseObject)), 401
def signout(**kwargs):
if Auth().is_user_logged_in():
Files().remove_api_key()
Rich().rich_print("🥺 You Now Logged-Out! Hope To See You Soon...")
else:
Rich().rich_print("😧 You Were Not Logged-In!")
