def dehydrate(self, bundle):
# Setting slug-field
bundle.data['slug'] = slugify(unidecode(bundle.data['title']))
# If image is set
if bundle.data['image']:
# Parse to FileObject used by Filebrowser
temp_image = FileObject(bundle.data['image'])
# Itterate the different versions (by key)
for ver in VERSIONS.keys():
# Check if the key start with article_ (if it does, we want to crop to that size)
if ver.startswith('events_'):
# Adding the new image to the object
bundle.data['image_' +
ver] = temp_image.version_generate(ver).url
# Unset the image-field
del (bundle.data['image'])
# Do the same thing for the company image
if 'image' in bundle.data and bundle.data['image']:
for company in bundle.data['company_event']:
temp_image = FileObject(
company.data['companies'].data['old_image'])
for ver in VERSIONS.keys():
if ver.startswith('companies_thumb'):
company.data['companies'].data[
'old_image_' +
ver] = temp_image.version_generate(ver).url
del (company.data['companies'].data['old_image'])
# Returning washed object
return bundle
def generate_version_add_watermark(original_path, version_suffix):
"""
Generate the given version of an image and adds watermark to it
NOTE: this function only generates a new version from original file (i.e in db) when
1. the version does not exists.
2. the modified date of original image is newer than version
:param original_path: relative path to original image
:param version_suffix: version prefix as defined in common settings
'medium'|'large'|'thumbnail'
:return: image object.
"""
from filebrowser.base import FileObject
from filebrowser.sites import site
from core.models import Image
fob = FileObject(original_path, site=site)
version_path = fob.version_path(version_suffix)
if not site.storage.isfile(version_path):
version_path = fob._generate_version(version_suffix)
# abs_path = os.path.join(settings.MEDIA_ROOT, version_path)
# Image.create_image_watermark(abs_path, abs_path, settings.WATERMARK_IMAGE_LOCATION)
elif site.storage.modified_time(
original_path) > site.storage.modified_time(version_path):
version_path = fob._generate_version(version_suffix)
# abs_path = os.path.join(settings.MEDIA_ROOT, version_path)
# Image.create_image_watermark(abs_path, abs_path, settings.WATERMARK_IMAGE_LOCATION)
return FileObject(version_path, site=site)
def test_get_context_data(self):
production = ProductionFactory(poster=FileObject('poster'))
no_poster_production = ProductionFactory()
review = ReviewFactory(
is_published=True,
cover_image=FileObject('image')
)
unpublished_review = ReviewFactory(
is_published=False,
cover_image=FileObject('x')
)
no_image_review = ReviewFactory(is_published=True)
context = self.view.get_context_data()
self.assertIn(production, context['productions'])
self.assertNotIn(no_poster_production, context['productions'])
self.assertIn(review, context['reviews'])
self.assertNotIn(unpublished_review, context['reviews'])
self.assertNotIn(no_image_review, context['reviews'])
self.assertIsNone(context['audition_groups'])
self.assertIsNone(context['media_news'])
self.assertIsNone(context['news_groups'])
audition = AuditionFactory()
media_news = ArtsNewsFactory(video_embed='<iframe />')
news = ArtsNewsFactory()
context = self.view.get_context_data()
self.assertIn([audition], context['audition_groups'])
self.assertEqual(context['media_news'], media_news)
self.assertIn([news], context['news_groups'])
def _upload_file(self, request):
"""
Upload file to the server.
"""
if request.method == "POST":
folder = request.GET.get('folder', '')
if len(request.FILES) == 0:
return HttpResponseBadRequest('Invalid request! No files included.')
if len(request.FILES) > 1:
return HttpResponseBadRequest('Invalid request! Multiple files included.')
filedata = list(request.FILES.values())[0]
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub('', folder)
path = os.path.join(self.directory, folder)
# we convert the filename before uploading in order
# to check for existing files/folders
file_name = convert_filename(filedata.name)
filedata.name = file_name
file_path = os.path.join(path, file_name)
file_already_exists = self.storage.exists(file_path)
# Check for name collision with a directory
if file_already_exists and self.storage.isdir(file_path):
ret_json = {'success': False, 'filename': file_name}
return HttpResponse(json.dumps(ret_json))
signals.filebrowser_pre_upload.send(sender=request, path=folder, file=filedata, site=self)
uploadedfile = handle_file_upload(path, filedata, site=self)
# Caminho do arquivo desde o diretorio MEDIA ate seu nome, usado no retorno do metodo
if file_already_exists and OVERWRITE_EXISTING:
old_file = smart_text(file_path)
new_file = smart_text(uploadedfile)
self.storage.move(new_file, old_file, allow_overwrite=True)
full_path = FileObject(smart_text(old_file), site=self).path_full
else:
file_name = smart_text(uploadedfile)
filedata.name = os.path.relpath(file_name, path)
full_path = FileObject(smart_text(file_name), site=self).path_full
# set permissions
if DEFAULT_PERMISSIONS is not None:
os.chmod(full_path, DEFAULT_PERMISSIONS)
f = FileObject(smart_text(file_name), site=self)
signals.filebrowser_post_upload.send(sender=request, path=folder, file=f, site=self)
# let Ajax Upload know whether we saved it or not
ret_json = {'success': True, 'filename': f.filename, 'filepath': uploadedfile}
return HttpResponse(json.dumps(ret_json))
def setUp(self):
"""
Save original values/functions so they can be restored in tearDown
"""
self.original_path = filebrowser.base.os.path
self.original_directory = site.directory
self.original_versions_basedir = filebrowser.base.VERSIONS_BASEDIR
self.original_versions = filebrowser.base.VERSIONS
self.original_admin_versions = filebrowser.base.ADMIN_VERSIONS
# DIRECTORY
# custom directory because this could be set with sites
# and we cannot rely on filebrowser.settings
# FIXME: find better directory name
self.directory = "fb_test_directory/"
self.directory_path = os.path.join(site.storage.location, self.directory)
if os.path.exists(self.directory_path):
self.fail("Test directory already exists.")
else:
os.makedirs(self.directory_path)
# set site directory
site.directory = self.directory
# VERSIONS
self.versions = "_versionstestdirectory"
self.versions_path = os.path.join(site.storage.location, self.versions)
if os.path.exists(self.versions_path):
self.fail("Versions directory already exists.")
else:
os.makedirs(self.versions_path)
# create temporary test folder and move testimage
# FIXME: find better path names
self.tmpdir_name = os.path.join("fb_tmp_dir", "fb_tmp_dir_sub")
self.tmpdir_path = os.path.join(site.storage.location, self.directory, self.tmpdir_name)
if os.path.exists(self.tmpdir_path):
self.fail("Temporary testfolder already exists.")
else:
os.makedirs(self.tmpdir_path)
# copy test image to temporary test folder
self.image_path = os.path.join(FILEBROWSER_PATH, "static", "filebrowser", "img", "testimage.jpg")
if not os.path.exists(self.image_path):
self.fail("Testimage not found.")
shutil.copy(self.image_path, self.tmpdir_path)
# set posixpath
filebrowser.base.os.path = posixpath
# fileobjects
self.f_image = FileObject(os.path.join(self.directory, self.tmpdir_name, "testimage.jpg"), site=site)
self.f_folder = FileObject(os.path.join(self.directory, self.tmpdir_name), site=site)
def test_do_upload(test):
"""
Test the actual uploading
"""
url = reverse('%s:fb_do_upload' % test.site_name)
url = '?'.join([
url,
urlencode({
'folder': test.tmpdir.path_relative_directory,
'qqfile': 'testimage.jpg'
})
])
with open(
os.path.join(FILEBROWSER_PATH,
'static/filebrowser/img/testimage.jpg'), "rb") as f:
file_size = os.path.getsize(f.name)
response = test.c.post(url,
data={
'qqfile': 'testimage.jpg',
'file': f
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
# Check we get OK response
test.assertTrue(response.status_code == 200)
# Check the file now exists
path = os.path.join(test.tmpdir.path, 'testimage.jpg')
test.testfile = FileObject(path, site=test.site)
test.assertTrue(test.site.storage.exists(path))
# Check the file has the correct size
test.assertTrue(file_size == test.site.storage.size(path))
def render(self, name, value, attrs=None):
substitutions = {
'initial_text': self.initial_text,
'input_text': self.input_text,
'clear_template': '',
'preview': '',
'clear_checkbox_label': self.clear_checkbox_label,
}
template = u'%(input)s'
substitutions['input'] = super(DjangoClearableFileInput,
self).render(name, value, attrs)
if value and hasattr(value, "url"):
template = self.template_with_initial
substitutions['initial'] = (
u'<a target="_blank" href="%s">%s</a>' % (value.url, value))
if not self.is_required:
checkbox_name = self.clear_checkbox_name(name)
checkbox_id = self.clear_checkbox_id(checkbox_name)
substitutions['clear_checkbox_name'] = checkbox_name
substitutions['clear_checkbox_id'] = checkbox_id
substitutions['clear'] = CheckboxInput().render(
checkbox_name, False, attrs={'id': checkbox_id})
substitutions[
'clear_template'] = self.template_with_clear % substitutions
if value and hasattr(value, "url"):
preview_template = render_to_string(
'filebrowser/widgets/clearablefileinput.html', {
'value': FileObject(value.name),
'ADMIN_THUMBNAIL': ADMIN_THUMBNAIL,
})
substitutions["preview"] = preview_template
return mark_safe(template % substitutions)
def setUp(self):
Organism.objects.create(
display_name=display_name, short_name=short_name,
tax_id=tax_id)
organism = Organism.objects.get(short_name=short_name)
prepare_test_fasta_file()
self.files = test_files
HmmerDB.objects.create(
fasta_file=FileObject('/blast/db/clec_peptide_example_BLASTdb.fa'),
organism=organism, is_shown=True, title=title)
if not DEBUG:
# headless chrome driver
options = webdriver.ChromeOptions()
options.add_argument('headless')
options.add_argument('window-size=1280x800')
self.driver = webdriver.Chrome(chrome_options=options)
else:
# use with header
self.driver = webdriver.Chrome()
# Or use different webdriver
# self.driver = webdriver.PhantomJS()
# self.driver = webdriver.Firefox()
self.driver.set_window_size(1280, 800)
# Start up celery worker for testing
self.celery_worker = start_worker(app)
self.celery_worker.__enter__()
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
if isinstance(source, FileObject):
source = source.path
source = force_unicode(source)
version_path = get_version_path(source, version_prefix)
if not os.path.isfile(version_path):
version_path = version_generator(source, version_prefix)
elif os.path.getmtime(source) > os.path.getmtime(version_path):
version_path = version_generator(source,
version_prefix,
force=True)
context[self.var_name] = FileObject(version_path)
except:
context[self.var_name] = ""
return ''
def _process_fileupload(request, file, target_folder):
"""Helper that is called upon a successful fileupload with the
file object, and a target folder.
"""
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, target_folder)
file.name = convert_filename(file.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=target_folder, file=file)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, file)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(
os.path.join(MEDIA_ROOT, DIRECTORY, target_folder, file.name)):
old_file = os.path.join(abs_path, file.name)
new_file = os.path.join(abs_path, uploadedfile)
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
# TODO: Do something about the fileobject class.
filebrowser_post_upload.send(sender=request,
path=target_folder,
file=FileObject(
os.path.join(DIRECTORY, target_folder,
file.name)))
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
source = force_unicode(source)
version_path = get_version_path(url_to_path(source),
version_prefix)
if not os.path.isfile(
smart_str(os.path.join(MEDIA_ROOT, version_path))):
# create version
version_path = version_generator(url_to_path(source),
version_prefix)
elif os.path.getmtime(
smart_str(os.path.join(
MEDIA_ROOT, url_to_path(source)))) > os.path.getmtime(
smart_str(os.path.join(MEDIA_ROOT, version_path))):
# recreate version if original image was updated
version_path = version_generator(url_to_path(source),
version_prefix,
force=True)
context[self.var_name] = FileObject(version_path)
except:
context[self.var_name] = ""
return ''
def delete(self, request):
"""
Delete existing File/Directory.
"""
query = request.GET
path = u'%s' % os.path.join(self.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')),
site=self)
if request.GET:
try:
# COG: must delete Doc objects
docs = Doc.objects.filter(file=fileobject.path)
for doc in docs:
print 'Deleting doc=%s' % doc
doc.delete()
self.filebrowser_pre_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename)
fileobject.delete_versions()
fileobject.delete()
self.filebrowser_post_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename)
messages.add_message(
request, messages.SUCCESS,
_('Successfully deleted %s') % fileobject.filename)
except OSError, (errno, strerror):
# TODO: define error-message
pass
def compress_video_task(video):
from models import OsCommandLog
from models import create_update_day
ext, file_path = video.file_video.extension, video.file_video.path_full
if video.compress:
return
out = ''.join(file_path.split('.')[:-1] + ['_compress%s' % ext])
command = 'ffmpeg -i %s -s %s %s -loglevel error -y' % (
file_path, COMPRESS_RESOLUTION, out)
process = subprocess.Popen(shlex.split(str(command)),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=False)
output, errors = process.communicate()
returncode = process.poll()
if path.exists(out):
video.file_video = FileObject(out)
video.compress = True
video.save()
# log
OsCommandLog.objects.create(command=command,
ouput=output,
errors=errors,
return_code=returncode)
# create or update day for video
create_update_day(None, video, action='post_add')
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
site = context.get('filebrowser_site', get_default_site())
directory = site.directory
try:
if isinstance(source, FileObject):
site = source.site
source = source.path
if isinstance(source, File):
source = source.name
source = force_unicode(source)
if FORCE_PLACEHOLDER:
source = PLACEHOLDER
elif SHOW_PLACEHOLDER and not site.storage.isfile(source):
source = PLACEHOLDER
version_path = get_version_path(source, version_prefix, site=site)
if not site.storage.isfile(version_path):
version_path = version_generator(source, version_prefix, site=site)
elif site.storage.modified_time(source) > site.storage.modified_time(version_path):
version_path = version_generator(source, version_prefix, force=True, site=site)
context[self.var_name] = FileObject(version_path, site=site)
except:
context[self.var_name] = ""
return ''
def delete(request):
"""
Delete existing File/Directory.
When trying to delete a Directory, the Directory has to be empty.
"""
query = request.GET
abs_path = u'%s' % os.path.join(MEDIA_ROOT, DIRECTORY, query.get(
'dir', ''))
fileobject = FileObject(os.path.join(abs_path, query.get('filename', '')))
if request.GET:
try:
filebrowser_pre_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename)
fileobject.delete_versions()
fileobject.delete()
filebrowser_post_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename)
messages.add_message(
request, messages.SUCCESS,
_('Successfully deleted %s') % fileobject.filename)
except OSError, (errno, strerror):
# TODO: define error-message
pass
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == 'POST':
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
filebrowser_pre_upload.send(sender=request,
path=request.POST.get('folder'),
file=filedata)
uploadedfile = handle_file_upload(abs_path, filedata)
# if file already exists
if os.path.isfile(
smart_str(
os.path.join(MEDIA_ROOT, DIRECTORY, folder,
filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file, allow_overwrite=True)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(
sender=request,
path=request.POST.get('folder'),
file=FileObject(
smart_str(os.path.join(DIRECTORY, folder, filedata.name))))
return HttpResponse('True')
def detail(self, request):
query = request.GET
path = u'%s' % os.path.join(site.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')))
from .forms import ChangeForm
if request.method == 'POST':
form = ChangeForm(request.POST)
# print(form.cleaned_data['name'])
if form.is_valid():
new_name = form.cleaned_data['name']
self.storage.move(fileobject.path, os.path.join(fileobject.head, new_name))
# return HttpResponse('upload succed!')
redirect_url = reverse("files:browse")+'?dir='+query.get('dir', '')
return HttpResponseRedirect(redirect_url)
else:
form = ChangeForm()
return render(request, 'files/detail.html', {
'form': form,
'query': query,
'fileobject': fileobject,
'breadcrumbs': get_Breadcrumbs(query.get('dir', ''))
})
def delete_confirm(self, request):
if not request.user.has_perm('auth.view_filebrowser'):
raise PermissionDenied()
"Delete existing File/Directory."
query = request.GET
path = u'%s' % os.path.join(self.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')), site=self)
if fileobject.filetype == "Folder":
filelisting = FileListing(
os.path.join(path, fileobject.filename),
sorting_by=query.get('o', 'filename'),
sorting_order=query.get('ot', DEFAULT_SORTING_ORDER),
site=self)
filelisting = filelisting.files_walk_total()
if len(filelisting) > 100:
additional_files = len(filelisting) - 100
filelisting = filelisting[:100]
else:
additional_files = None
else:
filelisting = None
additional_files = None
return render_to_response('filebrowser/delete_confirm.html', {
'fileobject': fileobject,
'filelisting': filelisting,
'additional_files': additional_files,
'query': query,
'title': _(u'Confirm delete'),
'is_popup': "pop" in request.REQUEST,
'settings_var': get_settings_var(directory=self.directory),
'breadcrumbs': get_breadcrumbs(query, query.get('dir', '')),
'breadcrumbs_title': _(u'Confirm delete'),
'filebrowser_site': self
}, context_instance=Context(request, current_app=self.name))
def render(self, name, value, attrs=None, renderer=None):
url = reverse(self.site.name + ":fb_browse")
if value is None:
value = ""
if value != "" and not isinstance(value, FileObject):
value = FileObject(value, site=self.site)
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
final_attrs['search_icon'] = static(
'filebrowser/img/filebrowser_icon_show.gif')
final_attrs['url'] = url
final_attrs['directory'] = self.directory
final_attrs['extensions'] = self.extensions
final_attrs['format'] = self.format
final_attrs['ADMIN_THUMBNAIL'] = ADMIN_THUMBNAIL
final_attrs['data_attrs'] = {
k: v
for k, v in final_attrs.items() if k.startswith('data-')
}
filebrowser_site = self.site
if value != "":
try:
final_attrs['directory'] = os.path.split(
value.original.path_relative_directory)[0]
except:
pass
return render_to_string("filebrowser/custom_field.html", locals())
def setUp(self):
self.sections = []
self.articles = []
for i in range(1, 3):
section = Section.objects.create(
title="Section%s" % i,
headline="HL%s" % i,
status="published",
)
self.sections.append(section)
article = Article.objects.create(
title="Title%s" % i,
slug="slug%s" % i,
content="Text%s" % i,
teaser="Teaser%s" % i,
image=FileObject("%s/foo.jpg" % settings.MEDIA_ROOT),
status="published",
)
self.articles.append(article)
s1, s2 = self.sections
PageNodePos.objects.create(content=self.articles[0],
owner=s1,
position=0)
self.sectionlist1 = SectionList.objects.create(
title="Sectionlist1",
slug="sectionlist1",
status="published",
)
PageNodePos.objects.create(content=s1,
owner=self.sectionlist1,
position=0)
def test_createdir(test):
"""
Check the createdir view functions as expected. Creates a new tmp directory
under 'site.directory'.
"""
# Generate a name of a new temp directory
prefix = 'tmp_test'
sufix = 0
tmpdir_name = '%s_%d' % (prefix, sufix)
while test.site.storage.exists(
os.path.join(test.site.directory, tmpdir_name)):
sufix += 1
tmpdir_name = '%s_%d' % (prefix, sufix)
# Store the this temp directory (we need to delete it later)
test.tmpdir = FileObject(os.path.join(test.site.directory, tmpdir_name),
site=test.site)
# Create the directory using the createdir view
url = reverse('%s:fb_createdir' % test.site_name)
response = test.c.post(url, {'name': tmpdir_name})
# Check we got Redirection response for createdir
test.assertTrue(response.status_code == 302)
# Check the directory now exists
test.assertTrue(test.site.storage.exists(test.tmpdir.path))
def delete(self, request):
"""
Delete existing File/Directory.
"""
query = request.GET
path = u'%s' % os.path.join(self.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')),
site=self)
if request.GET:
try:
signals.filebrowser_pre_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename,
site=self)
fileobject.delete_versions()
fileobject.delete()
signals.filebrowser_post_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename,
site=self)
messages.add_message(
request, messages.SUCCESS,
_('Successfully deleted %s') % fileobject.filename)
except OSError, (errno, strerror):
# TODO: define error-message
pass
def test_delete(self):
"""
FileObject delete methods
# delete
# delete_versions
# delete_admin_versions
"""
# new settings
filebrowser.base.VERSIONS_BASEDIR = ""
filebrowser.base.VERSIONS = {
'admin_thumbnail': {'verbose_name': 'Admin Thumbnail', 'width': 60, 'height': 60, 'opts': 'crop'},
'large': {'verbose_name': 'Large', 'width': 600, 'height': '', 'opts': ''},
}
filebrowser.base.ADMIN_VERSIONS = ['large']
# version does not exist yet
f_version = FileObject(os.path.join(self.directory, self.tmpdir_name, "testimage_large.jpg"), site=site)
self.assertEqual(f_version.exists, False)
# generate version
f_version = self.f_image.version_generate("large")
f_version_thumb = self.f_image.version_generate("admin_thumbnail")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version_thumb.exists, True)
self.assertEqual(f_version.path, "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
self.assertEqual(f_version_thumb.path, "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_admin_thumbnail.jpg")
# delete admin versions (large)
self.f_image.delete_admin_versions()
self.assertEqual(site.storage.exists(f_version.path), False)
# delete versions (admin_thumbnail)
self.f_image.delete_versions()
self.assertEqual(site.storage.exists(f_version_thumb.path), False)
def test_delete(self):
"""
FileObject delete methods
# delete
# delete_versions
# delete_admin_versions
"""
# version does not exist yet
f_version = FileObject(os.path.join(site.directory, 'folder', "testimage_large.jpg"), site=site)
self.assertEqual(f_version.exists, False)
# generate version
f_version = self.F_IMAGE.version_generate("large")
f_version_thumb = self.F_IMAGE.version_generate("admin_thumbnail")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version_thumb.exists, True)
self.assertEqual(f_version.path, "_test/_versions/folder/testimage_large.jpg")
self.assertEqual(f_version_thumb.path, "_test/_versions/folder/testimage_admin_thumbnail.jpg")
# delete admin versions (large)
self.F_IMAGE.delete_admin_versions()
self.assertEqual(site.storage.exists(f_version.path), False)
# delete versions (admin_thumbnail)
self.F_IMAGE.delete_versions()
self.assertEqual(site.storage.exists(f_version_thumb.path), False)
def render(self, context):
try:
version_suffix = self.suffix.resolve(context)
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if version_suffix not in VERSIONS:
return "" # FIXME: should this throw an error?
if isinstance(source, FileObject):
source = source.path
elif isinstance(source, File):
source = source.name
else: # string
source = source
site = context.get('filebrowser_site', get_default_site())
if FORCE_PLACEHOLDER or (SHOW_PLACEHOLDER
and not site.storage.isfile(source)):
source = PLACEHOLDER
fileobject = FileObject(source, site=site)
try:
version = fileobject.version_generate(version_suffix)
context[self.var_name] = version
except Exception:
if settings.TEMPLATE_DEBUG:
raise
context[self.var_name] = ""
return ""
def delete_confirm(request):
"""
Delete existing File/Directory.
"""
query = request.GET
abs_path = u'%s' % os.path.join(MEDIA_ROOT, DIRECTORY, query.get('dir', ''))
fileobject = FileObject(os.path.join(abs_path, query.get('filename', '')))
if fileobject.filetype == "Folder":
filelisting = FileListing(os.path.join(abs_path, fileobject.filename),
filter_func=filter_browse,
sorting_by=query.get('o', 'filename'),
sorting_order=query.get('ot', DEFAULT_SORTING_ORDER))
filelisting = filelisting.files_walk_total()
if len(filelisting) > 100:
additional_files = len(filelisting) - 100
filelisting = filelisting[:100]
else:
additional_files = None
else:
filelisting = None
additional_files = None
return render_to_response('filebrowser/delete_confirm.html', {
'fileobject': fileobject,
'filelisting': filelisting,
'additional_files': additional_files,
'query': query,
'title': _(u'Confirm delete'),
'settings_var': get_settings_var(),
'breadcrumbs': get_breadcrumbs(query, query.get('dir', '')),
'breadcrumbs_title': _(u'Confirm delete')
}, context_instance=Context(request))
def delete(self, request):
"Delete existing File/Directory."
query = request.GET
path = u'%s' % os.path.join(self.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')),
site=self)
if request.GET:
try:
signals.filebrowser_pre_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename,
site=self)
fileobject.delete_versions()
fileobject.delete()
signals.filebrowser_post_delete.send(sender=request,
path=fileobject.path,
name=fileobject.filename,
site=self)
messages.add_message(
request, messages.SUCCESS,
_('Successfully deleted %s') % fileobject.filename)
except OSError:
# TODO: define error-message
pass
redirect_url = reverse("filebrowser:fb_browse",
current_app=self.name) + query_helper(
query, "", "filename,filetype")
return HttpResponseRedirect(redirect_url)
def render(self, name, value, attrs=None, renderer=None):
url = reverse(self.site.name + ":fb_browse")
if value is None:
value = ""
if value != "" and not isinstance(value, FileObject):
value = FileObject(value, site=self.site)
final_attrs = self.build_attrs(attrs,
extra_attrs={
"type": self.input_type,
"name": name
})
final_attrs[
'search_icon'] = '/static/filebrowser/img/filebrowser_icon_show.gif'
final_attrs['url'] = url
final_attrs['directory'] = self.directory
final_attrs['extensions'] = self.extensions
final_attrs['format'] = self.format
final_attrs['upload_to'] = self.upload_to
final_attrs['temp_upload_dir'] = UPLOAD_TEMPDIR
final_attrs['ADMIN_THUMBNAIL'] = ADMIN_THUMBNAIL
if value != "":
try:
final_attrs['directory'] = os.path.split(
value.original.path_relative_directory)[0]
except:
pass
return render_to_string("filebrowser/custom_upload_field.html",
locals())
def delete_confirm(self, request):
"Delete existing File/Directory."
query = request.GET
path = u'%s' % os.path.join(self.directory, query.get('dir', ''))
fileobject = FileObject(os.path.join(path, query.get('filename', '')), site=self)
if fileobject.filetype == "Folder":
filelisting = FileListing(
os.path.join(path, fileobject.filename),
sorting_by=query.get('o', 'filename'),
sorting_order=query.get('ot', DEFAULT_SORTING_ORDER),
site=self)
filelisting = filelisting.files_walk_total()
if len(filelisting) > 100:
additional_files = len(filelisting) - 100
filelisting = filelisting[:100]
else:
additional_files = None
else:
filelisting = None
additional_files = None
return render(request, 'filebrowser/delete_confirm.html', admin_context({
'fileobject': fileobject,
'filelisting': filelisting,
'additional_files': additional_files,
'query': query,
'title': _(u'Confirm delete'),
'is_popup': "pop" in request.GET,
'settings_var': get_settings_var(directory=self.directory),
'breadcrumbs': get_breadcrumbs(query, query.get('dir', '')),
'breadcrumbs_title': _(u'Confirm delete'),
'filebrowser_site': self
}, request))
def test_do_upload(test):
## Attemp an upload using AJAX SUBMISSION
f = open(os.path.join(PATH_FILEBROWSER_MEDIA, 'img/testimage.jpg'), "rb")
file_size = os.path.getsize(f.name)
url = reverse('%s:fb_do_upload' % test.site_name)
url = '?'.join([
url,
urlencode({
'folder': test.tmpdir.path_relative_directory,
'qqfile': 'testimage.jpg'
})
])
response = test.c.post(url,
data=f.read(),
content_type='application/octet-stream',
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
X_File_Name='testimage.jpg')
f.close()
# Check we get OK response
test.assertTrue(response.status_code == 200)
# Check the file now exists
path = os.path.join(test.tmpdir.path, 'testimage.jpg')
test.testfile = FileObject(path, site=test.site)
test.assertTrue(test.site.storage.exists(path))
# Check the file has the correct size
test.assertTrue(file_size == test.site.storage.size(path))
