models/calendar/data.py

"""
Sql classes for calendar
"""

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Integer
from sqlalchemy import Unicode, UnicodeText
from sqlalchemy import DateTime
from sqlalchemy import Column
from sqlalchemy import ForeignKey
from sqlalchemy import or_, and_

Base = declarative_base()

DBSession = None
transaction = None

def _s():
    """
    returns session instance, relies on global being set before import 
    """
    global DBSession
    return DBSession()

def _t():
    """
    returns reference to zope transaction, relies on global being set before import
    """
    global transaction
    return transaction

class DatedItem(Base):
    """
    Basic Dated item, has date, title, and body
    """
    __tablename__ = "dated_items"
    id = Column(Integer, primary_key = True)
    discriminator = Column("type",Unicode(50))
    date = Column(DateTime, nullable = False)
    title = Column(Unicode(255),nullable = False)
    body = Column(UnicodeText, nullable = True)
    __mapper_args__ = {"polymorphic_on":discriminator}
    
    @classmethod
    def get(cls,id):
        _session = _s()
        return _session.query(cls).get(id)
    
    @classmethod
    def get_for_range(cls,begin,end):
        _session = _s()
        query = _session.query(cls).filter(
            cls.date.between(begin,end)
            ).order_by(cls.date)        
        return query

    def __repr__(self):
        return "%s\n==========\n%s" % (self.__class__.__name__,
                                       "\n".join(["%s: %s" % (k,v) for k,v in self.__dict__.items()]))

    
class EventItem(DatedItem):
    """
    Basic Dated item. Will likely have subclasses
    """
    __tablename__ = 'event_items'
    __mapper_args__ = {"polymorphic_identity":"event_item"}
    id = Column(Integer, ForeignKey(DatedItem.id),primary_key = True)
    end_date = Column(DateTime, nullable = False)

    def __init__(self,**kw):
        for k,v in kw.items():
            setattr(self, k, v)

    @classmethod
    def get_for_range(cls,begin,end):
        _session = _s()
        query = _session.query(cls).filter(
            or_(
            cls.date.between(begin,end),
            cls.end_date.between(begin,end),
            or_(
               and_(cls.date<=begin,cls.end_date>=end)
            )
            ),).order_by(cls.date).order_by(cls.end_date)        
        return query

models/calendar/date_context.py

from .data import DatedItem, EventItem

class DateContext(object):
    """
    Superclass for models in calendar object graph
    """
    def __init__(self,date_ctx,parent):
        self.__date_context = date_ctx
        self.__parent__ = parent

    def items(self,cls = None):
        """
        returns calendar_data items filtered by cls for the current date range
        """
        if not cls:
            qrys = []
            for c in (DatedItem,EventItem):
                qrys.append(c.get_for_range(self.date_context,
                                              self.max).all())
            results = {}
            for qry in qrys:
                for o in qry:
                    results[o.id] = o
            #tweak sort as generator
            return results.values()
        else:
            return cls.get_for_range(
                self.date_context,
                self.max).all()

    def _get_context(self):
        return self.__date_context

    def _get_max(self):
        return getattr(self,"__max__",None)
    date_context = property(_get_context)
    max = property(_get_max)

The magic is in the "items" method which takes a cls param and call it's "get_for_range" using it's date_context or, run the corresponding "get_for_range" on both DatedItem, and EventItem. and combine the results into a list. Another tricky part is that DateContext needs to defer to what inherits from it for the max of the range. Kind of like defining an abstract method that you require your children to implement. Except I'm doing it the easy way and just looking for an attribute named "__max__".

So now, the year, month, and day context models only differ in 4 ways.

1. the way they initialize their DateContext,
2. the way they set their __name__ attribute.
3. the way they set their __max__ attribute.
4. the way they implement their __getitem__ method.

models/calendar/year.py

from date_context import DateContext
from datetime import datetime
from .month import Month
class Year(DateContext):
    """
    Year datecontext, begin 1/1/self 00:00:00 end 12/31/self 23:59:59
    """
    def __init__(self,year, parent):
        DateContext.__init__(self,datetime(year,1,1),parent)
        self.__max__ = datetime(self.date_context.year,12,31,23,59)
        self.__name__ = str(self.date_context.year)
        self.months = {}

    def __getitem__(self,key):
        if key not in self.months:
            try:
                self.months[key] = Month(int(key),self)
            except (TypeError,ValueError):
                raise KeyError(key)

        return self.months[key]

models/calendar/month.py

from date_context import DateContext
from datetime import datetime, date, timedelta
from .day import Day

def mfd(dt, d_years=0, d_months=0):
    """
    first day of month
    """
    # d_years, d_months are "deltas" to apply to dt
    y, m = dt.year + d_years, dt.month + d_months
    a, m = divmod(m-1, 12)
    return date(y+a, m+1, 1)

def mld(dt):
    """
    last day of month
    """
    return mfd(dt, 0, 1) + timedelta(-1)

class Month(DateContext):
    """
    Month date context begin self/1/parent.year 00:00:00 end self/mld(self)/self.parent.year 23:59:59
    """
    def __init__(self,m,parent):
        DateContext.__init__(self,datetime(parent.date_context.year,m,1),parent)
        self.__name__ = str(self.date_context.month)
        self.__max__ = mld(self.date_context)
        self.days = {}

    def __getitem__(self,key):
        if key not in self.days:
            try:
                self.days[key] = Day(int(key),self)
            except (TypeError,ValueError):
                raise KeyError(key)
                

        return self.days[key]

models/calendar/day.py

from .date_context import DateContext
from datetime import datetime, date
from hour import Hour

class Day(DateContext):
    """
    Day date context 
    begin self.parent.month/self/self.parent.year 00:00:00 
    end self.parent.month/self/self.parent.year 23:59:59
    """
    def __init__(self,d,parent):
        DateContext.__init__(self,date(parent.date_context.year,parent.date_context.month,d),parent)
        self.__name__ = str(self.date_context.day)
        self.__max__ = datetime(
            self.date_context.year,
            self.date_context.month,
            self.date_context.day,
            23,
            59)
        self.hours={}
        
    def __getitem__(self,key):
        if key not in self.hours:
            try:
                self.hours[key] = Hour(int(key),self)
            except (TypeError,ValueError):
                raise KeyError(key)

        return self.hours[key]

models/calendar/__init__.py

And finally, the CalendarContainer starts it all off. But has a few convenience methods we'll eventually use on the view side.

"""
Calendar Container takes care of selecting date context and showing data
"""
from datetime import date, datetime, timedelta
from . import data
from .data import DatedItem, EventItem
from .date_context import DateContext
from year import Year

class CalendarContainer(object):
    """
    Container to handle url pattern of year/month/day/hour
    """
    def __init__(self, config, name = "calendar" ,parent = None):
        self.years = dict()
        self.__parent__ = parent
        self.__name__ = name

    def __getitem__(self,key):
        try:
            _k = int(key)
        except ValueError:
            raise KeyError(key)
        if _k not in self.years:
            self.years[_k] = Year(_k,self)

        return self.years[_k]


    def today(self):
        d = datetime.today()
        return self[d.year][d.month][d.day]

    def now(self):
        d = datetime.today()
        return self[d.year][d.month][d.day][d.hour]

    def save(self,item):
        session = data._s()
        session.add(item)

And that does it for the model side. Let's tie in a quick view to see if it works.

templates/model.pt

<html>
<head>
  <title>${context.__name__}</title>
</head>
<body>
  ${getattr(context,"date_context", None)}
</body>
</html>

As in our previous example, views get tied to models through the bb/configure.zcml.

<configure xmlns="http://namespaces.repoze.org/bfg">

  <!-- this must be included for the view declarations to work -->
  <include package="repoze.bfg.includes" />

  <view
     for=".models.RootContainer"
     view=".views.view_root"
     renderer="templates/root.pt"
     />

  <view
      for=".models.calendar.CalendarContainer"
      view=".views.view_root"
      renderer="templates/model.pt"
   />

  <view
      for=".models.calendar.year.Year"
      view=".views.view_root"
      renderer="templates/model.pt"
   />
  <view
      for=".models.calendar.month.Month"
      view=".views.view_root"
      renderer="templates/model.pt"
   />

  <view
      for=".models.calendar.day.Day"
      view=".views.view_root"
      renderer="templates/model.pt"
   />
  
  <static
     name="static"
     path="templates/static"
     />

  <subscriber for="repoze.bfg.interfaces.INewRequest"
     handler=".run.handle_teardown"
     />

</configure>

You'll notice that every view is configured to be "view_root", this is inconsequential at the moment because our template only relies on the context that is passed in, and the context is always passed in. Later on, we'll change this around as we implement more view functions.

models/__init__.py

"""
Root Container for traversal
"""
import transaction
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from zope.sqlalchemy import ZopeTransactionExtension
from .calendar import CalendarContainer
import calendar.data
from calendar.data import Base

DBSession = scoped_session(sessionmaker(expire_on_commit=False, extension=ZopeTransactionExtension()))

#pass the session along to the model classes that need it, 
#probably a more elegant way to do this


#root is made available to other parts of the app here

root = None

class RootContainer(object):
    """
    We'll hang the calendar and account containers off here.
    Thus: both containers can peacefully coexist without knowing 
    about each other, and then should be reusable
    """
    __name__ = None
    __parent__ = None

    def __init__(self,config):
        self.calendar = CalendarContainer(config,name = "calendar",parent = self)


    def __getitem__(self,key):
        _k = key.lower()
        if _k == "calendar":
            return self.calendar
        else:
            raise KeyError,key
        
def make_root(config):
    """
    Construct the callable that bfg calls with environ
    But, initialize the RootContainer with acl's and
    set a module level reference so the rest of the app 
    can get to it.
    """
    _root = RootContainer(config)


    global root
    #setting module level reference to root
    root = _root

    def _x(environ):
        return _root
    return _x


def initialize_sql(db_string, db_echo):
    engine = create_engine(db_string, echo=True)
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    Base.metadata.create_all(engine)

    if calendar.data.DBSession is None:
        print "setting DBSession"
        calendar.data.DBSession = DBSession
    else:
        print "DBSession already set"


def appmaker(db_string, db_echo, config):
    """
    Initialize SQL portion and make the root callable to hand back
    """
    initialize_sql(db_string, db_echo)
    return make_root(config)

You'll see that the "__getitem__" method looks for "calendar" as the key, anything else will be a key error. With this setup, a url like http://example.com/calendar will result in the CalendarContainer being set as the context to be handed off later to a view function. Because the CalendarContainer has no date_context attribute, our model.pt displays nothing in the body but the title you'll see is indeed "calendar". These urls will display the corresponding date_context of the passed in context in the body of the page.

• http://localhost:6543/calendar/2009
• http://localhost:6543/calendar/2009/11
• http://localhost:6543/calendar/2009/11/1

And an invalid date?

• http://localhost:6543/calendar/2009/11/31 <----causes a 404

So this is still a far cry from a complete app that you would want to show to your boss, but we're off to a good start. In the next article we'll implement the data entry portions, and some views that are a bit more pleasant to look at.