def upload_files(request):
files_data = []
files_metadata = []
if request.method == 'POST':
path2save = os.path.join(settings.MEDIA_ROOT, 'apps',request.POST['app_id'])
for key in request.FILES:
myfile = request.FILES[key]
name = "".join([ (c if c.isalnum() or c=='.' else '') for c in myfile.name])
for c in r' []/\;,><&*:%=+@!#^()|?^': name = name.replace(c,'')
fs = FileSystemStorage(location=path2save, base_url=settings.MEDIA_URL+'apps/'+request.POST['app_id']+'/')
filename = fs.save(name, myfile)
url = fs.url(filename)
files_data.append(url)
files_metadata.append({
'date':fs.get_created_time(filename).strftime("%Y-%m-%d %H:%M:%S"),
'extension':os.path.splitext(filename)[1],
'file':url,
'name':myfile.name,
'old_name':myfile.name,
'replaced':False,
'size':fs.size(filename),
'size2':fs.size(filename),
'type':[]
})
data = {'files':files_data, 'metas':files_metadata }
return HttpResponse(simplejson.dumps(data,bigint_as_string=True ), "application/json")
def upload2(request):
if request.method == 'POST':
if not request.FILES:
if request.user.is_authenticated:
return render(request, 'drodos/home.html', {
'erro': 'no file selected',
'user': request.user
})
else:
return render(request, 'drodos/index.html',
{'erro': 'no file selected'})
else:
files = request.FILES.getlist('filesInputId')
if request.user.is_authenticated:
for f in files:
if request.user.profile.currentStorage + f.size > request.user.profile.maxStorage:
return HttpResponseRedirect(
reverse('drodos:myprofile'))
else:
fs = FileSystemStorage()
filename = fs.save(fs.get_available_name(f.name), f)
size = int(fs.size(filename) / 1000)
print(str(size) + ' kb')
if request.POST.get(
'private') and request.user.profile.premium:
storeditem = StoredItem(owner=request.user,
title=f.name,
fileUrl=filename,
description='',
private=True)
else:
storeditem = StoredItem(owner=request.user,
title=f.name,
fileUrl=filename,
description='',
private=False)
request.user.profile.currentStorage += size
request.user.save()
storeditem.save()
return HttpResponseRedirect(reverse('drodos:files'))
else: # unregistered user upload
for f in files:
if f.size < 1000000: # too big for unregistered
fs = FileSystemStorage()
filename = fs.save(fs.get_available_name(f.name), f)
size = int(fs.size(filename) / 1000)
print(str(size) + ' kb')
tempitem = StoredItem(owner=None,
title=f.name,
fileUrl=filename,
description='',
private=False)
tempitem.save()
return HttpResponseRedirect(reverse('drodos:index'))
else:
return HttpResponseRedirect(reverse('drodos:index'))
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'])
class ThumbnailField:
'''
Instances of this class will be used to access data of the
generated thumbnails
'''
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
def is_landscape(self):
return self.orientation() == 'landscape'
def is_portrait(self):
return self.orientation() == 'portrait'
def orientation(self):
w, h = get_image_dimensions(self.path())
if w > h:
return 'landscape'
else:
return 'portrait'
class VariationField(object):
"""Instances of this class will be used to access data of the generated variations."""
def __init__(self, name):
"""
:param name: str
"""
self.name = name
self.storage = FileSystemStorage()
@property
def path(self):
"""Return the abs. path of the image file."""
return self.storage.path(self.name)
@property
def url(self):
"""Return the url of the image file."""
return self.storage.url(self.name)
@property
def size(self):
"""Return the size of the image file, reported by os.stat()."""
return self.storage.size(self.name)
def webcam_test_upload(request, run_uuid):
"""
Uploads the webcam/microphone test file and returns metadata of the uploaded file.
"""
if request.method == 'POST' and request.FILES.get('file'):
subject_data = get_object_or_404(SubjectData, pk=run_uuid)
webcam_file = request.FILES.get('file')
webcam_file_type = request.POST.get('type')
fs = FileSystemStorage(location=settings.WEBCAM_TEST_ROOT,
base_url=settings.WEBCAM_TEST_URL)
# Generate random file name
extension = os.path.splitext(webcam_file.name)[1]
random_file_name = str(uuid.uuid4()) + extension
filename = fs.save(random_file_name, webcam_file)
# Return metadata of uploaded video
return JsonResponse({
'videoUrl': fs.url(filename),
'size': fs.size(filename),
'type': webcam_file_type,
'runUuid': run_uuid
})
else:
logger.error('Failed to upload test media.')
raise Http404('Page not found.')
class ThumbnailField:
'''
Instances of this class will be used to access data of the
generated thumbnails
'''
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
@property
def path(self):
return self.storage.path(self.name)
@property
def url(self):
return self.storage.url(self.name)
@property
def size(self):
return self.storage.size(self.name)
@property
def height(self):
im = Image.open(self.path)
return im.size[1]
@property
def width(self):
im = Image.open(self.path)
return im.size[0]
class ThumbnailField:
'''
Instances of this class will be used to access data of the
generated thumbnails
'''
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
def is_landscape(self):
return self.orientation() == 'landscape'
def is_portrait(self):
return self.orientation() == 'portrait'
def orientation(self):
w, h = get_image_dimensions(self.path())
if w > h:
return 'landscape'
else:
return 'portrait'
def getFoldersAndFiles(self, folder=''):
"""
list:
Return a list of all folders.
"""
storage = FileSystemStorage(os.path.join(settings.MEDIA_ROOT,
'models'))
result = list()
base_path = ""
if folder.startswith("/"):
base_path = folder[1:]
elif folder:
base_path = f"{folder}/"
items = storage.listdir(base_path)
denied_folders = []
if not self.current_user.has_perm('pyplan.change_group_permissions'):
denied_folders = self._getDeniedFolders()
# folders
for item in sorted(items[0], key=str.lower):
full_path = f"{base_path}{item}"
if not denied_folders or not item in denied_folders:
result.append(
FileEntry(
show=not item.startswith('.'),
text=item,
type=eFileTypes.MY_FOLDER,
data=FileEntryData(
fileSize=None,
fullPath=full_path,
# specialFolderType=eSpecialFolder.MODELS_PATH
lastUpdateTime=storage.get_modified_time(
full_path),
)))
# files
for item in sorted(items[1], key=str.lower):
full_path = f"{base_path}{item}"
specialFileType = eSpecialFileType.FILE
lowerItem = item.lower()
if lowerItem.endswith('.ppl') | lowerItem.endswith('.cbpy') | \
lowerItem.endswith('.model') | lowerItem.endswith('.ana'):
specialFileType = eSpecialFileType.MODEL
elif lowerItem.endswith('.zip'):
specialFileType = eSpecialFileType.ZIP
result.append(
FileEntry(
text=item,
type=eFileTypes.PUBLIC,
data=FileEntryData(
fileSize=storage.size(full_path),
fullPath=full_path,
extension=full_path[full_path.rfind('.') + 1:],
specialFileType=specialFileType,
lastUpdateTime=storage.get_modified_time(full_path),
)))
return result
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_n
def create_ad(request):
if not request.user.is_authenticated:
return HttpResponseRedirect(reverse('panther_ad:index'))
else:
if request.method == 'POST':
size = request.POST['size']
name = request.POST['name']
uploaded_banner = request.FILES['upload_banner']
uploaded_banner.name = uploaded_banner.name.replace(' ', '_')
fss = FileSystemStorage()
file_name = fss.save(uploaded_banner.name, uploaded_banner)
url = fss.url(file_name)
logger.debug(fss.size(file_name))
logger.debug(fss.url(file_name))
logger.debug(fss.path(file_name))
try:
Ad.objects.create(user_id=request.user.id,
name=name,
url=url,
size=size)
return redirect('panther_ad:ads')
except Exception as e:
logger.error(e)
return render(request, 'panther_ad/create-new-ad.html',
{"error_message": 'Something went wrong!'})
elif request.method == 'GET':
return render(request, 'panther_ad/create-new-ad.html')
class RasterOptimizerView(TemplateView):
template_name = "admin/imageserver/raster_optimizer.html"
form = ActionForm
def __init__(self):
# FIXME: support for multiple directories
print('DIR', settings.GISCUBE_IMAGESERVER['DATA_ROOT'][0])
self.storage = FileSystemStorage(
settings.GISCUBE_IMAGESERVER['DATA_ROOT'][0])
def get_context_data(self, **kwargs):
context = super(RasterOptimizerView, self).get_context_data(**kwargs)
dir = self.request.GET.get('dir', '')
context['dir'] = dir
if dir.startswith('/'):
dir = dir[1:]
dirs, files = self.storage.listdir(dir)
entries = []
for f in sorted(dirs):
e = OptimizerEntry()
e.name = f
e.type = 'folder'
e.path = os.path.join(dir, f)
entries.append(e)
for f in sorted(files):
e = OptimizerEntry()
e.name = f
e.type = 'file'
e.path = os.path.join(dir, f)
try:
e.size = self.storage.size(e.path)
except Exception:
e.size = 0
for format in ('.tif', '.jpg'):
if f.lower().endswith(format):
e.overview = True
entries.append(e)
context['entries'] = entries
return context
def post(self, request, *args, **kwargs):
f = self.form(request.POST)
if f.is_valid():
action = f.cleaned_data['action']
path = f.cleaned_data['path']
if action == 'delete':
self.storage.delete(path)
elif action == 'build_overviews':
gdal_build_overviews(self.storage.path(path))
return HttpResponse('Overviews completed for %s' % path)
else:
return HttpResponse(f.errors)
return HttpResponse('OK')
def upload(request): #ajax upload file to a question or answer
class FileTypeNotAllow(Exception):
pass
class FileSizeNotAllow(Exception):
pass
class UploadPermissionNotAuthorized(Exception):
pass
xml_template = "<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>"
try:
f = request.FILES['file-upload']
# check upload permission
if not request.user.can_upload_files():
raise UploadPermissionNotAuthorized()
# check file type
try:
file_name_suffix = os.path.splitext(f.name)[1].lower()
except KeyError:
raise FileTypeNotAllow()
if not file_name_suffix in ('.jpg', '.jpeg', '.gif', '.png', '.bmp',
'.tiff', '.ico'):
raise FileTypeNotAllow()
storage = FileSystemStorage(str(settings.UPFILES_FOLDER),
str(settings.UPFILES_ALIAS))
new_file_name = storage.save("_".join(f.name.split()), f)
# check file size
# byte
size = storage.size(new_file_name)
if size > float(settings.ALLOW_MAX_FILE_SIZE) * 1024 * 1024:
storage.delete(new_file_name)
raise FileSizeNotAllow()
result = xml_template % ('Good', '',
str(settings.UPFILES_ALIAS) + new_file_name)
except UploadPermissionNotAuthorized:
result = xml_template % (
'',
_('uploading images is limited to users with >60 reputation points'
), '')
except FileTypeNotAllow:
result = xml_template % (
'',
_("allowed file types are 'jpg', 'jpeg', 'gif', 'bmp', 'png', 'tiff'"
), '')
except FileSizeNotAllow:
result = xml_template % ('', _("maximum upload file size is %sM") %
settings.ALLOW_MAX_FILE_SIZE, '')
except Exception, e:
result = xml_template % (
'',
_('Error uploading file. Please contact the site administrator. Thank you. %s'
% e), '')
def upload(request):
if request.method == 'POST':
print(request.FILES)
if not request.FILES:
if request.user.is_authenticated:
return render(request, 'drodos/home.html', {
'erro': 'no file selected',
'user': request.user
})
else:
return render(request, 'drodos/index.html',
{'erro': 'no file selected'})
else:
file = request.FILES['file']
fs = FileSystemStorage()
filename = fs.save(fs.get_available_name(file.name), file)
size = int(fs.size(filename) / 1000)
print(str(size) + ' kb')
if request.user.is_authenticated:
if request.user.profile.currentStorage + size > request.user.profile.maxStorage: # max storage reached
fs.delete(filename)
return HttpResponseRedirect(reverse('drodos:myprofile'))
else: # proceed with upload
if request.POST.get(
'private') and request.user.profile.premium:
storeditem = StoredItem(
owner=request.user,
title=request.POST['title'],
fileUrl=filename,
description=request.POST['desc'],
private=True)
print('PRIVATE')
else:
storeditem = StoredItem(
owner=request.user,
title=request.POST['title'],
fileUrl=filename,
description=request.POST['desc'],
private=False)
print('PUBLIC')
request.user.profile.currentStorage += size
request.user.save()
storeditem.save()
return HttpResponseRedirect(reverse('drodos:files'))
else: # unregistered user upload
if size > 1000: # too big for unregistered
fs.delete(filename)
return HttpResponseRedirect(reverse('drodos:index'))
else:
tempitem = StoredItem(owner=None,
title=request.POST['title'],
fileUrl=filename,
description=request.POST['desc'],
private=False)
tempitem.save()
return HttpResponseRedirect(
reverse('drodos:uploaded', args=(filename, )))
else:
return HttpResponseRedirect(reverse('drodos:index'))
def session_get_file(request, filename):
"""
Get a file in the storage
:param request: Django request object
:param filename: The name of the file to be returned
:return: A 2-tuple containing the File object and the file size
"""
storage = FileSystemStorage(location=session_get_storage(request))
return storage.open(filename, 'rb'), storage.size(filename)
class ResizedImageField: def __init__(self, name): self.name = name self.storage = FileSystemStorage() def path(self): return self.storage.path(self.name) def url(self): return self.storage.url(self.name) def size(self): return self.storage.size(self.name)
def deletefile(request, filename):
storeditem = get_object_or_404(StoredItem, fileUrl=filename)
if request.user == storeditem.owner:
storeditem.delete()
fs = FileSystemStorage()
size = int(fs.size(filename) / 1000)
print(size)
request.user.profile.currentStorage -= size
request.user.save()
fs.delete(filename)
return HttpResponseRedirect(reverse('drodos:files'))
else:
return HttpResponseRedirect(reverse('drodos:index'))
def upload_file_view(request):
f = request.FILES['file']
fs = FileSystemStorage()
filename, ext = str(f).split('.')
file = fs.save(str(f), f)
fileurl = fs.url(file)
return JsonResponse({'success': 1,
'file':
{'url': fileurl,
"size": fs.size(filename),
"name": str(f),
"extension": ext}
})
def upload(request):#ajax upload file to a question or answer
"""view that handles file upload via Ajax
"""
# check upload permission
result = ''
error = ''
new_file_name = ''
try:
#may raise exceptions.PermissionDenied
if request.user.is_anonymous():
msg = _('Sorry, anonymous users cannot upload files')
raise exceptions.PermissionDenied(msg)
request.user.assert_can_upload_file()
# check file type
f = request.FILES['file-upload']
file_extension = os.path.splitext(f.name)[1].lower()
if not file_extension in settings.ASKBOT_ALLOWED_UPLOAD_FILE_TYPES:
file_types = "', '".join(settings.ASKBOT_ALLOWED_UPLOAD_FILE_TYPES)
msg = _("allowed file types are '%(file_types)s'") % \
{'file_types': file_types}
raise exceptions.PermissionDenied(msg)
# generate new file name
new_file_name = str(
time.time()
).replace(
'.',
str(random.randint(0,100000))
) + file_extension
file_storage = FileSystemStorage(
location = settings.ASKBOT_FILE_UPLOAD_DIR,
base_url = reverse('uploaded_file', kwargs = {'path':''}),
)
# use default storage to store file
file_storage.save(new_file_name, f)
# check file size
# byte
size = file_storage.size(new_file_name)
if size > settings.ASKBOT_MAX_UPLOAD_FILE_SIZE:
file_storage.delete(new_file_name)
msg = _("maximum upload file size is %(file_size)sK") % \
{'file_size': settings.ASKBOT_MAX_UPLOAD_FILE_SIZE}
raise exceptions.PermissionDenied(msg)
except exceptions.PermissionDenied, e:
error = unicode(e)
def upload(request): # ajax upload file to a question or answer
class FileTypeNotAllow(Exception):
pass
class FileSizeNotAllow(Exception):
pass
class UploadPermissionNotAuthorized(Exception):
pass
xml_template = "<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>"
try:
f = request.FILES["file-upload"]
# check upload permission
if not request.user.can_upload_files():
raise UploadPermissionNotAuthorized()
# check file type
try:
file_name_suffix = os.path.splitext(f.name)[1].lower()
except KeyError:
raise FileTypeNotAllow()
if not file_name_suffix in (".jpg", ".jpeg", ".gif", ".png", ".bmp", ".tiff", ".ico"):
raise FileTypeNotAllow()
storage = FileSystemStorage(str(settings.UPFILES_FOLDER), str(settings.UPFILES_ALIAS))
new_file_name = storage.save("_".join(f.name.split()), f)
# check file size
# byte
size = storage.size(new_file_name)
if size > float(settings.ALLOW_MAX_FILE_SIZE) * 1024 * 1024:
storage.delete(new_file_name)
raise FileSizeNotAllow()
result = xml_template % ("Good", "", str(settings.UPFILES_ALIAS) + new_file_name)
except UploadPermissionNotAuthorized:
result = xml_template % ("", _("uploading images is limited to users with >60 reputation points"), "")
except FileTypeNotAllow:
result = xml_template % ("", _("allowed file types are 'jpg', 'jpeg', 'gif', 'bmp', 'png', 'tiff'"), "")
except FileSizeNotAllow:
result = xml_template % ("", _("maximum upload file size is %sM") % settings.ALLOW_MAX_FILE_SIZE, "")
except Exception, e:
result = xml_template % (
"",
_("Error uploading file. Please contact the site administrator. Thank you. %s" % e),
"",
)
def upload(request):#ajax upload file to a question or answer
"""view that handles file upload via Ajax
"""
# check upload permission
result = ''
error = ''
new_file_name = ''
try:
#may raise exceptions.PermissionDenied
if request.user.is_anonymous():
msg = _('Sorry, anonymous users cannot upload files')
raise exceptions.PermissionDenied(msg)
request.user.assert_can_upload_file()
# check file type
f = request.FILES['file-upload']
file_extension = os.path.splitext(f.name)[1].lower()
if not file_extension in settings.ASKBOT_ALLOWED_UPLOAD_FILE_TYPES:
file_types = "', '".join(settings.ASKBOT_ALLOWED_UPLOAD_FILE_TYPES)
msg = _("allowed file types are '%(file_types)s'") % \
{'file_types': file_types}
raise exceptions.PermissionDenied(msg)
# generate new file name
new_file_name = str(
time.time()
).replace(
'.',
str(random.randint(0,100000))
) + file_extension
file_storage = FileSystemStorage(
location = settings.ASKBOT_FILE_UPLOAD_DIR,
base_url = reverse('uploaded_file', kwargs = {'path':''}),
)
# use default storage to store file
file_storage.save(new_file_name, f)
# check file size
# byte
size = file_storage.size(new_file_name)
if size > settings.ASKBOT_MAX_UPLOAD_FILE_SIZE:
file_storage.delete(new_file_name)
msg = _("maximum upload file size is %(file_size)sK") % \
{'file_size': settings.ASKBOT_MAX_UPLOAD_FILE_SIZE}
raise exceptions.PermissionDenied(msg)
except exceptions.PermissionDenied, e:
error = unicode(e)
def getModelInfo(self):
"""Navigate Diagram"""
session = self.client_session
if not session is None:
modelInfo = session.modelInfo
storage = FileSystemStorage()
file_path = join(settings.MEDIA_ROOT, "models", modelInfo.uri)
file_size = storage.size(file_path)
if file_size > 1e+6:
file_size = f"{round(file_size / 1024 / 1024, 2)} MB"
else:
if file_size > 1e+3:
file_size = f"{round(file_size / 1024, 2)} kB"
else:
file_size = f"{file_size} B"
created_time = storage.get_created_time(file_path)
modified_time = storage.get_modified_time(file_path)
modelInfo.uri
res = [
{
"Key": "modelinfo_model_id",
"Value": modelInfo.modelId
},
{
"Key": "modelinfo_model_name",
"Value": modelInfo.name
},
{
"Key": "modelinfo_model_file",
"Value": modelInfo.uri
},
{
"Key": "modelinfo_file_size",
"Value": file_size
},
{
"Key": "modelinfo_created_date",
"Value": f"{created_time.strftime('%Y-%m-%d %H:%M')} hs."
},
{
"Key": "modelinfo_updated_date",
"Value": f"{modified_time.strftime('%Y-%m-%d %H:%M')} hs."
},
]
return res
else:
raise exceptions.NotAcceptable("Can't find session")
def crypt(request):
if request.method == 'POST':
print(request.POST)
print(request.FILES)
op = request.POST['op']
password = request.POST['pwd']
inFile = request.FILES['file']
# prepare output file path
filename = inFile.name
if op == 'Encrypt':
filename += '.crypt'
else:
name, ext = splitext(filename)
if ext == '.crypt':
filename = name
else:
filename += '.decrypt'
fs = FileSystemStorage()
os.makedirs('XX', exist_ok=True)
if fs.exists(join('XX', filename)):
fs.delete(join('XX', filename))
outFile = fs.open(join('XX', filename), 'wb')
# prepare key/iv from password
key, iv = generateSecrets(password)
# prepare AES/CBC
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
cryptor = cipher.encryptor() if (op
== 'Encrypt') else cipher.decryptor()
# read file, feed cryptor, write file
data = inFile.read()
if op == 'Encrypt':
padder = padding.PKCS7(algorithms.AES.block_size).padder()
padded_data = padder.update(data) + padder.finalize()
outFile.write(cryptor.update(padded_data))
outFile.write(cryptor.finalize())
else:
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
padded_plaintext = cryptor.update(data) + cryptor.finalize()
plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()
outFile.write(plaintext)
outFile.close()
size = fs.size(join('XX', filename))
return JsonResponse({
'status': op + 'ed',
'name': filename,
'member': 'XX',
'size': str(size)
})
return JsonResponse({'status': 'nothing processed'})
def upload(request):
if request.method == 'POST':
print(request.POST)
print(request.FILES)
file = request.FILES['file']
id = request.POST['userId']
makedirs(id, exist_ok=True)
filename = join(id, file.name)
fs = FileSystemStorage()
if fs.exists(filename):
fs.delete(filename)
fs.save(filename, file)
return JsonResponse(
{'status': 'uploaded (' + str(fs.size(filename)) + ' bytes)'})
return JsonResponse({'status': 'nothing uploaded'})
class ThumbnailField:
"""Instances of this class will be used to access data of the
generated thumbnails"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
class ThumbnailField:
"""Instances of this class will be used to access data of the
generated thumbnails"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
def upload_files(upfile, path, escape=True):
base_dir = str(settings.BASE_DIR)
filename = upfile.name if not escape else make_filename(upfile.name)
upload_url = path.replace(base_dir, settings.BASE_URL)
fs = FileSystemStorage(location=path, base_url=upload_url)
obj = fs.save(filename, upfile)
if fs.exists(obj):
return {
'path': fs.path(obj).replace(base_dir, ''),
'size': fs.size(obj),
'url': fs.url(obj)
}
return False
def uploadf(request):
f = request.FILES['file']
fs = FileSystemStorage()
filename, ext = str(f).split('.')
print(filename, ext)
file = fs.save(str(f), f)
fileurl = fs.url(file)
fileSize = fs.size(file)
return JsonResponse({
'success': 1,
'file': {
'url': fileurl,
'name': str(f),
'size': fileSize
}
})
class StdAudioField:
'''
Instances of this class will be used to access data of the converted
audio files
'''
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
class StdAudioField:
'''
Instances of this class will be used to access data of the converted
audio files
'''
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
def uploadfile_view(request):
# https://docs.djangoproject.com/en/3.1/topics/http/file-uploads/
if request.method == 'POST':
f = request.FILES['file']
fs = FileSystemStorage()
filename, ext = str(f).split('.')
file = fs.save(str(f), f)
fileurl = fs.url(file)
size = fs.size(file)
return render(request, 'demo_upload_files.html', {
'fileUrl': fileurl,
'fileName': filename,
'ext': ext,
'size': size
})
else:
return render(request, 'demo_upload_files.html', {})
class ThumbnailField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def delete(self):
return self.storage.delete(self.name)
def open(self):
self.file = self.storage.open(self.name)
def chunks(self, chunk_size=None):
"""
Read the file and yield chucks of ``chunk_size`` bytes (defaults to
``UploadedFile.DEFAULT_CHUNK_SIZE``).
"""
if not chunk_size:
chunk_size = 64 * 2 ** 10
if hasattr(self.file, 'seek'):
self.file.seek(0)
# Assume the pointer is at zero...
counter = self.file.size
while counter > 0:
yield self.file.read(chunk_size)
counter -= chunk_size
def close(self):
self.file.close()
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
class DummyExternalStorage(Storage):
def __init__(self, *args, **kwargs):
self.wrapped = FileSystemStorage(*args, **kwargs)
def path(self, name):
# Overridden to give it the behaviour of the base Storage class
# This is what an external storage backend would have
raise NotImplementedError("This backend doesn't support absolute paths.")
def _open(self, name, mode='rb'):
# Overridden to return a DummyExternalStorageFile instead of a normal
# File object
return DummyExternalStorageFile(open(self.wrapped.path(name), mode))
# Wrap all other functions
def _save(self, name, content):
return self.wrapped._save(name, content)
def delete(self, name):
self.wrapped.delete(name)
def exists(self, name):
return self.wrapped.exists(name)
def listdir(self, path):
return self.wrapped.listdir(path)
def size(self, name):
return self.wrapped.size(name)
def url(self, name):
return self.wrapped.url(name)
def accessed_time(self, name):
return self.wrapped.accessed_time(name)
def created_time(self, name):
return self.wrapped.created_time(name)
def modified_time(self, name):
return self.wrapped.modified_time(name)
class DummyExternalStorage(Storage):
def __init__(self, *args, **kwargs):
self.wrapped = FileSystemStorage(*args, **kwargs)
def path(self, name):
# Overridden to give it the behaviour of the base Storage class
# This is what an external storage backend would have
raise NotImplementedError("This backend doesn't support absolute paths.")
def _open(self, name, mode='rb'):
# Overridden to return a DummyExternalStorageFile instead of a normal
# File object
return DummyExternalStorageFile(open(self.wrapped.path(name), mode))
# Wrap all other functions
def _save(self, name, content):
return self.wrapped._save(name, content)
def delete(self, name):
self.wrapped.delete(name)
def exists(self, name):
return self.wrapped.exists(name)
def listdir(self, path):
return self.wrapped.listdir(path)
def size(self, name):
return self.wrapped.size(name)
def url(self, name):
return self.wrapped.url(name)
def accessed_time(self, name):
return self.wrapped.accessed_time(name)
def created_time(self, name):
return self.wrapped.created_time(name)
def modified_time(self, name):
return self.wrapped.modified_time(name)
class ThumbnailField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
warn('%(class)s has been deprecated in favor of VariationsField()', DeprecationWarning)
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
class ThumbnailField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
warn('%(class)s has been deprecated in favor of VariationsField()',
DeprecationWarning)
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
class ThumbnailField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
def path(self):
return self.storage.path(self.name)
def delete(self):
return self.storage.delete(self.name)
def open(self):
self.file = self.storage.open(self.name)
def chunks(self, chunk_size=None):
"""
Read the file and yield chucks of ``chunk_size`` bytes (defaults to
``UploadedFile.DEFAULT_CHUNK_SIZE``).
"""
if not chunk_size:
chunk_size = 64 * 2**10
if hasattr(self.file, 'seek'):
self.file.seek(0)
# Assume the pointer is at zero...
counter = self.file.size
while counter > 0:
yield self.file.read(chunk_size)
counter -= chunk_size
def close(self):
self.file.close()
def url(self):
return self.storage.url(self.name)
def size(self):
return self.storage.size(self.name)
def upload(request):#ajax upload file to a question or answer
class FileTypeNotAllow(Exception):
pass
class FileSizeNotAllow(Exception):
pass
class UploadPermissionNotAuthorized(Exception):
pass
#<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>
xml_template = "<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>"
try:
f = request.FILES['file-upload']
# check upload permission
if not auth.can_upload_files(request.user):
raise UploadPermissionNotAuthorized
# check file type
file_name_suffix = os.path.splitext(f.name)[1].lower()
if not file_name_suffix in ('.jpg', '.jpeg', '.gif', '.png', '.bmp', '.tiff'):
raise FileTypeNotAllow
storage = FileSystemStorage(str(settings.UPFILES_FOLDER), str(settings.UPFILES_ALIAS))
new_file_name = storage.save(f.name, f)
# check file size
# byte
size = storage.size(new_file_name)
if size > float(settings.ALLOW_MAX_FILE_SIZE) * 1024 * 1024:
storage.delete(new_file_name)
raise FileSizeNotAllow
result = xml_template % ('Good', '', str(settings.UPFILES_ALIAS) + new_file_name)
except UploadPermissionNotAuthorized:
result = xml_template % ('', _('uploading images is limited to users with >60 reputation points'), '')
except FileTypeNotAllow:
result = xml_template % ('', _("allowed file types are 'jpg', 'jpeg', 'gif', 'bmp', 'png', 'tiff'"), '')
except FileSizeNotAllow:
result = xml_template % ('', _("maximum upload file size is %sM") % settings.ALLOW_MAX_FILE_SIZE, '')
except Exception, e:
result = xml_template % ('', _('Error uploading file. Please contact the site administrator. Thank you. %s' % e), '')
def post(self, request, *args, **kwargs):
all_local_files = []
fs = FileSystemStorage()
for f in request.FILES.getlist("files"):
file = fs.save(f.name,f)
temp = {"name":file,"url":"local_storage","size":fs.size(file)}
# temp["name"] = file
# temp["url"] = "local_storage"
# temp["size"] = fs.size(file)
all_local_files.append(temp)
file_serializer = DocSerializer(data=all_local_files, many=True)
if file_serializer.is_valid():
file_serializer.save()
#saving metadata of selected files in models
return redirect("/doclib/files_display")
#rendering HTML Page for displaying selected files
else:
return Response(file_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class VariationField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
@property
def path(self):
return self.storage.path(self.name)
@property
def url(self):
return self.storage.url(self.name)
@property
def size(self):
return self.storage.size(self.name)
class VariationField(object):
"""Instances of this class will be used to access data of the
generated thumbnails
"""
def __init__(self, name):
self.name = name
self.storage = FileSystemStorage()
@property
def path(self):
return self.storage.path(self.name)
@property
def url(self):
return self.storage.url(self.name)
@property
def size(self):
return self.storage.size(self.name)
def upload(request): # ajax upload file to a question or answer
"""view that handles file upload via Ajax
"""
# check upload permission
result = ""
error = ""
new_file_name = ""
try:
# may raise exceptions.PermissionDenied
if request.user.is_anonymous():
msg = _("Sorry, anonymous users cannot upload files")
raise exceptions.PermissionDenied(msg)
request.user.assert_can_upload_file()
# check file type
f = request.FILES["file-upload"]
logging.info("Upload %s" % f.name)
file_extension = os.path.splitext(f.name)[1].lower()
# generate new file name
new_file_name = datetime.date.today().strftime("%y%m%d") + f.name.replace(" ", "_").lower()
logging.info("Save as %s" % new_file_name)
file_storage = FileSystemStorage(
location=settings.ASKBOT_FILE_UPLOAD_DIR, base_url=reverse("uploaded_file", kwargs={"path": ""})
)
# use default storage to store file
file_storage.save(new_file_name, f)
# check file size
# byte
size = file_storage.size(new_file_name)
if size > settings.ASKBOT_MAX_UPLOAD_FILE_SIZE:
file_storage.delete(new_file_name)
msg = _("maximum upload file size is %(file_size)sK") % {"file_size": settings.ASKBOT_MAX_UPLOAD_FILE_SIZE}
raise exceptions.PermissionDenied(msg)
except exceptions.PermissionDenied, e:
error = unicode(e)
class DefaultStorageManager(StorageManagerInterface):
def __init__(self):
self._fsm = FileSystemStorage()
def _get_concrete_manager(self):
return DefaultStorageManager()
def delete(self, name):
return self._fsm.delete(name)
def exists(self, name):
return self._fsm.exists(name)
def listdir(self, path):
return self._fsm.listdir(path)
def open(self, name, mode='rb'):
try:
return self._fsm.open(name, mode=mode)
except SuspiciousFileOperation:
return open(name, mode=mode)
def path(self, name):
return self._fsm.path(name)
def save(self, name, content, max_length=None):
return self._fsm.save(name, content, max_length=max_length)
def size(self, name):
return self._fsm.size(name)
def url(self, name):
return self._fsm.url(name)
def generate_filename(self, filename):
return self._fsm.generate_filename(filename)
def addProductFromExcel(request):
if request.method == 'GET':
get_type = ProductType.objects.all()
return render(request, 'product/add_from_excel.html',
{'get_type': get_type})
if request.method == 'POST' and request.FILES['xlFile']:
products_type = request.POST.get('type')
xlFile = request.FILES['xlFile']
fs = FileSystemStorage()
file_name = fs.save(xlFile.name, xlFile)
file_size = fs.size(xlFile.name)
# print(products_type)
# print(file_size)
file_path = 'media/' + file_name
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
file_dir = os.path.join(BASE_DIR, file_path)
# print(file_dir)
items = []
rows = []
wb = open_workbook(file_dir)
for sheet in wb.sheets():
number_of_rows = sheet.nrows
print(number_of_rows)
number_of_columns = sheet.ncols
# print(number_of_columns)
for row in range(0, number_of_rows):
values = []
for col in range(0, number_of_columns):
value = (sheet.cell(row, col).value)
# print('-----------------')
# print(value)
try:
value = str(value)
# print(value)
values.append(value)
except ValueError:
pass
# item = Arm(*values)
# print(values)
items.append(values)
for item in items:
p_name = item[1]
p_bar_code = item[2]
p_description = item[3]
p_image = item[4]
p_volume = item[5]
p_buying_price = int(float(item[6]))
p_available_quantity = int(float(item[7]))
p_selling_price = (p_buying_price * .2) + p_buying_price
single_product = Products(name=p_name,
description=p_description,
p_image=p_image,
volume_weight=p_volume,
buying_price=p_buying_price,
available_quantity=p_available_quantity,
bar_code=p_bar_code,
bar_code_image='test',
selling_price=p_selling_price,
brand_id=1,
p_type_id=products_type)
single_product.save()
return redirect('add-excel')
class ResumableFile(object):
"""A resumable file controls getting pieces of a file"""
upload_root = getattr(settings, 'UPLOAD_ROOT', None)
name_template = "part_%(resumableChunkNumber)04d.tmp"
def __init__(self, user, kwargs):
self.kwargs = kwargs
self.user = user
if not self.upload_root:
raise ImproperlyConfigured('You must set UPLOAD_ROOT in settings')
self.storage = FileSystemStorage(location=self.upload_dir)
@property
def chunk_exists(self):
"""Checks if the requested chunk exists."""
name = self.name_template % self.kwargs
if not self.storage.exists(name):
return False
chunk_size = int(self.kwargs.get('resumableCurrentChunkSize'))
return self.storage.size(name) == chunk_size
def chunk_names(self):
"""Iterates over all stored chunks and yields their names."""
try:
return sorted(self.storage.listdir('')[1])
except OSError:
return []
def chunks(self):
"""Yield the contents of every chunk, FileSystemStorage.save compatible"""
for name in self.chunk_names():
try:
yield self.storage.open(name).read()
except AttributeError:
raise IOError("Couldn't read {}".format(name))
def delete_chunks(self):
"""Remove every chunk (once complete)"""
return [self.storage.delete(chunk) for chunk in self.chunk_names()]
@property
def filename(self):
"""Gets the filename."""
filename = self.kwargs.get('resumableFilename')
if '/' in filename:
raise Exception('Invalid filename')
return filename
@property
def upload_dir(self):
"""Gets the directory to save chunks to"""
return os.path.join(self.upload_root, str(self.user.pk), self.filename)
@property
def is_complete(self):
"""Checks if all chunks are allready stored."""
return os.path.isfile(self.upload_dir) or \
self.kwargs['resumableTotalSize'] == self.size
def process_chunk(self, _file):
"""Process the chunks of the given file"""
if not self.chunk_exists:
try:
self.storage.save(self.name_template % self.kwargs, _file)
except AttributeError:
pass # Error saving file
except IOError:
pass # Existing file in the way
def save_to(self, new_dir):
"""When saving all the chunks to a new directory"""
filename = os.path.join(new_dir, self.filename)
if os.path.islink(self.upload_dir):
# This was previously uploaded and we can relink it.
if not os.path.exists(filename):
linkto = os.readlink(self.upload_dir)
os.symlink(linkto, filename)
return
# Actually save the file using storage
storage = FileSystemStorage(location=new_dir)
storage.save(self.filename, self)
# Delete all the chunks after use
self.delete_chunks()
os.rmdir(self.upload_dir)
# Create a symlink for tracking and re-user
if os.path.isfile(filename):
os.symlink(filename, self.upload_dir)
@property
def size(self):
"""Gets chunks size."""
size = 0
for chunk in self.chunk_names():
size += self.storage.size(chunk)
return size
@property
def started(self):
"""Return the first modified datetime"""
return self.get_times()[0]
@property
def ended(self):
"""Return the last modified datetime"""
return self.get_times()[-1]
def get_times(self):
"""Return a list of modified datetimes"""
upload = self.upload_dir
files = []
if os.path.isdir(upload):
files = [os.path.join(upload, f) for f in os.listdir(upload)]
elif os.path.exists(upload):
files = [upload]
return [fromtimestamp(os.path.getmtime(f)) for f in files]
def size(self, name):
file_system = FileSystemStorage()
return file_system.size(name)
def explore(request, f_path=''):
'''
View that returns the information of the current directory in the filesystem.
:param request: request information.
:param f_path: relative filepath from the URL.
:return: an array of JSON objects that represent the characteristics of the files/directories in the current path.
'''
f_path = f_path.split(
'/') # splitting just in case the OS doesn't use unix
current_folder_path = path.join(settings.MEDIA_ROOT, *f_path)
# open the current folder using Django specific classes.
current_folder = FileSystemStorage(location=current_folder_path,
file_permissions_mode=0o644,
directory_permissions_mode=0o644)
# current_folder_info: [[folder1, folder2, ...], [file1, file2, ...]]
current_folder_info = [[], []]
try:
current_folder_info = current_folder.listdir(path='.')
except NotADirectoryError:
raise Http404('Not a Directory')
# store data of present folder
folder_data = []
for f_name in current_folder_info[0]: # reading folders
folder_data.append({
'name':
f_name,
'is_folder':
True,
'created':
current_folder.get_created_time(name=f_name),
'modified':
current_folder.get_modified_time(name=f_name),
'accessed':
current_folder.get_accessed_time(name=f_name),
})
# update file's information
for f_name in current_folder_info[1]: # reading files
file_path = path.join(current_folder_path, f_name)
## Fetch tags
try:
obj = Dataset.objects.get(path=file_path)
obj_tags = DatasetTag.objects.filter(dataset_id=obj.id)
tags = [Tag.objects.get(id=el.tag_id).tag_name for el in obj_tags]
except ObjectDoesNotExist:
tags = []
# get file type using specific library
type_file = magic_unix.from_file(filename=file_path)
type_file_mime = magic_unix.from_file(filename=file_path, mime=True)
folder_data.append({
'name':
f_name,
'is_folder':
False,
'created':
current_folder.get_created_time(name=f_name),
'modified':
current_folder.get_modified_time(name=f_name),
'accessed':
current_folder.get_accessed_time(name=f_name),
'size':
current_folder.size(name=f_name),
'type':
type_file,
'type/mime':
type_file_mime,
'tags':
tags
})
return JsonResponse({'response': folder_data}, safe=True)
def size(self, name):
return FileSystemStorage.size(self, name)
