0003-wf-export_to_model-add-opendocument-support-4292.patch

Benjamin Dauvergne, 28 octobre 2015 13:13

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

Subject: [PATCH 3/4] wf/export_to_model: add opendocument support (#4292)

 tests/template-out.odt    | Bin 0 -> 31138 bytes
 tests/template.odt        | Bin 0 -> 9817 bytes
 tests/test_form_pages.py  |  90 ++++++++++++++++++++++++++++++++++++++++++++--
 wcs/wf/export_to_model.py |  87 ++++++++++++++++++++++++++++++++++++++++----
 4 files changed, 167 insertions(+), 10 deletions(-)
 create mode 100644 tests/template-out.odt
 create mode 100644 tests/template.odt

     import os
     import re
     import StringIO
     import zipfile
     from webtest import Upload
     from quixote.http_request import Upload as QuixoteUpload
-...
     from utilities import get_app, login, create_temporary_pub, clean_temporary_pub, emails
     def assert_equal_zip(stream1, stream2):
         z1 = zipfile.ZipFile(stream1)
         z2 = zipfile.ZipFile(stream2)
         assert set(z1.namelist()) == set(z2.namelist())
         for name in z1.namelist():
             assert z1.read(name) == z2.read(name), 'file "%s" differs' % name
     def pytest_generate_tests(metafunc):
         if 'pub' in metafunc.fixturenames:
             metafunc.parametrize('pub', ['pickle', 'sql'], indirect=True)
-...
         st1 = wf.add_status('Status1', 'st1')
         export_to = ExportToModel()
         export_to.label = 'create doc'
         upload = QuixoteUpload('/foo/test.rtf', content_type='text/rtf')
         upload = QuixoteUpload('/foo/test.rtf', content_type='application/rtf')
         upload.fp = StringIO.StringIO()
         upload.fp.write('HELLO WORLD')
         upload.fp.seek(0)
-...
         resp = resp.click('test.rtf')
         assert resp.location.endswith('/test.rtf')
         resp = resp.follow()
         assert resp.content_type == 'text/rtf'
         assert resp.content_type == 'application/rtf'
         assert resp.body == 'HELLO WORLD'
         # change file content, same name
         upload = QuixoteUpload('/foo/test.rtf', content_type='text/rtf')
         upload = QuixoteUpload('/foo/test.rtf', content_type='application/rtf')
         upload.fp = StringIO.StringIO()
         upload.fp.write('HELLO NEW WORLD')
         upload.fp.seek(0)
-...
         assert resp.click('test.rtf', index=0).follow().body == 'HELLO WORLD'
         assert resp.click('test.rtf', index=1).follow().body == 'HELLO NEW WORLD'
     def test_formdata_generated_document_odt_download(pub):
         create_user(pub)
         wf = Workflow(name='status')
         st1 = wf.add_status('Status1', 'st1')
         export_to = ExportToModel()
         export_to.label = 'create doc'
         template_filename = os.path.join(os.path.dirname(__file__), 'template.odt')
         template = open(template_filename).read()
         upload = QuixoteUpload('/foo/template.odt', content_type='application/octet-stream')
         upload.fp = StringIO.StringIO()
         upload.fp.write(template)
         upload.fp.seek(0)
         export_to.model_file = UploadedFile(pub.app_dir, None, upload)
         export_to.id = '_export_to'
         export_to.by = ['_submitter']
         st1.items.append(export_to)
         export_to.parent = st1
         wf.store()
         formdef = create_formdef()
         formdef.workflow_id = wf.id
         formdef.fields = []
         formdef.store()
         formdef.data_class().wipe()
         resp = login(get_app(pub), username='foo', password='foo').get('/test/')
         resp = resp.forms[0].submit('submit')
         assert 'Check values then click submit.' in resp.body
         resp = resp.forms[0].submit('submit')
         assert resp.status_int == 302
         form_location = resp.location
         resp = resp.follow()
         assert 'The form has been recorded' in resp.body
         resp = resp.form.submit('button_export_to')
         resp = resp.follow() # $form/$id/create_doc
         resp = resp.follow() # $form/$id/create_doc/
         with open(os.path.join(os.path.dirname(__file__), 'template-out.odt')) as f:
             assert_equal_zip(StringIO.StringIO(resp.body), f)
         export_to.attach_to_history = True
         wf.store()
         resp = login(get_app(pub), username='foo', password='foo').get(form_location)
         resp = resp.form.submit('button_export_to')
         assert resp.location == form_location
         resp = resp.follow() # back to form page
         resp = resp.click('template.odt')
         assert resp.location.endswith('/template.odt')
         resp = resp.follow()
         assert resp.content_type == 'application/octet-stream'
         with open(os.path.join(os.path.dirname(__file__), 'template-out.odt')) as f:
             assert_equal_zip(StringIO.StringIO(resp.body), f)
         # change file content, same name
         upload = QuixoteUpload('/foo/test.rtf', content_type='application/rtf')
         upload.fp = StringIO.StringIO()
         upload.fp.write('HELLO NEW WORLD')
         upload.fp.seek(0)
         export_to.model_file = UploadedFile(pub.app_dir, None, upload)
         wf.store()
         resp = login(get_app(pub), username='foo', password='foo').get(form_location)
         resp = resp.form.submit('button_export_to')
         assert resp.location == form_location
         resp = resp.follow() # back to form page
         with open(os.path.join(os.path.dirname(__file__), 'template-out.odt')) as f:
             body = resp.click('template.odt', index=0).follow().body
             assert_equal_zip(StringIO.StringIO(body), f)
         assert resp.click('test.rtf', index=0).follow().body == 'HELLO NEW WORLD'
     def test_formdata_form_file_download(pub):
         create_user(pub)
         wf = Workflow(name='status')

     from StringIO import StringIO
     from xml.etree import ElementTree as ET
     import zipfile
     from quixote import get_response, get_request, get_publisher
     from quixote.directory import Directory
-...
                                template_on_formdata, register_item_class)
     def transform_opendocument(instream, outstream, process):
         '''Take a file-like object containing an ODT, ODS, or any open-office
            format, parse context.xml with element tree and apply process to its root
            node.
         '''
         zin = zipfile.ZipFile(instream, mode='r')
         zout = zipfile.ZipFile(outstream, mode='w')
         assert 'content.xml' in zin.namelist()
         for filename in zin.namelist():
             content = zin.read(filename)
             if filename in ('meta.xml', 'content.xml'):
                 root = ET.fromstring(content)
                 process(root)
                 content = ET.tostring(root)
             zout.writestr(filename, content)
         zout.close()
     def is_opendocument(stream):
         try:
             with zipfile.ZipFile(stream) as z:
                 if 'mimetype' in z.namelist():
                     return z.read('mimetype').startswith('application/vnd.oasis.opendocument.')
         except zipfile.BadZipfile:
             return False
         finally:
             stream.seek(0)
     class TemplatingError(PublishError):
         def __init__(self, description):
             self.title = _('Templating Error')
-...
                 return base_url + self.get_directory_name()
         def model_file_validation(self, upload):
             if hasattr(upload, 'fp'):
                 fp = upload.fp
             elif hasattr(upload, 'get_file'):
                 fp = upload.get_file()
             else:
                 raise Exception('unknown upload %r' % upload)
             if upload.content_type and upload.content_type == 'application/rtf':
                 return True, ''
                 return 'rtf', ''
             if (upload.content_type and upload.content_type == 'application/octet-stream') or \
                     upload.content_type is None:
                 if upload.base_filename and upload.base_filename.endswith('.rtf'):
                     return True, ''
             upload.fp.seek(0)
             if upload.read(10).startswith('{\\rtf'):
                 upload.fp.seek(0)
                 return True, ''
             return False, _('Only RTF files can be used')
                     return 'rtf', ''
             if fp.read(10).startswith('{\\rtf'):
                 fp.seek(0)
                 return 'rtf', ''
             fp.seek(0)
             if upload.content_type and upload.content_type.startswith('application/vnd.oasis.opendocument.'):
                 return 'opendocument', ''
             if (upload.content_type and upload.content_type == 'application/octet-stream') or \
                     upload.content_type is None:
                 if upload.base_filename and upload.base_filename.rsplit('.', 1) in ('odt', 'ods', 'odc', 'odb'):
                     return 'opendocument', ''
             if is_opendocument(fp):
                 return 'opendocument', ''
             return False, _('Only RTF and OpenDocument files can be used')
         def add_parameters_widgets(self, form, parameters, prefix='',
                                    formdef=None):
-...
         directory_name = property(get_directory_name)
         def apply_template_to_formdata(self, formdata):
             assert self.model_file
             kind, msg = self.model_file_validation(self.model_file)
             if kind == 'rtf':
                 return self.apply_rtf_template_to_formdata(formdata)
             elif kind == 'opendocument':
                 return self.apply_od_template_to_formdata(formdata)
             else:
                 raise Exception('unsupported model kind %r' % kind)
         def apply_rtf_template_to_formdata(self, formdata):
             process = None
             if self.model_file.base_filename.endswith('.rtf'):
                 process = rtf_process
-...
                 raise TemplatingError(_('Unknown error in the '
                                         'template: %s') % str(e))
         def apply_od_template_to_formdata(self, formdata):
             def process_root(root):
                 def process_text(t):
                     if isinstance(t, unicode):
                         t = t.encode(get_publisher().site_charset)
                     t = template_on_formdata(formdata, t)
                     return unicode(t, get_publisher().site_charset)
                 for node in root.iter():
                     if node.text:
                         node.text = process_text(node.text)
                     if node.tail:
                         node.tail = process_text(node.tail)
             outstream = StringIO()
             transform_opendocument(self.model_file.get_file(), outstream,
                                    process_root)
             return outstream.getvalue()
         def get_parameters(self):
             return ('by', 'label', 'model_file', 'attach_to_history',
                     'backoffice_info_text')
+    -

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.

0003-wf-export_to_model-add-opendocument-support-4292.patch