source: waeup/branches/ulif-rewrite/src/waeup/university/certificate.py @ 4516

"""WAeUP portal certificates
"""
import grok
from hurry.workflow.interfaces import IWorkflowInfo, IWorkflowState
from zope.app.catalog.interfaces import ICatalog
from zope.component import getUtility
from zope.component.interfaces import IFactory, ComponentLookupError
from zope.interface import implementedBy
from waeup.interfaces import (ICertificate, ICertificateContainer,
                              ICertificateCourse, ICourse, IDepartment)
from waeup.viewlets import FormWrapMixin, Index, Manage, MainArea
from waeup.utils.helpers import getName

class Certificate(grok.Container):
    """A certificate.
    """
    grok.implements(ICertificate)

    def __init__(self, code=u'NA', title=u'Unnamed Certificate',
                 category=None, study_mode=None, start_level=None,
                 end_level=None, application_category=None, m_prefix=u'',
                 max_pass = u''):
        super(Certificate, self).__init__()
        self.code = code
        self.title = title
        self.category = category
        self.study_mode = study_mode
        self.start_level = start_level
        self.end_level = end_level
        self.application_category = application_category
        self.m_prefix = m_prefix
        self.max_pass = max_pass
        # Initialize workflow state...
        self.setReviewState('init')

    def check(self):
        """Set Review State to ``checked``.
        """
        self.setReviewState('check')

    def getReviewState(self):
        return IWorkflowState(self).getState()

    def setReviewState(self, transition_id='check'):
        info = IWorkflowInfo(self)
        info.fireTransition(transition_id)
        return

    def addCourseRef(self, course, level=100, core_or_elective=True):
        """Add a course reference.
        """
        code = "%s_%s" % (course.code, level)
        self[code] = CertificateCourse(course, level, core_or_elective)

    def delCourseRef(self, code):
        """Delete a course denoted by its code.
        """
        for key in self.keys():
            if self[key].getCourseCode() != code:
                continue
            del self[key]
            self._p_changed = True
        return

    review_state = property(getReviewState, setReviewState)


class CertificateFactory(grok.GlobalUtility):
    """A factory for certificates.
    """
    grok.implements(IFactory)
    grok.name(u'waeup.Certificate')
    title = u"Create a new certificate.",
    description = u"This factory instantiates new certificate instances."

    def __call__(self, *args, **kw):
        return Certificate(*args, **kw)

    def getInterfaces(self):
        return implementedBy(Certificate)

class CertificateCourse(grok.Model):
    grok.implements(ICertificateCourse)

    def __init__(self, course=None, level=100, core_or_elective=True):
        self.course = course
        self.level = level
        self.core_or_elective = core_or_elective

    def getCourseCode(self):
        return self.course.code
    
class CertificateCourseFactory(grok.GlobalUtility):
    """A factory for certificate courses.
    """
    grok.implements(IFactory)
    grok.name(u'waeup.CertificateCourse')
    title = u"Create a new certificate course.",
    description = u"This factory instantiates new certificate courses."

    def __call__(self, *args, **kw):
        return CertificateCourse(*args, **kw)

    def getInterfaces(self):
        return implementedBy(CertificateCourse)

class ContentHeader(grok.Viewlet):
    """A viewlet that renders the faculty, department and course title.
    """
    grok.viewletmanager(MainArea)
    grok.context(ICertificate)
    grok.view(Index)
    grok.order(2)

    def render(self):
        return '''<h5>%s</h5><h4>%s</h4><h3>%s</h3>''' % (
            getName(self.context.__parent__.__parent__.__parent__),
            getName(self.context.__parent__.__parent__),
            self.context.title)

class DisplayForm(grok.DisplayForm):
    grok.context(ICertificate)
    form_fields = grok.AutoFields(ICertificate)
 
class Content(FormWrapMixin, grok.Viewlet):
    """A viewlet that wraps the `DisplayForm`.
    """
    grok.viewletmanager(MainArea)
    grok.context(ICertificate)
    grok.view(Index)
    grok.order(2)
    formview_name = 'displayform' # The name of the formview we want
                                  # to be rendered in this viewlet.


class ManageForm(grok.EditForm):
    """Manage the basic properties of a `Department` instance.
    """
    grok.context(ICertificate)
    form_fields = grok.AutoFields(ICertificate)

    @property
    def label(self):
        # Set certificate name as form label
        return self.form_fields['title'].field.get(self.context)
    
    @grok.action('Save')
    def save(self, **data):
        self.applyData(self.context, **data)
        return
    
    @grok.action('Save and return')
    def saveAndReturn(self, **data):
        self.applyData(self.context, **data)
        self.redirect(self.url(self.context))
        return

    @grok.action('Cancel')
    def cancel(self, **data):
        self.redirect(self.url(self.context))
        return

class ManageCertificate(FormWrapMixin, grok.Viewlet):
    """A viewlet that renders the `ManageForm`.
    """
    grok.viewletmanager(MainArea)
    grok.context(ICertificate)
    grok.view(Manage)
    grok.require('waeup.manageUniversity')
    
    formview_name = 'manageform' # The name of the formview we want to
                                 # be rendered in this viewlet.

class CourseList(grok.Viewlet):
    grok.viewletmanager(MainArea)
    grok.context(ICertificate)
    grok.view(Index)
    grok.order(2)

    def render(self):
        result = '<h3>Courses</h4>\n'
        for key, course in self.context.items():
            certcourse = self.context[key]
            course = certcourse.course
            result += '<div><a href="%s">%s</a>%s (%s / %s)</div>' % (
                self.view.url(course), course.code, course.title,
                certcourse.level, certcourse.core_or_elective)
        return result
    
@grok.subscribe(ICourse, grok.IObjectRemovedEvent)
def removedCourseHandler(course, event):
    """If a course is deleted, we make sure that also references in a
       certificatecontainer are removed.
    """
    code = course.code

    # Find all certcourses that reference the given course...
    try:
        cat = getUtility(ICatalog, name='certcourses_catalog')
    except ComponentLookupError:
        # catalog not available. This might happen during tests.
        return
        
    results = cat.searchResults(course_code=(code, code))
    for certcourse in results:
        # Remove that reference...
        cert = certcourse.__parent__
        cert.delCourseRef(code)
        cert._p_changed = True
    return