def closest_match(cls, urlconf_path):
page_class = cls.parent.field.rel.to
contents = cls.objects.filter(
parent__in=page_class.objects.active(),
urlconf_path=urlconf_path,
).order_by('pk').select_related('parent')
if len(contents) > 1:
try:
current = short_language_code(get_language())
return [
content for content in contents if
short_language_code(content.parent.language) == current
][0]
except (AttributeError, IndexError):
pass
try:
return contents[0]
except IndexError:
pass
return None
def closest_match(cls, urlconf_path):
page_class = cls.parent.field.rel.to
contents = cls.objects.filter(
parent__in=page_class.objects.active(),
urlconf_path=urlconf_path,
).order_by('pk').select_related('parent')
if len(contents) > 1:
try:
current = short_language_code(get_language())
return [
content for content in contents
if short_language_code(content.parent.language) == current
][0]
except (AttributeError, IndexError):
pass
try:
return contents[0]
except IndexError:
pass
return None
def process(self, request, **kwargs):
if self.featured_only:
entries = Entry.objects.featured()
else:
entries = Entry.objects.active()
if self.category:
entries = entries.filter(categories=self.category)
if self.only_active_language:
entries = entries.filter(
language__istartswith=short_language_code())
entries = entries.transform(entry_list_lookup_related)
if self.paginate_by:
paginator = Paginator(entries, self.paginate_by)
page = request.GET.get('page', 1)
try:
self.entries = paginator.page(page).object_list
except PageNotAnInteger:
self.entries = paginator.page(1).object_list
except EmptyPage:
self.entries = paginator.page(paginator.num_pages).object_list
else:
self.entries = entries
def process(self, request, **kwargs):
if self.featured_only:
entries = Entry.objects.featured().transform(
entry_list_lookup_related)
else:
entries = Entry.objects.active().transform(
entry_list_lookup_related)
if self.category:
entries = entries.filter(categories=self.category)
if self.only_active_language:
entries = entries.filter(
language__istartswith=short_language_code())
if self.paginate_by:
paginator = Paginator(entries, self.paginate_by)
page = request.GET.get('page', 1)
try:
self.entries = paginator.page(page).object_list
except PageNotAnInteger:
self.entries = paginator.page(1).object_list
except EmptyPage:
self.entries = paginator.page(paginator.num_pages).object_list
else:
self.entries = entries
def get_queryset(self):
queryset = Entry.objects.active().transform(entry_list_lookup_related)
if self.only_active_language:
queryset = queryset.filter(
language__istartswith=short_language_code())
return queryset
def get_queryset(self):
queryset = Entry.objects.active().transform(entry_list_lookup_related)
if self.only_active_language:
queryset = queryset.filter(
language__istartswith=short_language_code())
return queryset
def get_frontpage(context, category=None):
try:
queryset = Entry.objects.featured().filter(language=short_language_code())
except (AttributeError, FieldError):
queryset = Entry.objects.featured()
if category:
queryset = queryset.filter(categories__translations__title=category).distinct()
context['entries'] = queryset
return ''
def get_entries(context, limit):
try:
queryset = Entry.objects.active().filter(language=short_language_code())
except (AttributeError, FieldError):
queryset = Entry.objects.active()
if limit:
queryset = queryset[:limit]
context['entries'] = queryset
return u''
def get_entries(context, limit):
try:
queryset = Entry.objects.active().filter(
language=short_language_code())
except (AttributeError, FieldError):
queryset = Entry.objects.active()
if limit:
queryset = queryset[:limit]
context['entries'] = queryset
return u''
def get_frontpage(context, category=None):
try:
queryset = Entry.objects.featured().filter(
language=short_language_code())
except (AttributeError, FieldError):
queryset = Entry.objects.featured()
if category:
queryset = queryset.filter(
categories__translations__title=category).distinct()
context['entries'] = queryset
return ''
def get_queryset(self):
slug = self.kwargs['slug']
try:
self.category = Category.objects.get(translations__slug=slug, )
except Category.DoesNotExist:
raise Http404('Category with slug %s does not exist' % slug)
except Category.MultipleObjectsReturned:
self.category = get_object_or_404(
Category,
translations__slug=slug,
translations__language_code__startswith=short_language_code(),
)
queryset = super(CategoryArchiveIndexView, self).get_queryset()
return queryset.filter(categories=self.category)
def get_queryset(self):
slug = self.kwargs['slug']
try:
self.category = Category.objects.get(
translations__slug=slug,
)
except Category.DoesNotExist:
raise Http404('Category with slug %s does not exist' % slug)
except Category.MultipleObjectsReturned:
self.category = get_object_or_404(Category,
translations__slug=slug,
translations__language_code__startswith=short_language_code(),
)
queryset = super(CategoryArchiveIndexView, self).get_queryset()
return queryset.filter(categories=self.category)
def feincms_pages(request):
lang = short_language_code()
try:
feincms_page = Page.objects.for_request(request, best_match=True)
except Page.DoesNotExist:
try:
feincms_page = Page.objects.get(slug=lang)
except Page.DoesNotExist:
feincms_page = None
try:
footer = Page.objects.get(language=lang, slug="footer")
except Page.DoesNotExist:
try:
footer = Page.objects.filter(slug="footer")[0]
except:
footer = None
return {
'feincms_page': feincms_page,
'footer': footer
}
def testTranslation(self):
create_chinese_entries(EntryFactory)
# Make sure the Entry has a translation extension
entry = Entry()
self.assertTrue(hasattr(entry, 'language'))
self.assertTrue(hasattr(entry, 'translation_of'))
# define the language of entry 2
entries = Entry.objects.order_by('pk')
entry1 = entries[0]
self.assertEqual(entry1.pk, 1)
self.assertEqual(entry1.title, 'Entry 1')
entry1.language = 'en'
entry1.save()
entry2 = entries[1]
self.assertEqual(entry2.pk, 2)
self.assertEqual(entry2.title, 'Eintrag 1')
entry2.language = 'de'
entry2.translation_of = entry1
entry2.save()
entry3 = entries[2]
entry4 = entries[3]
self.assertEqual(entry3.language, 'zh-hans')
self.assertEqual(entry4.language, 'zh-hant')
entry = Entry.objects.get(language='de')
self.assertEqual(entry.title, 'Eintrag 1')
with translation.override('de'):
c = Client()
self.assertEqual(short_language_code(), 'de')
# Test Archive URL
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, 'Entry 1')
self.assertContains(response, 'Eintrag 1')
# test all languages override
response = c.get('/multilang/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 4)
self.assertEqual(response.status_code, 200)
with translation.override('en'):
c = Client()
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='en')
self.assertEqual(short_language_code(), 'en')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Entry 1')
self.assertNotContains(response, 'Eintrag 1')
with translation.override('zh-hans'):
c = Client()
self.assertEqual(translation.get_language(), 'zh-hans')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-hans')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Entry 2 chinese traditional')
self.assertNotContains(response, 'Eintrag 1')
with translation.override('zh-hant'):
c = Client()
self.assertEqual(translation.get_language(), 'zh-hant')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-hant')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Entry 2 chinese simplified')
self.assertNotContains(response, 'Eintrag 1')
def testTranslation(self):
# Make sure the Entry has a translation extension
entry = Entry()
self.assertTrue(hasattr(entry, 'language'))
self.assertTrue(hasattr(entry, 'translation_of'))
# define the language of entry 2
entries = Entry.objects.order_by('pk')
entry1 = entries[0]
self.assertEqual(entry1.pk, 1)
self.assertEqual(entry1.title, u'Entry 1')
entry1.language = 'en'
entry1.save()
entry2 = entries[1]
self.assertEqual(entry2.pk, 2)
self.assertEqual(entry2.title, u'Eintrag 1')
entry2.language = 'de'
entry2.translation_of = entry1
entry2.save()
entry3 = entries[2]
entry4 = entries[3]
self.assertEqual(entry3.language, 'zh-cn')
self.assertEqual(entry4.language, 'zh-tw')
entry = Entry.objects.get(language='de')
self.assertEqual(entry.title, u'Eintrag 1')
with translation.override('de'):
c = Client()
self.assertEqual(short_language_code(), 'de')
# Test Archive URL
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, u'Entry 1')
self.assertContains(response, u'Eintrag 1')
# test all languages override
response = c.get('/multilang/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 4)
self.assertEqual(response.status_code, 200)
with translation.override('en'):
c = Client()
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='en')
self.assertEqual(short_language_code(), 'en')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 1')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-cn'):
c = Client()
self.assertEqual(translation.get_language(), 'zh-cn')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-cn')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese traditional')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-tw'):
c = Client()
self.assertEqual(translation.get_language(), 'zh-tw')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-tw')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese simplified')
self.assertNotContains(response, u'Eintrag 1')
def test_10_mediafile_and_imagecontent(self):
self.create_default_page_set()
page = Page.objects.get(pk=1)
self.create_pagecontent(page)
path = os.path.join(settings.MEDIA_ROOT, "somefile.jpg")
f = open(path, "wb")
f.write("blabla")
f.close()
category = Category.objects.create(title="Category", parent=None)
category2 = Category.objects.create(title="Something", parent=category)
self.assertEqual(unicode(category2), "Category - Something")
self.assertEqual(unicode(category), "Category")
mediafile = MediaFile.objects.create(file="somefile.jpg")
mediafile.categories = [category]
page.mediafilecontent_set.create(mediafile=mediafile, region="main", position="block", ordering=1)
self.assertEqual(unicode(mediafile), "somefile.jpg")
mediafile.translations.create(caption="something", language_code="%s-ha" % short_language_code())
assert "something" in unicode(mediafile)
mf = page.content.main[1].mediafile
self.assertEqual(mf.translation.caption, "something")
self.assertEqual(mf.translation.short_language_code(), short_language_code())
self.assertNotEqual(mf.get_absolute_url(), "")
self.assertEqual(unicode(mf), "something")
self.assertEqual(mf.file_type(), "Image")
self.assertEqual(MediaFile.objects.only_language("de").count(), 0)
self.assertEqual(MediaFile.objects.only_language("en").count(), 0)
self.assertEqual(MediaFile.objects.only_language("%s-ha" % short_language_code()).count(), 1)
assert "%s-ha" % short_language_code() in mf.available_translations
os.unlink(path)
# this should not raise
self.client.get("/admin/page/page/1/")
assert 'alt="something"' in page.content.main[1].render()
page.imagecontent_set.create(image="somefile.jpg", region="main", position="default", ordering=2)
page.filecontent_set.create(file="somefile.jpg", title="thetitle", region="main", ordering=3)
assert "somefile.jpg" in page.content.main[2].render()
assert '<a href="/media/somefile.jpg">thetitle</a>' in page.content.main[3].render()
page.mediafilecontent_set.update(mediafile=3)
# this should not raise
self.client.get("/admin/page/page/1/")
field = MediaFile._meta.get_field("file")
old = (field.upload_to, field.storage)
from django.core.files.storage import FileSystemStorage
MediaFile.reconfigure(
upload_to=lambda: "anywhere", storage=FileSystemStorage(location="/wha/", base_url="/whe/")
)
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, "/whe/somefile.jpg")
MediaFile.reconfigure(upload_to=old[0], storage=old[1])
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, "/media/somefile.jpg")
def entries(self, obj):
if 'translations' in getattr(Entry, '_feincms_extensions', ()):
return Entry.objects.filter(
categories=obj, language=short_language_code()).count()
return Entry.objects.filter(categories=obj)
def entries(self, obj):
if 'translations' in getattr(AppPromo, '_feincms_extensions', ()):
return AppPromo.objects.filter(categories=obj, language=short_language_code()).count()
return AppPromo.objects.filter(categories=obj)
def media(self):
media = forms.Media()
media.add_js(('http://connect.facebook.net/%s/all.js#xfbml=1' % FACEBOOK_LOCALES.get(short_language_code()),))
return media
def test_10_mediafile_and_imagecontent(self):
self.create_default_page_set()
page = Page.objects.get(pk=1)
self.create_pagecontent(page)
path = os.path.join(settings.MEDIA_ROOT, 'somefile.jpg')
f = open(path, 'wb')
f.write('blabla')
f.close()
category = Category.objects.create(title='Category', parent=None)
category2 = Category.objects.create(title='Something', parent=category)
self.assertEqual(unicode(category2), 'Category - Something')
self.assertEqual(unicode(category), 'Category')
mediafile = MediaFile.objects.create(file='somefile.jpg')
mediafile.categories = [category]
page.mediafilecontent_set.create(mediafile=mediafile,
region='main',
position='block',
ordering=1)
self.assertEqual(unicode(mediafile), 'somefile.jpg')
mediafile.translations.create(caption='something',
language_code='%s-ha' %
short_language_code())
self.assertTrue('something' in unicode(mediafile))
mf = page.content.main[1].mediafile
self.assertEqual(mf.translation.caption, 'something')
self.assertEqual(mf.translation.short_language_code(),
short_language_code())
self.assertNotEqual(mf.get_absolute_url(), '')
self.assertEqual(unicode(mf), 'something')
self.assertEqual(unicode(mf.file_type()),
u'Binary') # Ok, so it's not really an image...
self.assertEqual(MediaFile.objects.only_language('de').count(), 0)
self.assertEqual(MediaFile.objects.only_language('en').count(), 0)
self.assertEqual(
MediaFile.objects.only_language('%s-ha' %
short_language_code()).count(), 1)
self.assertTrue('%s-ha' %
short_language_code() in mf.available_translations)
os.unlink(path)
# this should not raise
self.client.get('/admin/page/page/1/')
#self.assertTrue('alt="something"' in page.content.main[1].render()) Since it isn't an image
page.imagecontent_set.create(image='somefile.jpg',
region='main',
position='default',
ordering=2)
page.filecontent_set.create(file='somefile.jpg',
title='thetitle',
region='main',
ordering=3)
self.assertTrue('somefile.jpg' in page.content.main[2].render())
self.assertTrue('<a href="/media/somefile.jpg">thetitle</a>' in
page.content.main[3].render())
page.mediafilecontent_set.update(mediafile=3)
# this should not raise
self.client.get('/admin/page/page/1/')
field = MediaFile._meta.get_field('file')
old = (field.upload_to, field.storage)
from django.core.files.storage import FileSystemStorage
MediaFile.reconfigure(upload_to=lambda: 'anywhere',
storage=FileSystemStorage(location='/wha/',
base_url='/whe/'))
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, '/whe/somefile.jpg')
MediaFile.reconfigure(upload_to=old[0], storage=old[1])
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, '/media/somefile.jpg')
from django.conf.urls import patterns, include, url
from django.conf import settings
from django.contrib import admin
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from django.shortcuts import redirect
from feincms.translations import short_language_code
admin.autodiscover()
urlpatterns = patterns('',
url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
url(r'^admin/', include(admin.site.urls)),
url(r'^$', lambda request: redirect('/%s/' % short_language_code())),
)
if not settings.DEBUG:
urlpatterns += patterns('',
url(r'^static/(?P<path>.*)$', 'django.views.static.serve', {
'document_root': settings.STATIC_ROOT
}),
)
else:
urlpatterns += staticfiles_urlpatterns()
urlpatterns += patterns('',
url(r'^uploads/(.*)', 'django.views.static.serve', {
'document_root': settings.MEDIA_ROOT,
}),
)
def testTranslation(self):
# Make sure the Entry has a translation extension
entry = Entry()
self.assertTrue(hasattr(entry, 'language'))
self.assertTrue(hasattr(entry, 'translation_of'))
# define the language of entry 2
entries = Entry.objects.order_by('pk')
entry1 = entries[0]
self.assertEqual(entry1.pk, 1)
self.assertEqual(entry1.title, u'Entry 1')
entry1.language = 'en'
entry1.save()
entry2 = entries[1]
self.assertEqual(entry2.pk, 2)
self.assertEqual(entry2.title, u'Eintrag 1')
entry2.language = 'de'
entry2.translation_of = entry1
entry2.save()
entry3 = entries[2]
entry4 = entries[3]
self.assertEqual(entry3.language, 'zh-cn')
self.assertEqual(entry4.language, 'zh-tw')
entry = Entry.objects.get(language='de')
self.assertEqual(entry.title, u'Eintrag 1')
with translation.override('de'):
c = Client()
self.assertEqual(short_language_code(), 'de')
# Test Archive URL
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, u'Entry 1')
self.assertContains(response, u'Eintrag 1')
# test all languages override
response = c.get('/multilang/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 4)
self.assertEqual(response.status_code, 200)
with translation.override('en'):
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='en')
self.assertEqual(short_language_code(), 'en')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 1')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-cn'):
self.assertEqual(translation.get_language(), 'zh-cn')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-cn')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese traditional')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-tw'):
self.assertEqual(translation.get_language(), 'zh-tw')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-tw')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese simplified')
self.assertNotContains(response, u'Eintrag 1')
# AttributeError: 'Settings' object has no attribute '_original_allowed_hosts'
# fixed in Django 1.6
# https://github.com/django/django/commit/e2b86571bfa3503fe43adfa92e9c9f4271a7a135
def testTranslation(self):
# Make sure the Entry has a translation extension
entry = Entry()
self.assertTrue(hasattr(entry, 'language'))
self.assertTrue(hasattr(entry, 'translation_of'))
# define the language of entry 2
entries = Entry.objects.order_by('pk')
entry1 = entries[0]
self.assertEqual(entry1.pk, 1)
self.assertEqual(entry1.title, u'Entry 1')
entry1.language = 'en'
entry1.save()
entry2 = entries[1]
self.assertEqual(entry2.pk, 2)
self.assertEqual(entry2.title, u'Eintrag 1')
entry2.language = 'de'
entry2.translation_of = entry1
entry2.save()
entry3 = entries[2]
entry4 = entries[3]
self.assertEqual(entry3.language, 'zh-cn')
self.assertEqual(entry4.language, 'zh-tw')
entry = Entry.objects.get(language='de')
self.assertEqual(entry.title, u'Eintrag 1')
with translation.override('de'):
c = Client()
self.assertEqual(short_language_code(), 'de')
# Test Archive URL
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, u'Entry 1')
self.assertContains(response, u'Eintrag 1')
# test all languages override
response = c.get('/multilang/', HTTP_ACCEPT_LANGUAGE='de')
self.assertEqual(len(response.context['object_list']), 4)
self.assertEqual(response.status_code, 200)
with translation.override('en'):
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='en')
self.assertEqual(short_language_code(), 'en')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 1')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-cn'):
self.assertEqual(translation.get_language(), 'zh-cn')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-cn')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese traditional')
self.assertNotContains(response, u'Eintrag 1')
with translation.override('zh-tw'):
self.assertEqual(translation.get_language(), 'zh-tw')
self.assertEqual(short_language_code(), 'zh')
response = c.get('/blog/', HTTP_ACCEPT_LANGUAGE='zh-tw')
self.assertEqual(len(response.context['object_list']), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'Entry 2 chinese simplified')
self.assertNotContains(response, u'Eintrag 1')
# AttributeError: 'Settings' object has no attribute '_original_allowed_hosts'
# fixed in Django 1.6
# https://github.com/django/django/commit/e2b86571bfa3503fe43adfa92e9c9f4271a7a135
def testTranslation(self):
create_chinese_entries(EntryFactory)
# Make sure the Entry has a translation extension
entry = Entry()
self.assertTrue(hasattr(entry, "language"))
self.assertTrue(hasattr(entry, "translation_of"))
# define the language of entry 2
entries = Entry.objects.order_by("pk")
entry1 = entries[0]
self.assertEqual(entry1.pk, 1)
self.assertEqual(entry1.title, "Entry 1")
entry1.language = "en"
entry1.save()
entry2 = entries[1]
self.assertEqual(entry2.pk, 2)
self.assertEqual(entry2.title, "Eintrag 1")
entry2.language = "de"
entry2.translation_of = entry1
entry2.save()
entry3 = entries[2]
entry4 = entries[3]
self.assertEqual(entry3.language, "zh-hans")
self.assertEqual(entry4.language, "zh-hant")
entry = Entry.objects.get(language="de")
self.assertEqual(entry.title, "Eintrag 1")
with translation.override("de"):
c = Client()
self.assertEqual(short_language_code(), "de")
# Test Archive URL
response = c.get("/blog/", HTTP_ACCEPT_LANGUAGE="de")
self.assertEqual(len(response.context["object_list"]), 1)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "Entry 1")
self.assertContains(response, "Eintrag 1")
# test all languages override
response = c.get("/multilang/", HTTP_ACCEPT_LANGUAGE="de")
self.assertEqual(len(response.context["object_list"]), 4)
self.assertEqual(response.status_code, 200)
with translation.override("en"):
c = Client()
response = c.get("/blog/", HTTP_ACCEPT_LANGUAGE="en")
self.assertEqual(short_language_code(), "en")
self.assertEqual(len(response.context["object_list"]), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Entry 1")
self.assertNotContains(response, "Eintrag 1")
with translation.override("zh-hans"):
c = Client()
self.assertEqual(translation.get_language(), "zh-hans")
self.assertEqual(short_language_code(), "zh")
response = c.get("/blog/", HTTP_ACCEPT_LANGUAGE="zh-hans")
self.assertEqual(len(response.context["object_list"]), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Entry 2 chinese traditional")
self.assertNotContains(response, "Eintrag 1")
with translation.override("zh-hant"):
c = Client()
self.assertEqual(translation.get_language(), "zh-hant")
self.assertEqual(short_language_code(), "zh")
response = c.get("/blog/", HTTP_ACCEPT_LANGUAGE="zh-hant")
self.assertEqual(len(response.context["object_list"]), 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Entry 2 chinese simplified")
self.assertNotContains(response, "Eintrag 1")
def test_10_mediafile_and_imagecontent(self):
self.create_default_page_set()
page = Page.objects.get(pk=1)
self.create_pagecontent(page)
path = os.path.join(settings.MEDIA_ROOT, 'somefile.jpg')
f = open(path, 'wb')
f.write('blabla')
f.close()
category = Category.objects.create(title='Category', parent=None)
category2 = Category.objects.create(title='Something', parent=category)
self.assertEqual(unicode(category2), 'Category - Something')
self.assertEqual(unicode(category), 'Category')
mediafile = MediaFile.objects.create(file='somefile.jpg')
mediafile.categories = [category]
page.mediafilecontent_set.create(
mediafile=mediafile,
region='main',
position='block',
ordering=1)
self.assertEqual(unicode(mediafile), 'somefile.jpg')
mediafile.translations.create(caption='something',
language_code='%s-ha' % short_language_code())
self.assertTrue('something' in unicode(mediafile))
mf = page.content.main[1].mediafile
self.assertEqual(mf.translation.caption, 'something')
self.assertEqual(mf.translation.short_language_code(), short_language_code())
self.assertNotEqual(mf.get_absolute_url(), '')
self.assertEqual(unicode(mf), 'something')
self.assertEqual(unicode(mf.file_type()), u'Binary') # Ok, so it's not really an image...
self.assertEqual(MediaFile.objects.only_language('de').count(), 0)
self.assertEqual(MediaFile.objects.only_language('en').count(), 0)
self.assertEqual(MediaFile.objects.only_language('%s-ha' % short_language_code()).count(),
1)
self.assertTrue('%s-ha' % short_language_code() in mf.available_translations)
os.unlink(path)
# this should not raise
self.client.get('/admin/page/page/1/')
#self.assertTrue('alt="something"' in page.content.main[1].render()) Since it isn't an image
page.imagecontent_set.create(image='somefile.jpg', region='main', position='default', ordering=2)
page.filecontent_set.create(file='somefile.jpg', title='thetitle', region='main', ordering=3)
self.assertTrue('somefile.jpg' in page.content.main[2].render())
self.assertTrue('<a href="/media/somefile.jpg">thetitle</a>' in page.content.main[3].render())
page.mediafilecontent_set.update(mediafile=3)
# this should not raise
self.client.get('/admin/page/page/1/')
field = MediaFile._meta.get_field('file')
old = (field.upload_to, field.storage)
from django.core.files.storage import FileSystemStorage
MediaFile.reconfigure(upload_to=lambda: 'anywhere',
storage=FileSystemStorage(location='/wha/', base_url='/whe/'))
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, '/whe/somefile.jpg')
MediaFile.reconfigure(upload_to=old[0], storage=old[1])
mediafile = MediaFile.objects.get(pk=1)
self.assertEqual(mediafile.file.url, '/media/somefile.jpg')
def entry_list(request, category=None, year=None, month=None, day=None, page=0,
paginate_by=10, template_name='blog/entry_list.html', limit=None,
exclude=None, **kwargs):
extra_context = { 'request' : request }
if getattr(djangosettings, 'LANGUAGES', False) and len(djangosettings.LANGUAGES)>1:
language_code = short_language_code()
queryset = Entry.objects.active().filter(language=language_code)
else:
try:
language_code = request._feincms_page.language
queryset = Entry.objects.active().filter(language=language_code)
except (AttributeError, FieldError):
queryset = Entry.objects.active()
""" You can define a dict of fields and values to exclude. """
if exclude:
queryset = queryset.exclude(**exclude)
if limit:
queryset = queryset[:limit]
if category:
queryset = queryset.filter(categories__translations__slug=category)
extra_context.update({'category': category})
if year:
queryset = queryset.filter(published_on__year=int(year))
extra_context.update({'drilldown_mode': 'year', 'title' : year })
else:
year = datetime.now().year
if month:
# display month as full word.
from django.template import defaultfilters
queryset = queryset.filter(published_on__month=int(month))
extra_context.update({'drilldown_mode': 'month', 'title' : defaultfilters.date(date(int(year), int(month), 1), 'E Y')})
else:
month = datetime.now().month
if day:
from django.contrib.humanize.templatetags.humanize import naturalday
queryset = queryset.filter(published_on__day=int(day))
extra_context.update({'drilldown_mode': 'day', 'title' : naturalday(date(int(year), int(month), int(day))) })
else:
day = 1
extra_context.update({'date':date(int(year), int(month), int(day)),
'comments' : settings.BLOG_COMMENTS})
'''
if this app runs without ApplicationContent integration we have to make sure
the template extends from the basic_template so we prepend 'standalone/'
to the template_name
'''
if recognize_app_content(request):
template_name = '/'.join(['standalone', template_name,])
#print request._feincms_extra_context
from django.views.generic import list_detail
else:
from feincms.views.generic import list_detail
return list_detail.object_list(
request,
queryset = queryset,
paginate_by = paginate_by,
page = page,
template_name = template_name,
extra_context = extra_context,
**kwargs)
