soutade/Dynastie
1
0
Fork 0
Code Issues Pull Requests Releases 1 Activity

Rename article in post

Browse Source
This commit is contained in:
Grégory Soutadé
2012-08-28 09:09:14 +02:00
parent e270a52e41
commit c393ea7197
17 changed files with 253 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
generators/__init__.py
View File

@@ -1 +1 @@
__all__ = ["generator", "index", "article", "category", "archive", "rss", "atom"]
__all__ = ["generator", "index", "post", "category", "archive", "rss", "atom"]

70
generators/archive.py
View File

@@ -9,24 +9,24 @@ class Archive(Index):
cur_page = 0
nb_pages = 0
cur_article = 0
articles_per_page = 0
cur_post = 0
posts_per_page = 0
filename = 'index'
dirname = ''
cur_year = 0
def createArchive(self, articles, dom, root, node):
def createArchive(self, posts, dom, root, node):
if node.hasAttribute('year'):
self.replaceByText(dom, root, node, str(self.cur_year))
def createArchives(self, src, output, dom, hooks, articles):
def createArchives(self, src, output, dom, hooks, posts):
filename = self.filename + '.html'
self.nb_pages = 0
self.cur_page = 0
self.cur_article = 0
self.cur_post = 0
if len(articles) > self.articles_per_page:
self.nb_pages = self.computeNbPages(len(articles), self.articles_per_page)
if len(posts) > self.posts_per_page:
self.nb_pages = self.computeNbPages(len(posts), self.posts_per_page)
self.dirname = '/archive/' + str(self.cur_year)
@@ -36,7 +36,7 @@ class Archive(Index):
while self.cur_page <= self.nb_pages:
#print 'Generate ' + filename
nodes = dom.getElementsByTagName("*")
nodes[0] = self.parse(src, hooks, articles, dom, nodes[0])
nodes[0] = self.parse(src, hooks, posts, dom, nodes[0])
self.writeIfNotTheSame(output + self.dirname + '/' + filename, nodes[0])
self.cur_page = self.cur_page + 1
filename = self.filename + str(self.cur_page) + '.html'
@@ -53,9 +53,9 @@ class Archive(Index):
filename = output + self.dirname + '/' + self.filename + str(self.cur_page) + '.html'
def generate(self, blog, src, output):
from dynastie.models import Article, Blog
from dynastie.models import Post, Blog
hooks = {'articles' : self.createArticles,
hooks = {'posts' : self.createPosts,
'navigation' : self.createNavigation,
'archive' : self.createArchive}
@@ -72,47 +72,47 @@ class Archive(Index):
if not os.path.exists(output + '/archive'):
os.mkdir(output + '/archive')
article_nodes = dom.getElementsByTagNameNS(self.URI, "articles")
if not article_nodes is None:
if article_nodes[0].hasAttribute("limit"):
self.articles_per_page = int(article_nodes[0].getAttribute("limit"))
post_nodes = dom.getElementsByTagNameNS(self.URI, "posts")
if not post_nodes is None:
if post_nodes[0].hasAttribute("limit"):
self.posts_per_page = int(post_nodes[0].getAttribute("limit"))
else:
self.articles_per_page = 5
self.posts_per_page = 5
else:
self.addError('No tag dyn:articles found')
self.addError('No tag dyn:posts found')
articles = Article.objects.filter(published=True, front_page=True).order_by('creation_date')
posts = Post.objects.filter(published=True, front_page=True).order_by('creation_date')
if articles.count() != 0:
self.cur_year = int(articles[0].creation_date.year)
if posts.count() != 0:
self.cur_year = int(posts[0].creation_date.year)
my_articles = []
my_post = []
now = datetime.now()
nb_articles = len(articles)
for i in range(0, nb_articles):
nb_post = len(posts)
for i in range(0, nb_post):
if self.cur_year == now.year:
break
if i < nb_articles-1:
if articles[i].creation_date.year != articles[i+1].creation_date.year:
if i < nb_post-1:
if posts[i].creation_date.year != posts[i+1].creation_date.year:
dom = parse(src + '/_archive.html')
my_articles.reverse()
self.createArchives(src, output, dom, hooks, my_articles)
self.cur_year = int(articles[i+1].creation_date.year)
my_post.reverse()
self.createArchives(src, output, dom, hooks, my_post)
self.cur_year = int(posts[i+1].creation_date.year)
#print 'New year ' + str(self.cur_year)
my_articles = []
my_post = []
if self.cur_year == int(now.year):
break
else:
my_articles.append(articles[i])
my_post.append(posts[i])
else:
# Last article
my_articles.append(article)
if nb_articles != 1 and articles[i].creation_date.year != articles[i-1].creation_date.year:
self.cur_year = int(articles[i].creation_date.year)
# Last post
my_post.append(post)
if nb_post != 1 and posts[i].creation_date.year != posts[i-1].creation_date.year:
self.cur_year = int(posts[i].creation_date.year)
if len(my_articles) != 0:
self.createArchives(src, output, dom, hooks, my_articles)
if len(my_post) != 0:
self.createArchives(src, output, dom, hooks, my_post)
if not self.somethingWrote:
self.addReport('Nothing changed')

51
generators/article.py
View File

@@ -1,51 +0,0 @@
import os
from xml.dom.minidom import parse, parseString
from dynastie.generators.generator import DynastieGenerator
from dynastie.generators.index import Index
from django.db import models
class Article(Index):
def _createArticle(self, article, dom, article_elem, root):
self.createArticle(article, dom, article_elem, root)
article_nodes = dom.getElementsByTagNameNS(self.URI, "article")
article_elem = article_nodes[0]
article_elem.parentNode.removeChild(article_elem)
def generate(self, blog, src, output):
from dynastie.models import Article, Blog
hooks = {'article' : self._createArticle}
if not os.path.exists(src + '/_article.html'):
self.addError('No _article.html found, exiting')
return self.report
try:
dom = parse(src + '/_article.html')
except xml.dom.DOMException as e:
self.addError('Error parsing _article.html : ' + e)
return self.report
if not os.path.exists(output + '/article'):
os.mkdir(output + '/article')
articles = Article.objects.all()
for article in articles:
#print 'Generate ' + filename
nodes = dom.getElementsByTagName("*")
nodes[0] = self.parse(src, hooks, article, dom, nodes[0])
filename = output + '/article/'
filename = filename + article.creation_date.strftime("%Y") + '/' + article.creation_date.strftime("%m") + '/'
if not os.path.exists(filename):
os.makedirs(filename)
filename = filename + article.title_slug + '.html'
self.writeIfNotTheSame(filename, nodes[0])
dom = parse(src + '/_article.html')
if not self.somethingWrote:
self.addReport('Nothing changed')
return self.report

24
generators/atom.py
View File

@@ -9,7 +9,7 @@ from django.db import models
class Atom(RSS):
def generate(self, blog, src, output):
from dynastie.models import Article, Blog
from dynastie.models import Post, Blog
now = datetime.datetime.now()
@@ -31,35 +31,35 @@ class Atom(RSS):
self.appendElement(dom, root, 'generator', 'The Dynastie project', {'uri':'http://indefero.soutade.fr/p/dynastie', 'version':'0.1'})
self.appendElement(dom, root, 'link', '', {'rel':'self', 'type':'application/atom+xml', 'href':address + '/atom.xml'})
articles = Article.objects.filter(published=True).order_by('-creation_date')[:10]
posts = Post.objects.filter(published=True).order_by('-creation_date')[:10]
for article in articles:
for post in posts:
item = dom.createElement('entry')
self.appendElement(dom, item, 'title', article.title)
path = 'http://' + blog.name + article.getPath()
self.appendElement(dom, item, 'title', post.title)
path = 'http://' + blog.name + post.getPath()
self.appendElement(dom, item, 'link', '', {'rel':'alternate', 'type':'text/html', 'href':path})
creationDate = article.creation_date.strftime('%Y-%m-%dT%H:%M:%SZ')
creationDate = post.creation_date.strftime('%Y-%m-%dT%H:%M:%SZ')
self.appendElement(dom, item, 'published', creationDate)
self.appendElement(dom, item, 'updated', creationDate)
self.appendElement(dom, item, 'id', path)
author = dom.createElement('author')
self.appendElement(dom, author, 'name', article.author.first_name + ' ' + article.author.last_name)
self.appendElement(dom, author, 'email', article.author.email)
self.appendElement(dom, author, 'name', post.author.first_name + ' ' + post.author.last_name)
self.appendElement(dom, author, 'email', post.author.email)
item.appendChild(author)
filename = blog.src_path + '/_articles/' + str(article.id)
filename = blog.src_path + '/_post/' + str(post.id)
if not os.path.exists(filename):
self.addError('File does not exists ' + filename)
return
f = open(filename, 'rb')
article_content = '<![CDATA[' + f.read() + ']]>'
post_content = '<![CDATA[' + f.read() + ']]>'
f.close()
self.appendElement(dom, item, 'summary', article_content, {'type':'html'})
self.appendElement(dom, item, 'content', article_content, {'type':'html'})
self.appendElement(dom, item, 'summary', post_content, {'type':'html'})
self.appendElement(dom, item, 'content', post_content, {'type':'html'})
root.appendChild(item)

32
generators/category.py
View File

@@ -8,22 +8,22 @@ class Category(Index):
cur_page = 0
nb_pages = 0
cur_article = 0
articles_per_page = 0
cur_post = 0
posts_per_page = 0
filename = 'index'
dirname = ''
cur_category = None
def createCategory(self, articles, dom, root, node):
def createCategory(self, posts, dom, root, node):
if node.hasAttribute('name'):
self.replaceByText(dom, root, node, self.cur_category.name)
if node.hasAttribute('description'):
self.replaceByText(dom, root, node, self.cur_category.description)
def generate(self, blog, src, output):
from dynastie.models import Article, Blog, Category
from dynastie.models import Post, Blog, Category
hooks = {'articles' : self.createArticles,
hooks = {'posts' : self.createPosts,
'navigation' : self.createNavigation,
'category' : self.createCategory}
@@ -40,30 +40,30 @@ class Category(Index):
if not os.path.exists(output + '/category'):
os.mkdir(output + '/category')
article_nodes = dom.getElementsByTagNameNS(self.URI, "articles")
if not article_nodes is None:
if article_nodes[0].hasAttribute("limit"):
self.articles_per_page = int(article_nodes[0].getAttribute("limit"))
post_nodes = dom.getElementsByTagNameNS(self.URI, "posts")
if not post_nodes is None:
if post_nodes[0].hasAttribute("limit"):
self.posts_per_page = int(post_nodes[0].getAttribute("limit"))
else:
self.articles_per_page = 5
self.posts_per_page = 5
else:
self.addError('No tag dyn:articles found')
self.addError('No tag dyn:posts found')
categories = Category.objects.all()
for category in categories:
self.cur_category = category
filename = self.filename + '.html'
articles = Article.objects.filter(category__exact=category, published=True).order_by('-creation_date')
posts = Post.objects.filter(category__exact=category, published=True).order_by('-creation_date')
self.nb_pages = 0
self.cur_page = 0
self.cur_article = 0
self.cur_post = 0
self.dirname = '/category/' + category.name_slug
if articles.count() > self.articles_per_page:
self.nb_pages = self.computeNbPages(articles.count(), self.articles_per_page)
if posts.count() > self.posts_per_page:
self.nb_pages = self.computeNbPages(posts.count(), self.posts_per_page)
if not os.path.exists(output + self.dirname):
os.mkdir(output + self.dirname)
@@ -72,7 +72,7 @@ class Category(Index):
while self.cur_page <= self.nb_pages:
#print 'Generate ' + filename
nodes = dom.getElementsByTagName("*")
nodes[0] = self.parse(src, hooks, articles, dom, nodes[0])
nodes[0] = self.parse(src, hooks, posts, dom, nodes[0])
self.writeIfNotTheSame(output + self.dirname + '/' + filename, nodes[0])
self.cur_page = self.cur_page + 1
filename = self.filename + str(self.cur_page) + '.html'

16
generators/generator.py
View File

@@ -66,8 +66,8 @@ class DynastieGenerator:
def generate(self, blog, src, output):
return
def computeNbPages(self, nb_articles, nb_articles_per_page):
res = math.ceil((nb_articles*1.0)/(nb_articles_per_page*1.0))
def computeNbPages(self, nb_post, nb_post_per_page):
res = math.ceil((nb_post*1.0)/(nb_post_per_page*1.0))
return int(res)
def writeIfNotTheSame(self, filename, node):
@@ -142,20 +142,20 @@ class DynastieGenerator:
new_node = dom.createTextNode(content)
root.replaceChild(new_node, node)
def _parse(self, hooks, articles, dom, root):
def _parse(self, hooks, posts, dom, root):
for node in root.childNodes:
if node.prefix == 'dyn':
if node.localName in hooks:
hooks[node.localName](articles, dom, root, node)
hooks[node.localName](posts, dom, root, node)
if node.hasChildNodes():
self._parse(hooks, articles, dom, node)
self._parse(hooks, posts, dom, node)
return
def parse(self, src, hooks, articles, dom, root):
def parse(self, src, hooks, posts, dom, root):
bases = dom.getElementsByTagNameNS(self.URI, 'base')
if len(bases) == 0:
self._parse(hooks, articles, dom, root)
self._parse(hooks, posts, dom, root)
return root
if len(bases) != 1:
@@ -206,6 +206,6 @@ class DynastieGenerator:
root = dom2.firstChild
self.parse(src, hooks, articles, dom2, root)
self.parse(src, hooks, posts, dom2, root)
return root

98
generators/index.py
View File

@@ -10,12 +10,12 @@ class Index(DynastieGenerator):
cur_page = 0
nb_pages = 0
cur_article = 0
articles_per_page = 0
cur_post = 0
posts_per_page = 0
filename = 'index'
dirname = ''
def createNavigation(self, articles, dom, root, node):
def createNavigation(self, posts, dom, root, node):
if self.nb_pages == 0 or self.nb_pages == 1:
return ''
@@ -60,55 +60,55 @@ class Index(DynastieGenerator):
new_node = new_dom.getElementsByTagName('div')[0]
root.replaceChild(new_node.cloneNode(True), node)
def createArticle(self, article, dom, article_elem, root):
def createPost(self, post, dom, post_elem, root):
values = {}
values['title'] = self.createLinkElem(dom, article.getPath(), article.title)
values['author'] = article.author.first_name + ' ' + article.author.last_name
values['date'] = article.creation_date.strftime("%A, %d %B %Y %H:%m")
values['article_content'] = ''
values['title'] = self.createLinkElem(dom, post.getPath(), post.title)
values['author'] = post.author.first_name + ' ' + post.author.last_name
values['date'] = post.creation_date.strftime("%A, %d %B %Y %H:%m")
values['post_content'] = ''
blog = article.blog
blog = post.blog
blog.create_paths()
filename = blog.src_path + '/_articles/' + str(article.id)
filename = blog.src_path + '/_post/' + str(post.id)
if not os.path.exists(filename):
self.addError('File does not exists ' + filename)
return
f = open(filename, 'rb')
article_content = f.read()
post_content = f.read()
f.close()
self.simpleTransform(values, dom, article_elem, root)
self.simpleTransform(values, dom, post_elem, root)
content_nodes = article_elem.getElementsByTagName("div")
post_transform = ('article_content')
content_nodes = post_elem.getElementsByTagName("div")
post_transform = ('post_content')
for content_node in content_nodes:
the_class = content_node.getAttribute('class')
if not the_class in post_transform:
continue
if the_class == 'article_content':
new_node = dom.createTextNode(article_content)
if the_class == 'post_content':
new_node = dom.createTextNode(post_content)
content_node.appendChild(new_node)
def createArticles(self, articles, dom, root, node):
articles_elem = self.createElement(dom, 'articles')
for i in range(0, self.articles_per_page):
article_elem = self.createElement(dom, 'article')
if len(articles) > self.cur_article:
self.createArticle(articles[self.cur_article], dom, article_elem, node)
def createPosts(self, posts, dom, root, node):
posts_elem = self.createElement(dom, 'posts')
for i in range(0, self.posts_per_page):
post_elem = self.createElement(dom, 'post')
if len(posts) > self.cur_post:
self.createPost(posts[self.cur_post], dom, post_elem, node)
else:
article_elem = self.createElement(dom, '', '<b>No articles yet</b>')
articles_elem.appendChild(article_elem)
post_elem = self.createElement(dom, '', '<b>No posts yet</b>')
posts_elem.appendChild(post_elem)
self.cur_article = self.cur_article + 1
if self.cur_article == len(articles):
self.cur_post = self.cur_post + 1
if self.cur_post == len(posts):
break
root.replaceChild(articles_elem, node)
root.replaceChild(posts_elem, node)
def createRecents(self, articles, dom, root, node):
if self.cur_article == len(articles):
def createRecents(self, posts, dom, root, node):
if self.cur_post == len(posts):
root.removeChild(node)
return
@@ -121,22 +121,22 @@ class Index(DynastieGenerator):
recents_elem.appendChild(child.cloneNode(True))
list_elem = dom.createElement('ul')
for i in range(0, nb_recents):
article_elem = dom.createElement('li')
if self.cur_article+i < len(articles):
article = articles[self.cur_article+i]
link_elem = self.createLinkElem(dom, article.getPath(), article.title)
article_elem.appendChild(link_elem)
post_elem = dom.createElement('li')
if self.cur_post+i < len(posts):
post = posts[self.cur_post+i]
link_elem = self.createLinkElem(dom, post.getPath(), post.title)
post_elem.appendChild(link_elem)
else:
break
list_elem.appendChild(article_elem)
list_elem.appendChild(post_elem)
recents_elem.appendChild(list_elem)
root.replaceChild(recents_elem, node)
def generate(self, blog, src, output):
from dynastie.models import Article, Blog
from dynastie.models import Post, Blog
hooks = {'articles' : self.createArticles,
hooks = {'posts' : self.createPosts,
'navigation' : self.createNavigation,
'recents' : self.createRecents}
@@ -150,31 +150,31 @@ class Index(DynastieGenerator):
self.addError('Error parsing _index.html : ' + e)
return self.report
article_nodes = dom.getElementsByTagNameNS(self.URI, "articles")
post_nodes = dom.getElementsByTagNameNS(self.URI, "posts")
if not article_nodes is None:
if article_nodes[0].hasAttribute("limit"):
self.articles_per_page = int(article_nodes[0].getAttribute("limit"))
if not post_nodes is None:
if post_nodes[0].hasAttribute("limit"):
self.posts_per_page = int(post_nodes[0].getAttribute("limit"))
else:
self.articles_per_page = 5
self.posts_per_page = 5
else:
self.addError('No tag dyn:articles found')
self.addError('No tag dyn:posts found')
now = datetime.datetime.now()
cur_year = now.year
articles = Article.objects.filter(creation_date__year=cur_year, published=True, front_page=True).order_by('-creation_date')
posts = Post.objects.filter(creation_date__year=cur_year, published=True, front_page=True).order_by('-creation_date')
if articles.count() < self.articles_per_page:
articles = Article.objects.all()[:self.articles_per_page]
if posts.count() < self.posts_per_page:
posts = Post.objects.all()[:self.posts_per_page]
if articles.count() > self.articles_per_page:
self.nb_pages = self.computeNbPages(articles.count(), self.articles_per_page)
if posts.count() > self.posts_per_page:
self.nb_pages = self.computeNbPages(posts.count(), self.posts_per_page)
filename = 'index.html'
while self.cur_page <= self.nb_pages:
#print 'Generate ' + filename
nodes = dom.getElementsByTagName("*")
nodes[0] = self.parse(src, hooks, articles, dom, nodes[0])
nodes[0] = self.parse(src, hooks, posts, dom, nodes[0])
self.writeIfNotTheSame(output + '/' + filename, nodes[0])
self.cur_page = self.cur_page + 1
filename = 'index' + str(self.cur_page) + '.html'

51
generators/post.py Normal file
View File

@@ -0,0 +1,51 @@
import os
from xml.dom.minidom import parse, parseString
from dynastie.generators.generator import DynastieGenerator
from dynastie.generators.index import Index
from django.db import models
class Post(Index):
def _createPost(self, post, dom, post_elem, root):
self.createPost(post, dom, post_elem, root)
post_nodes = dom.getElementsByTagNameNS(self.URI, "post")
post_elem = post_nodes[0]
post_elem.parentNode.removeChild(post_elem)
def generate(self, blog, src, output):
from dynastie.models import Post, Blog
hooks = {'post' : self._createPost}
if not os.path.exists(src + '/_post.html'):
self.addError('No _post.html found, exiting')
return self.report
try:
dom = parse(src + '/_post.html')
except xml.dom.DOMException as e:
self.addError('Error parsing _post.html : ' + e)
return self.report
if not os.path.exists(output + '/post'):
os.mkdir(output + '/post')
posts = Post.objects.all()
for post in posts:
#print 'Generate ' + filename
nodes = dom.getElementsByTagName("*")
nodes[0] = self.parse(src, hooks, post, dom, nodes[0])
filename = output + '/post/'
filename = filename + post.creation_date.strftime("%Y") + '/' + post.creation_date.strftime("%m") + '/'
if not os.path.exists(filename):
os.makedirs(filename)
filename = filename + post.title_slug + '.html'
self.writeIfNotTheSame(filename, nodes[0])
dom = parse(src + '/_post.html')
if not self.somethingWrote:
self.addReport('Nothing changed')
return self.report

24
generators/rss.py
View File

@@ -18,7 +18,7 @@ class RSS(DynastieGenerator):
return elem
def generate(self, blog, src, output):
from dynastie.models import Article, Blog
from dynastie.models import Post, Blog
now = datetime.datetime.now()
@@ -40,33 +40,33 @@ class RSS(DynastieGenerator):
self.appendElement(dom, channel, 'generator', 'Dynastie')
self.appendElement(dom, channel, 'language', 'en-gb')
articles = Article.objects.filter(published=True).order_by('-creation_date')[:10]
posts = Post.objects.filter(published=True).order_by('-creation_date')[:10]
for article in articles:
for post in posts:
item = dom.createElement('item')
self.appendElement(dom, item, 'title', article.title)
path = 'http://' + blog.name + article.getPath()
self.appendElement(dom, item, 'title', post.title)
path = 'http://' + blog.name + post.getPath()
self.appendElement(dom, item, 'link', path)
self.appendElement(dom, item, 'guid', path)
filename = blog.src_path + '/_articles/' + str(article.id)
filename = blog.src_path + '/_post/' + str(post.id)
if not os.path.exists(filename):
self.addError('File does not exists ' + filename)
return
f = open(filename, 'rb')
article_content = f.read()
post_content = f.read()
f.close()
self.appendElement(dom, item, 'description', '<![CDATA[' + article_content + ']]>')
self.appendElement(dom, item, 'description', '<![CDATA[' + post_content + ']]>')
author = article.author.email
author += ' (' + article.author.first_name + ' ' + article.author.last_name + ')'
author = post.author.email
author += ' (' + post.author.first_name + ' ' + post.author.last_name + ')'
self.appendElement(dom, item, 'author', author)
self.appendElement(dom, item, 'category', article.category.name)
self.appendElement(dom, item, 'category', post.category.name)
creationDate = article.creation_date.strftime('%a, %d %b %Y %H:%M:%S')
creationDate = post.creation_date.strftime('%a, %d %b %Y %H:%M:%S')
self.appendElement(dom, item, 'pubDate', creationDate)
channel.appendChild(item)