class AbstractDocument(CollectionMember, index.Indexed, models.Model):
title = models.CharField(max_length=255, verbose_name=_('title'))
file = models.FileField(upload_to='documents', verbose_name=_('file'))
created_at = models.DateTimeField(verbose_name=_('created at'), auto_now_add=True)
uploaded_by_user = models.ForeignKey(
settings.AUTH_USER_MODEL,
verbose_name=_('uploaded by user'),
null=True,
blank=True,
editable=False,
on_delete=models.SET_NULL
)
tags = TaggableManager(help_text=None, blank=True, verbose_name=_('tags'))
objects = DocumentQuerySet.as_manager()
search_fields = SearchFieldsShouldBeAList(CollectionMember.search_fields + [
index.SearchField('title', partial_match=True, boost=10),
index.RelatedFields('tags', [
index.SearchField('name', partial_match=True, boost=10),
]),
index.FilterField('uploaded_by_user'),
], name='search_fields on AbstractDocument subclasses')
def __str__(self):
return self.title
@property
def filename(self):
return os.path.basename(self.file.name)
@property
def file_extension(self):
return os.path.splitext(self.filename)[1][1:]
@property
def url(self):
return reverse('wagtaildocs_serve', args=[self.id, self.filename])
def get_usage(self):
return get_object_usage(self)
@property
def usage_url(self):
return reverse('wagtaildocs:document_usage',
args=(self.id,))
def is_editable_by_user(self, user):
from wagtail.wagtaildocs.permissions import permission_policy
return permission_policy.user_has_permission_for_instance(user, 'change', self)
class Meta:
abstract = True
verbose_name = _('document')
def test_add_a_list(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
base = SearchFieldsShouldBeAList(['hello'])
result = base + ['world']
# Ensure that adding things together works
self.assertEqual(result, ['hello', 'world'])
# Ensure that a new SearchFieldsShouldBeAList was returned
self.assertIsInstance(result, SearchFieldsShouldBeAList)
# Check that no deprecation warnings were raised
self.assertEqual(len(w), 0)
def test_add_a_tuple(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
base = SearchFieldsShouldBeAList(['hello'])
result = base + ('world', )
# Ensure that adding things together works
self.assertEqual(result, ['hello', 'world'])
# Ensure that a new SearchFieldsShouldBeAList was returned
self.assertIsInstance(result, SearchFieldsShouldBeAList)
# Check that a deprecation warning was raised
self.assertEqual(len(w), 1)
warning = w[0]
self.assertIs(warning.category, RemovedInWagtail17Warning)
class TagSearchable(index.Indexed):
"""
Mixin to provide a 'search' method, searching on the 'title' field and tags,
for models that provide those things.
"""
search_fields = SearchFieldsShouldBeAList([
index.SearchField('title', partial_match=True, boost=10),
index.RelatedFields('tags', [
index.SearchField('name', partial_match=True, boost=10),
]),
], name='search_fields on TagSearchable subclasses')
@classmethod
def popular_tags(cls):
content_type = ContentType.objects.get_for_model(cls)
return Tag.objects.filter(
taggit_taggeditem_items__content_type=content_type
).annotate(
item_count=Count('taggit_taggeditem_items')
).order_by('-item_count')[:10]
class Indexed(object):
@classmethod
def indexed_get_parent(cls, require_model=True):
for base in cls.__bases__:
if issubclass(base, Indexed) and (issubclass(base, models.Model)
or require_model is False):
return base
@classmethod
def indexed_get_content_type(cls):
# Work out content type
content_type = (cls._meta.app_label + '_' + cls.__name__).lower()
# Get parent content type
parent = cls.indexed_get_parent()
if parent:
parent_content_type = parent.indexed_get_content_type()
return parent_content_type + '_' + content_type
else:
return content_type
@classmethod
def indexed_get_toplevel_content_type(cls):
# Get parent content type
parent = cls.indexed_get_parent()
if parent:
return parent.indexed_get_content_type()
else:
# At toplevel, return this content type
return (cls._meta.app_label + '_' + cls.__name__).lower()
@classmethod
def get_search_fields(cls):
search_fields = {}
for field in cls.search_fields:
search_fields[(type(field), field.field_name)] = field
return list(search_fields.values())
@classmethod
def get_searchable_search_fields(cls):
return [
field for field in cls.get_search_fields()
if isinstance(field, SearchField)
]
@classmethod
def get_filterable_search_fields(cls):
return [
field for field in cls.get_search_fields()
if isinstance(field, FilterField)
]
@classmethod
def get_indexed_objects(cls):
queryset = cls.objects.all()
# Add prefetch/select related for RelatedFields
for field in cls.get_search_fields():
if isinstance(field, RelatedFields):
queryset = field.select_on_queryset(queryset)
return queryset
def get_indexed_instance(self):
"""
If the indexed model uses multi table inheritance, override this method
to return the instance in its most specific class so it reindexes properly.
"""
return self
search_fields = SearchFieldsShouldBeAList(
[], name='search_fields on Indexed subclasses')
class AbstractImage(CollectionMember, index.Indexed, models.Model):
title = models.CharField(max_length=255, verbose_name=_('title'))
file = models.ImageField(verbose_name=_('file'),
upload_to=get_upload_to,
width_field='width',
height_field='height')
width = models.IntegerField(verbose_name=_('width'), editable=False)
height = models.IntegerField(verbose_name=_('height'), editable=False)
created_at = models.DateTimeField(verbose_name=_('created at'),
auto_now_add=True,
db_index=True)
uploaded_by_user = models.ForeignKey(settings.AUTH_USER_MODEL,
verbose_name=_('uploaded by user'),
null=True,
blank=True,
editable=False,
on_delete=models.SET_NULL)
tags = TaggableManager(help_text=None, blank=True, verbose_name=_('tags'))
focal_point_x = models.PositiveIntegerField(null=True, blank=True)
focal_point_y = models.PositiveIntegerField(null=True, blank=True)
focal_point_width = models.PositiveIntegerField(null=True, blank=True)
focal_point_height = models.PositiveIntegerField(null=True, blank=True)
file_size = models.PositiveIntegerField(null=True, editable=False)
objects = ImageQuerySet.as_manager()
def is_stored_locally(self):
"""
Returns True if the image is hosted on the local filesystem
"""
try:
self.file.path
return True
except NotImplementedError:
return False
def get_file_size(self):
if self.file_size is None:
try:
self.file_size = self.file.size
except OSError:
# File doesn't exist
return
self.save(update_fields=['file_size'])
return self.file_size
def get_upload_to(self, filename):
folder_name = 'original_images'
filename = self.file.field.storage.get_valid_name(filename)
# do a unidecode in the filename and then
# replace non-ascii characters in filename with _ , to sidestep issues with filesystem encoding
filename = "".join(
(i if ord(i) < 128 else '_') for i in unidecode(filename))
# Truncate filename so it fits in the 100 character limit
# https://code.djangoproject.com/ticket/9893
while len(os.path.join(folder_name, filename)) >= 95:
prefix, dot, extension = filename.rpartition('.')
filename = prefix[:-1] + dot + extension
return os.path.join(folder_name, filename)
def get_usage(self):
return get_object_usage(self)
@property
def usage_url(self):
return reverse('wagtailimages:image_usage', args=(self.id, ))
search_fields = SearchFieldsShouldBeAList(
CollectionMember.search_fields + [
index.SearchField('title', partial_match=True, boost=10),
index.RelatedFields('tags', [
index.SearchField('name', partial_match=True, boost=10),
]),
index.FilterField('uploaded_by_user'),
],
name='search_fields on AbstractImage subclasses')
def __str__(self):
return self.title
@contextmanager
def get_willow_image(self):
# Open file if it is closed
close_file = False
try:
image_file = self.file
if self.file.closed:
# Reopen the file
if self.is_stored_locally():
self.file.open('rb')
else:
# Some external storage backends don't allow reopening
# the file. Get a fresh file instance. #1397
storage = self._meta.get_field('file').storage
image_file = storage.open(self.file.name, 'rb')
close_file = True
except IOError as e:
# re-throw this as a SourceImageIOError so that calling code can distinguish
# these from IOErrors elsewhere in the process
raise SourceImageIOError(text_type(e))
# Seek to beginning
image_file.seek(0)
try:
yield WillowImage.open(image_file)
finally:
if close_file:
image_file.close()
def get_rect(self):
return Rect(0, 0, self.width, self.height)
def get_focal_point(self):
if self.focal_point_x is not None and \
self.focal_point_y is not None and \
self.focal_point_width is not None and \
self.focal_point_height is not None:
return Rect.from_point(
self.focal_point_x,
self.focal_point_y,
self.focal_point_width,
self.focal_point_height,
)
def has_focal_point(self):
return self.get_focal_point() is not None
def set_focal_point(self, rect):
if rect is not None:
self.focal_point_x = rect.centroid_x
self.focal_point_y = rect.centroid_y
self.focal_point_width = rect.width
self.focal_point_height = rect.height
else:
self.focal_point_x = None
self.focal_point_y = None
self.focal_point_width = None
self.focal_point_height = None
def get_suggested_focal_point(self):
with self.get_willow_image() as willow:
faces = willow.detect_faces()
if faces:
# Create a bounding box around all faces
left = min(face[0] for face in faces)
top = min(face[1] for face in faces)
right = max(face[2] for face in faces)
bottom = max(face[3] for face in faces)
focal_point = Rect(left, top, right, bottom)
else:
features = willow.detect_features()
if features:
# Create a bounding box around all features
left = min(feature[0] for feature in features)
top = min(feature[1] for feature in features)
right = max(feature[0] for feature in features)
bottom = max(feature[1] for feature in features)
focal_point = Rect(left, top, right, bottom)
else:
return None
# Add 20% to width and height and give it a minimum size
x, y = focal_point.centroid
width, height = focal_point.size
width *= 1.20
height *= 1.20
width = max(width, 100)
height = max(height, 100)
return Rect.from_point(x, y, width, height)
@classmethod
def get_rendition_model(cls):
""" Get the Rendition model for this Image model """
if django.VERSION >= (1, 9):
return cls.renditions.rel.related_model
else:
return cls.renditions.related.related_model
def get_rendition(self, filter):
if isinstance(filter, string_types):
filter, created = Filter.objects.get_or_create(spec=filter)
cache_key = filter.get_cache_key(self)
Rendition = self.get_rendition_model()
try:
rendition = self.renditions.get(
filter=filter,
focal_point_key=cache_key,
)
except Rendition.DoesNotExist:
# Generate the rendition image
generated_image = filter.run(self, BytesIO())
# Generate filename
input_filename = os.path.basename(self.file.name)
input_filename_without_extension, input_extension = os.path.splitext(
input_filename)
# A mapping of image formats to extensions
FORMAT_EXTENSIONS = {
'jpeg': '.jpg',
'png': '.png',
'gif': '.gif',
}
output_extension = filter.spec.replace(
'|', '.') + FORMAT_EXTENSIONS[generated_image.format_name]
if cache_key:
output_extension = cache_key + '.' + output_extension
# Truncate filename to prevent it going over 60 chars
output_filename_without_extension = input_filename_without_extension[:(
59 - len(output_extension))]
output_filename = output_filename_without_extension + '.' + output_extension
rendition, created = self.renditions.get_or_create(
filter=filter,
focal_point_key=cache_key,
defaults={
'file': File(generated_image.f, name=output_filename)
})
return rendition
def is_portrait(self):
return (self.width < self.height)
def is_landscape(self):
return (self.height < self.width)
@property
def filename(self):
return os.path.basename(self.file.name)
@property
def default_alt_text(self):
# by default the alt text field (used in rich text insertion) is populated
# from the title. Subclasses might provide a separate alt field, and
# override this
return self.title
def is_editable_by_user(self, user):
from wagtail.wagtailimages.permissions import permission_policy
return permission_policy.user_has_permission_for_instance(
user, 'change', self)
class Meta:
abstract = True
class Indexed(object):
@classmethod
def indexed_get_parent(cls, require_model=True):
for base in cls.__bases__:
if issubclass(base, Indexed) and (issubclass(base, models.Model)
or require_model is False):
return base
@classmethod
def indexed_get_content_type(cls):
# Work out content type
content_type = (cls._meta.app_label + '_' + cls.__name__).lower()
# Get parent content type
parent = cls.indexed_get_parent()
if parent:
parent_content_type = parent.indexed_get_content_type()
return parent_content_type + '_' + content_type
else:
return content_type
@classmethod
def indexed_get_toplevel_content_type(cls):
# Get parent content type
parent = cls.indexed_get_parent()
if parent:
return parent.indexed_get_content_type()
else:
# At toplevel, return this content type
return (cls._meta.app_label + '_' + cls.__name__).lower()
@classmethod
def get_search_fields(cls):
search_fields = {}
for field in cls.search_fields:
search_fields[(type(field), field.field_name)] = field
return list(search_fields.values())
@classmethod
def get_searchable_search_fields(cls):
return [
field for field in cls.get_search_fields()
if isinstance(field, SearchField)
]
@classmethod
def get_filterable_search_fields(cls):
return [
field for field in cls.get_search_fields()
if isinstance(field, FilterField)
]
@classmethod
def get_indexed_objects(cls):
queryset = cls.objects.all()
# Add prefetch/select related for RelatedFields
for field in cls.get_search_fields():
if isinstance(field, RelatedFields):
queryset = field.select_on_queryset(queryset)
return queryset
def get_indexed_instance(self):
"""
If the indexed model uses multi table inheritance, override this method
to return the instance in its most specific class so it reindexes properly.
"""
return self
@classmethod
def _has_field(cls, name):
try:
cls._meta.get_field(name)
return True
except models.fields.FieldDoesNotExist:
return hasattr(cls, name)
@classmethod
def check(cls, **kwargs):
errors = super(Indexed, cls).check(**kwargs)
errors.extend(cls._check_search_fields(**kwargs))
return errors
@classmethod
def _check_search_fields(cls, **kwargs):
errors = []
for field in cls.get_search_fields():
message = "{model}.search_fields contains field '{name}' but it doesn't exist"
if not cls._has_field(field.field_name):
errors.append(
checks.Warning(
message.format(model=cls.__name__,
name=field.field_name),
obj=cls,
))
return errors
search_fields = SearchFieldsShouldBeAList(
[], name='search_fields on Indexed subclasses')