Ignore:
Timestamp:
8 Mar 2012, 19:00:51 (13 years ago)
Author:
uli
Message:

Rename all non-locales stuff from sirp to kofa.

Location:
main/waeup.kofa/trunk/src/waeup/kofa/university
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • main/waeup.kofa/trunk/src/waeup/kofa/university/__init__.py

    r7681 r7811  
    11# Make this a package.
    2 from waeup.sirp.university.course import Course
    3 from waeup.sirp.university.coursescontainer import CoursesContainer
    4 from waeup.sirp.university.certificate import Certificate
    5 from waeup.sirp.university.certificatescontainer import CertificatesContainer
    6 from waeup.sirp.university.faculty import Faculty
    7 from waeup.sirp.university.department import Department
    8 from waeup.sirp.university.facultiescontainer import FacultiesContainer
     2from waeup.kofa.university.course import Course
     3from waeup.kofa.university.coursescontainer import CoursesContainer
     4from waeup.kofa.university.certificate import Certificate
     5from waeup.kofa.university.certificatescontainer import CertificatesContainer
     6from waeup.kofa.university.faculty import Faculty
     7from waeup.kofa.university.department import Department
     8from waeup.kofa.university.facultiescontainer import FacultiesContainer
    99__all__ = (
    1010    'Course', 'CoursesContainer',

  • main/waeup.kofa/trunk/src/waeup/kofa/university/api.txt

    r7333 r7811  
    1 :mod:`waeup.sirp.university` -- academic components
     1:mod:`waeup.kofa.university` -- academic components
    22***************************************************
    33
    4 .. module:: waeup.sirp.university
     4.. module:: waeup.kofa.university
    55
    66Components that represent academic 'core' stuff like faculties,
    … …  
    99==========
    1010
    11 The :mod:`waeup.sirp.university` module provides the following submodules:
     11The :mod:`waeup.kofa.university` module provides the following submodules:
    1212
    1313.. toctree::

  • main/waeup.kofa/trunk/src/waeup/kofa/university/batching.py

    r7665 r7811  
    2626import grok
    2727from zope.interface import Interface
    28 from waeup.sirp.interfaces import IBatchProcessor
    29 from waeup.sirp.university.interfaces import (
     28from waeup.kofa.interfaces import IBatchProcessor
     29from waeup.kofa.university.interfaces import (
    3030    IFacultiesContainer, IFaculty, ICourse, IDepartment, ICertificate,
    3131    ICertificateCourse)
    32 from waeup.sirp.utils.batching import BatchProcessor
     32from waeup.kofa.utils.batching import BatchProcessor
    3333
    3434class FacultyProcessor(BatchProcessor):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/catalog.py

    r7641 r7811  
    2626from zope.index.text.parsetree import ParseError
    2727from zope.intid import IIntIds
    28 #from waeup.sirp.catalog import QueryResultItem
    29 from waeup.sirp.interfaces import IUniversity, IQueryResultItem
    30 from waeup.sirp.university.interfaces import (
     28#from waeup.kofa.catalog import QueryResultItem
     29from waeup.kofa.interfaces import IUniversity, IQueryResultItem
     30from waeup.kofa.university.interfaces import (
    3131    ICourse, ICertificateCourse, IDepartment,
    3232    ICertificate,

  • main/waeup.kofa/trunk/src/waeup/kofa/university/certificate.py

    r7751 r7811  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """SIRP certificates
     18"""KOFA certificates
    1919"""
    2020import grok
    … …  
    2424from zope.component.interfaces import IFactory, ComponentLookupError
    2525from zope.interface import implementedBy
    26 from waeup.sirp.university.interfaces import (
     26from waeup.kofa.university.interfaces import (
    2727    ICertificate, ICertificateAdd, ICertificateCourse)
    28 from waeup.sirp.university.vocabularies import course_levels
     28from waeup.kofa.university.vocabularies import course_levels
    2929
    3030class Certificate(grok.Container):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/certificate.txt

    r7665 r7811  
    1 :mod:`waeup.sirp.university.certificate` -- Certificates for SIRP
     1:mod:`waeup.kofa.university.certificate` -- Certificates for KOFA
    22******************************************************************
    33
    4 .. module:: waeup.sirp.university.certificate
     4.. module:: waeup.kofa.university.certificate
    55
    66Components that represent and manage certificates.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111
    … …  
    2525   All parameters are optional:
    2626
    27      >>> from waeup.sirp.university.certificate import Certificate
     27     >>> from waeup.kofa.university.certificate import Certificate
    2828     >>> mycertificate = Certificate()
    2929
    3030   Certificates have the attributes required by the `ICertificate` interface:
    3131
    32      >>> from waeup.sirp.university.interfaces import ICertificate
     32     >>> from waeup.kofa.university.interfaces import ICertificate
    3333     >>> ICertificate.providedBy(mycertificate)
    3434     True
    … …  
    9999
    100100      Add a referrer of a course. A course is an object implementing
    101       :class:`waeup.sirp.interfaces.ICourse`.
     101      :class:`waeup.kofa.interfaces.ICourse`.
    102102
    103103      Please don't be confused by the term 'referrer'. As course objects
    … …  
    159159     >>> mycertificate = createObject(u'waeup.Certificate')
    160160     >>> mycertificate
    161      <waeup.sirp.university.certificate.Certificate object at 0x...>
     161     <waeup.kofa.university.certificate.Certificate object at 0x...>
    162162
    163163   The factory complies with the specifications from the
    … …  
    166166     >>> from zope.interface.verify import verifyClass
    167167     >>> from zope.component.interfaces import IFactory
    168      >>> from waeup.sirp.university.certificate import CertificateFactory
     168     >>> from waeup.kofa.university.certificate import CertificateFactory
    169169     >>> verifyClass(IFactory, CertificateFactory)
    170170     True
    … …  
    175175     >>> certificate_factory = CertificateFactory()
    176176     >>> certificate_factory.getInterfaces()
    177      <implementedBy waeup.sirp.university.certificate.Certificate>
     177     <implementedBy waeup.kofa.university.certificate.Certificate>
    178178
    179179
    … …  
    193193     >>> mycertificatecourse = createObject(u'waeup.CertificateCourse')
    194194     >>> mycertificatecourse
    195      <waeup.sirp.university.certificate.CertificateCourse object at 0x...>
     195     <waeup.kofa.university.certificate.CertificateCourse object at 0x...>
    196196
    197197   The factory complies with the specifications from the
    … …  
    200200     >>> from zope.interface.verify import verifyClass
    201201     >>> from zope.component.interfaces import IFactory
    202      >>> from waeup.sirp.university.certificate import CertificateCourseFactory
     202     >>> from waeup.kofa.university.certificate import CertificateCourseFactory
    203203     >>> verifyClass(IFactory, CertificateCourseFactory)
    204204     True
    … …  
    209209     >>> certcourse_factory = CertificateCourseFactory()
    210210     >>> certcourse_factory.getInterfaces()
    211      <implementedBy waeup.sirp.university.certificate.CertificateCourse>
     211     <implementedBy waeup.kofa.university.certificate.CertificateCourse>
    212212
    213213
    … …  
    244244We can create certificates:
    245245
    246     >>> from waeup.sirp.university.certificate import Certificate
     246    >>> from waeup.kofa.university.certificate import Certificate
    247247    >>> mycertificate = Certificate()
    248248    >>> mycertificate
    249     <waeup.sirp.university.certificate.Certificate object at 0x...>
     249    <waeup.kofa.university.certificate.Certificate object at 0x...>
    250250
    251251Another way to create certificates is by asking for a factory called
    … …  
    256256    >>> mycertificate = createObject(u'waeup.Certificate')
    257257    >>> mycertificate
    258     <waeup.sirp.university.certificate.Certificate object at 0x...>
     258    <waeup.kofa.university.certificate.Certificate object at 0x...>
    259259
    260260CertificateCourses
    … …  
    264264:class:`ICertificateCourse` interface:
    265265
    266     >>> from waeup.sirp.university.interfaces import ICertificateCourse
    267     >>> from waeup.sirp.university.certificate import CertificateCourse
     266    >>> from waeup.kofa.university.interfaces import ICertificateCourse
     267    >>> from waeup.kofa.university.certificate import CertificateCourse
    268268    >>> mycertcourse = CertificateCourse(None, 200, False)
    269269    >>> ICertificateCourse.providedBy(mycertcourse)
    … …  
    280280    >>> mycertcourse = createObject(u'waeup.CertificateCourse')
    281281    >>> mycertcourse
    282     <waeup.sirp.university.certificate.CertificateCourse object at 0x...>
     282    <waeup.kofa.university.certificate.CertificateCourse object at 0x...>
    283283
    284284.. _removecertificatecourses:

  • main/waeup.kofa/trunk/src/waeup/kofa/university/certificatescontainer.py

    r7333 r7811  
    2323from zope.component import queryUtility
    2424from zope.interface import implementedBy
    25 from waeup.sirp.interfaces import DuplicationError
    26 from waeup.sirp.university.interfaces import (
     25from waeup.kofa.interfaces import DuplicationError
     26from waeup.kofa.university.interfaces import (
    2727    ICertificatesContainer, ICertificate)
    2828
    … …  
    3131
    3232    A :class:`CertificatesContainer` stores
    33     :class:`waeup.sirp.university.Certificate` instances.
     33    :class:`waeup.kofa.university.Certificate` instances.
    3434
    3535    It is a :class:`grok.Container` basically acting like a standard
    … …  
    5252
    5353        The `certificate` must be an object implementing
    54         :class:`waeup.sirp.university.interfaces.ICertificate`. If
     54        :class:`waeup.kofa.university.interfaces.ICertificate`. If
    5555        not, a :exc:`TypeError` is raised.
    5656
    … …  
    6060        If the `code` attribute of `certificate` is already in use by
    6161        another certificate stored in the local site
    62         (:class:`waeup.sirp.app.University` instance), then a
    63         :exc:`waeup.sirp.interfaces.DuplicationError` will be raised.
     62        (:class:`waeup.kofa.app.University` instance), then a
     63        :exc:`waeup.kofa.interfaces.DuplicationError` will be raised.
    6464
    6565        If `name` is already used as a key, a :exc:`KeyError` will be
    … …  
    9292
    9393        The certificate must be an object implementing
    94         :class:`waeup.sirp.university.interfaces.ICertificate`. If
     94        :class:`waeup.kofa.university.interfaces.ICertificate`. If
    9595        not, a :exc:`TypeError` is raised.
    9696
    … …  
    9898        `code` attribute as key. If this key is already used for
    9999        another certificate stored in the local site
    100         (:class:`waeup.sirp.app.University` instance), then a
    101         :exc:`waeup.sirp.interfaces.DuplicationError` will be raised.
     100        (:class:`waeup.kofa.app.University` instance), then a
     101        :exc:`waeup.kofa.interfaces.DuplicationError` will be raised.
    102102        """
    103103        self[getattr(certificate, 'code', None)] = certificate

  • main/waeup.kofa/trunk/src/waeup/kofa/university/certificatescontainer.txt

    r7333 r7811  
    1 :mod:`waeup.sirp.university.certificatescontainer` -- Certificate containers
     1:mod:`waeup.kofa.university.certificatescontainer` -- Certificate containers
    22****************************************************************************
    33
    4 .. module:: waeup.sirp.university.certificatescontainer
     4.. module:: waeup.kofa.university.certificatescontainer
    55
    66Containers for certificates.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111
    … …  
    2626   :class:`CertificatesContainer` instances are instances of
    2727   :class:`grok.Container` that hold and manage instances of
    28    :class:`waeup.sirp.university.certificate.Certificate`.
     28   :class:`waeup.kofa.university.certificate.Certificate`.
    2929
    30      >>> from waeup.sirp.university.certificatescontainer import CertificatesContainer
     30     >>> from waeup.kofa.university.certificatescontainer import CertificatesContainer
    3131     >>> mycontainer = CertificatesContainer()
    3232     >>> mycontainer
    33      <waeup.sirp.university.certificatescontainer.CertificatesContainer object at 0x...>
     33     <waeup.kofa.university.certificatescontainer.CertificatesContainer object at 0x...>
    3434
    3535   Certificate containers provide `ICertificatesContainer`:
    3636
    37      >>> from waeup.sirp.university.interfaces import ICertificatesContainer
     37     >>> from waeup.kofa.university.interfaces import ICertificatesContainer
    3838     >>> ICertificatesContainer.providedBy(mycontainer)
    3939     True
    … …  
    5757
    5858      *certificate* must be an instance of
    59       :class:`waeup.sirp.university.certificate.Certificate`:
     59      :class:`waeup.kofa.university.certificate.Certificate`:
    6060
    61         >>> from waeup.sirp.university.certificatescontainer import (
     61        >>> from waeup.kofa.university.certificatescontainer import (
    6262        ...   CertificatesContainer)
    6363        >>> mycontainer = CertificatesContainer()
    … …  
    6969      The key of added items is the ``code`` attribute:
    7070
    71         >>> from waeup.sirp.university.certificate import Certificate
     71        >>> from waeup.kofa.university.certificate import Certificate
    7272        >>> mycertificate = Certificate(code='CERTIFICATE1')
    7373        >>> mycontainer.addCertificate(mycertificate)
    … …  
    104104     >>> mycertificatescontainer = createObject(u'waeup.CertificatesContainer')
    105105     >>> mycertificatescontainer
    106      <waeup.sirp.university.certificatescontainer.CertificatesContainer object at 0x...>
     106     <waeup.kofa.university.certificatescontainer.CertificatesContainer object at 0x...>
    107107
    108108   The factory complies with the specifications from the
    … …  
    111111     >>> from zope.interface.verify import verifyClass
    112112     >>> from zope.component.interfaces import IFactory
    113      >>> from waeup.sirp.university.certificatescontainer import (
     113     >>> from waeup.kofa.university.certificatescontainer import (
    114114     ...   CertificatesContainerFactory)
    115115     >>> verifyClass(IFactory, CertificatesContainerFactory)
    … …  
    121121     >>> certificatescontainer_factory = CertificatesContainerFactory()
    122122     >>> certificatescontainer_factory.getInterfaces()
    123      <implementedBy waeup.sirp.university.certificatescontainer.CertificatesContainer>
     123     <implementedBy waeup.kofa.university.certificatescontainer.CertificatesContainer>
    124124
    125125
    … …  
    132132We can easily create `CertificatesContainers`:
    133133
    134     >>> from waeup.sirp.university.certificatescontainer import CertificatesContainer
     134    >>> from waeup.kofa.university.certificatescontainer import CertificatesContainer
    135135    >>> mycontainer = CertificatesContainer()
    136136
    … …  
    143143    >>> from zope.component import createObject
    144144    >>> createObject(u'waeup.CertificatesContainer')
    145     <waeup.sirp.university.certificatescontainer.CertificatesContainer object at 0x...>
     145    <waeup.kofa.university.certificatescontainer.CertificatesContainer object at 0x...>
    146146
    147147This way we get a thing that implements ICertificatesContainer without

  • main/waeup.kofa/trunk/src/waeup/kofa/university/course.py

    r7333 r7811  
    2323from zope.component import getUtility
    2424from zope.component.interfaces import IFactory, ComponentLookupError
    25 from waeup.sirp.university.interfaces import ICourse, ICourseAdd
     25from waeup.kofa.university.interfaces import ICourse, ICourseAdd
    2626
    2727class Course(grok.Model):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/course.txt

    r7321 r7811  
    1 :mod:`waeup.sirp.university.course` -- Courses
     1:mod:`waeup.kofa.university.course` -- Courses
    22**********************************************
    33
    4 .. module:: waeup.sirp.university.course
     4.. module:: waeup.kofa.university.course
    55
    66Components that represent courses.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111Content Classes (models and containers)
    … …  
    2323   All parameters are optional:
    2424
    25      >>> from waeup.sirp.university.course import Course
     25     >>> from waeup.kofa.university.course import Course
    2626     >>> mycourse = Course()
    2727     >>> mycourse
    28      <waeup.sirp.university.course.Course object at 0x...>
     28     <waeup.kofa.university.course.Course object at 0x...>
    2929
    3030   Course instances have the attributes required by the
    31    :class:`waeup.sirp.interfaces.ICourse` interface:
     31   :class:`waeup.kofa.interfaces.ICourse` interface:
    3232
    33      >>> from waeup.sirp.university.interfaces import ICourse
     33     >>> from waeup.kofa.university.interfaces import ICourse
    3434     >>> ICourse.providedBy(mycourse)
    3535     True
    … …  
    101101     >>> mycourse = createObject(u'waeup.Course')
    102102     >>> mycourse
    103      <waeup.sirp.university.course.Course object at 0x...>
     103     <waeup.kofa.university.course.Course object at 0x...>
    104104
    105105   The factory complies with the specifications from the
    … …  
    108108     >>> from zope.interface.verify import verifyClass
    109109     >>> from zope.component.interfaces import IFactory
    110      >>> from waeup.sirp.university.course import CourseFactory
     110     >>> from waeup.kofa.university.course import CourseFactory
    111111     >>> verifyClass(IFactory, CourseFactory)
    112112     True
    … …  
    117117     >>> course_factory = CourseFactory()
    118118     >>> course_factory.getInterfaces()
    119      <implementedBy waeup.sirp.university.course.Course>
     119     <implementedBy waeup.kofa.university.course.Course>
    120120
    121121Examples
    … …  
    128128class and calling the constructor:
    129129
    130     >>> from waeup.sirp.university.course import Course
     130    >>> from waeup.kofa.university.course import Course
    131131    >>> mycourse = Course()
    132132    >>> mycourse
    133     <waeup.sirp.university.course.Course object at 0x...>
     133    <waeup.kofa.university.course.Course object at 0x...>
    134134
    135135Another way to create courses is by asking for a factory called
    … …  
    140140    >>> mycourse = createObject(u'waeup.Course')
    141141    >>> mycourse
    142     <waeup.sirp.university.course.Course object at 0x...>
     142    <waeup.kofa.university.course.Course object at 0x...>
    143143

  • main/waeup.kofa/trunk/src/waeup/kofa/university/courserefs.txt

    r6737 r7811  
    1616As correct deletion of referrer needs support of catalogs (we lookup
    1717catalogs to find referrers), we need a fully blown ZODB here,
    18 including an instance of :class:`waeup.sirp.app.University`, as this is our
     18including an instance of :class:`waeup.kofa.app.University`, as this is our
    1919`ISite` object where the catalogs are stored.
    2020
    … …  
    2323and course certificates:
    2424
    25     >>> from waeup.sirp.app import University
     25    >>> from waeup.kofa.app import University
    2626    >>> root = getRootFolder()
    2727    >>> root['app'] = University()

  • main/waeup.kofa/trunk/src/waeup/kofa/university/coursescontainer.py

    r7333 r7811  
    2323from zope.catalog.interfaces import ICatalog
    2424from zope.component import queryUtility
    25 from waeup.sirp.interfaces import DuplicationError
    26 from waeup.sirp.university.interfaces import ICoursesContainer, ICourse
     25from waeup.kofa.interfaces import DuplicationError
     26from waeup.kofa.university.interfaces import ICoursesContainer, ICourse
    2727
    2828class CoursesContainer(grok.Container):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/coursescontainer.txt

    r7333 r7811  
    1 :mod:`waeup.sirp.university.coursescontainer` -- Course containers
     1:mod:`waeup.kofa.university.coursescontainer` -- Course containers
    22******************************************************************
    33
    4 .. module:: waeup.sirp.university.coursescontainer
     4.. module:: waeup.kofa.university.coursescontainer
    55
    66Containers for courses.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111
    … …  
    2626   :class:`CoursesContainer` instances are instances of
    2727   :class:`grok.Container` that hold and manage instances of
    28    :class:`waeup.sirp.university.course.Course`.
     28   :class:`waeup.kofa.university.course.Course`.
    2929
    30      >>> from waeup.sirp.university.coursescontainer import CoursesContainer
     30     >>> from waeup.kofa.university.coursescontainer import CoursesContainer
    3131     >>> mycontainer = CoursesContainer()
    3232     >>> mycontainer
    33      <waeup.sirp.university.coursescontainer.CoursesContainer object at 0x...>
     33     <waeup.kofa.university.coursescontainer.CoursesContainer object at 0x...>
    3434
    3535   Course containers provide `ICoursesContainer`:
    3636
    37      >>> from waeup.sirp.university.interfaces import ICoursesContainer
     37     >>> from waeup.kofa.university.interfaces import ICoursesContainer
    3838     >>> ICoursesContainer.providedBy(mycontainer)
    3939     True
    … …  
    5757
    5858      *course* must be an instance of
    59       :class:`waeup.sirp.university.course.Course`:
     59      :class:`waeup.kofa.university.course.Course`:
    6060
    61         >>> from waeup.sirp.university.coursescontainer import CoursesContainer
     61        >>> from waeup.kofa.university.coursescontainer import CoursesContainer
    6262        >>> mycontainer = CoursesContainer()
    6363        >>> mycontainer.addCourse('blah')
    … …  
    6868      The key of added items is the ``code`` attribute:
    6969
    70         >>> from waeup.sirp.university.course import Course
     70        >>> from waeup.kofa.university.course import Course
    7171        >>> mycourse = Course(code='COURSE1')
    7272        >>> mycontainer.addCourse(mycourse)
    … …  
    103103     >>> mycoursescontainer = createObject(u'waeup.CoursesContainer')
    104104     >>> mycoursescontainer
    105      <waeup.sirp.university.coursescontainer.CoursesContainer object at 0x...>
     105     <waeup.kofa.university.coursescontainer.CoursesContainer object at 0x...>
    106106
    107107   The factory complies with the specifications from the
    … …  
    110110     >>> from zope.interface.verify import verifyClass
    111111     >>> from zope.component.interfaces import IFactory
    112      >>> from waeup.sirp.university.coursescontainer import CoursesContainerFactory
     112     >>> from waeup.kofa.university.coursescontainer import CoursesContainerFactory
    113113     >>> verifyClass(IFactory, CoursesContainerFactory)
    114114     True
    … …  
    119119     >>> coursescontainer_factory = CoursesContainerFactory()
    120120     >>> coursescontainer_factory.getInterfaces()
    121      <implementedBy waeup.sirp.university.coursescontainer.CoursesContainer>
     121     <implementedBy waeup.kofa.university.coursescontainer.CoursesContainer>
    122122
    123123
    … …  
    130130We can easily create `CoursesContainers`:
    131131
    132     >>> from waeup.sirp.university.coursescontainer import CoursesContainer
     132    >>> from waeup.kofa.university.coursescontainer import CoursesContainer
    133133    >>> mycontainer = CoursesContainer()
    134134
    … …  
    141141    >>> from zope.component import createObject
    142142    >>> createObject(u'waeup.CoursesContainer')
    143     <waeup.sirp.university.coursescontainer.CoursesContainer object at 0x...>
     143    <waeup.kofa.university.coursescontainer.CoursesContainer object at 0x...>
    144144
    145145This way we get a thing that implements ICoursesContainer without

  • main/waeup.kofa/trunk/src/waeup/kofa/university/department.py

    r7733 r7811  
    2222from zope.interface import implementedBy
    2323from zope.component import getUtility
    24 from waeup.sirp.university.coursescontainer import CoursesContainer
    25 from waeup.sirp.university.certificatescontainer import CertificatesContainer
    26 from waeup.sirp.interfaces import ISIRPUtils
    27 from waeup.sirp.university.interfaces import IDepartment, IDepartmentAdd
     24from waeup.kofa.university.coursescontainer import CoursesContainer
     25from waeup.kofa.university.certificatescontainer import CertificatesContainer
     26from waeup.kofa.interfaces import IKOFAUtils
     27from waeup.kofa.university.interfaces import IDepartment, IDepartmentAdd
    2828
    2929class Department(grok.Container):
    … …  
    7373
    7474    def longtitle(self):
    75         insttypes_dict = getUtility(ISIRPUtils).getInstTypeDict()
     75        insttypes_dict = getUtility(IKOFAUtils).getInstTypeDict()
    7676        return "%s %s (%s)" % (
    7777            insttypes_dict[self.title_prefix],

  • main/waeup.kofa/trunk/src/waeup/kofa/university/department.txt

    r7333 r7811  
    1 :mod:`waeup.sirp.university.department` -- Departments
     1:mod:`waeup.kofa.university.department` -- Departments
    22******************************************************
    33
    4 .. module:: waeup.sirp.university.department
     4.. module:: waeup.kofa.university.department
    55
    66Components that represent university departments.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111Content Classes (models and containers)
    … …  
    2020   Create a representation of a university department:
    2121
    22      >>> from waeup.sirp.university.department import Department
     22     >>> from waeup.kofa.university.department import Department
    2323     >>> mydept = Department()
    2424     >>> mydept
    25      <waeup.sirp.university.department.Department object at 0x...>
     25     <waeup.kofa.university.department.Department object at 0x...>
    2626
    2727   Another way to create :class:`Department` instances is by asking
    28    for a factory called ``waeup.sirp.Department``. This way we can create a
     28   for a factory called ``waeup.kofa.Department``. This way we can create a
    2929   department without importing a class:
    3030
    … …  
    3232     >>> mydept = createObject(u'waeup.Department')
    3333     >>> mydept
    34      <waeup.sirp.university.department.Department object at 0x...>
     34     <waeup.kofa.university.department.Department object at 0x...>
    3535
    3636   :class:`Department` instances have the attributes required by the
    3737   `IDepartment` interface:
    3838
    39      >>> from waeup.sirp.university.interfaces import IDepartment
     39     >>> from waeup.kofa.university.interfaces import IDepartment
    4040     >>> IDepartment.providedBy(mydept)
    4141     True
    … …  
    8686
    8787        >>> mydept.courses
    88         <waeup.sirp.university.coursescontainer.CoursesContainer object at 0x...>
     88        <waeup.kofa.university.coursescontainer.CoursesContainer object at 0x...>
    8989
    9090
    … …  
    9797
    9898        >>> mydept.certificates
    99         <waeup.sirp...certificatescontainer.CertificatesContainer object at 0x...>
     99        <waeup.kofa...certificatescontainer.CertificatesContainer object at 0x...>
    100100
    101101Utilities
    … …  
    117117     >>> mydepartment = createObject(u'waeup.Department')
    118118     >>> mydepartment
    119      <waeup.sirp.university.department.Department object at 0x...>
     119     <waeup.kofa.university.department.Department object at 0x...>
    120120
    121121   The factory complies with the specifications from the
    … …  
    124124     >>> from zope.interface.verify import verifyClass
    125125     >>> from zope.component.interfaces import IFactory
    126      >>> from waeup.sirp.university.department import DepartmentFactory
     126     >>> from waeup.kofa.university.department import DepartmentFactory
    127127     >>> verifyClass(IFactory, DepartmentFactory)
    128128     True
    … …  
    133133     >>> department_factory = DepartmentFactory()
    134134     >>> department_factory.getInterfaces()
    135      <implementedBy waeup.sirp.university.department.Department>
     135     <implementedBy waeup.kofa.university.department.Department>

  • main/waeup.kofa/trunk/src/waeup/kofa/university/export.py

    r7757 r7811  
    2121import grok
    2222from cStringIO import StringIO
    23 from waeup.sirp.interfaces import ICSVExporter
     23from waeup.kofa.interfaces import ICSVExporter
    2424
    2525class FacultyExporter(grok.GlobalUtility):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/facultiescontainer.py

    r7725 r7811  
    1919from zope.component.interfaces import IFactory
    2020from zope.interface import implementedBy
    21 from waeup.sirp.interfaces import ISIRPPluggable
    22 from waeup.sirp.university.interfaces import IFacultiesContainer, IFaculty
     21from waeup.kofa.interfaces import IKOFAPluggable
     22from waeup.kofa.university.interfaces import IFacultiesContainer, IFaculty
    2323
    2424class FacultiesContainer(grok.Container):
    … …  
    5252    """A plugin that creates container for faculties inside a university.
    5353    """
    54     grok.implements(ISIRPPluggable)
     54    grok.implements(IKOFAPluggable)
    5555    grok.name('faculties')
    5656
    5757    def setup(self, site, name, logger):
    5858        if 'faculties' in site.keys():
    59             logger.warn('Could not create container for faculties in SIRP.')
     59            logger.warn('Could not create container for faculties in KOFA.')
    6060            return
    6161        site['faculties'] = FacultiesContainer()

  • main/waeup.kofa/trunk/src/waeup/kofa/university/facultiescontainer.txt

    r7333 r7811  
    1 :mod:`waeup.sirp.university.facultiescontainer` -- Faculty Containers
     1:mod:`waeup.kofa.university.facultiescontainer` -- Faculty Containers
    22*********************************************************************
    33
    4 .. module:: waeup.sirp.university.facultiescontainer
     4.. module:: waeup.kofa.university.facultiescontainer
    55
    66Components that represent faculty containers.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111
    … …  
    2020   Create a faculty container:
    2121
    22      >>> from waeup.sirp.university.facultiescontainer import FacultiesContainer
     22     >>> from waeup.kofa.university.facultiescontainer import FacultiesContainer
    2323     >>> mycontainer = FacultiesContainer()
    2424     >>> mycontainer
    25      <waeup.sirp.university.facultiescontainer.FacultiesContainer object at 0x...>
     25     <waeup.kofa.university.facultiescontainer.FacultiesContainer object at 0x...>
    2626
    2727   Another way to create :class:`FacultiesContainer` instances is by asking
    … …  
    3232     >>> mycontainer = createObject(u'waeup.FacultiesContainer')
    3333     >>> mycontainer
    34      <waeup.sirp.university.facultiescontainer.FacultiesContainer object at 0x...>
     34     <waeup.kofa.university.facultiescontainer.FacultiesContainer object at 0x...>
    3535
    3636   :class:`FacultiesContainer` instances have the attributes required by the
    3737   `IFacultiesContainer` interface:
    3838
    39      >>> from waeup.sirp.university.interfaces import IFacultiesContainer
     39     >>> from waeup.kofa.university.interfaces import IFacultiesContainer
    4040     >>> IFacultiesContainer.providedBy(mycontainer)
    4141     True
    … …  
    6060      Regular faculties are accepted:
    6161
    62         >>> from waeup.sirp.university.faculty import Faculty
     62        >>> from waeup.kofa.university.faculty import Faculty
    6363        >>> mycontainer.addFaculty(Faculty(title='Physics',
    6464        ...                                code='FP'))
    6565
    6666        >>> list(mycontainer.items())
    67         [(u'FP', <waeup.sirp.university.faculty.Faculty object at 0x...>)]
     67        [(u'FP', <waeup.kofa.university.faculty.Faculty object at 0x...>)]
    6868
    6969
    … …  
    7777.. class:: AcademicsPlugin()
    7878
    79    .. attribute:: grok.implements(ISIRPPluggable)
     79   .. attribute:: grok.implements(IKOFAPluggable)
    8080
    8181   This plugin component tells under which name (``faculties``) an
    82    instance of academics stuff should be created in plain SIRP
     82   instance of academics stuff should be created in plain KOFA
    8383   instances. It also tells the factory name for FacultiesContainer
    84    instances, which serve as root object for academics stuff in SIRP apps.
     84   instances, which serve as root object for academics stuff in KOFA apps.
    8585
    8686
    … …  
    100100     >>> mycontainer = createObject(u'waeup.FacultiesContainer')
    101101     >>> mycontainer
    102      <waeup.sirp.university.facultiescontainer.FacultiesContainer object at 0x...>
     102     <waeup.kofa.university.facultiescontainer.FacultiesContainer object at 0x...>
    103103
    104104   The factory complies with the specifications from the
    … …  
    107107     >>> from zope.interface.verify import verifyClass
    108108     >>> from zope.component.interfaces import IFactory
    109      >>> from waeup.sirp.university.facultiescontainer import (
     109     >>> from waeup.kofa.university.facultiescontainer import (
    110110     ...   FacultiesContainerFactory)
    111111     >>> verifyClass(IFactory, FacultiesContainerFactory)
    … …  
    117117     >>> fac_container_factory = FacultiesContainerFactory()
    118118     >>> fac_container_factory.getInterfaces()
    119      <implementedBy waeup.sirp.university.facultiescontainer.FacultiesContainer>
     119     <implementedBy waeup.kofa.university.facultiescontainer.FacultiesContainer>
    120120
    121121Examples
    … …  
    124124We can easily create `FacultiesContainers`:
    125125
    126     >>> from waeup.sirp.university.facultiescontainer import FacultiesContainer
     126    >>> from waeup.kofa.university.facultiescontainer import FacultiesContainer
    127127    >>> mycontainer = FacultiesContainer()
    128128
    129129Faculty containers provide `IFacultiesContainer`:
    130130
    131     >>> from waeup.sirp.university.interfaces import IFacultiesContainer
     131    >>> from waeup.kofa.university.interfaces import IFacultiesContainer
    132132    >>> IFacultiesContainer.providedBy(mycontainer)
    133133    True
    … …  
    139139    >>> from zope.component import createObject
    140140    >>> createObject(u'waeup.FacultiesContainer')
    141     <waeup.sirp.university.facultiescontainer.FacultiesContainer object at 0x...>
     141    <waeup.kofa.university.facultiescontainer.FacultiesContainer object at 0x...>
    142142
    143143This way we get a thing that implements IFacultiesContainer without
    … …  
    165165Okay, so we have to get a faculty first::
    166166
    167     >>> from waeup.sirp.university.faculty import Faculty
     167    >>> from waeup.kofa.university.faculty import Faculty
    168168    >>> myfaculty = Faculty()
    169169

  • main/waeup.kofa/trunk/src/waeup/kofa/university/faculty.py

    r7729 r7811  
    2323from zope.interface import implementedBy
    2424from zope.component import getUtility
    25 from waeup.sirp.interfaces import ISIRPUtils
    26 from waeup.sirp.university.interfaces import (
     25from waeup.kofa.interfaces import IKOFAUtils
     26from waeup.kofa.university.interfaces import (
    2727    IFaculty, IFacultyAdd, IDepartment)
    2828
    … …  
    6161
    6262    def longtitle(self):
    63         insttypes_dict = getUtility(ISIRPUtils).getInstTypeDict()
     63        insttypes_dict = getUtility(IKOFAUtils).getInstTypeDict()
    6464        result = "%s %s (%s)" % (
    6565            insttypes_dict[self.title_prefix],

  • main/waeup.kofa/trunk/src/waeup/kofa/university/faculty.txt

    r7321 r7811  
    1 :mod:`waeup.sirp.university.faculty` -- Faculties
     1:mod:`waeup.kofa.university.faculty` -- Faculties
    22*************************************************
    33
    4 .. module:: waeup.sirp.university.faculty
     4.. module:: waeup.kofa.university.faculty
    55
    66Components that represent university faculties.
    77
    88.. :doctest:
    9 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111
    … …  
    2121   Create a representation of a university faculty:
    2222
    23      >>> from waeup.sirp.university.faculty import Faculty
     23     >>> from waeup.kofa.university.faculty import Faculty
    2424     >>> myfac = Faculty()
    2525     >>> myfac
    26      <waeup.sirp.university.faculty.Faculty object at 0x...>
     26     <waeup.kofa.university.faculty.Faculty object at 0x...>
    2727
    2828   Another way to create :class:`Faculty` instances is by asking
    … …  
    3333     >>> myfac = createObject(u'waeup.Faculty')
    3434     >>> myfac
    35      <waeup.sirp.university.faculty.Faculty object at 0x...>
     35     <waeup.kofa.university.faculty.Faculty object at 0x...>
    3636
    3737   :class:`Faculty` instances have the attributes required by the
    3838   `IFaculty` interface:
    3939
    40      >>> from waeup.sirp.university.interfaces import IFaculty
     40     >>> from waeup.kofa.university.interfaces import IFaculty
    4141     >>> IFaculty.providedBy(myfac)
    4242     True
    … …  
    6262      Regular departments are accepted:
    6363
    64         >>> from waeup.sirp.university.department import Department
     64        >>> from waeup.kofa.university.department import Department
    6565        >>> myfac.addDepartment(Department(title='Physics',
    6666        ...                                code='DP'))
    6767
    6868        >>> list(myfac.items())
    69         [(u'DP', <waeup.sirp.university.department.Department object at 0x...>)]
     69        [(u'DP', <waeup.kofa.university.department.Department object at 0x...>)]
    7070
    7171
    … …  
    121121     >>> myfaculty = createObject(u'waeup.Faculty')
    122122     >>> myfaculty
    123      <waeup.sirp.university.faculty.Faculty object at 0x...>
     123     <waeup.kofa.university.faculty.Faculty object at 0x...>
    124124
    125125   The factory complies with the specifications from the
    … …  
    128128     >>> from zope.interface.verify import verifyClass
    129129     >>> from zope.component.interfaces import IFactory
    130      >>> from waeup.sirp.university.faculty import FacultyFactory
     130     >>> from waeup.kofa.university.faculty import FacultyFactory
    131131     >>> verifyClass(IFactory, FacultyFactory)
    132132     True
    … …  
    137137     >>> faculty_factory = FacultyFactory()
    138138     >>> faculty_factory.getInterfaces()
    139      <implementedBy waeup.sirp.university.faculty.Faculty>
     139     <implementedBy waeup.kofa.university.faculty.Faculty>
    140140
    141141
    … …  
    145145We can create faculties:
    146146
    147     >>> from waeup.sirp.university.faculty import Faculty
     147    >>> from waeup.kofa.university.faculty import Faculty
    148148    >>> myfaculty = Faculty()
    149149    >>> myfaculty
    150     <waeup.sirp.university.faculty.Faculty object at 0x...>
     150    <waeup.kofa.university.faculty.Faculty object at 0x...>
    151151
    152152Another way to create faculties is by asking for a factory called
    … …  
    157157    >>> myfaculty = createObject(u'waeup.Faculty')
    158158    >>> myfaculty
    159     <waeup.sirp.university.faculty.Faculty object at 0x...>
     159    <waeup.kofa.university.faculty.Faculty object at 0x...>
    160160
    161161Faculty attributes
    … …  
    164164Faculties have the attributes required by the `IFaculty` interface:
    165165
    166     >>> from waeup.sirp.university.interfaces import IFaculty
     166    >>> from waeup.kofa.university.interfaces import IFaculty
    167167    >>> IFaculty.providedBy(myfaculty)
    168168    True

  • main/waeup.kofa/trunk/src/waeup/kofa/university/interfaces.py

    r7707 r7811  
    2121from zope import schema
    2222from zope.interface import Attribute
    23 from waeup.sirp.interfaces import (ISIRPObject, ISIRPContainer)
    24 from waeup.sirp.interfaces import MessageFactory as _
    25 from waeup.sirp.university.vocabularies import (
     23from waeup.kofa.interfaces import (IKOFAObject, IKOFAContainer)
     24from waeup.kofa.interfaces import MessageFactory as _
     25from waeup.kofa.university.vocabularies import (
    2626    course_levels,
    2727    CourseSource,
    … …  
    3232    )
    3333
    34 class IFaculty(ISIRPContainer):
     34class IFaculty(IKOFAContainer):
    3535    """Representation of a university faculty.
    3636    """
    … …  
    7373IFacultyAdd['code'].order =  IFaculty['code'].order
    7474
    75 class IFacultiesContainer(ISIRPContainer):
     75class IFacultiesContainer(IKOFAContainer):
    7676    """A container for faculties.
    7777    """
    … …  
    8080
    8181        """
    82 class IDepartment(ISIRPObject):
     82class IDepartment(IKOFAObject):
    8383    """Representation of a department.
    8484    """
    … …  
    124124IDepartmentAdd['code'].order =  IDepartment['code'].order
    125125
    126 class ICoursesContainer(ISIRPContainer):
     126class ICoursesContainer(IKOFAContainer):
    127127    """A container for faculties.
    128128    """
    … …  
    133133        """
    134134
    135 class ICourse(ISIRPObject):
     135class ICourse(IKOFAObject):
    136136    """Representation of a course.
    137137    """
    … …  
    186186ICourseAdd['code'].order =  ICourse['code'].order
    187187
    188 class ICertificate(ISIRPObject):
     188class ICertificate(IKOFAObject):
    189189    """Representation of a certificate.
    190190    """
    … …  
    248248ICertificateAdd['code'].order =  ICertificate['code'].order
    249249
    250 class ICertificatesContainer(ISIRPContainer):
     250class ICertificatesContainer(IKOFAContainer):
    251251    """A container for certificates.
    252252    """
    … …  
    257257        """
    258258
    259 class ICertificateCourse(ISIRPObject):
     259class ICertificateCourse(IKOFAObject):
    260260    """A certificatecourse is referring a course and provides some own
    261261       attributes.

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_batching.py

    r7195 r7811  
    2121
    2222from zope.interface.verify import verifyClass, verifyObject
    23 from waeup.sirp.interfaces import IBatchProcessor
    24 from waeup.sirp.testing import FunctionalTestCase, FunctionalLayer
    25 from waeup.sirp.university.batching import (
     23from waeup.kofa.interfaces import IBatchProcessor
     24from waeup.kofa.testing import FunctionalTestCase, FunctionalLayer
     25from waeup.kofa.university.batching import (
    2626    FacultyProcessor, DepartmentProcessor, CourseProcessor,
    2727    CertificateProcessor, CertificateCourseProcessor)
    28 from waeup.sirp.university.certificate import Certificate, CertificateCourse
    29 from waeup.sirp.university.course import Course
    30 from waeup.sirp.university.department import Department
     28from waeup.kofa.university.certificate import Certificate, CertificateCourse
     29from waeup.kofa.university.course import Course
     30from waeup.kofa.university.department import Department
    3131
    3232

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_certificatescontainer.py

    r7333 r7811  
    2525from zope.interface.verify import verifyClass, verifyObject
    2626
    27 from waeup.sirp.app import University
    28 from waeup.sirp.interfaces import DuplicationError
    29 from waeup.sirp.testing import (
     27from waeup.kofa.app import University
     28from waeup.kofa.interfaces import DuplicationError
     29from waeup.kofa.testing import (
    3030    FunctionalLayer, doctestsuite_for_module, FunctionalTestCase)
    31 from waeup.sirp.university.certificate import Certificate
    32 from waeup.sirp.university.certificatescontainer import CertificatesContainer
    33 from waeup.sirp.university.interfaces import ICertificatesContainer
     31from waeup.kofa.university.certificate import Certificate
     32from waeup.kofa.university.certificatescontainer import CertificatesContainer
     33from waeup.kofa.university.interfaces import ICertificatesContainer
    3434
    3535
    … …  
    132132        unittest.makeSuite(CertificatesContainerTests),
    133133        doctestsuite_for_module(
    134                 'waeup.sirp.university.certificatescontainer'),
     134                'waeup.kofa.university.certificatescontainer'),
    135135        ))
    136136    return suite

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_coursescontainer.py

    r7333 r7811  
    2121import unittest
    2222from zope.interface.verify import verifyClass, verifyObject
    23 from waeup.sirp.university.interfaces import ICoursesContainer
    24 from waeup.sirp.university import CoursesContainer, Course
     23from waeup.kofa.university.interfaces import ICoursesContainer
     24from waeup.kofa.university import CoursesContainer, Course
    2525
    2626class CoursesContainerTests(unittest.TestCase):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_export.py

    r7757 r7811  
    2222from zope.component import queryUtility
    2323from zope.interface.verify import verifyObject, verifyClass
    24 from waeup.sirp.interfaces import ICSVExporter
    25 from waeup.sirp.testing import SIRPUnitTestLayer
    26 from waeup.sirp.university import (
     24from waeup.kofa.interfaces import ICSVExporter
     25from waeup.kofa.testing import KOFAUnitTestLayer
     26from waeup.kofa.university import (
    2727    FacultiesContainer, Faculty, Department, Course, Certificate,
    2828    )
    29 from waeup.sirp.university.export import (
     29from waeup.kofa.university.export import (
    3030    FacultyExporter, DepartmentExporter, CourseExporter,
    3131    CertificateExporter, CertificateCourseExporter,
    … …  
    3434class FacultyExporterTest(unittest.TestCase):
    3535
    36     layer = SIRPUnitTestLayer
     36    layer = KOFAUnitTestLayer
    3737
    3838    def setUp(self):
    … …  
    123123    # Tests for DepartmentExporter
    124124
    125     layer = SIRPUnitTestLayer
     125    layer = KOFAUnitTestLayer
    126126
    127127    def setUp(self):
    … …  
    214214    # Tests for CourseExporter
    215215
    216     layer = SIRPUnitTestLayer
     216    layer = KOFAUnitTestLayer
    217217
    218218    def setUp(self):
    … …  
    307307    # Tests for CertificateExporter
    308308
    309     layer = SIRPUnitTestLayer
     309    layer = KOFAUnitTestLayer
    310310
    311311    def setUp(self):
    … …  
    412412    # Tests for CertificateCourseExporter
    413413
    414     layer = SIRPUnitTestLayer
     414    layer = KOFAUnitTestLayer
    415415
    416416    def setUp(self):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_facultiescontainer.py

    r7333 r7811  
    2222from StringIO import StringIO
    2323from zope.interface.verify import verifyObject, verifyClass
    24 from waeup.sirp.testing import FunctionalTestCase, FunctionalLayer
    25 from waeup.sirp.university.interfaces import IFacultiesContainer
    26 from waeup.sirp.university import FacultiesContainer
    27 from waeup.sirp.university.facultiescontainer import AcademicsPlugin
     24from waeup.kofa.testing import FunctionalTestCase, FunctionalLayer
     25from waeup.kofa.university.interfaces import IFacultiesContainer
     26from waeup.kofa.university import FacultiesContainer
     27from waeup.kofa.university.facultiescontainer import AcademicsPlugin
    2828
    2929class FakeLogger(object):
    … …  
    9090        self.assertEqual(
    9191            self._logger_factory.get_messages(),
    92             'Could not create container for faculties in SIRP.\n'
     92            'Could not create container for faculties in KOFA.\n'
    9393            )
    9494

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_faculty.py

    r7681 r7811  
    2222import unittest
    2323from zope.interface.verify import verifyObject, verifyClass
    24 from waeup.sirp.university import Faculty, Department
    25 from waeup.sirp.university.interfaces import IFaculty, IDepartment
     24from waeup.kofa.university import Faculty, Department
     25from waeup.kofa.university.interfaces import IFaculty, IDepartment
    2626
    2727class FacultyAndDepartmentTests(unittest.TestCase):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/tests/test_university.py

    r7333 r7811  
    1919# Test the public API part of the university subpackage
    2020import unittest
    21 from waeup.sirp.university import *
    22 from waeup.sirp.testing import get_doctest_suite
     21from waeup.kofa.university import *
     22from waeup.kofa.testing import get_doctest_suite
    2323
    2424class UniversitySubpackageTests(unittest.TestCase):

  • main/waeup.kofa/trunk/src/waeup/kofa/university/vocabularies.py

    r7688 r7811  
    2222from zope.catalog.interfaces import ICatalog
    2323from zope.component import getUtility
    24 from waeup.sirp.interfaces import SimpleSIRPVocabulary, ISIRPUtils
    25 from waeup.sirp.interfaces import MessageFactory as _
     24from waeup.kofa.interfaces import SimpleKOFAVocabulary, IKOFAUtils
     25from waeup.kofa.interfaces import MessageFactory as _
    2626
    27 course_levels = SimpleSIRPVocabulary(
     27course_levels = SimpleKOFAVocabulary(
    2828    (_('Pre-Studies'),10),
    2929    (_('100 (Year 1)'),100),
    … …  
    4141    """
    4242    def getValues(self, context):
    43         semesters_dict = getUtility(ISIRPUtils).getSemesterDict()
     43        semesters_dict = getUtility(IKOFAUtils).getSemesterDict()
    4444        return semesters_dict.keys()
    4545
    … …  
    4848
    4949    def getTitle(self, context, value):
    50         semesters_dict = getUtility(ISIRPUtils).getSemesterDict()
     50        semesters_dict = getUtility(IKOFAUtils).getSemesterDict()
    5151        return semesters_dict[value]
    5252
    … …  
    5656    """
    5757    def getValues(self, context):
    58         insttypes_dict = getUtility(ISIRPUtils).getInstTypeDict()
     58        insttypes_dict = getUtility(IKOFAUtils).getInstTypeDict()
    5959        return sorted(insttypes_dict.keys())
    6060
    … …  
    6363
    6464    def getTitle(self, context, value):
    65         insttypes_dict = getUtility(ISIRPUtils).getInstTypeDict()
     65        insttypes_dict = getUtility(IKOFAUtils).getInstTypeDict()
    6666        return insttypes_dict[value]
    6767
    … …  
    7171    """
    7272    def getValues(self, context):
    73         appcats_dict = getUtility(ISIRPUtils).getAppCatDict()
     73        appcats_dict = getUtility(IKOFAUtils).getAppCatDict()
    7474        return sorted(appcats_dict.keys())
    7575
    … …  
    7878
    7979    def getTitle(self, context, value):
    80         appcats_dict = getUtility(ISIRPUtils).getAppCatDict()
     80        appcats_dict = getUtility(IKOFAUtils).getAppCatDict()
    8181        return appcats_dict[value]
    8282
    … …  
    8686    """
    8787    def getValues(self, context):
    88         studymodes_dict = getUtility(ISIRPUtils).getStudyModesDict()
     88        studymodes_dict = getUtility(IKOFAUtils).getStudyModesDict()
    8989        return sorted(studymodes_dict.keys())
    9090
    … …  
    9393
    9494    def getTitle(self, context, value):
    95         studymodes_dict = getUtility(ISIRPUtils).getStudyModesDict()
     95        studymodes_dict = getUtility(IKOFAUtils).getStudyModesDict()
    9696        return studymodes_dict[value]
    9797
Note: See TracChangeset for help on using the changeset viewer.