def test_anon_faces_wall(self):
a1 = Article(headline='test1')
a1.save()
s = requests.Session()
response = s.get(self.live_server_url + a1.get_absolute_url())
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
a2 = Article(headline='test2')
a2.save()
response = s.get(self.live_server_url + a2.get_absolute_url())
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
a3 = Article(headline='test3')
a3.save()
response = s.get(self.live_server_url + a3.get_absolute_url())
self.assertIn("Nos gustaría que te suscribieras", response.text)
def get_articles(self, categoryitem, lang, site):
cats = self.get_items_as_tree(categoryitem, 0)
manager = BaseManager()
manager.fetchOptions = {
'site': site.id,
'active': 1,
'activesite': site.id
}
manager.model = Article()
manager.modelLanguage = ArticleLanguage()
manager.order = 'date'
manager.debugger.filename = 'megamenu.py'
manager.rangeItemsStart = 1
manager.rangeItemsEnd = 5
manager.moduleName = '__adm_Articles__'
items = []
if 1:
#for cat in cats:
#manager.fetchOptions.update({ 'category__id': cat.id })
manager.fetchOptions.update({'category': cats})
manager.fetch_items(default_filter=False)
if manager.items:
for item in manager.items:
item.get_language(lang.id)
items.append(item)
manager.items = items
return manager.items[:5]
def choices(self, system):
s = ((datetime.date.today() + datetime.timedelta(days=1)) -
datetime.timedelta(6 * 365 / 12))
manager = BaseManager()
manager.model = Article()
manager.modelLanguage = ArticleLanguage()
manager.order = '-date'
manager.fetchOptions = {
'date_gte': s.isoformat(),
'site': system.portal.activeSite.id,
'active': system.requester.rData['selectedactivity'],
'activesite': system.requester.rData['activesite']
}
manager.rangeItemsStart = None
manager.rangeItemsEnd = None
manager.fetch_items()
items = manager.items
#items = Article.objects.optfilter(manager.fetchOptions)
#print '--->',items
choices = []
if items is not None:
manager.set_language(system.language.currentLanguage)
for il in items:
choices.append((il.id, il.language))
self.fields['article'].choices = choices
def test_reading_entry_str(self):
username = '******'
link = 'https://www.superlink.com/article.html'
article = Article(link=link)
user = User(username=username)
entry = ReadingEntry(user=user, article=article)
self.assertEqual("{} - {}".format(username, link[:50]), str(entry))
def handle(self, *args, **options):
Article.objects.all().delete()
Chapter.objects.all().delete()
for file in glob.glob("programme/chapitre*/index.md"):
title = open(file).read().split('\n')[0][1:].strip()
Chapter(
number=file.split('chapitre-')[1].split('/')[0],
slug=slugify(title),
title=title,
content='\n'.join(open(file).read().split('\n')[1:]),
).save()
for file in glob.glob("programme/chapitre*/*.md"):
if 'index.md' in file:
continue
chapter_number = file.split('chapitre-')[1].split('/')[0]
chapter = Chapter.objects.get(number=chapter_number)
title = open(file).read().split('\n')[0][1:].strip()
Article(
number=int(file.split('/')[-1].replace('.md', '')),
slug=slugify(title),
title=title,
content='\n'.join(open(file).read().split('\n')[1:]),
chapter=chapter,
).save()
def test_user_not_authenticated(self):
Article(title='title', body='body').put()
url = reverse('article_admin_delete', kwargs={'id': 1})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(Article.all().count(), 1)
def test_article_exist(self):
key = Article(title='title', body='body').put()
self.users_login('admin@localhost', is_admin=True)
url = reverse('article_admin_delete', kwargs={'id': key.id()})
resp = self.client.get(url)
self.assertRedirects(resp, reverse('index'))
self.assertEqual(Article.all().count(), 0)
def test_article_does_not_exist(self):
Article(key_name='randomkey', title='title', body='body').put()
self.users_login('admin@localhost', is_admin=True)
url = reverse('article_admin_delete', kwargs={'id': 1})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 404)
self.assertEqual(Article.all().count(), 1)
def test_user_not_admin(self):
Article(title='title', body='body').put()
self.users_login('user@localhost', is_admin=False)
url = reverse('article_admin_delete', kwargs={'id': 1})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(Article.all().count(), 1)
def add(request):
if request.method == "GET":
# ...
return render(request, "add.html")
elif request.method == "POST":
form = request.POST
article = Article(title=form["title"],
text=form["text"],
author=request.user)
article.save()
return redirect(homepage)
def test_fetch(self, mock_requests):
article = Article(link='http://test')
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = '<html>\
<head><title>Test</title></head>\
<body><h1>Test</h1>\
<p>content</p>\
</html>'
retrieve_article_content(article)
mock_requests.get.assert_called_with(article.link)
self.assertEqual(article.status, cst.READY_STATUS)
def test_subscriber_passes_wall(self):
user = User.objects.create_user('user2', '*****@*****.**', 'ldu2')
user.user_permissions.add(
Permission.objects.get(codename='es_suscriptor_default'))
s = self.login(user.username, 'ldu2')
a1 = Article(headline='test1')
a1.save()
response = s.get(self.live_server_url + a1.get_absolute_url())
self.assertIn(user.username, response.text)
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
a2 = Article(headline='test2')
a2.save()
response = s.get(self.live_server_url + a2.get_absolute_url())
self.assertIn(user.username, response.text)
self.assertNotIn("Nos gustaría que te suscribieras", response)
a3 = Article(headline='test3')
a3.save()
response = s.get(self.live_server_url + a3.get_absolute_url())
self.assertIn(user.username, response.text)
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
def load_to_db_from_csv(file):
sites_names = (REDDIT, ML_MASTERY, ML_WEEKLY, MIT_NEWS)
sites = [Site.objects.get(name=site) for site in sites_names]
sites_dict = dict(zip(sites_names, sites))
with open(file, 'r') as f:
reader = csv.reader(f)
articles = [
Article(title=row[0],
link=row[1],
timestamp=row[2],
site=sites_dict[row[3]]) for row in reader
]
Article.objects.bulk_create(articles)
def test_non_subscriber_faces_wall(self):
user = User.objects.create_user('user1', '*****@*****.**', 'ldu1')
s = self.login(user.username, 'ldu1')
a1 = Article(headline='test1')
a1.save()
response = s.get(self.live_server_url + a1.get_absolute_url())
self.assertEqual(response.status_code, 200)
self.assertIn(user.username, response.text)
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
a2 = Article(headline='test2')
a2.save()
response = s.get(self.live_server_url + a2.get_absolute_url())
self.assertEqual(response.status_code, 200)
self.assertIn(user.username, response.text)
self.assertNotIn("Nos gustaría que te suscribieras", response.text)
a3 = Article(headline='test3')
a3.save()
r = s.get(self.live_server_url + a3.get_absolute_url())
self.assertEqual(r.status_code, 200)
self.assertIn(user.username, r.text)
self.assertIn("Nos gustaría que te suscribieras", r.text)
def __init__(self, request, *args, **kwargs):
super(SystemObject, self).__init__(request, *args, **kwargs)
self.manager = Manager()
self.manager.fetchOptions = { 'site': self.portal.reqsite, 'active': 1, 'activesite': self.portal.reqsite }
self.urls.show_items = 'core.view.articleadmin.show_items'
self.manager.model = Article()
self.manager.modelLanguage = ArticleLanguage()
self.manager.order = '-date'
self.manager.debugger.filename = 'articleadmin.py'
self.manager.moduleName = '__adm_Articles__'
self.category = Manager()
self.category.model = Category()
self.category.order = 'parent'
self.category.fetchOptions = { 'site': self.portal.reqsite, 'active': 1, 'activesite': self.portal.reqsite }
self.category.modelLanguage = CategoryLanguage()
def __init__(self, request, *args, **kwargs):
super(SystemObject, self).__init__(request, *args, **kwargs)
self.manager = AdminManager()
self.manager.fetchOptions = { 'site': int(self.portal.activeSite.id), 'active': self.requester.rData['selectedactivity'], 'activesite': self.requester.rData['activesite'] }
self.urls.add = 'core.view.articleadmin.add_item'
self.urls.edit = 'core.view.articleadmin.edit_item'
self.urls.show_items = 'core.view.articleadmin.show_items'
self.manager.model = Article()
self.manager.modelLanguage = ArticleLanguage()
self.manager.form_class = AdmItemForm().__class__
self.manager.language_form_class = AdmItemLanguageForm().__class__
self.manager.order = '-date'
self.manager.debugger.filename = 'articleadmin.py'
self.manager.moduleName = '__adm_Articles__'
self.data.update({ 'filter_activity': reverse('core.view.articleadmin.show_items') })
self.data.update({ 'savebutton': 1, 'saveaddbutton': 1, 'copybutton': 1, 'addbutton': 1 })
self.category = AdminManager()
self.category.model = Category()
self.category.order = 'parent'
self.category.fetchOptions = { 'site': self.portal.activeSite.id, 'active': self.requester.rData['selectedactivity'], 'activesite': self.requester.rData['activesite'] }
self.category.modelLanguage = CategoryLanguage()
def test_get_by_id_or_404_article_found(self):
key = Article(title='title', body='body').put()
result = Article.get_by_id_or_404(key.id())
self.assertEqual(key, result.key())
def setUp(self):
create_blog()
self.key = Article(title='title123', body='body123').put()
self.url = reverse('article_admin_update',
kwargs={'id': self.key.id()})
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super(ParseView, self).get_context_data(**kwargs)
epub_file = context['files'].f
file = EpubFile.objects.get(f=epub_file)
epub_section = file.section
try:
book = epub.read_epub(epub_file)
for item in book.get_items():
# - 9 es el codigo de tipo de archivo xhtml
if (item.get_type() is 9):
content = item.get_body_content()
print content
#reemplazo los estilos con classes css del xhtml del epub
content = replace_style(
content, '<span class="char-style-override-1">',
'</span>', '<span>', '</span> ')
content = replace_style(
content, '<span class="char-style-override-3">',
'</span>', '_', '_')
content = replace_style(
content,
'<span class="Muy-destacado char-style-override-3">',
'</span>', '', '')
content = replace_style(
content,
'<span class="Muy-destacado char-style-override-4">',
'</span>', '', '')
content = replace_style(content, '<p class="Subt-tulo">',
'</p>', '<p class="Normal">\nS>',
'</p>')
content = replace_style(
content, '<p class="Primer para-style-override-1">',
'</p>', '<p class="Primer">', '</p>')
content = replace_style(content, '<span>', '</span>', ' ',
' ')
soup = BeautifulSoup(content, 'html.parser')
#cada subcuadro contiene un articulo
subcuadro_nota = soup('div', {'class': 'Subcuadro-nota'})
for e in subcuadro_nota:
tag = etree.fromstring(str(e))
titulo = ''.join(
tag.xpath(
'//p[starts-with(@class, "T-tulo")]/text()'))
bajada = ''.join(
tag.xpath('//p[@class="Bajada"]/text()'))
copete = ''.join(
tag.xpath(
'//p[starts-with(@class, "Copete")]/text()'))
parrafos = '\n\n'.join(
tag.xpath(
'(//p[@class="Primer"]|//p[@class="Normal"]|//p[@class="Normal"]/span '
'|//p[@class="Subt-tulo"]|//p[@class="Autor"])/text()'
))
if titulo:
try:
article = Article(
headline=titulo,
deck=bajada,
lead=copete,
#home_lead=copete,
body=parrafos,
)
article.save()
ar = Article.objects.get(id=article.id)
ar.sections.add(epub_section.id)
ar.save()
success_msg = 'Articulo generado correctamente: %s' % article.headline
messages.success(self.request,
success_msg,
fail_silently=True)
except:
traceback.print_exc()
messages.error(
self.request,
'Hubo un error al procesar el archivo')
except:
traceback.print_exc()
messages.error(self.request,
'Hubo un error al procesar el archivo')
files = EpubFile.objects.order_by('-id')
section = Section.objects.all()
context['files'] = files
context['section'] = section
return context
def test_articles_body_in_page(self):
Article(title='title_article_one', body='body_one').put()
Article(title='title_article_two', body='body_two').put()
resp = self.client.get(self.url)
self.assertContains(resp, 'body_one')
self.assertContains(resp, 'body_two')
def save_todb(self):
db_objs = []
for x in self.results:
obj = Article(source_file=self.source, **x)
db_objs.append(obj)
Article.objects.bulk_create(db_objs)
from core.models import Article
objs = []
for i in range(10):
obj = Article(title=f'{i} article')
objs.append(obj)
Article.objects.bulk_create(objs)
def test_get_by_id_or_404_no_article(self):
key = Article(title='title', body='body').put()
free_key = key.id() + 1
with self.assertRaises(Http404):
Article.get_by_id_or_404(free_key)
def save_article(data):
"""Create or update an article content type"""
"""Basic workflow:
node create --> article create --> node assoicate to article --> node hash
"""
# Test content type exists first
content_type_content = ContentType.query.filter_by(
name="Article Content Type"
).first()
if not content_type_content:
logging.error("Content Type 'Article' not found' crash and burn")
exit(1)
else:
# Kind of redundant to load this again, but it sticks to the content model
content_type = load_content(load_node(content_type_content._node_id))
if data["hidden_node_id"] and data["hidden_node_version"]: # Assume update
existing_content = load_content(load_node(data["hidden_node_id"]))
# @TODO Check hashes here just cause we can
# @TODO Check locks here, if locked restore form and return user
content_revision = save_revision(existing_content["content"], ArticleRevision)
new_version_number = existing_content["content"]._version + 1
existing_content["content"]._version = new_version_number
existing_content["content"]._node_id = existing_content["node"]._id
existing_content["content"]._lock = ""
existing_content["content"].title = clean_html(data["title"])
existing_content["content"].body = clean_html(data["body"])
existing_content["content"]._hash = _hash_table(existing_content["content"])
existing_content["content"]._hash_chain = _hash_table(
existing_content["content"], chain=True
)
existing_content["content"]._hash = _hash_table(
existing_content["content"]
) # Hash after updating object values
existing_content["content"]._hash_chain = _hash_table(
existing_content["content"], chain=True
)
db.session.add(existing_content["content"])
db.session.commit()
db.session.refresh(existing_content["content"])
return existing_content
else: # Assume new article
node = _register_node()
article = Article(
_version=1,
_node_id=node._id,
_lock="",
title=data["title"],
body=data["body"],
)
# First save get's our article ID to include in the hash
db.session.add(article)
db.session.commit()
db.session.refresh(article)
article._hash = _hash_table(article) # Hash after getting id
article._hash_chain = _hash_table(article, chain=True)
db.session.add(article)
db.session.commit()
db.session.refresh(article)
content_obj = _associate_node(node, article, content_type)
return content_obj
def setUp(self):
self.owner = User(username='******', email='owner@local')
self.other = User(username='******', email='other@local')
article = Article(link='http://nowhere.local')
self.entry = ReadingEntry(user=self.owner, article=article)
self.factory = RequestFactory()
def arts(request):
system = SystemObject(request)
data = dict()
fw = []
#items = DentoData.objects.using('dento').all().order_by('-added')
#gallery = Gallery.objects.get(id=2)
site = SitePortal.objects.get(id=1) # lekarze
items = Category.objects.optfilter({'site': site.id})
for cat in items:
if cat.dentoid is not None:
arts = DentoData.objects.using('dento').filter(
linkID=cat.dentoid).order_by('-added')
for item in arts:
text = ''
art = Article()
art.save()
system.language.set_non_existent_language_items(
art, ArticleLanguage)
art.get_language(system.language.currentLanguage.id)
if item.intro is not None:
item.intro = item.intro.replace('\n', u'</p><p>')
item.intro = change_image(item.ID, item.intro, art)
text = text + '<p>' + item.intro + '</p>'
if item.body is not None:
item.body = item.body.replace('\n', u'</p><p>')
item.body = change_image(item.ID, item.body, art)
text = text + '<p>' + item.body + '</p>'
if item.title is not None:
item.title = item.title.replace('\n\n', u'')
item.title = change_image(item.ID,
item.title,
art,
only_main=True,
show=True)
art.language.title = item.title
fw.append(art.dentomainimage)
art.language.text = text
art.visits = item.displayCount
if item.added:
art.date = item.added
art.category = cat
art.save()
art.language.save()
art.sites.add(site.site)
if item.active:
art.active.add(site.site)
time.sleep(0.2)
data.update({'data': fw})
t = loader.get_template('imp/impart.html')
c = RequestContext(request, data)
return HttpResponse(t.render(c))
def test_fetch_error(self, mock_requests):
article = Article(link='http://test.test/test.html')
mock_requests.get.side_effect = Exception()
retrieve_article_content(article)
mock_requests.get.assert_called_with(article.link)
self.assertEqual(article.status, cst.ERROR_STATUS)
def test_put_article(self):
entity = Article(key_name='test1', title='test_title1')
entity.put()
entity_for_assert = Article.get_by_key_name('test1')
self.assertEquals(entity_for_assert.title, 'test_title1')
def test_article_str(self):
link = 'http://somenews.fr/article.html'
article = Article(link=link)
self.assertEqual(str(article), link)
