Zope2: revive patches for Zope2.

product/ERP5/bin/zopewsgi.py

@@ -26,7 +26,7 @@ try:
   from ZPublisher.httpexceptions import HTTPExceptionHandler
 except ImportError:
   # BBB Zope2
-  from Products.ERP5Type.patches.WSGIPublisher import publish_module
+  from Products.ERP5Type.patches.WSGIPublisherZope2 import publish_module
   HTTPExceptionHandler = lambda app: app
 
 

product/ERP5Type/ZopePatch.py

@@ -21,16 +21,21 @@
 ##############################################################################
 import six
 
-from Products.ERP5Type import WITH_LEGACY_WORKFLOW
+from Products.ERP5Type import WITH_LEGACY_WORKFLOW, IS_ZOPE2
 
 # Load all monkey patches
-from Products.ERP5Type.patches import WSGIPublisher
+if IS_ZOPE2: # BBB Zope2
+  from Products.ERP5Type.patches import WSGIPublisherZope2
+else:
+  from Products.ERP5Type.patches import WSGIPublisher
 from Products.ERP5Type.patches import HTTPRequest
 from Products.ERP5Type.patches import AccessControl_patch
 from Products.ERP5Type.patches import Restricted
 from Products.ERP5Type.patches import m2crypto
 from Products.ERP5Type.patches import ObjectManager
 from Products.ERP5Type.patches import PropertyManager
+if IS_ZOPE2: # BBB Zope2
+  from Products.ERP5Type.patches import TM
 from Products.ERP5Type.patches import DA
 if WITH_LEGACY_WORKFLOW:
   from Products.ERP5Type.patches import DCWorkflow

product/ERP5Type/__init__.py

@@ -45,6 +45,12 @@ if six.PY3:
 else:
   WITH_LEGACY_WORKFLOW = True
 
+from App.version_txt import getZopeVersion
+if  getZopeVersion()[0] == 2: # BBB Zope2
+  IS_ZOPE2 = True
+else:
+  IS_ZOPE2 = False
+
 # We have a name conflict with source_reference and destination_reference,
 # which are at the same time property accessors for 'source_reference'
 # property, and category accessors (similar to getSourceValue().getReference())

product/ERP5Type/patches/CachingPolicyManager.py

@@ -487,3 +487,16 @@ CachingPolicyManager.addPolicy = addPolicy
 CachingPolicyManager._addPolicy = _addPolicy
 CachingPolicyManager.manage_cachingPolicies = DTMLFile( 'cachingPolicies', _dtmldir )
 CachingPolicyManager.getModTimeAndETag = getModTimeAndETag
+
+# BBB Zope2
+# Make CachingPolicyManager.CPMCache a new style classes already on
+# Zope2, so that we can install business templates exported on Zope4 in
+# Zope2 instances.
+import Products.CMFCore.CachingPolicyManager
+_CPMCache = Products.CMFCore.CachingPolicyManager.CPMCache
+if not isinstance(_CPMCache, type):
+  class CPMCache(_CPMCache, object):
+    pass
+  CPMCache.__module__ = _CPMCache.__module__
+
+  Products.CMFCore.CachingPolicyManager.CPMCache = CPMCache

product/ERP5Type/patches/DA.py

@@ -17,10 +17,14 @@ import re
 try: from IOBTree import Bucket
 except: Bucket=lambda:{}
 from Shared.DC.ZRDB.Aqueduct import decodestring, parse
-from Shared.DC.ZRDB.DA import DA, DatabaseError, SQLMethodTracebackSupplement, getBrain
+from Shared.DC.ZRDB.DA import DA, DatabaseError, SQLMethodTracebackSupplement
 from Shared.DC.ZRDB import RDB
 from Shared.DC.ZRDB.Results import Results
-from AccessControl import ClassSecurityInfo, getSecurityManager 
+try: # BBB Zope 2.12
+  from App.Extensions import getBrain
+except ImportError:
+  from Shared.DC.ZRDB.DA import getBrain
+from AccessControl import ClassSecurityInfo, getSecurityManager
 from Products.ERP5Type.Globals import InitializeClass
 from Acquisition import aq_base, aq_parent
 from zLOG import LOG, INFO, ERROR

product/ERP5Type/patches/OFSFile.py

 from App.special_dtml import DTMLFile
 from OFS.Image import File
-from Products.ERP5Type import _dtmldir
+from Products.ERP5Type import IS_ZOPE2, _dtmldir
 
 
 def _setData(self, data):
@@ -18,3 +18,19 @@ def _setData(self, data):
   # We call this method to make sure size is set and caches reset
   self.update_data(data, size=size)
 File._setData = _setData
+
+if IS_ZOPE2: # BBB Zope2
+  from OFS.SimpleItem import Item
+  # Patch for displaying textearea in full window instead of
+  # remembering a quantity of lines to display in a cookie
+  manage_editForm = DTMLFile("fileEdit", _dtmldir)
+  manage_editForm._setName('manage_editForm')
+  File.manage_editForm = manage_editForm
+  File.manage = manage_editForm
+  File.manage_main = manage_editForm
+  File.manage_editDocument = manage_editForm
+  File.manage_editForm = manage_editForm
+
+  # restore __repr__ after persistent > 4.4
+  # https://github.com/zopefoundation/Zope/issues/379
+  File.__repr__ = Item.__repr__

product/ERP5Type/patches/OFSFolder.py

@@ -15,7 +15,7 @@
 from AccessControl import ClassSecurityInfo
 from Products.ERP5Type.Globals import InitializeClass
 from OFS.Folder import Folder
-from Products.ERP5Type import Permissions
+from Products.ERP5Type import IS_ZOPE2, Permissions
 
 """
   This patch modifies OFS.Folder._setOb to update portal_skins cache when
@@ -59,16 +59,25 @@ def Folder_isERP5SitePresent(self):
 
 Folder.isERP5SitePresent = Folder_isERP5SitePresent
 
-def Folder_zope_quick_start(self):
-  """Compatibility for old `zope_quick_start` that is referenced in
-  /index_html (at the root)
-  """
-  return 'OK'
-
-Folder.zope_quick_start = Folder_zope_quick_start
-
 security = ClassSecurityInfo()
 security.declareProtected(Permissions.ManagePortal, 'isERP5SitePresent')
-security.declarePublic('zope_quick_start')
+
+if not IS_ZOPE2:
+  def Folder_zope_quick_start(self):
+    """Compatibility for old `zope_quick_start` that is referenced in
+    /index_html (at the root)
+    """
+    return 'OK'
+
+  Folder.zope_quick_start = Folder_zope_quick_start
+  security.declarePublic('zope_quick_start')
+
 Folder.security = security
 InitializeClass(Folder)
+
+if IS_ZOPE2: # BBB Zope2
+  from OFS.SimpleItem import Item
+
+  # restore __repr__ after persistent > 4.4
+  # https://github.com/zopefoundation/Zope/issues/379
+  Folder.__repr__ = Item.__repr__

product/ERP5Type/patches/OFSItem.py

 from AccessControl import ClassSecurityInfo
 from OFS.SimpleItem import SimpleItem
+from Products.ERP5Type import IS_ZOPE2
 
 """
 Very simple volatile-attribute-based caching.
@@ -44,7 +45,10 @@ def volatileCached(self, func):
     self._v_SimpleItem_Item_vCache = cache_dict = {}
   # Use whole func_code as a key, as it is the only reliable way to identify a
   # function.
-  key = func.__code__
+  if IS_ZOPE2: # BBB Zope2
+    key = func.func_code
+  else:
+    key = func.__code__
   try:
     return cache_dict[key]
   except KeyError:

product/ERP5Type/patches/TM.py

+##############################################################################
+#
+# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
+# Copyright (c) 2009 Nexedi SARL and Contributors. All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+import transaction
+from Shared.DC.ZRDB.TM import TM, Surrogate
+
+
+# ZPublisher error path can aggravate error:
+#   https://bugs.launchpad.net/bugs/229863
+
+def TM__register(self):
+    if not self._registered:
+        #try:
+            transaction.get().register(Surrogate(self))
+            self._begin()
+            self._registered = 1
+            self._finalize = 0
+        #except: pass
+
+TM._register = TM__register
+
+# sortKey should return str in transaction 1.4.1 or later.
+TM._sort_key = '1'

product/ERP5Type/patches/sqltest.py

@@ -13,10 +13,100 @@
 from Shared.DC.ZRDB.sqltest import *
 from Shared.DC.ZRDB import sqltest
 from DateTime import DateTime
+from Products.ERP5Type import IS_ZOPE2
 
 list_type_list = list, tuple, set, frozenset, dict
 
-if 1: # For easy diff with original (ZSQLMethods 3.14)
+if IS_ZOPE2: # BBB Zope2
+    def render(self, md):
+        name=self.__name__
+
+        t=self.type
+        args=self.args
+        try:
+            expr=self.expr
+            if type(expr) is type(''):
+                v=md[expr]
+            else:
+                v=expr(md)
+        except (KeyError, NameError):
+            if 'optional' in args and args['optional']:
+                return ''
+            raise ValueError('Missing input variable, <em>%s</em>' % name)
+
+        # PATCH: use isinstance instead of type comparison, to allow
+        # subclassing.
+        if isinstance(v, list_type_list):
+            if len(v) > 1 and not self.multiple:
+                raise ValueError(
+                    'multiple values are not allowed for <em>%s</em>'
+                    % name)
+        else: v=[v]
+
+        vs=[]
+        for v in v:
+            if not v and type(v) is StringType and t != 'string': continue
+            if t=='int':
+                try:
+                    if type(v) is StringType:
+                        if v[-1:]=='L':
+                            v=v[:-1]
+                        atoi(v)
+                    else: v=str(int(v))
+                except ValueError:
+                    raise ValueError(
+                        'Invalid integer value for <em>%s</em>' % name)
+            elif t=='float':
+                if not v and type(v) is StringType: continue
+                try:
+                    if type(v) is StringType: atof(v)
+                    else: v=str(float(v))
+                except ValueError:
+                    raise ValueError(
+                        'Invalid floating-point value for <em>%s</em>' % name)
+            elif t.startswith('datetime'):
+                # For subsecond precision, use 'datetime(N)' MySQL type,
+                # where N is the number of digits after the decimal point.
+                n = 0 if t == 'datetime' else int(t[9])
+                v = (v if isinstance(v, DateTime) else DateTime(v)).toZone('UTC')
+                v = "'%s%s'" % (v.ISO(),
+                    ('.%06u' % (v.micros() % 1000000))[:1+n] if n else '')
+
+            else:
+                if not isinstance(v, (str, unicode)):
+                    v = str(v)
+                v=md.getitem('sql_quote__',0)(v)
+                #if find(v,"\'") >= 0: v=join(split(v,"\'"),"''")
+                #v="'%s'" % v
+            vs.append(v)
+
+        if not vs and t=='nb':
+            if 'optional' in args and args['optional']:
+                return ''
+            else:
+                raise ValueError(
+                    'Invalid empty string value for <em>%s</em>' % name)
+
+        if not vs:
+            if self.optional: return ''
+            raise ValueError(
+                'No input was provided for <em>%s</em>' % name)
+
+        if len(vs) > 1:
+            vs=join(map(str,vs),', ')
+            if self.op == '<>':
+                ## Do the equivalent of 'not-equal' for a list,
+                ## "a not in (b,c)"
+                return "%s not in (%s)" % (self.column, vs)
+            else:
+                ## "a in (b,c)"
+                return "%s in (%s)" % (self.column, vs)
+        return "%s %s %s" % (self.column, self.op, vs[0])
+    SQLTest.render = SQLTest.__call__ = render
+
+    sqltest.valid_type = (('int', 'float', 'string', 'nb', 'datetime') + tuple('datetime(%s)' % x for x in xrange(7))).__contains__
+
+else: # For easy diff with original (ZSQLMethods 3.14)
     def render(self, md):
         name = self.__name__
 
@@ -117,12 +207,12 @@ if 1: # For easy diff with original (ZSQLMethods 3.14)
         return '%s %s %s' % (self.column, self.op, vs[0])
     SQLTest.render = SQLTest.__call__ = render
 
-from builtins import range
-new_valid_types = (('int', 'float', 'string', 'nb', 'datetime') + tuple('datetime(%s)' % x for x in range(7)))
+    from builtins import range
+    new_valid_types = (('int', 'float', 'string', 'nb', 'datetime') + tuple('datetime(%s)' % x for x in range(7)))
 
-try:
-  # BBB
-  from Shared.DC.ZRDB.sqltest import valid_type
-  sqltest.valid_type = new_valid_types.__contains__
-except ImportError:
-  sqltest.valid_types = new_valid_types
+    try:
+        # BBB
+        from Shared.DC.ZRDB.sqltest import valid_type
+        sqltest.valid_type = new_valid_types.__contains__
+    except ImportError:
+        sqltest.valid_types = new_valid_types

product/ERP5Type/patches/sqlvar.py

@@ -17,8 +17,83 @@
 from Shared.DC.ZRDB.sqlvar import *
 from Shared.DC.ZRDB import sqlvar
 from DateTime import DateTime
+from Products.ERP5Type import IS_ZOPE2
 
-if 1: # For easy diff with original (ZSQLMethods 3.14)
+if IS_ZOPE2: # BBB Zope2
+    from string import atoi,atof
+
+    def render(self, md):
+        args=self.args
+        t=args['type']
+        try:
+            expr=self.expr
+            if type(expr) is str: v=md[expr]
+            else: v=expr(md)
+        except Exception:
+            if args.get('optional'):
+                return 'null'
+            if type(expr) is not str:
+                raise
+            raise ValueError('Missing input variable, <em>%s</em>' % self.__name__)
+
+        if v is None and args.get('optional'):
+            return 'null'
+
+        if t=='int':
+            try:
+                if type(v) is str:
+                    if v[-1:]=='L':
+                        v=v[:-1]
+                    atoi(v)
+                    return v
+                return str(int(v))
+            except Exception:
+                t = 'integer'
+        elif t=='float':
+            try:
+                if type(v) is str:
+                    if v[-1:]=='L':
+                        v=v[:-1]
+                    atof(v)
+                    return v
+                # ERP5 patch, we use repr that have better precision than str for
+                # floats
+                return repr(float(v))
+            except Exception:
+                t = 'floating-point'
+        elif t.startswith('datetime'):
+            # For subsecond precision, use 'datetime(N)' MySQL type,
+            # where N is the number of digits after the decimal point.
+            n = 0 if t == 'datetime' else int(t[9])
+            try:
+                v = (v if isinstance(v, DateTime) else DateTime(v)).toZone('UTC')
+                return "'%s%s'" % (v.ISO(),
+                    ('.%06u' % (v.micros() % 1000000))[:1+n] if n else '')
+            except Exception:
+                t = 'datetime'
+        elif t=='nb' and not v:
+            t = 'empty string'
+        else:
+            v = md.getitem('sql_quote__',0)(
+                v if isinstance(v, basestring) else str(v))
+            #if find(v,"\'") >= 0: v=join(split(v,"\'"),"''")
+            #v="'%s'" % v
+            return v
+
+        if args.get('optional'):
+            return 'null'
+        raise ValueError('Invalid %s value for <em>%s</em>: %r'
+                         % (t, self.__name__, v))
+
+    valid_type = 'int', 'float', 'string', 'nb', 'datetime'
+    valid_type += tuple(map('datetime(%s)'.__mod__, xrange(7)))
+    valid_type = valid_type.__contains__
+
+    SQLVar.render = render
+    SQLVar.__call__ = render
+    sqlvar.valid_type = valid_type
+
+else: # For easy diff with original (ZSQLMethods 3.14)
     def render(self, md):
         name = self.__name__
         args = self.args
@@ -98,15 +173,15 @@ if 1: # For easy diff with original (ZSQLMethods 3.14)
 
         return v
 
-# Patched by yo. datetime is added.
-new_valid_types = 'int', 'float', 'string', 'nb', 'datetime'
-new_valid_types += tuple(map('datetime(%s)'.__mod__, range(7)))
-try:
-  # BBB
-  from Shared.DC.ZRDB.sqlvar import valid_type
-  sqlvar.valid_type = new_valid_types.__contains__
-except ImportError:
-  sqlvar.valid_types = new_valid_types
-
-SQLVar.render = render
-SQLVar.__call__ = render
+    # Patched by yo. datetime is added.
+    new_valid_types = 'int', 'float', 'string', 'nb', 'datetime'
+    new_valid_types += tuple(map('datetime(%s)'.__mod__, range(7)))
+    try:
+        # BBB
+        from Shared.DC.ZRDB.sqlvar import valid_type
+        sqlvar.valid_type = new_valid_types.__contains__
+    except ImportError:
+        sqlvar.valid_types = new_valid_types
+
+    SQLVar.render = render
+    SQLVar.__call__ = render