Produits Entr'ouvert » w.c.s.

def test_workflows_global_actions(pub):

    create_superuser(pub)

    create_role()

    Workflow.wipe()

    workflow = Workflow(name='foo')

    workflow.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('add global action')

    resp = resp.forms[0].submit('cancel')

    assert not Workflow.get(workflow.id).global_actions

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('add global action')

    resp.forms[0]['name'] = 'Global Action'

    resp = resp.forms[0].submit('submit')

    assert Workflow.get(workflow.id).global_actions[0].name == 'Global Action'

    # test rename

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('Global Action')

    resp = resp.click('Change Action Name')

    resp.forms[0]['name'] = 'Renamed Action'

    resp = resp.forms[0].submit('submit')

    assert Workflow.get(workflow.id).global_actions[0].name == 'Renamed Action'

    # test removal

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('Renamed Action')

    resp = resp.click('Delete')

    resp = resp.forms[0].submit('delete')

    assert not Workflow.get(workflow.id).global_actions

def test_workflows_global_actions_edit(pub):

    create_superuser(pub)

    create_role()

    Workflow.wipe()

    workflow = Workflow(name='foo')

    workflow.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('add global action')

    resp.forms[0]['name'] = 'Global Action'

    resp = resp.forms[0].submit('submit')

    resp = resp.follow()

    resp = resp.click('Global Action')

    # test adding all actions

    for action in [x[0] for x in resp.forms[0]['type'].options]:

        resp.forms[0]['type'] = action

        resp = resp.forms[0].submit()

        resp = resp.follow()

    # test visiting

    action_id = Workflow.get(workflow.id).global_actions[0].id

    for item in Workflow.get(workflow.id).global_actions[0].items:

        resp = app.get('/backoffice/workflows/%s/global-actions/%s/items/%s/' % (

            workflow.id, action_id, item.id))

    # test modifying a trigger

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('Global Action')

    assert len(Workflow.get(workflow.id).global_actions[0].triggers) == 1

    resp = resp.click(href='triggers/1/', index=0)

    assert resp.form['roles$element0'].value == 'None'

    resp.form['roles$element0'].value = '_receiver'

    resp = resp.form.submit('submit')

    assert Workflow.get(workflow.id).global_actions[0].triggers[0].roles == ['_receiver']

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('Global Action')

    resp = resp.click(href='triggers/1/', index=0)

    assert resp.form['roles$element0'].value == '_receiver'

    resp.form['roles$element1'].value = '_submitter'

    resp = resp.form.submit('submit')

    assert Workflow.get(workflow.id).global_actions[0].triggers[0].roles == [

            '_receiver', '_submitter']

    resp = app.get('/backoffice/workflows/%s/' % workflow.id)

    resp = resp.click('Global Action')

    resp = resp.click(href='triggers/1/', index=0)

    resp.form['roles$element1'].value = 'None'

    resp = resp.form.submit('submit')

    assert Workflow.get(workflow.id).global_actions[0].triggers[0].roles == ['_receiver']

from wcs.wf.jump import JumpWorkflowStatusItem

from wcs.wf.register_comment import RegisterCommenterWorkflowStatusItem

def test_backoffice_handling_global_action(pub):

    create_user(pub)

    create_environment(pub)

    formdef = FormDef()

    formdef.name = 'test global action'

    formdef.fields = []

    workflow = Workflow.get_default_workflow()

    workflow.id = '2'

    action = workflow.add_global_action('FOOBAR')

    register_comment = action.append_item('register-comment')

    register_comment.comment = 'HELLO WORLD GLOBAL ACTION'

    jump = action.append_item('jump')

    jump.status = 'finished'

    trigger = action.triggers[0]

    trigger.roles = [x.id for x in Role.select() if x.name == 'foobar']

    workflow.store()

    formdef.workflow_id = workflow.id

    formdef.workflow_roles = {'_receiver': 1}

    formdef.store()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/management/%s/%s/' % (formdef.url_name, formdata.id))

    assert 'button-action-1' in resp.form.fields

    resp = resp.form.submit('button-action-1')

    resp = app.get('/backoffice/management/%s/%s/' % (formdef.url_name, formdata.id))

    assert 'HELLO WORLD GLOBAL ACTION' in resp.body

    assert formdef.data_class().get(formdata.id).status == 'wf-finished'

from wcs.wf.register_comment import RegisterCommenterWorkflowStatusItem

def test_global_actions():

    role = Role()

    role.id = '5'

    role.name = 'Test Role'

    role.store()

    wf = Workflow(name='global actions')

    ac1 = wf.add_global_action('Action', 'ac1')

    ac1.backoffice_info_text = '<p>Foo</p>'

    add_to_journal = RegisterCommenterWorkflowStatusItem()

    add_to_journal.id = '_add_to_journal'

    add_to_journal.comment = 'HELLO WORLD'

    ac1.items.append(add_to_journal)

    add_to_journal.parent = ac1

    trigger = ac1.triggers[0]

    assert trigger.key == 'manual'

    trigger.roles = [role.id]

    wf2 = assert_import_export_works(wf)

    assert wf2.global_actions[0].triggers[0].roles == [role.id]

    wf2 = assert_import_export_works(wf, True)

    def __init__(self, workflow, parent, component, html_top):

            self.item = [x for x in parent.items if x.id == component][0]

        self.parent = parent

            r += htmltext('<h2>%s - %s</h2>') % (self.workflow.name, self.parent.name)

            del self.parent.items[self.parent.items.index(self.item)]

        t = self.item.q_admin_lookup(self.workflow, self.parent, component,

class GlobalActionTriggerPage(Directory):

    _q_exports = ['', 'delete']

    def __init__(self, workflow, action, component, html_top):

        try:

            self.trigger = [x for x in action.triggers if x.id == component][0]

        except (IndexError, ValueError):

            raise errors.TraversalError()

        self.workflow = workflow

        self.action = action

        self.status = action

        self.html_top = html_top

        get_response().breadcrumb.append(('triggers/%s/' % component, _('Trigger')))

    def _q_index(self):

        form = self.trigger.form(self.workflow)

        form.add_submit('submit', _('Save'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('..')

        if form.get_submit() == 'submit' and not form.has_errors():

            self.trigger.submit(form)

            if not form.has_errors():

                self.workflow.store()

                return redirect('../../')

        self.html_top('%s - %s' % (_('Workflow'), self.workflow.name))

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s - %s</h2>') % (self.workflow.name, self.action.name)

        r += form.render()

        return r.getvalue()

    def delete(self):

        form = Form(enctype='multipart/form-data')

        form.widgets.append(HtmlWidget('<p>%s</p>' % _('You are about to remove a trigger.')))

        form.add_submit('delete', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('../../')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            self.html_top(title=_('Delete Trigger'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Deleting Trigger')

            r += form.render()

            return r.getvalue()

        else:

            del self.action.triggers[self.action.triggers.index(self.trigger)]

            self.workflow.store()

            return redirect('../../')

class ToChildDirectory(Directory):

    klass = None

        return self.klass(self.workflow, self.status, component, self.html_top)

class WorkflowItemsDir(ToChildDirectory):

    klass = WorkflowItemPage

class GlobalActionTriggersDir(ToChildDirectory):

    klass = GlobalActionTriggerPage

class GlobalActionItemsDir(ToChildDirectory):

    klass = WorkflowItemPage

    def is_item_available(self, item):

        return item.is_available()

        available_items = [x for x in item_classes if self.is_item_available(x)]

class GlobalActionPage(WorkflowStatusPage):

    _q_exports = ['', 'new', 'delete', 'newitem', ('items', 'items_dir'),

                  'edit', ('triggers', 'triggers_dir'),

                  ('backoffice-info-text', 'backoffice_info_text'),]

    def __init__(self, workflow, action_id, html_top):

        self.html_top = html_top

        self.workflow = workflow

        try:

            self.action = [x for x in self.workflow.global_actions if x.id == action_id][0]

        except IndexError:

            raise errors.TraversalError()

        self.status = self.action

        self.items_dir = GlobalActionItemsDir(workflow, self.action, html_top)

        self.triggers_dir = GlobalActionTriggersDir(workflow, self.action, html_top)

    def _q_traverse(self, path):

        get_response().breadcrumb.append(

                ('global-actions/%s/' % self.action.id, _('Global Action: %s') % self.action.name))

        return Directory._q_traverse(self, path)

    def is_item_available(self, item):

        return item.is_available() and item.ok_in_global_action

    def _q_index(self):

        self.html_top('%s - %s' % (_('Workflow'), self.workflow.name))

        r = TemplateIO(html=True)

        get_response().add_javascript(['jquery.js', 'jquery-ui.js', 'biglist.js',

            'ckeditor/ckeditor.js', 'qommon.wysiwyg.js', 'ckeditor/adapters/jquery.js'])

        r += htmltext('<h2>%s - ') % _('Workflow')

        r += htmltext('%s - %s</h2>') % (self.workflow.name, self.action.name)

        r += get_session().display_message()

        r += htmltext('<div class="bo-block">')

        r += htmltext('<h2>%s</h2>') % _('Actions')

        if not self.action.items:

            r += htmltext('<p>%s</p>') % _('There are not yet any items in this action.')

        else:

            if str(self.workflow.id).startswith('_'):

                r += htmltext('<ul id="items-list" class="biglist">')

            else:

                r += htmltext('<p>')

                r += _('Use drag and drop to reorder items.')

                r += htmltext('</p>')

                r += htmltext('<ul id="items-list" class="biglist sortable">')

            for i, item in enumerate(self.action.items):

                r += htmltext('<li class="biglistitem" id="itemId_%s">') % item.id

                if str(self.workflow.id).startswith('_'):

                    r += item.render_as_line()

                else:

                    if hasattr(item, 'fill_admin_form'):

                        r += htmltext('<a href="items/%s/">%s</a>') % (item.id, item.render_as_line())

                    else:

                        r += item.render_as_line()

                    r += htmltext('<p class="commands">')

                    if hasattr(item, 'fill_admin_form'):

                        r += command_icon('items/%s/' % item.id, 'edit')

                    r += command_icon('items/%s/delete' % item.id, 'remove', popup = True)

                    r += htmltext('</p>')

                r += htmltext('</li>')

            r += htmltext('</ul>')

        r += htmltext('</div>') # bo-block

        r += htmltext('<div class="bo-block">')

        r += htmltext('<h2>%s</h2>') % _('Triggers')

        r += htmltext('<ul id="items-list" class="biglist sortable">')

        for trigger in self.action.triggers:

            r += htmltext('<li>')

            r += htmltext('<a rel="popup" href="triggers/%s/">%s</a>') % (

                    trigger.id, trigger.render_as_line())

            r += htmltext('<p class="commands">')

            r += command_icon('triggers/%s/' % trigger.id, 'edit', popup=True)

            r += htmltext('</li>')

        r+= htmltext('</ul>')

        r += htmltext('</div>') # bo-block

        r += htmltext('<p><a href="../../">%s</a></p>') % _('Back to workflow main page')

        get_response().filter['sidebar'] = self.get_sidebar()

        return r.getvalue()

    def delete(self):

        form = Form(enctype='multipart/form-data')

        form.widgets.append(HtmlWidget('<p>%s</p>' % _(

                        'You are about to remove an action.')))

        form.add_submit('delete', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('../../')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            self.html_top(title = _('Delete Action'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s %s</h2>') % (_('Deleting Action:'), self.action.name)

            r += form.render()

            return r.getvalue()

        del self.workflow.global_actions[self.workflow.global_actions.index(self.action)]

        self.workflow.store()

        return redirect('../../')

    def edit(self):

        form = Form(enctype = 'multipart/form-data')

        form.add(StringWidget, 'name', title=_('Action Name'), required=True,

                size=30, value=self.action.name)

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('..')

        if form.is_submitted() and not form.has_errors():

            new_name = str(form.get_widget('name').parse())

            if [x for x in self.workflow.global_actions if x.name == new_name]:

                form.get_widget('name').set_error(

                        _('There is already an action with that name.'))

            else:

                self.action.name = new_name

                self.workflow.store()

                return redirect('.')

        self.html_top(title=_('Edit Action Name'))

        get_response().breadcrumb.append( ('edit', _('Edit')) )

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('Edit Action Name')

        r += form.render()

        return r.getvalue()

    def get_sidebar(self):

        get_response().add_javascript(['jquery.js', 'jquery-ui.js', 'popup.js',

            'jquery.colourpicker.js'])

        r = TemplateIO(html=True)

        if str(self.workflow.id).startswith('_'):

            r += htmltext('<p>')

            r += _('''This is the default workflow, you cannot edit it but you can

                 duplicate it to base your own workflow on it.''')

            r += htmltext('</p>')

        else:

            r += htmltext('<ul id="sidebar-actions">')

            r += htmltext('<li><a href="edit" rel="popup">%s</a></li>') % _('Change Action Name')

            r += htmltext('<li><a href="backoffice-info-text" rel="popup">%s</a></li>'

                    ) % _('Change Backoffice Information Text')

            r += htmltext('<li><a href="delete" rel="popup">%s</a></li>') % _('Delete')

            r += htmltext('</ul>')

            r += htmltext('<div id="new-field">')

            r += htmltext('<h3>%s</h3>') % _('New Item')

            r += self.get_new_item_form().render()

            r += htmltext('</div>')

        return r.getvalue()

class GlobalActionsDirectory(Directory):

    _q_exports = ['', 'new']

    def __init__(self, workflow, html_top):

        self.workflow = workflow

        self.html_top = html_top

    def _q_lookup(self, component):

        return GlobalActionPage(self.workflow, component, self.html_top)

    def _q_index(self):

        return redirect('..')

    def new(self):

        form = Form(enctype='multipart/form-data')

        form.add(StringWidget, 'name', title=_('Name'), required=True, size=50)

        form.add_submit('submit', _('Add'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('..')

        if form.is_submitted() and not form.has_errors():

            name = form.get_widget('name').parse()

            action = self.workflow.add_global_action(name)

            self.workflow.store()

            return redirect('%s/' % action.id)

        get_response().breadcrumb.append(('new', _('New Global Action')))

        html_top('workflows', title=_('New Global Action'))

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('New Global Action')

        r += form.render()

        return r.getvalue()

            'update_actions_order',

            ('functions', 'functions_dir'), ('global-actions', 'global_actions_dir')]

        self.global_actions_dir = GlobalActionsDirectory(self.workflow, html_top)

                        r += htmltext('</a></li>')

        if not str(self.workflow.id).startswith('_') or self.workflow.global_actions:

            r += htmltext('<div class="bo-block">')

            r += htmltext('<h3>%s') % _('Global Actions')

            if not str(self.workflow.id).startswith('_'):

                r += htmltext(' <span class="change">(<a rel="popup" href="global-actions/new">%s</a>)</span>') % _('add global action')

            r += htmltext('</h3>')

            if not str(self.workflow.id).startswith('_'):

                r += htmltext('<ul id="status-list" class="biglist sortable" '

                              'data-order-function="update_actions_order">')

            else:

                r += htmltext('<ul id="status-list" class="biglist">')

            for action in (self.workflow.global_actions or []):

                r += htmltext('<li class="biglistitem" id="itemId_%s">' % action.id)

                if not str(self.workflow.id).startswith('_'):

                    r += htmltext('<a href="global-actions/%s/">%s</a>') % (

                            action.id, action.name)

                else:

                    r += htmltext('<a>%s</a>') % action.name

                r += htmltext('</li>')

            r += htmltext('</ul>')

            r += htmltext('</div>')

    def update_actions_order(self):

        request = get_request()

        new_order = request.form['order'].strip(';').split(';')

        self.workflow.global_actions = [ [x for x in self.workflow.global_actions if

                                        x.id == y][0] for y in new_order]

        self.workflow.store()

        return 'ok'

    _q_exports = ['', 'download', 'json', 'wfedit', 'action']

        from wcs.workflows import perform_items

        url = perform_items(wf_status.items, self)

    _q_exports = ['', 'download', 'json', 'action']

                    items = $(ui.item).parent().find('li');

                    var order_function = $(this).data('order-function') || 'update_order';

                    $.post(order_function, {'order': result});

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

def perform_items(items, formdata, depth=20):

    if depth == 0: # prevents infinite loops

        return

    url = None

    old_status = formdata.status

    for item in items:

        try:

            url = item.perform(formdata) or url

        except AbortActionException:

            break

        if formdata.status != old_status:

            break

    if formdata.status != old_status:

        if not formdata.evolution:

            formdata.evolution = []

        evo = Evolution()

        evo.time = time.localtime()

        evo.status = formdata.status

        formdata.evolution.append(evo)

        formdata.store()

        # performs the items of the new status

        wf_status = formdata.get_status()

        url = perform_items(wf_status.items, formdata, depth=depth-1) or url

    return url

class DuplicateGlobalActionNameError(Exception):

    pass

    global_actions = None

        self.global_actions = []

        if not self.global_actions:

            self.global_actions = []

    def add_global_action(self, name, id=None):

        if [x for x in self.global_actions if x.name == name]:

            raise DuplicateGlobalActionNameError()

        action = WorkflowGlobalAction(name)

        action.parent = self

        action.append_trigger('manual')

        if id is None:

            if self.global_actions:

                action.id = str(max([lax_int(x.id) for x in self.global_actions]) + 1)

            else:

                action.id = '1'

        else:

            action.id = id

        self.global_actions.append(action)

        return action

    def get_global_actions_for_user(self, formdata, user):

        if not user:

            return []

        actions = []

        for action in self.global_actions or []:

            for trigger in action.triggers or []:

                if isinstance(trigger, WorkflowGlobalActionManualTrigger):

                    roles = [get_role_translation(formdata, x)

                             for x in trigger.roles]

                    if set(roles).intersection(user.roles or []):

                        actions.append(action)

                        break

        return actions

        for s in self.possible_status + (self.global_actions or []):

            triggers = getattr(s, 'triggers', None) or []

            for i, item in enumerate(s.items + triggers):

        if self.global_actions:

            global_actions = ET.SubElement(root, 'global_actions')

            for action in self.global_actions:

                global_actions.append(action.export_to_xml(charset=charset,

                    include_id=include_id))

        workflow.global_actions = []

        global_actions = tree.find('global_actions')

        if global_actions is not None:

            for action in global_actions:

                action_o = WorkflowGlobalAction()

                action_o.parent = workflow

                action_o.init_with_xml(action, charset, include_id=include_id)

                workflow.global_actions.append(action_o)

        return render_list_of_roles(self, roles)

class XmlSerialisable(object):

    node_name = None

    def export_to_xml(self, charset, include_id=False):

        node = ET.Element(self.node_name)

        node.attrib['type'] = self.key

        for attribute in self.get_parameters():

            if hasattr(self, '%s_export_to_xml' % attribute):

                getattr(self, '%s_export_to_xml' % attribute)(node, charset,

                        include_id=include_id)

                continue

            if hasattr(self, attribute) and getattr(self, attribute) is not None:

                el = ET.SubElement(node, attribute)

                val = getattr(self, attribute)

                if type(val) is dict:

                    for k, v in val.items():

                        ET.SubElement(el, k).text = unicode(v, charset, 'replace')

                elif type(val) is list:

                    if attribute[-1] == 's':

                        atname = attribute[:-1]

                    else:

                        atname = 'item'

                    for v in val:

                        ET.SubElement(el, atname).text = unicode(str(v), charset, 'replace')

                elif type(val) in (str, unicode):

                    if type(val) is unicode:

                        el.text = val

                    else:

                        el.text = unicode(val, charset, 'replace')

                else:

                    el.text = str(val)

        return node

    def init_with_xml(self, elem, charset, include_id=False):

        for attribute in self.get_parameters():

            el = elem.find(attribute)

            if hasattr(self, '%s_init_with_xml' % attribute):

                getattr(self, '%s_init_with_xml' % attribute)(el, charset,

                        include_id=include_id)

                continue

            if el is None:

                continue

            if el.getchildren():

                if type(getattr(self, attribute)) is list:

                    v = [x.text.encode(charset) for x in el.getchildren()]

                elif type(getattr(self, attribute)) is dict:

                    v = {}

                    for e in el.getchildren():

                        v[e.tag] = e.text.encode(charset)

                else:

                    # ???

                    raise AssertionError

                setattr(self, attribute, v)

            else:

                if el.text is None:

                    setattr(self, attribute, None)

                elif el.text in ('False', 'True'): # bools

                    setattr(self, attribute, eval(el.text))

                elif type(getattr(self, attribute)) is int:

                    setattr(self, attribute, int(el.text.encode(charset)))

                else:

                    setattr(self, attribute, el.text.encode(charset))

    def _roles_export_to_xml(self, attribute, item, charset, include_id=False):

        if not hasattr(self, attribute) or not getattr(self, attribute):

            return

        el = ET.SubElement(item, attribute)

        for role_id in getattr(self, attribute):

            if role_id is None:

                continue

            role_id = str(role_id)

            if role_id.startswith('_') or role_id == 'logged-users':

                role = unicode(role_id, charset)

            else:

                try:

                    role = unicode(Role.get(role_id).name, charset)

                except KeyError:

                    role = unicode(role_id, charset)

            sub = ET.SubElement(el, 'item')

            sub.attrib['role_id'] = role_id

            sub.text = role

    def _roles_init_with_xml(self, attribute, elem, charset, include_id=False):

        if elem is None:

            setattr(self, attribute, [])

        else:

            imported_roles = []

            for child in elem.getchildren():

                imported_roles.append(self._get_role_id_from_xml(child,

                    charset, include_id=include_id))

            setattr(self, attribute, imported_roles)

    def _role_export_to_xml(self, attribute, item, charset, include_id=False):

        if not hasattr(self, attribute) or not getattr(self, attribute):

            return

        role_id = str(getattr(self, attribute))

        if role_id.startswith('_') or role_id == 'logged-users':

            role = unicode(role_id, charset)

        else:

            try:

                role = unicode(Role.get(role_id).name, charset)

            except KeyError:

                role = unicode(role_id, charset)

        sub = ET.SubElement(item, attribute)

        if include_id:

            sub.attrib['role_id'] = role_id

        sub.text = role

    def _get_role_id_from_xml(self, elem, charset, include_id=False):

        if elem is None:

            return None

        value = elem.text.encode(charset)

        # look for known static values

        if value.startswith('_') or value == 'logged-users':

            return value

        # if we import using id, only look at the role_id attribute

        if include_id:

            if not 'role_id' in elem.attrib:

                return None

            role_id = str(elem.attrib['role_id'])

            if Role.has_key(role_id):

                return role_id

            else:

                return None

        # if not using id, look up on the name

        for role in Role.select(ignore_errors=True):

            if role.name == value:

                return role.id

        # and if there's no match, create a new role

        role = Role()

        role.name = value

        role.store()

        return role.id

    def _role_init_with_xml(self, attribute, elem, charset, include_id=False):

        setattr(self, attribute, self._get_role_id_from_xml(elem, charset,

            include_id=include_id))

class WorkflowGlobalActionTrigger(XmlSerialisable):

    node_name = 'trigger'

class WorkflowGlobalActionManualTrigger(WorkflowGlobalActionTrigger):

    key = 'manual'

    roles = None

    def get_parameters(self):

        return ('roles',)

    def render_as_line(self):

        if self.roles:

            return _('Manual by %s') % render_list_of_roles(

                    self.parent.parent, self.roles)

        else:

            return _('Manual (not assigned)')

    def form(self, workflow):

        form = Form(enctype='multipart/form-data')

        options = [(None, '---', None)]

        options += workflow.get_list_of_roles(include_logged_in_users=False)

        form.add(WidgetList, 'roles', title=_('Roles'),

                element_type=SingleSelectWidget,

                value=self.roles,

                add_element_label=_('Add Role'),

                element_kwargs={'render_br': False,

                                'options': options})

        return form

    def submit(self, form):

        self.roles = form.get_widget('roles').parse()

    def roles_export_to_xml(self, item, charset, include_id=False):

        self._roles_export_to_xml('roles', item, charset, include_id=include_id)

    def roles_init_with_xml(self, elem, charset, include_id=False):

        self._roles_init_with_xml('roles', elem, charset, include_id=include_id)

class WorkflowGlobalAction(object):

    id = None

    name = None

    items = None

    triggers = None

    backoffice_info_text = None

    def __init__(self, name=None):

        self.name = name

        self.items = []

    def append_item(self, type):

        for klass in item_classes:

            if klass.key == type:

                o = klass()

                if self.items:

                    o.id = str(max([lax_int(x.id) for x in self.items]) + 1)

                else:

                    o.id = '1'

                self.items.append(o)

                return o

        else:

            raise KeyError()

    def append_trigger(self, type):

        trigger_types = {

            'manual': WorkflowGlobalActionManualTrigger

        }

        o = trigger_types.get(type)()

        if not self.triggers:

            self.triggers = []

        if self.triggers:

            o.id = str(max([lax_int(x.id) for x in self.triggers]) + 1)

        else:

            o.id = '1'

        self.triggers.append(o)

        return o

    def export_to_xml(self, charset, include_id=False):

        status = ET.Element('action')

        ET.SubElement(status, 'id').text = unicode(self.id, charset)

        ET.SubElement(status, 'name').text = unicode(self.name, charset)

        if self.backoffice_info_text:

            ET.SubElement(status, 'backoffice_info_text').text = unicode(

                    self.backoffice_info_text, charset)

        items = ET.SubElement(status, 'items')

        for item in self.items:

            items.append(item.export_to_xml(charset=charset,

                include_id=include_id))

        triggers = ET.SubElement(status, 'triggers')

        for trigger in self.triggers:

            triggers.append(trigger.export_to_xml(charset=charset,

                include_id=include_id))

        return status

    def init_with_xml(self, elem, charset, include_id=False):

        self.id = elem.find('id').text.encode(charset)

        self.name = elem.find('name').text.encode(charset)

        if elem.find('backoffice_info_text') is not None:

            self.backoffice_info_text = elem.find('backoffice_info_text').text.encode(charset)

        self.items = []

        for item in elem.find('items'):

            item_type = item.attrib['type']

            self.append_item(item_type)

            item_o = self.items[-1]

            item_o.parent = self

            item_o.init_with_xml(item, charset, include_id=include_id)

        self.triggers = []

        for trigger in elem.find('triggers'):

            trigger_type = trigger.attrib['type']

            self.append_trigger(trigger_type)

            trigger_o = self.triggers[-1]

            trigger_o.parent = self

            trigger_o.init_with_xml(trigger, charset, include_id=include_id)

        for action in filled.formdef.workflow.get_global_actions_for_user(filled, user):

            form.add_submit('button-action-%s' % action.id, action.name)

            if form.get_widget('button-action-%s' % action.id):

                form.get_widget('button-action-%s' % action.id).backoffice_info_text = action.backoffice_info_text

        # check for global actions

        for action in filled.formdef.workflow.get_global_actions_for_user(filled, user):

            if 'button-action-%s' % action.id in get_request().form:

                url = perform_items(action.items, filled)

                if url:

                    return redirect(url)

                return

class WorkflowStatusItem(XmlSerialisable):

    node_name = 'item'

    ok_in_global_action = True # means it can be used in a global action

def render_list_of_roles(workflow, roles):

    t = []

    for r in roles:

        role_label = get_role_translation_label(workflow, r)

        if role_label:

            t.append(role_label)

    return ', '.join(t)

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False

    ok_in_global_action = False