ERP5Conduit.py 47.4 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 143
      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,
144
                          previous_xml=previous_xml, force=force,
145
                          simulate=simulate, **kw)['conflict_list']
146
    elif xml.nodeName == 'object':
147 148
      if object_id is None:
        object_id = self.getAttribute(xml,'id')
149
      docid = self.getObjectDocid(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
150
      if object_id is not None:
151 152 153 154 155 156 157 158 159
        if sub_object is None:
          try:
            sub_object = object._getOb(object_id)
          except (AttributeError, KeyError, TypeError):
            sub_object = None
        else:
          #We prevent reset_workflow an reset_local_roles
          reset_local_roles = 0
          reset_workflow = 0
160
        if sub_object is None: # If so, it doesn't exist
Jean-Paul Smets's avatar
Jean-Paul Smets committed
161 162 163
          portal_type = ''
          if xml.nodeName == 'object':
            portal_type = self.getObjectType(xml)
164 165
          elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD: # Deprecated ???
            portal_type = self.getXupdateObjectType(xml) # Deprecated ???
166 167
          sub_object = self.constructContent(object, object_id, docid, 
              portal_type)
168 169 170 171 172 173
        self.newObject(
                  object=sub_object,
                  xml=xml,
                  simulate=simulate,
                  reset_local_roles=reset_local_roles,
                  reset_workflow=reset_workflow)
174
    elif xml.nodeName in self.XUPDATE_INSERT_OR_ADD \
175
         and self.getSubObjectDepth(xml)>=1:
176 177
      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
178
        # Find the previous xml corresponding to this subobject
179 180
        sub_previous_xml = self.getSubObjectXml(sub_object_id, previous_xml)
        LOG('addNode', DEBUG,'isSubObjectModification sub_previous_xml: %s' % str(sub_previous_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
181 182 183
        if sub_previous_xml is not None:
          sub_object = None
          try:
184
            sub_object = object._getOb(sub_object_id)
185
          except (AttributeError, KeyError, TypeError):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
186 187
            pass
          if sub_object is not None:
188
            LOG('addNode', DEBUG, 'subobject.id: %s' % sub_object.id)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
189 190 191
            # Change the xml in order to directly apply
            # modifications to the subobject
            sub_xml = self.getSubObjectXupdate(xml)
192
            LOG('addNode', DEBUG, 'sub_xml: %s' % str(sub_xml))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
193 194
            # Then do the udpate
            conflict_list += self.addNode(xml=sub_xml,object=sub_object,
195
                            previous_xml=sub_previous_xml, force=force,
196
                            simulate=simulate, **kw)['conflict_list']
197
    elif xml.nodeName == self.history_tag or self.isHistoryAdd(xml)>0:
198
      conflict_list += self.addWorkflowNode(object, xml, simulate)
Sebastien Robin's avatar
Sebastien Robin committed
199 200
    #elif xml.nodeName in self.local_role_list or self.isLocalRole(xml)>0 and not simulate:
    elif xml.nodeName in self.local_role_list:
201
      conflict_list += self.addLocalRoleNode(object, xml)
202
    elif xml.nodeName in self.local_permission_list:
203
      conflict_list += self.addLocalPermissionNode(object, xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
204
    else:
205 206
      conflict_list += self.updateNode(xml=xml,object=object, force=force,
                                       simulate=simulate,  **kw)
207 208
    # We must returns the object created
    return {'conflict_list':conflict_list, 'object': sub_object}
Jean-Paul Smets's avatar
Jean-Paul Smets committed
209

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sebastien Robin's avatar
Sebastien Robin committed
646
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectDocid')
647 648 649 650 651 652
  def getObjectDocid(self, xml):
    """
    Retrieve the docid
    """
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == 'docid':
653
        data = subnode.childNodes[0].value
654 655
        return self.convertXmlValue(data)
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
656

Sebastien Robin's avatar
Sebastien Robin committed
657
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectProperty')
658
  def getObjectProperty(self, property, xml, data_type=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
659 660 661
    """
    Retrieve the given property
    """
662
    xml = self.convertToXml(xml)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
663 664 665
    # document, with childNodes[0] a DocumentType and childNodes[1] the Element Node
    for subnode in self.getElementNodeList(xml):
      if subnode.nodeName == property:
666 667
        if data_type is None:
          data_type = self.getPropertyType(subnode)
668 669 670 671
        try:
          data = subnode.childNodes[0].data
        except IndexError: # There is no data
          data = None
672
        data =  self.convertXmlValue(data, data_type=data_type)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
673 674 675
        return data
    return None

Sebastien Robin's avatar
Sebastien Robin committed
676
  security.declareProtected(Permissions.AccessContentsInformation,'convertToXml')
677
  def convertToXml(self,xml):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
678 679 680
    """
    if xml is a string, convert it to a node
    """
681 682
    if xml is None:
      return
Jean-Paul Smets's avatar
Jean-Paul Smets committed
683
    if type(xml) in (type('a'),type(u'a')):
684
      if type(xml) is type(u'a'):
Sebastien Robin's avatar
Sebastien Robin committed
685
        xml = xml.encode('utf-8')
686
      xml = Parse(xml)
Nicolas Delaby's avatar
Nicolas Delaby committed
687
      #LOG('Conduit.convertToXml not failed',0,'ok')
Sebastien Robin's avatar
Sebastien Robin committed
688
      xml = xml.childNodes[0] # Because we just created a new xml
689 690 691
    # 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
692 693
    return xml

Sebastien Robin's avatar
Sebastien Robin committed
694
  security.declareProtected(Permissions.AccessContentsInformation,'getObjectType')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
695 696 697 698 699
  def getObjectType(self, xml):
    """
    Retrieve the portal type from an xml
    """
    portal_type = None
700 701 702 703 704
    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
705 706
    return portal_type

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

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

785 786 787 788
  security.declareProtected(Permissions.AccessContentsInformation,'afterNewObject')
  def afterNewObject(self, object):
    pass

Sebastien Robin's avatar
Sebastien Robin committed
789
  security.declareProtected(Permissions.AccessContentsInformation,'getStatusFromXml')
790 791 792 793 794 795 796 797 798 799 800
  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
801
  security.declareProtected(Permissions.AccessContentsInformation,'getXupdateElementList')
802 803 804 805 806 807 808 809
  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
810
    #LOG('getXupdateElementList, e_list:',0,e_list)
811 812
    return e_list

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

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

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

    return conflict_list

976 977 978 979 980 981
  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:
982
      value = self.getAttribute(subnode, 'select')
983 984 985 986 987 988
      if re.search(self.object_exp, value):
        comp += 1
    if nb_sub == comp:
      return 0
    return 1

989 990
  def isWorkflowActionAddable(self, object=None,status=None,wf_tool=None,
                              wf_id=None,xml=None):
Sebastien Robin's avatar
Sebastien Robin committed
991 992
    """
    Some checking in order to check if we should add the workfow or not
993 994 995 996
    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
997 998
    return 1
    # XXX Disable for now
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
    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

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

1044 1045 1046 1047 1048
  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.
1049
    """
1050 1051 1052 1053 1054 1055 1056 1057 1058
    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
1059
    #LOG('addNode, status:',0,status)
1060 1061 1062 1063 1064
    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)
1065 1066

    # Specific CPS, try to remove duplicate lines in portal_repository._histories
Sebastien Robin's avatar
Sebastien Robin committed
1067
    tool = getToolByName(self,'portal_repository',None)
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
    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)

1078
    return conflict_list
1079

1080 1081 1082 1083 1084
  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.
1085 1086
    """
    conflict_list = []
1087 1088 1089 1090
    # 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
1091
    #LOG('local_role: ',0,'user: %s roles: %s' % (repr(user),repr(roles)))
1092 1093 1094 1095 1096 1097 1098
    #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
1099

1100 1101 1102 1103 1104
  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.
1105 1106
    """
    conflict_list = []
1107
    # We want to add a local role
1108
    #LOG('addLocalPermissionNode, xml',0,xml)
1109 1110
    if len(xml.childNodes)>0:
      roles = self.convertXmlValue(xml.childNodes[0].data,data_type='tokens')
1111
      roles = list(roles) # Needed for CPS, or we have a CPS error
1112
    else:
1113
      roles = ()
1114
    permission = self.getAttribute(xml,'id')
1115
    #LOG('local_role: ',0,'permission: %s roles: %s' % (repr(permission),repr(roles)))
1116 1117 1118
    #user = roles[0]
    #roles = roles[1:]
    if xml.nodeName.find(self.local_permission_tag)>=0:
1119
      object.manage_setLocalPermissions(permission,roles)
1120 1121
    return conflict_list

1122
  security.declareProtected(Permissions.ModifyPortalContent, 'editDocument')
1123 1124 1125 1126 1127
  def editDocument(self, object=None, **kw):
    """
    This is the default editDocument method. This method
    can easily be overwritten.
    """
1128
    object._edit(**kw)
1129

1130 1131 1132 1133 1134 1135 1136 1137
  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)

1138

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
    # 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]
1158
#    return conflict_list
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168

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