def test_change_lang_next_url_after(self):
"""change language and redirect to url"""
original_text = '*!-+' * 10
translated_text = ':%@/' * 9
art1 = get_article_class().objects.create(title="Home", content=original_text)
art2 = get_article_class().objects.create(title="Next", content="****NEXT****")
origin_lang = settings.LANGUAGES[0][0]
trans_lang = settings.LANGUAGES[1][0]
setattr(art1, 'title_' + trans_lang, 'Accueil')
setattr(art1, 'content_' + trans_lang, translated_text)
art1.save()
origin_url = '/{0}/home/'.format(origin_lang)
response = self.client.get(origin_url, follow=True)
self.assertEqual(200, response.status_code)
self.assertContains(response, original_text)
data = {'language': trans_lang, 'next_url_after_change_lang': art2.get_absolute_url()}
response = self.client.post(
reverse('coop_cms_change_language'),
data=data,
follow=True
)
self.assertEqual(200, response.status_code)
self.assertContains(response, art2.content)
def test_homepage_multisites_same_home(self):
site1 = Site.objects.get(id=settings.SITE_ID)
site2 = Site.objects.create(domain="wooooooaa.com", name="wooaa")
article1 = get_article_class().objects.create(title="python", content='python')
article2 = get_article_class().objects.create(title="django", content='django')
article3 = get_article_class().objects.create(title="home1", content='homepage1')
article4 = get_article_class().objects.create(title="home2", content='homepage2')
self.assertEqual(0, SiteSettings.objects.count())
SiteSettings.objects.create(site=site1, homepage_article=article3.slug)
SiteSettings.objects.create(site=site2, homepage_article=article3.slug)
article3.sites.add(site2)
article3.save()
settings.SITE_ID = site1.id
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, article3.title)
self.assertContains(response, article3.content)
self.assertEqual(article3.is_homepage, True)
self.assertEqual(article4.is_homepage, False)
settings.SITE_ID = site2.id
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, article3.title)
self.assertContains(response, article3.content)
self.assertEqual(article3.is_homepage, True)
self.assertEqual(article4.is_homepage, False)
def test_change_lang_no_trans(self):
"""change language and no translation"""
original_text = '*!-+' * 10
get_article_class().objects.create(title="Home", content=original_text)
origin_lang = settings.LANGUAGES[0][0]
trans_lang = settings.LANGUAGES[1][0]
origin_url = '/{0}/home/'.format(origin_lang)
response = self.client.get(origin_url, follow=True)
self.assertEqual(200, response.status_code)
self.assertContains(response, original_text)
data = {'language': trans_lang}
response = self.client.post(
reverse('coop_cms_change_language') + '?next={0}'.format(origin_url),
data=data,
follow=True
)
self.assertEqual(200, response.status_code)
self.assertContains(response, original_text)
response = self.client.get('/{0}/home/'.format(trans_lang), follow=True)
self.assertEqual(200, response.status_code)
self.assertContains(response, original_text)
def test_homepage_multisites_same_home(self):
site1 = Site.objects.get(id=settings.SITE_ID)
site2 = Site.objects.create(domain="wooooooaa.com", name="wooaa")
article1 = get_article_class().objects.create(title="python", content='python')
article2 = get_article_class().objects.create(title="django", content='django')
article3 = get_article_class().objects.create(title="home1", content='homepage1')
article4 = get_article_class().objects.create(title="home2", content='homepage2')
self.assertEqual(0, SiteSettings.objects.count())
SiteSettings.objects.create(site=site1, homepage_url=article3.get_absolute_url())
SiteSettings.objects.create(site=site2, homepage_url=article3.get_absolute_url())
settings.SITE_ID = site1.id
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].find(article3.get_absolute_url()) >= 0)
self.assertEqual(article3.is_homepage, True)
self.assertEqual(article4.is_homepage, False)
settings.SITE_ID = site2.id
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].find(article3.get_absolute_url()) >= 0)
self.assertEqual(article3.is_homepage, True)
self.assertEqual(article4.is_homepage, False)
def test_homepage_url_context_processor(self):
site = Site.objects.get(id=settings.SITE_ID)
article1 = get_article_class().objects.create(title="pythonx", content='pythonx')
article2 = get_article_class().objects.create(title="django", content='django')
mommy.make(SiteSettings, site=site, homepage_article=article1.slug)
request = RequestFactory().get(article2.get_absolute_url())
self.assertEqual(homepage_url(request), {'homepage_url': reverse('coop_cms_homepage')})
def view_all_articles(request):
articles_admin_url = newsletters_admin_url = add_article_url = add_newsletter_url = None
if request.user.is_staff:
article_class = get_article_class()
view_name = "admin:%s_%s_changelist" % (article_class._meta.app_label, article_class._meta.module_name)
articles_admin_url = reverse(view_name)
# newsletters_admin_url = reverse('admin:coop_cms_newsletter_changelist')
# add_newsletter_url = reverse('admin:coop_cms_newsletter_add')
Article = get_article_class()
ct = ContentType.objects.get_for_model(Article)
perm = "{0}.add_{1}".format(ct.app_label, ct.model)
if request.user.has_perm(perm):
add_article_url = reverse("coop_cms_new_article")
return render_to_response(
"coop_cms/view_all_articles.html",
{
"articles": get_article_class().objects.all().order_by("-id")[:10],
#'newsletters': models.Newsletter.objects.all().order_by('-id')[:10],
"editable": True,
"articles_list_url": articles_admin_url,
# 'newsletters_list_url': newsletters_admin_url,
"add_article_url": add_article_url,
# 'add_newsletter_url': add_newsletter_url,
},
RequestContext(request),
)
def view_all_articles(request):
"""all article"""
articles_admin_url = newsletters_admin_url = add_article_url = add_newsletter_url = None
if request.user.is_staff:
article_class = get_article_class()
view_name = 'admin:{0}_{1}_changelist'.format(get_model_app(article_class), get_model_name(article_class))
articles_admin_url = reverse(view_name)
newsletters_admin_url = reverse('admin:coop_cms_newsletter_changelist')
add_newsletter_url = reverse('admin:coop_cms_newsletter_add')
article_class = get_article_class()
content_type = ContentType.objects.get_for_model(article_class)
perm = '{0}.add_{1}'.format(content_type.app_label, content_type.model)
if request.user.has_perm(perm):
add_article_url = reverse('coop_cms_new_article')
return render(
request,
'coop_cms/view_all_articles.html',
{
'articles': article_class.objects.filter(sites__id=settings.SITE_ID).order_by('-id')[:10],
'newsletters': models.Newsletter.objects.all().order_by('-id')[:10],
'editable': True,
'articles_list_url': articles_admin_url,
'newsletters_list_url': newsletters_admin_url,
'add_article_url': add_article_url,
'add_newsletter_url': add_newsletter_url,
}
)
def test_user_settings_homepage_priority(self):
site = Site.objects.get(id=settings.SITE_ID)
a1 = get_article_class().objects.create(title="python", content='python')
a2 = get_article_class().objects.create(title="django", content='django', homepage_for_site=site)
site_settings = mommy.make(SiteSettings, site=site, homepage_url=a1.get_absolute_url())
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].find(a1.get_absolute_url()) >= 0)
def test_view_change_homepage(self):
self._log_as_editor()
article1 = get_article_class().objects.create(title="python", content='python')
response = self.client.get(reverse('coop_cms_set_homepage', args=[article1.id]))
self.assertEqual(response.status_code, 200)
article1 = get_article_class().objects.get(id=article1.id)
self.assertEqual(article1.is_homepage, False)
def test_edit_private_article(self):
"""test user can edit own private article"""
article = mommy.make(get_article_class(), author=self.user)
self.assertTrue(self.client.login(username=self.user.username, password='******'))
data = {'title': 'A', 'content': 'B', 'author': article.author.id}
response = self.client.post(article.get_edit_url(), data=data, follow=True)
self.assertEqual(200, response.status_code)
article = get_article_class().objects.get(id=article.id)#refresh
self.assertEqual('A', article.title)
self.assertEqual('B', article.content)
def test_user_settings_homepage_url(self):
self._log_as_editor()
site = Site.objects.get(id=settings.SITE_ID)
article1 = get_article_class().objects.create(title="pythonx", content='pythonx')
article2 = get_article_class().objects.create(title="django", content='django')
article2_url = reverse('coop_cms_view_article', args=[article2.slug])
mommy.make(SiteSettings, site=site, homepage_url=article2_url)
response = self.client.get(reverse('coop_cms_homepage'), follow=True)
self.assertRedirects(response, reverse('coop_cms_view_all_articles'))
def test_user_settings_homepage_priority(self):
site = Site.objects.get(id=settings.SITE_ID)
article1 = get_article_class().objects.create(title="python", content='python')
get_article_class().objects.create(title="django", content='django', homepage_for_site=site)
mommy.make(SiteSettings, site=site, homepage_article=article1.slug)
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, article1.title)
self.assertContains(response, article1.content)
def test_user_settings_both(self):
site = Site.objects.get(id=settings.SITE_ID)
article1 = get_article_class().objects.create(title="pythonx", content='pythonx')
article2 = get_article_class().objects.create(title="django", content='django')
article2_url = reverse('coop_cms_view_article', args=[article2.slug])
mommy.make(SiteSettings, site=site, homepage_url=article2_url, homepage_article=article1.slug)
response = self.client.get(reverse('coop_cms_homepage'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, article1.title)
self.assertContains(response, article1.content)
def test_edit_private_article(self):
article = mommy.make_one(get_article_class(), author=self.user)
self.assertTrue(self.client.login(username=self.user.username, password="******"))
response = self.client.post(
article.get_edit_url(), data={"title": "A", "content": "B", "author": article.author.id}, follow=True
)
# self.assertEqual(200, self.client.get(article.get_absolute_url()).status_code)
self.assertEqual(200, response.status_code)
article = get_article_class().objects.get(id=article.id) # refresh
self.assertEqual("A", article.title)
self.assertEqual("B", article.content)
def test_cant_edit_private_article(self):
klass = get_article_class()
article = mommy.make_one(klass, publication=klass.DRAFT)
self.assertTrue(self.client.login(username=self.user.username, password="******"))
response = self.client.post(
article.get_edit_url(), data={"title": "A", "content": "B", "author": None}, follow=True
)
self.assertEqual(403, response.status_code)
article = get_article_class().objects.get(id=article.id) # refresh
self.assertNotEqual("A", article.title)
self.assertNotEqual("B", article.content)
def test_cant_edit_private_article(self):
"""test user can not edit other user article"""
klass = get_article_class()
article = mommy.make(klass, publication=klass.DRAFT)
self.assertTrue(self.client.login(username=self.user.username, password='******'))
data = {'title': 'A', 'content': 'B', 'author': None}
response = self.client.post(article.get_edit_url(), data=data, follow=True)
self.assertEqual(403, response.status_code)
article = get_article_class().objects.get(id=article.id)#refresh
self.assertNotEqual('A', article.title)
self.assertNotEqual('B', article.content)
def test_view_category_articles(self):
cat = mommy.make(ArticleCategory, name="abc")
art1 = mommy.make(
get_article_class(), slug="test1", category=cat, publication=True, publication_date=datetime.now()
)
art2 = mommy.make(
get_article_class(), slug="test2", category=cat, publication=True,
publication_date=datetime.now()-timedelta(1)
)
self.assertEqual(list(cat.get_articles_qs().all()), [art2, art1])
def test_publish_article(self):
initial_data = {'title': "test", 'content': "this is my article content"}
article = get_article_class().objects.create(publication=Article.DRAFT, **initial_data)
self._log_as_editor()
response = self.client.post(article.get_publish_url(), data={}, follow=True)
self.assertEqual(response.status_code, 200)
article = get_article_class().objects.get(id=article.id)
self.assertEqual(article.title, initial_data['title'])
self.assertEqual(article.content, initial_data['content'])
self.assertEqual(article.publication, Article.PUBLISHED)
def test_post_on_view_article(self):
initial_data = {'title': "test", 'content': "this is my article content"}
article = get_article_class().objects.create(publication=BaseArticle.PUBLISHED, **initial_data)
data = {"title": 'salut', 'content': 'bonjour!'}
self._log_as_editor()
response = self.client.post(article.get_absolute_url(), data=data, follow=True)
self.assertEqual(response.status_code, 404)
article = get_article_class().objects.get(id=article.id)
self.assertEquals(article.title, initial_data['title'])
self.assertEquals(article.content, initial_data['content'])
def test_change_homepage_anonymous(self):
Site.objects.get(id=settings.SITE_ID)
a1 = get_article_class().objects.create(title="python", content='python')
a2 = get_article_class().objects.create(title="django", content='django')
a3 = get_article_class().objects.create(title="home1", content='homepage1')
response = self.client.post(reverse('coop_cms_set_homepage', args=[a2.id]), data={'confirm': '1'}, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.redirect_chain[0][0], 302)
self.assertTrue(response.redirect_chain[-1][0].find(reverse('login')) >= 0)
a2 = get_article_class().objects.get(id=a2.id)
self.assertEqual(a2.homepage_for_site, None)
self.assertEqual(0, SiteSettings.objects.count())
def test_checks_aloah_links(self):
slugs = ("un", "deux", "trois", "quatre")
for slug in slugs:
get_article_class().objects.create(publication=Article.PUBLISHED, title=slug)
initial_data = {'title': "test", 'content': "this is my article content"}
article = get_article_class().objects.create(**initial_data)
self._log_as_editor()
response = self.client.get(reverse('aloha_init'))
context_slugs = [article.slug for article in response.context['links']]
for slug in slugs:
self.assertTrue(slug in context_slugs)
def test_article_edition_permission(self):
initial_data = {'title': "test", 'content': "this is my article content"}
article = get_article_class().objects.create(publication=Article.PUBLISHED, **initial_data)
data = {"title": 'salut', "content": 'oups'}
response = self.client.post(article.get_edit_url(), data=data, follow=True)
self.assertEqual(response.status_code, 200)
next_url = response.redirect_chain[-1][0]
login_url = reverse('django.contrib.auth.views.login')+"?next="+article.get_edit_url()
self.assertTrue(login_url in next_url)
article = get_article_class().objects.get(id=article.id)
self.assertEquals(article.title, initial_data['title'])
self.assertEquals(article.content, initial_data['content'])
def test_new_article_invalid_category_site(self):
article_class = get_article_class()
category1 = mommy.make(ArticleCategory)
category1.sites.clear()
category1.sites.add(Site.objects.get_current())
category1.save()
category2 = mommy.make(ArticleCategory)
category2.sites.clear()
category2.save()
self._log_as_editor()
data = {
'title': "Un titre",
'category': category2.id,
'publication': BaseArticle.DRAFT,
'template': get_article_templates(None, self.user)[0][0],
'navigation_parent': None,
'sites': [settings.SITE_ID]
}
response = self.client.post(reverse('coop_cms_new_article'),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(article_class.objects.count(), 0)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select("ul.errorlist")), 1)
def test_new_article_navigation(self):
article_class = get_article_class()
tree = get_navtree_class().objects.create()
self._log_as_editor()
data = {
'title': "Un titre",
'publication': BaseArticle.PUBLISHED,
'template': get_article_templates(None, self.user)[0][0],
'navigation_parent': -tree.id,
'sites': [settings.SITE_ID]
}
response = self.client.post(reverse('coop_cms_new_article'),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(article_class.objects.count(), 1)
article = article_class.objects.all()[0]
self.assertEqual(article.title, data['title'])
self.assertEqual(article.publication, data['publication'])
self.assertEqual(article.template, data['template'])
self.assertEqual(article.navigation_parent, -tree.id)
self.assertEqual(NavNode.objects.count(), 1)
node = NavNode.objects.all()[0]
self.assertEqual(node.content_object, article)
self.assertEqual(node.parent, None)
self.assertEqual(node.tree, tree)
def article_settings(request, article_id):
"""article settings"""
article = get_object_or_404(get_article_class(), id=article_id)
article_settings_form_class = get_article_settings_form()
if not request.user.has_perm('can_edit_article', article):
raise PermissionDenied
if request.method == "POST":
form = article_settings_form_class(request.user, request.POST, request.FILES, instance=article)
if form.is_valid():
article = form.save()
form.save_m2m()
return HttpResponseRedirect(article.get_absolute_url())
else:
form = article_settings_form_class(request.user, instance=article)
context = {
'article': article,
'form': form,
}
return render(
request,
'coop_cms/popup_article_settings.html',
context
)
def test_change_lang(self):
"""change language"""
original_text = '*!-+' * 10
translated_text = ':%@/' * 9
art1 = get_article_class().objects.create(title="Home",
content=original_text)
origin_lang = settings.LANGUAGES[0][0]
trans_lang = settings.LANGUAGES[1][0]
activate(origin_lang)
setattr(art1, 'title_' + trans_lang, 'Accueil')
setattr(art1, 'content_' + trans_lang, translated_text)
art1.save()
data = {'language': trans_lang}
response = self.client.post(reverse('coop_cms_switch_language_popup'),
data=data,
follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual(trans_lang, get_language())
def test_localized_slug_already_existing4(self):
"""test localized slug and existing article """
self._log_as_editor()
article_class = get_article_class()
art1 = article_class.objects.create(title="Home", content="aa")
art2 = article_class.objects.create(title="Rome",
content="aa",
template='test/article.html')
trans_lang = settings.LANGUAGES[1][0]
self.assertEqual(None, getattr(art2, 'slug_' + trans_lang))
# CHANGE LANGUAGE
activate(trans_lang)
url = art2.get_edit_url()
data = {
'title': art1.title,
'content': 'translation',
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
art2_updated = article_class.objects.get(id=art2.id)
self.assertEqual(getattr(art2_updated, 'title_' + trans_lang),
art1.title)
self.assertNotEqual(getattr(art2_updated, 'slug_' + trans_lang),
art1.slug)
def create_article_non_ascii_char(self):
"""create an article with russian characters"""
title = "Миниальбом"
article_class = get_article_class()
article1 = article_class.objects.create(title=title)
response = self.client.get(article1.get_absolute_url())
self.assertEqual(200, response.status_code)
def _do_change_language(request, lang_code, current_url):
"""change the language and returns redirect URL"""
if lang_code and check_for_language(lang_code):
# path is the locale-independent url
path = strip_locale_path(current_url)[1]
article_class = get_article_class()
try:
# get the translated slug of the current article
# If switching from French to English and path is /fr/accueil/
# The next should be : /en/home/
# Get the article
next_article = article_class.objects.get(slug=path.strip('/'))
except article_class.DoesNotExist:
next_article = None
if hasattr(request, 'session'):
request.session['django_language'] = lang_code
activate(lang_code)
if next_article:
next_url = next_article.get_absolute_url()
else:
next_url = make_locale_path(path, lang_code)
return next_url
def test_homepage_url(self):
site = Site.objects.get(id=settings.SITE_ID)
article1 = get_article_class().objects.create(title="pythonx", content='pythonx')
article1_url = reverse('coop_cms_view_article', args=[article1.slug])
mommy.make(SiteSettings, site=site, homepage_article=article1.slug)
self.assertNotEqual(article1.get_absolute_url(), article1_url)
self.assertEqual(article1.get_absolute_url(), reverse('coop_cms_homepage'))
def get_article_or_404(slug, **kwargs):
"""get article or 404"""
article_class = get_article_class()
try:
return get_article(slug, **kwargs)
except article_class.DoesNotExist:
raise Http404
def redirect_if_alias(path):
"""redirect if path correspond to an alias"""
article_class = get_article_class()
site = Site.objects.get_current()
# look for an article corresponding to this path. For example if trailing slash is missing in the url
try:
article = article_class.objects.get(slug=path,
sites=site,
publication=BaseArticle.PUBLISHED)
except article_class.DoesNotExist:
article = None
if article:
return HttpResponseRedirect(article.get_absolute_url())
else:
# look for a regular alias
try:
alias = Alias.objects.get(path=path, sites=site)
except Alias.DoesNotExist:
if path and path[-1] == '/':
alias = get_object_or_404(Alias, path=path[:-1], sites=site)
else:
alias = None
if alias and alias.redirect_url:
if alias.redirect_code == 301:
return HttpResponsePermanentRedirect(alias.redirect_url)
else:
return HttpResponseRedirect(alias.redirect_url)
else:
raise Http404
def _log_as_editor(self, can_add=False):
if not self.editor:
self.editor = User.objects.create_user('toto', '*****@*****.**',
'toto')
self.editor.is_staff = True
self.editor.is_active = True
can_edit_newsletter = Permission.objects.get(
content_type__app_label='coop_cms',
codename='change_newsletter')
self.editor.user_permissions.add(can_edit_newsletter)
ct = ContentType.objects.get_for_model(get_article_class())
codename = 'change_{0}'.format(ct.model)
can_edit_article = Permission.objects.get(
content_type__app_label=ct.app_label, codename=codename)
self.editor.user_permissions.add(can_edit_article)
if can_add:
codename = 'add_{0}'.format(ct.model)
can_add_article = Permission.objects.get(
content_type__app_label=ct.app_label, codename=codename)
self.editor.user_permissions.add(can_add_article)
self.editor.save()
return self.client.login(username='******', password='******')
def test_new_article_two_sites(self):
other_site = mommy.make(Site)
article_class = get_article_class()
self._log_as_editor()
data = {
'title': "Un titre",
'publication': BaseArticle.DRAFT,
'template': get_article_templates(None, self.user)[0][0],
'navigation_parent': None,
'sites': sorted([settings.SITE_ID, other_site.id])
}
response = self.client.post(reverse('coop_cms_new_article'),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(article_class.objects.count(), 1)
article = article_class.objects.all()[0]
self.assertEqual(article.title, data['title'])
self.assertEqual(article.publication, data['publication'])
self.assertEqual(article.template, data['template'])
self.assertEqual(article.navigation_parent, None)
self.assertEqual(NavNode.objects.count(), 0)
self.assertEqual(
[_article.id for _article in article.sites.order_by("id")],
data['sites'])
def test_localize_existing_article2(self):
"""test localized existing article 2 """
self._log_as_editor()
article_class = get_article_class()
art1 = article_class.objects.create(title="Accueil",
template='test/article.html')
origin_lang = settings.LANGUAGES[0][0]
trans_lang = settings.LANGUAGES[1][0]
# CHANGE LANGUAGE
activate(trans_lang)
url = art1.get_edit_url()
data = {
'title': "Home",
'content': 'translation',
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
art1_updated = article_class.objects.get(id=art1.id)
self.assertEqual(getattr(art1_updated, 'title_' + origin_lang),
art1.title)
self.assertEqual(getattr(art1_updated, 'title_' + trans_lang),
data["title"])
self.assertEqual(getattr(art1_updated, 'slug_' + trans_lang), "home")
self.assertEqual(getattr(art1_updated, 'slug_' + origin_lang),
"accueil")
def test_edit_article_html_with_img_wrapper(self):
"""It should save article correctly"""
article = get_article_class().objects.create(
title="test", publication=BaseArticle.PUBLISHED)
content = """
<p><div
contenteditable="false"
style="overflow: hidden; position: relative; display: inline-block; float: none;"
class="ui-wrapper aloha-image-box-active Aloha_Image_Resize aloha"
>
<img src="moby-dick.jpg" style="height: 207px; width: 269px;" class="ui-resizable" />
<div class="ui-resizable-handle ui-resizable-ne" style="z-index: 1000;"></div>
<div class="ui-resizable-handle ui-resizable-se ui-icon" style="z-index: 1000;"></div>
<div class="ui-resizable-handle ui-resizable-sw" style="z-index: 1000;"></div>
<div class="ui-resizable-handle ui-resizable-nw" style="z-index: 1000;"></div>
</div></p>
"""
data = {"title": 'salut', 'content': content}
self._log_as_editor()
response = self.client.post(article.get_edit_url(),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
expected_content = '<p><img class="" src="moby-dick.jpg" style="height: 207px; width: 269px;"/></p>'
data['content'] = expected_content
self._check_article(response, data)
def new_article(request):
"""new article"""
article_class = get_article_class()
new_article_form = get_new_article_form()
content_type = ContentType.objects.get_for_model(article_class)
perm = '{0}.add_{1}'.format(content_type.app_label, content_type.model)
if not request.user.has_perm(perm):
raise PermissionDenied
if request.method == "POST":
form = new_article_form(request.user, request.POST, request.FILES)
if form.is_valid():
article = form.save()
form.save_m2m()
success_message(request, _('The article has been created properly'))
return HttpResponseRedirect(article.get_edit_url())
else:
form = new_article_form(request.user)
return render(
request,
'coop_cms/popup_new_article.html',
locals()
)
def set_homepage(request, article_id):
"""use the article as homepage"""
article = get_object_or_404(get_article_class(), id=article_id)
if not request.user.has_perm('can_edit_article', article):
raise PermissionDenied
if request.method == "POST":
site_settings = models.SiteSettings.objects.get_or_create(
site=Site.objects.get_current())[0]
if homepage_no_redirection():
site_settings.homepage_url = ''
site_settings.homepage_article = article.slug
else:
site_settings.homepage_url = article.get_absolute_url()
site_settings.homepage_article = ''
site_settings.save()
return HttpResponseRedirect(reverse('coop_cms_homepage'))
context_dict = {
'article': article,
'title': _("Do you want to use this article as homepage?"),
}
return render(request, 'coop_cms/popup_set_homepage.html', context_dict)
class ArticleView(EditableObjectView):
"""Article view for edition"""
model = get_article_class()
form_class = get_article_form()
field_lookup = "slug"
varname = "article"
as_homepage = False
def get_object(self):
"""get object"""
article = get_article_or_404(slug=self.kwargs['slug'], sites=settings.SITE_ID)
if not self.edit_mode:
if article.is_homepage and homepage_no_redirection() and not self.as_homepage:
# Do not authorize access to homepage with its urls in 'homepage_no_redirection' mode
raise ArticleNotAllowed
return article
def dispatch(self, request, *args, **kwargs):
try:
return super(ArticleView, self).dispatch(request, *args, **kwargs)
except Http404:
slug = self.kwargs['slug']
return redirect_if_alias(slug)
except ArticleNotAllowed:
raise Http404
def can_access_object(self):
"""perms -> 404 if no perms"""
if self.object.login_required and not self.request.user.is_authenticated: # TODO
raise PermissionDenied
if self.object.is_archived():
return super(ArticleView, self).can_view_object()
return True
def get_headlines(self):
"""headline"""
return get_headlines(self.object)
def get_context_data(self):
"""context"""
context_data = super(ArticleView, self).get_context_data()
context_data.update({
'draft': self.object.publication == models.BaseArticle.DRAFT,
'headlines': self.get_headlines(),
'ARTICLE_PUBLISHED': models.BaseArticle.PUBLISHED
})
return context_data
def after_save(self, article):
"""after save"""
if article.temp_logo:
article.logo = article.temp_logo
article.temp_logo = ''
article.save()
def get_template(self):
"""get template"""
return get_article_template(self.object)
def test_view_articles_category_pagination_size_default(self):
"""view articles by category: check pagination"""
article_class = get_article_class()
cat = mommy.make(ArticleCategory)
for i in range(30):
mommy.make(article_class,
category=cat,
publication_date=datetime(2014, 3, i + 1),
title="AZERTY-{0}-UIOP".format(i),
publication=BaseArticle.PUBLISHED)
url = reverse('coop_cms_articles_category', args=[cat.slug])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
ids = list(range(30))
ids.reverse()
for i in ids[:5]:
self.assertContains(response, "AZERTY-{0}-UIOP".format(i))
for i in ids[5:]:
self.assertNotContains(response, "AZERTY-{0}-UIOP".format(i))
response = self.client.get(url + "?page=2")
self.assertEqual(response.status_code, 200)
for i in ids[5:10]:
self.assertContains(response, "AZERTY-{0}-UIOP".format(i))
for i in ids[:5]:
self.assertNotContains(response, "AZERTY-{0}-UIOP".format(i))
def test_link_existing_force_default_lang(self):
"""text article_link tag when language is forced to default"""
article_class = get_article_class()
article = article_class.objects.create(title="Test")
request = self._request()
def_lang = settings.LANGUAGES[0][0]
cur_lang = request.LANGUAGE_CODE = settings.LANGUAGES[1][0]
#activate(cur_lang)
setattr(article, "slug_" + cur_lang, "test_" + cur_lang)
article.save()
count = article_class.objects.count()
tpl = Template('{% load coop_utils %}{% article_link "test" ' +
def_lang + ' %}')
tpl.render(Context({'request': request}))
self.assertEqual(article_class.objects.count(), count)
article = article_class.objects.get(id=article.id)
self.assertEqual(article.slug, "test")
self.assertEqual(getattr(article, "slug_" + cur_lang),
"test_" + cur_lang)
def test_view_private_article(self):
"""test user can view his private article"""
article = mommy.make(get_article_class(), author=self.user)
self.assertTrue(
self.client.login(username=self.user.username, password='******'))
response = self.client.get(article.get_absolute_url())
self.assertEqual(200, response.status_code)
def update_logo(request, article_id):
"""update logo"""
try:
article = get_object_or_404(get_article_class(), id=article_id)
if request.method == "POST":
form = ArticleLogoForm(request.POST, request.FILES)
if form.is_valid():
article.temp_logo = form.cleaned_data['image']
article.save()
url = article.logo_thumbnail(True).url
data = {'ok': True, 'src': url}
return HttpResponse(json.dumps(data), content_type='application/json')
else:
template = get_template('coop_cms/popup_update_logo.html')
html = template.render(locals())
data = {'ok': False, 'html': html}
return HttpResponse(json.dumps(data), content_type='application/json')
else:
form = ArticleLogoForm()
return render(
request,
'coop_cms/popup_update_logo.html',
locals()
)
except Exception:
logger.exception("update_logo")
raise
def last_articles(self,number):
article_list = []
all_articles = get_article_class().objects.all().order_by('-created')[:number]
for a in all_articles:
if a.navigation_parent == None :
article_list.append(a)
return article_list
def test_create_article_in_third_lang(self):
"""test create article into an other language than the default"""
article_class = get_article_class()
default_lang = settings.LANGUAGES[0][0]
other_lang = settings.LANGUAGES[1][0]
third_lang = settings.LANGUAGES[2][0]
activate(third_lang)
content = "a!*%:" * 10
art1 = article_class.objects.create(title="abcd",
content=content,
publication=BaseArticle.PUBLISHED)
self.assertEqual(art1.slug, 'abcd')
third_lang_url = art1.get_absolute_url()
response = self.client.get(third_lang_url)
self.assertEqual(200, response.status_code)
self.assertContains(response, content)
activate(other_lang)
art1.title = 'efgh'
art1.save()
self.assertEqual(art1.slug, 'efgh')
response = self.client.get(art1.get_absolute_url())
self.assertEqual(200, response.status_code)
self.assertNotContains(response, content)
response = self.client.get(
third_lang_url.replace('/' + third_lang + '/',
'/' + other_lang + '/', 1))
self.assertEqual(404, response.status_code)
def _get_navigation_parent(self):
ct = ContentType.objects.get_for_model(get_article_class())
nodes = NavNode.objects.filter(object_id=self.id, content_type=ct)
if nodes.count():
return nodes[0].parent.id if nodes[0].parent else 0
else:
return None
def get_article_or_404(slug, **kwargs):
"""get article or 404"""
article_class = get_article_class()
try:
return get_article(slug, **kwargs)
except article_class.DoesNotExist:
raise Http404
def redirect_if_alias(path):
"""redirect if path correspond to an alias"""
article_class = get_article_class()
site = Site.objects.get_current()
# look for an article corresponding to this path. For example if trailing slash is missing in the url
try:
article = article_class.objects.get(slug=path, sites=site, publication=BaseArticle.PUBLISHED)
except article_class.DoesNotExist:
article = None
if article:
return HttpResponseRedirect(article.get_absolute_url())
else:
# look for a regular alias
try:
alias = Alias.objects.get(path=path, sites=site)
except Alias.DoesNotExist:
if path and path[-1] == '/':
alias = get_object_or_404(Alias, path=path[:-1], sites=site)
else:
alias = None
if alias and alias.redirect_url:
if alias.redirect_code == 301:
return HttpResponsePermanentRedirect(alias.redirect_url)
else:
return HttpResponseRedirect(alias.redirect_url)
else:
raise Http404
def update_logo(request, article_id):
"""update logo"""
try:
article = get_object_or_404(get_article_class(), id=article_id)
if request.method == "POST":
form = ArticleLogoForm(request.POST, request.FILES)
if form.is_valid():
article.temp_logo = form.cleaned_data['image']
article.save()
url = article.logo_thumbnail(True).url
data = {'ok': True, 'src': url}
return HttpResponse(json.dumps(data), content_type='application/json')
else:
template = get_template('coop_cms/popup_update_logo.html')
html = template.render(locals())
data = {'ok': False, 'html': html}
return HttpResponse(json.dumps(data), content_type='application/json')
else:
form = ArticleLogoForm()
return render(
request,
'coop_cms/popup_update_logo.html',
locals()
)
except Exception:
logger.exception("update_logo")
raise
def article_settings(request, article_id):
"""article settings"""
article = get_object_or_404(get_article_class(), id=article_id)
article_settings_form_class = get_article_settings_form()
if not request.user.has_perm('can_edit_article', article):
raise PermissionDenied
if request.method == "POST":
form = article_settings_form_class(request.user, request.POST, request.FILES, instance=article)
if form.is_valid():
article = form.save()
form.save_m2m()
return HttpResponseRedirect(article.get_absolute_url())
else:
form = article_settings_form_class(request.user, instance=article)
context = {
'article': article,
'form': form,
}
return render(
request,
'coop_cms/popup_article_settings.html',
context
)
def new_article(request):
"""new article"""
article_class = get_article_class()
new_article_form = get_new_article_form()
content_type = ContentType.objects.get_for_model(article_class)
perm = '{0}.add_{1}'.format(content_type.app_label, content_type.model)
if not request.user.has_perm(perm):
raise PermissionDenied
if request.method == "POST":
form = new_article_form(request.user, request.POST, request.FILES)
if form.is_valid():
article = form.save()
form.save_m2m()
success_message(request, _('The article has been created properly'))
return HttpResponseRedirect(article.get_edit_url())
else:
form = new_article_form(request.user)
return render(
request,
'coop_cms/popup_new_article.html',
locals()
)
def test_article_settings(self):
self._log_as_editor()
article_class = coop_settings.get_article_class()
article = mommy.make(article_class, slug="test")
url = reverse('coop_cms_article_settings', args=[article.id])
now = datetime.now()
now = now.replace(microsecond=0)
data = {
'template': settings.COOP_CMS_ARTICLE_TEMPLATES[0][0],
'publication_date': now,
'publication': BaseArticle.PUBLISHED,
'in_newsletter': False,
'summary': 'Summary',
'navigation_parent': None,
'sites': [settings.SITE_ID],
}
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
self.assertEqual(article_class.objects.count(), 1)
article = article_class.objects.all()[0]
for field in data:
if field == "sites":
self.assertEqual([x.id for x in getattr(article, field).all()],
data[field])
else:
self.assertEqual(getattr(article, field), data[field])
def test_edit_with_blocks(self):
"""test edition with block templatetag inside the cms_edit template tag"""
article_class = coop_settings.get_article_class()
article = mommy.make(
article_class,
title="This is my article",
content="<p>This is my <b>content</b></p>",
template='coop_cms/test_app/custom_tag_template.html')
self._log_as_editor()
data = {
"title": "This is a new title",
'content': "<p>This is a <i>*** NEW ***</i> <b>content</b></p>"
}
response = self.client.post(article.get_edit_url(),
data=data,
follow=True)
self.assertEqual(response.status_code, 200)
article = article_class.objects.get(id=article.id)
self.assertEqual(article.title, data['title'])
self.assertEqual(article.content, data['content'])
self.assertContains(response, article.title)
self.assertContains(response, article.content)
self.assertContains(response, "*** HELLO FROM CHILD ***")
self.assertContains(response, "*** HELLO FROM PARENT ***")
self.assertContains(response, "*** HELLO FROM BLOCK ***")
def test_view_article_not_allowed(self):
self._log_as_viewer()
article_class = coop_settings.get_article_class()
url = reverse('coop_cms_new_article')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self.assertEqual(article_class.objects.count(), 0)
def test_view_article_on_site2(self):
site1 = Site.objects.all()[0]
site2 = Site.objects.create(domain='hhtp://test2', name="Test2")
settings.SITE_ID = site2.id
article = get_article_class().objects.create(title="test", publication=BaseArticle.PUBLISHED)
response = self.client.get(article.get_absolute_url())
self.assertEqual(200, response.status_code)
def test_create_article_complex_html_in_title(self):
"""create article with html tag in title"""
article_class = get_article_class()
article1 = article_class.objects.create(title="<p><h2>Titre de <b>l'article</b><h2><div></div></p>")
response = self.client.get(article1.get_absolute_url())
self.assertEqual(200, response.status_code)
expected_title = self._get_localized_slug("/titre-de-larticle/")
self.assertEqual(article1.get_absolute_url(), expected_title)
def test_view_article_settings_not_allowed(self):
self._log_as_viewer()
article_class = coop_settings.get_article_class()
article = mommy.make(article_class, slug="test")
url = reverse('coop_cms_article_settings', args=[article.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self.assertEqual(article_class.objects.count(), 1)
def test_view_article_settings_anonymous(self):
article_class = coop_settings.get_article_class()
article = mommy.make(article_class, slug="test")
url = reverse('coop_cms_article_settings', args=[article.id])
response = self.client.get(url)
self.assertEqual(302, response.status_code)
auth_url = get_login_url()
self.assertRedirects(response, auth_url + '?next=' + url)
def items(self):
"""items"""
article_class = get_article_class()
queryset = article_class.objects.filter(publication=BaseArticle.PUBLISHED)
items = []
for site in self.sites():
items.extend(queryset.filter(sites=site))
return items
class Meta:
model = get_article_class()
fields = (
'title', 'template', 'category', 'headline', 'publication', 'in_newsletter', 'sites', 'login_required',
)
widgets = {
'sites': forms.CheckboxSelectMultiple(),
}
