Dynastie/models.py

import os
import shutil
import hashlib
from django.db import models
from django.contrib.auth.models import User
from django.db.models.signals import post_init, post_delete, post_save
from django.dispatch import receiver
from dynastie.generators import *

class Blog(models.Model):
    name = models.CharField(max_length=255, unique=True)
    title = models.CharField(max_length=255)
    description = models.TextField(max_length=255, blank=True)
    keywords = models.TextField(blank=True)
    writers = models.ManyToManyField(User)
    
    generators = []

    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(output)

    def remove(self):
        src = 'sites/' + self.name
        output = 'sites/' + self.name + '_output'

        if os.path.exists(src):
            shutil.rmtree(src)
        if os.path.exists(output):
            shutil.rmtree(output)

    def load_generators(self):
        src = 'sites/' + self.name
        if os.path.exists(src + '/_generators'):
            f = open(src + '/_generators', 'r')
            for line in f:
                generator.append(globals()[line])
            f.close()
        else:
            generator.append(globals()['dynastie.generators.index'])
            generator.append(globals()['dynastie.generators.categories'])
            generator.append(globals()['dynastie.generators.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('~'):
                continue
            srcname = os.path.join(src, name)
            dstname = os.path.join(dst, name)
            try:
                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):
                    self.copytree(srcname, dstname)
                else:
                    src_md5 = hashlib.md5()
                    f = open(srcname,'rb') 
                    src_md5.update(f.read())
                    f.close()

                    dst_md5 = hashlib.md5()
                    f = open(dstname,'rb') 
                    dst_md5.update(f.read())
                    f.close()

                    if src_md5.digest() != dst_md5.digest():
                        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:
                errors.extend(err.args[0])
        if errors:
            raise Error(errors)

    def generate(self):
        src = 'sites/' + self.name
        output = 'sites/' + self.name + '_output'

        self.load_generators()
        self.copytree(src, output)

class Editor(models.Model):
    name = models.CharField(max_length=255, unique=True)

class Category(models.Model):
    name = models.CharField(max_length=255, unique=True)
    parent = models.ForeignKey('self', blank=True, null=True)
    description = models.TextField(max_length=255, blank=True)

class Tag(models.Model):
    name = models.CharField(max_length=255, unique=True)
    
class Article(models.Model):
    title = models.CharField(max_length=255)
    category = models.ForeignKey(Category, blank=True, null=True, on_delete=models.SET_NULL)
    published = models.BooleanField()
    creation_date = models.DateField()
    front_page = models.BooleanField()
    author = models.ForeignKey(User, null=True, on_delete=models.SET_NULL)
    description = models.TextField(max_length=255, blank=True)
    keywords = models.TextField(blank=True)
    tags = models.ManyToManyField(Tag, blank=True, null=True)
    blog = models.ForeignKey(Blog)

class Comment(models.Model):
    article = models.ForeignKey(Article)
    parent = models.ForeignKey('Comment')
    date = models.DateField(max_length=255)
    author = models.CharField(max_length=255)
    email = models.EmailField(max_length=255)
    the_comment = models.TextField(max_length=255)

@receiver(post_init, sender=Blog)
def create_blog_signal(sender, **kwargs):
    sender.create()

@receiver(post_delete, sender=Blog)
def delete_blog_signal(sender, **kwargs):
    sender.remove()

@receiver(post_delete, sender=Article)
def delete_article_signal(sender, **kwargs):
    sender.blog.generate()

@receiver(post_save, sender=Article)
def save_article_signal(sender, **kwargs):
    sender.blog.generate()