forked from rc/aircox
565 lines
16 KiB
Python
565 lines
16 KiB
Python
import datetime
|
|
import re
|
|
from enum import Enum, IntEnum
|
|
|
|
|
|
from django.db import models
|
|
from django.utils.translation import ugettext as _, ugettext_lazy
|
|
from django.utils import timezone as tz
|
|
from django.template.loader import render_to_string
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
|
|
|
|
from wagtail.wagtailcore.models import Page, Orderable
|
|
from wagtail.wagtailcore.fields import RichTextField
|
|
from wagtail.wagtailimages.edit_handlers import ImageChooserPanel
|
|
from wagtail.wagtailadmin.edit_handlers import FieldPanel, FieldRowPanel, \
|
|
MultiFieldPanel, InlinePanel, PageChooserPanel, StreamFieldPanel
|
|
from wagtail.wagtailsearch import index
|
|
|
|
from wagtail.wagtailcore.utils import camelcase_to_underscore
|
|
|
|
# snippets
|
|
from wagtail.wagtailsnippets.edit_handlers import SnippetChooserPanel
|
|
from wagtail.wagtailsnippets.models import register_snippet
|
|
|
|
# tags
|
|
from modelcluster.models import ClusterableModel
|
|
from modelcluster.fields import ParentalKey
|
|
from modelcluster.tags import ClusterTaggableManager
|
|
from taggit.models import TaggedItemBase
|
|
|
|
|
|
def related_pages_filter():
|
|
"""
|
|
Return a dict that can be used to filter foreignkey to pages'
|
|
subtype declared in aircox.cms.models.
|
|
|
|
Note: the filter is calculated at the first call of the function.
|
|
"""
|
|
if hasattr(related_pages_filter, 'filter'):
|
|
return related_pages_filter.filter
|
|
|
|
import aircox.cms.models as cms
|
|
import inspect
|
|
related_pages_filter.filter = {
|
|
'model__in': (name.lower() for name, member in
|
|
inspect.getmembers(cms,
|
|
lambda x: inspect.isclass(x) and issubclass(x, Page)
|
|
)
|
|
if member != Page
|
|
),
|
|
}
|
|
return related_pages_filter.filter
|
|
|
|
|
|
class ListItem:
|
|
"""
|
|
Generic normalized element to add item in lists that are not based
|
|
on Publication.
|
|
"""
|
|
title = ''
|
|
summary = ''
|
|
url = ''
|
|
cover = None
|
|
date = None
|
|
|
|
def __init__(self, **kwargs):
|
|
self.__dict__.update(kwargs)
|
|
self.specific = self
|
|
|
|
|
|
#
|
|
# Base
|
|
#
|
|
class RelatedLinkBase(Orderable):
|
|
url = models.URLField(
|
|
_('url'),
|
|
null=True, blank=True,
|
|
help_text = _('URL of the link'),
|
|
)
|
|
page = models.ForeignKey(
|
|
'wagtailcore.Page',
|
|
null=True,
|
|
blank=True,
|
|
on_delete=models.SET_NULL,
|
|
related_name='+',
|
|
help_text = _('Use a page instead of a URL')
|
|
)
|
|
icon = models.ForeignKey(
|
|
'wagtailimages.Image',
|
|
verbose_name = _('icon'),
|
|
null=True, blank=True,
|
|
on_delete=models.SET_NULL,
|
|
related_name='+',
|
|
help_text = _('icon to display before the url'),
|
|
)
|
|
text = models.CharField(
|
|
_('text'),
|
|
max_length = 64,
|
|
null = True, blank=True,
|
|
help_text = _('text to display of the link'),
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
panels = [
|
|
MultiFieldPanel([
|
|
FieldPanel('text'),
|
|
ImageChooserPanel('icon'),
|
|
FieldPanel('url'),
|
|
PageChooserPanel('page'),
|
|
], heading=_('link'))
|
|
]
|
|
|
|
|
|
class ListBase(models.Model):
|
|
"""
|
|
Generic list
|
|
"""
|
|
class DateFilter(IntEnum):
|
|
none = 0x00
|
|
previous = 0x01
|
|
next = 0x02
|
|
before_related = 0x03,
|
|
after_related = 0x04,
|
|
|
|
filter_date = models.SmallIntegerField(
|
|
verbose_name = _('filter by date'),
|
|
choices = [ (int(y), _(x.replace('_', ' ')))
|
|
for x,y in DateFilter.__members__.items() ],
|
|
blank = True, null = True,
|
|
)
|
|
filter_model = models.ForeignKey(
|
|
ContentType,
|
|
verbose_name = _('filter by type'),
|
|
blank = True, null = True,
|
|
help_text = _('if set, select only elements that are of this type'),
|
|
limit_choices_to = related_pages_filter,
|
|
)
|
|
filter_related = models.ForeignKey(
|
|
'Publication',
|
|
verbose_name = _('filter by a related publication'),
|
|
blank = True, null = True,
|
|
help_text = _('if set, select children or siblings of this publication'),
|
|
)
|
|
related_sibling = models.BooleanField(
|
|
verbose_name = _('related is a sibling'),
|
|
default = False,
|
|
help_text = _('if selected select related publications that are '
|
|
'siblings of this one'),
|
|
)
|
|
sort_asc = models.BooleanField(
|
|
verbose_name = _('order ascending'),
|
|
default = True,
|
|
help_text = _('if selected sort list in the ascending order by date')
|
|
)
|
|
|
|
panels = [
|
|
MultiFieldPanel([
|
|
FieldPanel('filter_model'),
|
|
FieldPanel('filter_related'),
|
|
FieldPanel('related_sibling'),
|
|
], heading=_('filters')),
|
|
MultiFieldPanel([
|
|
FieldPanel('filter_date'),
|
|
FieldPanel('sort_asc'),
|
|
], heading=_('sorting'))
|
|
]
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
@classmethod
|
|
def get_base_queryset(cl, filter_date = None, filter_model = None,
|
|
filter_related = None, related_siblings = None,
|
|
sort_asc = True):
|
|
"""
|
|
Get queryset based on the arguments. This class is intended to be
|
|
reusable by other classes if needed.
|
|
"""
|
|
# model
|
|
if filter_model:
|
|
qs = filter_model.objects.all()
|
|
else:
|
|
qs = Publication.objects.all()
|
|
qs = qs.live().not_in_section()
|
|
|
|
# related
|
|
if filter_related:
|
|
if related_siblings:
|
|
qs = qs.sibling_of(filter_related)
|
|
else:
|
|
qs = qs.descendant_of(filter_related)
|
|
|
|
date = filter_related.date
|
|
if filter_date == cl.DateFilter.before_related:
|
|
qs = qs.filter(date__lt = date)
|
|
elif filter_date == cl.DateFilter.after_related:
|
|
qs = qs.filter(date__gte = date)
|
|
# date
|
|
else:
|
|
date = tz.now()
|
|
if filter_date == cl.DateFilter.previous:
|
|
qs = qs.filter(date__lt = date)
|
|
elif filter_date == cl.DateFilter.next:
|
|
qs = qs.filter(date__gte = date)
|
|
|
|
# sort
|
|
if sort_asc:
|
|
return qs.order_by('date', 'pk')
|
|
return qs.order_by('-date', '-pk')
|
|
|
|
@classmethod
|
|
def get_queryset_from_request(cl, request, *args,
|
|
related = None, context = {},
|
|
**kwargs):
|
|
"""
|
|
Return a queryset from the request's GET parameters. Context
|
|
can be used to update relative informations.
|
|
|
|
This function can be used by other views if needed
|
|
|
|
Parameters:
|
|
* model: ['program','diffusion','event'] type of the publication
|
|
* asc: if present, sort ascending instead of descending
|
|
* related: children of the thread passed in arguments only
|
|
* siblings: sibling of the related instead of children
|
|
* tag: tag to search for
|
|
* search: query to search in the publications
|
|
* page: page number
|
|
|
|
Context's fields:
|
|
* object_list: the final queryset
|
|
* list_selector: dict of { 'tag_query', 'search_query' } plus
|
|
arguments passed to ListBase.get_base_queryset
|
|
* paginator: paginator object
|
|
"""
|
|
model = request.GET.get('model')
|
|
|
|
kwargs = {
|
|
'filter_model': ProgramPage if model == 'program' else \
|
|
DiffusionPage if model == 'diffusion' else \
|
|
EventPage if model == 'event' else None,
|
|
'filter_related': 'related' in request.GET and related,
|
|
'related_siblings': 'siblings' in request.GET,
|
|
'sort_asc': 'asc' in request.GET,
|
|
}
|
|
qs = cl.get_base_queryset(**kwargs)
|
|
|
|
# filter by tag
|
|
tag = request.GET.get('tag')
|
|
if tag:
|
|
kwargs['terms'] = tag
|
|
qs = qs.filter(tags__name = tag)
|
|
|
|
# search
|
|
search = request.GET.get('search')
|
|
if search:
|
|
kwargs['terms'] = search
|
|
qs = qs.search(search)
|
|
|
|
context['list_selector'] = kwargs
|
|
|
|
# paginator
|
|
if qs:
|
|
paginator = Paginator(qs, 30)
|
|
try:
|
|
qs = paginator.page('page')
|
|
except PageNotAnInteger:
|
|
qs = paginator.page(1)
|
|
except EmptyPage:
|
|
qs = parginator.page(paginator.num_pages)
|
|
context['paginator'] = paginator
|
|
context['object_list'] = qs
|
|
return qs
|
|
|
|
|
|
class DatedListBase(models.Model):
|
|
"""
|
|
List that display items per days. Renders a navigation section on the
|
|
top.
|
|
"""
|
|
nav_days = models.SmallIntegerField(
|
|
_('navigation days count'),
|
|
default = 7,
|
|
help_text = _('number of days to display in the navigation header '
|
|
'when we use dates')
|
|
)
|
|
nav_per_week = models.BooleanField(
|
|
_('navigation per week'),
|
|
default = False,
|
|
help_text = _('if selected, show dates navigation per weeks instead '
|
|
'of show days equally around the current date')
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
panels = [
|
|
MultiFieldPanel([
|
|
FieldPanel('nav_days'),
|
|
FieldPanel('nav_per_week'),
|
|
], heading=_('Navigation')),
|
|
]
|
|
|
|
@staticmethod
|
|
def str_to_date(date):
|
|
"""
|
|
Parse a string and return a regular date or None.
|
|
Format is either "YYYY/MM/DD" or "YYYY-MM-DD" or "YYYYMMDD"
|
|
"""
|
|
try:
|
|
exp = r'(?P<year>[0-9]{4})(-|\/)?(?P<month>[0-9]{1,2})(-|\/)?' \
|
|
r'(?P<day>[0-9]{1,2})'
|
|
date = re.match(exp, date).groupdict()
|
|
return datetime.date(
|
|
year = int(date['year']), month = int(date['month']),
|
|
day = int(date['day'])
|
|
)
|
|
except:
|
|
return None
|
|
|
|
def get_nav_dates(self, date):
|
|
"""
|
|
Return a list of dates availables for the navigation
|
|
"""
|
|
if self.nav_per_week:
|
|
first = date.weekday()
|
|
else:
|
|
first = int((self.nav_days - 1) / 2)
|
|
first = date - tz.timedelta(days = first)
|
|
return [ first + tz.timedelta(days=i)
|
|
for i in range(0, self.nav_days) ]
|
|
|
|
def get_date_context(self, date):
|
|
"""
|
|
Return a dict that can be added to the context to be used by
|
|
a date_list.
|
|
"""
|
|
today = tz.now().today()
|
|
if not date:
|
|
date = today
|
|
|
|
# next/prev weeks/date bunch
|
|
dates = self.get_nav_dates(date)
|
|
next = date + tz.timedelta(days=self.nav_days)
|
|
prev = date - tz.timedelta(days=self.nav_days)
|
|
|
|
# context dict
|
|
return {
|
|
'nav_dates': {
|
|
'date': date,
|
|
'next': next,
|
|
'prev': prev,
|
|
'dates': dates,
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Sections
|
|
#
|
|
@register_snippet
|
|
class Section(ClusterableModel):
|
|
"""
|
|
Section is a container of multiple items of different types
|
|
that are used to render extra content related or not the current
|
|
page.
|
|
|
|
A section has an assigned position in the page, and can be restrained
|
|
to a given type of page.
|
|
"""
|
|
name = models.CharField(
|
|
_('name'),
|
|
max_length=32,
|
|
blank = True, null = True,
|
|
help_text=_('name of this section (not displayed)'),
|
|
)
|
|
position = models.CharField(
|
|
_('position'),
|
|
max_length=16,
|
|
blank = True, null = True,
|
|
help_text = _('name of the template block in which the section must '
|
|
'be set'),
|
|
)
|
|
model = models.ForeignKey(
|
|
ContentType,
|
|
verbose_name = _('model'),
|
|
blank = True, null = True,
|
|
help_text=_('this section is displayed only when the current '
|
|
'page or publication is of this type'),
|
|
limit_choices_to = related_pages_filter,
|
|
)
|
|
|
|
panels = [
|
|
MultiFieldPanel([
|
|
FieldPanel('name'),
|
|
FieldPanel('position'),
|
|
FieldPanel('model'),
|
|
], heading=_('General')),
|
|
InlinePanel('places', label=_('Section Items')),
|
|
]
|
|
|
|
def __str__(self):
|
|
return '{}: {}'.format(self.__class__.__name__, self.name or self.pk)
|
|
|
|
def render(self, request, page = None, *args, **kwargs):
|
|
return ''.join([
|
|
place.item.render(request, page, *args, **kwargs)
|
|
for place in self.places
|
|
])
|
|
|
|
|
|
class SectionPlace(Orderable):
|
|
section = ParentalKey(Section, related_name='places')
|
|
item = models.ForeignKey(
|
|
'SectionItem',
|
|
verbose_name=_('item')
|
|
)
|
|
|
|
panels = [
|
|
SnippetChooserPanel('item'),
|
|
FieldPanel('model'),
|
|
]
|
|
|
|
def __str__(self):
|
|
return '{}: {}'.format(self.__class__.__name__, self.title or self.pk)
|
|
|
|
|
|
class SectionItemMeta(models.base.ModelBase):
|
|
def __new__(cls, name, bases, attrs):
|
|
cl = super().__new__(name, bases, attrs)
|
|
if not 'template' in attrs:
|
|
attrs['template'] = 'cms/sections/{}.html' \
|
|
.format(camelcase_to_underscore(name))
|
|
return cl
|
|
|
|
|
|
@register_snippet
|
|
class SectionItem(models.Model):
|
|
real_type = models.CharField(
|
|
max_length=32,
|
|
blank = True, null = True,
|
|
)
|
|
title = models.CharField(
|
|
_('title'),
|
|
max_length=32,
|
|
blank = True, null = True,
|
|
)
|
|
show_title = models.BooleanField(
|
|
_('show title'),
|
|
default = False,
|
|
help_text=_('if set show a title at the head of the section'),
|
|
)
|
|
related = models.BooleanField(
|
|
_('related'),
|
|
default = False,
|
|
help_text=_('if set, section is related to the current publication. '
|
|
'e.g rendering a list related to it instead of to all '
|
|
'publications'),
|
|
)
|
|
css_class = models.CharField(
|
|
_('CSS class'),
|
|
max_length=64,
|
|
blank = True, null = True,
|
|
help_text=_('section container\'s "class" attribute')
|
|
)
|
|
panels = [
|
|
MultiFieldPanel([
|
|
FieldPanel('title'),
|
|
FieldPanel('show_title'),
|
|
FieldPanel('css_class'),
|
|
], heading=_('General')),
|
|
]
|
|
|
|
def model_name(self):
|
|
return self.__class__.__name__.lower()
|
|
|
|
def specific(self):
|
|
"""
|
|
Return a downcasted version of the post if it is from another
|
|
model, or itself
|
|
"""
|
|
if not self.real_type or type(self) != SectionItem:
|
|
return self
|
|
return getattr(self, self.real_type)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if type(self) != SectionItem and not self.real_type:
|
|
self.real_type = type(self).__name__.lower()
|
|
return super().save(*args, **kwargs)
|
|
|
|
def get_context(self, request, page, *args, **kwargs):
|
|
return {
|
|
'self': self,
|
|
'page': page,
|
|
}
|
|
|
|
def render(self, request, page, *args, **kwargs):
|
|
"""
|
|
Render the section. Page is the current publication being rendered.
|
|
"""
|
|
return render_to_string(
|
|
request, self.template,
|
|
self.get_context(request, *args, page=page, **kwargs)
|
|
)
|
|
|
|
def __str__(self):
|
|
return '{}: {}'.format(
|
|
(self.real_type or 'section item').replace('section','section '),
|
|
self.title or self.pk
|
|
)
|
|
|
|
|
|
@register_snippet
|
|
class SectionText(SectionItem):
|
|
body = RichTextField()
|
|
panels = SectionItem.panels + [
|
|
FieldPanel('body'),
|
|
]
|
|
|
|
|
|
@register_snippet
|
|
class SectionImage(SectionItem):
|
|
image = models.ForeignKey(
|
|
'wagtailimages.Image',
|
|
verbose_name = _('image'),
|
|
related_name='+',
|
|
)
|
|
panels = SectionItem.panels + [
|
|
ImageChooserPanel('image'),
|
|
]
|
|
|
|
|
|
@register_snippet
|
|
class SectionLink(RelatedLinkBase,SectionItem):
|
|
"""
|
|
Can either be used standalone or in a SectionLinkList
|
|
"""
|
|
parent = ParentalKey('SectionLinkList', related_name='links',
|
|
blank=True, null=True)
|
|
panels = SectionItem.panels + RelatedLinkBase.panels
|
|
|
|
|
|
@register_snippet
|
|
class SectionLinkList(SectionItem,ClusterableModel):
|
|
panels = SectionItem.panels + [
|
|
InlinePanel('links', label=_('links'))
|
|
]
|
|
|
|
|
|
@register_snippet
|
|
class SectionPublicationList(ListBase,SectionItem):
|
|
focus_available = models.BooleanField(
|
|
_('focus available'),
|
|
default = False,
|
|
help_text = _('if true, highlight the first focused article found')
|
|
)
|
|
panels = SectionItem.panels + [ FieldPanel('focus_available') ] +\
|
|
ListBase.panels
|
|
|
|
|
|
|