def updateblog(request):
# Get feed
url = 'http://blog.instanssi.org/feeds/posts/default'
feed = feedparser.parse(url)
# Delete old entries
BlogEntry.objects.filter(locked=False).delete()
# Get items that have changed
for item in feed['items']:
locked = False
try:
oldentry = BlogEntry.objects.get(title=item['title'])
locked = oldentry.locked
except BlogEntry.DoesNotExist:
pass
if not locked:
timestamp = datetime.fromtimestamp(
time.mktime(item['published_parsed'])) + timedelta(hours=2)
entry = BlogEntry()
entry.title = item['title']
entry.summary = item['summary']
entry.date = timestamp
entry.link = item['link']
entry.name = item['authors'][0]['name']
entry.save()
# Just return "ok"
return HttpResponse("ok")
def create_sample_blog_entries(klass, count=50):
"""
Create N number of sample blog entries where N = the count parameter.
Text in posts till be random lorem ipsum text. Author will be a
randomly selected author from the system, and date will be a random date
from the last 2 years. All test entries will be marked "published".
"""
klass._setup(BlogEntry, count)
while count > 0:
headline = words(randrange(3,12), common=False).capitalize()
slug = klass._check_slug(slugify(headline)[:klass.field_len])
b = BlogEntry(
headline = headline,
slug = slug,
intro = klass._join_paras(
paragraphs(randrange(1,3), common=False)
),
body = klass._join_paras(
paragraphs(randrange(2,5), common=False)
),
pub_date = klass._get_rand_date(),
status = BloggingSettings.PUBLISHED_ENTRY_STATES[0],
author = Author.objects.order_by('?')[0]
)
b.save()
count += -1
def test_publication_logic(self):
"""
Verify that unpublished entries cannot be viewed
"""
unpub_state = filter(
lambda s: s[0] not in BloggingSettings.PUBLISHED_ENTRY_STATES,
BloggingSettings.PUB_STATES
)[0][0]
pub_state = BloggingSettings.PUBLISHED_ENTRY_STATES[0]
slug = 'publication-test'
# Start by creating a new, unpublished entry:
entry = BlogEntry(
slug=slug,
headline='Headline TKTK',
intro='Loren ipsum...',
author=Author.objects.all()[0], #any author is fine...
status=unpub_state,
)
entry.save()
# Trying to view it should show a 404:
response = self.client.get(entry.get_absolute_url())
self.assertTrue(response.status_code == 404)
# Now publish it:
entry.status = pub_state
entry.save()
# Should be visible:
response = self.client.get(entry.get_absolute_url())
self.assertTrue(response.status_code == 200)
def testEditBlogEntry(self):
# Given there is a blog entry in the database
entry = BlogEntry(title='entry1', text='entry1')
entry.save()
self.assertEqual(1, BlogEntry.all().count())
# And I am signed in as admin
self.signInAsAdmin()
# When I edit the blog entry
handler = self.createEditBlogEntryHandler()
handler.request.GET['id'] = entry.key().id()
handler.get()
result = str(handler.response.out)
# And I should see an input for "title"
self.assertRegexpMatches(result, r'<[^>]+ name="title"[^>]*>')
self.assertRegexpMatches(result, r'<[^>]+ value="entry1"[^>]*>')
# And I should see an input for "text"
self.assertRegexpMatches(result, r'<[^>]+ name="text"[^>]*>')
self.assertRegexpMatches(result, r'<textarea[^>]*>entry1<')
# And I should see a "Save" button
self.assertRegexpMatches(result, r'<button[^>]*>Save</')
# And I fill out the "title" field with "new title"
handler = self.createEditBlogEntryHandler()
handler.request.POST['id'] = entry.key().id()
handler.request.POST['title'] = 'new title'
# And I fill out the "text" field with "new text"
handler.request.POST['text'] = 'new text'
# And I click on the "Save" button
handler.post()
# And I should see the blog entry with "title": "new title"
self.assertEqual(1, BlogEntry.all().count())
entry = BlogEntry.all().get()
self.assertEqual('new title', entry.title)
# And I should see the blog entry with "text": "new text"
self.assertEqual('new text', entry.text)
def updateblog(request):
# Get feed
url = "http://blog.instanssi.org/feeds/posts/default"
feed = feedparser.parse(url)
# Delete old entries
BlogEntry.objects.filter(locked=False).delete()
# Get items that have changed
for item in feed["items"]:
locked = False
try:
oldentry = BlogEntry.objects.get(title=item["title"])
locked = oldentry.locked
except BlogEntry.DoesNotExist:
pass
if not locked:
timestamp = datetime.fromtimestamp(time.mktime(item["published_parsed"])) + timedelta(hours=2)
entry = BlogEntry()
entry.title = item["title"]
entry.summary = item["summary"]
entry.date = timestamp
entry.link = item["link"]
entry.name = item["authors"][0]["name"]
entry.save()
# Just return "ok"
return HttpResponse("ok")
def save_post(request, idee):
if request.method == 'POST':
submit_names = ('save', 'publish', 'quit')
submit = [i for i in request.POST if i in submit_names][0]
author = request.user
form = BlogEntryForm(request.POST)
if form.is_valid():
if idee:
entry = get_object_or_404(BlogEntry, pk=idee, author=author)
entry.title = form.cleaned_data['title']
entry.content = form.cleaned_data['content']
entry.updated = entry.updated.now()
else:
entry = BlogEntry(author=author)
entry.title=form.cleaned_data['title']
entry.name = flatten(entry.title) + '.html'
entry.content = form.cleaned_data['content']
# We need a pk before settings tag_names below
entry.save()
Tag.objects.update_tags(entry, form.cleaned_data['tags'])
if submit == "publish":
entry.published = True
entry.posted = datetime.now()
entry.save()
return HttpResponseRedirect(reverse('index'))
elif submit == "save":
entry.save()
return render_to_response('edit_post.html', {'form': form,
'entry': entry})
else:
entry.save()
return HttpResponseRedirect(reverse('admin'))
elif submit == "quit":
return HttpResponseRedirect(reverse('admin'))
else:
form = BlogEntryForm()
return render_to_response('edit_post.html', {'form': form})
def test_comments_logic(self):
"""
Verify that comments are closed as expected
"""
pub_state = BloggingSettings.PUBLISHED_ENTRY_STATES[0]
# Create a published entry, set 'comments_allowed' off:
entry = BlogEntry(
slug='test-comments-entry',
headline='Headline TKTK',
intro='Loren ipsum...',
author=Author.objects.all()[0], #any author is fine...
status=pub_state,
allow_comments=False
)
entry.save()
self.assertTrue(entry.allow_comments == False)
entry.allow_comments = True
entry.save()
self.assertTrue(entry.comments_enabled)
# Now set date to just before BloggingSettings.DAYS_COMMENTS_OPEN:
pd = entry.pub_date - timedelta(BloggingSettings.DAYS_COMMENTS_OPEN + 1)
entry.pub_date = pd
entry.save()
self.assertTrue(entry.comments_enabled == False)
