0001-wf-export_to_model-support-XML-templates-56537.patch

Benjamin Dauvergne, 02 septembre 2021 13:23

Voir les différences: en ligne côte à côte

Subject: [PATCH] wf/export_to_model: support XML templates (#56537)

 tests/test_workflows.py   | 50 +++++++++++++++++++++++++++++++++++++--
 wcs/wf/export_to_model.py | 50 +++++++++++++++++++++++++++++++++++----
 2 files changed, 94 insertions(+), 6 deletions(-)

     from wcs.formdata import Evolution
     from wcs.formdef import FormDef
     from wcs.qommon.errors import ConnectionError
     from wcs.qommon.form import Form, UploadedFile
     from wcs.qommon.form import Form, UploadedFile, UploadValidationError
     from wcs.qommon.http_request import HTTPRequest
     from wcs.qommon.upload_storage import PicklableUpload
     from wcs.wf.aggregation_email import (
-...
     from wcs.wf.criticality import MODE_DEC, MODE_INC, MODE_SET, ModifyCriticalityWorkflowStatusItem
     from wcs.wf.dispatch import DispatchWorkflowStatusItem
     from wcs.wf.edit_carddata import EditCarddataWorkflowStatusItem
     from wcs.wf.export_to_model import ExportToModel, transform_to_pdf
     from wcs.wf.export_to_model import ExportToModel, TemplatingError, transform_to_pdf
     from wcs.wf.form import FormWorkflowStatusItem, WorkflowFormFieldsFormDef
     from wcs.wf.geolocate import GeolocateWorkflowStatusItem
     from wcs.wf.jump import JumpWorkflowStatusItem, _apply_timeouts
-...
         assert b'>A &lt;&gt; name<' in new_content
     def test_export_to_model_xml(pub):
         formdef = FormDef()
         formdef.name = 'foo-export-to-template-with-django'
         formdef.fields = [
             StringField(id='1', label='String', type='string', varname='string'),
+        ]
         formdef.store()
         formdata = formdef.data_class()()
         formdata.data = {'1': 'écho'}
         formdata.just_created()
         formdata.store()
         # good XML
         item = ExportToModel()
         item.method = 'non-interactive'
         item.attach_to_history = True
         def run(template, filename='/foo/template.xml', content_type='application/xml'):
             upload = QuixoteUpload(filename, content_type=content_type)
             upload.fp = io.BytesIO()
             upload.fp.write(template.encode())
             upload.fp.seek(0)
             item.model_file = UploadedFile(pub.app_dir, None, upload)
             item.convert_to_pdf = False
             pub.substitutions.reset()
             pub.substitutions.feed(formdata)
             item.perform(formdata)
             with open(formdata.evolution[0].parts[0].filename) as fd:
                 return fd.read()
         # unknown file format
         with pytest.raises(UploadValidationError):
             run(
                 template='<a>{{ form_var_string }}</a>',
                 filename='/foo/template.txt',
                 content_type='application/octet-stream',
+            )
         # good XML
         assert run(template='<a>{{ form_var_string }}</a>') == '<a>écho</a>'
         # malformed XML
         with pytest.raises(TemplatingError):
             run(template='<a>{{ form_var_string }}<a>')
     @pytest.mark.parametrize('filename', ['template-form-details.odt', 'template-form-details-no-styles.odt'])
     def test_export_to_model_form_details_section(pub, filename):
         BlockDef.wipe()

                 fp = upload.get_file()
             else:
                 raise UploadValidationError('unknown upload object %r' % upload)
             # RTF
             if upload.content_type and upload.content_type == 'application/rtf':
                 return 'rtf'
             if (
-...
             if fp.read(10).startswith(b'{\\rtf'):
                 fp.seek(0)
                 return 'rtf'
             # OpenDocument
             fp.seek(0)
             if upload.content_type and upload.content_type.startswith('application/vnd.oasis.opendocument.'):
                 return 'opendocument'
-...
                     return 'opendocument'
             if is_opendocument(fp):
                 return 'opendocument'
             # XML
             if (upload.content_type and upload.content_type in ('text/xml', 'application/xml')) or (
                 upload.content_type is None and upload.base_filename and upload.base_filename.endswith('.rtf')
             ):
                 return 'xml'
             raise UploadValidationError(_('Only RTF and OpenDocument files can be used'))
         def get_parameters(self):
-...
                 outstream = self.apply_rtf_template_to_formdata(formdata)
             elif kind == 'opendocument':
                 outstream = self.apply_od_template_to_formdata(formdata)
             elif kind == 'xml':
                 outstream = self.apply_text_template_to_formdata(formdata)
             else:
                 raise Exception('unsupported model kind %r' % kind)
             if self.convert_to_pdf:
                 if transform_to_pdf is None:
                     raise Exception('libreoffice is missing')
                 return transform_to_pdf(outstream)
             if kind == 'xml':
                 outstream.seek(0)
                 try:
                     ET.parse(outstream)
                 except ET.ParseError as e:
                     get_publisher().record_error(
                         _('Error in template for export to model'), formdata=formdata, exception=e
+                    )
                     raise TemplatingError(_('Error in template: output is not valid XML (%s)') % str(e))
                 finally:
                     outstream.seek(0)
             else:
                 if self.convert_to_pdf:
                     if transform_to_pdf is None:
                         raise Exception('libreoffice is missing')
                     return transform_to_pdf(outstream)
             return outstream
         def apply_text_template_to_formdata(self, formdata):
             try:
                 # force ezt_only=True because an RTF file may contain {{ characters
                 # and would be seen as a Django template
                 return io.BytesIO(
                     force_bytes(
                         template_on_formdata(
                             formdata,
                             self.model_file.get_file().read().decode(errors='surrogateescape'),
+                        )
+                    )
+                )
             except TemplateError as e:
                 get_publisher().record_error(
                     _('Error in template for export to model'), formdata=formdata, exception=e
+                )
                 raise TemplatingError(_('Error in template: %s') % str(e))
         def apply_rtf_template_to_formdata(self, formdata):
             try:
                 # force ezt_only=True because an RTF file may contain {{ characters
+    -

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.

0001-wf-export_to_model-support-XML-templates-56537.patch