source: enpraxis.staticsite/trunk/enpraxis/staticsite/utilities/staticsiteutility.py @ 265

import Globals
import httplib
import os

from OFS.SimpleItem import SimpleItem
from zope.interface import implements
from interfaces import IStaticSiteUtility
from zope.component import getUtility

class StaticSiteUtility(SimpleItem):
    """ Deploy a static site """

    implements(IStaticSiteUtility)

    def _getDeploymentPath(self, sp):
        """ Get the default static path location. """
        rpath = os.path.split(Globals.BobobaseName)[0]
        return os.path.join(rpath, sp.getProperty('deployment_path'))
        
    def createDirectory(self, path):
        """ Create a directory on the filesystem """      
        if not os.path.lexists(path):
            os.makedirs(path)
            
    def deploySite(self, context):
        """ Deploy the site """

        ssprops = context.portal_url.portal_properties.staticsite_properties
        subdomain = ssprops.getProperty('subdomain')
        rpath = self._getDeploymentPath(ssprops)
        self.createDirectory(rpath)

        allowed = context.portal_types.getTypeInfo('Plone Site').allowed_content_types
        brains = context.portal_catalog.searchResults(
            path={'query':'/'.join(context.getPhysicalPath()),
                  'depth':1,},
            portal_type=allowed,
            review_state='Published')
        for x in brains:
            self.traverse(x, rpath, subdomain)

    def traverse(self, brain, rpath, subdomain):
        """ Traverse the site. """
        brains = brain.portal_catalog.searchResults(
            path={'query':brain.getPath(), 'depth':1},
                  review_state='Published')
        for x in brains:
            url = x.getURL()
            self.deployObject(url, x, rpath, subdomain)
            if x.is_folderish:
                self.traverse(x, rpath, subdomain)
            
    def deployObject(self, url, brain, rpath, subdomain):
        """ Deploy an object """
        portal_url = brain.portal_url()    
        if brain.is_folderish:
            #create dir before processing html
            folder_path = url.replace(portal_url, rpath)
            self.createDirectory(folder_path)
        raw = self.httpget(url, portal_url, subdomain)        
        data = self.runFilters(raw, None)
        print url

    def runFilters(self, data, filterchain):
        """ Filter content """
        return data
    
    def httpget(self, url, portal_url, subdomain):
        url = url.replace(portal_url, subdomain)
        return url