def upload(request):
context = {}
if request.method == 'POST':
uploaded_file = request.FILES['document']
fs = FileSystemStorage()
name = fs.save(uploaded_file.name, uploaded_file)
context['url'] = fs.url(name)
with open(os.path.join(STATICFILES_DIRS[0], 'JSON', 'url.json'),
'w') as json_file:
json.dump({'url': context['url']}, json_file)
analysisAPI.start_analysis(fs.get_valid_name(name))
file = open(os.path.join(STATICFILES_DIRS[0], 'JSON', 'result.json'))
result = file.read()
file.close()
with open(os.path.join(STATICFILES_DIRS[0], 'JSON',
'result.json')) as f:
res1 = json.load(f)
return render(
request, 'analysis/upload.html', {
'result': result,
'url': context['url'],
'alltext': str(res1['allText']),
'finTones': res1['finTones']
})
return render(request, 'analysis/upload.html')
def upload(request):
if request.method == 'POST':
f = request.FILES.get('file')
resp = {}
fs = FileSystemStorage(location=settings.MEDIA_ROOT, base_url=settings.MEDIA_URL)
filename = fs.get_valid_name(f.name)
#Save the file to disk
disk_path = fs.save(filename, f)
#Save a thumbnail to disk
width, height = None, None
try:
# Thumbnails are saved as JPG unless the source is PNG. Then it's saved as a PNG to preserve transparency.
suffix = '-thumb.jpg'
if f.content_type == 'image/png':
suffix = '-thumb.png'
if f.content_type == 'image/gif':
suffix = '-thumb.gif'
thumbnail_filename = filename.split('.')[0] + suffix
im = Image.open(os.path.join(settings.MEDIA_ROOT, filename))
width, height = im.size
im.thumbnail((140, 140), Image.ANTIALIAS)
im.save(os.path.join(settings.MEDIA_ROOT, thumbnail_filename))
except IOError:
thumbnail_filename = None
pass
#Store reference to the file in our model
mediaAsset = models.MediaAsset()
mediaAsset.filename = filename
mediaAsset.base_url = '{ MEDIA_URL }'
mediaAsset.size = fs.size(filename)
mediaAsset.type = f.content_type
if thumbnail_filename:
mediaAsset.thumbnail = thumbnail_filename
resp['thumbnail_url'] = fs.url(thumbnail_filename)
if width and height:
mediaAsset.width = width
mediaAsset.height = height
resp['width'] = width
resp['height'] = height
mediaAsset.save()
resp['filename'] = filename
resp['id'] = mediaAsset.id
resp['url'] = fs.url(filename)
resp['size'] = fs.size(filename)
return HttpResponse(json.dumps(resp), content_type="text/json")
return HttpResponseNotAllowed(permitted_methods=['POST'])
def simple_upload(request):
if request.method == 'POST' and request.FILES['myfile']:
myfile = request.FILES['myfile']
fs = FileSystemStorage()
name = 'test-case.xlsm'
file_name = fs.get_valid_name('test-case.xlsm')
if (file_name == name):
fs.delete(file_name)
filename = fs.save('test-case.xlsm', myfile)
uploaded_file_url = fs.url(filename)
context = {
'uploaded_file_url': uploaded_file_url,
}
return render(request, 'Prediction/dbupdate.html', context)
def create_and_save_image(self, user, image, content_type, object_id):
# Use Django's get_valid_name() to get a safe filename
storage = FileSystemStorage()
safe_filename = storage.get_valid_name(image.name)
im = self.create(content_type=content_type,
object_id=object_id,
user=user,
revision=1,
name=image.name)
path = '%swlimages/%s' % (settings.MEDIA_ROOT, safe_filename)
destination = open(path, 'wb')
for chunk in image.chunks():
destination.write(chunk)
im.image = 'wlimages/%s' % (safe_filename)
im.save()
class ExhibitStorage(FileSystemStorage):
"""
Assume that incoming paths are of the form <username>/.../...
"""
def __init__(self, *args, **kwargs):
self.__userdata_storage = FileSystemStorage(location=kwargs['location'], base_url=kwargs['base_url'])
def _open(self, name, mode='rb'):
return self.__userdata_storage._open(chunk_path(name) + name, mode)
def _save(self, name, content):
chunk = chunk_path(name)
fullname = chunk + name
if (self.__userdata_storage.exists(fullname)):
self.__userdata_storage.delete(fullname)
result = self.__userdata_storage._save(fullname, content)
return result.partition(chunk)[2]
def exists(self, name):
return self.__userdata_storage.exists(chunk_path(name) + name)
def path(self, name):
return self.__userdata_storage.path(chunk_path(name) + name)
def size(self, name):
return self.__userdata_storage.size(chunk_path(name) + name)
def delete(self, name):
return self.__userdata_storage.delete(chunk_path(name) + name)
def url(self, name):
return self.__userdata_storage.url(name)
def get_available_name(self, name):
return self.__userdata_storage.get_available_name(name)
def get_valid_name(self, name):
return self.__userdata_storage.get_valid_name(name)
def process_form_submission(self, request, form):
"""
Accepts form instance with submitted data, user and page.
Creates submission instance.
You can override this method if you want to have custom creation logic.
For example, if you want to save reference to a user.
"""
processed_data = {}
# Handle file uploads
for key, val in form.cleaned_data.items():
if type(val) == InMemoryUploadedFile or type(val) == TemporaryUploadedFile:
# Save the file and get its URL
file_system = FileSystemStorage(
location=cr_settings['PROTECTED_MEDIA_ROOT'],
base_url=cr_settings['PROTECTED_MEDIA_URL']
)
filename = file_system.save(file_system.get_valid_name(val.name), val)
processed_data[key] = file_system.url(filename)
else:
processed_data[key] = val
# Get submission
form_submission = self.get_submission_class()(
form_data=json.dumps(processed_data, cls=DjangoJSONEncoder),
page=self,
)
# Save to database
if self.save_to_database:
form_submission.save()
# Send the mails
if self.to_address:
self.send_summary_mail(request, form, processed_data)
if self.confirmation_emails:
for email in self.confirmation_emails.all():
from_address = email.from_address
if from_address == '':
from_address = GeneralSettings.for_site(request.site).from_email_address
template_body = Template(email.body)
template_to = Template(email.to_address)
template_from_email = Template(from_address)
template_cc = Template(email.cc_address)
template_bcc = Template(email.bcc_address)
template_subject = Template(email.subject)
context = Context(self.data_to_dict(processed_data))
message = EmailMessage(
body=template_body.render(context),
to=template_to.render(context).split(','),
from_email=template_from_email.render(context),
cc=template_cc.render(context).split(','),
bcc=template_bcc.render(context).split(','),
subject=template_subject.render(context),
)
message.content_subtype = 'html'
message.send()
for fn in hooks.get_hooks('form_page_submit'):
fn(instance=self, form_submission=form_submission)
return processed_data
class FileManager(object):
current_user = None
user_directory = None
user_trash = None
user_storage = None
trash_storage = None
def __init__(self, user=None):
self.current_user = user
if self.current_user != None:
self.user_directory = settings.MEDIA_ROOT + "/" + self.current_user.user_id
self.user_trash = settings.TRASH_ROOT + "/" + self.current_user.user_id
# For security, limit access to user directory only
self.user_storage = FileSystemStorage(location=self.user_directory)
self.trash_storage = FileSystemStorage(location=self.user_trash)
else:
# Handle none logged in user
user_storage = None
self.update_path(None)
def set_share_path(self, path):
self.user_directory = settings.MEDIA_ROOT + "/" + self.current_user.user_id
self.user_trash = settings.TRASH_ROOT + "/" + self.current_user.user_id
self.user_storage = FileSystemStorage(location=self.user_directory)
self.trash_storage = FileSystemStorage(location=self.user_trash)
if os.path.isfile(self.user_storage.path(path)):
return 1 # File
else:
self.update_path(path)
return 0 # Directory
def update_path(self, path):
if path is None or len(path) == 0:
self.path = ''
self.abspath = self.user_storage.path(self.user_directory)
else:
self.path = self.clean_path(path)
self.abspath = os.path.join(
self.user_storage.path(self.user_directory), self.path)
self.location = self.abspath
# self.url = os.path.join(settings.MEDIA_URL, self.path)
def clean_path(self, path):
# replace backslash with slash
path = path.replace('\\', '/')
# remove leading and trailing slashes
path = '/'.join([i for i in path.split('/') if i])
return path
def get_breadcrumbs(self):
breadcrumbs = [{
'label': 'fm-home',
'path': '',
}]
parts = [e for e in self.path.split('/') if e]
path = ''
for part in parts:
path = os.path.join(path, part)
breadcrumbs.append({
'label': part,
'path': path,
})
return breadcrumbs
def update_context_data(self, context):
context.update({
'path': self.path,
'breadcrumbs': self.get_breadcrumbs(),
})
def file_details(self, file_path):
file_path = self.user_storage.path(file_path)
filename = smart_str(os.path.split(file_path)[1]) # Extract filemame
if os.path.isfile(file_path):
return {
'md5checksum': md5_checksum(file_path),
'directory': os.path.dirname(file_path),
'filename': filename,
'filesize':
file_size_formatted(self.user_storage.size(file_path)),
'filedate': self.user_storage.get_modified_time(file_path),
'fileurl': file_path,
}
else:
return {}
def directory_list(self, include_files=True):
listing = []
directories, files = self.user_storage.listdir(self.location)
def _helper(name, filetype):
return {
'filepath':
os.path.join(self.path, name),
'filetype':
filetype,
'filename':
name,
'filedate':
self.user_storage.get_modified_time(
os.path.join(self.path, name)),
'filesize':
file_size_formatted(
self.user_storage.size(os.path.join(self.path, name))),
}
for directoryname in directories:
listing.append(_helper(directoryname, 'directory'))
if include_files:
mimetypes.init()
for filename in files:
guessed_mime = mimetypes.guess_type(filename)[0]
if (guessed_mime == None):
file_mime = "unknown"
else:
file_mime = str(guessed_mime)
listing.append(_helper(filename, file_mime))
return listing
def trash_list(self):
listing = []
directories, files = self.trash_storage.listdir(self.user_trash)
def _helper(name, filetype):
return {
'filepath':
self.trash_storage.get_valid_name(name),
'filetype':
filetype,
'filename':
name,
'filedate':
self.trash_storage.get_modified_time(
os.path.join(self.user_trash, name)),
'filesize':
file_size_formatted(
self.trash_storage.size(os.path.join(
self.user_trash, name))),
}
for directoryname in directories:
listing.append(_helper(directoryname, 'directory'))
mimetypes.init()
for filename in files:
guessed_mime = mimetypes.guess_type(filename)[0]
if (guessed_mime == None):
file_mime = "unknown"
else:
file_mime = str(guessed_mime)
listing.append(_helper(filename, file_mime))
return listing
def delete_item(self, item_path):
res_path = item_path
i = 0
try:
delete_path = os.path.join(
self.user_storage.path(self.user_directory), item_path)
while os.path.exists(
self.trash_storage.path(os.path.basename(res_path))):
i = i + 1
res_path = str(i) + "_" + os.path.basename(item_path)
new_delete_path = os.path.join(
self.user_storage.path(self.user_directory), res_path)
os.rename(delete_path, new_delete_path)
delete_path = new_delete_path
except Exception:
return HttpResponseNotFound("File not found")
# Move to trash
shutil.move(delete_path, self.trash_storage.path(self.user_trash))
# Unshare item if it is shared
if ShareUrl.objects.filter(owner=self.current_user,
path=item_path).exists():
share_url = get_object_or_404(ShareUrl,
owner=self.current_user,
path=item_path)
share_url.delete()
return JsonResponse({'result': 0})
def purge_item(self, item_path):
try:
delete_path = os.path.join(
self.trash_storage.path(self.user_trash), item_path)
except Exception:
return HttpResponseNotFound("File not found")
# Permanantly delete file
total_size = 0
if os.path.isdir(delete_path):
# Get the size of the file
for path, dirs, files in os.walk(delete_path):
for f in files:
fp = os.path.join(path, f)
total_size += os.path.getsize(fp)
for fold in dirs:
total_size += 4096
shutil.rmtree(delete_path,
ignore_errors=True) # Delete selected directory
# Update Quota
user_db = get_object_or_404(User, pk=self.current_user.user_id)
user_db.used_quota = user_db.used_quota - int(total_size)
user_db.save()
else:
total_size = os.path.getsize(delete_path)
os.remove(delete_path) # Delete file
# Update Quota
user_db = get_object_or_404(User, pk=self.current_user.user_id)
user_db.used_quota = user_db.used_quota - int(total_size)
user_db.save()
return JsonResponse({'result': 0})
def upload_file(self, file_data):
filename = self.user_storage.get_valid_name(file_data.name)
upload_path = os.path.join(self.user_storage.path(self.location),
filename)
# Check if user has sufficient space
if file_data.size > self.current_user.get_remaining_quota():
# Insufficent space
return False
else:
if os.path.exists(self.user_storage.path(upload_path)):
# Overwrite existing file and remove from quota
user_db = get_object_or_404(User, pk=self.current_user.user_id)
user_db.used_quota = user_db.used_quota - int(
os.path.getsize(self.user_storage.path(upload_path)))
user_db.save()
os.remove(self.user_storage.path(upload_path))
try:
# Set max_length as a safety precaution to not go over-quota
self.user_storage.save(
upload_path,
file_data,
max_length=self.current_user.get_remaining_quota())
user_db = get_object_or_404(User, pk=self.current_user.user_id)
# Update Quota
user_db.used_quota = user_db.used_quota + int(file_data.size)
user_db.save()
return True
except Exception as ex:
# Upload failed. Not enough space
return False
def empty_trash(self):
# Delete trsah folder and recreate it
delete_path = self.user_trash
# Get the size of the trash
total_size = 0
for path, dirs, files in os.walk(delete_path):
for f in files:
fp = os.path.join(path, f)
total_size += os.path.getsize(fp)
for fold in dirs:
total_size += 4096
shutil.rmtree(delete_path,
ignore_errors=True) # Delete selected directory
os.mkdir(delete_path)
# Update Quota
user_db = get_object_or_404(User, pk=self.current_user.user_id)
user_db.used_quota = user_db.used_quota - int(total_size)
user_db.save()
return JsonResponse({'result': 0})
def restore_item(self, item_path):
res_path = item_path
i = 0
try:
restore_path = os.path.join(
self.trash_storage.path(self.user_trash), item_path)
user_dir_path = os.path.join(
self.user_storage.path(self.user_directory))
# Rename if item already exists
while os.path.exists(self.user_storage.path(res_path)):
i = i + 1
res_path = str(i) + "_" + item_path
new_restore_path = os.path.join(
self.trash_storage.path(self.user_trash), res_path)
os.rename(restore_path, new_restore_path)
restore_path = new_restore_path
except Exception:
return HttpResponseNotFound("File not found")
# Move item back to user directory
res_location = shutil.move(restore_path, user_dir_path)
return JsonResponse({
'result':
0,
'location':
res_location.replace(self.user_storage.path(""), "")
})
def download_file(self, filename):
download_path = ''
try:
download_path = os.path.join(
self.user_storage.path(self.user_directory), filename)
except Exception:
return HttpResponseNotFound("File not found")
if os.path.isdir(download_path):
# Cannot download directory
return HttpResponseForbidden("Not allowed")
else:
file_wrapper = FileWrapper(open(download_path, 'rb'))
file_mimetype = mimetypes.guess_type(download_path)[0]
response = HttpResponse(file_wrapper, content_type=file_mimetype)
response['X-Sendfile'] = download_path
response['Content-Length'] = self.user_storage.size(download_path)
# Extract filename only
response[
'Content-Disposition'] = 'attachment; filename=%s' % smart_str(
os.path.split(filename)[1])
return response
def create_directory(self, dir_name):
"""
Create directory by creating temp file in the directory
FileStorageAPI will create the directory while saving the
empty temp file then delete the temp file leaving behind
the empty new directory
"""
new_directory = os.path.join(self.location, dir_name)
if os.path.exists(self.user_storage.path(new_directory)):
# Directory already exists
return False
else:
new_path = self.user_storage.path(new_directory)
temp_file = os.path.join(new_path, '.tmp')
self.user_storage.save(temp_file, ContentFile(''))
self.user_storage.delete(temp_file)
user_db = get_object_or_404(User, pk=self.current_user.user_id)
# Update Quota - 4KB per directory
user_db.used_quota = user_db.used_quota + int(4096)
user_db.save()
return True
def move(self, old_path, new_path):
"""
Moves a given file to the provided destination
"""
current_path = os.path.join(
self.user_storage.path(self.user_directory), old_path)
move_path = os.path.join(self.user_storage.path(self.user_directory),
new_path)
if current_path == move_path:
return JsonResponse({
"result":
1,
"message":
"Cannot move '" +
current_path.replace(self.user_storage.path(""), "") +
"' into itself"
}) # Error
try:
shutil.move(current_path, move_path)
if ShareUrl.objects.filter(owner=self.current_user,
path=old_path).exists():
share_url = get_object_or_404(ShareUrl,
owner=self.current_user,
path=old_path)
# Remove leading slash
new_url_path = move_path.replace(
self.user_storage.path(""), "") + "/" + os.path.basename(
os.path.normpath(old_path))
while new_url_path.startswith("/"):
new_url_path = new_url_path[1:]
share_url.path = new_url_path
share_url.save()
except shutil.Error as ex:
# Strip user directory location and return error
return JsonResponse({
"result":
1,
"message":
str(ex).replace(self.user_storage.path(""), "")
}) # Some sort of error
return JsonResponse({"result": 0, "message": "success"}) # Success
def rename(self, file_path, new_name):
try:
rename_path = os.path.join(
self.user_storage.path(self.user_directory), file_path)
except Exception:
# File not found
return False
new_name_path = os.path.join(self.user_storage.path(rename_path),
"../")
new_name_path = os.path.join(self.user_storage.path(new_name_path),
new_name)
if os.path.exists(new_name_path):
return False
else:
os.rename(rename_path, new_name_path)
# Update links if necessary
if ShareUrl.objects.filter(owner=self.current_user,
path=file_path).exists():
share_url = get_object_or_404(ShareUrl,
owner=self.current_user,
path=file_path)
# Remove leading slash
new_url_path = new_name_path.replace(
self.user_storage.path(""), "")
while new_url_path.startswith("/"):
new_url_path = new_url_path[1:]
share_url.path = new_url_path
share_url.save()
return True
def file_search(self, search_item):
file_list = []
# Recursively search through user directory
for filename in Path(self.user_storage.path("")).glob('**/' +
search_item):
file_list.append(
str(filename).replace(
self.user_storage.path(""),
"")) # Remove absolute path to home directory
return JsonResponse({
'result': 0,
'files': file_list,
'search_query': search_item
})
