Produits Entr'ouvert » w.c.s.

    assert '2020-04-18' in formdata.evolution[0].parts[1].content

from wcs.workflows import ContentSnapshotPart, Workflow, WorkflowBackofficeFieldsFormDef

    assert len(formdata.evolution) == 2

    assert len(formdata.evolution[0].parts) == 1

    assert isinstance(formdata.evolution[0].parts[0], ContentSnapshotPart)

    assert formdata.evolution[1].parts is None

    assert formdata.evolution[0].parts[1].content == 'Hello bar World'

    assert formdata.evolution[0].parts[1].content == 'Hello bar World'

    assert formdata.evolution[0].parts[1].content == 'Hello World'

    assert formdata.evolution[0].parts[1].to is None

    assert formdata.evolution[0].parts[1].content == 'Hello World'

    assert formdata.evolution[0].parts[1].to == [role1.id]

    assert formdata.evolution[0].parts[1].content == 'Hello World'

    assert formdata.evolution[0].parts[1].to == [role2.id]

import json

import os

import pytest

from webtest import Upload

from wcs import fields

from wcs.api_access import ApiAccess

from wcs.carddef import CardDef

from wcs.formdef import FormDef

from wcs.qommon.http_request import HTTPRequest

from wcs.qommon.ident.password_accounts import PasswordAccount

from wcs.wf.backoffice_fields import SetBackofficeFieldsWorkflowStatusItem

from wcs.wf.create_formdata import Mapping

from wcs.workflows import ContentSnapshotPart, Workflow, WorkflowBackofficeFieldsFormDef

from .utilities import clean_temporary_pub, create_temporary_pub, get_app, login

@pytest.fixture

def pub(emails):

    pub = create_temporary_pub()

    req = HTTPRequest(None, {'SCRIPT_NAME': '/', 'SERVER_NAME': 'example.net'})

    pub.set_app_dir(req)

    pub.cfg['identification'] = {'methods': ['password']}

    pub.cfg['language'] = {'language': 'en'}

    pub.write_cfg()

    with open(os.path.join(pub.app_dir, 'site-options.cfg'), 'w') as fd:

        fd.write(

            '''

    [api-secrets]

    coucou = 1234

    '''

        )

    return pub

def teardown_module(module):

    clean_temporary_pub()

@pytest.fixture

def role(pub):

    pub.role_class.wipe()

    role = pub.role_class(name='foobar')

    role.store()

    return role

@pytest.fixture

def user(pub, role):

    pub.user_class.wipe()

    user = pub.user_class()

    user.name = 'Jean Darmette'

    user.email = 'jean.darmette@triffouilis.fr'

    user.name_identifiers = ['0123456789']

    user.roles = [role.id]

    user.store()

    account = PasswordAccount(id='admin')

    account.set_password('admin')

    account.user_id = user.id

    account.store()

    return user

@pytest.fixture

def access(pub, role):

    ApiAccess.wipe()

    access = ApiAccess()

    access.name = 'test'

    access.access_identifier = 'test'

    access.access_key = '12345'

    access.roles = [role]

    access.store()

    return access

def test_formdata_create_and_edit_and_bo_field(pub, user):

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'test'

    formdef.fields = [

        fields.StringField(id='1', label='string', varname='foo'),

    ]

    formdef.store()

    formdef.data_class().wipe()

    Workflow.wipe()

    workflow = Workflow(name='test')

    workflow.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(workflow)

    workflow.backoffice_fields_formdef.fields = [

        fields.StringField(id='bo1', label='bo field 1', type='string', varname='plop'),

    ]

    st1 = workflow.add_status('Status1', 'st1')

    setbo = st1.add_action('set-backoffice-fields')

    setbo.fields = [{'field_id': 'bo1', 'value': '{{ form_var_foo }}'}]

    setbo2 = st1.add_action('set-backoffice-fields')

    setbo2.fields = [{'field_id': 'bo1', 'value': '{{ "foo"|add:form_var_plop }}'}]

    jump = st1.add_action('jump')

    jump.status = 'st2'

    st2 = workflow.add_status('Status2', 'st2')

    editable = st2.add_action('editable', id='_editable')

    editable.by = ['_submitter']

    editable.status = st1.id

    workflow.store()

    formdef.workflow_id = workflow.id

    formdef.store()

    formdef.data_class().wipe()

    app = login(get_app(pub))

    resp = app.get('/test/')

    resp.form['f1'] = 'bar'

    resp = resp.form.submit('submit')  # -> validation

    resp = resp.form.submit('submit').follow()  # -> submitted

    assert 'The form has been recorded' in resp.text

    data_id = formdef.data_class().select()[0].id

    resp = app.get('/test/%s/' % data_id)

    assert 'button_editable-button' in resp.text

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

    resp = resp.follow()

    assert resp.form['f1'].value == 'bar'

    resp.form['f1'].value = 'baz'

    resp = resp.form.submit('submit').follow()  # -> saved

    formdata = formdef.data_class().get(data_id)

    assert isinstance(formdata.evolution[0].parts[0], ContentSnapshotPart)

    # creation, submit

    assert formdata.evolution[0].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[0].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[0].parts[0].old_data == {}

    assert formdata.evolution[0].parts[0].new_data == {'1': 'bar', 'bo1': None}

    # creation, bo field first action

    assert formdata.evolution[0].parts[1].formdef_type == 'formdef'

    assert formdata.evolution[0].parts[1].formdef_id == str(formdef.id)

    assert formdata.evolution[0].parts[1].old_data == {'1': 'bar'}

    assert formdata.evolution[0].parts[1].new_data == {'1': 'bar', 'bo1': 'bar'}

    # creation, bo field second action

    assert formdata.evolution[0].parts[2].formdef_type == 'formdef'

    assert formdata.evolution[0].parts[2].formdef_id == str(formdef.id)

    assert formdata.evolution[0].parts[2].old_data == {'1': 'bar', 'bo1': 'bar'}

    assert formdata.evolution[0].parts[2].new_data == {'1': 'bar', 'bo1': 'foobar'}

    # update, submit

    assert formdata.evolution[1].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[1].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[1].parts[0].old_data == {'1': 'bar', 'bo1': 'foobar'}

    assert formdata.evolution[1].parts[0].new_data == {'1': 'baz', 'bo1': 'foobar'}

    # update, bo field first action

    assert formdata.evolution[2].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[2].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[2].parts[0].old_data == {'1': 'baz', 'bo1': 'foobar'}

    assert formdata.evolution[2].parts[0].new_data == {'1': 'baz', 'bo1': 'baz'}

    # update, bo field second action

    assert formdata.evolution[2].parts[1].formdef_type == 'formdef'

    assert formdata.evolution[2].parts[1].formdef_id == str(formdef.id)

    assert formdata.evolution[2].parts[1].old_data == {'1': 'baz', 'bo1': 'baz'}

    assert formdata.evolution[2].parts[1].new_data == {'1': 'baz', 'bo1': 'foobaz'}

def test_backoffice_formdata_submission(pub, user):

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'form title'

    formdef.fields = [

        fields.StringField(id='1', label='String', type='string'),

    ]

    formdef.workflow_roles = {'_receiver': user.roles[0]}

    formdef.backoffice_submission_roles = user.roles[:]

    formdef.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/submission/form-title/')

    resp.form['f1'] = 'test submission'

    resp = resp.form.submit('submit')  # -> validation

    resp = resp.form.submit('submit').follow()  # -> submitted

    assert 'The form has been recorded' in resp.text

    formdata = formdef.data_class().select()[0]

    assert isinstance(formdata.evolution[0].parts[0], ContentSnapshotPart)

    assert formdata.evolution[0].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[0].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[0].parts[0].old_data == {}

    assert formdata.evolution[0].parts[0].new_data == {'1': 'test submission'}

def test_backoffice_carddata_add_edit(pub, user):

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='1', label='string', varname='foo'),

    ]

    carddef.backoffice_submission_roles = user.roles

    carddef.workflow_roles = {

        '_viewer': user.roles[0],

        '_editor': user.roles[0],

    }

    carddef.store()

    carddef.data_class().wipe()

    Workflow.wipe()

    workflow = Workflow(name='test')

    workflow.roles = {

        '_viewer': 'Viewer',

        '_editor': 'Editor',

    }

    st1 = workflow.add_status('Status1', 'st1')

    jump = st1.add_action('jump')

    jump.status = 'st2'

    st2 = workflow.add_status('Status2', 'st2')

    editable = st2.add_action('editable', id='_editable')

    editable.by = ['_editor']

    editable.status = st1.id

    workflow.store()

    carddef.workflow_id = workflow.id

    carddef.store()

    carddef.data_class().wipe()

    app = login(get_app(pub))

    resp = app.get('/backoffice/data/test/add/')

    resp.form['f1'] = 'foo'

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

    assert 'button_editable-button' in resp.text

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

    resp = resp.follow()

    resp.form['f1'].value = 'bar'

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

    carddata = carddef.data_class().select()[0]

    # creation

    assert isinstance(carddata.evolution[0].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[0].parts[0].old_data == {}

    assert carddata.evolution[0].parts[0].new_data == {'1': 'foo'}

    # update

    assert isinstance(carddata.evolution[1].parts[0], ContentSnapshotPart)

    assert carddata.evolution[1].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[1].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[1].parts[0].old_data == {'1': 'foo'}

    assert carddata.evolution[1].parts[0].new_data == {'1': 'bar'}

def test_backoffice_card_import_csv(pub, user):

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='1', label='Test'),

        fields.StringField(id='2', label='Test2'),

    ]

    carddef.workflow_roles = {'_editor': user.roles[0]}

    carddef.backoffice_submission_roles = user.roles

    carddef.store()

    carddef.data_class().wipe()

    app = login(get_app(pub))

    resp = app.get(carddef.get_url())

    resp = resp.click('Import data from a file')

    data = [b'Test,Test2']

    data.append(b'data,foo')

    resp.forms[0]['file'] = Upload('test.csv', b'\n'.join(data), 'text/csv')

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

    assert 'Importing data into cards' in resp

    assert carddef.data_class().count() == 1

    carddata = carddef.data_class().select()[0]

    assert isinstance(carddata.evolution[-1].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[-1].parts[0].old_data == {}

    assert carddata.evolution[-1].parts[0].new_data == {'1': 'data', '2': 'foo'}

def test_backoffice_card_import_json(pub, user):

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='1', label='Test', varname='string'),

    ]

    carddef.workflow_roles = {'_editor': user.roles[0]}

    carddef.backoffice_submission_roles = user.roles

    carddef.store()

    carddef.data_class().wipe()

    app = login(get_app(pub))

    resp = app.get(carddef.get_url())

    resp = resp.click('Import data from a file')

    data = {

        'data': [

            {

                'fields': {

                    'string': 'a string',

                }

            }

        ]

    }

    resp.forms[0]['file'] = Upload('test.json', json.dumps(data).encode(), 'application/json')

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

    assert '/backoffice/processing?job=' in resp.location

    resp = resp.follow()

    carddata = carddef.data_class().select()[0]

    assert isinstance(carddata.evolution[-1].parts[0], ContentSnapshotPart)

    assert carddata.evolution[-1].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[-1].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[-1].parts[0].old_data == {}

    assert carddata.evolution[-1].parts[0].new_data == {'1': 'a string'}

def test_workflow_formdata_create(pub):

    FormDef.wipe()

    pub.tracking_code_class.wipe()

    target_formdef = FormDef()

    target_formdef.name = 'target form'

    target_formdef.fields = [

        fields.StringField(id='0', label='string', varname='string'),

    ]

    target_formdef.store()

    wf = Workflow(name='create-formdata')

    wf.possible_status = Workflow.get_default_workflow().possible_status[:]

    create = wf.possible_status[1].add_action('create_formdata', id='_create', prepend=True)

    create.formdef_slug = target_formdef.url_name

    create.label = 'create a new linked form'

    create.varname = 'resubmitted'

    create.mappings = [

        Mapping(field_id='0', expression='{{ form_var_foo }}'),

    ]

    wf.store()

    source_formdef = FormDef()

    source_formdef.name = 'source form'

    source_formdef.fields = [

        fields.StringField(id='0', label='string', varname='foo'),

    ]

    source_formdef.workflow_id = wf.id

    source_formdef.store()

    formdata = source_formdef.data_class()()

    formdata.data = {'0': 'foobar'}

    formdata.just_created()

    formdata.store()

    formdata.perform_workflow()

    assert target_formdef.data_class().count() == 1

    created_formdata = target_formdef.data_class().select()[0]

    assert isinstance(created_formdata.evolution[0].parts[0], ContentSnapshotPart)

    assert created_formdata.evolution[0].parts[0].formdef_type == 'formdef'

    assert created_formdata.evolution[0].parts[0].formdef_id == str(target_formdef.id)

    assert created_formdata.evolution[0].parts[0].old_data == {}

    assert created_formdata.evolution[0].parts[0].new_data == {'0': 'foobar'}

def test_workflow_carddata_create(pub):

    CardDef.wipe()

    FormDef.wipe()

    carddef = CardDef()

    carddef.name = 'My card'

    carddef.fields = [

        fields.StringField(id='1', label='string'),

    ]

    carddef.store()

    wf = Workflow(name='create-carddata')

    wf.possible_status = Workflow.get_default_workflow().possible_status[:]

    create = wf.possible_status[1].add_action('create_carddata', id='_create', prepend=True)

    create.label = 'Create CardDef'

    create.varname = 'mycard'

    create.formdef_slug = carddef.url_name

    create.mappings = [

        Mapping(field_id='1', expression='{{ form_var_string }}'),

    ]

    wf.store()

    formdef = FormDef()

    formdef.name = 'source form'

    formdef.fields = [

        fields.StringField(id='1', label='string', varname='string'),

    ]

    formdef.workflow_id = wf.id

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {'1': 'foobar'}

    formdata.just_created()

    formdata.store()

    formdata.perform_workflow()

    assert carddef.data_class().count() == 1

    carddata = carddef.data_class().select()[0]

    assert isinstance(carddata.evolution[-1].parts[0], ContentSnapshotPart)

    assert carddata.evolution[-1].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[-1].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[-1].parts[0].old_data == {}

    assert carddata.evolution[-1].parts[0].new_data == {'1': 'foobar'}

def test_workflow_carddata_edit(pub):

    FormDef.wipe()

    CardDef.wipe()

    # carddef

    carddef = CardDef()

    carddef.name = 'Model 1'

    carddef.fields = [

        fields.StringField(id='1', label='string', varname='string'),

    ]

    carddef.store()

    carddef.data_class().wipe()

    carddata = carddef.data_class()()

    carddata.data = {

        '1': 'foobar',

    }

    carddata.just_created()

    carddata.store()

    # formdef workflow that will update carddata

    wf = Workflow(name='update')

    st1 = wf.add_status('New', 'st1')

    jump = st1.add_action('jump', id='_jump')

    jump.by = ['_submitter', '_receiver']

    jump.status = 'st2'

    st2 = wf.add_status('Update card', 'st2')

    edit = st2.add_action('edit_carddata', id='edit')

    edit.formdef_slug = carddef.url_name

    edit.target_mode = 'manual'

    edit.target_id = '{{ form_var_card }}'

    edit.mappings = [

        Mapping(field_id='1', expression='{{ form_var_foo }}'),

    ]

    wf.store()

    # associated formdef

    formdef = FormDef()

    formdef.name = 'Update'

    formdef.fields = [

        fields.StringField(id='1', label='string', varname='card'),

        fields.StringField(id='2', label='string', varname='foo'),

    ]

    formdef.workflow = wf

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {

        '1': str(carddata.id),

        '2': 'foobaz',

    }

    formdata.just_created()

    formdata.store()

    formdata.perform_workflow()

    carddata.refresh_from_storage()

    # creation

    assert isinstance(carddata.evolution[0].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[0].parts[0].old_data == {}

    assert carddata.evolution[0].parts[0].new_data == {'1': 'foobar'}

    # update

    assert isinstance(carddata.evolution[1].parts[0], ContentSnapshotPart)

    assert carddata.evolution[1].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[1].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[1].parts[0].old_data == {'1': 'foobar'}

    assert carddata.evolution[1].parts[0].new_data == {'1': 'foobaz'}

def test_workflow_set_backoffice_field(http_requests, pub):

    Workflow.wipe()

    FormDef.wipe()

    wf = Workflow(name='xxx')

    wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf)

    wf.backoffice_fields_formdef.fields = [

        fields.StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'),

    ]

    st1 = wf.add_status('Status1')

    wf.store()

    formdef = FormDef()

    formdef.name = 'baz'

    formdef.fields = [

        fields.StringField(id='0', label='String', type='string', varname='string'),

    ]

    formdef.workflow_id = wf.id

    formdef.store()

    formdata = formdef.data_class()()

    formdata.data = {'0': 'HELLO'}

    formdata.just_created()

    formdata.store()

    pub.substitutions.feed(formdata)

    item = SetBackofficeFieldsWorkflowStatusItem()

    item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_string }}'}]

    item.parent = st1

    item.perform(formdata)

    formdata.refresh_from_storage()

    # creation

    assert isinstance(formdata.evolution[-1].parts[0], ContentSnapshotPart)

    assert formdata.evolution[-1].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[-1].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[-1].parts[0].old_data == {}

    assert formdata.evolution[-1].parts[0].new_data == {

        '0': 'HELLO',

    }

    # bo action

    assert isinstance(formdata.evolution[-1].parts[1], ContentSnapshotPart)

    assert formdata.evolution[-1].parts[1].formdef_type == 'formdef'

    assert formdata.evolution[-1].parts[1].formdef_id == str(formdef.id)

    assert formdata.evolution[-1].parts[1].old_data == {

        '0': 'HELLO',

    }

    assert formdata.evolution[-1].parts[1].new_data == {

        '0': 'HELLO',

        'bo1': 'HELLO',

    }

def test_api_form_submit(pub, user, access, role):

    app = get_app(pub)

    app.set_authorization(('Basic', ('test', '12345')))

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'test'

    formdef.fields = [

        fields.StringField(id='1', label='foobar', varname='foobar'),

    ]

    formdef.backoffice_submission_roles = [role.id]

    formdef.store()

    data_class = formdef.data_class()

    payload = {

        'data': {

            'foobar': 'xxx',

        }

    }

    resp = app.post_json(

        '/api/formdefs/test/submit',

        payload,

    )

    assert resp.json['err'] == 0

    formdata = data_class.get(resp.json['data']['id'])

    assert isinstance(formdata.evolution[0].parts[0], ContentSnapshotPart)

    assert formdata.evolution[0].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[0].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[0].parts[0].old_data == {}

    assert formdata.evolution[0].parts[0].new_data == {'1': 'xxx'}

def test_api_formdata_edit(pub, user, access, role):

    app = get_app(pub)

    app.set_authorization(('Basic', ('test', '12345')))

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'test'

    formdef.fields = [

        fields.StringField(id='0', label='foobar', varname='foobar'),

    ]

    Workflow.wipe()

    workflow = Workflow(name='foo')

    workflow.possible_status = Workflow.get_default_workflow().possible_status[:]

    workflow.store()

    formdef.workflow_id = workflow.id

    formdef.workflow_roles = {'_receiver': role.id}

    formdef.store()

    formdef.data_class().wipe()

    formdata = formdef.data_class()()

    formdata.data = {

        '0': 'foo@localhost',

    }

    formdata.user_id = user.id

    formdata.just_created()

    formdata.status = 'wf-new'

    formdata.evolution[-1].status = 'wf-new'

    formdata.store()

    wfedit = workflow.possible_status[1].add_action('editable', id='_wfedit')

    wfedit.by = [user.roles[0]]

    workflow.store()

    app.post_json(

        '/api/forms/test/%s/' % formdata.id,

        {'data': {'0': 'bar@localhost'}},

    )

    formdata.refresh_from_storage()

    # creation

    assert isinstance(formdata.evolution[-1].parts[0], ContentSnapshotPart)

    assert formdata.evolution[-1].parts[0].formdef_type == 'formdef'

    assert formdata.evolution[-1].parts[0].formdef_id == str(formdef.id)

    assert formdata.evolution[-1].parts[0].old_data == {}

    assert formdata.evolution[-1].parts[0].new_data == {'0': 'foo@localhost'}

    # update

    assert isinstance(formdata.evolution[-1].parts[1], ContentSnapshotPart)

    assert formdata.evolution[-1].parts[1].formdef_type == 'formdef'

    assert formdata.evolution[-1].parts[1].formdef_id == str(formdef.id)

    assert formdata.evolution[-1].parts[1].old_data == {'0': 'foo@localhost'}

    assert formdata.evolution[-1].parts[1].new_data == {'0': 'bar@localhost'}

def test_api_card_import_csv(pub, user, access, role):

    app = get_app(pub)

    app.set_authorization(('Basic', ('test', '12345')))

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='0', label='foobar', varname='foo'),

        fields.StringField(id='1', label='foobar2', varname='foo2'),

    ]

    carddef.workflow_roles = {'_viewer': role.id}

    carddef.backoffice_submission_roles = [role.id]

    carddef.digest_templates = {'default': 'bla {{ form_var_foo }} xxx'}

    carddef.store()

    carddef.data_class().wipe()

    resp = app.put(

        '/api/cards/test/import-csv',

        params=b'foobar;foobar2\nfirst entry;plop\n',

        headers={'content-type': 'text/csv'},

    )

    assert resp.json == {'err': 0}

    assert carddef.data_class().count() == 1

    carddata = carddef.data_class().select()[0]

    assert isinstance(carddata.evolution[0].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[0].parts[0].old_data == {}

    assert carddata.evolution[0].parts[0].new_data == {'0': 'first entry', '1': 'plop'}

def test_api_card_import_json(pub, user, access, role):

    app = get_app(pub)

    app.set_authorization(('Basic', ('test', '12345')))

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='0', label='foobar', varname='foo'),

    ]

    carddef.workflow_roles = {'_viewer': role.id}

    carddef.backoffice_submission_roles = [role.id]

    carddef.store()

    carddef.data_class().wipe()

    data = {

        'data': [

            {

                'fields': {

                    'foo': 'bar',

                }

            },

        ]

    }

    resp = app.put_json(

        '/api/cards/test/import-json',

        data,

    )

    assert resp.json == {'err': 0}

    assert carddef.data_class().count() == 1

    carddata = carddef.data_class().select()[0]

    assert isinstance(carddata.evolution[0].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[0].parts[0].old_data == {}

    assert carddata.evolution[0].parts[0].new_data == {'0': 'bar'}

def test_api_card_submit(pub, user, access, role):

    app = get_app(pub)

    app.set_authorization(('Basic', ('test', '12345')))

    CardDef.wipe()

    carddef = CardDef()

    carddef.name = 'test'

    carddef.fields = [

        fields.StringField(id='1', label='foobar', varname='foobar'),

    ]

    carddef.backoffice_submission_roles = [role.id]

    carddef.store()

    data_class = carddef.data_class()

    payload = {

        'data': {

            'foobar': 'xxx',

        }

    }

    resp = app.post_json(

        '/api/cards/test/submit',

        payload,

    )

    assert resp.json['err'] == 0

    carddata = data_class.get(resp.json['data']['id'])

    assert isinstance(carddata.evolution[0].parts[0], ContentSnapshotPart)

    assert carddata.evolution[0].parts[0].formdef_type == 'carddef'

    assert carddata.evolution[0].parts[0].formdef_id == str(carddef.id)

    assert carddata.evolution[0].parts[0].old_data == {}

    assert carddata.evolution[0].parts[0].new_data == {'1': 'xxx'}

    ContentSnapshotPart,

    assert len(formdata.evolution[-1].parts) == 4

    assert isinstance(formdata.evolution[-1].parts[0], ContentSnapshotPart)

    assert isinstance(formdata.evolution[-1].parts[1], ContentSnapshotPart)

    assert isinstance(formdata.evolution[-1].parts[2], AttachmentEvolutionPart)

    assert formdata.evolution[-1].parts[2].orig_filename == upload.orig_filename

    assert isinstance(formdata.evolution[-1].parts[3], JournalEvolutionPart)

    assert len(formdata.evolution[-1].parts[3].content) > 0

    comment_view = str(formdata.evolution[-1].parts[3].view())

    assert len(formdata.evolution[-1].parts) == 2

    assert len(formdata.evolution[-1].parts) == 3

    assert len(formdata.evolution[-1].parts) == 4

    assert len(formdata.evolution[-1].parts) == 5

    assert len(formdata.evolution[-1].parts) == 6

    assert len(formdata.evolution[-1].parts) == 7

    assert len(formdata.evolution[-1].parts) == 9

    assert isinstance(formdata.evolution[-1].parts[0], ContentSnapshotPart)

    with zipfile.ZipFile(formdata.evolution[-1].parts[-1].get_file_path(), mode='r') as zfile:

        with zipfile.ZipFile(formdata.evolution[-1].parts[-1].get_file_path(), mode='r') as zfile:

    with zipfile.ZipFile(formdata.evolution[-1].parts[-1].get_file_path(), mode='r') as zfile:

    with open(formdata.evolution[0].parts[-1].get_file_path(), 'rb') as fd:

    with open(formdata.evolution[0].parts[-1].get_file_path(), 'rb') as fd:

    with open(formdata.evolution[0].parts[-1].get_file_path(), 'rb') as fd:

    with open(formdata.evolution[0].parts[-1].get_file_path(), 'rb') as fd:

        with open(formdata.evolution[0].parts[-1].get_file_path(), 'rb') as fd:

    carddef_wf.add_status('New')

    carddata.just_created()

    carddef_wf.add_status('New')

    carddata.just_created()

        carddata.just_created()

import copy

from wcs.workflows import ContentSnapshotPart

            old_data = copy.deepcopy(self.formdata.data)

            evo = self.formdata.evolution[-1]

            evo.add_part(ContentSnapshotPart(formdata=self.formdata, old_data=old_data))

            self.formdata.store()

        from wcs.workflows import ContentSnapshotPart

        evo.add_part(ContentSnapshotPart(formdata=self, old_data={}))

        from wcs.workflows import ActionsTracingEvolutionPart, ContentSnapshotPart

                x

                for x in self.evolution[-1].parts or []

                if not isinstance(x, (ActionsTracingEvolutionPart, ContentSnapshotPart))

from wcs.workflows import ContentSnapshotPart, Workflow, WorkflowBackofficeFieldsFormDef, WorkflowStatusItem

        old_data = copy.deepcopy(self.edited_data.data)

        evo = self.edited_data.evolution[-1]

        evo.add_part(ContentSnapshotPart(formdata=self.edited_data, old_data=old_data))

import copy

from wcs.workflows import ContentSnapshotPart, WorkflowStatusItem, register_item_class

        old_data = copy.deepcopy(formdata.data)

        evo = formdata.evolution[-1]

        evo.add_part(ContentSnapshotPart(formdata=formdata, old_data=old_data))

        formdata.store()

import copy

import time

from wcs.formdata import Evolution

from wcs.workflows import ContentSnapshotPart, register_item_class

            old_data = copy.deepcopy(target_data.data)

                evo = Evolution()

                evo.time = time.localtime()

                evo.status = target_data.status

                target_data.evolution.append(evo)

                evo.add_part(ContentSnapshotPart(formdata=target_data, old_data=old_data))

import copy

class ContentSnapshotPart(EvolutionPart):

    def __init__(self, formdata, old_data):

        self.formdef_type = formdata.formdef.xml_root_node

        self.formdef_id = formdata.formdef.id

        self.old_data = old_data

        self.new_data = copy.deepcopy(formdata.data)