Produits Entr'ouvert » w.c.s.

import pytest

from wcs.blocks import BlockDef

from wcs.carddef import CardDef

from wcs.data_sources import NamedDataSource

from wcs.formdef import FormDef

from wcs.workflows import Workflow

from wcs.wscalls import NamedWsCall

from utilities import get_app, login, create_temporary_pub, clean_temporary_pub

    assert 'This workflow is readonly' in resp

def test_wscall_snapshot_browse(pub):

    create_superuser(pub)

    create_role()

        return blockdef

    @classmethod

        charset = 'utf-8'

        blockdef = cls()

        if tree.find('name') is None or not tree.find('name').text:

                    el.text = str(val)

        return field

        for attribute in self.get_admin_attributes():

            el = elem.find(attribute)

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

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

                continue

            if el is None:

                continue

            except:

                pass

        self.condition = None

        if node is None:

            return

        elif node.text:

            self.condition = {'type': 'python', 'value': force_str(node.text).strip()}

        self.data_source = {}

        if node is None:

            return

            elif self.data_source.get('value') is None:

                del self.data_source['value']

        self.prefill = {}

        if node is not None and node.findall('type'):

            self.prefill = {

            changed = True

        return changed

        super(StringField, self).init_with_xml(element, charset, include_id=include_id)

        self.migrate()

            self.document_type['mimetypes'] = old_value

        return result

        super(FileField, self).init_with_xml(element, charset, include_id=include_id)

        # translate fields flattened to strings

        if self.document_type and self.document_type.get('mimetypes'):

            changed = True

        return changed

        super(ItemField, self).init_with_xml(element, charset, include_id=include_id)

        if getattr(element.find('show_as_radio'), 'text', None) == 'True':

            self.display_mode = 'radio'

    post_conditions = None

        if node is None:

            return

        self.post_conditions = []

        return formdef

    @classmethod

        if charset is None:

            charset = get_publisher().site_charset

        assert charset == 'utf-8'

                include_id=include_id)

    @classmethod

        if charset is None:

            charset = get_publisher().site_charset

        obj = cls()

    def instance(self):

        if self._instance is None:

            tree = ET.fromstring(self.serialization)

            self._instance.readonly = True

        return self._instance

            ET.SubElement(node, 'mimetype').text = mimetype

        return node

        self.document_type = {}

        if node is None:

            return

        return fields_node

        fields = []

        if elem is None:

            return

        for field_xml_node in elem.findall('field'):

            field_node = FieldNode()

            field_node.init_with_xml(field_xml_node, charset,

            fields.append(field_node.as_dict())

        if fields:

            self.fields = fields

            item.attrib['field_id'] = str(mapping.field_id)

            item.text = mapping.expression

        self.mappings = []

        for child in container:

            field_id = child.attrib.get('field_id', '')

        self._role_export_to_xml('role_id', item, charset,

                include_id=include_id)

        self._role_init_with_xml('role_id', elem, charset,

class DispatchWorkflowStatusItem(WorkflowStatusItem):

        self._role_export_to_xml('role_id', item, charset,

                include_id=include_id)

        self._role_init_with_xml('role_id', elem, charset,

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

        if self.dispatch_type != 'automatic' or not self.rules:

        return rules_node

        rules = []

        if elem is None:

            return

        for rule_xml_node in elem.findall('rule'):

            rule_node = RuleNode()

            rule_node.init_with_xml(rule_xml_node, charset,

            rules.append(rule_node.as_dict())

        if rules:

            self.rules = rules

        ET.SubElement(el, 'b64_content').text = force_text(base64.encodebytes(

                self.model_file.get_file().read()))

        if elem is None:

            return

        base_filename = elem.find('base_filename').text

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

            content = elem.find('content').text

            ids = (self.parent.parent.id, self.parent.id, self.id)

        else:

            # hopefully this will be random enough.

            ids = ('i%i' % random.randint(0, 1000000), self.parent.id, self.id)

            fields.append(field.export_to_xml(charset=charset, include_id=include_id))

        return item

        WorkflowStatusItem.init_with_xml(self, elem, charset)

        el = elem.find('formdef')

        if el is None:

            return

        # we can always include id in the formdef export as it lives in

        # a different space, isolated from other formdefs.

        self.formdef = WorkflowFormFieldsFormDef(item=self)

        self.formdef.fields = imported_formdef.fields

        if self.formdef.max_field_id is None and self.formdef.fields:

    directory_name = 'jump'

    directory_class = JumpDirectory

        if elem is None or elem.text is None:

            self.timeout = None

        else:

        return fields_node

        fields = []

        if elem is None:

            return

        for field_xml_node in elem.findall('field'):

            field_node = FieldNode()

            field_node.init_with_xml(field_xml_node, charset,

            fields.append(field_node.as_dict())

        if fields:

            self.fields = fields

        self._role_export_to_xml('role_id', item, charset,

                include_id=include_id)

        self._role_init_with_xml('role_id', elem, charset,

    def perform(self, formdata):

        if not self.role_id:

        self._kv_data_export_to_xml(xml_item, charset, include_id=include_id,

                                    attribute='post_data')

        self._kv_data_init_with_xml(elem, charset, include_id=include_id, attribute='post_data')

    def qs_data_export_to_xml(self, xml_item, charset, include_id=False):

        self._kv_data_export_to_xml(xml_item, charset, include_id=include_id, attribute='qs_data')

        self._kv_data_init_with_xml(elem, charset, include_id=include_id, attribute='qs_data')

register_item_class(WebserviceCallStatusItem)

        return cls.import_from_xml_tree(tree, include_id=include_id)

    @classmethod

        charset = get_publisher().site_charset

        workflow = cls()

        if tree.find('name') is None or not tree.find('name').text:

        for status in tree.find('possible_status'):

            status_o = WorkflowStatus()

            status_o.parent = workflow

            workflow.possible_status.append(status_o)

        workflow.global_actions = []

            for action in global_actions:

                action_o = WorkflowGlobalAction()

                action_o.parent = workflow

                workflow.global_actions.append(action_o)

        workflow.criticality_levels = []

        variables = tree.find('variables')

        if variables is not None:

            formdef = variables.find('formdef')

            workflow.variables_formdef = WorkflowVariablesFieldsFormDef(workflow=workflow)

            workflow.variables_formdef.fields = imported_formdef.fields

        variables = tree.find('backoffice-fields')

        if variables is not None:

            formdef = variables.find('formdef')

            workflow.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(workflow=workflow)

            workflow.backoffice_fields_formdef.fields = imported_formdef.fields

                    el.text = str(val)

        return node

        if include_id and elem.attrib.get('id'):

            self.id = elem.attrib.get('id')

        for attribute in self.get_parameters():

            el = elem.find(attribute)

            if getattr(self, '%s_init_with_xml' % attribute, None):

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

                continue

            if el is None:

                continue

            sub.attrib['role_id'] = role_id

            sub.text = role

        if elem is None:

            setattr(self, attribute, [])

        else:

        role.store()

        return role.id

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

            include_id=include_id))

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

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

class WorkflowGlobalActionTimeoutTriggerMarker(object):

        return status

        self.id = xml_node_text(elem.find('id'))

        self.name = xml_node_text(elem.find('name'))

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

            self.append_item(item_type)

            item_o = self.items[-1]

            item_o.parent = self

        self.triggers = []

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

            self.append_trigger(trigger_type)

            trigger_o = self.triggers[-1]

            trigger_o.parent = self

class WorkflowCriticalityLevel(object):

            ET.SubElement(level, 'colour').text = force_text(self.colour, charset)

        return level

        self.id = xml_node_text(elem.find('id'))

        self.name = xml_node_text(elem.find('name'))

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

                include_id=include_id))

        return status

        self.id = xml_node_text(elem.find('id'))

        self.name = xml_node_text(elem.find('name'))

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

            self.append_item(item_type)

            item_o = self.items[-1]

            item_o.parent = self

    def __repr__(self):

        return '<%s %s %r>' % (self.__class__.__name__, self.id, self.name)

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

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

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

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

        self.condition = None

        if node is None:

            return

            del odict['parent']

        return odict

        if elem is None:

            self.mail_template = None

            return

        self.mail_template = value

        return

        if elem is None:

            self.attachments = None

        else:

            el = ET.SubElement(xml_item, 'button_label')

            el.text = self.button_label

        if element is None:

            return

        # this can be None if element is self-closing, <button_label />, which