Dynastie seems OK, start generators

generators/__init__.py

@@ -0,0 +1 @@
+__all__ = ["generator", "index"]

generators/generator.py

@@ -0,0 +1,6 @@
+class DynastieGenerator:
+
+    def generate(self, blog, src, output):
+        return
+
+

generators/index.py

@@ -0,0 +1,16 @@
+from xml.dom.minidom import parse
+from dynastie.generators.generator import DynastieGenerator
+from django.db import models
+
+class Index(DynastieGenerator):
+
+    def generate(self, blog, src, output):
+        from dynastie.models import *
+        articles = Article.objects.all()
+
+        dom = parse(src + '/_index.html')
+
+        for node in dom.NodeList:
+            print node
+
+        return

models.py

@@ -1,6 +1,7 @@
 import os
 import shutil
 import hashlib
+import inspect
 from django.db import models
 from django.contrib.auth.models import User
 from django.db.models.signals import post_init, post_delete, post_save
@@ -14,47 +15,44 @@ class Blog(models.Model):
     keywords = models.TextField(blank=True)
     writers = models.ManyToManyField(User)
     
-    generators = []
+    engines = list()
 
+    src_path = ''
+    output_path = ''
+
+    def create_paths(self):
+        self.src_path = 'sites/' + self.name
+        self.output_path = 'sites/' + self.name + '_output'
+        
     def create(self):
-        src = 'sites/' + self.name
-        output = 'sites/' + self.name + '_output'
-
         if not os.path.exists('sites'):
             os.mkdir('sites')
 
         self.remove()
 
-        os.mkdir(src)
+        os.mkdir(self.src_path)
-        os.mkdir(output)
+        os.mkdir(self.output_path)
 
     def remove(self):
-        src = 'sites/' + self.name
+        if os.path.exists(self.src_path):
-        output = 'sites/' + self.name + '_output'
+            shutil.rmtree(self.src_path)
-
+        if os.path.exists(self.output_path):
-        if os.path.exists(src):
+            shutil.rmtree(self.output_path)
-            shutil.rmtree(src)
-        if os.path.exists(output):
-            shutil.rmtree(output)
 
     def load_generators(self):
-        src = 'sites/' + self.name
+        if os.path.exists(self.src_path + '/_generators'):
-        if os.path.exists(src + '/_generators'):
+            f = open(self.src_path + '/_generators', 'r')
-            f = open(src + '/_generators', 'r')
             for line in f:
-                generator.append(globals()[line])
+                self.engines.append(globals()[line.strip()])
             f.close()
         else:
-            generator.append(globals()['dynastie.generators.index'])
+            self.engines.append(globals()['index'])
-            generator.append(globals()['dynastie.generators.categories'])
+            self.engines.append(globals()['categories'])
-            generator.append(globals()['dynastie.generators.archives'])
+            self.engines.append(globals()['archives'])
             
     def copytree(self, src, dst):
         names = os.listdir(src)
 
-        if not os.path.exists(dstname):
-            os.makedirs(dst)
-
         errors = []
         for name in names:
             if name.startswith('_') or name.endswith('~'):
@@ -65,38 +63,45 @@ class Blog(models.Model):
                 if os.path.islink(srcname) and not os.path.exists(dstname):
                     linkto = os.readlink(srcname)
                     os.symlink(linkto, dstname)
-                if os.path.isdir(srcname) and not os.path.exists(dstname):
+                if os.path.isdir(srcname):
+                    if not os.path.exists(dstname):
+                        os.makedirs(dstname)
                     self.copytree(srcname, dstname)
                 else:
-                    src_md5 = hashlib.md5()
+                    if os.path.exists(dstname):
-                    f = open(srcname,'rb') 
+                        src_md5 = hashlib.md5()
-                    src_md5.update(f.read())
+                        f = open(srcname,'rb') 
-                    f.close()
+                        src_md5.update(f.read())
+                        f.close()
 
-                    dst_md5 = hashlib.md5()
+                        dst_md5 = hashlib.md5()
-                    f = open(dstname,'rb') 
+                        f = open(dstname,'rb') 
-                    dst_md5.update(f.read())
+                        dst_md5.update(f.read())
-                    f.close()
+                        f.close()
 
-                    if src_md5.digest() != dst_md5.digest():
+                        if src_md5.digest() != dst_md5.digest():
-                        copy2(srcname, dstname)
+                            shutil.copy2(srcname, dstname)
+                    else:
+                        shutil.copy2(srcname, dstname)
 
         # XXX What about devices, sockets etc.?
             except (IOError, os.error), why:
                 errors.append((srcname, dstname, str(why)))
         # catch the Error from the recursive copytree so that we can
         # continue with other files
-            except Error, err:
+            except Exception, err:
                 errors.extend(err.args[0])
         if errors:
-            raise Error(errors)
+            raise Exception(errors)
 
     def generate(self):
-        src = 'sites/' + self.name
-        output = 'sites/' + self.name + '_output'
-
         self.load_generators()
-        self.copytree(src, output)
+        self.copytree(self.src_path, self.output_path)
+        for engine in self.engines:
+            for name, obj in inspect.getmembers(engine):
+                if inspect.isclass(obj):
+                    e = obj()
+                    e.generate(self, self.src_path, self.output_path)
 
 class Editor(models.Model):
     name = models.CharField(max_length=255, unique=True)
@@ -130,8 +135,8 @@ class Comment(models.Model):
     the_comment = models.TextField(max_length=255)
 
 @receiver(post_init, sender=Blog)
-def create_blog_signal(sender, **kwargs):
+def delete_blog_signal(sender, **kwargs):
-    sender.create()
+    sender.create_paths()
 
 @receiver(post_delete, sender=Blog)
 def delete_blog_signal(sender, **kwargs):
@@ -139,8 +144,14 @@ def delete_blog_signal(sender, **kwargs):
 
 @receiver(post_delete, sender=Article)
 def delete_article_signal(sender, **kwargs):
-    sender.blog.generate()
+    kwargs["instance"].blog.create_paths()
+    kwargs["instance"].blog.generate()
+    # b = Blog.objects.filter(pk=kwargs["instance"].blog.id)
+    # b.generate()
 
 @receiver(post_save, sender=Article)
 def save_article_signal(sender, **kwargs):
-    sender.blog.generate()
+    kwargs["instance"].blog.create_paths()
+    kwargs["instance"].blog.generate()
+    # b = Blog.objects.filter(pk=kwargs["instance"].blog.id)
+    # b.generate()

urls.py

@@ -23,6 +23,8 @@ urlpatterns = patterns('',
     url(r'^blog/edit/(\d+)$',     'dynastie.views.edit_blog',    name='edit_blog'),
     url(r'^article/add/(\d+)$',   'dynastie.views.add_article',  name='add_article'),
     url(r'^article/edit/(\d+)$',  'dynastie.views.edit_article', name='edit_article'),
+    url(r'^article/delete/(\d+)$','dynastie.views.delete_article', name='delete_article'),
+    url(r'^generate/(\d+)$',      'dynastie.views.generate',     name='generate'),
     # url(r'^dynastie/', include('dynastie.foo.urls')),
 
     # Uncomment the admin/doc line below to enable admin documentation:

views.py

@@ -150,7 +150,13 @@ def delete_category(request, category_id):
     if not request.user.is_superuser:
         return HttpResponseRedirect('/category/' + str(category_id))
 
-    Category.objects.get(pk=category_id).delete()
+    category = Category.objects.get(pk=category_id)
+
+    if category is None:
+        raise Http404
+
+    category.delete()
+
     return HttpResponseRedirect('/category')
 
 @login_required
@@ -174,6 +180,7 @@ def add_blog(request):
             form = BlogForm(request.POST) # A form bound to the POST data
             if form.is_valid(): # All validation rules pass
                 form = form.save()
+                form.create()
                 return HttpResponseRedirect('/blog') # Redirect after POST
         else:
             return HttpResponseRedirect('/blog') # Redirect after POST
@@ -289,3 +296,33 @@ def edit_article(request, article_id):
     return render(request, 'edit_article.html', {
         'form': form, 'article_id' : article_id
     })
+
+@login_required
+def delete_article(request, article_id):
+    article = Article.objects.get(pk=article_id)
+
+    if article is None:
+        raise Http404
+
+    b = Blog.objects.filter(writers=request.user.id).filter(pk=article.blog.id)
+
+    if b is None:
+        raise Http404
+
+    article.delete()
+
+    return HttpResponseRedirect('/blog/' + str(article.blog.id))
+
+@login_required
+def generate(request, blog_id):
+    if not request.user.is_superuser:
+        #b = Blog.objects.filter(id=blog_id).filter(writers=request.user.id)
+        b = Blog.objects.get(pk=blog_id)
+    else:
+        b = Blog.objects.get(pk=blog_id)
+
+    if b is None:
+        raise Http404
+
+    b.create_paths()
+    b.generate()