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 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 get_thumb(image):
"""вернуть миниатюру ***ADMIN***"""
from django.conf import settings
if image:
fileobject = FileObject(os.path.join(site.directory, '', image.name))
link = '{}{}'.format(settings.MEDIA_URL,
fileobject.version_path("admin_thumbnail"))
return mark_safe('<img src="{}">'.format(link))
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))
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))
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)
