ERP5Conduit.py 47.8 KB
Newer Older
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
##############################################################################
#
# Copyright (c) 2002 Nexedi SARL and Contributors. All Rights Reserved.
#          Sebastien Robin <seb@nexedi.com>
#
# 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.
#
##############################################################################

from Products.ERP5SyncML.SyncCode import SyncCode
30
from Products.ERP5SyncML.XMLSyncUtils import XMLSyncUtilsMixin
Jean-Paul Smets's avatar
Jean-Paul Smets committed
31 32 33 34 35
from Products.ERP5SyncML.Subscription import Conflict
from Products.CMFCore.utils import getToolByName
from Products.ERP5SyncML.XupdateUtils import XupdateUtils
from Products.ERP5Type.Utils import convertToUpperCase
from Products.ERP5Type.Accessor.TypeDefinition import list_types
36
from Products.ERP5SyncML.XMLSyncUtils import Parse
37
from DateTime.DateTime import DateTime
Jean-Paul Smets's avatar
Jean-Paul Smets committed
38 39
from email.MIMEBase import MIMEBase
from email import Encoders
Sebastien Robin's avatar
Sebastien Robin committed
40
from AccessControl import ClassSecurityInfo
41
from AccessControl.PermissionMapping import setPermissionMapping
Sebastien Robin's avatar
Sebastien Robin committed
42
from Products.ERP5Type import Permissions
Sebastien Robin's avatar
Sebastien Robin committed
43
from Globals import PersistentMapping
44 45
import pickle
import string
46
from cStringIO import StringIO
47
from xml.sax.saxutils import escape, unescape
48
import re, copy
49
import cStringIO
50

Jean-Paul Smets's avatar
Jean-Paul Smets committed
51
from zLOG import LOG
52 53 54 55 56 57 58 59 60 61 62
try:
  from Ft.Xml.Domlette import Print, PrettyPrint
except ImportError:
  LOG('ERP5Conduit',0,"Can't import Print and PrettyPrint")
  class Print:
    def __init__(self, *args, **kw):
      raise ImportError, "Sorry, it was not possible to import Ft library"

  class PrettyPrint:
    def __init__(self, *args, **kw):
      raise ImportError, "Sorry, it was not possible to import Ft library"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
63

64
class ERP5Conduit(XMLSyncUtilsMixin):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
  """
    A conduit is a piece of code in charge of

    - updating an object attributes from an XUpdate XML stream

    (Conduits are not in charge of creating new objects which
    are eventually missing in a synchronisation process)

    If an object has be created during a synchronisation process,
    the way to proceed consists in:

    1- creating an empty instance of the appropriate class
      in the appropriate directory

    2- updating that empty instance with the conduit

    The first implementation of ERP5 synchronisation
    will define a default location to create new objects and
    a default class. This will be defined at the level of the synchronisation
    tool

86 87 88 89 90 91 92 93 94 95 96 97 98 99
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
    Look carefully when we are adding elements,
    for example, when we do 'insert-after', with 2 xupdate:element,
    so adding 2 differents objects, actually it adds only XXXX one XXX object
    In this case the getSubObjectDepth(), doesn't have
    too much sence
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    There is also one problem, when we synchronize a conflict, we are not waiting
    the response of the client, so that we are not sure if it take into account,
    we may have CONFLICT_NOT_SYNCHRONIZED AND CONFLICT_SYNCHRONIZED
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Jean-Paul Smets's avatar
Jean-Paul Smets committed
100

101
  """
Jean-Paul Smets's avatar
Jean-Paul Smets committed
102

Sebastien Robin's avatar
Sebastien Robin committed
103 104
  # Declarative security
  security = ClassSecurityInfo()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
105

Sebastien Robin's avatar
Sebastien Robin committed
106
  security.declareProtected(Permissions.AccessContentsInformation,'getEncoding')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
107 108 109 110
  def getEncoding(self):
    """
    return the string corresponding to the local encoding
    """
111 112
    #return "iso-8859-1"
    return "utf-8"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
113

Sebastien Robin's avatar
Sebastien Robin committed
114
  security.declareProtected(Permissions.ModifyPortalContent, '__init__')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
115 116
  def __init__(self):
    self.args = {}
117

Sebastien Robin's avatar
Sebastien Robin committed
118
  security.declareProtected(Permissions.ModifyPortalContent, 'addNode')
119
  def addNode(self, xml=None, object=None, previous_xml=None,
120
              object_id=None, sub_object=None, force=0, simulate=0, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
121 122 123
    """
    A node is added

124 125 126 127 128 129 130 131
    xml : the xml wich contains what we want to add

    object : from where we want to add something

    previous_xml : the previous xml of the object, if any

    force : apply updates even if there's a conflict

Jean-Paul Smets's avatar
Jean-Paul Smets committed
132 133
    This fucntion returns conflict_list, wich is of the form,
    [conflict1,conflict2,...] where conclict1 is of the form :
134
    [object.getPath(),keyword,local_and_actual_value,subscriber_value]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
135
    """
136 137
    reset_local_roles = 1
    reset_workflow = 1
Jean-Paul Smets's avatar
Jean-Paul Smets committed
138
    conflict_list = []
139
    xml = self.convertToXml(xml)
140 141
    if xml is None:
      return {'conflict_list':conflict_list, 'object':sub_object}
Jean-Paul Smets's avatar
Jean-Paul Smets committed
142
    # In the case where this new node is a object to add
143 144
    if xml.nodeName in self.XUPDATE_INSERT_OR_ADD and \
        self.getSubObjectDepth(xml)==0:
Sebastien Robin's avatar
Sebastien Robin committed
145 146 147 148
      if self.isHistoryAdd(xml)!=-1: # bad hack XXX to be removed
        for element in self.getXupdateElementList(xml):
          xml = self.getElementFromXupdate(element)
          conflict_list += self.addNode(xml=xml,object=object,
149
                          previous_xml=previous_xml, force=force,
150
                          simulate=simulate, **kw)['conflict_list']
151
    elif xml.nodeName == 'object':
152 153
      if object_id is None:
        object_id = self.getAttribute(xml,'id')
154
      docid = self.getObjectDocid(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
155
      if object_id is not None:
156 157 158 159 160 161 162 163 164
        if sub_object is None:
          try:
            sub_object = object._getOb(object_id)
          except (AttributeError, KeyError, TypeError):
            sub_object = None
        else:
          #We prevent reset_workflow an reset_local_roles
          reset_local_roles = 0
          reset_workflow = 0
165
        if sub_object is None: # If so, it doesn't exist
Jean-Paul Smets's avatar
Jean-Paul Smets committed
166 167 168
          portal_type = ''
          if xml.nodeName == 'object':
            portal_type = self.getObjectType(xml)
169 170
          elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD: # Deprecated ???
            portal_type = self.getXupdateObjectType(xml) # Deprecated ???
171 172
          sub_object = self.constructContent(object, object_id, docid, 
              portal_type)
173 174 175 176 177 178
        self.newObject(
                  object=sub_object,
                  xml=xml,
                  simulate=simulate,
                  reset_local_roles=reset_local_roles,
                  reset_workflow=reset_workflow)
179
    elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD \
180
         and self.getSubObjectDepth(xml)>=1:
181 182
      sub_object_id = self.getSubObjectId(xml)
      if previous_xml is not None and sub_object_id is not None:
Nicolas Delaby's avatar
Nicolas Delaby committed
183
        #LOG('addNode',0,'previous xml is not none and also sub_object_id')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
184
        # Find the previous xml corresponding to this subobject
185
        sub_previous_xml = self.getSubObjectXml(sub_object_id,previous_xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
186
        #LOG('addNode',0,'isSubObjectModification sub_p_xml: %s' % str(sub_previous_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
187 188 189
        if sub_previous_xml is not None:
          sub_object = None
          try:
190
            sub_object = object._getOb(sub_object_id)
191
          except (AttributeError, KeyError, TypeError):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
192 193
            pass
          if sub_object is not None:
Nicolas Delaby's avatar
Nicolas Delaby committed
194
            #LOG('addNode',0,'subobject.id: %s' % sub_object.id)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
195 196 197
            # Change the xml in order to directly apply
            # modifications to the subobject
            sub_xml = self.getSubObjectXupdate(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
198
            #LOG('addNode',0,'sub_xml: %s' % str(sub_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
199 200
            # Then do the udpate
            conflict_list += self.addNode(xml=sub_xml,object=sub_object,
201
                            previous_xml=sub_previous_xml, force=force,
202
                            simulate=simulate, **kw)['conflict_list']
203
    elif xml.nodeName == self.history_tag or self.isHistoryAdd(xml)>0:
204
      conflict_list += self.addWorkflowNode(object, xml, simulate)
Sebastien Robin's avatar
Sebastien Robin committed
205 206
    #elif xml.nodeName in self.local_role_list or self.isLocalRole(xml)>0 and not simulate:
    elif xml.nodeName in self.local_role_list:
207
      conflict_list += self.addLocalRoleNode(object, xml)
208
    elif xml.nodeName in self.local_permission_list:
209
      conflict_list += self.addLocalPermissionNode(object, xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
210
    else:
211 212
      conflict_list += self.updateNode(xml=xml,object=object, force=force,
                                       simulate=simulate,  **kw)
213 214
    # We must returns the object created
    return {'conflict_list':conflict_list, 'object': sub_object}
Jean-Paul Smets's avatar
Jean-Paul Smets committed
215

Sebastien Robin's avatar
Sebastien Robin committed
216
  security.declareProtected(Permissions.ModifyPortalContent, 'deleteNode')
217 218
  def deleteNode(self, xml=None, object=None, object_id=None, force=None,
                 simulate=0, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
219 220 221
    """
    A node is deleted
    """
222
    # In the case where we have to delete an object
Nicolas Delaby's avatar
Nicolas Delaby committed
223 224 225
    #LOG('ERP5Conduit',0,'deleteNode')
    #LOG('ERP5Conduit',0,'deleteNode, object.id: %s' % object.getId())
    #LOG('ERP5Conduit',0,'deleteNode, object path: %s' % repr(object.getPhysicalPath()))
226
    conflict_list = []
227 228
    if xml is not None:
      xml = self.convertToXml(xml)
229
    if object_id is None:
Nicolas Delaby's avatar
Nicolas Delaby committed
230
      #LOG('ERP5Conduit',0,'deleteNode, SubObjectDepth: %i' % self.getSubObjectDepth(xml))
231
      if xml.nodeName == self.xml_object_tag:
232
        object_id = self.getAttribute(xml,'id')
233 234 235 236 237
      elif self.getSubObjectDepth(xml)==1:
        object_id = self.getSubObjectId(xml)
      elif self.getSubObjectDepth(xml)==2:
        # we have to call delete node on a subsubobject
        sub_object_id = self.getSubObjectId(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
238
        try:
239 240 241
          sub_object = object._getOb(sub_object_id)
          sub_xml = self.getSubObjectXupdate(xml)
          conflict_list += self.deleteNode(xml=sub_xml,object=sub_object,
242
                                       force=force, simulate=simulate, **kw)
243
        except (KeyError, AttributeError, TypeError):
Nicolas Delaby's avatar
Nicolas Delaby committed
244
          #LOG('ERP5Conduit',0,'deleteNode, Unable to delete SubObject: %s' % str(sub_object_id))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
245
          pass
246
    if object_id is not None: # We do have an object_id
247 248 249
      try:
        object._delObject(object_id)
      except (AttributeError, KeyError):
Nicolas Delaby's avatar
Nicolas Delaby committed
250
        #LOG('ERP5Conduit',0,'deleteNode, Unable to delete: %s' % str(object_id))
251
        pass
252 253 254 255 256 257 258
    # In the case where we have to delete an user role
    # If we are still there, this means the delete is for this node
    elif xml.nodeName in self.XUPDATE_DEL:
      xml = self.getElementFromXupdate(xml)
      if xml.nodeName in self.local_role_list and not simulate:
        # We want to del a local role
        user = self.getAttribute(xml,'id')
Nicolas Delaby's avatar
Nicolas Delaby committed
259
        #LOG('local_role: ',0,'user: %s' % repr(user))
260 261 262 263
        if xml.nodeName.find(self.local_role_tag)>=0:
          object.manage_delLocalRoles([user])
        elif xml.nodeName.find(self.local_group_tag)>=0:
          object.manage_delLocalGroupRoles([user])
264 265
      if xml.nodeName in self.local_permission_list and not simulate:
        permission = self.getAttribute(xml,'id')
266
        object.manage_setLocalPermissions(permission)
267
    return conflict_list
Jean-Paul Smets's avatar
Jean-Paul Smets committed
268

Sebastien Robin's avatar
Sebastien Robin committed
269
  security.declareProtected(Permissions.ModifyPortalContent, 'updateNode')
270 271
  def updateNode(self, xml=None, object=None, previous_xml=None, force=0,
                 simulate=0,  **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
272 273 274 275 276 277 278 279
    """
    A node is updated with some xupdate
      - xml : the xml corresponding to the update, it should be xupdate
      - object : the object on wich we want to apply the xupdate
      - [previous_xml] : the previous xml of the object, it is mandatory
                         when we have sub objects
    """
    conflict_list = []
280
    xml = self.convertToXml(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
281 282
    #LOG('updateNode',0,'xml.nodeName: %s' % xml.nodeName)
    #LOG('updateNode, force: ',0,force)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
283 284
    # we have an xupdate xml
    if xml.nodeName == 'xupdate:modifications':
285 286 287
      conflict_list += self.applyXupdate(object=object, xupdate=xml, 
          conduit=self,previous_xml=previous_xml, force=force, 
          simulate=simulate, **kw)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
288 289 290
    # we may have only the part of an xupdate
    else:
      args = {}
Nicolas Delaby's avatar
Nicolas Delaby committed
291
      #LOG('isSubObjectModification',0,'result: %s' % str(self.isSubObjectModification(xml)))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
292
      if self.isProperty(xml) and not(self.isSubObjectModification(xml)):
293
        keyword = None
294 295
        for subnode in self.getAttributeNodeList(xml):
          if subnode.nodeName=='select':
Nicolas Delaby's avatar
Nicolas Delaby committed
296
            #LOG('updateNode',0,'selection: %s' % str(subnode.nodeValue))
297 298
            select_list = subnode.nodeValue.split('/') # Something like:
                                                       #('','object[1]','sid[1]')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
299 300
            new_select_list = ()
            for select_item in select_list:
301 302 303
              if select_item.find('[')>=0:
                select_item = select_item[:select_item.find('[')]
              new_select_list += (select_item,)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
304 305
            select_list = new_select_list # Something like : ('','object','sid')
            keyword = select_list[len(select_list)-1] # this will be 'sid'
306 307
        data_xml = xml
        data = None
Nicolas Delaby's avatar
Nicolas Delaby committed
308
        #LOG('updateNode',0,'keyword: %s' % str(keyword))
309
        if xml.nodeName not in self.XUPDATE_INSERT_OR_ADD:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
310 311 312 313 314
          for subnode in self.getElementNodeList(xml):
            if subnode.nodeName=='xupdate:element':
              for subnode1 in subnode.attributes:
                if subnode1.nodeName=='name':
                  keyword = subnode1.nodeValue
315
              data_xml = subnode
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
        else:
          #We can call add node
          conflict_list += self.addNode(xml=xml,
                                        object=object,
                                        force=force,
                                        simulate=simulate,
                                        **kw)
          return conflict_list

        if xml.nodeName in self.XUPDATE_DEL:
          conflict_list += self.deleteNode(xml=xml,
                                           object=object,
                                           force=force,
                                           simulate=simulate,
                                           **kw)
          return conflict_list
332 333
        if keyword is None: # This is not a selection, directly the property
          keyword = xml.nodeName
334 335 336 337 338
        if len(self.getElementNodeList(data_xml))==0:
          try:
            data = data_xml.childNodes[0].data
          except IndexError: # There is no data
            data = None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
339 340
        if not (keyword in self.NOT_EDITABLE_PROPERTY):
          # We will look for the data to enter
341
          data_type = object.getPropertyType(keyword)
Nicolas Delaby's avatar
Nicolas Delaby committed
342
          #LOG('updateNode',0,'data_type: %s' % str(data_type))
343
          data = self.convertXmlValue(data,data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
344 345 346 347 348 349 350 351
          args[keyword] = data
          args = self.getFormatedArgs(args=args)
          # This is the place where we should look for conflicts
          # For that we need :
          #   - data : the data from the remote box
          #   - old_data : the data from this box but at the time of the last synchronization
          #   - current_data : the data actually on this box
          isConflict = 0
Sebastien Robin's avatar
Sebastien Robin committed
352
          if (previous_xml is not None) and (not force): # if no previous_xml, no conflict
353 354
            old_data = self.getObjectProperty(keyword, previous_xml, 
                data_type=data_type)
355 356
            #current_data = object.getProperty(keyword)
            current_data = self.getProperty(object, keyword)
Nicolas Delaby's avatar
Nicolas Delaby committed
357 358 359
            #LOG('updateNode',0,'Conflict data: %s' % str(data))
            #LOG('updateNode',0,'Conflict old_data: %s' % str(old_data))
            #LOG('updateNode',0,'Conflict current_data: %s' % str(current_data))
360 361
            if (old_data != current_data) and (data != current_data) \
                and keyword not in self.force_conflict_list:
Nicolas Delaby's avatar
Nicolas Delaby committed
362
              #LOG('updateNode',0,'Conflict on : %s' % keyword)
363 364
              # Hack in order to get the synchronization working for demo
              # XXX this have to be removed after
365 366
              #if not (data_type in self.binary_type_list):
              if 1:
367 368
                # This is a conflict
                isConflict = 1
369 370
                string_io = StringIO()
                PrettyPrint(xml,stream=string_io)
Sebastien Robin's avatar
Sebastien Robin committed
371 372
                conflict = Conflict(object_path=object.getPhysicalPath(),
                                    keyword=keyword)
373
                conflict.setXupdate(string_io.getvalue())
Sebastien Robin's avatar
Sebastien Robin committed
374 375 376
                if not (data_type in self.binary_type_list):
                  conflict.setLocalValue(current_data)
                  conflict.setRemoteValue(data)
377 378 379 380
                conflict_list += [conflict]
                #conflict_list += [Conflict(object_path=object.getPhysicalPath(),
                #                           keyword=keyword,
                #                           xupdate=string_io)]
381 382
                                           #publisher_value=current_data, # not needed any more
                                           #subscriber_value=data)] # not needed any more
Jean-Paul Smets's avatar
Jean-Paul Smets committed
383
          # We will now apply the argument with the method edit
384
          if args != {} and (isConflict==0 or force) and (not simulate):
385 386
            #object._edit(**args)
            self.editDocument(object=object,**args)
387 388 389
            # It is sometimes required to do something after an edit
            if hasattr(object,'manage_afterEdit'):
              object.manage_afterEdit()
390

Jean-Paul Smets's avatar
Jean-Paul Smets committed
391 392
        if keyword == 'object':
          # This is the case where we have to call addNode
393 394
          conflict_list += self.addNode(xml=xml, object=object, force=force, 
              simulate=simulate, **kw)['conflict_list']
395
        elif keyword == self.history_tag and not simulate:
396
          # This is the case where we have to call addNode
397
          conflict_list += self.addNode(xml=subnode,object=object,force=force,
398
              simulate=simulate,**kw)['conflict_list']
Sebastien Robin's avatar
Sebastien Robin committed
399
        elif keyword in (self.local_role_tag,self.local_permission_tag) and not simulate:
400
          # This is the case where we have to update Roles or update permission
Nicolas Delaby's avatar
Nicolas Delaby committed
401
          #LOG('updateNode',0,'we will add a local role')
402 403 404 405
          #user = self.getSubObjectId(xml)
          #roles = self.convertXmlValue(data,data_type='tokens')
          #object.manage_setLocalRoles(user,roles)
          xml = self.getElementFromXupdate(xml)
406 407
          conflict_list += self.addNode(xml=xml, object=object, force=force, 
              simulate=simulate,**kw)['conflict_list']
Jean-Paul Smets's avatar
Jean-Paul Smets committed
408 409 410
      elif self.isSubObjectModification(xml):
        # We should find the object corresponding to
        # this update, so we have to look in the previous_xml
411
        sub_object_id = self.getSubObjectId(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
412
        #LOG('updateNode',0,'isSubObjectModification sub_object_id: %s' % sub_object_id)
413
        if previous_xml is not None and sub_object_id is not None:
Nicolas Delaby's avatar
Nicolas Delaby committed
414
          #LOG('updateNode',0,'previous xml is not none and also sub_object_id')
415
          sub_previous_xml = self.getSubObjectXml(sub_object_id,previous_xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
416
          #LOG('updateNode',0,'isSubObjectModification sub_p_xml: %s' % str(sub_previous_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
417 418 419
          if sub_previous_xml is not None:
            sub_object = None
            try:
420
              sub_object = object[sub_object_id]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
421 422 423
            except KeyError:
              pass
            if sub_object is not None:
Nicolas Delaby's avatar
Nicolas Delaby committed
424
              #LOG('updateNode',0,'subobject.id: %s' % sub_object.id)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
425 426 427
              # Change the xml in order to directly apply
              # modifications to the subobject
              sub_xml = self.getSubObjectXupdate(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
428
              #LOG('updateNode',0,'sub_xml: %s' % str(sub_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
429
              # Then do the udpate
430 431 432
              conflict_list += self.updateNode(xml=sub_xml, object=sub_object, 
                  force=force, previous_xml=sub_previous_xml, 
                  simulate=simulate, **kw)
433 434 435 436 437 438 439 440 441 442 443 444 445
        elif previous_xml is None and xml is not None and sub_object_id is not None:
          sub_object = None
          try:
            sub_object = object[sub_object_id]
          except KeyError:
            pass
          if sub_object is not None:
            sub_xml = self.getSubObjectXupdate(xml)
            conflict_list += self.updateNode(xml=sub_xml,
                                             object=sub_object,
                                             force=force,
                                             simulate=simulate,
                                             **kw)
446 447 448 449 450 451 452 453 454 455 456 457 458
        elif previous_xml is None and xml is not None and sub_object_id is not None:
          sub_object = None
          try:
            sub_object = object[sub_object_id]
          except KeyError:
            pass
          if sub_object is not None:
            sub_xml = self.getSubObjectXupdate(xml)
            conflict_list += self.updateNode(xml=sub_xml,
                                             object=sub_object,
                                             force=force,
                                             simulate=simulate,
                                             **kw)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
459 460
    return conflict_list

461 462
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getFormatedArgs')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
  def getFormatedArgs(self, args=None):
    """
    This lookd inside the args dictionnary and then
    convert any unicode string to string
    """
    new_args = {}
    for keyword in args.keys():
      data = args[keyword]
      if type(keyword) is type(u"a"):
        keyword = keyword.encode(self.getEncoding())
      if type(data) is type([]) or type(data) is type(()):
        new_data = []
        for item in data:
          if type(item) is type(u"a"):
            item = item.encode(self.getEncoding())
478
            item = item.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
479 480 481 482
          new_data += [item]
        data = new_data
      if type(data) is type(u"a"):
        data = data.encode(self.getEncoding())
483
        data = data.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
484
      if keyword == 'binary_data':
Nicolas Delaby's avatar
Nicolas Delaby committed
485
        #LOG('ERP5Conduit.getFormatedArgs',0,'binary_data keyword: %s' % str(keyword))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
486 487 488 489 490 491 492
        msg = MIMEBase('application','octet-stream')
        Encoders.encode_base64(msg)
        msg.set_payload(data)
        data = msg.get_payload(decode=1)
      new_args[keyword] = data
    return new_args

Sebastien Robin's avatar
Sebastien Robin committed
493
  security.declareProtected(Permissions.AccessContentsInformation,'isProperty')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
494 495 496 497
  def isProperty(self, xml):
    """
    Check if it is a simple property
    """
498
    bad_list = (self.sub_object_exp,self.history_exp)
499 500
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
501 502
        value = subnode.nodeValue
        for bad_string in bad_list:
503
          if re.search(bad_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
504 505 506
            return 0
    return 1

507 508
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectXupdate')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
509 510 511 512 513
  def getSubObjectXupdate(self, xml):
    """
    This will change the xml in order to change the update
    from the object to the subobject
    """
514 515
    xml_copy = xml.cloneNode(True) #make a deepcopy of the node xml
    for subnode in self.getAttributeNodeList(xml_copy):
516 517
      if subnode.nodeName=='select':
        subnode.nodeValue = self.getSubObjectSelect(subnode.nodeValue)
518
    return xml_copy
Jean-Paul Smets's avatar
Jean-Paul Smets committed
519

520 521
  security.declareProtected(Permissions.AccessContentsInformation, 
      'isHistoryAdd')
522
  def isHistoryAdd(self, xml):
Sebastien Robin's avatar
Sebastien Robin committed
523
    bad_list = (self.history_exp,)
524 525
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
526 527 528
        value = subnode.nodeValue
        for bad_string in bad_list:
          if re.search(bad_string,value) is not None:
Sebastien Robin's avatar
Sebastien Robin committed
529 530 531 532
            if re.search(self.bad_history_exp,value) is None:
              return 1
            else:
              return -1
533 534
    return 0

535 536
  security.declareProtected(Permissions.AccessContentsInformation, 
      'isSubObjectModification')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
537 538 539 540
  def isSubObjectModification(self, xml):
    """
    Check if it is a modification from an subobject
    """
541
    good_list = (self.sub_object_exp,)
542 543
    for subnode in self.getAttributeNodeList(xml) :
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
544 545
        value = subnode.nodeValue
        for good_string in good_list:
546
          if re.search(good_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
547 548 549
            return 1
    return 0

550 551
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectDepth')
552 553 554 555 556 557 558
  def getSubObjectDepth(self, xml):
    """
    Give the Depth of a subobject modification
    0 means, no depth
    1 means it is a subobject
    2 means it is more depth than subobject
    """
Nicolas Delaby's avatar
Nicolas Delaby committed
559
    #LOG('getSubObjectDepth',0,'xml.nodeName: %s' % xml.nodeName)
560
    if xml.nodeName in self.XUPDATE_TAG:
561 562 563
      i = 0
      if xml.nodeName in self.XUPDATE_INSERT:
        i = 1
Nicolas Delaby's avatar
Nicolas Delaby committed
564
      #LOG('getSubObjectDepth',0,'xml2.nodeName: %s' % xml.nodeName)
565
      for subnode in self.getAttributeNodeList(xml):
Nicolas Delaby's avatar
Nicolas Delaby committed
566
        #LOG('getSubObjectDepth',0,'subnode.nodeName: %s' % subnode.nodeName)
567 568
        if subnode.nodeName == 'select':
          value = subnode.nodeValue
Nicolas Delaby's avatar
Nicolas Delaby committed
569
          #LOG('getSubObjectDepth',0,'subnode.nodeValue: %s' % subnode.nodeValue)
570 571 572 573 574 575 576 577 578 579
          if re.search(self.sub_sub_object_exp,value) is not None:
            return 2 # This is sure in all cases
          elif re.search(self.sub_object_exp,value) is not None:
            #new_select = self.getSubObjectSelect(value) # Still needed ???
            #if self.getSubObjectSelect(new_select) != new_select:
            #  return (2 - i)
            #return (1 - i)
            return (2 - i)
          elif re.search(self.object_exp,value) is not None:
            return (1 - i)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
580 581
    return 0

582 583
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectSelect')
584
  def getSubObjectSelect(self, select):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
585
    """
586 587
    Return a string wich is the selection for the subobject
    ex: for "/object[@id='161']/object[@id='default_address']/street_address"
588
    it returns "/object[@id='default_address']/street_address"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
589
    """
590 591 592 593 594 595
    if re.search(self.object_exp,select) is not None:
      s = '/'
      if re.search('/.*/',select) is not None: # This means we have more than just object
        new_value = select[select.find(s,select.find(s)+1):]
      else:
        new_value = '/'
596 597 598
      select = new_value
    return select

599 600
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectId')
601 602 603 604 605 606 607
  def getSubObjectId(self, xml):
    """
    Return the id of the subobject in an xupdate modification
    """
    object_id = None
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
608
        value = subnode.nodeValue
609 610 611 612
        if re.search(self.object_exp,value) is not None:
          s = "'"
          first = value.find(s)+1
          object_id = value[first:value.find(s,first)]
613 614 615
          return object_id
    return object_id

616 617
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getHistoryIdFromSelect')
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
  def getHistoryIdFromSelect(self, xml):
    """
    Return the id of the subobject in an xupdate modification
    """
    object_id = None
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
        value = subnode.nodeValue
        if re.search(self.history_exp,value) is not None:
          s = self.history_tag
          object_id = value[value.find(s):]
          object_id = object_id[object_id.find("'")+1:]
          object_id = object_id[:object_id.find("'")]
          return object_id
    return object_id

634 635
  security.declareProtected(Permissions.AccessContentsInformation,
      'getSubObjectXml')
636 637 638 639 640 641 642
  def getSubObjectXml(self, object_id, xml):
    """
    Return the xml of the subobject which as the id object_id
    """
    xml = self.convertToXml(xml)
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName==self.xml_object_tag:
643
        if object_id == self.getAttribute(subnode,'id'):
644 645
          return subnode
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
646

Sebastien Robin's avatar
Sebastien Robin committed
647
  security.declareProtected(Permissions.AccessContentsInformation,'getAttribute')
648
  def getAttribute(self, xml, param):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
649
    """
650
    Retrieve the given parameter from the xml
Jean-Paul Smets's avatar
Jean-Paul Smets committed
651
    """
652
    for attribute in self.getAttributeNodeList(xml):
653
      if attribute.nodeName == param:
654
        data = attribute.value
655
        return self.convertXmlValue(data,data_type='string')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
656 657
    return None

Sebastien Robin's avatar
Sebastien Robin committed
658
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectDocid')
659 660 661 662 663 664
  def getObjectDocid(self, xml):
    """
    Retrieve the docid
    """
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == 'docid':
665
        data = subnode.childNodes[0].value
666 667
        return self.convertXmlValue(data)
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
668

Sebastien Robin's avatar
Sebastien Robin committed
669
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectProperty')
670
  def getObjectProperty(self, property, xml, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
671 672 673
    """
    Retrieve the given property
    """
674
    xml = self.convertToXml(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
675 676 677
    # document, with childNodes[0] a DocumentType and childNodes[1] the Element Node
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == property:
678 679
        if data_type is None:
          data_type = self.getPropertyType(subnode)
680 681 682 683
        try:
          data = subnode.childNodes[0].data
        except IndexError: # There is no data
          data = None
684
        data =  self.convertXmlValue(data, data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
685 686 687
        return data
    return None

Sebastien Robin's avatar
Sebastien Robin committed
688
  security.declareProtected(Permissions.AccessContentsInformation,'convertToXml')
689
  def convertToXml(self,xml):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
690 691 692
    """
    if xml is a string, convert it to a node
    """
693 694
    if xml is None:
      return
Jean-Paul Smets's avatar
Jean-Paul Smets committed
695
    if type(xml) in (type('a'),type(u'a')):
696
      if type(xml) is type(u'a'):
Sebastien Robin's avatar
Sebastien Robin committed
697
        xml = xml.encode('utf-8')
698
      xml = Parse(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
699
      #LOG('Conduit.convertToXml not failed',0,'ok')
Sebastien Robin's avatar
Sebastien Robin committed
700
      xml = xml.childNodes[0] # Because we just created a new xml
701 702 703
    # If we have the xml from the node erp5, we just take the subnode
    if xml.nodeName=='erp5':
      xml = self.getElementNodeList(xml)[0]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
704 705
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
706
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
707 708 709 710 711
  def getObjectType(self, xml):
    """
    Retrieve the portal type from an xml
    """
    portal_type = None
712 713 714 715 716
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='portal_type':
        portal_type = subnode.nodeValue
        portal_type = self.convertXmlValue(portal_type)
        return portal_type
Jean-Paul Smets's avatar
Jean-Paul Smets committed
717 718
    return portal_type

Sebastien Robin's avatar
Sebastien Robin committed
719
  security.declareProtected(Permissions.AccessContentsInformation,'getPropertyType')
720 721 722 723
  def getPropertyType(self, xml):
    """
    Retrieve the portal type from an xml
    """
Sebastien Robin's avatar
Sebastien Robin committed
724
    p_type = None # use getElementsByTagName !!!! XXX
725 726 727 728 729 730 731
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='type':
        p_type = subnode.nodeValue
        p_type = self.convertXmlValue(p_type,data_type='string')
        return p_type
    return p_type

Sebastien Robin's avatar
Sebastien Robin committed
732
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
733 734 735
  def getXupdateObjectType(self, xml):
    """
    Retrieve the portal type from an xupdate
736
    XXXX  This should not be used any more !!! XXXXXXXXXXX
Jean-Paul Smets's avatar
Jean-Paul Smets committed
737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
    """
    if xml.nodeName.find('xupdate')>=0:
      for subnode in self.getElementNodeList(xml):
        if subnode.nodeName == 'xupdate:element':
          for subnode1 in self.getElementNodeList(subnode):
            if subnode1.nodeName == 'xupdate:attribute':
              for attribute in subnode1.attributes:
                if attribute.nodeName == 'name':
                  if attribute.nodeValue == 'portal_type':
                    data = subnode1.childNodes[0].data
                    data = self.convertXmlValue(data)
                    return data
    return None


Sebastien Robin's avatar
Sebastien Robin committed
752
  security.declareProtected(Permissions.ModifyPortalContent, 'newObject')
753
  def newObject(self, object=None, xml=None, simulate=0, reset_local_roles=1, reset_workflow=1):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
754 755 756 757 758
    """
      modify the object with datas from
      the xml (action section)
    """
    args = {}
759 760
    if simulate:
      return
761
    # Retrieve the list of users with a role and delete default roles
762 763 764
    if reset_local_roles:
      user_role_list = map(lambda x:x[0],object.get_local_roles())
      object.manage_delLocalRoles(user_role_list)
765 766
    if hasattr(object,'workflow_history') and reset_workflow:
      object.workflow_history = PersistentMapping()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
767 768 769 770
    if xml.nodeName.find('xupdate')>= 0:
      xml = self.getElementNodeList(xml)[0]
    for subnode in self.getElementNodeList(xml):
      if not(subnode.nodeName in self.NOT_EDITABLE_PROPERTY):
771
        keyword_type = self.getPropertyType(subnode)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
772 773 774 775 776
        # This is the case where the property is a list
        keyword=str(subnode.nodeName)
        if len(subnode.childNodes) > 0: # We check that this tag is not empty
          data = subnode.childNodes[0].data
          args[keyword]=data
777 778
        #if args.has_key(keyword):
        #  LOG('newObject',0,'data: %s' % str(args[keyword]))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
779
        if args.has_key(keyword):
780
          args[keyword] = self.convertXmlValue(args[keyword],keyword_type)
781
      elif subnode.nodeName in self.ADDABLE_PROPERTY:
Sebastien Robin's avatar
Sebastien Robin committed
782
        self.addNode(object=object,xml=subnode, force=1)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
783 784 785 786
    # We should first edit the object
    args = self.getFormatedArgs(args=args)
    # edit the object with a dictionnary of arguments,
    # like {"telephone_number":"02-5648"}
787 788
    #object._edit(**args)
    self.editDocument(object=object,**args)
789 790 791
    if hasattr(object,'manage_afterEdit'):
      object.manage_afterEdit()

Jean-Paul Smets's avatar
Jean-Paul Smets committed
792 793

    # Then we may create subobject
794
    for subnode in self.getElementNodeList(xml):
Sebastien Robin's avatar
Sebastien Robin committed
795
      if subnode.nodeName in (self.xml_object_tag,): #,self.history_tag):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
796 797
        self.addNode(object=object,xml=subnode)

Sebastien Robin's avatar
Sebastien Robin committed
798
  security.declareProtected(Permissions.AccessContentsInformation,'getStatusFromXml')
799 800 801 802 803 804 805 806 807 808 809
  def getStatusFromXml(self, xml):
    """
    Return a worklow status from xml
    """
    status = {}
    for subnode in self.getElementNodeList(xml):
      keyword = self.convertXmlValue(subnode.nodeName)
      value = self.getObjectProperty(keyword,xml)
      status[keyword] = value
    return status

Sebastien Robin's avatar
Sebastien Robin committed
810
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateElementList')
811 812 813 814 815 816 817 818
  def getXupdateElementList(self, xml):
    """
    Retrieve the list of xupdate:element subnodes
    """
    e_list = []
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName in self.XUPDATE_EL:
        e_list += [subnode]
Nicolas Delaby's avatar
Nicolas Delaby committed
819
    #LOG('getXupdateElementList, e_list:',0,e_list)
820 821
    return e_list

Sebastien Robin's avatar
Sebastien Robin committed
822
  security.declareProtected(Permissions.AccessContentsInformation,'getElementFromXupdate')
823 824 825 826 827
  def getElementFromXupdate(self, xml):
    """
    from a xupdate:element returns the element as xml
    """
    if xml.nodeName in self.XUPDATE_EL:
Sebastien Robin's avatar
Sebastien Robin committed
828 829
      result = unicode('<',encoding='utf-8')
      result += xml.attributes.values()[0].nodeValue
830 831
      for subnode in self.getElementNodeList(xml):  #getElementNodeList
        if subnode.nodeName == 'xupdate:attribute':
Sebastien Robin's avatar
Sebastien Robin committed
832
          result += ' ' + subnode.attributes.values()[0].nodeValue + '='
833 834
          result += '"' + subnode.childNodes[0].nodeValue + '"'
      result += '>'
835
      # Then dumps the xml and remove what we does'nt want
Sebastien Robin's avatar
Sebastien Robin committed
836 837 838 839
      #xml_string = StringIO()
      #PrettyPrint(xml,xml_string)
      #xml_string = xml_string.getvalue()
      #xml_string = unicode(xml_string,encoding='utf-8')
840
      xml_string = self.nodeToString(xml)
841
      xml_string = unicode(xml_string,encoding='utf-8')
Sebastien Robin's avatar
Sebastien Robin committed
842 843
      #if type(xml_string) is type (u'a'):
      #  xml_string = xml_string.encode('utf-8')
844 845 846
      maxi = max(xml_string.find('>')+1,\
                 xml_string.rfind('</xupdate:attribute>')+len('</xupdate:attribute>'))
      result += xml_string[maxi:xml_string.find('</xupdate:element>')]
Sebastien Robin's avatar
Sebastien Robin committed
847 848
      result += '</' + xml.attributes.values()[0].nodeValue + '>'
      return self.convertToXml(result.encode('utf-8'))
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
    if xml.nodeName in (self.XUPDATE_UPDATE+self.XUPDATE_DEL):
      result = u'<'
      for subnode in self.getAttributeNodeList(xml):
        if subnode.nodeName == 'select':
          attribute = subnode.nodeValue
      s = '[@id='
      s_place = attribute.find(s)
      select_id = None
      if (s_place > 0):
        select_id = attribute[s_place+len(s):]
        select_id = select_id[:select_id.find("'",1)+1]
      else:
        s_place = len(attribute)
      property = attribute[:s_place]
      if property.find('/')==0:
        property = property[1:]
      result += property
      if select_id is not None:
        result += ' id=%s' % select_id
      result +=  '>'
869
      xml_string = self.nodeToString(xml)
870 871 872 873
      xml_string = unicode(xml_string,encoding='utf-8')
      maxi = xml_string.find('>')+1
      result += xml_string[maxi:xml_string.find('</%s>' % xml.nodeName)]
      result += '</' + property + '>'
Nicolas Delaby's avatar
Nicolas Delaby committed
874
      #LOG('getElementFromXupdate, result:',0,repr(result))
875
      return self.convertToXml(result)
876 877
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
878
  security.declareProtected(Permissions.AccessContentsInformation,'getWorkflowActionFromXml')
879 880 881 882 883 884 885 886 887 888 889 890 891
  def getWorkflowActionFromXml(self, xml):
    """
    Return the list of workflow actions
    """
    action_list = []
    if xml.nodeName in self.XUPDATE_EL:
      action_list += [xml]
      return action_list
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == self.action_tag:
        action_list += [subnode]
    return action_list

Sebastien Robin's avatar
Sebastien Robin committed
892
  security.declareProtected(Permissions.AccessContentsInformation,'convertXmlValue')
893
  def convertXmlValue(self, data, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
894 895
    """
    It is possible that the xml change the value, for example
896 897 898 899 900 901
    there is some too much '\n' and some spaces. We have to do some extra
    things so that we convert correctly the vlalue
    """
    if data is None:
      if data_type in self.list_type_list:
        data = ()
902 903
      if data_type in self.text_type_list:
        data = ''
904
      return data
Jean-Paul Smets's avatar
Jean-Paul Smets committed
905 906 907
    data = data.replace('\n','')
    if type(data) is type(u"a"):
      data = data.encode(self.getEncoding())
908 909
    if data=='None':
      return None
910 911 912 913 914 915
    # We can now convert string in tuple, dict, binary...
    if data_type in self.list_type_list:
      if type(data) is type('a'):
        data = tuple(data.split('@@@'))
    elif data_type in self.text_type_list:
      data = data.replace('@@@','\n')
916 917 918 919 920 921
#     elif data_type in self.binary_type_list:
#       data = data.replace('@@@','\n')
#       msg = MIMEBase('application','octet-stream')
#       Encoders.encode_base64(msg)
#       msg.set_payload(data)
#       data = msg.get_payload(decode=1)
922
      data = unescape(data)
923
    elif data_type in self.pickle_type_list:
924 925 926 927 928
      data = data.replace('@@@','\n')
      msg = MIMEBase('application','octet-stream')
      Encoders.encode_base64(msg)
      msg.set_payload(data)
      data = msg.get_payload(decode=1)
929
      data = pickle.loads(data)
930 931
    elif data_type in self.date_type_list:
      data = DateTime(data)
Sebastien Robin's avatar
Sebastien Robin committed
932 933
    elif data_type in self.int_type_list:
      data = int(data)
Sebastien Robin's avatar
Sebastien Robin committed
934 935 936 937 938 939 940
    elif data_type in self.dict_type_list: # only usefull for CPS, with data = '{fr:1}'
      if data == '{}':
        data = {}
      else:
        dict_list = map(lambda x:x.split(':'),data[1:-1].split(','))
        data = map(lambda (x,y):(x.replace(' ','').replace("'",''),int(y)),dict_list)
        data = dict(data)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
941 942
    return data

943 944
  # XXX is it the right place ? It should be in XupdateUtils, but here we
  # have some specific things to do
Sebastien Robin's avatar
Sebastien Robin committed
945
  security.declareProtected(Permissions.ModifyPortalContent, 'applyXupdate')
946 947
  def applyXupdate(self, object=None, xupdate=None, conduit=None, force=0,
                   simulate=0, **kw):
948 949 950 951 952
    """
    Parse the xupdate and then it will call the conduit
    """
    conflict_list = []
    if type(xupdate) in (type('a'),type(u'a')):
953
      xupdate = Parse(xupdate)
954 955 956 957 958 959 960 961 962 963 964 965 966 967
    #When xupdate mix different object, (like object and his subobject) we need to treat them separatly
    if self.isMixedXupdate(xupdate):
      #return to updateNode with only one line
      #del all sub_element
      sub_node_list = self.getElementNodeList(xupdate)
      #clean the node
      for subnode in sub_node_list:
        #Create one xupdate:modification per update node
        conflict_list += self.updateNode(xml=subnode,
                                         object=object,
                                         force=force,
                                         simulate=simulate,
                                         **kw)
      return conflict_list
968 969 970 971 972
    for subnode in self.getElementNodeList(xupdate):
      sub_xupdate = self.getSubObjectXupdate(subnode)
      selection_name = ''
      if subnode.nodeName in self.XUPDATE_INSERT_OR_ADD:
        conflict_list += conduit.addNode(xml=sub_xupdate,object=object, \
973
                                         force=force, simulate=simulate, **kw)['conflict_list']
974 975
      elif subnode.nodeName in self.XUPDATE_DEL:
        conflict_list += conduit.deleteNode(xml=sub_xupdate, object=object, \
976
                                      force=force, simulate=simulate, **kw)
977 978
      elif subnode.nodeName in self.XUPDATE_UPDATE:
        conflict_list += conduit.updateNode(xml=sub_xupdate, object=object, \
979
                                         force=force, simulate=simulate, **kw)
980 981 982 983 984
      #elif subnode.nodeName in self.XUPDATE_INSERT:
      #  conflict_list += conduit.addNode(xml=subnode, object=object, force=force, **kw)

    return conflict_list

985 986 987 988 989 990
  def isMixedXupdate(self, xml):
    #If an xupdate:modifications contains modification which concerns different objects
    subnode_list = self.getElementNodeList(xml)
    nb_sub = len(subnode_list)
    comp = 0
    for subnode in subnode_list:
991
      value = self.getAttribute(subnode, 'select')
992 993 994 995 996 997
      if re.search(self.object_exp, value):
        comp += 1
    if nb_sub == comp:
      return 0
    return 1

998 999
  def isWorkflowActionAddable(self, object=None,status=None,wf_tool=None,
                              wf_id=None,xml=None):
Sebastien Robin's avatar
Sebastien Robin committed
1000 1001
    """
    Some checking in order to check if we should add the workfow or not
1002 1003 1004 1005
    We should not returns a conflict list as we wanted before, we should
    instead go to a conflict state.
    """
    # We first test if the status in not already inside the workflow_history
1006 1007
    return 1
    # XXX Disable for now
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
    wf_history = object.workflow_history
    if wf_history.has_key(wf_id):
      action_list = wf_history[wf_id]
    else: action_list = []
    addable = 1
    for action in action_list:
      this_one = 1
      for key in action.keys():
        if status[key] != action[key]:
          this_one = 0
          break
      if this_one:
        addable = 0
        break
    return addable

1024 1025 1026 1027 1028 1029 1030 1031
  security.declareProtected(Permissions.ModifyPortalContent, 'constructContent')
  def constructContent(self, object, object_id, docid, portal_type):
    """
    This allows to specify how to construct a new content.
    This is really usefull if you want to write your
    own Conduit.
    """
    portal_types = getToolByName(object,'portal_types')
Nicolas Delaby's avatar
Nicolas Delaby committed
1032
    #LOG('ERP5Conduit.addNode',0,'portal_type: |%s|' % str(portal_type))
1033
    if docid==None: # ERP5 content
1034
      object.newContent(portal_type=portal_type,id=object_id)
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
    else: # CPS content
      # This is specific to CPS, we will call the proxy tool
      px_tool= getToolByName(object,'portal_proxies')
      trees_tool= getToolByName(object,'portal_trees')
      proxy_type = 'document'
      if portal_type in ('Workspace','Section'):
        proxy_type = 'folder'
      proxy = px_tool.createEmptyProxy(proxy_type,
                                object,portal_type,object_id,docid=docid)
      proxy.isIndexable = 0 # So it will not be reindexed, this prevent errors
      # Calculate rpath
      utool = getToolByName(object, 'portal_url')
      rpath = utool.getRelativeUrl(proxy)
      px_tool._modifyProxy(proxy,rpath)
      trees_tool.notify_tree('sys_modify_object',proxy,rpath)
    subobject = object._getOb(object_id)
    return subobject
1052

1053 1054 1055 1056 1057
  security.declareProtected(Permissions.ModifyPortalContent, 'addWorkflowNode')
  def addWorkflowNode(self, object, xml, simulate):
    """
    This allows to specify how to handle the workflow informations.
    This is really usefull if you want to write your own Conduit.
1058
    """
1059 1060 1061 1062 1063 1064 1065 1066 1067
    conflict_list = []
    # We want to add a workflow action
    wf_tool = getToolByName(object,'portal_workflow')
    wf_id = self.getAttribute(xml,'id')
    if wf_id is None: # History added by xupdate
      wf_id = self.getHistoryIdFromSelect(xml)
      xml = self.getElementNodeList(xml)[0]
    #for action in self.getWorkflowActionFromXml(xml):
    status = self.getStatusFromXml(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
1068
    #LOG('addNode, status:',0,status)
1069 1070 1071 1072 1073
    add_action = self.isWorkflowActionAddable(object=object,
                                           status=status,wf_tool=wf_tool,
                                           wf_id=wf_id,xml=xml)
    if add_action and not simulate:
      wf_tool.setStatusOf(wf_id,object,status)
1074 1075

    # Specific CPS, try to remove duplicate lines in portal_repository._histories
Sebastien Robin's avatar
Sebastien Robin committed
1076
    tool = getToolByName(self,'portal_repository',None)
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
    if tool is not None:
      if hasattr(self,'getDocid'):
        docid = self.getDocid()
        history = tool.getHistory(docid)
        new_history = ()
        for history_line in history:
          if history_line not in new_history:
            new_history += (history_line,)
        tool.setHistory(docid,new_history)

1087
    return conflict_list
1088

1089 1090 1091 1092 1093
  security.declareProtected(Permissions.ModifyPortalContent, 'addLocalRoleNode')
  def addLocalRoleNode(self, object, xml):
    """
    This allows to specify how to handle the local role informations.
    This is really usefull if you want to write your own Conduit.
1094 1095
    """
    conflict_list = []
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
    # We want to add a local role
    roles = self.convertXmlValue(xml.childNodes[0].data,data_type='tokens')
    user = self.getAttribute(xml,'id')
    roles = list(roles) # Needed for CPS, or we have a CPS error
    LOG('local_role: ',0,'user: %s roles: %s' % (repr(user),repr(roles)))
    #user = roles[0]
    #roles = roles[1:]
    if xml.nodeName.find(self.local_role_tag)>=0:
      object.manage_setLocalRoles(user,roles)
    elif xml.nodeName.find(self.local_group_tag)>=0:
      object.manage_setLocalGroupRoles(user,roles)
    return conflict_list
1108

1109 1110 1111 1112 1113
  security.declareProtected(Permissions.ModifyPortalContent, 'addLocalPermissionNode')
  def addLocalPermissionNode(self, object, xml):
    """
    This allows to specify how to handle the local permision informations.
    This is really usefull if you want to write your own Conduit.
1114 1115
    """
    conflict_list = []
1116
    # We want to add a local role
1117 1118 1119
    LOG('addLocalPermissionNode, xml',0,xml)
    if len(xml.childNodes)>0:
      roles = self.convertXmlValue(xml.childNodes[0].data,data_type='tokens')
1120
      roles = list(roles) # Needed for CPS, or we have a CPS error
1121
    else:
1122
      roles = ()
1123 1124 1125 1126 1127
    permission = self.getAttribute(xml,'id')
    LOG('local_role: ',0,'permission: %s roles: %s' % (repr(permission),repr(roles)))
    #user = roles[0]
    #roles = roles[1:]
    if xml.nodeName.find(self.local_permission_tag)>=0:
1128
      object.manage_setLocalPermissions(permission,roles)
1129 1130
    return conflict_list

1131
  security.declareProtected(Permissions.ModifyPortalContent, 'editDocument')
1132 1133 1134 1135 1136 1137 1138
  def editDocument(self, object=None, **kw):
    """
    This is the default editDocument method. This method
    can easily be overwritten.
    """
    object._edit(**kw)

1139 1140 1141 1142 1143 1144 1145 1146
  security.declareProtected(Permissions.ModifyPortalContent, 'getProperty')
  def getProperty(self, object, kw):
    """
    This is the default getProperty method. This method
    can easily be overwritten.
    """
    return object.getProperty(kw)

1147

1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
    # This doesn't works fine because all workflows variables
    # are not set the same way
#    if status.has_key('action'):
#      action_name = status['action']
#      authorized = 0
#      authorized_actions = wf_tool.getActionsFor(object)
#      LOG('isWorkflowActionAddable, status:',0,status)
#      LOG('isWorkflowActionAddable, authorized_actions:',0,authorized_actions)
#      for action in authorized_actions:
#        if action['id']==action_name:
#          authorized = 1
#      if not authorized:
#        string_io = StringIO()
#        PrettyPrint(xml,stream=string_io)
#        conflict = Conflict(object_path=object.getPhysicalPath(),
#                            keyword=self.history_tag)
#        conflict.setXupdate(string_io.getvalue())
#        conflict.setRemoteValue(status)
#        conflict_list += [conflict]
1167
#    return conflict_list
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177

  def nodeToString(self, node):
    """
    return an xml string corresponding to the node
    """
    buf = cStringIO.StringIO()
    Print(node, stream=buf, encoding='utf-8')
    xml_string = buf.getvalue()
    buf.close() 
    return xml_string