ModelMiddleware: model_utils.py

# -*- coding: utf-8 -*-
from django.db.models.base import ModelBase
from django.db import models
import types

def _filter_bases(bases, filter_key): 
    """ Remove all classes descendants of ``filter_key`` from ``bases`` """
    new_bases = tuple([base for base in bases \
                       if ((not (base is filter_key)) and (not issubclass(base, filter_key)))])
    
    # ensure that we don't end up with an orphan class - it must be
    # parented by at least models.Model
    if len(new_bases) == 0: new_bases = (models.Model,)
    return new_bases

class Hooks(object):
    _pre_saves = {}
    _post_saves = {}
    _pre_deletes = {}
    _post_deletes = {}

class MetaModelMiddleware(ModelBase):
    
    # pre and post hooks for save() will be temporarily stored in these
    #pre_saves = {}
    #post_saves = {}
    # pre and post hooks for delete()
    #pre_deletes = {}
    #post_deletes = {}
    def __new__(cls, name, bases, attrs):
        
        # whether base classes should be filtered
        cls.hide_bases = False
        # only filter bases if this wasn't invoked by the ModelMiddleware
        # class, which is a super class for all custom middleware, and the
        # one we are using as a filter key
        if not (name == 'ModelMiddleware'):
            if not (ModelMiddleware in bases):
                cls.hide_bases = True
        if cls.hide_bases:
            # replace the original bases with filtered ones to fool Django's inheritance
            bases = _filter_bases(bases, ModelMiddleware)
        # set the middleware options under Klass._middle
        if attrs.has_key('Middle'):
            midopts = attrs['Middle']
            assert type(midopts) == types.ClassType, "Middle attribute of %s model must be a class, not a %s object" % (name, type(midopts))
            opts = {}
            opts.update([(k,v) for k,v in midopts.__dict__.items() if not k.startswith('_')])
            attrs["_middle"] = opts
            attrs.pop('Middle')
        return ModelBase.__new__(cls, name, bases, attrs)
    
    def __init__(cls,name,bases,attrs):
        # provide a wrapper func for save()
        def new_save(func):
            def wrapper(*args, **kwargs):
                if hasattr(cls, 'pre_saves'):
                    [pre(args[0]) for pre in cls.pre_saves]
                func(*args, **kwargs)
                if hasattr(cls, 'post_saves'):
                    [post(args[0]) for post in cls.post_saves]
            return wrapper
        # provide a wrapper func for delete()
        def new_delete(func):
            def wrapper(*args, **kwargs):
                if hasattr(cls, 'pre_deletes'):
                    [pre(args[0]) for pre in cls.pre_deletes]
                func(*args, **kwargs)
                if hasattr(cls, 'post_deletes') > 0:
                    [post(args[0]) for post in cls.post_deletes]
            return wrapper
        
        # if this is a descendant of ModelMiddleware, but not ModelMiddleware itself
        if name != 'ModelMiddleware':
            # if this class inherits directly from ModelMiddleware then save its hooks
            if ModelMiddleware in bases:
                if attrs.has_key('pre_save'):
                    Hooks._pre_saves[name] = attrs['pre_save']
                if attrs.has_key('post_save'):
                    Hooks._post_saves[name] = attrs['post_save']
                if attrs.has_key('pre_delete'):
                    Hooks._pre_deletes[name] = attrs['pre_delete']
                if attrs.has_key('post_delete'):
                    Hooks._post_deletes[name] = attrs['post_delete']
        

            # if this is NOT a direct descendant of ModelMiddleware - not a holder of callbacks
            if ModelMiddleware not in bases:
                orig_save = cls.save
                orig_delete = cls.delete
                for base in bases:
                    base_pre_save = Hooks._pre_saves.get(base.__name__, False)
                    if base_pre_save:
                        if not hasattr(cls,'pre_saves'):
                            cls.pre_saves = []
                        cls.pre_saves.append(base_pre_save)
                    base_post_save = Hooks._post_saves.get(base.__name__, False)
                    if base_post_save:
                        if not hasattr(cls, 'post_saves'):
                            cls.post_saves = []
                        cls.post_saves.append(base_post_saves)
                    base_pre_delete = Hooks._pre_deletes.get(base.__name__, False)
                    if base_pre_delete:
                        if not hasattr(cls, 'pre_deletes'):
                            cls.pre_deletes = []
                        cls.pre_deletes.append(base_pre_deletes)
                    base_post_delete = Hooks._post_deletes.get(base.__name__, False)
                    if base_post_delete:
                        if not hasattr(cls, 'post_deletes'):
                            cls.post_deletes = []
                        cls.post_deletes.append(base_post_deletes)
                cls.save = new_save(orig_save)
                cls.delete = new_delete(orig_delete)
                # replace original bases with filtered ones
                bases = _filter_bases(bases,ModelMiddleware)
        new_class = super(ModelBase,cls).__init__(name,bases,attrs)
        return new_class
    

class ModelMiddleware(models.Model):
    """
    Custom model middleware components should subclass this and never
    use the MetaModelMiddleware metaclass directly.
    """
    __metaclass__ = MetaModelMiddleware
    
    
class ReSTMiddleware(ModelMiddleware):
    def pre_save(self):
        try:
            opts = self.__class__._middle["ReST"] # individual options are saved in a dict
        except (AttributeError, KeyError):
            return  # just fail silently, though it might not be a very good idea in practice

        # parse for as many fields as we have options for
        for opt in opts:  
            # lets be nice to ourselves and provide a default value for the initial header level
            if not opt.has_key("init_header"):
                opt["init_header"] = 1 
            try:
                cont = getattr(self, opt["field"]).decode("utf_8")
                parts = build_document(cont, initial_header_level=opt["init_header"])
                setattr(self, opt["save_body"], parts["html_body"].encode('utf_8'))
                setattr(self, opt["save_toc"], parts["toc"].encode('utf_8'))
            except:
                pass # another silent fail, needs fixing        d = datetime.now()

from datetime import datetime

class TimestampMiddleware(ModelMiddleware):
    """
    This class can record a timestamp (down to one second precision) into any fields you specify.
    There are two types of timestamps: 'always' and 'once'. 'always' means that record must be
    made on every save(), while 'once' fields will be timestamped once on the first save() of this
    object.
    
    A default set of options (used if none are provided by the model) is provided, which presume
    the existance of 'pub_date' and 'last_modified' fields.  The 'pub_date' field is of type "once",
    and 'last_modified' is of type "always". This lets you timestamp the object's creation and modification
    times.
    
    Example options (also the default ones):
    
    class Middle:
        Timestamp = ({'field' : 'pub_date', 'type' : 'once'},
            {'field' : 'last_modified', 'type' : 'always'})
    """
    def pre_save(self):
        try:
            opts = self.__class__._middle["Timestamp"]
        except (AttributeError, KeyError):
            opts = ({'field' : 'pub_date', 'type' : 'once'},
                {'field' : 'last_modified', 'type' : 'always'})
        
        for opt in opts:
            if not opt.has_key('type'):
                opt['type'] = 'always'
            d = datetime.now()
            pdate = datetime(d.year, d.month, d.day, d.hour, d.minute)
            # if this is a "set once" type of field, then we check whether
            # it's been filled in and if not - do so
            if opt['type'] == 'once':
                if getattr(self, opt['field']) is None:
                    setattr(self, opt['field'], pdate)
            elif opt['type'] == 'always':
                setattr(self, opt['field'], pdate)