authors = models.ManyToManyField(
User,
blank = True,
)
def _get_permalink_for_page(self, page):
"""Returns the URL of this article for the given news feed page."""
return page.reverse("article_detail", kwargs={
"year": self.date.year,
"month": self.date.strftime("%b").lower(),
"day": self.date.day,
"url_title": self.url_title,
})
def get_absolute_url(self):
"""Returns the URL of the article."""
return self._get_permalink_for_page(self.news_feed.page)
class Meta:
unique_together = (("news_feed", "date", "url_title",),)
ordering = ("-date",)
externals.historylinks("register", Article)
sitemaps.register(Article)
externals.watson("register", Article, adapter_cls=PageBaseSearchAdapter)
from cms import sitemaps
from cms.apps.media.models import ImageRefField
from cms.models import PageBase
from django.db import models
from historylinks import shortcuts as historylinks
class Partner(PageBase):
summary = models.TextField(max_length=140, blank=True, null=True)
logo = ImageRefField()
website = models.CharField(max_length=140, blank=True, null=True)
order = models.PositiveIntegerField(default=0)
class Meta:
ordering = ['order']
def __str__(self):
return self.title
historylinks.register(Partner)
sitemaps.register(Partner)
name='page_mptt_values',
)
]
class PageSitemap(sitemaps.PageBaseSitemap):
'''Sitemap for page models.'''
model = Page
def items(self):
'''Only lists items that are marked as indexable.'''
return filter_indexable_pages(super().items())
sitemaps.register(Page, sitemap_cls=PageSitemap)
class PageSearchAdapter(PageBaseSearchAdapter):
'''Search adapter for Page models.'''
def get_content(self, obj):
'''Returns the search text for the page.'''
content_obj = obj.content
return ' '.join([
super().get_content(obj),
self.prepare_content(content_obj.get_searchable_text())
])
def get_live_queryset(self):
'''Selects the live page queryset.'''
)
class Meta:
ordering = ['start_date']
def __str__(self):
return self.title
def get_absolute_url(self):
if self.page:
return self.page.page.reverse('event_detail',
kwargs={
'slug': self.slug,
})
def get_summary(self):
return self.summary
@property
def date(self):
date_string = '{}'.format(date(self.start_date, 'j F Y'))
if self.start_date != self.end_date:
date_string += ' - {}'.format(date(self.end_date, 'j F Y'))
return date_string
historylinks.register(Event)
sitemaps.register(Event)
@property
def last_modified(self):
version = Version.objects.get_for_object(self).first()
if version:
return version.revision.date_created
def render_card(self):
return render_to_string('news/includes/card.html', {
'article': self,
})
def get_related_articles(self, count=3):
related_articles = Article.objects.filter(
categories=self.categories.all(),
).exclude(
id=self.id
)
if related_articles.count() < count:
related_articles |= Article.objects.exclude(
id__in=[self.pk] + [x.id for x in related_articles]
)
return related_articles.distinct()[:count]
historylinks.register(Article)
sitemaps.register(Article)
externals.historylinks("register", Page)
class PageSitemap(sitemaps.PageBaseSitemap):
"""Sitemap for page models."""
model = Page
def items(self):
"""Only lists items that are marked as indexable."""
return filter_indexable_pages(super(PageSitemap, self).items())
sitemaps.register(Page, sitemap_cls=PageSitemap)
class PageSearchAdapter(PageBaseSearchAdapter):
"""Search adapter for Page models."""
def get_content(self, obj):
"""Returns the search text for the page."""
content_obj = obj.content
return u" ".join((
super(PageSearchAdapter, self).get_content(obj),
self.prepare_content(u" ".join(
force_text(self._resolve_field(content_obj, field_name))
for field_name in (
'Category',
blank=True,
null=True,
)
question = models.CharField(
max_length=256
)
answer = HtmlField()
order = models.PositiveIntegerField(
default=0
)
def __str__(self):
return self.question
class Meta:
verbose_name = 'FAQ'
verbose_name_plural = 'FAQs'
ordering = ['order', 'question']
def get_absolute_url(self):
return self.page.page.reverse('faq_detail', kwargs={
'slug': self.slug,
})
historylinks.register(Faq)
sitemaps.register(Faq)
def get_absolute_url(self):
return self.page.page.reverse('person_detail', kwargs={
'slug': self.slug,
})
def get_twitter_url(self):
twitter_username = self.twitter_username
if twitter_username.startswith('http://') or twitter_username.startswith('https://'):
return self.twitter_username
if self.twitter_username.startswith('@'):
twitter_username = twitter_username[1:]
return f'https://twitter.com/{twitter_username}'
def get_linkedin_url(self):
linkedin_username = self.linkedin_username
if linkedin_username.startswith('http://') or linkedin_username.startswith('https://'):
return self.linked_username
if linkedin_username.startswith('@'):
linkedin_username = linkedin_username[1:]
return f'https://www.linkedin.com/in/{linkedin_username}'
historylinks.register(Person)
sitemaps.register(Person)
def test_register(self):
register(TestSitemapModel)
with self.assertRaises(SitemapRegistrationError):
register(TestSitemapModel)
self.assertEqual(
registered_sitemaps['testing_models-testsitemapmodel'].
__bases__[0], BaseSitemap)
register(TestSearchMetaBaseModel)
self.assertEqual(
registered_sitemaps['testing_models-testsearchmetabasemodel'].
__bases__[0], SearchMetaBaseSitemap)
register(TestOnlineBaseModel)
self.assertEqual(
registered_sitemaps['testing_models-testonlinebasemodel'].
__bases__[0], OnlineBaseSitemap)
register(TestPublishedBaseModel)
self.assertEqual(
registered_sitemaps['testing_models-testpublishedbasemodel'].
__bases__[0], PublishedBaseSitemap)
register(TestPageBaseModel)
self.assertEqual(
registered_sitemaps['testing_models-testpagebasemodel'].
__bases__[0], PageBaseSitemap)
blank=True,
null=True
)
summary = models.TextField(
blank=True,
null=True
)
description = HtmlField()
email_address = models.EmailField()
order = models.PositiveIntegerField(
default=0
)
class Meta:
ordering = ['order']
def __str__(self):
return self.title
def get_absolute_url(self):
return self.page.page.reverse('career_detail', kwargs={
'slug': self.slug,
})
historylinks.register(Career)
sitemaps.register(Career)
