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 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 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 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 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 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 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 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 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 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 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 image_thumbnail(self, obj):
image = obj.content_object.image
if image:
fb_image = FileObject(image.path)
if fb_image.filetype == 'Image':
url = image.url.rsplit('/',
1)[0] + '/' + fb_image.version_generate(
ADMIN_THUMBNAIL).filename
return '<img src="%s" />' % url
else:
return '(None)'
def add_root_elements(self, handler):
super(iTunesFeed, self).add_root_elements(handler)
image_file = FileObject(self.programme.photo.name,
site=get_default_site())
image_url = self.request.build_absolute_uri(
image_file.version_generate('rss_image').url)
itunes_image_url = self.request.build_absolute_uri(
image_file.version_generate('itunes_image').url)
handler.addQuickElement('itunes:explicit', 'clean')
handler.addQuickElement('itunes:summary', self.programme.synopsis_text)
handler.addQuickElement('itunes:image', '', {'href': itunes_image_url})
if self.programme.category:
handler.addQuickElement('itunes:category', '',
{'text': self.programme.category})
handler.addQuickElement(
'image', '', {
'url':
image_url,
'title':
self.programme.name,
'link':
self.request.build_absolute_uri(
self.programme.get_absolute_url()),
})
def preview(request):
if not request.is_ajax():
raise PermissionDenied
file = request.GET.get('file')
obj = FileObject(file) if file else ""
thumbnail_name = request.GET.get('thumbnail_name', THUMBNAIL)
return JsonResponse(
dict(filename=obj.filename,
url=obj.url,
filetype=obj.filetype,
filesize=filesizeformat(obj.filesize),
thumbnail=obj.version_generate(thumbnail_name).url
if obj.filetype == 'Image' else None))
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 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 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 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 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, 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 _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 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)
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)
