OOoDocument.py 21.2 KB
Newer Older
1
# -*- coding: utf-8 -*-
Bartek Górny's avatar
Bartek Górny committed
2 3 4
##############################################################################
#
# Copyright (c) 2002-2006 Nexedi SARL and Contributors. All Rights Reserved.
5
# Copyright (c) 2006-2007 Nexedi SA and Contributors. All Rights Reserved.
Bartek Górny's avatar
Bartek Górny committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

30
import xmlrpclib, base64, re, zipfile, cStringIO
31
from warnings import warn
32
from xmlrpclib import Fault
33 34
from xmlrpclib import Transport
from xmlrpclib import SafeTransport
Bartek Górny's avatar
Bartek Górny committed
35
from AccessControl import ClassSecurityInfo
36
from AccessControl import Unauthorized
Bartek Górny's avatar
Bartek Górny committed
37
from OFS.Image import Pdata
38
from OFS.Image import File as OFSFile
39 40 41 42
try:
    from OFS.content_types import guess_content_type
except ImportError:
    from zope.contenttype import guess_content_type
43 44
from Products.CMFCore.utils import getToolByName, _setCacheHeaders,\
    _ViewEmulator
45
from Products.ERP5Type import Permissions, PropertySheet, Constraint
Bartek Górny's avatar
Bartek Górny committed
46
from Products.ERP5Type.Cache import CachingMethod
47
from Products.ERP5.Document.File import File
48 49
from Products.ERP5.Document.Document import Document, PermanentURLMixIn,\
VALID_IMAGE_FORMAT_LIST, ConversionError, NotConvertedError
50
from zLOG import LOG, ERROR
51

52
# Mixin Import
53 54 55 56
from Products.ERP5.mixin.base_convertable import BaseConvertableMixin
from Products.ERP5.mixin.text_convertable import TextConvertableMixin
from Products.ERP5.mixin.base_convertable_and_file import\
                                                    BaseConvertableAndFileMixin
57

Bartek Górny's avatar
Bartek Górny committed
58 59 60
enc=base64.encodestring
dec=base64.decodestring

61 62
_MARKER = []

63 64 65 66 67 68
class TimeoutTransport(SafeTransport):
  """A xmlrpc transport with configurable timeout.
  """
  def __init__(self, timeout=None, scheme='http'):
    self._timeout = timeout
    self._scheme = scheme
69 70 71 72 73 74 75
    # On Python 2.6, .__init__() of Transport and SafeTransport must be called
    # to set up the ._use_datetime attribute.
    # sigh... too bad we can't use super() here, as SafeTransport is not
    # a new-style class (as of Python 2.4 to 2.6)
    # remove the gettattr below when we drop support for Python 2.4
    super__init__ = getattr(SafeTransport, '__init__', lambda self: None)
    super__init__(self)
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

  def send_content(self, connection, request_body):
    connection.putheader("Content-Type", "text/xml")
    connection.putheader("Content-Length", str(len(request_body)))
    connection.endheaders()
    if self._timeout:
      connection._conn.sock.settimeout(self._timeout)
    if request_body:
      connection.send(request_body)

  def make_connection(self, h):
    if self._scheme == 'http':
      return Transport.make_connection(self, h)
    return SafeTransport.make_connection(self, h)


92 93
class OOoDocument(PermanentURLMixIn, BaseConvertableAndFileMixin, File,
                  BaseConvertableMixin, TextConvertableMixin, Document):
Bartek Górny's avatar
Bartek Górny committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
  """
    A file document able to convert OOo compatible files to
    any OOo supported format, to capture metadata and to
    update metadata in OOo documents.

    This class can be used:

    - to create an OOo document database with powerful indexing (r/o)
      and metadata handling (r/w) features (ex. change title in ERP5 ->
      title is changed in OOo document)

    - to massively convert MS Office documents to OOo format

    - to easily keep snapshots (in PDF and/or OOo format) of OOo documents
      generated from OOo templates

    This class may be used in the future:

    - to create editable OOo templates (ex. by adding tags in WYSIWYG mode
      and using tags to make document dynamic - ask kevin for more info)

    - to automatically sign / encrypt OOo documents based on user

    - to automatically sign / encrypt PDF generated from OOo documents based on user

    This class should not be used:

    - to store files in formats not supported by OOo

    - to stored pure images (use Image for that)

    - as a general file conversion system (use portal_transforms for that)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
126 127 128

    TODO:
    - better permissions
Bartek Górny's avatar
Bartek Górny committed
129 130 131 132 133 134 135 136 137 138 139
  """
  # CMF Type Definition
  meta_type = 'ERP5 OOo Document'
  portal_type = 'OOo Document'

  # Declarative security
  security = ClassSecurityInfo()
  security.declareObjectProtected(Permissions.AccessContentsInformation)

  # Default Properties
  property_sheets = ( PropertySheet.Base
140 141
                    , PropertySheet.XMLObject
                    , PropertySheet.Reference
Bartek Górny's avatar
Bartek Górny committed
142 143 144
                    , PropertySheet.CategoryCore
                    , PropertySheet.DublinCore
                    , PropertySheet.Version
145
                    , PropertySheet.Document
146 147 148 149
                    , PropertySheet.Snapshot
                    , PropertySheet.ExternalDocument
                    , PropertySheet.Url
                    , PropertySheet.Periodicity
150
                    , PropertySheet.SortIndex
Bartek Górny's avatar
Bartek Górny committed
151 152
                    )

153
  # regular expressions for stripping xml from ODF documents
154 155
  rx_strip = re.compile('<[^>]*?>', re.DOTALL|re.MULTILINE)
  rx_compr = re.compile('\s+')
156

157 158
  security.declareProtected(Permissions.AccessContentsInformation,
                            'isSupportBaseDataConversion')
159 160 161 162 163 164
  def isSupportBaseDataConversion(self):
    """
    OOoDocument is needed to conversion to base format.
    """
    return True

165
  # Format conversion implementation
166
  def _getServerCoordinate(self):
Bartek Górny's avatar
Bartek Górny committed
167
    """
168 169
      Returns the oood conversion server coordinates
      as defined in preferences.
Bartek Górny's avatar
Bartek Górny committed
170
    """
171 172 173
    preference_tool = getToolByName(self, 'portal_preferences')
    address = preference_tool.getPreferredOoodocServerAddress()
    port = preference_tool.getPreferredOoodocServerPortNumber()
174
    if address in ('', None) or port in ('', None) :
175
      raise ConversionError('OOoDocument: can not proceed with conversion:'
176
            ' conversion server host and port is not defined in preferences')
177
    return address, port
Bartek Górny's avatar
Bartek Górny committed
178 179 180

  def _mkProxy(self):
    """
181
      Create an XML-RPC proxy to access the conversion server.
Bartek Górny's avatar
Bartek Górny committed
182
    """
183 184 185 186
    server_proxy = xmlrpclib.ServerProxy(
             'http://%s:%d' % self._getServerCoordinate(),
             allow_none=True,
             transport=TimeoutTransport(timeout=360, scheme='http'))
187
    return server_proxy
Bartek Górny's avatar
Bartek Górny committed
188

189 190
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getTargetFormatItemList')
Bartek Górny's avatar
Bartek Górny committed
191 192 193 194 195
  def getTargetFormatItemList(self):
    """
      Returns a list of acceptable formats for conversion
      in the form of tuples (for listfield in ERP5Form)

196 197
      NOTE: it is the responsability of the conversion server
      to provide an extensive list of conversion formats.
Bartek Górny's avatar
Bartek Górny committed
198
    """
199
    if not self.hasBaseData():
200
      raise NotConvertedError
201

202
    def cached_getTargetFormatItemList(content_type):
203
      server_proxy = self._mkProxy()
204
      try:
205 206 207 208 209 210 211 212 213 214
        allowed_target_item_list = server_proxy.getAllowedTargetItemList(
                                                      content_type)
        try:
          response_code, response_dict, response_message = \
                                             allowed_target_item_list
        except ValueError:
          # Compatibility with older oood where getAllowedTargetItemList only
          # returned response_dict
          response_code, response_dict, response_message = \
                         200, dict(response_data=allowed_target_item_list), ''
215

216 217 218 219 220
        if response_code == 200:
          allowed = response_dict['response_data']
        else:
          # This is very temporary code - XXX needs to be changed
          # so that the system can retry
221
          raise ConversionError("OOoDocument: can not get list of allowed acceptable"
222 223
                                " formats for conversion: %s (%s)" % (
                                      response_code, response_message))
224

225 226 227 228
      except Fault, f:
        allowed = server_proxy.getAllowedTargets(content_type)
        warn('Your oood version is too old, using old method '
            'getAllowedTargets instead of getAllowedTargetList',
229 230
             DeprecationWarning)

231 232
      # tuple order is reversed to be compatible with ERP5 Form
      return [(y, x) for x, y in allowed]
Bartek Górny's avatar
Bartek Górny committed
233

234
    # Cache valid format list
235 236 237 238
    cached_getTargetFormatItemList = CachingMethod(
                                cached_getTargetFormatItemList,
                                id="OOoDocument_getTargetFormatItemList",
                                cache_factory='erp5_ui_medium')
Bartek Górny's avatar
Bartek Górny committed
239

240 241
    return cached_getTargetFormatItemList(self.getBaseContentType())

242 243
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getTargetFormatTitleList')
244
  def getTargetFormatTitleList(self):
Bartek Górny's avatar
Bartek Górny committed
245 246 247 248 249
    """
      Returns a list of acceptable formats for conversion
    """
    return map(lambda x: x[0], self.getTargetFormatItemList())

250 251
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getTargetFormatList')
252
  def getTargetFormatList(self):
Bartek Górny's avatar
Bartek Górny committed
253
    """
254
      Returns a list of acceptable formats for conversion
Bartek Górny's avatar
Bartek Górny committed
255
    """
256
    return map(lambda x: x[1], self.getTargetFormatItemList())
Bartek Górny's avatar
Bartek Górny committed
257

258 259
  security.declareProtected(Permissions.ModifyPortalContent,
                            'isTargetFormatAllowed')
260
  def isTargetFormatAllowed(self, format):
261
    """
262
      Checks if the current document can be converted
263
      into the specified target format.
264 265 266 267 268 269 270 271
    """
    return format in self.getTargetFormatList()

  security.declarePrivate('_convert')
  def _convert(self, format):
    """
      Communicates with server to convert a file 
    """
272
    if not self.hasBaseData():
273
      raise NotConvertedError
274 275 276
    if format == 'text-content':
      # Extract text from the ODF file
      cs = cStringIO.StringIO()
277
      cs.write(str(self.getBaseData()))
278 279 280 281 282 283
      z = zipfile.ZipFile(cs)
      s = z.read('content.xml')
      s = self.rx_strip.sub(" ", s) # strip xml
      s = self.rx_compr.sub(" ", s) # compress multiple spaces
      cs.close()
      z.close()
284
      return 'text/plain', s
285
    server_proxy = self._mkProxy()
286
    orig_format = self.getBaseContentType()
287
    generate_result = server_proxy.run_generate(self.getId(),
288
                                       enc(str(self.getBaseData())),
289
                                       None,
290 291
                                       format,
                                       orig_format)
292 293 294 295 296 297
    try:
      response_code, response_dict, response_message = generate_result
    except ValueError:
      # This is for backward compatibility with older oood version returning
      # only response_dict
      response_dict = generate_result
298

299
    # XXX: handle possible OOOd server failure
300
    return response_dict['mime'], Pdata(dec(response_dict['data']))
301

302
  # Conversion API
303
  security.declareProtected(Permissions.AccessContentsInformation, 'convert')
304
  def convert(self, format, display=None, **kw):
305 306 307 308
    """Convert the document to the given format.

    If a conversion is already stored for this format, it is returned
    directly, otherwise the conversion is stored for the next time.
Bartek Górny's avatar
Bartek Górny committed
309
    """
310 311
    #XXX if document is empty, stop to try to convert.
    #XXX but I don't know what is a appropriate mime-type.(Yusei)
312
    if self.get_size() == 0:
313
      return 'text/plain', ''
314 315 316 317 318 319 320
    # if no conversion asked (format empty)
    # return raw data
    if not format:
      return self.getContentType(), self.getData()
    # Check if we have already a base conversion
    if not self.hasBaseData():
      raise NotConvertedError
321 322
    # Make sure we can support html and pdf by default
    is_html = 0
323
    requires_pdf_first = 0
324
    original_format = format
325
    if format == 'base-data':
326
      return self.getBaseContentType(), str(self.getBaseData())
327
    if format == 'pdf':
328 329
      format_list = [x for x in self.getTargetFormatList()
                                          if x.endswith('pdf')]
330
      format = format_list[0]
331
    elif format in VALID_IMAGE_FORMAT_LIST:
332 333
      format_list = [x for x in self.getTargetFormatList()
                                          if x.endswith(format)]
334 335 336 337 338 339 340 341
      if len(format_list):
        format = format_list[0]
      else:
        # We must fist make a PDF
        requires_pdf_first = 1
        format_list = [x for x in self.getTargetFormatList()
                                          if x.endswith('pdf')]
        format = format_list[0]
342
    elif format == 'html':
343 344
      format_list = [x for x in self.getTargetFormatList()
                              if x.startswith('html') or x.endswith('html')]
345 346
      format = format_list[0]
      is_html = 1
347 348
    elif format in ('txt', 'text', 'text-content'):
      format_list = self.getTargetFormatList()
349 350 351 352
      # if possible, we try to get utf8 text. ('enc.txt' will encode to utf8)
      if 'enc.txt' in format_list:
        format = 'enc.txt'
      elif format not in format_list:
353 354 355 356 357 358 359
        #Text conversion is not supported by oood, do it in other way
        if not self.hasConversion(format=original_format):
          #Do real conversion for text
          mime, data = self._convert(format='text-content')
          self.setConversion(data, mime, format=original_format)
          return mime, data
        return self.getConversion(format=original_format)
360 361
    # Raise an error if the format is not supported
    if not self.isTargetFormatAllowed(format):
362
      raise ConversionError("OOoDocument: target format %s is not supported" % format)
363
    # Return converted file
364 365 366 367 368 369 370 371
    if requires_pdf_first:
      # We should use original_format whenever we wish to
      # display an image version of a document which needs to go
      # through PDF
      if display is None:
        has_format = self.hasConversion(format=original_format)
      else:
        has_format = self.hasConversion(format=original_format, display=display)
372
    elif display is None or original_format not in VALID_IMAGE_FORMAT_LIST:
373
      has_format = self.hasConversion(format=original_format)
374
    else:
375
      has_format = self.hasConversion(format=original_format, display=display)
376
    if not has_format:
377 378 379 380 381 382
      # Do real conversion
      mime, data = self._convert(format)
      if is_html:
        # Extra processing required since
        # we receive a zip file
        cs = cStringIO.StringIO()
383
        cs.write(str(data))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
384
        z = zipfile.ZipFile(cs) # A disk file would be more RAM efficient
385 386 387
        for f in z.infolist():
          fn = f.filename
          if fn.endswith('html'):
388 389 390
            if self.getPortalType() == 'Presentation'\
                  and not (fn.find('impr') >= 0):
              continue
391 392 393
            data = z.read(fn)
            break
        mime = 'text/html'
394
        self._populateConversionCacheWithHTML(zip_file=z) # Maybe some parts should be asynchronous for
395
                                         # better usability
396 397
        z.close()
        cs.close()
398
      if (display is None or original_format not in VALID_IMAGE_FORMAT_LIST) \
399
        and not requires_pdf_first:
400
        self.setConversion(data, mime, format=original_format)
401
      else:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
402
        temp_image = self.portal_contributions.newContent(
403 404 405
                                       portal_type='Image',
                                       temp_object=1)
        temp_image._setData(data)
406
        mime, data = temp_image.convert(original_format, display=display)
407 408 409 410 411 412 413
        if requires_pdf_first:
          if display is None:
            self.setConversion(data, mime, format=original_format)
          else:
            self.setConversion(data, mime, format=original_format, display=display)
        else:
          if display is None:
414
            self.setConversion(data, mime, format=original_format)
415
          else:
416
            self.setConversion(data, mime, format=original_format, display=display)
417 418
    if requires_pdf_first:
      format = original_format
419
    if display is None or original_format not in VALID_IMAGE_FORMAT_LIST:
420
      return self.getConversion(format=original_format)
421
    else:
422
      return self.getConversion(format=original_format, display=display)
423

424 425
  security.declareProtected(Permissions.AccessContentsInformation,
                                                               'asTextContent')
426 427
  def asTextContent(self):
    """
428
      Backward compatibility
429
    """
430
    return self.asText()
431

432
  security.declareProtected(Permissions.ModifyPortalContent,
433 434
                            '_populateConversionCacheWithHTML')
  def _populateConversionCacheWithHTML(self, zip_file=None):
435 436 437 438 439
    """
    Extract content from the ODF zip file and populate the document.
    Optional parameter zip_file prevents from converting content twice.
    """
    if zip_file is None:
440
      format_list = [x for x in self.getTargetFormatList()
441
                                if x.startswith('html') or x.endswith('html')]
442 443 444
      format = format_list[0]
      mime, data = self._convert(format)
      archive_file = cStringIO.StringIO()
445
      archive_file.write(str(data))
446 447 448 449 450 451
      zip_file = zipfile.ZipFile(archive_file)
      must_close = 1
    else:
      must_close = 0
    for f in zip_file.infolist():
      file_name = f.filename
452 453
      document = self.get(file_name, None)
      if document is not None:
454
        self.manage_delObjects([file_name]) # For compatibility with old implementation
455
      if file_name.endswith('html'):
456
        mime = 'text/html'
457 458 459 460 461 462 463
        # call portal_transforms to strip HTML in safe mode
        portal = self.getPortalObject()
        transform_tool = getToolByName(portal, 'portal_transforms')
        data = transform_tool.convertToData('text/xhtml-safe',
                                            zip_file.read(file_name),
                                            object=self, context=self,
                                            mimetype=mime)
464
      else:
465 466
        mime = guess_content_type(file_name)[0]
        data = Pdata(zip_file.read(file_name))
467
      self.setConversion(data, mime=mime, format='_embedded', file_name=file_name)
468 469 470 471
    if must_close:
      zip_file.close()
      archive_file.close()

472
  def _getExtensibleContent(self, request, name):
473
    try:
474
      mime, data = self.getConversion(format='_embedded', file_name=name)
475
      return OFSFile(name, name, data, content_type=mime).__of__(self.aq_parent)
476 477
    except KeyError:
      return PermanentURLMixIn._getExtensibleContent(self, request, name)
478

479 480
  security.declarePrivate('_convertToBaseFormat')
  def _convertToBaseFormat(self):
Bartek Górny's avatar
Bartek Górny committed
481
    """
482 483 484
      Converts the original document into ODF
      by invoking the conversion server. Store the result
      on the object. Update metadata information.
Bartek Górny's avatar
Bartek Górny committed
485
    """
486
    server_proxy = self._mkProxy()
487 488
    response_code, response_dict, response_message = server_proxy.run_convert(
                                      self.getSourceReference() or self.getId(),
489
                                      enc(str(self.getData())))
490 491 492 493 494 495
    if response_code == 200:
      # sucessfully converted document
      self._setBaseData(dec(response_dict['data']))
      metadata = response_dict['meta']
      self._base_metadata = metadata
      if metadata.get('MIMEType', None) is not None:
496
        self._setBaseContentType(metadata['MIMEType'])
497
    else:
498 499
      # Explicitly raise the exception!
      raise ConversionError(
500 501
                "OOoDocument: Error converting document to base format %s:%s:"
                                       % (response_code, response_message))
502

503 504
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getContentInformation')
505
  def getContentInformation(self):
Bartek Górny's avatar
Bartek Górny committed
506
    """
507 508
      Returns the metadata extracted by the conversion
      server.
Bartek Górny's avatar
Bartek Górny committed
509
    """
510
    return getattr(self, '_base_metadata', {})
Bartek Górny's avatar
Bartek Górny committed
511

512 513
  security.declareProtected(Permissions.ModifyPortalContent,
                            'updateBaseMetadata')
514
  def updateBaseMetadata(self, **kw):
Bartek Górny's avatar
Bartek Górny committed
515
    """
516 517 518
      Updates metadata information in the converted OOo document
      based on the values provided by the user. This is implemented
      through the invocation of the conversion server.
Bartek Górny's avatar
Bartek Górny committed
519
    """
520 521 522
    if not self.hasBaseData():
      raise NotConvertedError

523
    server_proxy = self._mkProxy()
524 525
    response_code, response_dict, response_message = \
          server_proxy.run_setmetadata(self.getId(),
526
                                       enc(str(self.getBaseData())),
527
                                       kw)
528 529 530
    if response_code == 200:
      # successful meta data extraction
      self._setBaseData(dec(response_dict['data']))
531
      self.updateFileMetadata() # record in workflow history # XXX must put appropriate comments.
532
    else:
533
      # Explicitly raise the exception!
534
      raise ConversionError("OOoDocument: error getting document metadata %s:%s"
535
                        % (response_code, response_message))