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 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 update_user_info():
"""
Input
- profile_picture (optional): base64 of the profile picture. Set to null to remove the profile picture
- name (optional)
"""
user = g.user
data = request.get_json() or {}
if "profile_picture" in data:
if data["profile_picture"] is None:
if user.profile_picture_id:
file = user.profile_picture
user.profile_picture_id = None
Session.flush()
if file:
File.delete(file.id)
s3.delete(file.path)
Session.flush()
else:
raw_data = base64.decodebytes(data["profile_picture"].encode())
file_path = random_string(30)
file = File.create(user_id=user.id, path=file_path)
Session.flush()
s3.upload_from_bytesio(file_path, BytesIO(raw_data))
user.profile_picture_id = file.id
Session.flush()
if "name" in data:
user.name = data["name"]
Session.commit()
return jsonify(user_to_dict(user))
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 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 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 zip_upload(file):
""" Save the uploaded file as a zip file """
app.logger.warn('generating zip from upload')
if not file:
return None
# Allow uploading zip file.
if file.filename.endswith('.zip'):
app.logger.warn('zip file, validate contents')
zipFile = ZipFile(file.stream, 'r', ZIP_DEFLATED)
if (len(zipFile.infolist()) != 1):
app.logger.error('wrong number of files in zip')
raise BadRequest('ZIP uploads must contain exactly one file')
app.logger.warn('valid zip')
return File.fromUpload(file, File.MODELS_DIR)
# Zip source file & save to large file storage
app.logger.warn('create empty zip')
zip = File.fromName(file.filename + '.zip', File.MODELS_DIR)
zip.mime_type = 'application/zip'
filename, fileExt = os.path.splitext(file.filename)
with tempfile.NamedTemporaryFile(suffix=fileExt) as uploadFile:
app.logger.warn('save upload to temp')
file.save(uploadFile.name)
with ZipFile(zip.getAbsolutePath(), 'w', ZIP_DEFLATED) as zipFile:
app.logger.warn('write temp file to zip')
zipFile.write(uploadFile.name, file.filename)
app.logger.warn('set zip size')
zip.size = os.stat(zip.getAbsolutePath()).st_size
app.logger.warn('generated zip')
return zip
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 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 mutate(self, info, **kwargs):
user = info.context.user
post = {}
if "content" in kwargs: post["content"] = kwargs["content"]
if "picture" in kwargs:
picture = File.filter_permissions(
File.objects, File.permission_filters(user))\
.get(pk=kwargs["picture"])
post["picture"] = picture
if "createdBy" in kwargs:
created_by = User.filter_permissions(
User.objects, User.permission_filters(user))\
.get(pk=kwargs["createdBy"])
post["created_by"] = created_by
post = Post.objects.create(**post)
if "likedBy" in kwargs:
post.liked_by.clear()
for liked_by_id in kwargs["likedBy"]:
liked_by = User.filter_permissions(
User.objects, User.permission_filters(user))\
.get(pk=liked_by_id)
post.liked_by.add(liked_by)
post.save()
return SavePostMutation(post=post)
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 init():
'''Init the database'''
db.drop_all()
db.create_all()
Role.insert_roles()
u = User(email='*****@*****.**',
nickname='Admin',
password='******',
confirmed=True,
role=Role.query.filter_by(name='Administrator').first(),
about_me='Wait for updating')
db.session.add(u)
u = User(email='*****@*****.**',
nickname='testuser',
password='******',
confirmed=True,
role=Role.query.filter_by(name='User').first(),
about_me='this is a test user')
db.session.add(u)
db.session.commit()
CFILE.generate_fake(5) # éęŗēę 5 äøŖ å®ä½ę件
User.generate_fake(5) # éęŗēę 5 äøŖ ēØę·
File.generate_fake(100) # éęŗēę 100 ę”ę件记å½
Comment.generate_fake(70) # éęŗēę 100 ę”čÆč®ŗ
Message.generate_fake(100) # éęŗēę 100 ę”ę¶ęÆ
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_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_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 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 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 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 post(self):
file = request.files['file']
f = File()
f.set_file(file)
db.session.add(f)
db.session.commit()
return f, 201
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('/')
def validate(self):
"""
Uploads the file
:return: "upload.html"
"""
file_path = FilesPath()
# Set file model attributes
file = self.form.file.data
filename = self.form.filename.data or file.filename
repo = self.form.repo.data
ext = file_path.get_ext(filename=filename.lower())
# Create dir
if not file_path.isdir():
file_path.newdir()
user = User.query.filter_by(username=current_user.username).first()
file_db = File(filename=filename, repo=repo, uploader=user)
db = Database()
db.add(file_db)
type = None
ext_list = [Extensions.document_list, Extensions.image_list, Extensions.audio_list, Extensions.video_list]
if any(ext in ext_check for ext_check in ext_list):
token = Tokens(length=7)
filename_save = str(file_db.id) + ext
if ext in ext_list[0]:
type = "document"
elif ext in ext_list[1]:
type = "image"
elif ext in ext_list[2]:
type = "audio"
elif ext in ext_list[3]:
type = "video"
file_db.type = type
token_db = Token(token=token.token, type=type, auth=user, file=file_db)
db.add(file_db, token_db)
else:
type = "misc"
filename_save = str(file_db.id)
if file_db.repo == "public":
file_db.path = file_path.public(filename=filename_save, type=type)
db.add(file_db)
file.save(file_path.public(filename=filename_save, type=type))
elif file_db.repo == "private":
file_db.path = file_path.private(filename=filename_save, type=type)
db.add(file_db)
file.save(file_path.private(filename=filename_save, type=type))
flash('File {} uploaded successfully!'.format(file.filename))
return url_for('upload')
def file_view(request, filename=None):
if request.method == 'GET':
if request.user.is_authenticated:
files = File.objects.filter(
Q(owner=request.user) | Q(private=False))
else:
files = File.objects.filter(private=False)
if 'search' in request.GET:
files = files.filter(name__icontains=request.GET['search'])
if filename:
try:
file = files.get(unique_name=filename)
except ObjectDoesNotExist:
file = None
file_full_path = os.path.join(settings.MEDIA_ROOT, filename)
if file and os.path.isfile(file_full_path):
response = StreamingHttpResponse(
(line for line in open(file_full_path, 'rb')))
response[
'Content-Disposition'] = "attachment; filename={0}".format(
file.name)
response['Content-Length'] = os.path.getsize(file_full_path)
return response
else:
return JsonResponse(
{'error': 'The file is not found or is deleted.'})
else:
files = files.order_by('-create')
return JsonResponse(list(files),
encoder=UploaderEncoder,
safe=False)
elif request.method == 'POST':
if 'file' not in request.FILES or 'private' not in request.POST:
return JsonResponse(
{
'error':
"Please provide the file and whether it should be private."
},
status=400)
file = request.FILES['file']
is_private = json.loads(request.POST['private'])
fs = FileSystemStorage(location=settings.MEDIA_ROOT)
filename = fs.save(file.name, file)
f = File(owner=request.user,
name=file.name,
private=is_private,
unique_name=filename)
f.save()
return JsonResponse(f, encoder=UploaderEncoder, safe=False)
def create_file(name, username, user_id, id=0, desc=""):
try:
file = File(id=id,
name=name,
key="{0}/{1}".format(username, name),
body=desc)
file.user_id = user_id
return file
except Exception as err:
print("Unexpected error creating File: ", err)
raise
def index_file(filename):
f = File(filename)
filepath = os.path.join(app.root_path, app.config['FILE_FOLDER'], filename)
try:
st = os.stat(filepath)
f.size = st[ST_SIZE]
except IOError:
pass
db.session.add(f)
db.session.commit()
def save_photo(update, context):
""" Add given photo to current directory
"""
# create new record about the file in the DB
photo = File(telegram_id=update.message.message_id)
photo.save()
# attach new file to current directory
directory = Directory.objects.get(
name=context.chat_data.get('current_directory'),
user_id=Directory.encrypt_user_id(update.effective_user.id))
directory.update(add_to_set__contains_files=photo)
directory.save()
update.message.reply_text(
f'Your file now live in directory {directory.name}')
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 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 handle(self, *args, **options):
source = options['source']
if not source or not os.path.exists(os.path.expanduser(source)):
raise Exception('{0} is not a valid CSV path'.format(source))
functions = set()
files = set()
with open(source) as file_:
reader = csv.reader(file_)
for row in reader:
if 'Function' in row[0]:
name = row[1]
file = row[2]
sloc = int(row[3])
function = Function()
function.name = name
function.file = file
function.sloc = sloc
if function not in functions:
functions.add(function)
else:
functions = self._update(function, functions)
elif 'File' in row[0]:
name = row[2]
sloc = int(row[3])
file_ = File()
file_.name = name
file_.sloc = sloc
if file_ not in files:
files.add(file_)
else:
files = self._update(file_, files)
if len(functions) > 0:
logger.debug('Adding {0} functions.'.format(len(functions)))
Function.objects.bulk_create(functions)
logger.info('Loaded {0} functions.'.format(len(functions)))
if len(files) > 0:
logger.debug('Adding {0} files.'.format(len(files)))
File.objects.bulk_create(files)
logger.info('Loaded {0} files.'.format(len(files)))
def prepare(mode):
if mode == "append":
fmode = "a"
elif mode == "refresh":
fmode = "w"
else:
return "Wrong mode specifier"
# Get data as strings
data = json.loads(request.data.decode('utf-8'))
username = data['user']
user = db.session.query(User).filter_by(username=username).scalar()
if not user:
return "User can't be found"
raw = data['raw'].encode('utf-8')
key = user.key
encoder = Fernet(key)
# Check credentials
raw = encoder.decrypt(raw).decode('utf-8')
if not raw.startswith(username):
return "Auth error"
else:
raw = raw[len(username):]
info = json.loads(raw)
# Create project if doesn't exist
project_name = info[0]
pr = user.projects.filter_by(name=project_name).scalar()
if not pr:
pr = Project(name=project_name, user_id=user.id)
db.session.add(pr)
file_names = info[1]
bad_files = pr.files.filter(~File.name.in_(file_names)).all()
for file in bad_files:
path = file.get_path()
if os.path.exists(path):
os.remove(path)
db.session.delete(file)
for fname in file_names:
file = pr.files.filter_by(name=fname).scalar()
if not file:
file = File(name=fname, project_id=pr.id)
db.session.add(file)
open(file.get_path(), fmode).close()
db.session.commit()
return "Project is ready for work"
def post(self, filename):
extension = filename.split('.')[-1]
f = File()
db.session.add(f)
db.session.commit()
with open(
os.path.join(app.config['UPLOAD_DIRECTORY'],
'.'.join([str(f.id), extension])), "wb") as file:
file.write(request.data)
response = jsonify(f.as_dict())
response.status_code = 201
f.extension = extension
thread = threading.Thread(f.process())
thread.start()
return response
def tcm_exclusions():
page = request.args.get("page", 1, type=int)
quality_threshold = (db.session.query(RefQuality.preference).filter(
RefQuality.quality_title == "HDTV-720p").subquery())
ranked_files = File.get_ranked_files()
library = (db.session.query(File, Movie, RefQuality).outerjoin(
Movie, (Movie.id == File.movie_id)).join(
RefQuality, (RefQuality.id == File.quality_id)).join(
ranked_files, (ranked_files.c.id == File.id)).filter(
File.feature_type == None).filter(
ranked_files.c.rank == 1).filter(
RefQuality.preference >=
quality_threshold.c.preference).filter(
File.media_library == "Movies").order_by(
File.plex_filename).paginate(
page,
current_app.config["RESULTS_PER_PAGE"],
False))
prev_url = (url_for("main.tcm_exclusions", page=library.prev_num)
if library.has_prev else None)
next_url = (url_for("main.tcm_exclusions", page=library.next_num)
if library.has_next else None)
return render_template(
"tcm_exclusions.html",
title="TCM Exclusion List",
library=library.items,
prev_url=prev_url,
next_url=next_url,
)
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 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 test_import_no_mailboxes(flask_client):
# Create user
user = login(flask_client)
# Check start state
assert len(Alias.filter_by(user_id=user.id).all()) == 1 # Onboarding alias
# Create domain
CustomDomain.create(
user_id=user.id, domain="my-domain.com", ownership_verified=True
)
Session.commit()
alias_data = [
"alias,note",
"[email protected],Used on eBay",
'[email protected],"Used on Facebook, Instagram."',
]
file = File.create(path="/test", commit=True)
batch_import = BatchImport.create(user_id=user.id, file_id=file.id)
import_from_csv(batch_import, user, alias_data)
assert len(Alias.filter_by(user_id=user.id).all()) == 3 # +2
def mytask(request, team_name_t):
if logged_in(request):
if read_access(request,team_name_t):
if request.method=='POST':
task_object=Task.objects.get(
assigned_to=User.objects.get(uname=request.COOKIES['username']),
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()
if not 'file_submit' in request.FILES:
return HttpResponse("<html><h1>No file selected</h1></html>")
uploaded_file = request.FILES['file_submit']
file_text = uploaded_file.read()
if File.objects.filter(task=task_object,file_name=uploaded_file.name).exists():
file_object=File.objects.get(task=task_object,file_name=uploaded_file.name)
file_object.accepted=False
file_object.submitted_time=timezone.localtime(timezone.now())
file_object.save()
else:
file_object=File(file_name=uploaded_file.name,task=task_object,tags=request.POST['tags'])
file_object.save()
f = open('files/'+str(file_object.file_id),'w+')
f.write(file_text)
f.close()
return HttpResponse("<html><h1>File Submitted</h1></html>")
my_tasks = Task.objects.prefetch_related('file_set').filter(
assigned_to=User.objects.get(uname=request.COOKIES.get("username")),
team=Team.objects.get(team_name=team_name_t)
).order_by('-task_id')
context = {
"team": team_name_t,
"tasks": my_tasks,
"user": User.objects.get(uname=request.COOKIES['username']),
"round": get_formatted_team_name(team_name_t),
"is_admin": is_admin(request,team_name_t),
}
return render(request, 'home/mytask.html', context)
else:
raise Http404
else:
return redirect("/")
def images_index(request):
query = __store_session_query(request, File.get_all_images())
try:
del request.session['random_list']
except KeyError:
pass
per_page = 24
paginator = Paginator(query, per_page)
page = request.GET.get('page')
try:
files = paginator.page(page)
except PageNotAnInteger:
files = paginator.page(1)
page = 1
except EmptyPage:
files = paginator.page(paginator.num_pages)
page = paginator.num_pages
page = int(page)
page_range = []
threshold = 10
threshold_size = (threshold*2) + 1
# build initial page range list
for i in xrange(1, paginator.num_pages+1):
if i+threshold >= page and i <= page:
page_range.append(i)
elif i-threshold <= page and i >= page:
page_range.append(i)
# if the length of page_range is less than the threshold size, add to it
if len(page_range) < threshold_size:
if page <= threshold:
i = page_range[-1]
while len(page_range) < threshold_size and i < paginator.num_pages:
i = i + 1
page_range.append(i)
else:
i = page_range[0]
while len(page_range) < threshold_size and i > 1:
i = i - 1
page_range.insert(0, i)
if page_range[0] != 1:
page_range.insert(0, '...')
if page_range[-1] != paginator.num_pages:
page_range.append('...')
i = per_page * (page-1) + 1
for f in files:
f.num = i
i = i + 1
context = {'files': files, 'page_range': page_range}
if request.GET.get('view') == 'list':
context['view'] = 'list'
return render(request, 'images/index.html', context)
def uploader(request):
form = FileForm()
if request.method == 'POST':
if form.validate(request.form, request.files):
file = File(comment=form['comment'],
tags=form['tags'],
name=request.files['file'].filename)
file.put()
data = form['file']
chunk_size = 1000000
for i in xrange(int(len(data)/chunk_size)+1):
chunk = Chunk(file=file, data=data[i*chunk_size:(i+1)*chunk_size], index=i)
chunk.put()
return redirect(url_for('app/uploader'))
query = File.all().order('-created')
files = create_paginator_page(request, query)
return render_to_response('app/uploader/index.html', {'files': files,
'paginator': render_paginator(files),
'form': form.as_widget()})
def sendRequestgetJSON(idProject):
"""First request to getJSON"""
fileURL = idProject + ".json" #http://sarabc.pencilcode.net/load/first.json
print fileURL
# Create DB of files
now = datetime.now()
fileName = File (filename = fileURL, method = "url", time = now,
score = 0, abstraction = 0, parallelism = 0,
logic = 0, synchronization = 0, flowControl = 0,
userInteractivity = 0, dataRepresentation = 0)
print "GUARDADO EN LA BASE DE DATOS --> ", fileName
# Guardamos en la base de datos.
fileName.save()
dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/"
fileSaved = dir_zips + str(fileName.id) + ".json"
#fileName.id -> models aƱaden el campo id automaticamente.
# /home/sara/drPencilcode-master/uploads/15.json
# Log
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) # /home/sara/drPencilcode-master/uploads/15.json
outputFile = open(file_name, 'wb')
# print "Retrieving: ", idProject
jsonFile = urllib2.urlopen(idProject) # http://sarabc.pencilcode.net/load/first
# abre la url(urlopen) y lee los datos de esa url(urllib2).
outputFile.write(jsonFile.read())
outputFile.close() #lo escribe todo en un .json.
return (file_name, fileName)
def index():
file_names = []
file_paths = []
files_ = File.get_all()
for f in files_:
file_names.append(f.file_name)
file_paths.append(f.file_path)
# pages = [i for i in range(int(len(file_names)/20))]
return render_template(
'index.html', files=zip(file_names, file_paths))
def save(self):
filename = self.f
with open(self.path, 'wb') as f:
f.write(self.f.value)
if not self.id:
entry = File()
entry.name = self.filename
entry.type = self.type
entry.base = self.base
entry.filename = self.base + self.ext
entry.size = len(self.f.value)
entry.mime = self.mimetype
entry.save()
self.id = entry.id
return self.base
def download_file(url, user, password, filename, dest, strongest_site_id):
"""
Download a specific file. If the file is already
downloaded ask the user if the file shoule be downloaded again
"""
from ftplib import FTP
from datetime import date
from app.models import File
from app import db
name = '{}.xml'.format(date.today())
dest = '{}'.format(os.path.join(dest, name))
f = File(name=name, path=dest)
try:
ftp = FTP(host=url,
user=user,
passwd=password)
except Exception as e:
logger.error("There was an error when loggin to ftp server {}".format(e))
f.error = True
f.error_message = "{}".format(e)
db.session.add(f)
db.session.commit()
raise FTPError(e)
logger.debug("Filename: {}".format(filename))
cmd = 'RETR {}'.format(filename)
logger.debug("CMD {}".format(cmd))
logger.info("Start Downloading file {}".format(filename))
file = open(dest, 'wb')
try:
ftp.retrbinary(cmd, file.write, blocksize=2048)
except Exception as e:
f.error = True
f.error_message = "{}".format(e)
db.session.add(f)
db.session.commit()
raise FTPError(e)
logger.info("File successfully downloaded")
f.error = False
db.session.add(f)
db.session.commit()
# Import file
import_xml.delay(f.id, strongest_site_id)
logger.info("Start import the downloaded file")
def uploader_delete(request, id):
file = File.get_by_id(id)
if request.user == file.user or request.user.id_admin:
db.delete(file.chunks)
db.delete(file)
return redirect(url_for('app/uploader'))
def get_file(base):
try:
f = File.get(File.base == base)
except File.DoesNotExist:
return None
return f
def uploader_download(request, id, filename):
file = File.get_by_id(id)
data = ''.join(chunk.data for chunk in file.chunks.order('index'))
return Response(mimetype=mimetypes.guess_type(file.name)[0], response=data)
def uploadUnregistered(request):
"""Upload file from form POST for unregistered users"""
if request.method == 'POST':
#Revise the form in main
#If user doesn't complete all the fields,it'll show a warning
try:
file = request.FILES['zipFile']
except:
d = {'Error': 'MultiValueDict'}
return d
# Create DB of files
now = datetime.now()
fileName = File (filename = file.name.encode('utf-8'), method = "project" , time = now)
fileName.save()
dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/"
# Version of Scratch 1.4Vs2.0
version = checkVersion(fileName.filename)
if version == "1.4":
fileSaved = dir_zips + str(fileName.id) + ".sb"
else:
fileSaved = dir_zips + str(fileName.id) + ".sb2"
# Create log
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)
with open(file_name, 'wb+') as destination:
for chunk in file.chunks():
destination.write(chunk)
#Create 2.0Scratch's File
file_name = changeVersion(request, file_name)
# Analyze the scratch project
try:
d = analyzeProject(request, file_name)
except:
#There ir an error with kutz or hairball
#We save the project in folder called error_analyzing
fileName.method = 'project/error'
fileName.save()
oldPathProject = fileSaved
newPathProject = fileSaved.split("/uploads/")[0] + \
"/error_analyzing/" + \
fileSaved.split("/uploads/")[1]
shutil.copy(oldPathProject, newPathProject)
d = {'Error': 'analyzing'}
return d
# Show the dashboard
# Redirect to dashboard for unregistered user
d['Error'] = 'None'
return d
else:
return HttpResponseRedirect('/')
def uploader_check_delete(request, id):
return render_to_response('app/uploader/delete.html', {'file': File.get_by_id(id)})
thumb_dir = mk_md5_dir(md5, settings.MAIO_SETTINGS['thumbnail_directory'])
thumb = os.path.join(thumb_dir,
md5 + '.jpg')
if not os.path.isfile(thumb):
im.thumbnail((128, 128), Image.ANTIALIAS)
im.save(thumb)
print md5sum.hexdigest(), mimetype, file_path
# save file information to the database
try:
file_path_hash = hashlib.md5()
file_path_hash.update(file_path.encode('utf-8'))
fph = file_path_hash.hexdigest()
f = File(mime_type=mimetype, size=sfile.st_size, mtime=sfile.st_mtime,
md5sum=md5, tn_path=thumb, file_path=file_path, file_path_hash=fph)
f.save()
except django.db.utils.IntegrityError:
f = File.objects.get(file_path_hash=fph)
if sfile.st_mtime == f.mtime:
print "Already in database and up-to-date, skipping %s ..." % (file_path,)
continue
f.mime_type = mimetype
f.size = sfile.st_size
f.mtime = sfile.st_mtime
f.md5sum = md5
f.tn_path = thumb
f.save()
except:
raise
