source: waeup/branches/ulif-rewrite/src/waeup/viewlets.py @ 4091

# -*- coding: utf-8 -*-
import grok
import zope.interface
from zope.component import getMultiAdapter
from zope.location.interfaces import ISite
from waeup.interfaces import (IUniversity, IWAeUPObject, IWAeUPXMLExporter,
                        IWAeUPXMLImporter)

grok.context(zope.interface.Interface)

class Index(grok.View):
    """main structure for all pages"""
    grok.template('master')
    
class Manage(grok.View):
    """Admin view for waeup objects.
    """
    grok.context(IWAeUPObject)
    grok.template('master')

class Add(grok.View):
    """Admin add form wrapper for waeup objects.
    """
    grok.context(IWAeUPObject)
    grok.template('master')

class ExportXML(grok.View):
    """Deliver an XML representation of the context.
    """
    grok.name('export.xml')
    grok.require('waeup.manageUniversity')
    
    def render(self):
        exporter = IWAeUPXMLExporter(self.context)
        xml = exporter.export().read()
        self.response.setHeader(
            'Content-Type', 'text/xml; charset=UTF-8')
        return xml

class ImportXML(grok.View):
    """Replace the context object by an object created from an XML
       representation.

       XXX: This does not work for ISite objects, i.e. for instance
            for complete University objects.
    """
    grok.require('waeup.manageUniversity')
    grok.template('master')

    def update(self, xmlfile=None, CANCEL=None, SUBMIT=None):
        if CANCEL is not None:
            self.redirect(self.url(self.context))
            return
        if not xmlfile:
            return
        importer = IWAeUPXMLImporter(self.context)
        obj = importer.doImport(xmlfile)
        if type(obj) != type(self.context):
            return
        parent = self.context.__parent__
        name = self.context.__name__
        self.context = obj
        if hasattr(parent, name):
            setattr(parent, name, obj)
        else:
            del parent[name]
            parent[name] = obj
            pass
        return
        
            
    
class Head(grok.ViewletManager):
    """additions to HTML head"""
    grok.name('head')

class Title(grok.Viewlet):
    grok.viewletmanager(Head)

class AppCSS(grok.Viewlet):
    grok.viewletmanager(Head)

class Header(grok.ViewletManager):
    grok.name('header')

class Logo(grok.Viewlet):
    grok.viewletmanager(Header)
    grok.order(1)

    def getAppTitle(self):
        """Get the `name` attribute of the local site object.

        This is normally the waeup application or IUniversity object.
        If this object has no ``name`` attribute, then we return the
        empty string.
        """
        app = grok.getSite()
        return getattr(app, 'name', u'')

class NavigationBar(grok.Viewlet):
    grok.viewletmanager(Header)
    grok.order(2)
    
    def getSite(self):
        return grok.getSite()

class LeftSidebar(grok.ViewletManager):
    grok.name('left')

class AuthUser(grok.Viewlet):
    grok.viewletmanager(LeftSidebar)
    grok.order(1)

class Login(grok.Viewlet):
    """This viewlet allows to login in the sidebar.
    """
    grok.viewletmanager(LeftSidebar)
    grok.context(IUniversity)
    grok.view(Index)
    grok.order(2)

    def isAuthenticated(self):
        """Is the calling user authenticated?
        """
        return self.request.principal.id != 'zope.anybody'

class ExportLink(grok.Viewlet):
    grok.viewletmanager(LeftSidebar)
    grok.view(Index)
    grok.order(99)
    grok.require('waeup.manageUniversity')

    def render(self):
        return '<div class="portlet"><a href="export.xml">%s</a></div>' % (
            'Export as XML',)

class ImportLink(grok.Viewlet):
    grok.viewletmanager(LeftSidebar)
    grok.view(Index)
    grok.order(99)
    grok.require('waeup.manageUniversity')

    def render(self):
        if ISite.providedBy(self.context):
            # We cannot simply replace local sites.
            return ''
        return '<div class="portlet"><a href="importxml">%s</a></div>' % (
            'Import from XML',)
    
class MainArea(grok.ViewletManager):
    grok.name('main')

class ImportXMLViewlet(grok.Viewlet):
    grok.viewletmanager(MainArea)
    grok.view(ImportXML)
    

class Footer(grok.ViewletManager):
    grok.name('footer')

class Copyright(grok.Viewlet):
    grok.viewletmanager(Footer)

class FormWrapMixin(object):
    """Mixin for viewlets that renders forms.

    XXX: Need tests for this.
    
    This is a mixin that provides some convenience features for
    viewlets that want to render forms, by overriding the default
    `render()` and `update()` methods.

    To create a viewlet that renders a form, you can define one as
    usual but also derive from this mixin-class.

    Say we have a usual form view like this::

      >>> import grok
      >>> class EditForm(grok.EditForm):
      ...   grok.context(SomeType)
      ...   grok.name('addsometype')
      ...   form_fields = grok.AutoFields(IUniversity)
      ...   @grok.action('Save')
      ...   def save(self, **data):
      ...     self.applyData(self.context, **data)
      ...     return

    then we can create a viewlet that displays this view like this::
      
      >>> import grok
      >>> from waeup.viewlets import FormWrapMixin
      >>> class EditFormViewlet(FormWrapMixin, grok.Viewlet):
      ...     grok.viewletmanager(MainArea)
      ...     grok.context(ISomeType)
      ...     grok.view(Manage)
      ...     formview_name = 'addsometype'

    Here we define a regular viewlet with two modifications:

    * it is also derived from `FormWrapMixin` and

    * it provides an attribute ``formview_name`` which tells us, what
      form we want to be rendered in this viewlet. We tell the name of
      this form and not its class or similar.

    The associated view, context, viewletmanager, etc. can be set as
    with regular viewlets.
    
    """
    formview_name = None
    
    def update(self):
        self.form = getMultiAdapter((self.context, self.request),
                                    name=self.formview_name)
        self.form.update_form()
        if self.request.method == 'POST':
            #app = get_application(self.context)
            #self.__parent__.redirect(self.__parent__.url(obj=app))
            pass

    def render(self):
        result = self.form.render()
        try:
            # strip all except the form part...
            result = re.match('^.+\(<form[^\>]+>.*</form>).+$', result,
                              re.DOTALL).groups()[0]
        except:
            # except there is no such part...
            pass
        return result