def check_availability(self): """ Perform check against Default Storage. """ try: name = default_storage.get_valid_name('Informer Storage') # Save data. content = ContentFile('File used by StorageInformer checking.') path = default_storage.save(name, content) # Check properties. default_storage.size(path) default_storage.url(path) default_storage.path(path) default_storage.get_accessed_time(path) default_storage.get_available_name(path) default_storage.get_created_time(path) default_storage.get_modified_time(path) default_storage.get_valid_name(path) # And remove file. default_storage.delete(path) storage = default_storage.__class__.__name__ except Exception as error: raise InformerException( f'An error occurred when trying to use your Storage: {error}') else: return True, f'Your {storage} is operational.'
def get_context_data(self, **kwargs): documentversion_list = [{ 'name': d.uploaded_file.name, 'generate_filename': default_storage.generate_filename(d.uploaded_file.name), 'url': default_storage.url( default_storage.generate_filename(d.uploaded_file.name)), 'exists': default_storage.exists( default_storage.generate_filename(d.uploaded_file.name)), 'id': d.id } for d in DocumentVersion.objects.all()] kwargs.update({ 'objectstore_container_list': [ 'uploads/%s' % default_storage.get_valid_name(o) for o in default_storage.listdir('uploads')[1] ], 'documentversion_list': documentversion_list, }) return super().get_context_data(**kwargs)
def check_availability(self): """ Perform check against Default Storage. """ try: name = default_storage.get_valid_name('Informer Storage') # Save data. content = ContentFile('File used by StorageInformer checking.') path = default_storage.save(name, content) # Check properties. default_storage.size(path) default_storage.url(path) default_storage.path(path) default_storage.modified_time(path) default_storage.created_time(path) # And remove file. default_storage.delete(path) storage = default_storage.__class__.__name__ except Exception as error: raise InformerException( 'A error occured when trying access your database: %s' % error) else: return True, 'Your %s is operational.' % storage
def get_filename(self, filename): filename = default_storage.get_valid_name(os.path.basename(filename)) filename = force_text(filename) filename = unicodedata.normalize('NFKD', filename).encode( 'ascii', 'ignore').decode('ascii') name, ext = splitext(filename) print(f"name=[{name}] and ext=[{ext}]") return normpath(f"{self.document_type}{ext}")
def unique_filename(file): """ Return the file's name as last component and \ a unique ID as first component. \ A unique ID is returned as filename if \ the file's name is not valid. The extension \ is assumed to be valid """ name, ext = os.path.splitext(file.name) name = default_storage.get_valid_name(name) return os.path.join( safe_uuid(), '{name}{ext}'.format(name=name.lstrip('.') or safe_uuid(), ext=ext.lower()))
def save_data(self, filename, django_file): """Save the response data from django_file. Does NOT save the StoredFile object, you must save it or the file will be forgotten and orphaned. django_file must be a django.core.files.File object (or subclass). filename is used to construct the actual filename in storage. """ if self.file_exists(): raise Exception("ERROR: Attempt to save respondent data that's already been saved") # We need to find a unique name - use a timestamp if we have to name = filename while default_storage.exists(name): name = default_storage.get_valid_name(u"%s_%s" % (filename, time.time())) self.filename = default_storage.save(name, django_file)
def download(image_url): response, content = client.request(image_url) #if response.status == 200 and response.get('content-type', None) == 'image/jpeg': if response.status == 200: image_url = image_url.split('?')[0] # chop the query string out image_name = default_storage.get_valid_name(image_url) image_path = TWITTER_IMAGE_PATH + image_name if not default_storage.exists(image_path): log.info('saving image name = %s' % image_path) save_image(image_name, content) return image_name else: log.error('%s %s' % (response.status, response.get('content-type', None))) return None
def unique_filename(file): """ Return the file's name as last component and \ a unique ID as first component. \ A unique ID is returned as filename if \ the file's name is not valid. The extension \ is assumed to be valid """ name, ext = os.path.splitext(file.name) name = default_storage.get_valid_name(name) return os.path.join( safe_uuid(), '{name}{ext}'.format( name=name.lstrip('.') or safe_uuid(), ext=ext.lower()))
def upload_image(self, request, *args, **kwargs): username = self.request.user.username serializer = self.get_serializer(data=request.data) if not serializer.is_valid(): return Response( serializer.errors, status=status.HTTP_400_BAD_REQUEST, ) file = request.data["file"] upload_file_name = default_storage.get_valid_name(file.name) upload_path = os.path.join("user_uploaded_file", f"{username}", upload_file_name) saved_file = default_storage.save(upload_path, file) url = request.build_absolute_uri(default_storage.url(saved_file)) data = {"name": saved_file, "url": url} return Response(data)
def forwards(self, orm): "Write your forwards methods here." # Note: Remember to use orm['appname.ModelName'] rather than "from appname.models..." # This has two responsibilities: # 1. copy old template/static directories to themes/<pk>/* # 2. create a zipped version of those directories and save it to the # Theme object. old_template = '{path}{dirname}/{pk}/' new_template = 'uploadtemplate/themes/{pk}/{dirname}/' dirnames = ('templates', 'static') upload_to = 'uploadtemplate/files/%Y/%m/%d' for theme in orm['uploadtemplate.Theme'].objects.all(): sio = StringIO() zip_file = zipfile.ZipFile(sio, 'w') try: for dirname in dirnames: format_kwargs = {'path': settings.UPLOADTEMPLATE_MEDIA_ROOT, 'pk': theme.pk, 'dirname': dirname} old = old_template.format(**format_kwargs) new = new_template.format(**format_kwargs) for dir_path, dirs, files in os.walk(old): for filename in files: old_path = os.path.join(dir_path, filename) name = old_path[len(old):] new_path = os.path.join(new, name) zip_path = os.path.join(dirname, name) with open(old_path, 'r') as fp: f = File(fp) if default_storage.exists(new_path): default_storage.delete(new_path) default_storage.save(new_path, f) zip_file.write(old_path, zip_path) finally: zip_file.close() sio.seek(0) directory_name = os.path.normpath(force_unicode(datetime.datetime.now().strftime(smart_str(upload_to)))) filename = os.path.normpath(default_storage.get_valid_name(os.path.basename('theme.zip'))) name = os.path.join(directory_name, filename) name = default_storage.save(name, ContentFile(sio.read())) theme.theme_files_zip = name theme.save()
def _save_attachments(self): # @@@ convert into proper form field with widget? delete_ids = set(self.data.getlist("remove-attachment")) for attachment in self.instance.attachments: if attachment.id in delete_ids: attachment.delete() # if we're saving as new version, bring forward existing attachments # from previous version prior_version = getattr(self, "prior_version", None) if prior_version is not None: for attachment in prior_version.attachments: self.instance.attachments.post(attachment) if not self.files: return for uf in self.files.getlist("attachment"): try: file_name = uf.name file_size = uf.size except AttributeError: continue if not file_name or not file_size: continue storage_name = default_storage.get_available_name( default_storage.get_valid_name(file_name)) default_storage.save(storage_name, uf) attachment = Attachment( name=storage_name, description=file_name, url=default_storage.url(storage_name), size=file_size, attachmentType=AttachmentType.UNSPECIFIED ) self.instance.attachments.post(attachment)
def _save_attachments(self): # @@@ convert into proper form field with widget? delete_ids = set(self.data.getlist("remove-attachment")) for attachment in self.instance.attachments: if attachment.id in delete_ids: attachment.delete() # if we're saving as new version, bring forward existing attachments # from previous version if self.prior_version is not None: for attachment in self.prior_version.attachments: self.instance.attachments.post(attachment) if not self.files: return for uf in self.files.getlist("attachment"): try: file_name = uf.name file_size = uf.size except AttributeError: continue if not file_name or not file_size: continue storage_name = default_storage.get_available_name( default_storage.get_valid_name(file_name)) default_storage.save(storage_name, uf) attachment = Attachment(name=storage_name, description=file_name, url=default_storage.url(storage_name), size=file_size, attachmentType=AttachmentType.UNSPECIFIED) self.instance.attachments.post(attachment)
def get_valid_name(self, name): return default_storage.get_valid_name(name)
def clean(self): cleaned_data = super(UploadMapForm, self).clean() file_obj = cleaned_data.get('file') if not file_obj: # no clean file => abort return cleaned_data # Make a save filename and copy the uploaded file saved_file = file_obj.temporary_file_path() safe_name = default_storage.get_valid_name(file_obj.name) tmpdir = tempfile.gettempdir() copied_file = shutil.copyfile(saved_file, os.path.join(tmpdir, safe_name)) try: # call map info tool to generate minimap and json info file # change working directory so that the datadir is found old_cwd = os.getcwd() os.chdir(settings.WIDELANDS_SVN_DIR) check_call(['wl_map_info', copied_file]) os.chdir(old_cwd) except CalledProcessError: self._errors['file'] = self.error_class( ['The map file could not be processed.']) del cleaned_data['file'] os.remove(copied_file) return cleaned_data mapinfo = json.load(open(copied_file + '.json')) if Map.objects.filter(name=mapinfo['name']): self._errors['file'] = self.error_class( ['A map with the same name already exists.']) del cleaned_data['file'] # Delete the file copy and the generated files try: os.remove(copied_file) os.remove(copied_file + '.json') os.remove(copied_file + '.png') except os.FileNotFoundError: pass return cleaned_data # Add information to the map self.instance.name = mapinfo['name'] self.instance.author = mapinfo['author'] self.instance.w = mapinfo['width'] self.instance.h = mapinfo['height'] self.instance.nr_players = mapinfo['nr_players'] self.instance.descr = mapinfo['description'] self.instance.hint = mapinfo['hint'] self.instance.world_name = mapinfo['world_name'] # The field is called 'wl_version_after' even though it actually means the # _minimum_ WL version required to play the map for historical reasons if 'minimum_required_widelands_version' in mapinfo: self.instance.wl_version_after = mapinfo[ 'minimum_required_widelands_version'] else: self.instance.wl_version_after = 'build {}'.format( mapinfo['needs_widelands_version_after'] + 1) # mapinfo["minimap"] is the absolute path to the image file # We move the file to the correct destination minimap_name = mapinfo['minimap'].rpartition('/')[2] minimap_upload_to = self.instance._meta.get_field('minimap').upload_to minimap_path = os.path.join(minimap_upload_to, minimap_name) self.instance.minimap = minimap_path shutil.move(mapinfo['minimap'], os.path.join(settings.MEDIA_ROOT, minimap_path)) # Final cleanup os.remove(copied_file + '.json') os.remove(copied_file) return cleaned_data
def get_filename(self, filename): filename = default_storage.get_valid_name(os.path.basename(filename)) filename = force_text(filename) filename = unicodedata.normalize('NFKD', filename).encode( 'ascii', 'ignore').decode('ascii') return os.path.normpath(filename)