source: main/waeup.kofa/trunk/src/waeup/kofa/university/certificate.py @ 9098

## $Id: certificate.py 8993 2012-07-13 06:07:07Z henrik $
##
## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
"""Kofa certificates
"""
import grok
from zope.event import notify
from zope.catalog.interfaces import ICatalog
from zope.intid.interfaces import IIntIds
from zope.schema import getFields
from zope.component import getUtility
from zope.component.interfaces import IFactory, ComponentLookupError
from zope.interface import implementedBy
from waeup.kofa.interfaces import IKofaPluggable
from waeup.kofa.university.interfaces import (
    ICertificate, ICertificateAdd, ICertificateCourse)
from waeup.kofa.university.vocabularies import course_levels

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

    local_roles = [
        'waeup.local.CourseAdviser100',
        'waeup.local.CourseAdviser200',
        'waeup.local.CourseAdviser300',
        'waeup.local.CourseAdviser400',
        'waeup.local.CourseAdviser500',
        'waeup.local.CourseAdviser600',
        ]

    def __init__(self, code=u'NA', title=u'Unnamed Certificate',
                 study_mode=None, start_level=None,
                 end_level=None, application_category=None,
                 school_fee_1=None, school_fee_2=None,
                 school_fee_3=None, school_fee_4=None):
        super(Certificate, self).__init__()
        self.code = code
        self.title = title
        self.study_mode = study_mode
        self.start_level = start_level
        self.end_level = end_level
        self.application_category = application_category
        self.school_fee_1 = school_fee_1
        self.school_fee_2 = school_fee_2
        self.school_fee_3 = school_fee_3
        self.school_fee_4 = school_fee_4

    def longtitle(self):
        return "%s (%s)" % (self.title,self.code)

    def addCertCourse(self, course, level=100, mandatory=True):
        """Add a certificate course.
        """
        code = "%s_%s" % (course.code, level)
        self[code] = CertificateCourse(course, level, mandatory)
        self[code].__parent__ = self
        self[code].__name__ = code
        self._p_changed = True

    def delCertCourse(self, code, level=None):
        """Delete a certificate course denoted by its code.
        """
        keys = list(self.keys()) # create list copy
        for key in keys:
            if self[key].getCourseCode() != code:
                continue
            if level is not None and str(self[key].level) != str(level):
                # found a course with correct key but wrong level...
                continue
            del self[key]
            self._p_changed = True
        return

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, mandatory=True):
        self.course = course
        self.level = level
        self.mandatory = mandatory

    def getCourseCode(self):
        """Get code of a course.
        """
        return self.course.code

    def longtitle(self):
        return "%s in level %s" % (self.course.code,
                   course_levels.getTerm(self.level).title)

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)

@grok.subscribe(ICertificate, grok.IObjectRemovedEvent)
def handle_certificate_removed(certificate, event):
    """If a certificate is deleted, we make sure that also referrers to
    student studycourse objects are removed.
    """
    code = certificate.code

    # Find all student studycourses that refer to given certificate...
    try:
        cat = getUtility(ICatalog, name='students_catalog')
    except ComponentLookupError:
        # catalog not available. This might happen during tests.
        return

    results = cat.searchResults(certcode=(code, code))
    for student in results:
        # Remove that referrer...
        studycourse = student['studycourse']
        studycourse.certificate = None
        notify(grok.ObjectModifiedEvent(student))
        student.__parent__.logger.info(
            'ObjectRemovedEvent - %s - removed: certificate' % student.__name__)
    return

class CertificatesPlugin(grok.GlobalUtility):
    """A plugin that updates certificates.
    """

    grok.implements(IKofaPluggable)
    grok.name('certificates')

    deprecated_attributes = []

    def setup(self, site, name, logger):
        return

    def update(self, site, name, logger):
        cat = getUtility(ICatalog, name='certificates_catalog')
        results = cat.apply({'code':(None,None)})
        uidutil = getUtility(IIntIds, context=cat)
        items = getFields(ICertificate).items()
        for r in results:
            o = uidutil.getObject(r)
            # Add new attributes
            for i in items:
                if not hasattr(o,i[0]):
                    setattr(o,i[0],i[1].missing_value)
                    logger.info(
                        'CertificatesPlugin: %s attribute %s added.' % (
                        o.code,i[0]))
            # Remove deprecated attributes
            for i in self.deprecated_attributes:
                try:
                    delattr(o,i)
                    logger.info(
                        'CertificatesPlugin: %s attribute %s deleted.' % (
                        o.code,i))
                except AttributeError:
                    pass
        return