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/accesscodes
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r7137 r7811  
    44
    55Main content components are defined in
    6 :mod:`waeup.sirp.accesscodes.accesscode`. This subpackage also
     6:mod:`waeup.kofa.accesscodes.accesscode`. This subpackage also
    77provides a _catalog_ to lookup any access code quickly and a
    88_workflow_ to guarantee consistent states and transitions when dealing
    … …  
    1111We also provide UI components to generate, archive, import and
    1212reimport access codes or batches thereof. These parts are defined in
    13 :mod:`waeup.sirp.accesscodes.browser`.
     13:mod:`waeup.kofa.accesscodes.browser`.
    1414
    1515The interfaces of this subpackage are defined in
    16 :mod:`waeup.sirp.accesscodes.interfaces`.
     16:mod:`waeup.kofa.accesscodes.interfaces`.
    1717"""
    18 from waeup.sirp.accesscodes.accesscode import (
     18from waeup.kofa.accesscodes.accesscode import (
    1919    get_access_code, invalidate_accesscode, disable_accesscode,
    2020    reenable_accesscode, create_accesscode,

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/accesscode.py

    r7747 r7811  
    3131from hurry.workflow.interfaces import IWorkflowInfo, IWorkflowState
    3232from random import SystemRandom as random
    33 from waeup.sirp.interfaces import ISIRPPluggable, IObjectHistory
    34 from waeup.sirp.utils.logger import Logger
    35 from waeup.sirp.accesscodes.interfaces import (
     33from waeup.kofa.interfaces import IKOFAPluggable, IObjectHistory
     34from waeup.kofa.utils.logger import Logger
     35from waeup.kofa.accesscodes.interfaces import (
    3636    IAccessCode, IAccessCodeBatch, IAccessCodeBatchContainer
    3737    )
    38 from waeup.sirp.accesscodes.workflow import DISABLED, USED, ac_states_dict
     38from waeup.kofa.accesscodes.workflow import DISABLED, USED, ac_states_dict
    3939
    4040class AccessCode(grok.Model):
    … …  
    4242
    4343    Implements
    44     :class:`waeup.sirp.accesscodes.interfaces.IAccessCode`. :class:`AccessCode`
     44    :class:`waeup.kofa.accesscodes.interfaces.IAccessCode`. :class:`AccessCode`
    4545    instances are normally part of an :class:`AccessCodeBatch` so
    4646    their representation (or code) is built with the containing batch
    … …  
    6868    The state of an access code is something like 'used', 'disabled',
    6969    etc. and determined by the workflow defined in
    70     :mod:`waeup.sirp.accesscodes.workflow`. This also means that
     70    :mod:`waeup.kofa.accesscodes.workflow`. This also means that
    7171    instead of setting the status of an access code directly (you
    7272    can't do that easily, and yes, that's intentionally), you have to
    7373    trigger a transition (that might fail, if the transition is not
    7474    allowed in terms of logic or permissions). See
    75     :mod:`waeup.sirp.accesscodes.workflow` for details.
     75    :mod:`waeup.kofa.accesscodes.workflow` for details.
    7676
    7777    """
    … …  
    139139    @property
    140140    def history(self):
    141         """A :class:`waeup.sirp.objecthistory.ObjectHistory` instance.
     141        """A :class:`waeup.kofa.objecthistory.ObjectHistory` instance.
    142142        """
    143143        history = IObjectHistory(self)
    … …  
    285285        If the path does not exist yet, it is created. The path is
    286286        normally ``accesscodes/imports`` below the datacenter storage
    287         path (see :data:`waeup.sirp.accesscodes.Datacenter.storage`).
     287        path (see :data:`waeup.kofa.accesscodes.Datacenter.storage`).
    288288        """
    289289        site = grok.getSite()
    … …  
    403403        return
    404404
    405     logger_name = 'waeup.sirp.${sitename}.accesscodes'
     405    logger_name = 'waeup.kofa.${sitename}.accesscodes'
    406406    logger_filename = 'accesscodes.log'
    407407
    … …  
    415415class AccessCodePlugin(grok.GlobalUtility):
    416416    grok.name('accesscodes')
    417     grok.implements(ISIRPPluggable)
     417    grok.implements(IKOFAPluggable)
    418418
    419419    def setup(self, site, name, logger):
    … …  
    481481    `arg` tells what kind of transition to trigger. This will be a
    482482    transition id like ``'use'`` or ``'init'``, or some transition
    483     target like :data:`waeup.sirp.accesscodes.workflow.INITIALIZED`.
     483    target like :data:`waeup.kofa.accesscodes.workflow.INITIALIZED`.
    484484
    485485    If `toward` is ``False`` (the default) you have to pass a

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/accesscode.txt

    r7321 r7811  
    1 :mod:`waeup.sirp.accesscodes.accesscode` -- access codes (aka PINs)
     1:mod:`waeup.kofa.accesscodes.accesscode` -- access codes (aka PINs)
    22*******************************************************************
    33
    4 .. module:: waeup.sirp.accesscodes.accesscode
     4.. module:: waeup.kofa.accesscodes.accesscode
    55
    66Components that represent access codes and related.
    77
    88.. :NOdoctest:
    9 .. :NOlayer: waeup.sirp.testing.SIRPUnitTestLayer
     9.. :NOlayer: waeup.kofa.testing.KOFAUnitTestLayer
    1010
    1111About access-codes
    … …  
    2828unique random number of 10 digits.
    2929
    30 For the generation of the random number :mod:`waeup.sirp` requires a
     30For the generation of the random number :mod:`waeup.kofa` requires a
    3131'urandom' entropy provider which is available with most standard
    3232Unix/Linux systems. This makes the generated numbers relatively
    … …  
    5757
    5858   The class implements
    59    :mod:`waeup.sirp.accesscodes.interfaces.IAccessCode`:
    60 
    61     >>> from waeup.sirp.accesscodes.interfaces import IAccessCode
    62     >>> from waeup.sirp.accesscodes.accesscodes import AccessCode
     59   :mod:`waeup.kofa.accesscodes.interfaces.IAccessCode`:
     60
     61    >>> from waeup.kofa.accesscodes.interfaces import IAccessCode
     62    >>> from waeup.kofa.accesscodes.accesscodes import AccessCode
    6363    >>> from zope.interface.verify import verifyClass
    6464    >>> verifyClass(IAccessCode, AccessCode)
    … …  
    150150
    151151   A persistent :class:`grok.Model`. It implements
    152    :class:`waeup.sirp.accesscodes.interfaces.IAccessCodeBatch`.
     152   :class:`waeup.kofa.accesscodes.interfaces.IAccessCodeBatch`.
    153153
    154154   When creating a batch, all entries (access-codes) are generated as
    … …  
    306306:class:`AccessCodeBatch` implements :class:`IAccessCodeBatch`:
    307307
    308     >>> from waeup.sirp.accesscodes.interfaces import IAccessCodeBatch
    309     >>> from waeup.sirp.accesscodes.accesscodes import AccessCodeBatch
     308    >>> from waeup.kofa.accesscodes.interfaces import IAccessCodeBatch
     309    >>> from waeup.kofa.accesscodes.accesscodes import AccessCodeBatch
    310310    >>> from zope.interface.verify import verifyClass
    311311    >>> verifyClass(IAccessCodeBatch, AccessCodeBatch)
    … …  
    317317
    318318    >>> import datetime
    319     >>> from waeup.sirp.accesscodes.accesscodes import AccessCodeBatch
     319    >>> from waeup.kofa.accesscodes.accesscodes import AccessCodeBatch
    320320    >>> batch = AccessCodeBatch(
    321321    ...   datetime.datetime(2009, 12, 23), 'Fred','APP', 12.12, 3, num=10)
    … …  
    331331
    332332    >>> [x for x in batch.entries()]
    333     [<waeup.sirp...AccessCode object at 0x...>, ...]
     333    [<waeup.kofa...AccessCode object at 0x...>, ...]
    334334
    335335Getting a single entry from the batch:
    … …  
    338338    >>> ac = batch.getAccessCode(ac_id)
    339339    >>> ac
    340     <waeup.sirp...AccessCode object at 0x...>
     340    <waeup.kofa...AccessCode object at 0x...>
    341341
    342342    >>> ac is list(batch.entries())[0]
    … …  
    374374#
    375375#    >>> batch.getAccessCodeForStudentId('some_user_id')
    376 #    <waeup.sirp...AccessCode object at 0x...>
     376#    <waeup.kofa...AccessCode object at 0x...>
    377377#
    378378#Non-existent values will cause a :exc:`KeyError`:
    … …  
    440440    >>> result = batch.search(0, 'serial')
    441441    >>> result
    442     [<waeup.sirp...AccessCode object at 0x...>]
     442    [<waeup.kofa...AccessCode object at 0x...>]
    443443
    444444    >>> result[0].batch_serial
    … …  
    545545Creating a batch container:
    546546
    547     >>> from waeup.sirp.accesscodes.accesscodes import (
     547    >>> from waeup.kofa.accesscodes.accesscodes import (
    548548    ...   AccessCodeBatchContainer)
    549549    >>> container = AccessCodeBatchContainer()
    … …  
    561561
    562562    >>> container.search(1, 'serial')
    563     [<waeup.sirp...AccessCode object at 0x...>,
    564      <waeup.sirp...AccessCode object at 0x...>]
     563    [<waeup.kofa...AccessCode object at 0x...>,
     564     <waeup.kofa...AccessCode object at 0x...>]
    565565
    566566    >>> container.search('not-a-number', 'serial')
    … …  
    569569    >>> result = container.search('1', 'serial')
    570570    >>> result
    571     [<waeup.sirp...AccessCode object at 0x...>,
    572      <waeup.sirp...AccessCode object at 0x...>]
     571    [<waeup.kofa...AccessCode object at 0x...>,
     572     <waeup.kofa...AccessCode object at 0x...>]
    573573
    574574Searching for ACs:
    … …  
    576576    >>> ac = result[0]
    577577    >>> container.search(ac.representation, 'pin')
    578     [<waeup.sirp...AccessCode object at 0x...>]
     578    [<waeup.kofa...AccessCode object at 0x...>]
    579579
    580580Searching for student IDs:
    … …  
    583583#    ...   ac.representation, 'some_user')
    584584#    >>> container.search('some_user', 'stud_id')
    585 #    [<waeup.sirp...AccessCode object at 0x...>]
     585#    [<waeup.kofa...AccessCode object at 0x...>]
    586586
    587587
    … …  
    591591.. class:: AccessCodePlugin
    592592
    593   A `waeup.sirp` plugin that updates existing SIRP university
     593  A `waeup.kofa` plugin that updates existing KOFA university
    594594  instances so that they provide support for access-codes.
    595595
    596   .. attribute:: grok.implements(ISIRPPluggable)
     596  .. attribute:: grok.implements(IKOFAPluggable)
    597597  .. attribute:: grok.name('accesscodes')
    598598
    … …  
    608608
    609609  The AccessCodePlugin is available as a global named utility for the
    610   ISIRPPluggable interface named ``accesscodes``.
     610  IKOFAPluggable interface named ``accesscodes``.
    611611
    612612  It is looked up by a university instance when created, so that this
    … …  
    615615
    616616    >>> from zope.component import getUtility
    617     >>> from waeup.sirp.interfaces import ISIRPPluggable
    618     >>> plugin = getUtility(ISIRPPluggable, name='accesscodes')
     617    >>> from waeup.kofa.interfaces import IKOFAPluggable
     618    >>> plugin = getUtility(IKOFAPluggable, name='accesscodes')
    619619    >>> plugin
    620     <waeup.sirp.accesscodes.accesscodes.AccessCodePlugin object at 0x...>
     620    <waeup.kofa.accesscodes.accesscodes.AccessCodePlugin object at 0x...>
    621621
    622622  It provides a `setup()` and an `update()` method. Both have to be

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

    r6408 r7811  
    1 :mod:`waeup.sirp.accesscodes` -- Access Codes
     1:mod:`waeup.kofa.accesscodes` -- Access Codes
    22*********************************************
    33
    4 .. module:: waeup.sirp.accesscodes
     4.. module:: waeup.kofa.accesscodes
    55
    66Components that represent access codes and related components.
    … …  
    99==========
    1010
    11 The :mod:`waeup.sirp.accesscodes` module provides the following submodules:
     11The :mod:`waeup.kofa.accesscodes` module provides the following submodules:
    1212
    1313.. toctree::

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/browser.py

    r7747 r7811  
    2121from datetime import datetime
    2222from hurry.workflow.interfaces import InvalidTransitionError
    23 from waeup.sirp.browser.resources import datatable
    24 from waeup.sirp.browser import SIRPPage, SIRPAddFormPage, NullValidator
    25 from waeup.sirp.browser.breadcrumbs import Breadcrumb
    26 from waeup.sirp.browser.viewlets import (
     23from waeup.kofa.browser.resources import datatable
     24from waeup.kofa.browser import KOFAPage, KOFAAddFormPage, NullValidator
     25from waeup.kofa.browser.breadcrumbs import Breadcrumb
     26from waeup.kofa.browser.viewlets import (
    2727    AdminTask, AddActionButton, SearchActionButton, BatchOpButton, ManageLink)
    28 from waeup.sirp.interfaces import ISIRPObject
    29 from waeup.sirp.interfaces import MessageFactory as _
    30 from waeup.sirp.accesscodes.interfaces import (
     28from waeup.kofa.interfaces import IKOFAObject
     29from waeup.kofa.interfaces import MessageFactory as _
     30from waeup.kofa.accesscodes.interfaces import (
    3131    IAccessCodeBatchContainer, IAccessCodeBatch,
    3232    )
    33 from waeup.sirp.accesscodes.catalog import search
    34 from waeup.sirp.browser.layout import action
    35 
    36 grok.context(ISIRPObject)
    37 
    38 class BatchContainerPage(SIRPPage):
     33from waeup.kofa.accesscodes.catalog import search
     34from waeup.kofa.browser.layout import action
     35
     36grok.context(IKOFAObject)
     37
     38class BatchContainerPage(KOFAPage):
    3939    grok.name('index')
    4040    grok.context(IAccessCodeBatchContainer)
    … …  
    5555        if isinstance(batches, basestring):
    5656            batches = [batches]
    57         ob_class = self.__implemented__.__name__.replace('waeup.sirp.','')
     57        ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
    5858        for name in batches:
    5959            batch = self.context[name]
    … …  
    7070            self.context.logger_info(ob_class, message)
    7171
    72 class AddBatchPage(SIRPAddFormPage):
     72class AddBatchPage(KOFAAddFormPage):
    7373    grok.name('add')
    7474    grok.context(IAccessCodeBatchContainer)
    … …  
    9292            mapping = {'a':data['entry_num']}))
    9393        self.flash(_('Data written to ${a}', mapping = {'a':csv_file}))
    94         ob_class = self.__implemented__.__name__.replace('waeup.sirp.','')
     94        ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
    9595        message = 'created: %s (%d, %f)' % (
    9696            csv_file, data['entry_num'], data['cost'])
    … …  
    103103        self.redirect(self.url(self.context))
    104104
    105 class ReimportBatchPage(SIRPPage):
     105class ReimportBatchPage(KOFAPage):
    106106    """Screen for reimporting AC batches.
    107107    """
    … …  
    139139            self.flash(_('Successfully reimported: ${a}',
    140140                mapping = {'a':filename}))
    141             ob_class = self.__implemented__.__name__.replace('waeup.sirp.','')
     141            ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
    142142            message = 'reimported: %s' % filename
    143143            self.context.logger_info(ob_class, message)
    144144        self.redirect(self.url(self.context))
    145145
    146 class BatchContainerSearchPage(SIRPPage):
     146class BatchContainerSearchPage(KOFAPage):
    147147    grok.name('search')
    148148    grok.context(IAccessCodeBatchContainer)
    … …  
    174174        if isinstance(entries, basestring):
    175175            entries = [entries]
    176         ob_class = self.__implemented__.__name__.replace('waeup.sirp.','')
     176        ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
    177177        for entry in entries:
    178178            if 'disable' in form:

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/browser.txt

    r7748 r7811  
    1 :mod:`waeup.sirp.accesscodes.browser` -- UI components for access-codes
     1:mod:`waeup.kofa.accesscodes.browser` -- UI components for access-codes
    22***********************************************************************
    33
    4 .. module:: waeup.sirp.accesscodes.browser
    5 
    6 Here we visit the access-code related parts of a SIRP site using
     4.. module:: waeup.kofa.accesscodes.browser
     5
     6Here we visit the access-code related parts of a KOFA site using
    77a virtual browser.
    88
    … …  
    2020    >>> root = getRootFolder()
    2121
    22     >>> from waeup.sirp.app import University
     22    >>> from waeup.kofa.app import University
    2323    >>> u = University()
    2424    >>> root['myuniversity'] = u

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/browser_templates/batchcontainer.pt

    r7719 r7811  
    1 <form i18n:domain="waeup.sirp" method="POST">
     1<form i18n:domain="waeup.kofa" method="POST">
    22  <p i18n:translate="">
    33    The following batches are available:

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/browser_templates/reimportbatchpage.pt

    r7719 r7811  
    1 <p i18n:domain="waeup.sirp">
     1<p i18n:domain="waeup.kofa">
    22Please select the files to reimport. Please note, that batches with
    33same name have to be deleted before.
    44</p>
    5 <form method="POST" i18n:domain="waeup.sirp">
     5<form method="POST" i18n:domain="waeup.kofa">
    66  <table>
    77    <thead>

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/browser_templates/searchpage.pt

    r7754 r7811  
    1 <form method="POST" i18n:domain="waeup.sirp">
     1<form method="POST" i18n:domain="waeup.kofa">
    22<br />
    33  <input type="submit" class="btn primary" name="search"

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

    r7754 r7811  
    2323from hurry.query.query import Query
    2424from zope.index.text.parsetree import ParseError
    25 from waeup.sirp.interfaces import IUniversity, IQueryResultItem
    26 from waeup.sirp.accesscodes.interfaces import IAccessCode
     25from waeup.kofa.interfaces import IUniversity, IQueryResultItem
     26from waeup.kofa.accesscodes.interfaces import IAccessCode
    2727
    2828class AccessCodeIndexes(grok.Indexes):

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

    r7745 r7811  
    2020from zope import schema
    2121from zope.interface import Interface
    22 from waeup.sirp.interfaces import ISIRPObject
    23 from waeup.sirp.interfaces import MessageFactory as _
     22from waeup.kofa.interfaces import IKOFAObject
     23from waeup.kofa.interfaces import MessageFactory as _
    2424
    25 class IAccessCode(ISIRPObject):
     25class IAccessCode(IKOFAObject):
    2626    """An access code.
    2727    """
    … …  
    9292        )
    9393
    94 class IAccessCodeBatchContainer(ISIRPObject):
     94class IAccessCodeBatchContainer(IKOFAObject):
    9595    """A container for access code batches.
    9696    """

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/tests/test_accesscode.py

    r7719 r7811  
    2828from zope.interface.verify import verifyObject, verifyClass
    2929from zope.testing import renormalizing
    30 from waeup.sirp.app import University
    31 from waeup.sirp.interfaces import IObjectHistory, ISIRPPluggable
    32 from waeup.sirp.testing import (
     30from waeup.kofa.app import University
     31from waeup.kofa.interfaces import IObjectHistory, IKOFAPluggable
     32from waeup.kofa.testing import (
    3333    FunctionalLayer, FunctionalTestCase, setUp, tearDown, getRootFolder)
    34 from waeup.sirp.accesscodes.accesscode import (
     34from waeup.kofa.accesscodes.accesscode import (
    3535    AccessCodeBatch, get_access_code, invalidate_accesscode, AccessCode,
    3636    disable_accesscode, reenable_accesscode, fire_transition,
    3737    AccessCodeBatchContainer, AccessCodePlugin)
    38 from waeup.sirp.accesscodes.interfaces import (
     38from waeup.kofa.accesscodes.interfaces import (
    3939    IAccessCode, IAccessCodeBatch,  IAccessCodeBatchContainer,)
    40 from waeup.sirp.accesscodes.workflow import INITIALIZED, USED, DISABLED
     40from waeup.kofa.accesscodes.workflow import INITIALIZED, USED, DISABLED
    4141
    4242
    … …  
    412412    def test_iface(self):
    413413        plugin = AccessCodePlugin()
    414         assert verifyObject(ISIRPPluggable, plugin)
    415         assert verifyClass(ISIRPPluggable, AccessCodePlugin)
     414        assert verifyObject(IKOFAPluggable, plugin)
     415        assert verifyClass(IKOFAPluggable, AccessCodePlugin)
    416416
    417417    def test_update_w_ac_container(self):

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/tests/test_catalog.py

    r7195 r7811  
    2222from zope.component.hooks import setSite
    2323from zope.interface.verify import verifyClass, verifyObject
    24 from waeup.sirp.app import University
    25 from waeup.sirp.interfaces import IQueryResultItem
    26 from waeup.sirp.testing import FunctionalLayer, FunctionalTestCase
    27 from waeup.sirp.accesscodes.accesscode import (
     24from waeup.kofa.app import University
     25from waeup.kofa.interfaces import IQueryResultItem
     26from waeup.kofa.testing import FunctionalLayer, FunctionalTestCase
     27from waeup.kofa.accesscodes.accesscode import (
    2828    AccessCodeBatch, invalidate_accesscode, disable_accesscode)
    29 from waeup.sirp.accesscodes.workflow import INITIALIZED, USED, DISABLED
    30 from waeup.sirp.accesscodes.catalog import AccessCodeQueryResultItem, search
     29from waeup.kofa.accesscodes.workflow import INITIALIZED, USED, DISABLED
     30from waeup.kofa.accesscodes.catalog import AccessCodeQueryResultItem, search
    3131
    3232class CatalogTestSetup(FunctionalTestCase):

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/tests/test_workflow.py

    r7195 r7811  
    1818import shutil
    1919import tempfile
    20 from waeup.sirp.testing import FunctionalLayer, FunctionalTestCase
    21 from waeup.sirp.accesscodes.workflow import (
     20from waeup.kofa.testing import FunctionalLayer, FunctionalTestCase
     21from waeup.kofa.accesscodes.workflow import (
    2222    invalidate_action, disable_used_action, disable_unused_action,
    2323    reenable_action,

  • main/waeup.kofa/trunk/src/waeup/kofa/accesscodes/workflow.py

    r7723 r7811  
    2525from hurry.workflow.workflow import Transition, WorkflowState, NullCondition
    2626from hurry.workflow.interfaces import IWorkflowState, IWorkflowTransitionEvent
    27 from waeup.sirp.accesscodes.interfaces import IAccessCode
    28 from waeup.sirp.interfaces import IObjectHistory, ISIRPWorkflowInfo
    29 from waeup.sirp.interfaces import MessageFactory as _
    30 from waeup.sirp.workflow import SIRPWorkflow, SIRPWorkflowInfo
     27from waeup.kofa.accesscodes.interfaces import IAccessCode
     28from waeup.kofa.interfaces import IObjectHistory, IKOFAWorkflowInfo
     29from waeup.kofa.interfaces import MessageFactory as _
     30from waeup.kofa.workflow import KOFAWorkflow, KOFAWorkflowInfo
    3131
    3232INITIALIZED = 'initialized'
    … …  
    113113    )
    114114
    115 accesscode_workflow = SIRPWorkflow(ACCESSCODE_TRANSITIONS)
     115accesscode_workflow = KOFAWorkflow(ACCESSCODE_TRANSITIONS)
    116116
    117117class AccessCodeWorkflowState(WorkflowState, grok.Adapter):
    … …  
    122122    state_id = 'wf.accesscode.id'
    123123
    124 class AccessCodeWorkflowInfo(SIRPWorkflowInfo, grok.Adapter):
     124class AccessCodeWorkflowInfo(KOFAWorkflowInfo, grok.Adapter):
    125125    grok.context(IAccessCode)
    126     grok.provides(ISIRPWorkflowInfo)
     126    grok.provides(IKOFAWorkflowInfo)
    127127
    128128    def __init__(self, context):
Note: See TracChangeset for help on using the changeset viewer.