ERP5Conduit.py 40.6 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 36
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
from xml.dom.ext.reader.Sax2 import FromXml
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 41
from AccessControl import ClassSecurityInfo
from Products.ERP5Type import Permissions
42 43
import pickle
import string
44 45
from xml.dom.ext import PrettyPrint
from cStringIO import StringIO
46
from xml.sax.saxutils import escape, unescape
47
import re, copy
Jean-Paul Smets's avatar
Jean-Paul Smets committed
48 49 50

from zLOG import LOG

51
class ERP5Conduit(XMLSyncUtilsMixin):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
  """
    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

73 74 75 76 77 78 79 80 81 82 83 84 85 86
    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
87

88
  """
Jean-Paul Smets's avatar
Jean-Paul Smets committed
89

Sebastien Robin's avatar
Sebastien Robin committed
90 91
  # Declarative security
  security = ClassSecurityInfo()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
92

Sebastien Robin's avatar
Sebastien Robin committed
93
  security.declareProtected(Permissions.AccessContentsInformation,'getEncoding')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
94 95 96 97 98 99
  def getEncoding(self):
    """
    return the string corresponding to the local encoding
    """
    return "iso-8859-1"

Sebastien Robin's avatar
Sebastien Robin committed
100
  security.declareProtected(Permissions.ModifyPortalContent, '__init__')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
101 102 103
  def __init__(self):
    self.args = {}

Sebastien Robin's avatar
Sebastien Robin committed
104
  security.declareProtected(Permissions.ModifyPortalContent, 'addNode')
105
  def addNode(self, xml=None, object=None, previous_xml=None,
106
              object_id=None, force=0, simulate=0, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
107 108 109
    """
    A node is added

110 111 112 113 114 115 116 117
    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
118 119
    This fucntion returns conflict_list, wich is of the form,
    [conflict1,conflict2,...] where conclict1 is of the form :
120
    [object.getPath(),keyword,local_and_actual_value,subscriber_value]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
121 122
    """
    conflict_list = []
123
    xml = self.convertToXml(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
124 125 126 127
    LOG('addNode',0,'xml_reconstitued: %s' % str(xml))
    # In the case where this new node is a object to add
    LOG('addNode',0,'object.id: %s' % object.getId())
    LOG('addNode',0,'xml.nodeName: %s' % xml.nodeName)
128
    LOG('addNode',0,'getSubObjectDepth: %i' % self.getSubObjectDepth(xml))
Sebastien Robin's avatar
Sebastien Robin committed
129
    LOG('addNode',0,'isHistoryAdd: %i' % self.isHistoryAdd(xml))
130
    if xml.nodeName in self.XUPDATE_INSERT_OR_ADD and self.getSubObjectDepth(xml)==0:
Sebastien Robin's avatar
Sebastien Robin committed
131 132 133 134
      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,
135 136
                          previous_xml=previous_xml, force=force,
                          simulate=simulate, **kw)
137
    elif xml.nodeName == 'object':
138 139
      if object_id is None:
        object_id = self.getAttribute(xml,'id')
140
      docid = self.getObjectDocid(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
141 142 143
      LOG('addNode',0,'object_id: %s' % object_id)
      if object_id is not None:
        try:
144
          subobject = object._getOb(object_id)
145
        except (AttributeError, KeyError, TypeError):
146
          subobject = None
147
        if subobject is None: # If so, it doesn't exist
Jean-Paul Smets's avatar
Jean-Paul Smets committed
148 149 150
          portal_type = ''
          if xml.nodeName == 'object':
            portal_type = self.getObjectType(xml)
151 152
          elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD: # Deprecated ???
            portal_type = self.getXupdateObjectType(xml) # Deprecated ???
Jean-Paul Smets's avatar
Jean-Paul Smets committed
153 154
          portal_types = getToolByName(object,'portal_types')
          LOG('ERP5Conduit.addNode',0,'portal_type: |%s|' % str(portal_type))
155 156 157 158 159 160 161 162 163 164 165
          if docid==None: # ERP5 content
            portal_types.constructContent(type_name = portal_type,
                                              container = object,
                                              id = object_id)
          else: # CPS content
            # This is specific to CPS, we will call the proxy tool
            px_tool= getToolByName(object,'portal_proxies')
            proxy_type = 'document'
            if portal_type == 'Workspace':
              proxy_type = 'folder'
            proxy = px_tool.createEmptyProxy(proxy_type,
166
                                   object,portal_type,object_id,docid=docid)
167 168 169 170 171 172
            proxy.isIndexable = 0 # So it will not be reindexed, this prevent errors
            # Calculate rpath
            utool = getToolByName(object, 'portal_url')
            rpath = utool.getRelativeUrl(object)
            px_tool._modifyProxy(proxy,rpath)

173
          subobject = object._getOb(object_id)
174
        self.newObject(object=subobject,xml=xml,simulate=simulate)
175
    elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD \
176
         and self.getSubObjectDepth(xml)>=1:
177 178 179 180
      sub_object_id = self.getSubObjectId(xml)
      LOG('addNode',0,'getSubObjectModification number: %s' % sub_object_id)
      if previous_xml is not None and sub_object_id is not None:
        LOG('addNode',0,'previous xml is not none and also sub_object_id')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
181
        # Find the previous xml corresponding to this subobject
182
        sub_previous_xml = self.getSubObjectXml(sub_object_id,previous_xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
183 184 185 186
        LOG('addNode',0,'isSubObjectModification sub_p_xml: %s' % str(sub_previous_xml))
        if sub_previous_xml is not None:
          sub_object = None
          try:
187
            sub_object = object._getOb(sub_object_id)
188
          except (AttributeError, KeyError, TypeError):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
189 190 191 192 193 194 195 196 197
            pass
          if sub_object is not None:
            LOG('addNode',0,'subobject.id: %s' % sub_object.id)
            # Change the xml in order to directly apply
            # modifications to the subobject
            sub_xml = self.getSubObjectXupdate(xml)
            LOG('addNode',0,'sub_xml: %s' % str(sub_xml))
            # Then do the udpate
            conflict_list += self.addNode(xml=sub_xml,object=sub_object,
198 199
                            previous_xml=sub_previous_xml, force=force,
                            simulate=simulate, **kw)
200 201 202
    elif xml.nodeName == self.history_tag or self.isHistoryAdd(xml)>0:
      # We want to add a workflow action
      wf_tool = getToolByName(object,'portal_workflow')
203
      wf_id = self.getAttribute(xml,'id')
204 205 206 207 208
      if wf_id is None: # History added by xupdate
        wf_id = self.getHistoryIdFromSelect(xml)
        xml = self.getElementNodeList(xml)[0]
      LOG('addNode, workflow_history id:',0,wf_id)
      LOG('addNode, workflow_history xml:',0,xml)
Sebastien Robin's avatar
Sebastien Robin committed
209 210 211
      #for action in self.getWorkflowActionFromXml(xml):
      status = self.getStatusFromXml(xml)
      LOG('addNode, status:',0,status)
212
      add_action = self.isWorkflowActionAddable(object=object,
Sebastien Robin's avatar
Sebastien Robin committed
213
                                             status=status,wf_tool=wf_tool,
214 215 216 217
                                             wf_id=wf_id,xml=xml)
      #LOG('addNode, workflow_history wf_conflict_list:',0,wf_conflict_list)
      LOG('addNode, workflow_history add_action:',0,add_action)
      if add_action and not simulate:
Sebastien Robin's avatar
Sebastien Robin committed
218
        LOG('addNode, setting status:',0,'ok')
219
        wf_tool.setStatusOf(wf_id,object,status)
220 221
      #else:
      #  conflict_list += wf_conflict_list
222
    elif xml.nodeName in self.local_role_list and not simulate:
223 224
      # We want to add a local role
      roles = self.convertXmlValue(xml.childNodes[0].data,data_type='tokens')
225
      user = self.getAttribute(xml,'id')
226
      roles = list(roles) # Needed for CPS, or we have a CPS error
227 228 229
      LOG('local_role: ',0,'user: %s roles: %s' % (repr(user),repr(roles)))
      #user = roles[0]
      #roles = roles[1:]
230
      object.manage_setLocalRoles(user,roles)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
231
    else:
232 233
      conflict_list += self.updateNode(xml=xml,object=object, force=force,
                                       simulate=simulate,  **kw)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
234 235
    return conflict_list

Sebastien Robin's avatar
Sebastien Robin committed
236
  security.declareProtected(Permissions.ModifyPortalContent, 'deleteNode')
237 238
  def deleteNode(self, xml=None, object=None, object_id=None, force=None,
                 simulate=0, **kw):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
239 240 241
    """
    A node is deleted
    """
242
    # In the case where we have to delete an object
Jean-Paul Smets's avatar
Jean-Paul Smets committed
243
    LOG('ERP5Conduit',0,'deleteNode')
244
    LOG('ERP5Conduit',0,'deleteNode, object.id: %s' % object.getId())
245
    LOG('ERP5Conduit',0,'deleteNode, object path: %s' % repr(object.getPhysicalPath()))
246
    conflict_list = []
247 248
    if xml is not None:
      xml = self.convertToXml(xml)
249 250 251
    if object_id is None:
      LOG('ERP5Conduit',0,'deleteNode, SubObjectDepth: %i' % self.getSubObjectDepth(xml))
      if xml.nodeName == self.xml_object_tag:
252
        object_id = self.getAttribute(xml,'id')
253 254
      elif self.getSubObjectDepth(xml)==1:
        object_id = self.getSubObjectId(xml)
255
        #LOG('ERP5Conduit',0,'deleteNode, SubObjectDepth: %i' % self.getSubObjectDepth(xml))
256 257 258
      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
259
        try:
260 261 262
          sub_object = object._getOb(sub_object_id)
          sub_xml = self.getSubObjectXupdate(xml)
          conflict_list += self.deleteNode(xml=sub_xml,object=sub_object,
263
                                           force=force, simulate=simulate, **kw)
264
        except (KeyError, AttributeError, TypeError):
265
          LOG('ERP5Conduit',0,'deleteNode, Unable to delete SubObject: %s' % str(sub_object_id))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
266
          pass
267
    if object_id is not None: # We do have an object_id
268 269 270
      try:
        object._delObject(object_id)
      except (AttributeError, KeyError):
271
        LOG('ERP5Conduit',0,'deleteNode, Unable to delete: %s' % str(object_id))
272
        pass
273 274 275 276 277 278 279 280 281
    # 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')
        LOG('local_role: ',0,'user: %s' % repr(user))
        object.manage_delLocalRoles([user])
282
    return conflict_list
Jean-Paul Smets's avatar
Jean-Paul Smets committed
283

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

Jean-Paul Smets's avatar
Jean-Paul Smets committed
389 390 391
        if keyword == 'object':
          # This is the case where we have to call addNode
          LOG('updateNode',0,'we will add sub-object')
392 393 394
          conflict_list += self.addNode(xml=subnode,object=object,force=force,
                                        simulate=simulate, **kw)
        elif keyword == self.history_tag and not simulate:
395
          # This is the case where we have to call addNode
396
          LOG('updateNode',0,'we will add history')
397 398 399
          conflict_list += self.addNode(xml=subnode,object=object,force=force,
                                        simulate=simulate,**kw)
        elif keyword == self.local_role_tag and not simulate:
400
          # This is the case where we have to update Roles
401
          LOG('updateNode',0,'we will add a local role')
402 403 404 405 406 407
          #user = self.getSubObjectId(xml)
          #roles = self.convertXmlValue(data,data_type='tokens')
          #object.manage_setLocalRoles(user,roles)
          xml = self.getElementFromXupdate(xml)
          conflict_list += self.addNode(xml=xml,object=object,force=force,
                                        simulate=simulate,**kw)
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 412 413 414 415
        sub_object_id = self.getSubObjectId(xml)
        LOG('updateNode',0,'getSubObjectModification number: %s' % sub_object_id)
        if previous_xml is not None and sub_object_id is not None:
          LOG('updateNode',0,'previous xml is not none and also sub_object_id')
          sub_previous_xml = self.getSubObjectXml(sub_object_id,previous_xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
416 417 418 419
          LOG('updateNode',0,'isSubObjectModification sub_p_xml: %s' % str(sub_previous_xml))
          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 424 425 426 427 428 429 430
            except KeyError:
              pass
            if sub_object is not None:
              LOG('updateNode',0,'subobject.id: %s' % sub_object.id)
              # Change the xml in order to directly apply
              # modifications to the subobject
              sub_xml = self.getSubObjectXupdate(xml)
              LOG('updateNode',0,'sub_xml: %s' % str(sub_xml))
              # Then do the udpate
              conflict_list += self.updateNode(xml=sub_xml,object=sub_object, force=force,
431
                              previous_xml=sub_previous_xml,simulate=simulate, **kw)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
432 433
    return conflict_list

Sebastien Robin's avatar
Sebastien Robin committed
434
  security.declareProtected(Permissions.AccessContentsInformation,'getFormatedArgs')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
  def getFormatedArgs(self, args=None):
    """
    This lookd inside the args dictionnary and then
    convert any unicode string to string
    """
    LOG('ERP5Conduit.getFormatedArgs',0,'args: %s' % str(args))
    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())
451
            item = item.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
452 453 454 455
          new_data += [item]
        data = new_data
      if type(data) is type(u"a"):
        data = data.encode(self.getEncoding())
456
        data = data.replace('@@@','\n')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
457 458 459 460 461 462 463 464 465
      if keyword == 'binary_data':
        LOG('ERP5Conduit.getFormatedArgs',0,'binary_data keyword: %s' % str(keyword))
        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
466
  security.declareProtected(Permissions.AccessContentsInformation,'isProperty')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
467 468 469 470
  def isProperty(self, xml):
    """
    Check if it is a simple property
    """
471
    bad_list = (self.sub_object_exp,self.history_exp)
472 473
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
474 475
        value = subnode.nodeValue
        for bad_string in bad_list:
476
          if re.search(bad_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
477 478 479
            return 0
    return 1

Sebastien Robin's avatar
Sebastien Robin committed
480
  security.declareProtected(Permissions.AccessContentsInformation,'getSubObjectXupdate')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
481 482 483 484 485
  def getSubObjectXupdate(self, xml):
    """
    This will change the xml in order to change the update
    from the object to the subobject
    """
486 487 488 489
    xml = copy.deepcopy(xml)
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
        subnode.nodeValue = self.getSubObjectSelect(subnode.nodeValue)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
490 491
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
492
  security.declareProtected(Permissions.AccessContentsInformation,'isHistoryAdd')
493 494
  def isHistoryAdd(self, xml):
    bad_list = (self.history_exp)
495 496
    for subnode in self.getAttributeNodeList(xml):
      if subnode.nodeName=='select':
497 498 499
        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
500 501 502 503
            if re.search(self.bad_history_exp,value) is None:
              return 1
            else:
              return -1
504 505
    return 0

Sebastien Robin's avatar
Sebastien Robin committed
506
  security.declareProtected(Permissions.AccessContentsInformation,'isSubObjectModification')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
507 508 509 510
  def isSubObjectModification(self, xml):
    """
    Check if it is a modification from an subobject
    """
511
    good_list = (self.sub_object_exp,)
512 513
    for subnode in self.getAttributeNodeList(xml) :
      if subnode.nodeName=='select':
Jean-Paul Smets's avatar
Jean-Paul Smets committed
514 515 516
        value = subnode.nodeValue
        LOG('isSubObjectModification',0,'value: %s' % value)
        for good_string in good_list:
517
          if re.search(good_string,value) is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
518 519 520
            return 1
    return 0

Sebastien Robin's avatar
Sebastien Robin committed
521
  security.declareProtected(Permissions.AccessContentsInformation,'getSubObjectDepth')
522 523 524 525 526 527 528 529 530
  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
    """
    LOG('getSubObjectDepth',0,'xml.nodeName: %s' % xml.nodeName)
    if xml.nodeName in self.XUPDATE_TAG:
531 532 533
      i = 0
      if xml.nodeName in self.XUPDATE_INSERT:
        i = 1
534 535 536 537 538 539
      LOG('getSubObjectDepth',0,'xml2.nodeName: %s' % xml.nodeName)
      for subnode in self.getAttributeNodeList(xml):
        LOG('getSubObjectDepth',0,'subnode.nodeName: %s' % subnode.nodeName)
        if subnode.nodeName == 'select':
          value = subnode.nodeValue
          LOG('getSubObjectDepth',0,'subnode.nodeValue: %s' % subnode.nodeValue)
540 541 542 543 544 545 546 547 548 549
          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
550 551
    return 0

Sebastien Robin's avatar
Sebastien Robin committed
552
  security.declareProtected(Permissions.AccessContentsInformation,'getSubObjectSelect')
553
  def getSubObjectSelect(self, select):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
554
    """
555 556
    Return a string wich is the selection for the subobject
    ex: for "/object[@id='161']/object[@id='default_address']/street_address"
557
    it returns "/object[@id='default_address']/street_address"
Jean-Paul Smets's avatar
Jean-Paul Smets committed
558
    """
559 560 561 562 563 564
    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 = '/'
565 566 567
      select = new_value
    return select

Sebastien Robin's avatar
Sebastien Robin committed
568
  security.declareProtected(Permissions.AccessContentsInformation,'getSubObjectId')
569 570 571 572 573 574 575
  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
576
        value = subnode.nodeValue
577 578 579 580
        if re.search(self.object_exp,value) is not None:
          s = "'"
          first = value.find(s)+1
          object_id = value[first:value.find(s,first)]
581 582 583
          return object_id
    return object_id

Sebastien Robin's avatar
Sebastien Robin committed
584
  security.declareProtected(Permissions.AccessContentsInformation,'getHistoryIdFromSelect')
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
  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

Sebastien Robin's avatar
Sebastien Robin committed
601
  security.declareProtected(Permissions.AccessContentsInformation,'getSubObjectXml')
602 603 604 605 606 607 608 609
  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:
        LOG('getSub0bjectXml: object_id:',0,object_id)
610
        if object_id == self.getAttribute(subnode,'id'):
611 612
          return subnode
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
613

Sebastien Robin's avatar
Sebastien Robin committed
614
  security.declareProtected(Permissions.AccessContentsInformation,'getAttribute')
615
  def getAttribute(self, xml, param):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
616
    """
617
    Retrieve the given parameter from the xml
Jean-Paul Smets's avatar
Jean-Paul Smets committed
618
    """
619
    for attribute in self.getAttributeNodeList(xml):
620
      if attribute.nodeName == param:
621
        data = attribute.childNodes[0].data
622
        return self.convertXmlValue(data,data_type='string')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
623 624
    return None

Sebastien Robin's avatar
Sebastien Robin committed
625
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectDocid')
626 627 628 629 630 631 632 633 634
  def getObjectDocid(self, xml):
    """
    Retrieve the docid
    """
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == 'docid':
        data = subnode.childNodes[0].data
        return self.convertXmlValue(data)
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
635

Sebastien Robin's avatar
Sebastien Robin committed
636
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectProperty')
637
  def getObjectProperty(self, property, xml, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
638 639 640
    """
    Retrieve the given property
    """
641
    xml = self.convertToXml(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
642 643 644
    # document, with childNodes[0] a DocumentType and childNodes[1] the Element Node
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == property:
645 646
        if data_type is None:
          data_type = self.getPropertyType(subnode)
647 648 649 650
        try:
          data = subnode.childNodes[0].data
        except IndexError: # There is no data
          data = None
651
        data =  self.convertXmlValue(data, data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
652 653 654
        return data
    return None

Sebastien Robin's avatar
Sebastien Robin committed
655
  security.declareProtected(Permissions.AccessContentsInformation,'convertToXml')
656
  def convertToXml(self,xml):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
657 658 659 660 661 662
    """
    if xml is a string, convert it to a node
    """
    if type(xml) in (type('a'),type(u'a')):
      xml = FromXml(xml)
      xml = xml.childNodes[1] # Because we just created a new xml
663 664 665
    # 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
666 667
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
668
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
669 670 671 672 673
  def getObjectType(self, xml):
    """
    Retrieve the portal type from an xml
    """
    portal_type = None
674 675 676 677 678
    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
679 680
    return portal_type

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

Jean-Paul Smets's avatar
Jean-Paul Smets committed
757 758

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

Sebastien Robin's avatar
Sebastien Robin committed
763
  security.declareProtected(Permissions.AccessContentsInformation,'getStatusFromXml')
764 765 766 767 768 769 770 771 772 773 774
  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
775
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateElementList')
776 777 778 779 780 781 782 783
  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]
784
    LOG('getXupdateElementList, e_list:',0,e_list)
785 786
    return e_list

Sebastien Robin's avatar
Sebastien Robin committed
787
  security.declareProtected(Permissions.AccessContentsInformation,'getElementFromXupdate')
788 789 790 791 792
  def getElementFromXupdate(self, xml):
    """
    from a xupdate:element returns the element as xml
    """
    if xml.nodeName in self.XUPDATE_EL:
793
      result = u'<'
794 795 796 797 798 799
      result += xml.attributes[0].nodeValue
      for subnode in self.getElementNodeList(xml):  #getElementNodeList
        if subnode.nodeName == 'xupdate:attribute':
          result += ' ' + subnode.attributes[0].nodeValue + '='
          result += '"' + subnode.childNodes[0].nodeValue + '"'
      result += '>'
800 801 802 803
      # Then dumps the xml and remove what we does'nt want
      xml_string = StringIO()
      PrettyPrint(xml,xml_string)
      xml_string = xml_string.getvalue()
804
      xml_string = unicode(xml_string,encoding='utf-8')
805 806 807
      maxi = max(xml_string.find('>')+1,\
                 xml_string.rfind('</xupdate:attribute>')+len('</xupdate:attribute>'))
      result += xml_string[maxi:xml_string.find('</xupdate:element>')]
808
      result += '</' + xml.attributes[0].nodeValue + '>'
809
      return self.convertToXml(result)
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
    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 +=  '>'
      # Then dumps the xml and remove what we does'nt want
      xml_string = StringIO()
      PrettyPrint(xml,xml_string)
      xml_string = xml_string.getvalue()
      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 + '>'
      LOG('getElementFromXupdate, result:',0,repr(result))
      return self.convertToXml(result)
840 841
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
842
  security.declareProtected(Permissions.AccessContentsInformation,'getWorkflowActionFromXml')
843 844 845 846 847 848 849 850 851 852 853 854 855
  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
856
  security.declareProtected(Permissions.AccessContentsInformation,'convertXmlValue')
857
  def convertXmlValue(self, data, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
858 859
    """
    It is possible that the xml change the value, for example
860 861 862 863 864 865
    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 = ()
866 867
      if data_type in self.text_type_list:
        data = ''
868
      return data
Jean-Paul Smets's avatar
Jean-Paul Smets committed
869 870 871
    data = data.replace('\n','')
    if type(data) is type(u"a"):
      data = data.encode(self.getEncoding())
872 873
    if data=='None':
      return None
874 875 876 877 878 879
    # 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')
880 881 882 883 884 885
#     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)
886
      data = unescape(data)
887
    elif data_type in self.pickle_type_list:
888 889 890 891 892
      data = data.replace('@@@','\n')
      msg = MIMEBase('application','octet-stream')
      Encoders.encode_base64(msg)
      msg.set_payload(data)
      data = msg.get_payload(decode=1)
893
      data = pickle.loads(data)
894 895 896 897 898 899 900
    elif data_type in self.date_type_list:
      data = DateTime(data)
    elif data_type in self.dict_type_list:
      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)
    LOG('convertXmlValue',0,'data: %s' % str(data))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
901 902
    return data

903 904
  # 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
905
  security.declareProtected(Permissions.ModifyPortalContent, 'applyXupdate')
906 907
  def applyXupdate(self, object=None, xupdate=None, conduit=None, force=0,
                   simulate=0, **kw):
908 909 910 911 912 913 914 915 916 917 918 919
    """
    Parse the xupdate and then it will call the conduit
    """
    conflict_list = []
    if type(xupdate) in (type('a'),type(u'a')):
      xupdate = FromXml(xupdate)

    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, \
920
                                         force=force, simulate=simulate, **kw)
921 922
      elif subnode.nodeName in self.XUPDATE_DEL:
        conflict_list += conduit.deleteNode(xml=sub_xupdate, object=object, \
923
                                         force=force, simulate=simulate, **kw)
924 925
      elif subnode.nodeName in self.XUPDATE_UPDATE:
        conflict_list += conduit.updateNode(xml=sub_xupdate, object=object, \
926
                                         force=force, simulate=simulate, **kw)
927 928 929 930 931
      #elif subnode.nodeName in self.XUPDATE_INSERT:
      #  conflict_list += conduit.addNode(xml=subnode, object=object, force=force, **kw)

    return conflict_list

932 933
  def isWorkflowActionAddable(self, object=None,status=None,wf_tool=None,
                              wf_id=None,xml=None):
Sebastien Robin's avatar
Sebastien Robin committed
934 935
    """
    Some checking in order to check if we should add the workfow or not
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
    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
    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

    # 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]
#    return conflict_list