0001-misc-split-workflow-tests.patch
tests/workflow/test_all.py | ||
---|---|---|
4477 | 4477 |
assert rsps.calls[-1].request.body == '{"bar": "2020-01-01"}' |
4478 | 4478 | |
4479 | 4479 | |
4480 |
def test_set_backoffice_field(http_requests, pub): |
|
4481 |
Workflow.wipe() |
|
4482 |
FormDef.wipe() |
|
4483 |
wf = Workflow(name='xxx') |
|
4484 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
4485 |
wf.backoffice_fields_formdef.fields = [ |
|
4486 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
4487 |
] |
|
4488 |
st1 = wf.add_status('Status1') |
|
4489 |
wf.store() |
|
4490 | ||
4491 |
formdef = FormDef() |
|
4492 |
formdef.name = 'baz' |
|
4493 |
formdef.fields = [ |
|
4494 |
StringField(id='00', label='String', type='string', varname='string'), |
|
4495 |
StringField(id='01', label='Other string', type='string', varname='other'), |
|
4496 |
] |
|
4497 |
formdef.workflow_id = wf.id |
|
4498 |
formdef.store() |
|
4499 | ||
4500 |
formdata = formdef.data_class()() |
|
4501 |
formdata.data = {'00': 'HELLO'} |
|
4502 |
formdata.just_created() |
|
4503 |
formdata.store() |
|
4504 |
pub.substitutions.feed(formdata) |
|
4505 | ||
4506 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4507 |
item.parent = st1 |
|
4508 | ||
4509 |
assert item.render_as_line() == 'Backoffice Data' |
|
4510 |
assert item.get_jump_label('plop') == 'Backoffice Data' |
|
4511 |
item.label = 'label' |
|
4512 |
assert item.render_as_line() == 'Backoffice Data (label)' |
|
4513 |
assert item.get_jump_label('plop') == 'Backoffice Data "label"' |
|
4514 | ||
4515 |
item.perform(formdata) |
|
4516 |
formdata = formdef.data_class().get(formdata.id) |
|
4517 |
assert formdata.data.get('bo1') is None |
|
4518 | ||
4519 |
item.fields = [{'field_id': 'bo1', 'value': '=form_var_string'}] |
|
4520 |
item.perform(formdata) |
|
4521 |
formdata = formdef.data_class().get(formdata.id) |
|
4522 |
assert formdata.data['bo1'] == 'HELLO' |
|
4523 | ||
4524 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_string }} WORLD'}] |
|
4525 |
item.perform(formdata) |
|
4526 |
formdata = formdef.data_class().get(formdata.id) |
|
4527 |
assert formdata.data['bo1'] == 'HELLO WORLD' |
|
4528 | ||
4529 |
item.fields = [{'field_id': 'bo1', 'value': '[form_var_string] GOODBYE'}] |
|
4530 |
item.perform(formdata) |
|
4531 |
formdata = formdef.data_class().get(formdata.id) |
|
4532 |
assert formdata.data['bo1'] == 'HELLO GOODBYE' |
|
4533 | ||
4534 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form.var.string }} LAZY'}] |
|
4535 |
item.perform(formdata) |
|
4536 |
formdata = formdef.data_class().get(formdata.id) |
|
4537 |
assert formdata.data['bo1'] == 'HELLO LAZY' |
|
4538 | ||
4539 |
item.fields = [{'field_id': 'bo1', 'value': '=form.var.string'}] # lazy python |
|
4540 |
item.perform(formdata) |
|
4541 |
formdata = formdef.data_class().get(formdata.id) |
|
4542 |
assert formdata.data['bo1'] == 'HELLO' |
|
4543 | ||
4544 |
item.fields = [{'field_id': 'bo1', 'value': '=vars().get("form_var_string") + " PLOP"'}] |
|
4545 |
item.perform(formdata) |
|
4546 |
formdata = formdef.data_class().get(formdata.id) |
|
4547 |
assert formdata.data['bo1'] == 'HELLO PLOP' |
|
4548 | ||
4549 |
item.fields = [ |
|
4550 |
{'field_id': 'bo1', 'value': '=vars().get("form_var_other") or vars().get("form_var_string")'} |
|
4551 |
] |
|
4552 |
item.perform(formdata) |
|
4553 |
formdata = formdef.data_class().get(formdata.id) |
|
4554 |
assert formdata.data['bo1'] == 'HELLO' |
|
4555 | ||
4556 |
item.fields = [{'field_id': 'bo1', 'value': '=vars().get("form_var_bouh", "X") + " PLOP"'}] |
|
4557 |
item.perform(formdata) |
|
4558 |
formdata = formdef.data_class().get(formdata.id) |
|
4559 |
assert formdata.data['bo1'] == 'X PLOP' |
|
4560 | ||
4561 |
item.fields = [{'field_id': 'bo1', 'value': None}] |
|
4562 |
item.perform(formdata) |
|
4563 |
formdata = formdef.data_class().get(formdata.id) |
|
4564 |
assert formdata.data['bo1'] is None |
|
4565 | ||
4566 |
item.fields = [{'field_id': 'bo1', 'value': ''}] |
|
4567 |
item.perform(formdata) |
|
4568 |
formdata = formdef.data_class().get(formdata.id) |
|
4569 |
assert formdata.data['bo1'] is None |
|
4570 | ||
4571 |
# check a value computed as the empty string is stored as an empty string, not None |
|
4572 |
item.fields = [{'field_id': 'bo1', 'value': '=""'}] |
|
4573 |
item.perform(formdata) |
|
4574 |
formdata = formdef.data_class().get(formdata.id) |
|
4575 |
assert formdata.data['bo1'] == '' |
|
4576 |
item.fields = [{'field_id': 'bo1', 'value': '{{ does_not_exist }}'}] |
|
4577 |
item.perform(formdata) |
|
4578 |
formdata = formdef.data_class().get(formdata.id) |
|
4579 |
assert formdata.data['bo1'] == '' |
|
4580 | ||
4581 |
assert pub.loggederror_class.count() == 0 |
|
4582 | ||
4583 |
item.fields = [{'field_id': 'bo1', 'value': '= ~ invalid python ~'}] |
|
4584 |
item.perform(formdata) |
|
4585 |
formdata = formdef.data_class().get(formdata.id) |
|
4586 |
assert pub.loggederror_class.count() == 1 |
|
4587 |
logged_error = pub.loggederror_class.select()[0] |
|
4588 |
assert logged_error.summary == 'Failed to compute Python expression' |
|
4589 |
assert logged_error.formdata_id == str(formdata.id) |
|
4590 |
assert logged_error.expression == ' ~ invalid python ~' |
|
4591 |
assert logged_error.expression_type == 'python' |
|
4592 |
assert logged_error.exception_class == 'SyntaxError' |
|
4593 |
assert logged_error.exception_message == 'invalid syntax (<string>, line 1)' |
|
4594 | ||
4595 |
pub.loggederror_class.wipe() |
|
4596 |
item.fields = [{'field_id': 'bo1', 'value': '{% if bad django %}'}] |
|
4597 |
item.perform(formdata) |
|
4598 |
formdata = formdef.data_class().get(formdata.id) |
|
4599 |
assert pub.loggederror_class.count() == 1 |
|
4600 |
logged_error = pub.loggederror_class.select()[0] |
|
4601 |
assert logged_error.summary == 'Failed to compute template' |
|
4602 |
assert logged_error.formdata_id == str(formdata.id) |
|
4603 |
assert logged_error.expression == '{% if bad django %}' |
|
4604 |
assert logged_error.expression_type == 'template' |
|
4605 |
assert logged_error.exception_class == 'TemplateError' |
|
4606 |
assert logged_error.exception_message.startswith('syntax error in Django template') |
|
4607 | ||
4608 | ||
4609 |
def test_set_backoffice_field_map(http_requests, pub): |
|
4610 |
Workflow.wipe() |
|
4611 |
FormDef.wipe() |
|
4612 |
wf = Workflow(name='xxx') |
|
4613 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
4614 |
wf.backoffice_fields_formdef.fields = [ |
|
4615 |
MapField(id='bo1', label='1st backoffice field', type='map', varname='backoffice_blah'), |
|
4616 |
] |
|
4617 |
st1 = wf.add_status('Status1') |
|
4618 |
wf.store() |
|
4619 | ||
4620 |
formdef = FormDef() |
|
4621 |
formdef.name = 'baz' |
|
4622 |
formdef.fields = [ |
|
4623 |
MapField(id='1', label='Map1', type='map', varname='map1'), |
|
4624 |
MapField(id='2', label='Map2', type='map', varname='map2'), |
|
4625 |
] |
|
4626 |
formdef.workflow_id = wf.id |
|
4627 |
formdef.store() |
|
4628 | ||
4629 |
formdata = formdef.data_class()() |
|
4630 |
formdata.data = {'1': '42;10', '2': None} |
|
4631 |
formdata.just_created() |
|
4632 |
formdata.store() |
|
4633 |
pub.substitutions.feed(formdata) |
|
4634 | ||
4635 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4636 |
item.parent = st1 |
|
4637 | ||
4638 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_map1|default:"" }}'}] |
|
4639 |
item.perform(formdata) |
|
4640 |
formdata = formdef.data_class().get(formdata.id) |
|
4641 |
assert formdata.data.get('bo1') == '42;10' |
|
4642 | ||
4643 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_map2|default:"" }}'}] |
|
4644 |
item.perform(formdata) |
|
4645 |
formdata = formdef.data_class().get(formdata.id) |
|
4646 |
assert formdata.data.get('bo1') is None |
|
4647 | ||
4648 |
assert pub.loggederror_class.count() == 0 |
|
4649 | ||
4650 |
item.fields = [{'field_id': 'bo1', 'value': 'invalid value'}] |
|
4651 |
item.perform(formdata) |
|
4652 |
formdata = formdef.data_class().get(formdata.id) |
|
4653 |
assert pub.loggederror_class.count() == 1 |
|
4654 |
logged_error = pub.loggederror_class.select()[0] |
|
4655 |
assert ( |
|
4656 |
logged_error.summary |
|
4657 |
== "Failed to set Map field (bo1), error: invalid coordinates 'invalid value' (missing ;)" |
|
4658 |
) |
|
4659 |
assert logged_error.formdata_id == str(formdata.id) |
|
4660 |
assert logged_error.exception_class == 'SetValueError' |
|
4661 |
assert logged_error.exception_message == "invalid coordinates 'invalid value' (missing ;)" |
|
4662 |
pub.loggederror_class.wipe() |
|
4663 | ||
4664 |
item.fields = [{'field_id': 'bo1', 'value': 'XXX;YYY'}] |
|
4665 |
item.perform(formdata) |
|
4666 |
formdata = formdef.data_class().get(formdata.id) |
|
4667 |
assert pub.loggederror_class.count() == 1 |
|
4668 |
logged_error = pub.loggederror_class.select()[0] |
|
4669 |
assert logged_error.summary == "Failed to set Map field (bo1), error: invalid coordinates 'XXX;YYY'" |
|
4670 |
assert logged_error.formdata_id == str(formdata.id) |
|
4671 |
assert logged_error.exception_class == 'SetValueError' |
|
4672 |
assert logged_error.exception_message == "invalid coordinates 'XXX;YYY'" |
|
4673 |
pub.loggederror_class.wipe() |
|
4674 | ||
4675 | ||
4676 |
def test_set_backoffice_field_decimal(http_requests, pub): |
|
4677 |
Workflow.wipe() |
|
4678 |
FormDef.wipe() |
|
4679 |
wf = Workflow(name='xxx') |
|
4680 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
4681 |
wf.backoffice_fields_formdef.fields = [ |
|
4682 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
4683 |
] |
|
4684 |
st1 = wf.add_status('Status1') |
|
4685 |
wf.store() |
|
4686 | ||
4687 |
formdef = FormDef() |
|
4688 |
formdef.name = 'baz' |
|
4689 |
formdef.fields = [ |
|
4690 |
StringField(id='1', label='String', type='string', varname='string'), |
|
4691 |
] |
|
4692 |
formdef.workflow_id = wf.id |
|
4693 |
formdef.store() |
|
4694 | ||
4695 |
formdata = formdef.data_class()() |
|
4696 |
formdata.data = {'1': '1000'} |
|
4697 |
formdata.just_created() |
|
4698 |
formdata.store() |
|
4699 |
pub.substitutions.feed(formdata) |
|
4700 | ||
4701 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4702 |
item.parent = st1 |
|
4703 |
item.fields = [{'field_id': 'bo1', 'value': '{{ "100"|decimal }}'}] |
|
4704 |
item.perform(formdata) |
|
4705 |
assert formdef.data_class().get(formdata.id).data['bo1'] == '100' |
|
4706 | ||
4707 |
formdata.store() # reset |
|
4708 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_string|decimal }}'}] |
|
4709 |
item.perform(formdata) |
|
4710 |
assert formdef.data_class().get(formdata.id).data['bo1'] == '1000' |
|
4711 | ||
4712 | ||
4713 |
def test_set_backoffice_field_file(http_requests, pub): |
|
4714 |
Workflow.wipe() |
|
4715 |
FormDef.wipe() |
|
4716 |
wf = Workflow(name='xxx') |
|
4717 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
4718 |
wf.backoffice_fields_formdef.fields = [ |
|
4719 |
FileField(id='bo1', label='1st backoffice field', type='file', varname='backoffice_file'), |
|
4720 |
StringField(id='bo2', label='2nd backoffice field', type='string'), |
|
4721 |
] |
|
4722 |
st1 = wf.add_status('Status1') |
|
4723 |
wf.store() |
|
4724 | ||
4725 |
formdef = FormDef() |
|
4726 |
formdef.name = 'baz' |
|
4727 |
formdef.fields = [ |
|
4728 |
FileField(id='00', label='File', type='file', varname='file'), |
|
4729 |
] |
|
4730 |
formdef.workflow_id = wf.id |
|
4731 |
formdef.store() |
|
4732 | ||
4733 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4734 |
item.parent = st1 |
|
4735 |
item.fields = [{'field_id': 'bo1', 'value': '=locals().get("form_var_file_raw")'}] |
|
4736 | ||
4737 |
# the file does not exist |
|
4738 |
formdata = formdef.data_class()() |
|
4739 |
formdata.data = {} |
|
4740 |
formdata.just_created() |
|
4741 |
formdata.store() |
|
4742 |
pub.substitutions.feed(formdata) |
|
4743 |
item.perform(formdata) |
|
4744 |
formdata = formdef.data_class().get(formdata.id) |
|
4745 |
assert formdata.data['bo1'] is None |
|
4746 | ||
4747 |
# store a PiclableUpload |
|
4748 |
upload = PicklableUpload('test.jpeg', 'image/jpeg') |
|
4749 |
with open(os.path.join(os.path.dirname(__file__), '..', 'image-with-gps-data.jpeg'), 'rb') as fd: |
|
4750 |
image_with_gps_data = fd.read() |
|
4751 |
upload.receive([image_with_gps_data]) |
|
4752 | ||
4753 |
formdata = formdef.data_class()() |
|
4754 |
formdata.data = {'00': upload} |
|
4755 |
formdata.just_created() |
|
4756 |
formdata.store() |
|
4757 | ||
4758 |
pub.substitutions.feed(formdata) |
|
4759 |
item.perform(formdata) |
|
4760 | ||
4761 |
formdata = formdef.data_class().get(formdata.id) |
|
4762 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
4763 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4764 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
4765 |
assert formdata.data['bo1'].get_base64_content() == base64.encodebytes(image_with_gps_data) |
|
4766 | ||
4767 |
# check with template string |
|
4768 |
formdata = formdef.data_class()() |
|
4769 |
formdata.data = {'00': upload} |
|
4770 |
formdata.just_created() |
|
4771 |
formdata.store() |
|
4772 | ||
4773 |
pub.substitutions.feed(formdata) |
|
4774 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file_raw}}'}] |
|
4775 |
item.perform(formdata) |
|
4776 | ||
4777 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
4778 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4779 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
4780 | ||
4781 |
# check with template string, without _raw |
|
4782 |
formdata = formdef.data_class()() |
|
4783 |
formdata.data = {'00': upload} |
|
4784 |
formdata.just_created() |
|
4785 |
formdata.store() |
|
4786 | ||
4787 |
pub.substitutions.feed(formdata) |
|
4788 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file}}'}] |
|
4789 |
item.perform(formdata) |
|
4790 | ||
4791 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
4792 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4793 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
4794 | ||
4795 |
# check |strip_metadata filter |
|
4796 |
formdata = formdef.data_class()() |
|
4797 |
formdata.data = {'00': upload} |
|
4798 |
formdata.just_created() |
|
4799 |
formdata.store() |
|
4800 | ||
4801 |
pub.substitutions.feed(formdata) |
|
4802 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|strip_metadata}}'}] |
|
4803 |
item.perform(formdata) |
|
4804 | ||
4805 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
4806 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4807 |
assert b'JFIF' in formdata.data['bo1'].get_content() |
|
4808 |
assert b'<exif:XResolution>' not in formdata.data['bo1'].get_content() |
|
4809 | ||
4810 |
# check |rename_file filter |
|
4811 |
formdata = formdef.data_class()() |
|
4812 |
formdata.data = {'00': upload} |
|
4813 |
formdata.just_created() |
|
4814 |
formdata.store() |
|
4815 | ||
4816 |
pub.substitutions.feed(formdata) |
|
4817 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|rename_file:"foobar.jpeg"}}'}] |
|
4818 |
item.perform(formdata) |
|
4819 | ||
4820 |
assert formdata.data['bo1'].base_filename == 'foobar.jpeg' |
|
4821 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4822 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
4823 | ||
4824 |
formdata = formdef.data_class()() |
|
4825 |
formdata.data = {'00': upload} |
|
4826 |
formdata.just_created() |
|
4827 |
formdata.store() |
|
4828 | ||
4829 |
pub.substitutions.feed(formdata) |
|
4830 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|rename_file:"foobar.$ext"}}'}] |
|
4831 |
item.perform(formdata) |
|
4832 | ||
4833 |
assert formdata.data['bo1'].base_filename == 'foobar.jpeg' |
|
4834 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
4835 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
4836 | ||
4837 |
# check |rename_file with invalid input |
|
4838 |
formdata = formdef.data_class()() |
|
4839 |
formdata.data = {'00': upload} |
|
4840 |
formdata.just_created() |
|
4841 |
formdata.store() |
|
4842 | ||
4843 |
pub.substitutions.feed(formdata) |
|
4844 | ||
4845 |
item.fields = [{'field_id': 'bo1', 'value': '{{"xxx"|rename_file:"foobar.jpeg"}}'}] |
|
4846 |
item.perform(formdata) |
|
4847 | ||
4848 |
assert 'bo1' not in formdata.data |
|
4849 | ||
4850 |
# check with a template string, into a string field |
|
4851 |
pub.substitutions.feed(formdata) |
|
4852 |
item.fields = [{'field_id': 'bo2', 'value': '{{form_var_file}}'}] |
|
4853 |
item.perform(formdata) |
|
4854 | ||
4855 |
assert formdata.data['bo2'] == 'test.jpeg' |
|
4856 | ||
4857 |
# check with template string and missing file |
|
4858 |
formdata = formdef.data_class()() |
|
4859 |
formdata.data = {'00': None} |
|
4860 |
formdata.just_created() |
|
4861 |
formdata.store() |
|
4862 | ||
4863 |
assert formdata.data.get('bo1') is None |
|
4864 | ||
4865 |
# check stripping metadata |
|
4866 |
pub.substitutions.feed(formdata) |
|
4867 |
item.fields = [ |
|
4868 |
{ |
|
4869 |
'field_id': 'bo1', |
|
4870 |
'value': '=utils.attachment(form_var_file_raw,' |
|
4871 |
+ ' filename="new_"+form_var_file,' |
|
4872 |
+ ' content_type="my content type",' |
|
4873 |
+ ' strip_metadata=True)', |
|
4874 |
} |
|
4875 |
] |
|
4876 |
formdata = formdef.data_class()() |
|
4877 |
formdata.data = {'00': upload} |
|
4878 |
formdata.just_created() |
|
4879 |
formdata.store() |
|
4880 |
pub.substitutions.feed(formdata) |
|
4881 |
item.perform(formdata) |
|
4882 |
formdata = formdef.data_class().get(formdata.id) |
|
4883 |
assert formdata.data['bo1'].base_filename == 'new_test.jpeg' |
|
4884 |
assert formdata.data['bo1'].content_type == 'my content type' |
|
4885 |
assert formdata.data['bo1'].qfilename != formdata.data['00'].qfilename |
|
4886 |
assert formdata.data['00'].get_content().find(b'<exif:XResolution>') |
|
4887 |
assert not Image or formdata.data['bo1'].get_content().find(b'<exif:XResolution>') == -1 |
|
4888 | ||
4889 |
upload2 = PicklableUpload('test2.odt', 'application/vnd.oasis.opendocument.text') |
|
4890 |
with open(os.path.join(os.path.dirname(__file__), '..', 'template.odt'), 'rb') as fd: |
|
4891 |
template_odt = fd.read() |
|
4892 |
upload2.receive([template_odt]) |
|
4893 |
formdata = formdef.data_class()() |
|
4894 |
formdata.data = {'00': upload2} |
|
4895 |
formdata.just_created() |
|
4896 |
formdata.store() |
|
4897 |
pub.substitutions.feed(formdata) |
|
4898 |
item.perform(formdata) |
|
4899 |
formdata = formdef.data_class().get(formdata.id) |
|
4900 |
assert formdata.data['bo1'].base_filename == 'new_test2.odt' |
|
4901 |
assert formdata.data['bo1'].content_type == 'my content type' |
|
4902 |
assert formdata.data['bo1'].get_content() == template_odt |
|
4903 |
assert formdata.data['bo1'].qfilename == formdata.data['00'].qfilename |
|
4904 | ||
4905 |
# check storing response as attachment |
|
4906 |
pub.substitutions.feed(formdata) |
|
4907 |
item = WebserviceCallStatusItem() |
|
4908 |
item.url = 'http://remote.example.net/xml' |
|
4909 |
item.varname = 'xxx' |
|
4910 |
item.response_type = 'attachment' |
|
4911 |
item.record_errors = True |
|
4912 |
item.perform(formdata) |
|
4913 |
attachment = formdata.evolution[-1].parts[-1] |
|
4914 |
assert isinstance(attachment, AttachmentEvolutionPart) |
|
4915 |
assert attachment.base_filename == 'xxx.xml' |
|
4916 |
assert attachment.content_type == 'text/xml' |
|
4917 | ||
4918 |
formdata = formdef.data_class().get(formdata.id) |
|
4919 |
pub.substitutions.feed(formdata) |
|
4920 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4921 |
item.parent = st1 |
|
4922 |
item.fields = [{'field_id': 'bo1', 'value': '=attachments.xxx'}] |
|
4923 |
item.perform(formdata) |
|
4924 | ||
4925 |
formdata = formdef.data_class().get(formdata.id) |
|
4926 |
assert formdata.data['bo1'].base_filename == 'xxx.xml' |
|
4927 | ||
4928 |
# check storing a file from an assembled dictionary |
|
4929 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4930 |
item.parent = st1 |
|
4931 |
item.fields = [{'field_id': 'bo1', 'value': '={"content": "hello world", "filename": "hello.txt"}'}] |
|
4932 |
item.perform(formdata) |
|
4933 | ||
4934 |
formdata = formdef.data_class().get(formdata.id) |
|
4935 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
4936 |
assert formdata.data['bo1'].get_content() == b'hello world' |
|
4937 | ||
4938 |
# check resetting a value |
|
4939 |
for value in ('', None): |
|
4940 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4941 |
item.parent = st1 |
|
4942 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
4943 |
item.perform(formdata) |
|
4944 | ||
4945 |
formdata = formdef.data_class().get(formdata.id) |
|
4946 |
assert formdata.data['bo1'] is None |
|
4947 | ||
4948 |
# set from base64 content |
|
4949 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4950 |
item.parent = st1 |
|
4951 |
item.fields = [ |
|
4952 |
{'field_id': 'bo1', 'value': '={"b64_content": "SEVMTE8gV09STEQ=", "filename": "hello.txt"}'} |
|
4953 |
] |
|
4954 |
item.perform(formdata) |
|
4955 | ||
4956 |
formdata = formdef.data_class().get(formdata.id) |
|
4957 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
4958 |
assert formdata.data['bo1'].get_content() == b'HELLO WORLD' |
|
4959 | ||
4960 |
hello_world = formdata.data['bo1'] |
|
4961 |
# check wrong value |
|
4962 |
for value in ('="HELLO"', 'BAD'): |
|
4963 |
formdata.data['bo1'] = hello_world |
|
4964 |
formdata.store() |
|
4965 | ||
4966 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4967 |
item.parent = st1 |
|
4968 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
4969 | ||
4970 |
pub.loggederror_class.wipe() |
|
4971 |
item.perform(formdata) |
|
4972 | ||
4973 |
formdata = formdef.data_class().get(formdata.id) |
|
4974 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
4975 |
assert formdata.data['bo1'].get_content() == b'HELLO WORLD' |
|
4976 |
assert pub.loggederror_class.count() == 1 |
|
4977 |
logged_error = pub.loggederror_class.select()[0] |
|
4978 |
assert logged_error.summary.startswith('Failed to convert') |
|
4979 |
assert logged_error.formdata_id == str(formdata.id) |
|
4980 |
assert logged_error.exception_class == 'ValueError' |
|
4981 | ||
4982 |
# check wrong field |
|
4983 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
4984 |
item.parent = st1 |
|
4985 |
item.fields = [{'field_id': 'bo3', 'value': '=form_var_file_raw'}] |
|
4986 |
item.perform(formdata) |
|
4987 | ||
4988 |
formdata = formdef.data_class().get(formdata.id) |
|
4989 |
assert formdata.data.get('bo3') is None |
|
4990 | ||
4991 | ||
4992 |
def test_set_backoffice_field_item(pub): |
|
4993 |
Workflow.wipe() |
|
4994 |
FormDef.wipe() |
|
4995 |
wf = Workflow(name='xxx') |
|
4996 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
4997 |
st1 = wf.add_status('Status1') |
|
4998 |
wf.backoffice_fields_formdef.fields = [ |
|
4999 |
ItemField( |
|
5000 |
id='bo1', |
|
5001 |
label='1st backoffice field', |
|
5002 |
type='item', |
|
5003 |
varname='backoffice_item', |
|
5004 |
items=['a', 'b', 'c'], |
|
5005 |
), |
|
5006 |
] |
|
5007 |
wf.store() |
|
5008 | ||
5009 |
formdef = FormDef() |
|
5010 |
formdef.name = 'baz' |
|
5011 |
formdef.fields = [] |
|
5012 |
formdef.workflow_id = wf.id |
|
5013 |
formdef.store() |
|
5014 | ||
5015 |
formdata = formdef.data_class()() |
|
5016 |
formdata.data = {} |
|
5017 |
formdata.just_created() |
|
5018 |
formdata.store() |
|
5019 | ||
5020 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5021 |
item.parent = st1 |
|
5022 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
5023 |
item.perform(formdata) |
|
5024 | ||
5025 |
formdata = formdef.data_class().get(formdata.id) |
|
5026 |
assert formdata.data['bo1'] == 'a' |
|
5027 |
assert formdata.data['bo1_display'] == 'a' |
|
5028 | ||
5029 |
datasource = {'type': 'formula', 'value': repr([('a', 'aa'), ('b', 'bb'), ('c', 'cc')])} |
|
5030 | ||
5031 |
wf.backoffice_fields_formdef.fields = [ |
|
5032 |
ItemField( |
|
5033 |
id='bo1', |
|
5034 |
label='1st backoffice field', |
|
5035 |
type='item', |
|
5036 |
varname='backoffice_item', |
|
5037 |
data_source=datasource, |
|
5038 |
), |
|
5039 |
] |
|
5040 |
wf.store() |
|
5041 | ||
5042 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5043 |
item.parent = st1 |
|
5044 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
5045 |
item.perform(formdata) |
|
5046 | ||
5047 |
formdata = formdef.data_class().get(formdata.id) |
|
5048 |
assert formdata.data['bo1'] == 'a' |
|
5049 |
assert formdata.data['bo1_display'] == 'aa' |
|
5050 | ||
5051 |
datasource = { |
|
5052 |
'type': 'formula', |
|
5053 |
'value': repr([{'id': 'a', 'text': 'aa', 'more': 'aaa'}, {'id': 'b', 'text': 'bb', 'more': 'bbb'}]), |
|
5054 |
} |
|
5055 | ||
5056 |
wf.backoffice_fields_formdef.fields = [ |
|
5057 |
ItemField( |
|
5058 |
id='bo1', |
|
5059 |
label='1st backoffice field', |
|
5060 |
type='item', |
|
5061 |
varname='backoffice_item', |
|
5062 |
data_source=datasource, |
|
5063 |
), |
|
5064 |
] |
|
5065 |
wf.store() |
|
5066 | ||
5067 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5068 |
item.parent = st1 |
|
5069 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
5070 |
item.perform(formdata) |
|
5071 | ||
5072 |
formdata = formdef.data_class().get(formdata.id) |
|
5073 |
assert formdata.data['bo1'] == 'a' |
|
5074 |
assert formdata.data['bo1_display'] == 'aa' |
|
5075 |
assert formdata.data['bo1_structured'] == {'id': 'a', 'more': 'aaa', 'text': 'aa'} |
|
5076 | ||
5077 |
# check when assigning using the display value |
|
5078 |
formdata = formdef.data_class()() |
|
5079 |
formdata.data = {} |
|
5080 |
formdata.just_created() |
|
5081 |
formdata.store() |
|
5082 | ||
5083 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5084 |
item.parent = st1 |
|
5085 |
item.fields = [{'field_id': 'bo1', 'value': 'aa'}] |
|
5086 |
item.perform(formdata) |
|
5087 | ||
5088 |
formdata = formdef.data_class().get(formdata.id) |
|
5089 |
assert formdata.data['bo1'] == 'a' |
|
5090 |
assert formdata.data['bo1_display'] == 'aa' |
|
5091 |
assert formdata.data['bo1_structured'] == {'id': 'a', 'more': 'aaa', 'text': 'aa'} |
|
5092 | ||
5093 |
# check with unknown value |
|
5094 |
formdata = formdef.data_class()() |
|
5095 |
formdata.data = {} |
|
5096 |
formdata.just_created() |
|
5097 |
formdata.store() |
|
5098 | ||
5099 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5100 |
item.parent = st1 |
|
5101 |
item.fields = [{'field_id': 'bo1', 'value': 'foobar'}] |
|
5102 |
item.perform(formdata) |
|
5103 | ||
5104 |
formdata = formdef.data_class().get(formdata.id) |
|
5105 |
assert formdata.data['bo1'] == 'foobar' |
|
5106 |
assert formdata.data.get('bo1_display') is None |
|
5107 |
assert formdata.data.get('bo1_structured') is None |
|
5108 | ||
5109 | ||
5110 |
def test_set_backoffice_field_card_item(pub): |
|
5111 |
CardDef.wipe() |
|
5112 |
Workflow.wipe() |
|
5113 |
FormDef.wipe() |
|
5114 | ||
5115 |
carddef = CardDef() |
|
5116 |
carddef.name = 'items' |
|
5117 |
carddef.digest_templates = {'default': '{{form_var_name}}'} |
|
5118 |
carddef.fields = [ |
|
5119 |
StringField(id='0', label='string', varname='name'), |
|
5120 |
StringField(id='1', label='string', varname='attr'), |
|
5121 |
] |
|
5122 |
carddef.store() |
|
5123 |
carddef.data_class().wipe() |
|
5124 |
for i, value in enumerate(['foo', 'bar', 'baz']): |
|
5125 |
carddata = carddef.data_class()() |
|
5126 |
carddata.data = { |
|
5127 |
'0': value, |
|
5128 |
'1': 'attr%s' % i, |
|
5129 |
} |
|
5130 |
carddata.just_created() |
|
5131 |
carddata.store() |
|
5132 |
latest_carddata = carddata |
|
5133 |
latest_carddata_id = carddata.id |
|
5134 |
ds = {'type': 'carddef:%s' % carddef.url_name} |
|
5135 | ||
5136 |
wf = Workflow(name='xxx') |
|
5137 |
wf.store() |
|
5138 | ||
5139 |
formdef = FormDef() |
|
5140 |
formdef.name = 'baz' |
|
5141 |
formdef.workflow_id = wf.id |
|
5142 |
formdef.fields = [ |
|
5143 |
ItemField(id='0', label='string', type='item', data_source=ds, display_disabled_items=True) |
|
5144 |
] |
|
5145 |
formdef.store() |
|
5146 | ||
5147 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5148 |
st1 = wf.add_status('Status1') |
|
5149 |
wf.backoffice_fields_formdef.fields = [ |
|
5150 |
ItemField( |
|
5151 |
id='bo1', label='1st backoffice field', type='item', varname='backoffice_item', data_source=ds |
|
5152 |
), |
|
5153 |
] |
|
5154 |
wf.store() |
|
5155 | ||
5156 |
formdef = FormDef() |
|
5157 |
formdef.name = 'baz' |
|
5158 |
formdef.fields = [] |
|
5159 |
formdef.workflow_id = wf.id |
|
5160 |
formdef.store() |
|
5161 | ||
5162 |
formdata = formdef.data_class()() |
|
5163 |
formdata.data = {} |
|
5164 |
formdata.just_created() |
|
5165 |
formdata.store() |
|
5166 | ||
5167 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5168 |
item.parent = st1 |
|
5169 |
item.fields = [{'field_id': 'bo1', 'value': str(latest_carddata_id)}] |
|
5170 |
item.perform(formdata) |
|
5171 | ||
5172 |
formdata = formdef.data_class().get(formdata.id) |
|
5173 |
assert formdata.data['bo1'] == str(latest_carddata_id) |
|
5174 |
assert formdata.data['bo1_display'] == 'baz' |
|
5175 |
assert formdata.data['bo1_structured']['attr'] == 'attr2' |
|
5176 | ||
5177 |
# reset, and get by display id value |
|
5178 |
formdata.data = {} |
|
5179 |
formdata.store() |
|
5180 |
item.fields = [{'field_id': 'bo1', 'value': latest_carddata.get_display_id()}] |
|
5181 |
item.perform(formdata) |
|
5182 |
formdata = formdef.data_class().get(formdata.id) |
|
5183 |
assert formdata.data['bo1'] == str(latest_carddata_id) |
|
5184 |
assert formdata.data['bo1_display'] == 'baz' |
|
5185 |
assert formdata.data['bo1_structured']['attr'] == 'attr2' |
|
5186 | ||
5187 |
# reset, and get by text value |
|
5188 |
formdata.data = {} |
|
5189 |
formdata.store() |
|
5190 |
item.fields = [{'field_id': 'bo1', 'value': 'bar'}] |
|
5191 |
item.perform(formdata) |
|
5192 |
formdata = formdef.data_class().get(formdata.id) |
|
5193 |
assert formdata.data['bo1'] != str(latest_carddata_id) |
|
5194 |
assert formdata.data['bo1_display'] == 'bar' |
|
5195 |
assert formdata.data['bo1_structured']['attr'] == 'attr1' |
|
5196 | ||
5197 |
# reset, with unknown value |
|
5198 |
pub.loggederror_class.wipe() |
|
5199 |
formdata.data = {} |
|
5200 |
formdata.store() |
|
5201 |
item.fields = [{'field_id': 'bo1', 'value': 'xxx'}] |
|
5202 |
item.perform(formdata) |
|
5203 |
formdata = formdef.data_class().get(formdata.id) |
|
5204 |
assert formdata.data.get('bo1') is None # invalid value is not stored |
|
5205 |
assert formdata.data.get('bo1_display') is None |
|
5206 |
assert formdata.data.get('bo1_structured') is None |
|
5207 |
assert pub.loggederror_class.count() == 1 |
|
5208 |
logged_error = pub.loggederror_class.select()[0] |
|
5209 |
assert logged_error.summary.startswith('Failed to convert') |
|
5210 | ||
5211 |
# reset, and get empty value |
|
5212 |
formdata.data = {} |
|
5213 |
formdata.store() |
|
5214 |
item.fields = [{'field_id': 'bo1', 'value': ''}] |
|
5215 |
item.perform(formdata) |
|
5216 |
formdata = formdef.data_class().get(formdata.id) |
|
5217 |
assert formdata.data['bo1'] is None |
|
5218 |
assert formdata.data.get('bo1_display') is None |
|
5219 |
assert formdata.data.get('bo1_structured') is None |
|
5220 | ||
5221 | ||
5222 |
def test_set_backoffice_field_items(pub): |
|
5223 |
Workflow.wipe() |
|
5224 |
FormDef.wipe() |
|
5225 |
wf = Workflow(name='xxx') |
|
5226 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5227 |
st1 = wf.add_status('Status1') |
|
5228 |
wf.backoffice_fields_formdef.fields = [ |
|
5229 |
ItemsField( |
|
5230 |
id='bo1', |
|
5231 |
label='1st backoffice field', |
|
5232 |
type='items', |
|
5233 |
varname='backoffice_item', |
|
5234 |
items=['a', 'b', 'c'], |
|
5235 |
), |
|
5236 |
] |
|
5237 |
wf.store() |
|
5238 | ||
5239 |
formdef = FormDef() |
|
5240 |
formdef.name = 'baz' |
|
5241 |
formdef.fields = [] |
|
5242 |
formdef.workflow_id = wf.id |
|
5243 |
formdef.store() |
|
5244 | ||
5245 |
formdata = formdef.data_class()() |
|
5246 |
formdata.data = {} |
|
5247 |
formdata.just_created() |
|
5248 |
formdata.store() |
|
5249 | ||
5250 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5251 |
item.parent = st1 |
|
5252 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'b']"}] |
|
5253 |
item.perform(formdata) |
|
5254 | ||
5255 |
formdata = formdef.data_class().get(formdata.id) |
|
5256 |
assert formdata.data['bo1'] == ['a', 'b'] |
|
5257 |
assert formdata.data['bo1_display'] == 'a, b' |
|
5258 | ||
5259 |
datasource = {'type': 'formula', 'value': repr([('a', 'aa'), ('b', 'bb'), ('c', 'cc')])} |
|
5260 | ||
5261 |
wf.backoffice_fields_formdef.fields = [ |
|
5262 |
ItemsField( |
|
5263 |
id='bo1', |
|
5264 |
label='1st backoffice field', |
|
5265 |
type='items', |
|
5266 |
varname='backoffice_item', |
|
5267 |
data_source=datasource, |
|
5268 |
), |
|
5269 |
] |
|
5270 |
wf.store() |
|
5271 | ||
5272 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5273 |
item.parent = st1 |
|
5274 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'b']"}] |
|
5275 |
item.perform(formdata) |
|
5276 | ||
5277 |
formdata = formdef.data_class().get(formdata.id) |
|
5278 |
assert formdata.data['bo1'] == ['a', 'b'] |
|
5279 |
assert formdata.data['bo1_display'] == 'aa, bb' |
|
5280 | ||
5281 |
datasource = { |
|
5282 |
'type': 'formula', |
|
5283 |
'value': repr( |
|
5284 |
[ |
|
5285 |
{'id': 'a', 'text': 'aa', 'more': 'aaa'}, |
|
5286 |
{'id': 'b', 'text': 'bb', 'more': 'bbb'}, |
|
5287 |
{'id': 'c', 'text': 'cc', 'more': 'ccc'}, |
|
5288 |
] |
|
5289 |
), |
|
5290 |
} |
|
5291 | ||
5292 |
wf.backoffice_fields_formdef.fields = [ |
|
5293 |
ItemsField( |
|
5294 |
id='bo1', |
|
5295 |
label='1st backoffice field', |
|
5296 |
type='items', |
|
5297 |
varname='backoffice_item', |
|
5298 |
data_source=datasource, |
|
5299 |
), |
|
5300 |
] |
|
5301 |
wf.store() |
|
5302 | ||
5303 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5304 |
item.parent = st1 |
|
5305 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'c']"}] |
|
5306 |
item.perform(formdata) |
|
5307 | ||
5308 |
formdata = formdef.data_class().get(formdata.id) |
|
5309 |
assert formdata.data['bo1'] == ['a', 'c'] |
|
5310 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
5311 |
assert len(formdata.data['bo1_structured']) == 2 |
|
5312 |
assert {'id': 'a', 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
5313 |
assert {'id': 'c', 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
5314 | ||
5315 |
# from formdata field |
|
5316 |
formdef.fields = [ |
|
5317 |
ItemsField(id='1', label='field', type='items', varname='items', data_source=datasource), |
|
5318 |
] |
|
5319 |
formdef.store() |
|
5320 | ||
5321 |
formdata = formdef.data_class()() |
|
5322 |
formdata.data = {'1': ['a', 'c']} |
|
5323 |
formdata.data['1_display'] = formdef.fields[0].store_display_value(formdata.data, '1') |
|
5324 |
formdata.data['1_structured'] = formdef.fields[0].store_structured_value(formdata.data, '1') |
|
5325 |
formdata.just_created() |
|
5326 |
formdata.store() |
|
5327 |
pub.substitutions.feed(formdata) |
|
5328 | ||
5329 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5330 |
item.parent = st1 |
|
5331 |
item.fields = [{'field_id': 'bo1', 'value': "=form_var_items_raw"}] |
|
5332 |
item.perform(formdata) |
|
5333 | ||
5334 |
assert formdata.data['bo1'] == ['a', 'c'] |
|
5335 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
5336 |
assert len(formdata.data['bo1_structured']) == 2 |
|
5337 |
assert {'id': 'a', 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
5338 |
assert {'id': 'c', 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
5339 | ||
5340 |
# with a template |
|
5341 |
formdata = formdef.data_class()() |
|
5342 |
formdata.data = {'1': ['a', 'c']} |
|
5343 |
formdata.data['1_display'] = formdef.fields[0].store_display_value(formdata.data, '1') |
|
5344 |
formdata.data['1_structured'] = formdef.fields[0].store_structured_value(formdata.data, '1') |
|
5345 |
formdata.just_created() |
|
5346 |
formdata.store() |
|
5347 |
pub.substitutions.reset() |
|
5348 |
pub.substitutions.feed(formdata) |
|
5349 | ||
5350 |
item.fields = [{'field_id': 'bo1', 'value': "{{form_var_items_raw}}"}] |
|
5351 |
item.perform(formdata) |
|
5352 | ||
5353 |
# using a single int |
|
5354 |
datasource = { |
|
5355 |
'type': 'formula', |
|
5356 |
'value': repr( |
|
5357 |
[ |
|
5358 |
{'id': 1, 'text': 'aa', 'more': 'aaa'}, |
|
5359 |
{'id': 2, 'text': 'bb', 'more': 'bbb'}, |
|
5360 |
{'id': 3, 'text': 'cc', 'more': 'ccc'}, |
|
5361 |
] |
|
5362 |
), |
|
5363 |
} |
|
5364 | ||
5365 |
wf.backoffice_fields_formdef.fields = [ |
|
5366 |
ItemsField( |
|
5367 |
id='bo1', |
|
5368 |
label='1st backoffice field', |
|
5369 |
type='items', |
|
5370 |
varname='backoffice_item', |
|
5371 |
data_source=datasource, |
|
5372 |
), |
|
5373 |
] |
|
5374 |
wf.store() |
|
5375 | ||
5376 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5377 |
item.parent = st1 |
|
5378 |
item.fields = [{'field_id': 'bo1', 'value': "=2"}] |
|
5379 |
item.perform(formdata) |
|
5380 | ||
5381 |
formdata = formdef.data_class().get(formdata.id) |
|
5382 |
assert formdata.data['bo1'] == ['2'] |
|
5383 |
assert formdata.data['bo1_display'] == 'bb' |
|
5384 |
assert len(formdata.data['bo1_structured']) == 1 |
|
5385 | ||
5386 |
# using an invalid value |
|
5387 |
formdata.data = {} |
|
5388 |
formdata.store() |
|
5389 |
pub.loggederror_class.wipe() |
|
5390 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5391 |
item.parent = st1 |
|
5392 |
item.fields = [{'field_id': 'bo1', 'value': "=Ellipsis"}] |
|
5393 |
item.perform(formdata) |
|
5394 |
assert pub.loggederror_class.count() == 1 |
|
5395 |
logged_error = pub.loggederror_class.select()[0] |
|
5396 |
assert 'Failed to convert' in logged_error.summary |
|
5397 | ||
5398 |
# using a string with multiple values |
|
5399 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5400 |
item.parent = st1 |
|
5401 |
item.fields = [{'field_id': 'bo1', 'value': "1|3"}] |
|
5402 |
item.perform(formdata) |
|
5403 | ||
5404 |
formdata = formdef.data_class().get(formdata.id) |
|
5405 |
assert formdata.data['bo1'] == ['1', '3'] |
|
5406 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
5407 |
assert len(formdata.data['bo1_structured']) == 2 |
|
5408 |
assert {'id': 1, 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
5409 |
assert {'id': 3, 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
5410 | ||
5411 | ||
5412 |
def test_set_backoffice_field_date(pub): |
|
5413 |
Workflow.wipe() |
|
5414 |
FormDef.wipe() |
|
5415 |
wf = Workflow(name='xxx') |
|
5416 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5417 |
st1 = wf.add_status('Status1') |
|
5418 |
wf.backoffice_fields_formdef.fields = [ |
|
5419 |
DateField(id='bo1', label='1st backoffice field', type='date', varname='backoffice_date'), |
|
5420 |
] |
|
5421 |
wf.store() |
|
5422 | ||
5423 |
formdef = FormDef() |
|
5424 |
formdef.name = 'baz' |
|
5425 |
formdef.fields = [] |
|
5426 |
formdef.workflow_id = wf.id |
|
5427 |
formdef.store() |
|
5428 | ||
5429 |
formdata = formdef.data_class()() |
|
5430 |
formdata.data = {} |
|
5431 |
formdata.just_created() |
|
5432 |
formdata.store() |
|
5433 | ||
5434 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5435 |
item.parent = st1 |
|
5436 |
item.fields = [{'field_id': 'bo1', 'value': "=utils.today()"}] |
|
5437 |
item.perform(formdata) |
|
5438 | ||
5439 |
formdata = formdef.data_class().get(formdata.id) |
|
5440 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date.today() |
|
5441 | ||
5442 |
formdata.data['bo1'] = None |
|
5443 |
formdata.store() |
|
5444 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5445 |
item.parent = st1 |
|
5446 |
item.fields = [{'field_id': 'bo1', 'value': '{% now "j/n/Y" %}'}] |
|
5447 |
item.perform(formdata) |
|
5448 | ||
5449 |
formdata = formdef.data_class().get(formdata.id) |
|
5450 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date.today() |
|
5451 | ||
5452 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5453 |
item.parent = st1 |
|
5454 |
item.fields = [{'field_id': 'bo1', 'value': "23/3/2017"}] |
|
5455 |
item.perform(formdata) |
|
5456 | ||
5457 |
formdata = formdef.data_class().get(formdata.id) |
|
5458 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23) |
|
5459 | ||
5460 |
# invalid values => do nothing |
|
5461 |
assert pub.loggederror_class.count() == 0 |
|
5462 |
for value in ('plop', '={}', '=[]'): |
|
5463 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5464 |
item.parent = st1 |
|
5465 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
5466 | ||
5467 |
pub.loggederror_class.wipe() |
|
5468 |
item.perform(formdata) |
|
5469 |
formdata = formdef.data_class().get(formdata.id) |
|
5470 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23) |
|
5471 |
assert pub.loggederror_class.count() == 1 |
|
5472 |
assert pub.loggederror_class.select()[0].summary.startswith('Failed to convert') |
|
5473 | ||
5474 |
# None : empty date |
|
5475 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5476 |
item.parent = st1 |
|
5477 |
item.fields = [{'field_id': 'bo1', 'value': None}] |
|
5478 |
item.perform(formdata) |
|
5479 | ||
5480 |
formdata = formdef.data_class().get(formdata.id) |
|
5481 |
assert formdata.data['bo1'] is None |
|
5482 | ||
5483 | ||
5484 |
def test_set_backoffice_field_boolean(pub): |
|
5485 |
Workflow.wipe() |
|
5486 |
FormDef.wipe() |
|
5487 |
wf = Workflow(name='xxx') |
|
5488 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5489 |
st1 = wf.add_status('Status1') |
|
5490 |
wf.backoffice_fields_formdef.fields = [ |
|
5491 |
BoolField(id='bo1', label='1st backoffice field', type='bool', varname='backoffice_bool'), |
|
5492 |
] |
|
5493 |
wf.store() |
|
5494 | ||
5495 |
formdef = FormDef() |
|
5496 |
formdef.name = 'baz' |
|
5497 |
formdef.fields = [BoolField(id='1', label='field', type='bool', varname='foo')] |
|
5498 |
formdef.workflow_id = wf.id |
|
5499 |
formdef.store() |
|
5500 | ||
5501 |
formdata = formdef.data_class()() |
|
5502 |
formdata.data = {'1': True} |
|
5503 |
formdata.just_created() |
|
5504 |
formdata.store() |
|
5505 |
get_publisher().substitutions.feed(formdata) |
|
5506 | ||
5507 |
for value in ('=True', '=form_var_foo_raw', '{{ form_var_foo_raw }}', 'True', 'Yes', 'true', 'yes'): |
|
5508 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5509 |
item.parent = st1 |
|
5510 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
5511 |
item.perform(formdata) |
|
5512 |
formdata = formdef.data_class().get(formdata.id) |
|
5513 |
assert formdata.data['bo1'] is True |
|
5514 |
formdata.data['bo1'] = None |
|
5515 |
formdata.store() |
|
5516 | ||
5517 |
for value in ('=False', '=not(form_var_foo_raw)', 'False', 'plop', ''): |
|
5518 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5519 |
item.parent = st1 |
|
5520 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
5521 |
item.perform(formdata) |
|
5522 |
formdata = formdef.data_class().get(formdata.id) |
|
5523 |
assert formdata.data['bo1'] is False |
|
5524 |
formdata.data['bo1'] = None |
|
5525 |
formdata.store() |
|
5526 | ||
5527 | ||
5528 |
def test_set_backoffice_field_str_time_filter(pub): |
|
5529 |
Workflow.wipe() |
|
5530 |
FormDef.wipe() |
|
5531 |
wf = Workflow(name='xxx') |
|
5532 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5533 |
st1 = wf.add_status('Status1') |
|
5534 |
wf.backoffice_fields_formdef.fields = [ |
|
5535 |
StringField(id='bo1', label='1st backoffice field', type='str', varname='backoffice_str'), |
|
5536 |
] |
|
5537 |
wf.store() |
|
5538 | ||
5539 |
formdef = FormDef() |
|
5540 |
formdef.name = 'baz' |
|
5541 |
formdef.fields = [StringField(id='1', label='field', type='str', varname='foo')] |
|
5542 |
formdef.workflow_id = wf.id |
|
5543 |
formdef.store() |
|
5544 | ||
5545 |
formdata = formdef.data_class()() |
|
5546 |
formdata.data = {'1': '09:00'} |
|
5547 |
formdata.just_created() |
|
5548 |
formdata.store() |
|
5549 |
get_publisher().substitutions.feed(formdata) |
|
5550 | ||
5551 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5552 |
item.parent = st1 |
|
5553 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_foo|time:"H:i:s" }}'}] |
|
5554 |
item.perform(formdata) |
|
5555 |
formdata = formdef.data_class().get(formdata.id) |
|
5556 |
assert formdata.data['bo1'] == '09:00:00' |
|
5557 |
formdata.data['bo1'] = None |
|
5558 |
formdata.store() |
|
5559 | ||
5560 |
# |time will yield the default django reprentation |
|
5561 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5562 |
item.parent = st1 |
|
5563 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_foo|time }}'}] |
|
5564 |
item.perform(formdata) |
|
5565 |
formdata = formdef.data_class().get(formdata.id) |
|
5566 |
assert formdata.data['bo1'] == '9 a.m.' |
|
5567 |
formdata.data['bo1'] = None |
|
5568 |
formdata.store() |
|
5569 | ||
5570 | ||
5571 |
def test_set_backoffice_field_block(pub): |
|
5572 |
BlockDef.wipe() |
|
5573 |
Workflow.wipe() |
|
5574 |
FormDef.wipe() |
|
5575 | ||
5576 |
block = BlockDef() |
|
5577 |
block.name = 'foobar' |
|
5578 |
block.digest_template = 'X{{foobar_var_foo}}Y' |
|
5579 |
block.fields = [ |
|
5580 |
StringField(id='123', required=True, label='Test', type='string', varname='foo'), |
|
5581 |
StringField(id='234', required=True, label='Test2', type='string', varname='bar'), |
|
5582 |
] |
|
5583 |
block.store() |
|
5584 | ||
5585 |
wf = Workflow(name='xxx') |
|
5586 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5587 |
st1 = wf.add_status('Status1') |
|
5588 |
wf.backoffice_fields_formdef.fields = [ |
|
5589 |
BlockField(id='bo1', label='1st backoffice field', type='block:foobar'), |
|
5590 |
StringField(id='bo2', label='2nd backoffice field', type='string'), |
|
5591 |
] |
|
5592 |
wf.store() |
|
5593 | ||
5594 |
formdef = FormDef() |
|
5595 |
formdef.name = 'baz' |
|
5596 |
formdef.fields = [ |
|
5597 |
BlockField(id='1', label='test', type='block:foobar', max_items=3, varname='foo'), |
|
5598 |
] |
|
5599 |
formdef.workflow_id = wf.id |
|
5600 |
formdef.store() |
|
5601 | ||
5602 |
formdata = formdef.data_class()() |
|
5603 |
# value from test_block_digest in tests/test_form_pages.py |
|
5604 |
formdata.data = { |
|
5605 |
'1': { |
|
5606 |
'data': [{'123': 'foo', '234': 'bar'}, {'123': 'foo2', '234': 'bar2'}], |
|
5607 |
'schema': {'123': 'string', '234': 'string'}, |
|
5608 |
}, |
|
5609 |
'1_display': 'XfooY, Xfoo2Y', |
|
5610 |
} |
|
5611 |
formdata.just_created() |
|
5612 |
formdata.store() |
|
5613 |
get_publisher().substitutions.feed(formdata) |
|
5614 | ||
5615 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5616 |
item.parent = st1 |
|
5617 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_foo_raw}}'}] |
|
5618 |
item.perform(formdata) |
|
5619 |
formdata = formdef.data_class().get(formdata.id) |
|
5620 |
assert formdata.data['bo1'] == formdata.data['1'] |
|
5621 |
assert formdata.data['bo1_display'] == formdata.data['1_display'] |
|
5622 | ||
5623 |
# without _raw suffix |
|
5624 |
formdata = formdef.data_class()() |
|
5625 |
# value from test_block_digest in tests/test_form_pages.py |
|
5626 |
formdata.data = { |
|
5627 |
'1': { |
|
5628 |
'data': [{'123': 'foo', '234': 'bar'}, {'123': 'foo2', '234': 'bar2'}], |
|
5629 |
'schema': {'123': 'string', '234': 'string'}, |
|
5630 |
}, |
|
5631 |
'1_display': 'XfooY, Xfoo2Y', |
|
5632 |
} |
|
5633 |
formdata.just_created() |
|
5634 |
formdata.store() |
|
5635 |
get_publisher().substitutions.reset() |
|
5636 |
get_publisher().substitutions.feed(formdata) |
|
5637 | ||
5638 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5639 |
item.parent = st1 |
|
5640 |
item.fields = [ |
|
5641 |
{'field_id': 'bo1', 'value': '{{form_var_foo}}'}, |
|
5642 |
{'field_id': 'bo2', 'value': '{{form_var_foo}}'}, |
|
5643 |
] |
|
5644 |
item.perform(formdata) |
|
5645 |
formdata = formdef.data_class().get(formdata.id) |
|
5646 |
assert formdata.data['bo1'] == formdata.data['1'] |
|
5647 |
assert formdata.data['bo1_display'] == formdata.data['1_display'] |
|
5648 |
assert formdata.data['bo2'] == formdata.data['1_display'] |
|
5649 | ||
5650 | ||
5651 |
def test_set_backoffice_field_block_template_tag(pub): |
|
5652 |
BlockDef.wipe() |
|
5653 |
Workflow.wipe() |
|
5654 |
FormDef.wipe() |
|
5655 | ||
5656 |
block = BlockDef() |
|
5657 |
block.name = 'foobar' |
|
5658 |
block.digest_template = 'X{{foobar_var_foo}}Y' |
|
5659 |
block.fields = [ |
|
5660 |
StringField(id='123', required=True, label='Test', type='string', varname='foo'), |
|
5661 |
StringField(id='234', required=True, label='Test2', type='string', varname='bar'), |
|
5662 |
] |
|
5663 |
block.store() |
|
5664 | ||
5665 |
wf = Workflow(name='xxx') |
|
5666 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5667 |
st1 = wf.add_status('Status1') |
|
5668 |
wf.backoffice_fields_formdef.fields = [ |
|
5669 |
BlockField(id='bo1', label='1st backoffice field', max_items=3, type='block:foobar'), |
|
5670 |
] |
|
5671 |
wf.store() |
|
5672 | ||
5673 |
formdef = FormDef() |
|
5674 |
formdef.name = 'baz' |
|
5675 |
formdef.fields = [ |
|
5676 |
StringField(id='1', label='test', varname='foo'), |
|
5677 |
] |
|
5678 |
formdef.workflow_id = wf.id |
|
5679 |
formdef.store() |
|
5680 | ||
5681 |
formdata = formdef.data_class()() |
|
5682 |
formdata.data = {'1': 'plop'} |
|
5683 |
formdata.just_created() |
|
5684 |
formdata.store() |
|
5685 |
get_publisher().substitutions.feed(formdata) |
|
5686 | ||
5687 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5688 |
item.parent = st1 |
|
5689 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value foo=form_var_foo bar="xxx" %}'}] |
|
5690 |
item.perform(formdata) |
|
5691 |
formdata = formdef.data_class().get(formdata.id) |
|
5692 |
assert formdata.data['bo1'] == { |
|
5693 |
'data': [{'123': 'plop', '234': 'xxx'}], |
|
5694 |
'schema': {'123': 'string', '234': 'string'}, |
|
5695 |
} |
|
5696 |
assert formdata.data['bo1_display'] == 'XplopY' |
|
5697 | ||
5698 |
# override |
|
5699 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5700 |
item.parent = st1 |
|
5701 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value foo=form_var_foo bar="yyy" %}'}] |
|
5702 |
item.perform(formdata) |
|
5703 |
formdata = formdef.data_class().get(formdata.id) |
|
5704 |
assert formdata.data['bo1'] == { |
|
5705 |
'data': [{'123': 'plop', '234': 'yyy'}], |
|
5706 |
'schema': {'123': 'string', '234': 'string'}, |
|
5707 |
} |
|
5708 |
assert formdata.data['bo1_display'] == 'XplopY' |
|
5709 | ||
5710 |
# append |
|
5711 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5712 |
item.parent = st1 |
|
5713 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value append=True foo="zzz" bar=form_var_foo %}'}] |
|
5714 |
item.perform(formdata) |
|
5715 |
formdata = formdef.data_class().get(formdata.id) |
|
5716 |
assert formdata.data['bo1'] == { |
|
5717 |
'data': [{'123': 'plop', '234': 'yyy'}, {'123': 'zzz', '234': 'plop'}], |
|
5718 |
'schema': {'123': 'string', '234': 'string'}, |
|
5719 |
} |
|
5720 |
assert formdata.data['bo1_display'] == 'XplopY, XzzzY' |
|
5721 | ||
5722 |
# merge (into last row) |
|
5723 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5724 |
item.parent = st1 |
|
5725 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=True foo="AAA" %}'}] |
|
5726 |
item.perform(formdata) |
|
5727 |
formdata = formdef.data_class().get(formdata.id) |
|
5728 |
assert formdata.data['bo1'] == { |
|
5729 |
'data': [{'123': 'plop', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
5730 |
'schema': {'123': 'string', '234': 'string'}, |
|
5731 |
} |
|
5732 |
assert formdata.data['bo1_display'] == 'XplopY, XAAAY' |
|
5733 | ||
5734 |
# merge (into given row) |
|
5735 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5736 |
item.parent = st1 |
|
5737 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=0 foo="BBB" %}'}] |
|
5738 |
item.perform(formdata) |
|
5739 |
formdata = formdef.data_class().get(formdata.id) |
|
5740 |
assert formdata.data['bo1'] == { |
|
5741 |
'data': [{'123': 'BBB', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
5742 |
'schema': {'123': 'string', '234': 'string'}, |
|
5743 |
} |
|
5744 |
assert formdata.data['bo1_display'] == 'XBBBY, XAAAY' |
|
5745 | ||
5746 |
# merge with indexerror (ignored) |
|
5747 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5748 |
item.parent = st1 |
|
5749 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=50 foo="CCC" %}'}] |
|
5750 |
item.perform(formdata) |
|
5751 |
formdata = formdef.data_class().get(formdata.id) |
|
5752 |
assert formdata.data['bo1'] == { |
|
5753 |
'data': [{'123': 'BBB', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
5754 |
'schema': {'123': 'string', '234': 'string'}, |
|
5755 |
} |
|
5756 |
assert formdata.data['bo1_display'] == 'XBBBY, XAAAY' |
|
5757 | ||
5758 |
# "item" subfield, make sure raw and display and structured values are stored |
|
5759 |
datasource = { |
|
5760 |
'type': 'formula', |
|
5761 |
'value': repr( |
|
5762 |
[ |
|
5763 |
{'id': 'a', 'text': 'aa', 'more': 'aaa'}, |
|
5764 |
{'id': 'b', 'text': 'bb', 'more': 'bbb'}, |
|
5765 |
{'id': 'c', 'text': 'cc', 'more': 'ccc'}, |
|
5766 |
] |
|
5767 |
), |
|
5768 |
} |
|
5769 |
block.fields.append( |
|
5770 |
ItemField(id='345', label='Test3', type='item', varname='item', data_source=datasource) |
|
5771 |
) |
|
5772 |
block.store() |
|
5773 |
wf.backoffice_fields_formdef.fields[0]._block = None # remove cache |
|
5774 | ||
5775 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5776 |
item.parent = st1 |
|
5777 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value item="b" %}'}] |
|
5778 |
item.perform(formdata) |
|
5779 |
formdata = formdef.data_class().get(formdata.id) |
|
5780 |
assert formdata.data['bo1'] == { |
|
5781 |
'data': [ |
|
5782 |
{'345': 'b', '345_display': 'bb', '345_structured': {'id': 'b', 'text': 'bb', 'more': 'bbb'}} |
|
5783 |
], |
|
5784 |
'schema': {'123': 'string', '234': 'string', '345': 'item'}, |
|
5785 |
} |
|
5786 |
assert formdata.data['bo1_display'] == 'XNoneY' |
|
5787 | ||
5788 |
# append to invalid existing value (should not happen) |
|
5789 |
formdata.data['bo1'] = {'invalid': 'value'} |
|
5790 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5791 |
item.parent = st1 |
|
5792 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value item="b" append=True %}'}] |
|
5793 |
item.perform(formdata) |
|
5794 |
formdata = formdef.data_class().get(formdata.id) |
|
5795 |
assert formdata.data['bo1'] == { |
|
5796 |
'data': [ |
|
5797 |
{'345': 'b', '345_display': 'bb', '345_structured': {'id': 'b', 'text': 'bb', 'more': 'bbb'}} |
|
5798 |
], |
|
5799 |
'schema': {'123': 'string', '234': 'string', '345': 'item'}, |
|
5800 |
} |
|
5801 |
assert formdata.data['bo1_display'] == 'XNoneY' |
|
5802 | ||
5803 | ||
5804 |
def test_set_backoffice_field_invalid_block_value(pub): |
|
5805 |
BlockDef.wipe() |
|
5806 |
Workflow.wipe() |
|
5807 |
FormDef.wipe() |
|
5808 | ||
5809 |
block = BlockDef() |
|
5810 |
block.name = 'foobar' |
|
5811 |
block.fields = [StringField(id='123', required=True, label='Test', type='string', varname='foo')] |
|
5812 |
block.store() |
|
5813 | ||
5814 |
wf = Workflow(name='xxx') |
|
5815 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5816 |
st1 = wf.add_status('Status1') |
|
5817 |
wf.backoffice_fields_formdef.fields = [ |
|
5818 |
BlockField(id='bo1', label='1st backoffice field', max_items=3, type='block:foobar'), |
|
5819 |
] |
|
5820 |
wf.store() |
|
5821 | ||
5822 |
formdef = FormDef() |
|
5823 |
formdef.name = 'baz' |
|
5824 |
formdef.fields = [] |
|
5825 |
formdef.workflow_id = wf.id |
|
5826 |
formdef.store() |
|
5827 | ||
5828 |
formdata = formdef.data_class()() |
|
5829 |
formdata.just_created() |
|
5830 |
formdata.store() |
|
5831 |
get_publisher().substitutions.feed(formdata) |
|
5832 | ||
5833 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5834 |
item.parent = st1 |
|
5835 |
item.fields = [{'field_id': 'bo1', 'value': 'xxx'}] |
|
5836 | ||
5837 |
pub.loggederror_class.wipe() |
|
5838 |
item.perform(formdata) |
|
5839 |
assert pub.loggederror_class.count() == 1 |
|
5840 |
logged_error = pub.loggederror_class.select()[0] |
|
5841 |
assert ( |
|
5842 |
logged_error.summary |
|
5843 |
== 'Failed to set Field Block (foobar) field (bo1), error: invalid value for block' |
|
5844 |
) |
|
5845 | ||
5846 |
formdata = formdef.data_class().get(formdata.id) |
|
5847 |
assert not formdata.data.get('bo1') |
|
5848 | ||
5849 | ||
5850 |
def test_set_backoffice_field_immediate_use(http_requests, pub): |
|
5851 |
Workflow.wipe() |
|
5852 |
FormDef.wipe() |
|
5853 |
wf = Workflow(name='xxx') |
|
5854 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
5855 |
wf.backoffice_fields_formdef.fields = [ |
|
5856 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
5857 |
StringField(id='bo2', label='2nd backoffice field', type='string', varname='backoffice_barr'), |
|
5858 |
] |
|
5859 |
st1 = wf.add_status('Status1') |
|
5860 |
wf.store() |
|
5861 | ||
5862 |
formdef = FormDef() |
|
5863 |
formdef.name = 'baz' |
|
5864 |
formdef.fields = [ |
|
5865 |
StringField(id='00', label='String', type='string', varname='string'), |
|
5866 |
] |
|
5867 |
formdef.workflow_id = wf.id |
|
5868 |
formdef.store() |
|
5869 | ||
5870 |
formdata = formdef.data_class()() |
|
5871 |
formdata.data = {'00': 'HELLO'} |
|
5872 |
formdata.just_created() |
|
5873 |
formdata.store() |
|
5874 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
5875 |
item.parent = st1 |
|
5876 | ||
5877 |
item.fields = [ |
|
5878 |
{'field_id': 'bo1', 'value': '{{form_var_string}}'}, |
|
5879 |
] |
|
5880 |
pub.substitutions.reset() |
|
5881 |
pub.substitutions.feed(formdata) |
|
5882 |
item.perform(formdata) |
|
5883 |
formdata = formdef.data_class().get(formdata.id) |
|
5884 |
assert formdata.data.get('bo1') == 'HELLO' |
|
5885 | ||
5886 |
item.fields = [ |
|
5887 |
{'field_id': 'bo1', 'value': 'WORLD'}, |
|
5888 |
] |
|
5889 |
pub.substitutions.reset() |
|
5890 |
pub.substitutions.feed(formdata) |
|
5891 |
item.perform(formdata) |
|
5892 |
formdata = formdef.data_class().get(formdata.id) |
|
5893 |
assert formdata.data.get('bo1') == 'WORLD' |
|
5894 | ||
5895 |
item.fields = [ |
|
5896 |
{'field_id': 'bo1', 'value': 'X{{form_var_string}}X'}, |
|
5897 |
{'field_id': 'bo2', 'value': "Y{{form_var_backoffice_blah}}Y"}, |
|
5898 |
] |
|
5899 |
pub.substitutions.reset() |
|
5900 |
pub.substitutions.feed(formdata) |
|
5901 |
item.perform(formdata) |
|
5902 |
formdata = formdef.data_class().get(formdata.id) |
|
5903 |
assert formdata.data.get('bo1') == 'XHELLOX' |
|
5904 |
assert formdata.data.get('bo2') == 'YXHELLOXY' |
|
5905 | ||
5906 | ||
5907 | 4480 |
def test_redirect_to_url(pub): |
5908 | 4481 |
formdef = FormDef() |
5909 | 4482 |
formdef.name = 'baz' |
tests/workflow/test_backoffice_field.py | ||
---|---|---|
1 |
import base64 |
|
2 |
import datetime |
|
3 |
import os |
|
4 | ||
5 |
import pytest |
|
6 | ||
7 |
try: |
|
8 |
from PIL import Image |
|
9 |
except ImportError: |
|
10 |
Image = None |
|
11 | ||
12 |
from quixote import cleanup, get_publisher |
|
13 | ||
14 |
from wcs import sessions |
|
15 |
from wcs.blocks import BlockDef |
|
16 |
from wcs.carddef import CardDef |
|
17 |
from wcs.fields import ( |
|
18 |
BlockField, |
|
19 |
BoolField, |
|
20 |
DateField, |
|
21 |
FileField, |
|
22 |
ItemField, |
|
23 |
ItemsField, |
|
24 |
MapField, |
|
25 |
StringField, |
|
26 |
) |
|
27 |
from wcs.formdef import FormDef |
|
28 |
from wcs.qommon.http_request import HTTPRequest |
|
29 |
from wcs.qommon.upload_storage import PicklableUpload |
|
30 |
from wcs.wf.backoffice_fields import SetBackofficeFieldsWorkflowStatusItem |
|
31 |
from wcs.wf.wscall import WebserviceCallStatusItem |
|
32 |
from wcs.workflows import AttachmentEvolutionPart, Workflow, WorkflowBackofficeFieldsFormDef |
|
33 | ||
34 |
from ..utilities import clean_temporary_pub, create_temporary_pub |
|
35 | ||
36 | ||
37 |
def setup_module(module): |
|
38 |
cleanup() |
|
39 | ||
40 | ||
41 |
def teardown_module(module): |
|
42 |
clean_temporary_pub() |
|
43 | ||
44 | ||
45 |
@pytest.fixture |
|
46 |
def pub(): |
|
47 |
pub = create_temporary_pub() |
|
48 |
pub.cfg['language'] = {'language': 'en'} |
|
49 |
pub.cfg['identification'] = {'methods': ['password']} |
|
50 |
pub.write_cfg() |
|
51 |
req = HTTPRequest(None, {'SERVER_NAME': 'example.net', 'SCRIPT_NAME': ''}) |
|
52 |
req.response.filter = {} |
|
53 |
req._user = None |
|
54 |
pub._set_request(req) |
|
55 |
req.session = sessions.BasicSession(id=1) |
|
56 |
pub.set_config(req) |
|
57 |
return pub |
|
58 | ||
59 | ||
60 |
def test_set_backoffice_field(http_requests, pub): |
|
61 |
Workflow.wipe() |
|
62 |
FormDef.wipe() |
|
63 |
wf = Workflow(name='xxx') |
|
64 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
65 |
wf.backoffice_fields_formdef.fields = [ |
|
66 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
67 |
] |
|
68 |
st1 = wf.add_status('Status1') |
|
69 |
wf.store() |
|
70 | ||
71 |
formdef = FormDef() |
|
72 |
formdef.name = 'baz' |
|
73 |
formdef.fields = [ |
|
74 |
StringField(id='00', label='String', type='string', varname='string'), |
|
75 |
StringField(id='01', label='Other string', type='string', varname='other'), |
|
76 |
] |
|
77 |
formdef.workflow_id = wf.id |
|
78 |
formdef.store() |
|
79 | ||
80 |
formdata = formdef.data_class()() |
|
81 |
formdata.data = {'00': 'HELLO'} |
|
82 |
formdata.just_created() |
|
83 |
formdata.store() |
|
84 |
pub.substitutions.feed(formdata) |
|
85 | ||
86 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
87 |
item.parent = st1 |
|
88 | ||
89 |
assert item.render_as_line() == 'Backoffice Data' |
|
90 |
assert item.get_jump_label('plop') == 'Backoffice Data' |
|
91 |
item.label = 'label' |
|
92 |
assert item.render_as_line() == 'Backoffice Data (label)' |
|
93 |
assert item.get_jump_label('plop') == 'Backoffice Data "label"' |
|
94 | ||
95 |
item.perform(formdata) |
|
96 |
formdata = formdef.data_class().get(formdata.id) |
|
97 |
assert formdata.data.get('bo1') is None |
|
98 | ||
99 |
item.fields = [{'field_id': 'bo1', 'value': '=form_var_string'}] |
|
100 |
item.perform(formdata) |
|
101 |
formdata = formdef.data_class().get(formdata.id) |
|
102 |
assert formdata.data['bo1'] == 'HELLO' |
|
103 | ||
104 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_string }} WORLD'}] |
|
105 |
item.perform(formdata) |
|
106 |
formdata = formdef.data_class().get(formdata.id) |
|
107 |
assert formdata.data['bo1'] == 'HELLO WORLD' |
|
108 | ||
109 |
item.fields = [{'field_id': 'bo1', 'value': '[form_var_string] GOODBYE'}] |
|
110 |
item.perform(formdata) |
|
111 |
formdata = formdef.data_class().get(formdata.id) |
|
112 |
assert formdata.data['bo1'] == 'HELLO GOODBYE' |
|
113 | ||
114 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form.var.string }} LAZY'}] |
|
115 |
item.perform(formdata) |
|
116 |
formdata = formdef.data_class().get(formdata.id) |
|
117 |
assert formdata.data['bo1'] == 'HELLO LAZY' |
|
118 | ||
119 |
item.fields = [{'field_id': 'bo1', 'value': '=form.var.string'}] # lazy python |
|
120 |
item.perform(formdata) |
|
121 |
formdata = formdef.data_class().get(formdata.id) |
|
122 |
assert formdata.data['bo1'] == 'HELLO' |
|
123 | ||
124 |
item.fields = [{'field_id': 'bo1', 'value': '=vars().get("form_var_string") + " PLOP"'}] |
|
125 |
item.perform(formdata) |
|
126 |
formdata = formdef.data_class().get(formdata.id) |
|
127 |
assert formdata.data['bo1'] == 'HELLO PLOP' |
|
128 | ||
129 |
item.fields = [ |
|
130 |
{'field_id': 'bo1', 'value': '=vars().get("form_var_other") or vars().get("form_var_string")'} |
|
131 |
] |
|
132 |
item.perform(formdata) |
|
133 |
formdata = formdef.data_class().get(formdata.id) |
|
134 |
assert formdata.data['bo1'] == 'HELLO' |
|
135 | ||
136 |
item.fields = [{'field_id': 'bo1', 'value': '=vars().get("form_var_bouh", "X") + " PLOP"'}] |
|
137 |
item.perform(formdata) |
|
138 |
formdata = formdef.data_class().get(formdata.id) |
|
139 |
assert formdata.data['bo1'] == 'X PLOP' |
|
140 | ||
141 |
item.fields = [{'field_id': 'bo1', 'value': None}] |
|
142 |
item.perform(formdata) |
|
143 |
formdata = formdef.data_class().get(formdata.id) |
|
144 |
assert formdata.data['bo1'] is None |
|
145 | ||
146 |
item.fields = [{'field_id': 'bo1', 'value': ''}] |
|
147 |
item.perform(formdata) |
|
148 |
formdata = formdef.data_class().get(formdata.id) |
|
149 |
assert formdata.data['bo1'] is None |
|
150 | ||
151 |
# check a value computed as the empty string is stored as an empty string, not None |
|
152 |
item.fields = [{'field_id': 'bo1', 'value': '=""'}] |
|
153 |
item.perform(formdata) |
|
154 |
formdata = formdef.data_class().get(formdata.id) |
|
155 |
assert formdata.data['bo1'] == '' |
|
156 |
item.fields = [{'field_id': 'bo1', 'value': '{{ does_not_exist }}'}] |
|
157 |
item.perform(formdata) |
|
158 |
formdata = formdef.data_class().get(formdata.id) |
|
159 |
assert formdata.data['bo1'] == '' |
|
160 | ||
161 |
assert pub.loggederror_class.count() == 0 |
|
162 | ||
163 |
item.fields = [{'field_id': 'bo1', 'value': '= ~ invalid python ~'}] |
|
164 |
item.perform(formdata) |
|
165 |
formdata = formdef.data_class().get(formdata.id) |
|
166 |
assert pub.loggederror_class.count() == 1 |
|
167 |
logged_error = pub.loggederror_class.select()[0] |
|
168 |
assert logged_error.summary == 'Failed to compute Python expression' |
|
169 |
assert logged_error.formdata_id == str(formdata.id) |
|
170 |
assert logged_error.expression == ' ~ invalid python ~' |
|
171 |
assert logged_error.expression_type == 'python' |
|
172 |
assert logged_error.exception_class == 'SyntaxError' |
|
173 |
assert logged_error.exception_message == 'invalid syntax (<string>, line 1)' |
|
174 | ||
175 |
pub.loggederror_class.wipe() |
|
176 |
item.fields = [{'field_id': 'bo1', 'value': '{% if bad django %}'}] |
|
177 |
item.perform(formdata) |
|
178 |
formdata = formdef.data_class().get(formdata.id) |
|
179 |
assert pub.loggederror_class.count() == 1 |
|
180 |
logged_error = pub.loggederror_class.select()[0] |
|
181 |
assert logged_error.summary == 'Failed to compute template' |
|
182 |
assert logged_error.formdata_id == str(formdata.id) |
|
183 |
assert logged_error.expression == '{% if bad django %}' |
|
184 |
assert logged_error.expression_type == 'template' |
|
185 |
assert logged_error.exception_class == 'TemplateError' |
|
186 |
assert logged_error.exception_message.startswith('syntax error in Django template') |
|
187 | ||
188 | ||
189 |
def test_set_backoffice_field_map(http_requests, pub): |
|
190 |
Workflow.wipe() |
|
191 |
FormDef.wipe() |
|
192 |
wf = Workflow(name='xxx') |
|
193 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
194 |
wf.backoffice_fields_formdef.fields = [ |
|
195 |
MapField(id='bo1', label='1st backoffice field', type='map', varname='backoffice_blah'), |
|
196 |
] |
|
197 |
st1 = wf.add_status('Status1') |
|
198 |
wf.store() |
|
199 | ||
200 |
formdef = FormDef() |
|
201 |
formdef.name = 'baz' |
|
202 |
formdef.fields = [ |
|
203 |
MapField(id='1', label='Map1', type='map', varname='map1'), |
|
204 |
MapField(id='2', label='Map2', type='map', varname='map2'), |
|
205 |
] |
|
206 |
formdef.workflow_id = wf.id |
|
207 |
formdef.store() |
|
208 | ||
209 |
formdata = formdef.data_class()() |
|
210 |
formdata.data = {'1': '42;10', '2': None} |
|
211 |
formdata.just_created() |
|
212 |
formdata.store() |
|
213 |
pub.substitutions.feed(formdata) |
|
214 | ||
215 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
216 |
item.parent = st1 |
|
217 | ||
218 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_map1|default:"" }}'}] |
|
219 |
item.perform(formdata) |
|
220 |
formdata = formdef.data_class().get(formdata.id) |
|
221 |
assert formdata.data.get('bo1') == '42;10' |
|
222 | ||
223 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_map2|default:"" }}'}] |
|
224 |
item.perform(formdata) |
|
225 |
formdata = formdef.data_class().get(formdata.id) |
|
226 |
assert formdata.data.get('bo1') is None |
|
227 | ||
228 |
assert pub.loggederror_class.count() == 0 |
|
229 | ||
230 |
item.fields = [{'field_id': 'bo1', 'value': 'invalid value'}] |
|
231 |
item.perform(formdata) |
|
232 |
formdata = formdef.data_class().get(formdata.id) |
|
233 |
assert pub.loggederror_class.count() == 1 |
|
234 |
logged_error = pub.loggederror_class.select()[0] |
|
235 |
assert ( |
|
236 |
logged_error.summary |
|
237 |
== "Failed to set Map field (bo1), error: invalid coordinates 'invalid value' (missing ;)" |
|
238 |
) |
|
239 |
assert logged_error.formdata_id == str(formdata.id) |
|
240 |
assert logged_error.exception_class == 'SetValueError' |
|
241 |
assert logged_error.exception_message == "invalid coordinates 'invalid value' (missing ;)" |
|
242 |
pub.loggederror_class.wipe() |
|
243 | ||
244 |
item.fields = [{'field_id': 'bo1', 'value': 'XXX;YYY'}] |
|
245 |
item.perform(formdata) |
|
246 |
formdata = formdef.data_class().get(formdata.id) |
|
247 |
assert pub.loggederror_class.count() == 1 |
|
248 |
logged_error = pub.loggederror_class.select()[0] |
|
249 |
assert logged_error.summary == "Failed to set Map field (bo1), error: invalid coordinates 'XXX;YYY'" |
|
250 |
assert logged_error.formdata_id == str(formdata.id) |
|
251 |
assert logged_error.exception_class == 'SetValueError' |
|
252 |
assert logged_error.exception_message == "invalid coordinates 'XXX;YYY'" |
|
253 |
pub.loggederror_class.wipe() |
|
254 | ||
255 | ||
256 |
def test_set_backoffice_field_decimal(http_requests, pub): |
|
257 |
Workflow.wipe() |
|
258 |
FormDef.wipe() |
|
259 |
wf = Workflow(name='xxx') |
|
260 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
261 |
wf.backoffice_fields_formdef.fields = [ |
|
262 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
263 |
] |
|
264 |
st1 = wf.add_status('Status1') |
|
265 |
wf.store() |
|
266 | ||
267 |
formdef = FormDef() |
|
268 |
formdef.name = 'baz' |
|
269 |
formdef.fields = [ |
|
270 |
StringField(id='1', label='String', type='string', varname='string'), |
|
271 |
] |
|
272 |
formdef.workflow_id = wf.id |
|
273 |
formdef.store() |
|
274 | ||
275 |
formdata = formdef.data_class()() |
|
276 |
formdata.data = {'1': '1000'} |
|
277 |
formdata.just_created() |
|
278 |
formdata.store() |
|
279 |
pub.substitutions.feed(formdata) |
|
280 | ||
281 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
282 |
item.parent = st1 |
|
283 |
item.fields = [{'field_id': 'bo1', 'value': '{{ "100"|decimal }}'}] |
|
284 |
item.perform(formdata) |
|
285 |
assert formdef.data_class().get(formdata.id).data['bo1'] == '100' |
|
286 | ||
287 |
formdata.store() # reset |
|
288 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_string|decimal }}'}] |
|
289 |
item.perform(formdata) |
|
290 |
assert formdef.data_class().get(formdata.id).data['bo1'] == '1000' |
|
291 | ||
292 | ||
293 |
def test_set_backoffice_field_file(http_requests, pub): |
|
294 |
Workflow.wipe() |
|
295 |
FormDef.wipe() |
|
296 |
wf = Workflow(name='xxx') |
|
297 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
298 |
wf.backoffice_fields_formdef.fields = [ |
|
299 |
FileField(id='bo1', label='1st backoffice field', type='file', varname='backoffice_file'), |
|
300 |
StringField(id='bo2', label='2nd backoffice field', type='string'), |
|
301 |
] |
|
302 |
st1 = wf.add_status('Status1') |
|
303 |
wf.store() |
|
304 | ||
305 |
formdef = FormDef() |
|
306 |
formdef.name = 'baz' |
|
307 |
formdef.fields = [ |
|
308 |
FileField(id='00', label='File', type='file', varname='file'), |
|
309 |
] |
|
310 |
formdef.workflow_id = wf.id |
|
311 |
formdef.store() |
|
312 | ||
313 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
314 |
item.parent = st1 |
|
315 |
item.fields = [{'field_id': 'bo1', 'value': '=locals().get("form_var_file_raw")'}] |
|
316 | ||
317 |
# the file does not exist |
|
318 |
formdata = formdef.data_class()() |
|
319 |
formdata.data = {} |
|
320 |
formdata.just_created() |
|
321 |
formdata.store() |
|
322 |
pub.substitutions.feed(formdata) |
|
323 |
item.perform(formdata) |
|
324 |
formdata = formdef.data_class().get(formdata.id) |
|
325 |
assert formdata.data['bo1'] is None |
|
326 | ||
327 |
# store a PiclableUpload |
|
328 |
upload = PicklableUpload('test.jpeg', 'image/jpeg') |
|
329 |
with open(os.path.join(os.path.dirname(__file__), '..', 'image-with-gps-data.jpeg'), 'rb') as fd: |
|
330 |
image_with_gps_data = fd.read() |
|
331 |
upload.receive([image_with_gps_data]) |
|
332 | ||
333 |
formdata = formdef.data_class()() |
|
334 |
formdata.data = {'00': upload} |
|
335 |
formdata.just_created() |
|
336 |
formdata.store() |
|
337 | ||
338 |
pub.substitutions.feed(formdata) |
|
339 |
item.perform(formdata) |
|
340 | ||
341 |
formdata = formdef.data_class().get(formdata.id) |
|
342 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
343 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
344 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
345 |
assert formdata.data['bo1'].get_base64_content() == base64.encodebytes(image_with_gps_data) |
|
346 | ||
347 |
# check with template string |
|
348 |
formdata = formdef.data_class()() |
|
349 |
formdata.data = {'00': upload} |
|
350 |
formdata.just_created() |
|
351 |
formdata.store() |
|
352 | ||
353 |
pub.substitutions.feed(formdata) |
|
354 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file_raw}}'}] |
|
355 |
item.perform(formdata) |
|
356 | ||
357 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
358 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
359 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
360 | ||
361 |
# check with template string, without _raw |
|
362 |
formdata = formdef.data_class()() |
|
363 |
formdata.data = {'00': upload} |
|
364 |
formdata.just_created() |
|
365 |
formdata.store() |
|
366 | ||
367 |
pub.substitutions.feed(formdata) |
|
368 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file}}'}] |
|
369 |
item.perform(formdata) |
|
370 | ||
371 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
372 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
373 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
374 | ||
375 |
# check |strip_metadata filter |
|
376 |
formdata = formdef.data_class()() |
|
377 |
formdata.data = {'00': upload} |
|
378 |
formdata.just_created() |
|
379 |
formdata.store() |
|
380 | ||
381 |
pub.substitutions.feed(formdata) |
|
382 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|strip_metadata}}'}] |
|
383 |
item.perform(formdata) |
|
384 | ||
385 |
assert formdata.data['bo1'].base_filename == 'test.jpeg' |
|
386 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
387 |
assert b'JFIF' in formdata.data['bo1'].get_content() |
|
388 |
assert b'<exif:XResolution>' not in formdata.data['bo1'].get_content() |
|
389 | ||
390 |
# check |rename_file filter |
|
391 |
formdata = formdef.data_class()() |
|
392 |
formdata.data = {'00': upload} |
|
393 |
formdata.just_created() |
|
394 |
formdata.store() |
|
395 | ||
396 |
pub.substitutions.feed(formdata) |
|
397 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|rename_file:"foobar.jpeg"}}'}] |
|
398 |
item.perform(formdata) |
|
399 | ||
400 |
assert formdata.data['bo1'].base_filename == 'foobar.jpeg' |
|
401 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
402 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
403 | ||
404 |
formdata = formdef.data_class()() |
|
405 |
formdata.data = {'00': upload} |
|
406 |
formdata.just_created() |
|
407 |
formdata.store() |
|
408 | ||
409 |
pub.substitutions.feed(formdata) |
|
410 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_file|rename_file:"foobar.$ext"}}'}] |
|
411 |
item.perform(formdata) |
|
412 | ||
413 |
assert formdata.data['bo1'].base_filename == 'foobar.jpeg' |
|
414 |
assert formdata.data['bo1'].content_type == 'image/jpeg' |
|
415 |
assert formdata.data['bo1'].get_content() == image_with_gps_data |
|
416 | ||
417 |
# check |rename_file with invalid input |
|
418 |
formdata = formdef.data_class()() |
|
419 |
formdata.data = {'00': upload} |
|
420 |
formdata.just_created() |
|
421 |
formdata.store() |
|
422 | ||
423 |
pub.substitutions.feed(formdata) |
|
424 | ||
425 |
item.fields = [{'field_id': 'bo1', 'value': '{{"xxx"|rename_file:"foobar.jpeg"}}'}] |
|
426 |
item.perform(formdata) |
|
427 | ||
428 |
assert 'bo1' not in formdata.data |
|
429 | ||
430 |
# check with a template string, into a string field |
|
431 |
pub.substitutions.feed(formdata) |
|
432 |
item.fields = [{'field_id': 'bo2', 'value': '{{form_var_file}}'}] |
|
433 |
item.perform(formdata) |
|
434 | ||
435 |
assert formdata.data['bo2'] == 'test.jpeg' |
|
436 | ||
437 |
# check with template string and missing file |
|
438 |
formdata = formdef.data_class()() |
|
439 |
formdata.data = {'00': None} |
|
440 |
formdata.just_created() |
|
441 |
formdata.store() |
|
442 | ||
443 |
assert formdata.data.get('bo1') is None |
|
444 | ||
445 |
# check stripping metadata |
|
446 |
pub.substitutions.feed(formdata) |
|
447 |
item.fields = [ |
|
448 |
{ |
|
449 |
'field_id': 'bo1', |
|
450 |
'value': '=utils.attachment(form_var_file_raw,' |
|
451 |
+ ' filename="new_"+form_var_file,' |
|
452 |
+ ' content_type="my content type",' |
|
453 |
+ ' strip_metadata=True)', |
|
454 |
} |
|
455 |
] |
|
456 |
formdata = formdef.data_class()() |
|
457 |
formdata.data = {'00': upload} |
|
458 |
formdata.just_created() |
|
459 |
formdata.store() |
|
460 |
pub.substitutions.feed(formdata) |
|
461 |
item.perform(formdata) |
|
462 |
formdata = formdef.data_class().get(formdata.id) |
|
463 |
assert formdata.data['bo1'].base_filename == 'new_test.jpeg' |
|
464 |
assert formdata.data['bo1'].content_type == 'my content type' |
|
465 |
assert formdata.data['bo1'].qfilename != formdata.data['00'].qfilename |
|
466 |
assert formdata.data['00'].get_content().find(b'<exif:XResolution>') |
|
467 |
assert not Image or formdata.data['bo1'].get_content().find(b'<exif:XResolution>') == -1 |
|
468 | ||
469 |
upload2 = PicklableUpload('test2.odt', 'application/vnd.oasis.opendocument.text') |
|
470 |
with open(os.path.join(os.path.dirname(__file__), '..', 'template.odt'), 'rb') as fd: |
|
471 |
template_odt = fd.read() |
|
472 |
upload2.receive([template_odt]) |
|
473 |
formdata = formdef.data_class()() |
|
474 |
formdata.data = {'00': upload2} |
|
475 |
formdata.just_created() |
|
476 |
formdata.store() |
|
477 |
pub.substitutions.feed(formdata) |
|
478 |
item.perform(formdata) |
|
479 |
formdata = formdef.data_class().get(formdata.id) |
|
480 |
assert formdata.data['bo1'].base_filename == 'new_test2.odt' |
|
481 |
assert formdata.data['bo1'].content_type == 'my content type' |
|
482 |
assert formdata.data['bo1'].get_content() == template_odt |
|
483 |
assert formdata.data['bo1'].qfilename == formdata.data['00'].qfilename |
|
484 | ||
485 |
# check storing response as attachment |
|
486 |
pub.substitutions.feed(formdata) |
|
487 |
item = WebserviceCallStatusItem() |
|
488 |
item.url = 'http://remote.example.net/xml' |
|
489 |
item.varname = 'xxx' |
|
490 |
item.response_type = 'attachment' |
|
491 |
item.record_errors = True |
|
492 |
item.perform(formdata) |
|
493 |
attachment = formdata.evolution[-1].parts[-1] |
|
494 |
assert isinstance(attachment, AttachmentEvolutionPart) |
|
495 |
assert attachment.base_filename == 'xxx.xml' |
|
496 |
assert attachment.content_type == 'text/xml' |
|
497 | ||
498 |
formdata = formdef.data_class().get(formdata.id) |
|
499 |
pub.substitutions.feed(formdata) |
|
500 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
501 |
item.parent = st1 |
|
502 |
item.fields = [{'field_id': 'bo1', 'value': '=attachments.xxx'}] |
|
503 |
item.perform(formdata) |
|
504 | ||
505 |
formdata = formdef.data_class().get(formdata.id) |
|
506 |
assert formdata.data['bo1'].base_filename == 'xxx.xml' |
|
507 | ||
508 |
# check storing a file from an assembled dictionary |
|
509 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
510 |
item.parent = st1 |
|
511 |
item.fields = [{'field_id': 'bo1', 'value': '={"content": "hello world", "filename": "hello.txt"}'}] |
|
512 |
item.perform(formdata) |
|
513 | ||
514 |
formdata = formdef.data_class().get(formdata.id) |
|
515 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
516 |
assert formdata.data['bo1'].get_content() == b'hello world' |
|
517 | ||
518 |
# check resetting a value |
|
519 |
for value in ('', None): |
|
520 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
521 |
item.parent = st1 |
|
522 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
523 |
item.perform(formdata) |
|
524 | ||
525 |
formdata = formdef.data_class().get(formdata.id) |
|
526 |
assert formdata.data['bo1'] is None |
|
527 | ||
528 |
# set from base64 content |
|
529 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
530 |
item.parent = st1 |
|
531 |
item.fields = [ |
|
532 |
{'field_id': 'bo1', 'value': '={"b64_content": "SEVMTE8gV09STEQ=", "filename": "hello.txt"}'} |
|
533 |
] |
|
534 |
item.perform(formdata) |
|
535 | ||
536 |
formdata = formdef.data_class().get(formdata.id) |
|
537 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
538 |
assert formdata.data['bo1'].get_content() == b'HELLO WORLD' |
|
539 | ||
540 |
hello_world = formdata.data['bo1'] |
|
541 |
# check wrong value |
|
542 |
for value in ('="HELLO"', 'BAD'): |
|
543 |
formdata.data['bo1'] = hello_world |
|
544 |
formdata.store() |
|
545 | ||
546 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
547 |
item.parent = st1 |
|
548 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
549 | ||
550 |
pub.loggederror_class.wipe() |
|
551 |
item.perform(formdata) |
|
552 | ||
553 |
formdata = formdef.data_class().get(formdata.id) |
|
554 |
assert formdata.data['bo1'].base_filename == 'hello.txt' |
|
555 |
assert formdata.data['bo1'].get_content() == b'HELLO WORLD' |
|
556 |
assert pub.loggederror_class.count() == 1 |
|
557 |
logged_error = pub.loggederror_class.select()[0] |
|
558 |
assert logged_error.summary.startswith('Failed to convert') |
|
559 |
assert logged_error.formdata_id == str(formdata.id) |
|
560 |
assert logged_error.exception_class == 'ValueError' |
|
561 | ||
562 |
# check wrong field |
|
563 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
564 |
item.parent = st1 |
|
565 |
item.fields = [{'field_id': 'bo3', 'value': '=form_var_file_raw'}] |
|
566 |
item.perform(formdata) |
|
567 | ||
568 |
formdata = formdef.data_class().get(formdata.id) |
|
569 |
assert formdata.data.get('bo3') is None |
|
570 | ||
571 | ||
572 |
def test_set_backoffice_field_item(pub): |
|
573 |
Workflow.wipe() |
|
574 |
FormDef.wipe() |
|
575 |
wf = Workflow(name='xxx') |
|
576 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
577 |
st1 = wf.add_status('Status1') |
|
578 |
wf.backoffice_fields_formdef.fields = [ |
|
579 |
ItemField( |
|
580 |
id='bo1', |
|
581 |
label='1st backoffice field', |
|
582 |
type='item', |
|
583 |
varname='backoffice_item', |
|
584 |
items=['a', 'b', 'c'], |
|
585 |
), |
|
586 |
] |
|
587 |
wf.store() |
|
588 | ||
589 |
formdef = FormDef() |
|
590 |
formdef.name = 'baz' |
|
591 |
formdef.fields = [] |
|
592 |
formdef.workflow_id = wf.id |
|
593 |
formdef.store() |
|
594 | ||
595 |
formdata = formdef.data_class()() |
|
596 |
formdata.data = {} |
|
597 |
formdata.just_created() |
|
598 |
formdata.store() |
|
599 | ||
600 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
601 |
item.parent = st1 |
|
602 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
603 |
item.perform(formdata) |
|
604 | ||
605 |
formdata = formdef.data_class().get(formdata.id) |
|
606 |
assert formdata.data['bo1'] == 'a' |
|
607 |
assert formdata.data['bo1_display'] == 'a' |
|
608 | ||
609 |
datasource = {'type': 'formula', 'value': repr([('a', 'aa'), ('b', 'bb'), ('c', 'cc')])} |
|
610 | ||
611 |
wf.backoffice_fields_formdef.fields = [ |
|
612 |
ItemField( |
|
613 |
id='bo1', |
|
614 |
label='1st backoffice field', |
|
615 |
type='item', |
|
616 |
varname='backoffice_item', |
|
617 |
data_source=datasource, |
|
618 |
), |
|
619 |
] |
|
620 |
wf.store() |
|
621 | ||
622 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
623 |
item.parent = st1 |
|
624 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
625 |
item.perform(formdata) |
|
626 | ||
627 |
formdata = formdef.data_class().get(formdata.id) |
|
628 |
assert formdata.data['bo1'] == 'a' |
|
629 |
assert formdata.data['bo1_display'] == 'aa' |
|
630 | ||
631 |
datasource = { |
|
632 |
'type': 'formula', |
|
633 |
'value': repr([{'id': 'a', 'text': 'aa', 'more': 'aaa'}, {'id': 'b', 'text': 'bb', 'more': 'bbb'}]), |
|
634 |
} |
|
635 | ||
636 |
wf.backoffice_fields_formdef.fields = [ |
|
637 |
ItemField( |
|
638 |
id='bo1', |
|
639 |
label='1st backoffice field', |
|
640 |
type='item', |
|
641 |
varname='backoffice_item', |
|
642 |
data_source=datasource, |
|
643 |
), |
|
644 |
] |
|
645 |
wf.store() |
|
646 | ||
647 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
648 |
item.parent = st1 |
|
649 |
item.fields = [{'field_id': 'bo1', 'value': 'a'}] |
|
650 |
item.perform(formdata) |
|
651 | ||
652 |
formdata = formdef.data_class().get(formdata.id) |
|
653 |
assert formdata.data['bo1'] == 'a' |
|
654 |
assert formdata.data['bo1_display'] == 'aa' |
|
655 |
assert formdata.data['bo1_structured'] == {'id': 'a', 'more': 'aaa', 'text': 'aa'} |
|
656 | ||
657 |
# check when assigning using the display value |
|
658 |
formdata = formdef.data_class()() |
|
659 |
formdata.data = {} |
|
660 |
formdata.just_created() |
|
661 |
formdata.store() |
|
662 | ||
663 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
664 |
item.parent = st1 |
|
665 |
item.fields = [{'field_id': 'bo1', 'value': 'aa'}] |
|
666 |
item.perform(formdata) |
|
667 | ||
668 |
formdata = formdef.data_class().get(formdata.id) |
|
669 |
assert formdata.data['bo1'] == 'a' |
|
670 |
assert formdata.data['bo1_display'] == 'aa' |
|
671 |
assert formdata.data['bo1_structured'] == {'id': 'a', 'more': 'aaa', 'text': 'aa'} |
|
672 | ||
673 |
# check with unknown value |
|
674 |
formdata = formdef.data_class()() |
|
675 |
formdata.data = {} |
|
676 |
formdata.just_created() |
|
677 |
formdata.store() |
|
678 | ||
679 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
680 |
item.parent = st1 |
|
681 |
item.fields = [{'field_id': 'bo1', 'value': 'foobar'}] |
|
682 |
item.perform(formdata) |
|
683 | ||
684 |
formdata = formdef.data_class().get(formdata.id) |
|
685 |
assert formdata.data['bo1'] == 'foobar' |
|
686 |
assert formdata.data.get('bo1_display') is None |
|
687 |
assert formdata.data.get('bo1_structured') is None |
|
688 | ||
689 | ||
690 |
def test_set_backoffice_field_card_item(pub): |
|
691 |
CardDef.wipe() |
|
692 |
Workflow.wipe() |
|
693 |
FormDef.wipe() |
|
694 | ||
695 |
carddef = CardDef() |
|
696 |
carddef.name = 'items' |
|
697 |
carddef.digest_templates = {'default': '{{form_var_name}}'} |
|
698 |
carddef.fields = [ |
|
699 |
StringField(id='0', label='string', varname='name'), |
|
700 |
StringField(id='1', label='string', varname='attr'), |
|
701 |
] |
|
702 |
carddef.store() |
|
703 |
carddef.data_class().wipe() |
|
704 |
for i, value in enumerate(['foo', 'bar', 'baz']): |
|
705 |
carddata = carddef.data_class()() |
|
706 |
carddata.data = { |
|
707 |
'0': value, |
|
708 |
'1': 'attr%s' % i, |
|
709 |
} |
|
710 |
carddata.just_created() |
|
711 |
carddata.store() |
|
712 |
latest_carddata = carddata |
|
713 |
latest_carddata_id = carddata.id |
|
714 |
ds = {'type': 'carddef:%s' % carddef.url_name} |
|
715 | ||
716 |
wf = Workflow(name='xxx') |
|
717 |
wf.store() |
|
718 | ||
719 |
formdef = FormDef() |
|
720 |
formdef.name = 'baz' |
|
721 |
formdef.workflow_id = wf.id |
|
722 |
formdef.fields = [ |
|
723 |
ItemField(id='0', label='string', type='item', data_source=ds, display_disabled_items=True) |
|
724 |
] |
|
725 |
formdef.store() |
|
726 | ||
727 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
728 |
st1 = wf.add_status('Status1') |
|
729 |
wf.backoffice_fields_formdef.fields = [ |
|
730 |
ItemField( |
|
731 |
id='bo1', label='1st backoffice field', type='item', varname='backoffice_item', data_source=ds |
|
732 |
), |
|
733 |
] |
|
734 |
wf.store() |
|
735 | ||
736 |
formdef = FormDef() |
|
737 |
formdef.name = 'baz' |
|
738 |
formdef.fields = [] |
|
739 |
formdef.workflow_id = wf.id |
|
740 |
formdef.store() |
|
741 | ||
742 |
formdata = formdef.data_class()() |
|
743 |
formdata.data = {} |
|
744 |
formdata.just_created() |
|
745 |
formdata.store() |
|
746 | ||
747 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
748 |
item.parent = st1 |
|
749 |
item.fields = [{'field_id': 'bo1', 'value': str(latest_carddata_id)}] |
|
750 |
item.perform(formdata) |
|
751 | ||
752 |
formdata = formdef.data_class().get(formdata.id) |
|
753 |
assert formdata.data['bo1'] == str(latest_carddata_id) |
|
754 |
assert formdata.data['bo1_display'] == 'baz' |
|
755 |
assert formdata.data['bo1_structured']['attr'] == 'attr2' |
|
756 | ||
757 |
# reset, and get by display id value |
|
758 |
formdata.data = {} |
|
759 |
formdata.store() |
|
760 |
item.fields = [{'field_id': 'bo1', 'value': latest_carddata.get_display_id()}] |
|
761 |
item.perform(formdata) |
|
762 |
formdata = formdef.data_class().get(formdata.id) |
|
763 |
assert formdata.data['bo1'] == str(latest_carddata_id) |
|
764 |
assert formdata.data['bo1_display'] == 'baz' |
|
765 |
assert formdata.data['bo1_structured']['attr'] == 'attr2' |
|
766 | ||
767 |
# reset, and get by text value |
|
768 |
formdata.data = {} |
|
769 |
formdata.store() |
|
770 |
item.fields = [{'field_id': 'bo1', 'value': 'bar'}] |
|
771 |
item.perform(formdata) |
|
772 |
formdata = formdef.data_class().get(formdata.id) |
|
773 |
assert formdata.data['bo1'] != str(latest_carddata_id) |
|
774 |
assert formdata.data['bo1_display'] == 'bar' |
|
775 |
assert formdata.data['bo1_structured']['attr'] == 'attr1' |
|
776 | ||
777 |
# reset, with unknown value |
|
778 |
pub.loggederror_class.wipe() |
|
779 |
formdata.data = {} |
|
780 |
formdata.store() |
|
781 |
item.fields = [{'field_id': 'bo1', 'value': 'xxx'}] |
|
782 |
item.perform(formdata) |
|
783 |
formdata = formdef.data_class().get(formdata.id) |
|
784 |
assert formdata.data.get('bo1') is None # invalid value is not stored |
|
785 |
assert formdata.data.get('bo1_display') is None |
|
786 |
assert formdata.data.get('bo1_structured') is None |
|
787 |
assert pub.loggederror_class.count() == 1 |
|
788 |
logged_error = pub.loggederror_class.select()[0] |
|
789 |
assert logged_error.summary.startswith('Failed to convert') |
|
790 | ||
791 |
# reset, and get empty value |
|
792 |
formdata.data = {} |
|
793 |
formdata.store() |
|
794 |
item.fields = [{'field_id': 'bo1', 'value': ''}] |
|
795 |
item.perform(formdata) |
|
796 |
formdata = formdef.data_class().get(formdata.id) |
|
797 |
assert formdata.data['bo1'] is None |
|
798 |
assert formdata.data.get('bo1_display') is None |
|
799 |
assert formdata.data.get('bo1_structured') is None |
|
800 | ||
801 | ||
802 |
def test_set_backoffice_field_items(pub): |
|
803 |
Workflow.wipe() |
|
804 |
FormDef.wipe() |
|
805 |
wf = Workflow(name='xxx') |
|
806 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
807 |
st1 = wf.add_status('Status1') |
|
808 |
wf.backoffice_fields_formdef.fields = [ |
|
809 |
ItemsField( |
|
810 |
id='bo1', |
|
811 |
label='1st backoffice field', |
|
812 |
type='items', |
|
813 |
varname='backoffice_item', |
|
814 |
items=['a', 'b', 'c'], |
|
815 |
), |
|
816 |
] |
|
817 |
wf.store() |
|
818 | ||
819 |
formdef = FormDef() |
|
820 |
formdef.name = 'baz' |
|
821 |
formdef.fields = [] |
|
822 |
formdef.workflow_id = wf.id |
|
823 |
formdef.store() |
|
824 | ||
825 |
formdata = formdef.data_class()() |
|
826 |
formdata.data = {} |
|
827 |
formdata.just_created() |
|
828 |
formdata.store() |
|
829 | ||
830 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
831 |
item.parent = st1 |
|
832 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'b']"}] |
|
833 |
item.perform(formdata) |
|
834 | ||
835 |
formdata = formdef.data_class().get(formdata.id) |
|
836 |
assert formdata.data['bo1'] == ['a', 'b'] |
|
837 |
assert formdata.data['bo1_display'] == 'a, b' |
|
838 | ||
839 |
datasource = {'type': 'formula', 'value': repr([('a', 'aa'), ('b', 'bb'), ('c', 'cc')])} |
|
840 | ||
841 |
wf.backoffice_fields_formdef.fields = [ |
|
842 |
ItemsField( |
|
843 |
id='bo1', |
|
844 |
label='1st backoffice field', |
|
845 |
type='items', |
|
846 |
varname='backoffice_item', |
|
847 |
data_source=datasource, |
|
848 |
), |
|
849 |
] |
|
850 |
wf.store() |
|
851 | ||
852 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
853 |
item.parent = st1 |
|
854 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'b']"}] |
|
855 |
item.perform(formdata) |
|
856 | ||
857 |
formdata = formdef.data_class().get(formdata.id) |
|
858 |
assert formdata.data['bo1'] == ['a', 'b'] |
|
859 |
assert formdata.data['bo1_display'] == 'aa, bb' |
|
860 | ||
861 |
datasource = { |
|
862 |
'type': 'formula', |
|
863 |
'value': repr( |
|
864 |
[ |
|
865 |
{'id': 'a', 'text': 'aa', 'more': 'aaa'}, |
|
866 |
{'id': 'b', 'text': 'bb', 'more': 'bbb'}, |
|
867 |
{'id': 'c', 'text': 'cc', 'more': 'ccc'}, |
|
868 |
] |
|
869 |
), |
|
870 |
} |
|
871 | ||
872 |
wf.backoffice_fields_formdef.fields = [ |
|
873 |
ItemsField( |
|
874 |
id='bo1', |
|
875 |
label='1st backoffice field', |
|
876 |
type='items', |
|
877 |
varname='backoffice_item', |
|
878 |
data_source=datasource, |
|
879 |
), |
|
880 |
] |
|
881 |
wf.store() |
|
882 | ||
883 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
884 |
item.parent = st1 |
|
885 |
item.fields = [{'field_id': 'bo1', 'value': "=['a', 'c']"}] |
|
886 |
item.perform(formdata) |
|
887 | ||
888 |
formdata = formdef.data_class().get(formdata.id) |
|
889 |
assert formdata.data['bo1'] == ['a', 'c'] |
|
890 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
891 |
assert len(formdata.data['bo1_structured']) == 2 |
|
892 |
assert {'id': 'a', 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
893 |
assert {'id': 'c', 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
894 | ||
895 |
# from formdata field |
|
896 |
formdef.fields = [ |
|
897 |
ItemsField(id='1', label='field', type='items', varname='items', data_source=datasource), |
|
898 |
] |
|
899 |
formdef.store() |
|
900 | ||
901 |
formdata = formdef.data_class()() |
|
902 |
formdata.data = {'1': ['a', 'c']} |
|
903 |
formdata.data['1_display'] = formdef.fields[0].store_display_value(formdata.data, '1') |
|
904 |
formdata.data['1_structured'] = formdef.fields[0].store_structured_value(formdata.data, '1') |
|
905 |
formdata.just_created() |
|
906 |
formdata.store() |
|
907 |
pub.substitutions.feed(formdata) |
|
908 | ||
909 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
910 |
item.parent = st1 |
|
911 |
item.fields = [{'field_id': 'bo1', 'value': "=form_var_items_raw"}] |
|
912 |
item.perform(formdata) |
|
913 | ||
914 |
assert formdata.data['bo1'] == ['a', 'c'] |
|
915 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
916 |
assert len(formdata.data['bo1_structured']) == 2 |
|
917 |
assert {'id': 'a', 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
918 |
assert {'id': 'c', 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
919 | ||
920 |
# with a template |
|
921 |
formdata = formdef.data_class()() |
|
922 |
formdata.data = {'1': ['a', 'c']} |
|
923 |
formdata.data['1_display'] = formdef.fields[0].store_display_value(formdata.data, '1') |
|
924 |
formdata.data['1_structured'] = formdef.fields[0].store_structured_value(formdata.data, '1') |
|
925 |
formdata.just_created() |
|
926 |
formdata.store() |
|
927 |
pub.substitutions.reset() |
|
928 |
pub.substitutions.feed(formdata) |
|
929 | ||
930 |
item.fields = [{'field_id': 'bo1', 'value': "{{form_var_items_raw}}"}] |
|
931 |
item.perform(formdata) |
|
932 | ||
933 |
# using a single int |
|
934 |
datasource = { |
|
935 |
'type': 'formula', |
|
936 |
'value': repr( |
|
937 |
[ |
|
938 |
{'id': 1, 'text': 'aa', 'more': 'aaa'}, |
|
939 |
{'id': 2, 'text': 'bb', 'more': 'bbb'}, |
|
940 |
{'id': 3, 'text': 'cc', 'more': 'ccc'}, |
|
941 |
] |
|
942 |
), |
|
943 |
} |
|
944 | ||
945 |
wf.backoffice_fields_formdef.fields = [ |
|
946 |
ItemsField( |
|
947 |
id='bo1', |
|
948 |
label='1st backoffice field', |
|
949 |
type='items', |
|
950 |
varname='backoffice_item', |
|
951 |
data_source=datasource, |
|
952 |
), |
|
953 |
] |
|
954 |
wf.store() |
|
955 | ||
956 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
957 |
item.parent = st1 |
|
958 |
item.fields = [{'field_id': 'bo1', 'value': "=2"}] |
|
959 |
item.perform(formdata) |
|
960 | ||
961 |
formdata = formdef.data_class().get(formdata.id) |
|
962 |
assert formdata.data['bo1'] == ['2'] |
|
963 |
assert formdata.data['bo1_display'] == 'bb' |
|
964 |
assert len(formdata.data['bo1_structured']) == 1 |
|
965 | ||
966 |
# using an invalid value |
|
967 |
formdata.data = {} |
|
968 |
formdata.store() |
|
969 |
pub.loggederror_class.wipe() |
|
970 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
971 |
item.parent = st1 |
|
972 |
item.fields = [{'field_id': 'bo1', 'value': "=Ellipsis"}] |
|
973 |
item.perform(formdata) |
|
974 |
assert pub.loggederror_class.count() == 1 |
|
975 |
logged_error = pub.loggederror_class.select()[0] |
|
976 |
assert 'Failed to convert' in logged_error.summary |
|
977 | ||
978 |
# using a string with multiple values |
|
979 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
980 |
item.parent = st1 |
|
981 |
item.fields = [{'field_id': 'bo1', 'value': "1|3"}] |
|
982 |
item.perform(formdata) |
|
983 | ||
984 |
formdata = formdef.data_class().get(formdata.id) |
|
985 |
assert formdata.data['bo1'] == ['1', '3'] |
|
986 |
assert formdata.data['bo1_display'] == 'aa, cc' |
|
987 |
assert len(formdata.data['bo1_structured']) == 2 |
|
988 |
assert {'id': 1, 'more': 'aaa', 'text': 'aa'} in formdata.data['bo1_structured'] |
|
989 |
assert {'id': 3, 'more': 'ccc', 'text': 'cc'} in formdata.data['bo1_structured'] |
|
990 | ||
991 | ||
992 |
def test_set_backoffice_field_date(pub): |
|
993 |
Workflow.wipe() |
|
994 |
FormDef.wipe() |
|
995 |
wf = Workflow(name='xxx') |
|
996 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
997 |
st1 = wf.add_status('Status1') |
|
998 |
wf.backoffice_fields_formdef.fields = [ |
|
999 |
DateField(id='bo1', label='1st backoffice field', type='date', varname='backoffice_date'), |
|
1000 |
] |
|
1001 |
wf.store() |
|
1002 | ||
1003 |
formdef = FormDef() |
|
1004 |
formdef.name = 'baz' |
|
1005 |
formdef.fields = [] |
|
1006 |
formdef.workflow_id = wf.id |
|
1007 |
formdef.store() |
|
1008 | ||
1009 |
formdata = formdef.data_class()() |
|
1010 |
formdata.data = {} |
|
1011 |
formdata.just_created() |
|
1012 |
formdata.store() |
|
1013 | ||
1014 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1015 |
item.parent = st1 |
|
1016 |
item.fields = [{'field_id': 'bo1', 'value': "=utils.today()"}] |
|
1017 |
item.perform(formdata) |
|
1018 | ||
1019 |
formdata = formdef.data_class().get(formdata.id) |
|
1020 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date.today() |
|
1021 | ||
1022 |
formdata.data['bo1'] = None |
|
1023 |
formdata.store() |
|
1024 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1025 |
item.parent = st1 |
|
1026 |
item.fields = [{'field_id': 'bo1', 'value': '{% now "j/n/Y" %}'}] |
|
1027 |
item.perform(formdata) |
|
1028 | ||
1029 |
formdata = formdef.data_class().get(formdata.id) |
|
1030 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date.today() |
|
1031 | ||
1032 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1033 |
item.parent = st1 |
|
1034 |
item.fields = [{'field_id': 'bo1', 'value': "23/3/2017"}] |
|
1035 |
item.perform(formdata) |
|
1036 | ||
1037 |
formdata = formdef.data_class().get(formdata.id) |
|
1038 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23) |
|
1039 | ||
1040 |
# invalid values => do nothing |
|
1041 |
assert pub.loggederror_class.count() == 0 |
|
1042 |
for value in ('plop', '={}', '=[]'): |
|
1043 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1044 |
item.parent = st1 |
|
1045 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
1046 | ||
1047 |
pub.loggederror_class.wipe() |
|
1048 |
item.perform(formdata) |
|
1049 |
formdata = formdef.data_class().get(formdata.id) |
|
1050 |
assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23) |
|
1051 |
assert pub.loggederror_class.count() == 1 |
|
1052 |
assert pub.loggederror_class.select()[0].summary.startswith('Failed to convert') |
|
1053 | ||
1054 |
# None : empty date |
|
1055 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1056 |
item.parent = st1 |
|
1057 |
item.fields = [{'field_id': 'bo1', 'value': None}] |
|
1058 |
item.perform(formdata) |
|
1059 | ||
1060 |
formdata = formdef.data_class().get(formdata.id) |
|
1061 |
assert formdata.data['bo1'] is None |
|
1062 | ||
1063 | ||
1064 |
def test_set_backoffice_field_boolean(pub): |
|
1065 |
Workflow.wipe() |
|
1066 |
FormDef.wipe() |
|
1067 |
wf = Workflow(name='xxx') |
|
1068 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1069 |
st1 = wf.add_status('Status1') |
|
1070 |
wf.backoffice_fields_formdef.fields = [ |
|
1071 |
BoolField(id='bo1', label='1st backoffice field', type='bool', varname='backoffice_bool'), |
|
1072 |
] |
|
1073 |
wf.store() |
|
1074 | ||
1075 |
formdef = FormDef() |
|
1076 |
formdef.name = 'baz' |
|
1077 |
formdef.fields = [BoolField(id='1', label='field', type='bool', varname='foo')] |
|
1078 |
formdef.workflow_id = wf.id |
|
1079 |
formdef.store() |
|
1080 | ||
1081 |
formdata = formdef.data_class()() |
|
1082 |
formdata.data = {'1': True} |
|
1083 |
formdata.just_created() |
|
1084 |
formdata.store() |
|
1085 |
get_publisher().substitutions.feed(formdata) |
|
1086 | ||
1087 |
for value in ('=True', '=form_var_foo_raw', '{{ form_var_foo_raw }}', 'True', 'Yes', 'true', 'yes'): |
|
1088 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1089 |
item.parent = st1 |
|
1090 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
1091 |
item.perform(formdata) |
|
1092 |
formdata = formdef.data_class().get(formdata.id) |
|
1093 |
assert formdata.data['bo1'] is True |
|
1094 |
formdata.data['bo1'] = None |
|
1095 |
formdata.store() |
|
1096 | ||
1097 |
for value in ('=False', '=not(form_var_foo_raw)', 'False', 'plop', ''): |
|
1098 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1099 |
item.parent = st1 |
|
1100 |
item.fields = [{'field_id': 'bo1', 'value': value}] |
|
1101 |
item.perform(formdata) |
|
1102 |
formdata = formdef.data_class().get(formdata.id) |
|
1103 |
assert formdata.data['bo1'] is False |
|
1104 |
formdata.data['bo1'] = None |
|
1105 |
formdata.store() |
|
1106 | ||
1107 | ||
1108 |
def test_set_backoffice_field_str_time_filter(pub): |
|
1109 |
Workflow.wipe() |
|
1110 |
FormDef.wipe() |
|
1111 |
wf = Workflow(name='xxx') |
|
1112 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1113 |
st1 = wf.add_status('Status1') |
|
1114 |
wf.backoffice_fields_formdef.fields = [ |
|
1115 |
StringField(id='bo1', label='1st backoffice field', type='str', varname='backoffice_str'), |
|
1116 |
] |
|
1117 |
wf.store() |
|
1118 | ||
1119 |
formdef = FormDef() |
|
1120 |
formdef.name = 'baz' |
|
1121 |
formdef.fields = [StringField(id='1', label='field', type='str', varname='foo')] |
|
1122 |
formdef.workflow_id = wf.id |
|
1123 |
formdef.store() |
|
1124 | ||
1125 |
formdata = formdef.data_class()() |
|
1126 |
formdata.data = {'1': '09:00'} |
|
1127 |
formdata.just_created() |
|
1128 |
formdata.store() |
|
1129 |
get_publisher().substitutions.feed(formdata) |
|
1130 | ||
1131 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1132 |
item.parent = st1 |
|
1133 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_foo|time:"H:i:s" }}'}] |
|
1134 |
item.perform(formdata) |
|
1135 |
formdata = formdef.data_class().get(formdata.id) |
|
1136 |
assert formdata.data['bo1'] == '09:00:00' |
|
1137 |
formdata.data['bo1'] = None |
|
1138 |
formdata.store() |
|
1139 | ||
1140 |
# |time will yield the default django reprentation |
|
1141 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1142 |
item.parent = st1 |
|
1143 |
item.fields = [{'field_id': 'bo1', 'value': '{{ form_var_foo|time }}'}] |
|
1144 |
item.perform(formdata) |
|
1145 |
formdata = formdef.data_class().get(formdata.id) |
|
1146 |
assert formdata.data['bo1'] == '9 a.m.' |
|
1147 |
formdata.data['bo1'] = None |
|
1148 |
formdata.store() |
|
1149 | ||
1150 | ||
1151 |
def test_set_backoffice_field_block(pub): |
|
1152 |
BlockDef.wipe() |
|
1153 |
Workflow.wipe() |
|
1154 |
FormDef.wipe() |
|
1155 | ||
1156 |
block = BlockDef() |
|
1157 |
block.name = 'foobar' |
|
1158 |
block.digest_template = 'X{{foobar_var_foo}}Y' |
|
1159 |
block.fields = [ |
|
1160 |
StringField(id='123', required=True, label='Test', type='string', varname='foo'), |
|
1161 |
StringField(id='234', required=True, label='Test2', type='string', varname='bar'), |
|
1162 |
] |
|
1163 |
block.store() |
|
1164 | ||
1165 |
wf = Workflow(name='xxx') |
|
1166 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1167 |
st1 = wf.add_status('Status1') |
|
1168 |
wf.backoffice_fields_formdef.fields = [ |
|
1169 |
BlockField(id='bo1', label='1st backoffice field', type='block:foobar'), |
|
1170 |
StringField(id='bo2', label='2nd backoffice field', type='string'), |
|
1171 |
] |
|
1172 |
wf.store() |
|
1173 | ||
1174 |
formdef = FormDef() |
|
1175 |
formdef.name = 'baz' |
|
1176 |
formdef.fields = [ |
|
1177 |
BlockField(id='1', label='test', type='block:foobar', max_items=3, varname='foo'), |
|
1178 |
] |
|
1179 |
formdef.workflow_id = wf.id |
|
1180 |
formdef.store() |
|
1181 | ||
1182 |
formdata = formdef.data_class()() |
|
1183 |
# value from test_block_digest in tests/test_form_pages.py |
|
1184 |
formdata.data = { |
|
1185 |
'1': { |
|
1186 |
'data': [{'123': 'foo', '234': 'bar'}, {'123': 'foo2', '234': 'bar2'}], |
|
1187 |
'schema': {'123': 'string', '234': 'string'}, |
|
1188 |
}, |
|
1189 |
'1_display': 'XfooY, Xfoo2Y', |
|
1190 |
} |
|
1191 |
formdata.just_created() |
|
1192 |
formdata.store() |
|
1193 |
get_publisher().substitutions.feed(formdata) |
|
1194 | ||
1195 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1196 |
item.parent = st1 |
|
1197 |
item.fields = [{'field_id': 'bo1', 'value': '{{form_var_foo_raw}}'}] |
|
1198 |
item.perform(formdata) |
|
1199 |
formdata = formdef.data_class().get(formdata.id) |
|
1200 |
assert formdata.data['bo1'] == formdata.data['1'] |
|
1201 |
assert formdata.data['bo1_display'] == formdata.data['1_display'] |
|
1202 | ||
1203 |
# without _raw suffix |
|
1204 |
formdata = formdef.data_class()() |
|
1205 |
# value from test_block_digest in tests/test_form_pages.py |
|
1206 |
formdata.data = { |
|
1207 |
'1': { |
|
1208 |
'data': [{'123': 'foo', '234': 'bar'}, {'123': 'foo2', '234': 'bar2'}], |
|
1209 |
'schema': {'123': 'string', '234': 'string'}, |
|
1210 |
}, |
|
1211 |
'1_display': 'XfooY, Xfoo2Y', |
|
1212 |
} |
|
1213 |
formdata.just_created() |
|
1214 |
formdata.store() |
|
1215 |
get_publisher().substitutions.reset() |
|
1216 |
get_publisher().substitutions.feed(formdata) |
|
1217 | ||
1218 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1219 |
item.parent = st1 |
|
1220 |
item.fields = [ |
|
1221 |
{'field_id': 'bo1', 'value': '{{form_var_foo}}'}, |
|
1222 |
{'field_id': 'bo2', 'value': '{{form_var_foo}}'}, |
|
1223 |
] |
|
1224 |
item.perform(formdata) |
|
1225 |
formdata = formdef.data_class().get(formdata.id) |
|
1226 |
assert formdata.data['bo1'] == formdata.data['1'] |
|
1227 |
assert formdata.data['bo1_display'] == formdata.data['1_display'] |
|
1228 |
assert formdata.data['bo2'] == formdata.data['1_display'] |
|
1229 | ||
1230 | ||
1231 |
def test_set_backoffice_field_block_template_tag(pub): |
|
1232 |
BlockDef.wipe() |
|
1233 |
Workflow.wipe() |
|
1234 |
FormDef.wipe() |
|
1235 | ||
1236 |
block = BlockDef() |
|
1237 |
block.name = 'foobar' |
|
1238 |
block.digest_template = 'X{{foobar_var_foo}}Y' |
|
1239 |
block.fields = [ |
|
1240 |
StringField(id='123', required=True, label='Test', type='string', varname='foo'), |
|
1241 |
StringField(id='234', required=True, label='Test2', type='string', varname='bar'), |
|
1242 |
] |
|
1243 |
block.store() |
|
1244 | ||
1245 |
wf = Workflow(name='xxx') |
|
1246 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1247 |
st1 = wf.add_status('Status1') |
|
1248 |
wf.backoffice_fields_formdef.fields = [ |
|
1249 |
BlockField(id='bo1', label='1st backoffice field', max_items=3, type='block:foobar'), |
|
1250 |
] |
|
1251 |
wf.store() |
|
1252 | ||
1253 |
formdef = FormDef() |
|
1254 |
formdef.name = 'baz' |
|
1255 |
formdef.fields = [ |
|
1256 |
StringField(id='1', label='test', varname='foo'), |
|
1257 |
] |
|
1258 |
formdef.workflow_id = wf.id |
|
1259 |
formdef.store() |
|
1260 | ||
1261 |
formdata = formdef.data_class()() |
|
1262 |
formdata.data = {'1': 'plop'} |
|
1263 |
formdata.just_created() |
|
1264 |
formdata.store() |
|
1265 |
get_publisher().substitutions.feed(formdata) |
|
1266 | ||
1267 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1268 |
item.parent = st1 |
|
1269 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value foo=form_var_foo bar="xxx" %}'}] |
|
1270 |
item.perform(formdata) |
|
1271 |
formdata = formdef.data_class().get(formdata.id) |
|
1272 |
assert formdata.data['bo1'] == { |
|
1273 |
'data': [{'123': 'plop', '234': 'xxx'}], |
|
1274 |
'schema': {'123': 'string', '234': 'string'}, |
|
1275 |
} |
|
1276 |
assert formdata.data['bo1_display'] == 'XplopY' |
|
1277 | ||
1278 |
# override |
|
1279 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1280 |
item.parent = st1 |
|
1281 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value foo=form_var_foo bar="yyy" %}'}] |
|
1282 |
item.perform(formdata) |
|
1283 |
formdata = formdef.data_class().get(formdata.id) |
|
1284 |
assert formdata.data['bo1'] == { |
|
1285 |
'data': [{'123': 'plop', '234': 'yyy'}], |
|
1286 |
'schema': {'123': 'string', '234': 'string'}, |
|
1287 |
} |
|
1288 |
assert formdata.data['bo1_display'] == 'XplopY' |
|
1289 | ||
1290 |
# append |
|
1291 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1292 |
item.parent = st1 |
|
1293 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value append=True foo="zzz" bar=form_var_foo %}'}] |
|
1294 |
item.perform(formdata) |
|
1295 |
formdata = formdef.data_class().get(formdata.id) |
|
1296 |
assert formdata.data['bo1'] == { |
|
1297 |
'data': [{'123': 'plop', '234': 'yyy'}, {'123': 'zzz', '234': 'plop'}], |
|
1298 |
'schema': {'123': 'string', '234': 'string'}, |
|
1299 |
} |
|
1300 |
assert formdata.data['bo1_display'] == 'XplopY, XzzzY' |
|
1301 | ||
1302 |
# merge (into last row) |
|
1303 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1304 |
item.parent = st1 |
|
1305 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=True foo="AAA" %}'}] |
|
1306 |
item.perform(formdata) |
|
1307 |
formdata = formdef.data_class().get(formdata.id) |
|
1308 |
assert formdata.data['bo1'] == { |
|
1309 |
'data': [{'123': 'plop', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
1310 |
'schema': {'123': 'string', '234': 'string'}, |
|
1311 |
} |
|
1312 |
assert formdata.data['bo1_display'] == 'XplopY, XAAAY' |
|
1313 | ||
1314 |
# merge (into given row) |
|
1315 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1316 |
item.parent = st1 |
|
1317 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=0 foo="BBB" %}'}] |
|
1318 |
item.perform(formdata) |
|
1319 |
formdata = formdef.data_class().get(formdata.id) |
|
1320 |
assert formdata.data['bo1'] == { |
|
1321 |
'data': [{'123': 'BBB', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
1322 |
'schema': {'123': 'string', '234': 'string'}, |
|
1323 |
} |
|
1324 |
assert formdata.data['bo1_display'] == 'XBBBY, XAAAY' |
|
1325 | ||
1326 |
# merge with indexerror (ignored) |
|
1327 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1328 |
item.parent = st1 |
|
1329 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value merge=50 foo="CCC" %}'}] |
|
1330 |
item.perform(formdata) |
|
1331 |
formdata = formdef.data_class().get(formdata.id) |
|
1332 |
assert formdata.data['bo1'] == { |
|
1333 |
'data': [{'123': 'BBB', '234': 'yyy'}, {'123': 'AAA', '234': 'plop'}], |
|
1334 |
'schema': {'123': 'string', '234': 'string'}, |
|
1335 |
} |
|
1336 |
assert formdata.data['bo1_display'] == 'XBBBY, XAAAY' |
|
1337 | ||
1338 |
# "item" subfield, make sure raw and display and structured values are stored |
|
1339 |
datasource = { |
|
1340 |
'type': 'formula', |
|
1341 |
'value': repr( |
|
1342 |
[ |
|
1343 |
{'id': 'a', 'text': 'aa', 'more': 'aaa'}, |
|
1344 |
{'id': 'b', 'text': 'bb', 'more': 'bbb'}, |
|
1345 |
{'id': 'c', 'text': 'cc', 'more': 'ccc'}, |
|
1346 |
] |
|
1347 |
), |
|
1348 |
} |
|
1349 |
block.fields.append( |
|
1350 |
ItemField(id='345', label='Test3', type='item', varname='item', data_source=datasource) |
|
1351 |
) |
|
1352 |
block.store() |
|
1353 |
wf.backoffice_fields_formdef.fields[0]._block = None # remove cache |
|
1354 | ||
1355 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1356 |
item.parent = st1 |
|
1357 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value item="b" %}'}] |
|
1358 |
item.perform(formdata) |
|
1359 |
formdata = formdef.data_class().get(formdata.id) |
|
1360 |
assert formdata.data['bo1'] == { |
|
1361 |
'data': [ |
|
1362 |
{'345': 'b', '345_display': 'bb', '345_structured': {'id': 'b', 'text': 'bb', 'more': 'bbb'}} |
|
1363 |
], |
|
1364 |
'schema': {'123': 'string', '234': 'string', '345': 'item'}, |
|
1365 |
} |
|
1366 |
assert formdata.data['bo1_display'] == 'XNoneY' |
|
1367 | ||
1368 |
# append to invalid existing value (should not happen) |
|
1369 |
formdata.data['bo1'] = {'invalid': 'value'} |
|
1370 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1371 |
item.parent = st1 |
|
1372 |
item.fields = [{'field_id': 'bo1', 'value': '{% block_value item="b" append=True %}'}] |
|
1373 |
item.perform(formdata) |
|
1374 |
formdata = formdef.data_class().get(formdata.id) |
|
1375 |
assert formdata.data['bo1'] == { |
|
1376 |
'data': [ |
|
1377 |
{'345': 'b', '345_display': 'bb', '345_structured': {'id': 'b', 'text': 'bb', 'more': 'bbb'}} |
|
1378 |
], |
|
1379 |
'schema': {'123': 'string', '234': 'string', '345': 'item'}, |
|
1380 |
} |
|
1381 |
assert formdata.data['bo1_display'] == 'XNoneY' |
|
1382 | ||
1383 | ||
1384 |
def test_set_backoffice_field_invalid_block_value(pub): |
|
1385 |
BlockDef.wipe() |
|
1386 |
Workflow.wipe() |
|
1387 |
FormDef.wipe() |
|
1388 | ||
1389 |
block = BlockDef() |
|
1390 |
block.name = 'foobar' |
|
1391 |
block.fields = [StringField(id='123', required=True, label='Test', type='string', varname='foo')] |
|
1392 |
block.store() |
|
1393 | ||
1394 |
wf = Workflow(name='xxx') |
|
1395 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1396 |
st1 = wf.add_status('Status1') |
|
1397 |
wf.backoffice_fields_formdef.fields = [ |
|
1398 |
BlockField(id='bo1', label='1st backoffice field', max_items=3, type='block:foobar'), |
|
1399 |
] |
|
1400 |
wf.store() |
|
1401 | ||
1402 |
formdef = FormDef() |
|
1403 |
formdef.name = 'baz' |
|
1404 |
formdef.fields = [] |
|
1405 |
formdef.workflow_id = wf.id |
|
1406 |
formdef.store() |
|
1407 | ||
1408 |
formdata = formdef.data_class()() |
|
1409 |
formdata.just_created() |
|
1410 |
formdata.store() |
|
1411 |
get_publisher().substitutions.feed(formdata) |
|
1412 | ||
1413 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1414 |
item.parent = st1 |
|
1415 |
item.fields = [{'field_id': 'bo1', 'value': 'xxx'}] |
|
1416 | ||
1417 |
pub.loggederror_class.wipe() |
|
1418 |
item.perform(formdata) |
|
1419 |
assert pub.loggederror_class.count() == 1 |
|
1420 |
logged_error = pub.loggederror_class.select()[0] |
|
1421 |
assert ( |
|
1422 |
logged_error.summary |
|
1423 |
== 'Failed to set Field Block (foobar) field (bo1), error: invalid value for block' |
|
1424 |
) |
|
1425 | ||
1426 |
formdata = formdef.data_class().get(formdata.id) |
|
1427 |
assert not formdata.data.get('bo1') |
|
1428 | ||
1429 | ||
1430 |
def test_set_backoffice_field_immediate_use(http_requests, pub): |
|
1431 |
Workflow.wipe() |
|
1432 |
FormDef.wipe() |
|
1433 |
wf = Workflow(name='xxx') |
|
1434 |
wf.backoffice_fields_formdef = WorkflowBackofficeFieldsFormDef(wf) |
|
1435 |
wf.backoffice_fields_formdef.fields = [ |
|
1436 |
StringField(id='bo1', label='1st backoffice field', type='string', varname='backoffice_blah'), |
|
1437 |
StringField(id='bo2', label='2nd backoffice field', type='string', varname='backoffice_barr'), |
|
1438 |
] |
|
1439 |
st1 = wf.add_status('Status1') |
|
1440 |
wf.store() |
|
1441 | ||
1442 |
formdef = FormDef() |
|
1443 |
formdef.name = 'baz' |
|
1444 |
formdef.fields = [ |
|
1445 |
StringField(id='00', label='String', type='string', varname='string'), |
|
1446 |
] |
|
1447 |
formdef.workflow_id = wf.id |
|
1448 |
formdef.store() |
|
1449 | ||
1450 |
formdata = formdef.data_class()() |
|
1451 |
formdata.data = {'00': 'HELLO'} |
|
1452 |
formdata.just_created() |
|
1453 |
formdata.store() |
|
1454 |
item = SetBackofficeFieldsWorkflowStatusItem() |
|
1455 |
item.parent = st1 |
|
1456 | ||
1457 |
item.fields = [ |
|
1458 |
{'field_id': 'bo1', 'value': '{{form_var_string}}'}, |
|
1459 |
] |
|
1460 |
pub.substitutions.reset() |
|
1461 |
pub.substitutions.feed(formdata) |
|
1462 |
item.perform(formdata) |
|
1463 |
formdata = formdef.data_class().get(formdata.id) |
|
1464 |
assert formdata.data.get('bo1') == 'HELLO' |
|
1465 | ||
1466 |
item.fields = [ |
|
1467 |
{'field_id': 'bo1', 'value': 'WORLD'}, |
|
1468 |
] |
|
1469 |
pub.substitutions.reset() |
|
1470 |
pub.substitutions.feed(formdata) |
|
1471 |
item.perform(formdata) |
|
1472 |
formdata = formdef.data_class().get(formdata.id) |
|
1473 |
assert formdata.data.get('bo1') == 'WORLD' |
|
1474 | ||
1475 |
item.fields = [ |
|
1476 |
{'field_id': 'bo1', 'value': 'X{{form_var_string}}X'}, |
|
1477 |
{'field_id': 'bo2', 'value': "Y{{form_var_backoffice_blah}}Y"}, |
|
1478 |
] |
|
1479 |
pub.substitutions.reset() |
|
1480 |
pub.substitutions.feed(formdata) |
|
1481 |
item.perform(formdata) |
|
1482 |
formdata = formdef.data_class().get(formdata.id) |
|
1483 |
assert formdata.data.get('bo1') == 'XHELLOX' |
|
1484 |
assert formdata.data.get('bo2') == 'YXHELLOXY' |
|
0 |
- |