ERP5Conduit.py 45.9 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
##############################################################################
#
# 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.
#
##############################################################################

29
from Products.ERP5SyncML.XMLSyncUtils import XMLSyncUtilsMixin
Jean-Paul Smets's avatar
Jean-Paul Smets committed
30 31
from Products.ERP5SyncML.Subscription import Conflict
from Products.CMFCore.utils import getToolByName
32
from Products.ERP5SyncML.XMLSyncUtils import Parse
33
from DateTime.DateTime import DateTime
Jean-Paul Smets's avatar
Jean-Paul Smets committed
34 35
from email.MIMEBase import MIMEBase
from email import Encoders
Sebastien Robin's avatar
Sebastien Robin committed
36
from AccessControl import ClassSecurityInfo
Fabien Morin's avatar
Fabien Morin committed
37
from Products.ERP5Type import Permissions, Interface
Sebastien Robin's avatar
Sebastien Robin committed
38
from Globals import PersistentMapping
39
import pickle
40
from cStringIO import StringIO
41
from xml.sax.saxutils import escape, unescape
Fabien Morin's avatar
Fabien Morin committed
42
import re
43
import cStringIO
44
from zLOG import LOG, INFO, DEBUG
45 46 47 48 49 50 51 52 53 54 55
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
56

Fabien Morin's avatar
Fabien Morin committed
57

58
class ERP5Conduit(XMLSyncUtilsMixin):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
  """
    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

80 81 82 83 84 85 86 87 88 89 90 91 92 93
    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
94

Fabien Morin's avatar
Fabien Morin committed
95 96 97
  # Declarative interfaces
  __implements__ = ( Interface.IConduit, )

Sebastien Robin's avatar
Sebastien Robin committed
98 99
  # Declarative security
  security = ClassSecurityInfo()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
100

Sebastien Robin's avatar
Sebastien Robin committed
101
  security.declareProtected(Permissions.AccessContentsInformation,'getEncoding')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
102 103 104 105
  def getEncoding(self):
    """
    return the string corresponding to the local encoding
    """
106 107
    #return "iso-8859-1"
    return "utf-8"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
108

Sebastien Robin's avatar
Sebastien Robin committed
109
  security.declareProtected(Permissions.ModifyPortalContent, '__init__')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
110 111
  def __init__(self):
    self.args = {}
112

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

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

Sebastien Robin's avatar
Sebastien Robin committed
211
  security.declareProtected(Permissions.ModifyPortalContent, 'deleteNode')
212 213
  def deleteNode(self, xml=None, object=None, object_id=None, force=None,
                 simulate=0, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
214 215 216
    """
    A node is deleted
    """
217
    # In the case where we have to delete an object
218
    #LOG('ERP5Conduit.deleteNode', DEBUG, 'deleteNode, object path: %s' % repr(object.getPhysicalPath()))
219
    conflict_list = []
220 221
    if xml is not None:
      xml = self.convertToXml(xml)
222
    if object_id is None:
223
      #LOG('ERP5Conduit.deleteNode', DEBUG, 'deleteNode, SubObjectDepth: %i' % self.getSubObjectDepth(xml))
224
      if xml.nodeName == self.xml_object_tag:
225
        object_id = self.getAttribute(xml,'id')
226 227 228 229 230
      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
231
        try:
232 233 234
          sub_object = object._getOb(sub_object_id)
          sub_xml = self.getSubObjectXupdate(xml)
          conflict_list += self.deleteNode(xml=sub_xml,object=sub_object,
235
                                       force=force, simulate=simulate, **kw)
236
        except (KeyError, AttributeError, TypeError):
237
          #LOG('ERP5Conduit.deleteNode', DEBUG, 'deleteNode, Unable to delete SubObject: %s' % str(sub_object_id))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
238
          pass
239
    if object_id is not None: # We do have an object_id
240
      self.deleteObject(object, object_id)
241 242 243 244 245 246 247
    # 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')
248
        #LOG('ERP5Conduit.deleteNode local_role: ', DEBUG, 'user: %s' % repr(user))
249 250 251 252
        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])
253 254
      if xml.nodeName in self.local_permission_list and not simulate:
        permission = self.getAttribute(xml,'id')
255
        object.manage_setLocalPermissions(permission)
256
    return conflict_list
Jean-Paul Smets's avatar
Jean-Paul Smets committed
257

258 259 260 261 262
  security.declareProtected(Permissions.ModifyPortalContent, 'deleteObject')
  def deleteObject(self, object, object_id):
    try:
      object._delObject(object_id)
    except (AttributeError, KeyError):
263
      #LOG('ERP5Conduit.deleteObject', DEBUG, 'Unable to delete: %s' % str(object_id))
264 265
      pass

Sebastien Robin's avatar
Sebastien Robin committed
266
  security.declareProtected(Permissions.ModifyPortalContent, 'updateNode')
267 268
  def updateNode(self, xml=None, object=None, previous_xml=None, force=0,
                 simulate=0,  **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
269 270 271 272 273 274 275 276
    """
    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 = []
277
    xml = self.convertToXml(xml)
278 279
    #LOG('ERP5Conduit.updateNode', DEBUG, 'xml.nodeName: %s' % xml.nodeName)
    #LOG('ERP5Conduit.updateNode, force: ', DEBUG, force)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
280 281
    # we have an xupdate xml
    if xml.nodeName == 'xupdate:modifications':
282 283 284
      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
285 286 287 288
    # we may have only the part of an xupdate
    else:
      args = {}
      if self.isProperty(xml) and not(self.isSubObjectModification(xml)):
289
        keyword = None
290 291
        for subnode in self.getAttributeNodeList(xml):
          if subnode.nodeName=='select':
292 293
            select_list = subnode.nodeValue.split('/') # Something like:
                                                       #('','object[1]','sid[1]')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
294 295
            new_select_list = ()
            for select_item in select_list:
296 297 298
              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
299 300
            select_list = new_select_list # Something like : ('','object','sid')
            keyword = select_list[len(select_list)-1] # this will be 'sid'
301 302
        data_xml = xml
        data = None
303
        if xml.nodeName not in self.XUPDATE_INSERT_OR_ADD:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
304 305 306 307 308
          for subnode in self.getElementNodeList(xml):
            if subnode.nodeName=='xupdate:element':
              for subnode1 in subnode.attributes:
                if subnode1.nodeName=='name':
                  keyword = subnode1.nodeValue
309
              data_xml = subnode
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
        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
326 327
        if keyword is None: # This is not a selection, directly the property
          keyword = xml.nodeName
328 329 330 331 332
        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
333 334
        if not (keyword in self.NOT_EDITABLE_PROPERTY):
          # We will look for the data to enter
335
          data_type = object.getPropertyType(keyword)
336
          #LOG('ERP5Conduit.updateNode', DEBUG, 'data_type: %s for keyword: %s' % (str(data_type), keyword))
337
          data = self.convertXmlValue(data,data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
338 339 340 341 342
          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
Fabien Morin's avatar
Fabien Morin committed
343 344
          #   - old_data : the data from this box but at the time of the i
          #last synchronization
Jean-Paul Smets's avatar
Jean-Paul Smets committed
345 346
          #   - current_data : the data actually on this box
          isConflict = 0
Fabien Morin's avatar
Fabien Morin committed
347 348
          if (previous_xml is not None) and (not force): 
          # if no previous_xml, no conflict
349 350
            old_data = self.getObjectProperty(keyword, previous_xml, 
                data_type=data_type)
351 352
            #current_data = object.getProperty(keyword)
            current_data = self.getProperty(object, keyword)
353 354 355
            #LOG('ERP5Conduit.updateNode', DEBUG, 'Conflict data: %s' % str(data))
            #LOG('ERP5Conduit.updateNode', DEBUG, 'Conflict old_data: %s' % str(old_data))
            #LOG('ERP5Conduit.updateNode', DEBUG, 'Conflict current_data: %s' % str(current_data))
356 357
            if (old_data != current_data) and (data != current_data) \
                and keyword not in self.force_conflict_list:
358
              #LOG('ERP5Conduit.updateNode', DEBUG, 'Conflict on : %s' % keyword)
359 360
              # Hack in order to get the synchronization working for demo
              # XXX this have to be removed after
361 362
              #if not (data_type in self.binary_type_list):
              if 1:
363 364
                # This is a conflict
                isConflict = 1
365 366
                string_io = StringIO()
                PrettyPrint(xml,stream=string_io)
Sebastien Robin's avatar
Sebastien Robin committed
367 368
                conflict = Conflict(object_path=object.getPhysicalPath(),
                                    keyword=keyword)
369
                conflict.setXupdate(string_io.getvalue())
Sebastien Robin's avatar
Sebastien Robin committed
370 371 372
                if not (data_type in self.binary_type_list):
                  conflict.setLocalValue(current_data)
                  conflict.setRemoteValue(data)
373
                conflict_list += [conflict]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
374
          # We will now apply the argument with the method edit
375
          if args != {} and (isConflict==0 or force) and (not simulate):
376
            self.editDocument(object=object,**args)
377 378 379
            # It is sometimes required to do something after an edit
            if hasattr(object,'manage_afterEdit'):
              object.manage_afterEdit()
380

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

450 451
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getFormatedArgs')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
  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())
467
            item = item.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
468 469 470 471
          new_data += [item]
        data = new_data
      if type(data) is type(u"a"):
        data = data.encode(self.getEncoding())
472
        data = data.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
473
      if keyword == 'binary_data':
474
        #LOG('ERP5Conduit.getFormatedArgs', DEBUG, 'binary_data keyword: %s' % str(keyword))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
475 476 477 478 479 480 481
        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
482
  security.declareProtected(Permissions.AccessContentsInformation,'isProperty')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
483 484 485 486
  def isProperty(self, xml):
    """
    Check if it is a simple property
    """
487
    bad_list = (self.sub_object_exp,self.history_exp)
488 489
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
490 491
        value = subnode.nodeValue
        for bad_string in bad_list:
492
          if re.search(bad_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
493 494 495
            return 0
    return 1

496 497
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectXupdate')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
498 499 500 501 502
  def getSubObjectXupdate(self, xml):
    """
    This will change the xml in order to change the update
    from the object to the subobject
    """
503 504
    xml_copy = xml.cloneNode(True) #make a deepcopy of the node xml
    for subnode in self.getAttributeNodeList(xml_copy):
505 506
      if subnode.nodeName=='select':
        subnode.nodeValue = self.getSubObjectSelect(subnode.nodeValue)
507
    return xml_copy
Jean-Paul Smets's avatar
Jean-Paul Smets committed
508

509 510
  security.declareProtected(Permissions.AccessContentsInformation, 
      'isHistoryAdd')
511
  def isHistoryAdd(self, xml):
Sebastien Robin's avatar
Sebastien Robin committed
512
    bad_list = (self.history_exp,)
513 514
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
515 516 517
        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
518 519 520 521
            if re.search(self.bad_history_exp,value) is None:
              return 1
            else:
              return -1
522 523
    return 0

524 525
  security.declareProtected(Permissions.AccessContentsInformation, 
      'isSubObjectModification')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
526 527 528 529
  def isSubObjectModification(self, xml):
    """
    Check if it is a modification from an subobject
    """
530
    good_list = (self.sub_object_exp,)
531 532
    for subnode in self.getAttributeNodeList(xml) :
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
533 534
        value = subnode.nodeValue
        for good_string in good_list:
535
          if re.search(good_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
536 537 538
            return 1
    return 0

539 540
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectDepth')
541 542 543 544 545 546 547
  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
548
    #LOG('getSubObjectDepth',0,'xml.nodeName: %s' % xml.nodeName)
549
    if xml.nodeName in self.XUPDATE_TAG:
550 551 552
      i = 0
      if xml.nodeName in self.XUPDATE_INSERT:
        i = 1
Nicolas Delaby's avatar
Nicolas Delaby committed
553
      #LOG('getSubObjectDepth',0,'xml2.nodeName: %s' % xml.nodeName)
554
      for subnode in self.getAttributeNodeList(xml):
Nicolas Delaby's avatar
Nicolas Delaby committed
555
        #LOG('getSubObjectDepth',0,'subnode.nodeName: %s' % subnode.nodeName)
556 557
        if subnode.nodeName == 'select':
          value = subnode.nodeValue
Nicolas Delaby's avatar
Nicolas Delaby committed
558
          #LOG('getSubObjectDepth',0,'subnode.nodeValue: %s' % subnode.nodeValue)
559 560 561 562 563 564 565 566 567 568
          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
569 570
    return 0

571 572
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectSelect')
573
  def getSubObjectSelect(self, select):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
574
    """
575 576
    Return a string wich is the selection for the subobject
    ex: for "/object[@id='161']/object[@id='default_address']/street_address"
577
    it returns "/object[@id='default_address']/street_address"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
578
    """
579 580 581 582 583 584
    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 = '/'
585 586 587
      select = new_value
    return select

588 589
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getSubObjectId')
590 591 592 593 594 595 596
  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
597
        value = subnode.nodeValue
598 599 600 601
        if re.search(self.object_exp,value) is not None:
          s = "'"
          first = value.find(s)+1
          object_id = value[first:value.find(s,first)]
602 603 604
          return object_id
    return object_id

605 606
  security.declareProtected(Permissions.AccessContentsInformation, 
      'getHistoryIdFromSelect')
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
  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

623 624
  security.declareProtected(Permissions.AccessContentsInformation,
      'getSubObjectXml')
625 626 627 628 629 630
  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):
631
      if subnode.nodeName == self.xml_object_tag:
632
        if object_id == self.getAttribute(subnode,'id'):
633 634
          return subnode
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
635

Sebastien Robin's avatar
Sebastien Robin committed
636
  security.declareProtected(Permissions.AccessContentsInformation,'getAttribute')
637
  def getAttribute(self, xml, param):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
638
    """
639
    Retrieve the given parameter from the xml
Jean-Paul Smets's avatar
Jean-Paul Smets committed
640
    """
641
    for attribute in self.getAttributeNodeList(xml):
642
      if attribute.nodeName == param:
643
        data = attribute.value
644
        return self.convertXmlValue(data,data_type='string')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
645 646
    return None

Sebastien Robin's avatar
Sebastien Robin committed
647
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectProperty')
648
  def getObjectProperty(self, property, xml, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
649 650 651
    """
    Retrieve the given property
    """
652
    xml = self.convertToXml(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
653 654 655
    # document, with childNodes[0] a DocumentType and childNodes[1] the Element Node
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == property:
656 657
        if data_type is None:
          data_type = self.getPropertyType(subnode)
658 659 660 661
        try:
          data = subnode.childNodes[0].data
        except IndexError: # There is no data
          data = None
662
        data =  self.convertXmlValue(data, data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
663 664 665
        return data
    return None

Sebastien Robin's avatar
Sebastien Robin committed
666
  security.declareProtected(Permissions.AccessContentsInformation,'convertToXml')
667
  def convertToXml(self,xml):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
668 669 670
    """
    if xml is a string, convert it to a node
    """
671 672
    if xml is None:
      return
Jean-Paul Smets's avatar
Jean-Paul Smets committed
673
    if type(xml) in (type('a'),type(u'a')):
674
      if type(xml) is type(u'a'):
Sebastien Robin's avatar
Sebastien Robin committed
675
        xml = xml.encode('utf-8')
676
      xml = Parse(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
677
      #LOG('Conduit.convertToXml not failed',0,'ok')
Sebastien Robin's avatar
Sebastien Robin committed
678
      xml = xml.childNodes[0] # Because we just created a new xml
679 680 681
    # 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
682 683
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
684
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
685 686 687 688 689
  def getObjectType(self, xml):
    """
    Retrieve the portal type from an xml
    """
    portal_type = None
690 691 692 693 694
    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
695 696
    return portal_type

Sebastien Robin's avatar
Sebastien Robin committed
697
  security.declareProtected(Permissions.AccessContentsInformation,'getPropertyType')
698 699 700 701
  def getPropertyType(self, xml):
    """
    Retrieve the portal type from an xml
    """
Sebastien Robin's avatar
Sebastien Robin committed
702
    p_type = None # use getElementsByTagName !!!! XXX
703 704 705 706 707 708 709
    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
710
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
711 712 713
  def getXupdateObjectType(self, xml):
    """
    Retrieve the portal type from an xupdate
714
    XXXX  This should not be used any more !!! XXXXXXXXXXX
Jean-Paul Smets's avatar
Jean-Paul Smets committed
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
    """
    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
730
  security.declareProtected(Permissions.ModifyPortalContent, 'newObject')
731
  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
732 733 734 735 736
    """
      modify the object with datas from
      the xml (action section)
    """
    args = {}
737 738
    if simulate:
      return
739
    # Retrieve the list of users with a role and delete default roles
740 741 742
    if reset_local_roles:
      user_role_list = map(lambda x:x[0],object.get_local_roles())
      object.manage_delLocalRoles(user_role_list)
743 744
    if hasattr(object,'workflow_history') and reset_workflow:
      object.workflow_history = PersistentMapping()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
745 746 747 748
    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):
749
        keyword_type = self.getPropertyType(subnode)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
750 751 752 753 754
        # 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
755 756
        #if args.has_key(keyword):
        #  LOG('newObject',0,'data: %s' % str(args[keyword]))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
757
        if args.has_key(keyword):
758
          args[keyword] = self.convertXmlValue(args[keyword],keyword_type)
759
      elif subnode.nodeName in self.ADDABLE_PROPERTY:
Sebastien Robin's avatar
Sebastien Robin committed
760
        self.addNode(object=object,xml=subnode, force=1)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
761 762 763 764
    # We should first edit the object
    args = self.getFormatedArgs(args=args)
    # edit the object with a dictionnary of arguments,
    # like {"telephone_number":"02-5648"}
765
    self.editDocument(object=object,**args)
766 767
    if hasattr(object,'manage_afterEdit'):
      object.manage_afterEdit()
768
    self.afterNewObject(object = object)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
769 770

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

775 776 777 778
  security.declareProtected(Permissions.AccessContentsInformation,'afterNewObject')
  def afterNewObject(self, object):
    pass

Sebastien Robin's avatar
Sebastien Robin committed
779
  security.declareProtected(Permissions.AccessContentsInformation,'getStatusFromXml')
780 781 782 783 784 785 786 787 788 789 790
  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
791
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateElementList')
792 793 794 795 796 797 798 799
  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
800
    #LOG('getXupdateElementList, e_list:',0,e_list)
801 802
    return e_list

Sebastien Robin's avatar
Sebastien Robin committed
803
  security.declareProtected(Permissions.AccessContentsInformation,'getElementFromXupdate')
804 805 806 807 808
  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
809 810
      result = unicode('<',encoding='utf-8')
      result += xml.attributes.values()[0].nodeValue
811 812
      for subnode in self.getElementNodeList(xml):  #getElementNodeList
        if subnode.nodeName == 'xupdate:attribute':
Sebastien Robin's avatar
Sebastien Robin committed
813
          result += ' ' + subnode.attributes.values()[0].nodeValue + '='
814 815
          result += '"' + subnode.childNodes[0].nodeValue + '"'
      result += '>'
816
      # Then dumps the xml and remove what we does'nt want
Sebastien Robin's avatar
Sebastien Robin committed
817 818 819 820
      #xml_string = StringIO()
      #PrettyPrint(xml,xml_string)
      #xml_string = xml_string.getvalue()
      #xml_string = unicode(xml_string,encoding='utf-8')
821
      xml_string = self.nodeToString(xml)
822
      xml_string = unicode(xml_string, encoding='utf-8')
Sebastien Robin's avatar
Sebastien Robin committed
823 824
      #if type(xml_string) is type (u'a'):
      #  xml_string = xml_string.encode('utf-8')
825 826 827
      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
828 829
      result += '</' + xml.attributes.values()[0].nodeValue + '>'
      return self.convertToXml(result.encode('utf-8'))
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
    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 +=  '>'
850
      xml_string = self.nodeToString(xml)
851 852 853 854
      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
855
      #LOG('getElementFromXupdate, result:',0,repr(result))
856
      return self.convertToXml(result)
857 858
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
859
  security.declareProtected(Permissions.AccessContentsInformation,'getWorkflowActionFromXml')
860 861 862 863 864 865 866 867 868 869 870 871 872
  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
873
  security.declareProtected(Permissions.AccessContentsInformation,'convertXmlValue')
874
  def convertXmlValue(self, data, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
875 876
    """
    It is possible that the xml change the value, for example
877 878 879 880 881 882
    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 = ()
883 884
      if data_type in self.text_type_list:
        data = ''
885
      return data
Jean-Paul Smets's avatar
Jean-Paul Smets committed
886 887 888
    data = data.replace('\n','')
    if type(data) is type(u"a"):
      data = data.encode(self.getEncoding())
889 890
    if data=='None':
      return None
891 892 893 894 895 896
    # 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')
897 898 899 900 901 902
#     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)
903
      data = unescape(data)
904
    elif data_type in self.pickle_type_list:
905 906 907 908 909
      data = data.replace('@@@','\n')
      msg = MIMEBase('application','octet-stream')
      Encoders.encode_base64(msg)
      msg.set_payload(data)
      data = msg.get_payload(decode=1)
910
      data = pickle.loads(data)
911 912
    elif data_type in self.date_type_list:
      data = DateTime(data)
Sebastien Robin's avatar
Sebastien Robin committed
913 914
    elif data_type in self.int_type_list:
      data = int(data)
Sebastien Robin's avatar
Sebastien Robin committed
915 916 917 918 919 920 921
    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
922 923
    return data

924 925
  # 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
926
  security.declareProtected(Permissions.ModifyPortalContent, 'applyXupdate')
927 928
  def applyXupdate(self, object=None, xupdate=None, conduit=None, force=0,
                   simulate=0, **kw):
929 930 931 932 933
    """
    Parse the xupdate and then it will call the conduit
    """
    conflict_list = []
    if type(xupdate) in (type('a'),type(u'a')):
934
      xupdate = Parse(xupdate)
935 936 937 938 939 940 941 942 943 944 945 946 947 948
    #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
949 950 951 952 953
    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, \
954
                                         force=force, simulate=simulate, **kw)['conflict_list']
955 956
      elif subnode.nodeName in self.XUPDATE_DEL:
        conflict_list += conduit.deleteNode(xml=sub_xupdate, object=object, \
957
                                      force=force, simulate=simulate, **kw)
958 959
      elif subnode.nodeName in self.XUPDATE_UPDATE:
        conflict_list += conduit.updateNode(xml=sub_xupdate, object=object, \
960
                                         force=force, simulate=simulate, **kw)
961 962 963 964 965
      #elif subnode.nodeName in self.XUPDATE_INSERT:
      #  conflict_list += conduit.addNode(xml=subnode, object=object, force=force, **kw)

    return conflict_list

966 967 968 969 970 971
  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:
972
      value = self.getAttribute(subnode, 'select')
973 974 975 976 977 978
      if re.search(self.object_exp, value):
        comp += 1
    if nb_sub == comp:
      return 0
    return 1

979 980
  def isWorkflowActionAddable(self, object=None,status=None,wf_tool=None,
                              wf_id=None,xml=None):
Sebastien Robin's avatar
Sebastien Robin committed
981 982
    """
    Some checking in order to check if we should add the workfow or not
983 984 985 986
    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
987 988
    return 1
    # XXX Disable for now
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
    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

1005
  security.declareProtected(Permissions.ModifyPortalContent, 'constructContent')
1006
  def constructContent(self, object, object_id, portal_type):
1007 1008 1009 1010 1011
    """
    This allows to specify how to construct a new content.
    This is really usefull if you want to write your
    own Conduit.
    """
1012
    portal_types = getToolByName(object, 'portal_types')
Nicolas Delaby's avatar
Nicolas Delaby committed
1013
    #LOG('ERP5Conduit.addNode',0,'portal_type: |%s|' % str(portal_type))
1014 1015

    object.newContent(portal_type=portal_type, id=object_id)
1016
    subobject = object._getOb(object_id)
1017
    return subobject, 1, 1
1018

1019 1020 1021 1022 1023
  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.
1024
    """
1025 1026 1027 1028 1029 1030 1031 1032 1033
    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
1034
    #LOG('addNode, status:',0,status)
1035 1036 1037 1038 1039
    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)
1040 1041

    # Specific CPS, try to remove duplicate lines in portal_repository._histories
Sebastien Robin's avatar
Sebastien Robin committed
1042
    tool = getToolByName(self,'portal_repository',None)
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
    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)

1053
    return conflict_list
1054

1055 1056 1057 1058 1059
  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.
1060 1061
    """
    conflict_list = []
1062 1063 1064 1065
    # 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
1066
    #LOG('local_role: ',0,'user: %s roles: %s' % (repr(user),repr(roles)))
1067 1068 1069 1070 1071 1072 1073
    #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
1074

1075 1076 1077 1078 1079
  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.
1080 1081
    """
    conflict_list = []
1082
    # We want to add a local role
1083
    #LOG('addLocalPermissionNode, xml',0,xml)
1084 1085
    if len(xml.childNodes)>0:
      roles = self.convertXmlValue(xml.childNodes[0].data,data_type='tokens')
1086
      roles = list(roles) # Needed for CPS, or we have a CPS error
1087
    else:
1088
      roles = ()
1089
    permission = self.getAttribute(xml,'id')
1090
    #LOG('local_role: ',0,'permission: %s roles: %s' % (repr(permission),repr(roles)))
1091 1092 1093
    #user = roles[0]
    #roles = roles[1:]
    if xml.nodeName.find(self.local_permission_tag)>=0:
1094
      object.manage_setLocalPermissions(permission,roles)
1095 1096
    return conflict_list

1097
  security.declareProtected(Permissions.ModifyPortalContent, 'editDocument')
1098 1099 1100 1101 1102
  def editDocument(self, object=None, **kw):
    """
    This is the default editDocument method. This method
    can easily be overwritten.
    """
1103
    object._edit(**kw)
1104

1105 1106 1107 1108 1109 1110 1111 1112
  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)

1113 1114 1115 1116 1117 1118 1119
  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()
1120
    buf.close()
1121
    return xml_string
1122 1123 1124 1125 1126 1127 1128

  def getGidFromObject(self, object):
    """
    return the Gid composed with the object informations
    """
    return object.getId()

1129 1130 1131 1132 1133
  #def getGidFromXML(self, xml, gid_from_xml_list):
    #"""
    #return the Gid composed with xml informations
    #"""
    #return None
1134