def image_thumbnail(self, obj):
if obj.image:
image = FileObject(obj.image.path)
if image.filetype == "Image":
return '<img src="%s" />' % image.version_generate(ADMIN_THUMBNAIL).url
else:
return ""
def image_thumbnail(self):
if self.image:
image = FileObject(self.image.path)
if image.filetype == "Image":
return '<img src="%s" />' % image.version_generate('admin_thumbnail').url
else:
return ""
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 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 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 as e:
if settings.TEMPLATE_DEBUG:
raise e
context[self.var_name] = ""
return ""
def get_teaser_image(path, version):
if path:
image = FileObject(path)
if image.filetype == "Image":
return image.version_generate(version).url.split('adimas.info')[1]
else:
return ""
def test_unicode_options_namer_version(self):
path_unicode = os.path.join(self.FOLDER_PATH, "測試文件.jpg")
expected = u"測試文件_large--680x0.jpg"
shutil.copy(self.STATIC_IMG_PATH, path_unicode)
f = FileObject(path_unicode, site=site)
version = f.version_generate("large")
self.assertEqual(version.filename, expected)
def detail(self, request):
"""
Show detail page for a file.
Rename existing File/Directory (deletes existing Image Versions/Thumbnails).
"""
from filebrowser.forms import ChangeForm
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.method == 'POST':
form = ChangeForm(request.POST, path=path, fileobject=fileobject, filebrowser_site=self)
if form.is_valid():
new_name = form.cleaned_data['name']
action_name = form.cleaned_data['custom_action']
try:
action_response = None
if action_name:
action = self.get_action(action_name)
# Pre-action signal
signals.filebrowser_actions_pre_apply.send(sender=request, action_name=action_name, fileobject=[fileobject], site=self)
# Call the action to action
action_response = action(request=request, fileobjects=[fileobject])
# Post-action signal
signals.filebrowser_actions_post_apply.send(sender=request, action_name=action_name, fileobject=[fileobject], result=action_response, site=self)
if new_name != fileobject.filename:
signals.filebrowser_pre_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name, site=self)
fileobject.delete_versions()
self.storage.move(fileobject.path, os.path.join(fileobject.head, new_name))
signals.filebrowser_post_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name, site=self)
messages.add_message(request, messages.SUCCESS, _('Renaming was successful.'))
if isinstance(action_response, HttpResponse):
return action_response
if "_continue" in request.POST:
redirect_url = reverse("filebrowser:fb_detail", current_app=self.name) + query_helper(query, "filename=" + new_name, "filename")
else:
redirect_url = reverse("filebrowser:fb_browse", current_app=self.name) + query_helper(query, "", "filename")
return HttpResponseRedirect(redirect_url)
except OSError:
form.errors['name'] = forms.util.ErrorList([_('Error.')])
else:
form = ChangeForm(initial={"name": fileobject.filename}, path=path, fileobject=fileobject, filebrowser_site=self)
return render(
admin_request(request, self.name),
'filebrowser/detail.html',
admin_context({
'form': form,
'fileobject': fileobject,
'query': query,
'title': u'%s' % fileobject.filename,
'is_popup': "pop" in request.GET,
'settings_var': get_settings_var(directory=self.directory),
'breadcrumbs': get_breadcrumbs(query, query.get('dir', '')),
'breadcrumbs_title': u'%s' % fileobject.filename,
'filebrowser_site': self
}, request),
)
def detail(self, request):
"""
Show detail page for a file.
Rename existing File/Directory (deletes existing Image Versions/Thumbnails).
"""
from filebrowser.forms import ChangeForm
query = request.GET
abs_path = u"%s" % os.path.join(self.media_root, query.get("dir", ""))
fileobject = FileObject(
os.path.join(abs_path, query.get("filename", "")), media_root=self.media_root, media_url=self.media_url
)
if request.method == "POST":
form = ChangeForm(request.POST, path=abs_path, fileobject=fileobject, site=self)
if form.is_valid():
new_name = form.cleaned_data["name"]
action_name = form.cleaned_data["custom_action"]
try:
action_response = None
if action_name:
action = self.get_action(action_name)
# Pre-action signal
self.filebrowser_actions_pre_apply.send(
sender=request, action_name=action_name, fileobject=[fileobject]
)
# Call the action to action
action_response = action(request=request, fileobjects=[fileobject])
# Post-action signal
self.filebrowser_actions_post_apply.send(
sender=request, action_name=action_name, fileobject=[fileobject], result=action_response
)
if new_name != fileobject.filename:
self.filebrowser_pre_rename.send(
sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name
)
fileobject.delete_versions()
os.rename(fileobject.path, os.path.join(fileobject.head, new_name))
self.filebrowser_post_rename.send(
sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name
)
messages.add_message(request, messages.SUCCESS, _("Renaming was successful."))
if isinstance(action_response, HttpResponse):
return action_response
if "_continue" in request.POST:
redirect_url = reverse("filebrowser:fb_detail", current_app=self.name) + query_helper(
query, "filename=" + new_name, "filename"
)
else:
redirect_url = reverse("filebrowser:fb_browse", current_app=self.name) + query_helper(
query, "", "filename"
)
return HttpResponseRedirect(redirect_url)
except OSError, (errno, strerror):
form.errors["name"] = forms.util.ErrorList([_("Error.")])
def get_image_thumbnail_html(image):
if image:
image_fileobject = FileObject(image.path)
if image_fileobject and image_fileobject.filetype == "Image" \
and os.path.isfile(settings.MEDIA_ROOT + image.path):
str = '<img src="%s" />' % image_fileobject.version_generate(settings.FILEBROWSER_ADMIN_THUMBNAIL).url
return str
return False
else:
return False
def get(self, request, *args, **kwargs):
''' Receives the request '''
ctx = {'show_profile': "0"}
if 'loggedin_user_credentials' in request.session:
ctx = request.session['loggedin_user_credentials']
try:
PhotographerObj = Photographer.objects.get(user_ref=request.user)
if len(PhotographerObj.image.all()):
formargs = {'username': request.user.username, 'home_page_desc': PhotographerObj.home_page_desc}
count = 1
for k in PhotographerObj.image.all().order_by('created_date'):
if k.profile_image:
rel_path = os.path.join(os.path.join(FILEBROWSER_DIRECTORY,request.user.username) + '/', k.image.filename)
a = FileObject(rel_path)
version = a.version_generate('thumbnail').url
formargs.update({'profile_image_name': k.image.filename,
'profile_image': version})
name = 'image_' + str(count) + '_desc'
rel_path = os.path.join(os.path.join(FILEBROWSER_DIRECTORY,request.user.username) + '/', k.image.filename)
a = FileObject(rel_path)
version = a.version_generate('thumbnail').url
formargs.update({'image_' + str(count) + '_name': k.image.filename,
'image_' + str(count): version
})
formargs.update({'image_' + str(count) + '_desc': k.image_desc})
count += 1
# formargs.update({'image_1_desc': PhotographerObj.image_1_desc,
# 'image_2_desc': PhotographerObj.image_2_desc,
# 'image_3_desc': PhotographerObj.image_3_desc,
# 'image_4_desc': PhotographerObj.image_4_desc,
# })
formsubmit = self.form_class(formargs)
ctx.update({'upload_form': formsubmit})
ctx.update({'show_profile': "1"})
except Exception as e:
ctx.update({'show_profile': "0"})
pass
ctx.update({'username': request.user.username})
return Response(ctx, template_name=self.template_name)
def view_tinymce_templates(request):
full_path = os.path.join(settings.MEDIA_ROOT, NEWSLETTER_TINYMCE_TEMPLATE_DIR)
tmpl_dir = os.listdir(full_path)
templates = []
for tmpl in tmpl_dir:
fileobject = FileObject(os.path.join(NEWSLETTER_TINYMCE_TEMPLATE_DIR, tmpl))
templates.append('["%s", "%s"]' % (fileobject.filename, fileobject._url_full()))
page = """
var tinyMCETemplateList = [
// Name, URL, Description
%s,
];
""" % ",".join(templates)
return HttpResponse(page, mimetype='text/javascript; charset=utf8')
def test_get(self):
""" Check the detail view and version generation. Check also renaming of files. """
response = self.client.get(self.url, {'dir': self.F_IMAGE.dirname, 'filename': self.F_IMAGE.filename})
self.assertTrue(response.status_code == 200)
# At this moment all versions should be generated. Check that.
pre_rename_versions = []
for version_suffix in VERSIONS:
path = self.F_IMAGE.version_path(version_suffix)
pre_rename_versions.append(path)
self.assertTrue(site.storage.exists(path))
# Attemp renaming the file
url = '?'.join([self.url, urlencode({'dir': self.F_IMAGE.dirname, 'filename': self.F_IMAGE.filename})])
response = self.client.post(url, {'name': 'testpic.jpg'})
# Check we get 302 response for renaming
self.assertTrue(response.status_code == 302)
# Check the file was renamed correctly:
self.assertTrue(site.storage.exists(os.path.join(self.F_IMAGE.head, 'testpic.jpg')))
# Store the renamed file
self.F_IMAGE = FileObject(os.path.join(self.F_IMAGE.head, 'testpic.jpg'), site=site)
# Check if all pre-rename versions were deleted:
for path in pre_rename_versions:
self.assertFalse(site.storage.exists(path))
# Check if all post–rename versions were deleted (resp. not being generated):
for version_suffix in VERSIONS:
path = self.F_IMAGE.version_path(version_suffix)
self.assertFalse(site.storage.exists(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 save_file(self, file):
"""
Little helper to save a file default save to media/temp/
"""
# original_name = file.name
# extension = os.path.splitext(original_name)[1][1:]
# filename = os.path.splitext(original_name)[0].strip('.')
# filename = filename + '__' + str(time.time()) + '.' + extension
# rel_path = os.path.join(TEMP_UPLOAD_DIR, filename)
#Create user directory in temp folder
try:
os.makedirs(os.path.join(MEDIA_ROOT, TEMP_UPLOAD_DIR))
except OSError:
# Do nothing Assume that dir is already created.
pass
try:
userdirpath = os.path.join(os.path.join(MEDIA_ROOT, TEMP_UPLOAD_DIR), self.request.user.username)
os.makedirs(userdirpath)
except OSError:
# Do nothing Assume that dir is already created.
pass
source_dir = os.path.join(MEDIA_ROOT)
destination_dir = os.path.join(source_dir,os.path.join(TEMP_UPLOAD_DIR,self.request.user.username))
ext = '.' + os.path.splitext(file.name)[1][1:]
img_name = file.name.split(ext)[0]
img_name = generate_unique_file_name(destination_dir, img_name, ext)
rel_path = os.path.join(os.path.join(TEMP_UPLOAD_DIR,self.request.user.username) + '/', img_name)
fd = open(os.path.join(MEDIA_ROOT, rel_path), 'wb')
for chunk in file.chunks():
fd.write(chunk)
fd.close()
try:
a = FileObject(rel_path)
version = a.version_generate('thumbnail').url
except Exception as e:
pass
return {'path': MEDIA_URL + rel_path, 'file': img_name, 'name': img_name, 'version': version}
def test_version_attributes_3(self):
"""
FileObject version attributes/methods
with alternative versions_basedir
# is_version
# original
# original_filename
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_generate(suffix)
"""
# new settings
filebrowser.base.VERSIONS_BASEDIR = "_versionstestdirectory"
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']
# expected test results
version_list = ['_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_admin_thumbnail.jpg', '_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg']
admin_version_list = ['_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg']
self.assertEqual(self.f_image.is_version, False)
self.assertEqual(self.f_image.original.path, self.f_image.path)
self.assertEqual(self.f_image.versions_basedir, "_versionstestdirectory")
self.assertEqual(self.f_image.versions(), version_list)
self.assertEqual(self.f_image.admin_versions(), admin_version_list)
self.assertEqual(self.f_image.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.f_image.version_path("large"), "_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.f_image.path)
self.assertEqual(f_version.versions(), [])
self.assertEqual(f_version.admin_versions(), [])
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 set_version_img_url(image, context, version):
if isinstance(image, FileObject):
source = image.path
elif isinstance(image, File):
source = image.name
else: # string
source = image
site = context.get('filebrowser_site', get_default_site())
if getattr(settings, 'FILEBROWSER_FORCE_PLACEHOLDER', None) \
or \
(getattr(settings, 'FILEBROWSER_SHOW_PLACEHOLDER', None) and not site.storage.isfile(source)):
source = settings.FILEBROWSER_PLACEHOLDER
fileobject = FileObject(source, site=site)
try:
version = fileobject.version_generate(version)
image = version.path
except Exception as e:
raise e
return settings.MEDIA_URL + image
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 generate_summary(self, nchars=200):
'''提出摘要, 最终返回以HTML片段. 代表插图 + 前N个文字'''
orig_html = pq(self.html_content)
# 优先提取带有 cover 类的图片作为封面
cover = orig_html('img.cover:first') or orig_html('img:first')
if cover:
try:
# 清楚来自图片上传插件(ckeditor)自动添加的属性
cover.removeAttr('style').removeAttr('width').removeAttr('height')
except KeyError:
pass
cover.addClass('cover')
orig_src = cover.attr('src')
# 如果是本地图片, 则封面img标签使用django-filebrowser生成的缩略图
if orig_src.startswith(settings.MEDIA_URL):
print "更新封面"
relative_path = orig_src.replace(settings.MEDIA_URL, '')
if relative_path.startswith(settings.FILEBROWSER_VERSIONS_BASEDIR):
# 如果已经引用的是FileBrowser生成的小尺寸图片,
# 则试图推导出原图路径, 并根据原图生成缩略图.
relative_path = re.sub(r'^%s' % settings.FILEBROWSER_VERSIONS_BASEDIR,
settings.FILEBROWSER_DIRECTORY, relative_path)
# FileBrowser生成图片的后缀模式:
postfix_pat = '|'.join(['_'+i for i in settings.FILEBROWSER_ADMIN_VERSIONS])
relative_path = re.sub(r'(%s)\.' % postfix_pat, '.', relative_path)
fileobject = FileObject(relative_path)
if fileobject.exists():
fileobject = fileobject.original
thumbnail = fileobject.version_generate('thumbnail')
cover.attr('src', thumbnail.url).attr('data-orig-src', orig_src)
cover.css(height='100px', width='100px')
else:
print u'引用的图片不存在: %s' % fileobject.path
summary_text = cgi.escape(orig_html.text()[:int(nchars)])
return (cover.outerHtml() or "") + \
(u'<span class="summary-text">%s...</span>' % summary_text) + \
(u'<a class="more" href="/%d/">阅读全文→</a>' % self.id) + \
u'<div class="clear"></div>'
def delete(self, 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(self.media_root, query.get("dir", ""))
fileobject = FileObject(
os.path.join(abs_path, query.get("filename", "")), media_root=self.media_root, media_url=self.media_url
)
if request.GET:
try:
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 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_version_attributes_3(self):
"""
FileObject version attributes/methods
with alternative versions_basedir
# is_version
# original
# original_filename
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_generate(suffix)
"""
# new settings
version_list = sorted(['_test/_versions/folder/testimage_{}.jpg'.format(name) for name in VERSIONS.keys()])
admin_version_list = ['_test/_versions/folder/testimage_large.jpg']
self.assertEqual(self.F_IMAGE.is_version, False)
self.assertEqual(self.F_IMAGE.original.path, self.F_IMAGE.path)
self.assertEqual(self.F_IMAGE.versions_basedir, "_test/_versions/")
self.assertEqual(self.F_IMAGE.versions(), version_list)
self.assertEqual(self.F_IMAGE.admin_versions(), admin_version_list)
self.assertEqual(self.F_IMAGE.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.F_IMAGE.version_path("large"), "_test/_versions/folder/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "_test/_versions/folder/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.F_IMAGE.path)
self.assertEqual(f_version.versions(), [])
self.assertEqual(f_version.admin_versions(), [])
def detail(request):
"""
Show detail page for a file.
Rename existing File/Directory (deletes existing Image Versions/Thumbnails).
"""
from filebrowser.forms import ChangeForm
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.method == 'POST':
form = ChangeForm(request.POST, path=abs_path, fileobject=fileobject)
if form.is_valid():
new_name = form.cleaned_data['name']
transpose = form.cleaned_data['transpose']
try:
if transpose:
im = Image.open(fileobject.path)
new_image = im.transpose(int(transpose))
try:
new_image.save(fileobject.path, quality=VERSION_QUALITY, optimize=(os.path.splitext(fileobject.path)[1].lower() != '.gif'))
except IOError:
new_image.save(fileobject.path, quality=VERSION_QUALITY)
fileobject.delete_versions()
messages.add_message(request, messages.SUCCESS, _('Transposing was successful.'))
if new_name != fileobject.filename:
filebrowser_pre_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name)
fileobject.delete_versions()
os.rename(fileobject.path, os.path.join(fileobject.head, new_name))
filebrowser_post_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name)
messages.add_message(request, messages.SUCCESS, _('Renaming was successful.'))
if "_continue" in request.POST:
redirect_url = reverse("fb_detail") + query_helper(query, "filename="+new_name, "filename")
else:
redirect_url = reverse("fb_browse") + query_helper(query, "", "filename")
return HttpResponseRedirect(redirect_url)
except OSError, (errno, strerror):
form.errors['name'] = forms.util.ErrorList([_('Error.')])
def render(self, context):
try:
version_suffix = self.suffix.resolve(context)
source = self.src.resolve(context)
except VariableDoesNotExist:
return ""
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())
fileobject = FileObject(source, site=site)
try:
version = fileobject.version_generate(version_suffix)
return version.url
except Exception, e:
if settings.TEMPLATE_DEBUG:
raise e
def render(self, name, value, attrs=None):
url = urlresolvers.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['url'] = url
final_attrs['directory'] = self.directory
final_attrs['extensions'] = self.extensions
final_attrs['format'] = self.format
final_attrs['ADMIN_THUMBNAIL'] = ADMIN_THUMBNAIL
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 version(self, request):
"""
Version detail.
This just exists in order to select a version with a filebrowser–popup.
"""
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)
return render_to_response(
'filebrowser/version.html',
self._add_each_context(
{
'fileobject': fileobject,
'query': query,
'settings_var': get_settings_var(directory=self.directory),
'filebrowser_site': self
}, request),
context_instance=Context(request, current_app=self.name))
def incorporate(self, filename, path, correctFilename, correctPath, getByPath):
top_level_mime, mime_type = self.guess_type(filename)
if top_level_mime != None:
# sanitize
path = unicode(path, 'utf8')
filename = unicode(filename, 'utf8')
name = self.sanitize_filename(filename)
if correctFilename and filename != name:
filename = self.correct_filename(path, name, filename)
# create
instance, created = self.create_content_object(top_level_mime, mime_type, filename, path, getByPath)
# enforce media/type folder structure
if correctPath:
path = self.correct_path(path, instance, filename)
if created or correctPath:
setattr(instance, instance.media_file_field, FileObject(self.path_name(path, filename)))
instance.save()
# be happy
else:
print ('\t\t skipping UNKNOWN %s' % filename)
def version(self, request):
"""
Version detail.
This just exists in order to select a version with a filebrowser–popup.
"""
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)
request.current_app = self.name
return TemplateResponse(
request, 'filebrowser/version.html',
dict(
admin_site.each_context(request), **{
'fileobject': fileobject,
'query': query,
'settings_var': get_settings_var(directory=self.directory),
'filebrowser_site': self
}))
def render(self, name, value, attrs=None):
if value is None:
value = ""
if value != "" and not isinstance(value, FileObject):
value = FileObject(value)
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
final_attrs['search_icon'] = URL_FILEBROWSER_MEDIA + 'img/multi_filebrowser_icon_show.png'
final_attrs['directory'] = self.directory
final_attrs['extensions'] = self.extensions
final_attrs['format'] = self.format
final_attrs['ADMIN_THUMBNAIL'] = ADMIN_THUMBNAIL
final_attrs['DEBUG'] = DEBUG
final_attrs['thumbs'] = self.value_to_list(value.path)
if value != "":
try:
final_attrs['directory'] = os.path.split(value.path_relative_directory)[0]
except:
pass
return render_to_string("filebrowser/custom_field_multi.html", locals())
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
preview_template = render_to_string('filebrowser/widgets/fileinput.html', {
'value': FileObject(value.name),
'ADMIN_THUMBNAIL': ADMIN_THUMBNAIL,
})
substitutions["preview"] = preview_template
return mark_safe(template % substitutions)
def test_version_attributes_with_options_namer(self):
"""
FileObject version attributes/methods
without versions_basedir
# is_version
# original
# original_filename
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_path(suffix)
# version_generate(suffix)
"""
# new settings
version_list = sorted([
'_test/_versions/folder/testimage_large--680x0.jpg',
'_test/_versions/folder/testimage_small--140x0.jpg',
'_test/_versions/folder/testimage_thumbnail--60x60--opts-crop.jpg'
])
admin_version_list = ['_test/_versions/folder/testimage_large--680x0.jpg']
self.assertEqual(self.F_IMAGE.is_version, False)
self.assertEqual(self.F_IMAGE.original.path, self.F_IMAGE.path)
self.assertEqual(self.F_IMAGE.versions_basedir, "_test/_versions/")
self.assertEqual(self.F_IMAGE.versions(), version_list)
self.assertEqual(self.F_IMAGE.admin_versions(), admin_version_list)
self.assertEqual(self.F_IMAGE.version_name("large"), "testimage_large--680x0.jpg")
self.assertEqual(self.F_IMAGE.version_path("large"), "_test/_versions/folder/testimage_large--680x0.jpg")
# version does not exist yet
f_version = FileObject(os.path.join(site.directory, 'folder', "testimage_large--680x0.jpg"), site=site)
self.assertEqual(f_version.exists, False)
# generate version
f_version = self.F_IMAGE.version_generate("large")
self.assertEqual(f_version.path, "_test/_versions/folder/testimage_large--680x0.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.F_IMAGE.path)
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))
# Check permissions
if DEFAULT_PERMISSIONS is not None:
permissions_default = oct(DEFAULT_PERMISSIONS)
permissions_file = oct(os.stat(test.testfile.path_full).st_mode & 0777)
test.assertTrue(permissions_default == permissions_file)
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 = _check_access(request, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
_check_access(request, abs_path, filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request,
path=request.POST.get('folder'),
file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(
smart_str(
os.path.join(fb_settings.MEDIA_ROOT,
fb_settings.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)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request,
path=request.POST.get('folder'),
file=FileObject(
smart_str(
os.path.join(
fb_settings.DIRECTORY,
folder, filedata.name))))
return HttpResponse('True')
class DetailViewTests(TestCase):
def setUp(self):
super(DetailViewTests, self).setUp()
self.url = reverse('filebrowser:fb_detail')
self.client.login(username=self.user.username, password='******')
shutil.copy(self.STATIC_IMG_PATH, self.FOLDER_PATH)
def test_get(self):
""" Check the detail view and version generation. Check also renaming of files. """
response = self.client.get(self.url, {'dir': self.F_IMAGE.dirname, 'filename': self.F_IMAGE.filename})
self.assertTrue(response.status_code == 200)
# At this moment all versions should be generated. Check that.
pre_rename_versions = []
for version_suffix in VERSIONS:
path = self.F_IMAGE.version_path(version_suffix)
pre_rename_versions.append(path)
self.assertTrue(site.storage.exists(path))
# Attemp renaming the file
url = '?'.join([self.url, urlencode({'dir': self.F_IMAGE.dirname, 'filename': self.F_IMAGE.filename})])
response = self.client.post(url, {'name': 'testpic.jpg'})
# Check we get 302 response for renaming
self.assertTrue(response.status_code == 302)
# Check the file was renamed correctly:
self.assertTrue(site.storage.exists(os.path.join(self.F_IMAGE.head, 'testpic.jpg')))
# Store the renamed file
self.F_IMAGE = FileObject(os.path.join(self.F_IMAGE.head, 'testpic.jpg'), site=site)
# Check if all pre-rename versions were deleted:
for path in pre_rename_versions:
self.assertFalse(site.storage.exists(path))
# Check if all post–rename versions were deleted (resp. not being generated):
for version_suffix in VERSIONS:
path = self.F_IMAGE.version_path(version_suffix)
self.assertFalse(site.storage.exists(path))
def treeview_parser(root=''):
"""
According to the given root, traverse its file tree and return a json object.
:param root:
:return dict:
"""
dataList = []
path = os.path.join(DIRECTORY, root)
filelisting = FileListing(path, sorting_by='date', sorting_order='desc')
for item in filelisting.listing():
fileobject = FileObject(os.path.join(path, item))
if fileobject.is_folder and not fileobject.is_empty:
dataList.append({
"text":
item,
"nodes":
treeview_parser(fileobject.path_relative_directory)
})
else:
dataList.append({"text": item})
return dataList
def render(self, name, value, attrs=None, renderer=None):
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['data-extensions'] = json.dumps(self.extensions)
final_attrs['data-thumbnail_size'] = "{}"
if self.thumbnail:
final_attrs['data-thumbnail'] = self.thumbnail
fb_version = VERSIONS.get(self.thumbnail, None)
if fb_version:
final_attrs['data-thumbnail_size'] = json.dumps(dict(
width=fb_version['width'],
height=fb_version['height']
))
filebrowser_site = self.site
allowed_title = _('Allowed')
return render_to_string("uploadfield/uploadfield_widget.html", locals())
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('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(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 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 = self.filelisting_class(
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
request.current_app = self.name
return TemplateResponse(
request, 'filebrowser/delete_confirm.html',
dict(
admin_site.each_context(request), **{
'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
}))
def test_post(self):
uploaded_path = os.path.join(self.F_SUBFOLDER.path, 'testimage.jpg')
self.assertFalse(site.storage.exists(uploaded_path))
url = '?'.join([
self.url,
urlencode({'folder': self.F_SUBFOLDER.path_relative_directory})
])
with open(self.STATIC_IMG_PATH, "rb") as f:
file_size = os.path.getsize(f.name)
response = self.client.post(url,
data={
'qqfile': 'testimage.jpg',
'file': f
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
# Check we get OK response
self.assertTrue(response.status_code == 200)
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(data["filename"], "testimage.jpg")
self.assertEqual(data["temp_filename"], None)
# Check the file now exists
self.testfile = FileObject(uploaded_path, site=site)
self.assertTrue(site.storage.exists(uploaded_path))
# Check the file has the correct size
self.assertTrue(file_size == site.storage.size(uploaded_path))
# Check permissions
# TODO: break out into separate test
if DEFAULT_PERMISSIONS is not None:
permissions_default = oct(DEFAULT_PERMISSIONS)
permissions_file = oct(
os.stat(self.testfile.path_full).st_mode & 0o777)
self.assertTrue(permissions_default == permissions_file)
def setUpClass(self):
super(QueryTestCase, self).setUpClass()
# Start up celery worker for testing
self.celery_worker = start_worker(app)
self.celery_worker.__enter__()
Organism.objects.create(display_name=display_name,
short_name=short_name,
tax_id=tax_id)
organism = Organism.objects.get(short_name=short_name)
sequence = SequenceType.objects.create(molecule_type='prot',
dataset_type=dataset_type)
prepare_test_fasta_file()
self.files = test_files
BlastDb.objects.create(
fasta_file=FileObject('/blast/db/clec_peptide_example_BLASTdb.fa'),
organism=organism,
type=sequence,
is_shown=False,
title=title)
organism = Organism.objects.get(short_name=short_name)
blastdb = BlastDb.objects.get(organism=organism)
returncode, error, output = blastdb.makeblastdb()
returncode, error, output = blastdb.index_fasta()
blastdb.is_shown = True
blastdb.save()
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)
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_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(directory=self.directory),
'breadcrumbs': get_breadcrumbs(query, query.get('dir', '')),
'breadcrumbs_title': _(u'Confirm delete'),
'site': self
},
context_instance=Context(request, current_app=self.name))
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 test_version_attributes_1(self):
"""
FileObject version attributes/methods
without versions_basedir
# is_version
# original
# original_filename
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_path(suffix)
# version_generate(suffix)
"""
# new settings
version_list = sorted(['_test/_versions/folder/testimage_{}.jpg'.format(name) for name in VERSIONS.keys()])
admin_version_list = ['_test/_versions/folder/testimage_large.jpg']
self.assertEqual(self.F_IMAGE.is_version, False)
self.assertEqual(self.F_IMAGE.original.path, self.F_IMAGE.path)
self.assertEqual(self.F_IMAGE.versions_basedir, "_test/_versions/")
self.assertEqual(self.F_IMAGE.versions(), version_list)
self.assertEqual(self.F_IMAGE.admin_versions(), admin_version_list)
self.assertEqual(self.F_IMAGE.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.F_IMAGE.version_path("large"), "_test/_versions/folder/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "_test/_versions/folder/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.F_IMAGE.path)
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['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 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:
version_path = get_version_path(url_to_path(source), version_prefix)
if not os.path.isfile(smart_str(os.path.join(fb_settings.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(fb_settings.MEDIA_ROOT, url_to_path(source)))) > os.path.getmtime(smart_str(os.path.join(fb_settings.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 treeview_parser(root='', abspath='', flag='C'):
"""
According to the given root, traverse its file tree and return a json object.
:param root:
:param abspath:
:param flag: 'C'-> Complete file tree, 'O'-> file tree used in open project
:return:
"""
dataList = []
path = os.path.join(DIRECTORY, root)
filelisting = FileListing(path, sorting_by='date', sorting_order='desc')
for item in filelisting.listing():
fileobject = FileObject(os.path.join(path, item))
newabspath = os.path.join(abspath, item)
if fileobject.is_folder: # and not fileobject.is_empty:
dataList.append({
"text":
item,
"icon":
"glyphicon glyphicon-folder-close",
# "selectedIcon": "glyphicon glyphicon-folder-open",
"nodes":
treeview_parser(fileobject.path_relative_directory,
newabspath,
flag=flag)
})
elif flag == 'C':
dataList.append({
"text":
item,
"icon":
"glyphicon glyphicon-file",
"href":
reverse('maintest:test') + "?file=" + newabspath
})
return dataList
def setUp(self):
self.DIRECTORY = DIRECTORY
self.TEST_PATH = os.path.join(site.storage.location, '_test')
self.DIRECTORY_PATH = os.path.join(site.storage.location, DIRECTORY)
self.VERSIONS_PATH = os.path.join(site.storage.location,
VERSIONS_BASEDIR)
if os.path.exists(self.TEST_PATH):
raise Exception('TEST_PATH Already Exists')
self.TEMP_PATH = os.path.join(self.TEST_PATH, 'tempfolder')
self.FOLDER_PATH = os.path.join(self.DIRECTORY_PATH, 'folder')
self.SUBFOLDER_PATH = os.path.join(self.FOLDER_PATH, 'subfolder')
self.CREATEFOLDER_PATH = os.path.join(self.DIRECTORY_PATH, 'create')
self.PLACEHOLDER_PATH = os.path.join(self.DIRECTORY_PATH,
'placeholders')
self.STATIC_IMG_PATH = os.path.join(settings.BASE_DIR, 'filebrowser',
"static", "filebrowser", "img",
"testimage.jpg")
self.STATIC_IMG_BAD_NAME_PATH = os.path.join(settings.BASE_DIR,
'filebrowser', "static",
"filebrowser", "img",
"TEST_IMAGE_000.jpg")
self.F_IMAGE = FileObject(os.path.join(DIRECTORY, 'folder',
"testimage.jpg"),
site=site)
self.F_MISSING = FileObject(os.path.join(DIRECTORY, 'folder',
"missing.jpg"),
site=site)
self.F_FOLDER = FileObject(os.path.join(DIRECTORY, 'folder'),
site=site)
self.F_SUBFOLDER = FileObject(os.path.join(DIRECTORY, 'folder',
'subfolder'),
site=site)
self.F_CREATEFOLDER = FileObject(os.path.join(DIRECTORY, 'create'),
site=site)
self.F_TEMPFOLDER = FileObject(os.path.join('_test', 'tempfolder'),
site=site)
os.makedirs(self.FOLDER_PATH)
os.makedirs(self.SUBFOLDER_PATH)
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 detail(request):
"""
Show detail page for a file.
Rename existing File/Directory (deletes existing Image Versions/Thumbnails).
"""
from filebrowser.forms import ChangeForm
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.method == 'POST':
form = ChangeForm(request.POST, path=abs_path, fileobject=fileobject)
if form.is_valid():
new_name = form.cleaned_data['name']
transpose = form.cleaned_data['transpose']
try:
if new_name != fileobject.filename:
filebrowser_pre_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name)
fileobject.delete_versions()
os.rename(fileobject.path, os.path.join(fileobject.head, new_name))
filebrowser_post_rename.send(sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name)
messages.add_message(request, messages.SUCCESS, _('Renaming was successful.'))
if transpose:
im = Image.open(fileobject.path)
new_image = im.transpose(int(transpose))
try:
new_image.save(fileobject.path, quality=VERSION_QUALITY, optimize=(os.path.splitext(fileobject.path)[1].lower() != '.gif'))
except IOError:
new_image.save(fileobject.path, quality=VERSION_QUALITY)
fileobject.delete_versions()
messages.add_message(request, messages.SUCCESS, _('Transposing was successful.'))
if "_continue" in request.POST:
redirect_url = reverse("fb_detail") + query_helper(query, "filename="+new_name, "filename")
else:
redirect_url = reverse("fb_browse") + query_helper(query, "", "filename")
return HttpResponseRedirect(redirect_url)
except OSError, (errno, strerror):
form.errors['name'] = forms.util.ErrorList([_('Error.')])
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
self.stdin = sys.stdin
# DIRECTORY
# custom directory because this could be set with sites
# and we cannot rely on filebrowser.settings
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
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_image_not_exists = FileObject(os.path.join(
self.directory, self.tmpdir_name, "testimage_does_not_exist.jpg"),
site=site)
self.f_folder = FileObject(os.path.join(self.directory,
self.tmpdir_name),
site=site)
def handle(self, *args, **options):
template_set = djangoUserExtension.models.TemplateSet()
template_set.title = 'default_template_set'
template_set.invoiceXSLFile = Command.store_default_template_xsl_file(
"en", "invoice.xsl")
template_set.quoteXSLFile = Command.store_default_template_xsl_file(
"en", "quote.xsl")
template_set.purchaseconfirmationXSLFile = Command.store_default_template_xsl_file(
"en", "purchaseconfirmation.xsl")
template_set.purchaseorderXSLFile = Command.store_default_template_xsl_file(
"en", "purchaseorder.xsl")
template_set.deilveryorderXSLFile = Command.store_default_template_xsl_file(
"en", "deliveryorder.xsl")
if 'apps.accounting' in settings.INSTALLED_APPS:
template_set.profitLossStatementXSLFile = Command.store_default_template_xsl_file(
"en", "profitlossstatement.xsl")
template_set.balancesheetXSLFile = Command.store_default_template_xsl_file(
"en", "balancesheet.xsl")
template_set.logo = FileObject(
Command.path_of_default_template_file("generic", "logo.jpg"))
template_set.fopConfigurationFile = FileObject(
Command.path_of_default_template_file("generic", "fontconfig.xml"))
template_set.bankingaccountref = "xx-xxxxxx-x"
template_set.addresser = _(
"John Smit, Sample Company, 8976 Smallville")
template_set.headerTextsalesorders = _(
"According to your wishes the contract consists of the following positions:"
)
template_set.footerTextsalesorders = _(
"Thank you for your interest in our company \n Best regards")
template_set.headerTextpurchaseorders = _(
"We would like to order the following positions:")
template_set.footerTextpurchaseorders = _("Best regards")
template_set.pagefooterleft = _("Sample Company")
template_set.pagefootermiddle = _("Sample Address")
template_set.save()
currency = crm.models.Currency()
currency.description = "US Dollar"
currency.shortName = "USD"
currency.rounding = "0.10"
currency.save()
user_extension = djangoUserExtension.models.UserExtension()
user_extension.defaultTemplateSet = template_set
user_extension.defaultCurrency = currency
user_extension.user = User.objects.all()[0]
user_extension.save()
postaladdress = djangoUserExtension.models.UserExtensionPostalAddress()
postaladdress.purpose = 'H'
postaladdress.name = "John"
postaladdress.prename = "Smith"
postaladdress.addressline1 = "Ave 1"
postaladdress.zipcode = 899887
postaladdress.town = "Smallville"
postaladdress.userExtension = user_extension
postaladdress.save()
phoneaddress = djangoUserExtension.models.UserExtensionPhoneAddress()
phoneaddress.phone = "1293847"
phoneaddress.purpose = 'H'
phoneaddress.userExtension = user_extension
phoneaddress.save()
emailaddress = djangoUserExtension.models.UserExtensionEmailAddress()
emailaddress.email = "*****@*****.**"
emailaddress.purpose = 'H'
emailaddress.userExtension = user_extension
emailaddress.save()
def store_xsl_file(xsl_file_path):
xsl_file = djangoUserExtension.models.XSLFile()
xsl_file.title = path.basename(xsl_file_path)
xsl_file.xslfile = FileObject(xsl_file_path)
xsl_file.save()
return xsl_file
def to_python(self, value):
if not value or isinstance(value, FileObject):
return value
return FileObject(url_to_path(value))
def _upload_file(self, request):
"""
Upload file to the server.
If temporary is true, we upload to UPLOAD_TEMP_DIR, otherwise
we upload to site.directory
"""
if request.method == "POST":
folder = request.GET.get('folder', '')
temporary = request.GET.get('temporary', '')
temp_filename = None
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)
# temporary upload folder should be outside self.directory
if folder == UPLOAD_TEMPDIR and temporary == "true":
path = folder
else:
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)
# construct temporary filename by adding the upload folder, because
# otherwise we don't have any clue if the file has temporary been
# uploaded or not
if folder == UPLOAD_TEMPDIR and temporary == "true":
temp_filename = os.path.join(folder, file_name)
# 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)
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)
# We don't know at this stage if it's an image
# so attempt to generate an admin thumb and catch the exception
try:
admin_thumbnail_url = f.version_generate(ADMIN_THUMBNAIL).url
except IOError:
admin_thumbnail_url = ''
# Let Ajax Upload know whether we saved it or not
ret_json = {
'success': True,
'filename': f.filename,
'temp_filename': temp_filename,
'url': f.url,
'admin_thumbnail_url': admin_thumbnail_url,
}
return HttpResponse(json.dumps(ret_json), content_type="application/json")
def detail(self, request):
"""
Show detail page for a file.
Rename existing File/Directory (deletes existing Image Versions/Thumbnails).
"""
from filebrowser.forms import ChangeForm
from filebrowser.models import FileDescription
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)
try:
file_description = FileDescription.objects.get(file_path=fileobject)
except:
file_description = FileDescription(file_path=fileobject.path)
if request.method == "POST":
form = ChangeForm(request.POST, path=path, fileobject=fileobject, filebrowser_site=self)
if form.is_valid():
new_name = form.cleaned_data["name"]
action_name = form.cleaned_data["custom_action"]
try:
action_response = None
if action_name:
action = self.get_action(action_name)
# Pre-action signal
signals.filebrowser_actions_pre_apply.send(
sender=request, action_name=action_name, fileobject=[fileobject], site=self
)
# Call the action to action
action_response = action(request=request, fileobjects=[fileobject])
# Post-action signal
signals.filebrowser_actions_post_apply.send(
sender=request,
action_name=action_name,
fileobject=[fileobject],
result=action_response,
site=self,
)
new_file_description = form.save(commit=False)
new_file_description.file_path = fileobject.path
new_file_description.pk = file_description.pk
if new_name != fileobject.filename:
signals.filebrowser_pre_rename.send(
sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name, site=self
)
fileobject.delete_versions()
new_path = os.path.join(fileobject.head, new_name)
self.storage.move(fileobject.path, os.path.join(fileobject.head, new_name))
if new_file_description:
new_file_description.file_path = new_path
signals.filebrowser_post_rename.send(
sender=request, path=fileobject.path, name=fileobject.filename, new_name=new_name, site=self
)
if fileobject.filetype == "Folder":
for fd in FileDescription.objects.filter(file_path__startswith=fileobject.path):
fd.file_path = new_path + fd.file_path.path[len(fileobject.path) :]
fd.save()
messages.add_message(request, messages.SUCCESS, _("Renaming was successful."))
new_file_description.save()
if isinstance(action_response, HttpResponse):
return action_response
if "_continue" in request.POST:
redirect_url = reverse("filebrowser:fb_detail", current_app=self.name) + query_helper(
query, "filename=" + new_name, "filename"
)
else:
redirect_url = reverse("filebrowser:fb_browse", current_app=self.name) + query_helper(
query, "", "filename"
)
return HttpResponseRedirect(redirect_url)
except OSError:
form.errors["name"] = forms.util.ErrorList([_("Error.")])
else:
form = ChangeForm(
initial=dict(name=fileobject.filename, **file_description.__dict__),
path=path,
fileobject=fileobject,
filebrowser_site=self,
instance=file_description,
)
return render_to_response(
"filebrowser/detail.html",
{
"form": form,
"fileobject": fileobject,
"query": query,
"title": u"%s" % fileobject.filename,
"settings_var": get_settings_var(directory=self.directory),
"breadcrumbs": get_breadcrumbs(query, query.get("dir", "")),
"breadcrumbs_title": u"%s" % fileobject.filename,
"filebrowser_site": self,
},
context_instance=Context(request, current_app=self.name),
)
def _upload_file(self, request):
"""
Upload file to the server.
If temporary is true, we upload to UPLOAD_TEMPDIR, otherwise
we upload to site.directory
"""
if request.method == "POST":
folder = request.GET.get('folder', '')
temporary = request.GET.get('temporary', '')
temp_filename = None
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)
# temporary upload folder should be outside self.directory
if folder == UPLOAD_TEMPDIR and temporary == "true":
path = folder
else:
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)
# construct temporary filename by adding the upload folder, because
# otherwise we don't have any clue if the file has temporary been
# uploaded or not
if folder == UPLOAD_TEMPDIR and temporary == "true":
temp_filename = os.path.join(folder, file_name)
# 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)
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,
'temp_filename': temp_filename,
'url': f.url,
}
return HttpResponse(json.dumps(ret_json), content_type="application/json")
class FileObjectAttributeTests(TestCase):
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_init_attributes(self):
"""
FileObject init attributes
# path
# head
# filename
# filename_lower
# filename_root
# extension
# mimetype
"""
self.assertEqual(self.f_image.path, "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage.jpg")
self.assertEqual(self.f_image.head, 'fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub')
self.assertEqual(self.f_image.filename, 'testimage.jpg')
self.assertEqual(self.f_image.filename_lower, 'testimage.jpg')
self.assertEqual(self.f_image.filename_root, 'testimage')
self.assertEqual(self.f_image.extension, '.jpg')
self.assertEqual(self.f_image.mimetype, ('image/jpeg', None))
def test_general_attributes(self):
"""
FileObject general attributes
# filetype
# filesize
# date
# datetime
# exists
"""
self.assertEqual(self.f_image.filetype, 'Image')
self.assertEqual(self.f_image.filesize, 870037)
# FIXME: test date/datetime
self.assertEqual(self.f_image.exists, True)
def test_path_url_attributes(self):
"""
FileObject path and url attributes
# path (see init)
# path_relative_directory
# path_full
# dirname
# url
"""
self.assertEqual(self.f_image.path, "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage.jpg")
self.assertEqual(self.f_image.path_relative_directory, "fb_tmp_dir/fb_tmp_dir_sub/testimage.jpg")
self.assertEqual(self.f_image.path_full, os.path.join(site.storage.location, site.directory, "fb_tmp_dir/fb_tmp_dir_sub/testimage.jpg"))
self.assertEqual(self.f_image.dirname, "fb_tmp_dir/fb_tmp_dir_sub")
self.assertEqual(self.f_image.url, site.storage.url(self.f_image.path))
def test_image_attributes(self):
"""
FileObject image attributes
# dimensions
# width
# height
# aspectratio
# orientation
"""
self.assertEqual(self.f_image.dimensions, (1000, 750))
self.assertEqual(self.f_image.width, 1000)
self.assertEqual(self.f_image.height, 750)
self.assertEqual(self.f_image.aspectratio, 1.3333333333333333)
self.assertEqual(self.f_image.orientation, 'Landscape')
def test_folder_attributes(self):
"""
FileObject folder attributes
# directory
# folder
# is_folder
# is_empty
"""
# test with image
self.assertEqual(self.f_image.directory, "fb_tmp_dir/fb_tmp_dir_sub/testimage.jpg")
self.assertEqual(self.f_image.folder, "fb_tmp_dir/fb_tmp_dir_sub") # FIXME: equals dirname?
self.assertEqual(self.f_image.is_folder, False)
self.assertEqual(self.f_image.is_empty, False)
# test with actual folder
self.assertEqual(self.f_folder.directory, "fb_tmp_dir/fb_tmp_dir_sub")
self.assertEqual(self.f_folder.folder, "fb_tmp_dir") # FIXME: equals dirname?
self.assertEqual(self.f_folder.is_folder, True)
self.assertEqual(self.f_folder.is_empty, False)
def test_version_attributes_1(self):
"""
FileObject version attributes/methods
without versions_basedir
# is_version
# original
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_path(suffix)
# version_generate(suffix)
"""
# 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']
# expected test results
version_list = ['fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg', 'fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_admin_thumbnail.jpg']
admin_version_list = ['fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg']
self.assertEqual(self.f_image.is_version, False)
self.assertEqual(self.f_image.original.path, self.f_image.path)
self.assertEqual(self.f_image.versions_basedir, "fb_test_directory/")
self.assertEqual(self.f_image.versions(), version_list)
self.assertEqual(self.f_image.admin_versions(), admin_version_list)
self.assertEqual(self.f_image.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.f_image.version_path("large"), "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "fb_test_directory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.f_image.path)
# FIXME: versions should not have versions or admin_versions
def test_version_attributes_2(self):
"""
FileObject version attributes/methods
with versions_basedir
# is_version
# original
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_generate(suffix)
"""
# new settings
filebrowser.base.VERSIONS_BASEDIR = "fb_test_directory/_versions"
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']
# expected test results
version_list = ['fb_test_directory/_versions/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg', 'fb_test_directory/_versions/fb_tmp_dir/fb_tmp_dir_sub/testimage_admin_thumbnail.jpg']
admin_version_list = ['fb_test_directory/_versions/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg']
self.assertEqual(self.f_image.is_version, False)
self.assertEqual(self.f_image.original.path, self.f_image.path)
self.assertEqual(self.f_image.versions_basedir, "fb_test_directory/_versions")
self.assertEqual(self.f_image.versions(), version_list)
self.assertEqual(self.f_image.admin_versions(), admin_version_list)
self.assertEqual(self.f_image.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.f_image.version_path("large"), "fb_test_directory/_versions/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "fb_test_directory/_versions/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.f_image.path)
# FIXME: versions should not have versions or admin_versions
def test_version_attributes_3(self):
"""
FileObject version attributes/methods
with alternative versions_basedir
# is_version
# original
# versions_basedir
# versions
# admin_versions
# version_name(suffix)
# version_generate(suffix)
"""
# new settings
filebrowser.base.VERSIONS_BASEDIR = "_versionstestdirectory"
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']
# expected test results
version_list = ['_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg', '_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_admin_thumbnail.jpg']
admin_version_list = ['_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg']
self.assertEqual(self.f_image.is_version, False)
self.assertEqual(self.f_image.original.path, self.f_image.path)
self.assertEqual(self.f_image.versions_basedir, "_versionstestdirectory")
self.assertEqual(self.f_image.versions(), version_list)
self.assertEqual(self.f_image.admin_versions(), admin_version_list)
self.assertEqual(self.f_image.version_name("large"), "testimage_large.jpg")
self.assertEqual(self.f_image.version_path("large"), "_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
# 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")
self.assertEqual(f_version.path, "_versionstestdirectory/fb_tmp_dir/fb_tmp_dir_sub/testimage_large.jpg")
self.assertEqual(f_version.exists, True)
self.assertEqual(f_version.is_version, True)
self.assertEqual(f_version.original_filename, "testimage.jpg")
self.assertEqual(f_version.original.path, self.f_image.path)
# FIXME: versions should not have versions or admin_versions
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 tearDown(self):
"""
Restore original values/functions
"""
filebrowser.base.os.path = self.original_path
site.directory = self.original_directory
filebrowser.base.VERSIONS_BASEDIR = self.original_versions_basedir
filebrowser.base.VERSIONS = self.original_versions
filebrowser.base.ADMIN_VERSIONS = self.original_admin_versions
# remove temporary directory and test folder
shutil.rmtree(self.directory_path)
shutil.rmtree(self.versions_path)
