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]
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 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)
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)
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 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)
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)