SelectionTool.py 65.5 KB
Newer Older
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1 2
##############################################################################
#
3
# Copyright (c) 2002,2007 Nexedi SARL and Contributors. All Rights Reserved.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
4
#                    Jean-Paul Smets-Solanes <jp@nexedi.com>
Jean-Paul Smets's avatar
Jean-Paul Smets committed
5 6
#
# WARNING: This program as such is intended to be used by professional
7
# programmers who take the whole responsibility of assessing all potential
Jean-Paul Smets's avatar
Jean-Paul Smets committed
8 9
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
10
# guarantees and support are strongly adviced to contract a Free Software
Jean-Paul Smets's avatar
Jean-Paul Smets committed
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
# 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 30
"""
  ERP5 portal_selection tool.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
31 32 33 34 35 36
"""

from OFS.SimpleItem import SimpleItem
from Products.CMFCore.utils import UniqueObject
from Globals import InitializeClass, DTMLFile, PersistentMapping, get_request
from AccessControl import ClassSecurityInfo
37
from Products.ERP5Type.Tool.BaseTool import BaseTool
Jean-Paul Smets's avatar
Jean-Paul Smets committed
38 39
from Products.ERP5Type import Permissions as ERP5Permissions
from Products.ERP5Form import _dtmldir
40
from Selection import Selection, DomainSelection
41
from ZPublisher.HTTPRequest import FileUpload
Sebastien Robin's avatar
Sebastien Robin committed
42
import md5
43
import string
44 45
from zLOG import LOG, INFO
from Acquisition import aq_base
46
from Products.ERP5Type.Message import translateString
47
import warnings
48

49

50 51
_MARKER = []

Jean-Paul Smets's avatar
Jean-Paul Smets committed
52 53 54
class SelectionError( Exception ):
    pass

55
class SelectionTool( BaseTool, UniqueObject, SimpleItem ):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
56 57 58 59 60 61 62 63
    """
      The SelectionTool object is the place holder for all
      methods and algorithms related to persistent selections
      in ERP5.
    """

    id              = 'portal_selections'
    meta_type       = 'ERP5 Selections'
64
    portal_type     = 'Selection Tool'
Jean-Paul Smets's avatar
Jean-Paul Smets committed
65 66 67 68 69 70 71
    security = ClassSecurityInfo()

    #
    #   ZMI methods
    #
    manage_options = ( ( { 'label'      : 'Overview'
                         , 'action'     : 'manage_overview'
72 73
                         },
                         { 'label'      : 'View Selections'
74
                         , 'action'     : 'manage_viewSelections'
75 76 77
                         },
                         { 'label'      : 'Configure'
                         , 'action'     : 'manage_configure'
78
                         } ))
Jean-Paul Smets's avatar
Jean-Paul Smets committed
79 80 81

    security.declareProtected( ERP5Permissions.ManagePortal
                             , 'manage_overview' )
82
    manage_overview = DTMLFile( 'explainSelectionTool', _dtmldir )
Jean-Paul Smets's avatar
Jean-Paul Smets committed
83

84
    security.declareProtected( ERP5Permissions.ManagePortal
85 86
                             , 'manage_viewSelections' )
    manage_viewSelections = DTMLFile( 'SelectionTool_manageViewSelections', _dtmldir )
87

88 89 90 91
    security.declareProtected( ERP5Permissions.ManagePortal
                             , 'manage_configure' )
    manage_configure = DTMLFile( 'SelectionTool_configure', _dtmldir )

92 93 94 95 96 97 98 99 100 101 102
    security.declareProtected( ERP5Permissions.ManagePortal
                             , 'manage_deleteSelection' )
    def manage_deleteSelection(self, selection_name, REQUEST=None):
      """
        Relete a specified selection
      """
      self._deleteSelectionFromContainer(selection_name)
      if REQUEST is not None:
        return REQUEST.RESPONSE.redirect('%s/%s' %
                (self.absolute_url(), 'manage_viewSelections'))

103 104 105 106 107 108 109 110 111 112 113
    security.declareProtected( ERP5Permissions.ManagePortal
                             , 'manage_deleteGlobalSelection' )
    def manage_deleteGlobalSelection(self, selection_name, REQUEST=None):
      """
        Relete a specified selection
      """
      self._deleteGlobalSelectionFromContainer(selection_name)
      if REQUEST is not None:
        return REQUEST.RESPONSE.redirect('%s/%s' %
                (self.absolute_url(), 'manage_viewSelections'))

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
    # storages of SelectionTool
    storage_list = ('Persistent Mapping', 'Memcached Tool')

    security.declareProtected( ERP5Permissions.ManagePortal, 'setStorage')
    def setStorage(self, value, RESPONSE=None):
      """
        Set the storage of Selection Tool.
      """
      if value in self.storage_list:
        self.storage = value
      else:
        raise ValueError, 'Given storage type (%s) is now supported.' % (value,)
      if RESPONSE is not None:
        RESPONSE.redirect('%s/manage_configure' % (self.absolute_url()))

    def getStorage(self, default=None):
      if default is None:
        default = self.storage_list[0]
132
      storage = getattr(aq_base(self), 'storage', default)
133
      if storage is not default and storage not in self.storage_list:
Jérome Perrin's avatar
Jérome Perrin committed
134
        storage = self.storage_list[0]
135 136 137 138
      return storage

    def isMemcachedUsed(self):
      return self.getStorage() == 'Memcached Tool'
139

Vincent Pelletier's avatar
Vincent Pelletier committed
140 141
    def _redirectToOriginalForm(self, REQUEST=None, form_id=None, dialog_id=None,
                                query_string=None,
142
                                no_reset=False, no_report_depth=False):
Vincent Pelletier's avatar
Vincent Pelletier committed
143 144
      """Redirect to the original form or dialog, using the information given
         as parameters.
145 146
         (Actually does not redirect  in the HTTP meaning because of URL
         limitation problems.)
Vincent Pelletier's avatar
Vincent Pelletier committed
147 148 149

         DEPRECATED parameters :
         query_string is used to transmit parameters from caller to callee.
150
         If no_reset is True, replace reset parameters with noreset.
Vincent Pelletier's avatar
Vincent Pelletier committed
151 152
         If no_report_depth is True, replace report_depth parameters with
         noreport_depth.
153 154 155 156
      """
      if REQUEST is None:
        return

Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
157 158 159 160 161 162 163
      form = REQUEST.form
      if no_reset and form.has_key('reset'):
        form['noreset'] = form['reset'] # Kept for compatibility - might no be used anymore
        del form['reset']
      if no_report_depth and form.has_key('report_depth'):
        form['noreport_depth'] = form['report_depth'] # Kept for compatibility - might no be used anymore
        del form['report_depth']
Vincent Pelletier's avatar
Vincent Pelletier committed
164

165
      if query_string is not None:
166 167
        warnings.warn('DEPRECATED: _redirectToOriginalForm got called with a query_string. The variables must be passed in REQUEST.form.',
                      DeprecationWarning)
168
      context = REQUEST['PARENTS'][0]
Vincent Pelletier's avatar
Vincent Pelletier committed
169
      form_id = dialog_id or REQUEST.get('dialog_id', None) or form_id or REQUEST.get('form_id', 'view')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
170
      return getattr(context, form_id)()
171

172 173
    security.declareProtected(ERP5Permissions.View, 'getSelectionNameList')
    def getSelectionNameList(self, context=None, REQUEST=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
174 175 176
      """
        Returns the selection names of the current user.
      """
177 178
      if self.isMemcachedUsed():
        return []
179
      return sorted(self._getSelectionNameListFromContainer())
180

181 182 183 184 185 186 187 188
    # backward compatibility
    security.declareProtected(ERP5Permissions.View, 'getSelectionNames')
    def getSelectionNames(self, context=None, REQUEST=None):
      warnings.warn("getSelectionNames() is deprecated.\n"
                    "Please use getSelectionNameList() instead.",
                    DeprecationWarning)
      return self.getSelectionNameList(context, REQUEST)

189 190 191 192 193 194 195 196
    security.declareProtected(ERP5Permissions.View, 'callSelectionFor')
    def callSelectionFor(self, selection_name, context=None, REQUEST=None):
      if context is None: context = self
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is None:
        return None
      return selection(context=context)

Jean-Paul Smets's avatar
Jean-Paul Smets committed
197 198 199 200 201
    security.declareProtected(ERP5Permissions.View, 'getSelectionFor')
    def getSelectionFor(self, selection_name, REQUEST=None):
      """
        Returns the selection instance for a given selection_name
      """
202 203 204 205 206
      if isinstance(selection_name, (tuple, list)):
        selection_name = selection_name[0]
      selection = self._getSelectionFromContainer(selection_name)
      if selection is not None:
        return selection.__of__(self)
207

208 209 210
    def __getitem__(self, key):
        return self.getSelectionParamsFor(key)

Jean-Paul Smets's avatar
Jean-Paul Smets committed
211 212 213 214 215
    security.declareProtected(ERP5Permissions.View, 'setSelectionFor')
    def setSelectionFor(self, selection_name, selection_object, REQUEST=None):
      """
        Sets the selection instance for a given selection_name
      """
216 217
      if selection_object != None:
        # Set the name so that this selection itself can get its own name.
218
        selection_object.edit(name=selection_name)
219

220 221
      if self.getSelectionFor(selection_name) != selection_object:
        self._setSelectionToContainer(selection_name, selection_object)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
222

223 224
    security.declareProtected(ERP5Permissions.View, 'getSelectionParamsFor')
    def getSelectionParamsFor(self, selection_name, params=None, REQUEST=None):
225 226 227
      """
        Returns the params in the selection
      """
228
      if params is None: params = {}
229 230
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
231 232
        if len(selection.params) > 0:
          return selection.getParams()
233 234 235 236
        else:
          return params
      else:
        return params
237 238

    # backward compatibility
239 240
    security.declareProtected(ERP5Permissions.View, 'getSelectionParams')
    getSelectionParams = getSelectionParamsFor
241

Jean-Paul Smets's avatar
Jean-Paul Smets committed
242 243 244 245 246 247
    security.declareProtected(ERP5Permissions.View, 'setSelectionParamsFor')
    def setSelectionParamsFor(self, selection_name, params, REQUEST=None):
      """
        Sets the selection params for a given selection_name
      """
      selection_object = self.getSelectionFor(selection_name, REQUEST)
248
      if selection_object is not None:
Jean-Paul Smets's avatar
Jean-Paul Smets committed
249 250 251 252 253
        selection_object.edit(params=params)
      else:
        selection_object = Selection(params=params)
      self.setSelectionFor(selection_name, selection_object, REQUEST)

254
    security.declareProtected(ERP5Permissions.View, 'getSelectionDomainDictFor')
255 256 257 258 259 260 261 262 263 264 265
    def getSelectionDomainDictFor(self, selection_name, REQUEST=None):
      """
        Returns the Domain dict for a given selection_name
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        try:
          return selection.getDomain().asDomainDict
        except AttributeError:
          return {}

266
    security.declareProtected(ERP5Permissions.View, 'getSelectionReportDictFor')
267 268 269 270 271 272 273 274 275 276 277
    def getSelectionReportDictFor(self, selection_name, REQUEST=None):
      """
        Returns the Report dict for a given selection_name
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        try:
          return selection.getReport().asDomainDict
        except AttributeError:
          return {}

Jean-Paul Smets's avatar
Jean-Paul Smets committed
278 279 280
    security.declareProtected(ERP5Permissions.View, 'setSelectionCheckedUidsFor')
    def setSelectionCheckedUidsFor(self, selection_name, checked_uids, REQUEST=None):
      """
281
        Sets the checked uids for a given selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
282 283 284 285 286 287 288 289
      """
      selection_object = self.getSelectionFor(selection_name, REQUEST)
      if selection_object:
        selection_object.edit(checked_uids=checked_uids)
      else:
        selection_object = Selection(checked_uids=checked_uids)
      self.setSelectionFor(selection_name, selection_object, REQUEST)

290
    security.declareProtected(ERP5Permissions.View, 'updateSelectionCheckedUidList')
291 292
    def updateSelectionCheckedUidList(self, selection_name, listbox_uid, uids, REQUEST=None):
      """
293 294
        Updates the unchecked uids(listbox_uids) and checked uids (uids)
        for a given selection_name
295 296 297 298 299 300 301 302
      """
      if listbox_uid is None:
        listbox_uid = []
      if uids is None:
        uids = []
      self.uncheckAll(selection_name,listbox_uid,REQUEST=REQUEST)
      self.checkAll(selection_name,uids,REQUEST=REQUEST)

303 304 305
    security.declareProtected(ERP5Permissions.View, 'getSelectionCheckedUidsFor')
    def getSelectionCheckedUidsFor(self, selection_name, REQUEST=None):
      """
306
        Returns the checked uids for a given selection_name
307 308 309
      """
      selection_object = self.getSelectionFor(selection_name, REQUEST)
      if selection_object:
310
        return selection_object.getCheckedUids()
311 312 313
      return []

    security.declareProtected(ERP5Permissions.View, 'checkAll')
314
    def checkAll(self, list_selection_name, listbox_uid=[], REQUEST=None,
315
                 query_string=None, form_id=None):
316
      """
317
        Check uids in a given listbox_uid list for a given list_selection_name
318
      """
319
      selection_object = self.getSelectionFor(list_selection_name, REQUEST)
320 321
      if selection_object:
        selection_uid_dict = {}
322
        for uid in selection_object.checked_uids:
323 324
          selection_uid_dict[uid] = 1
        for uid in listbox_uid:
325 326
          try:
            selection_uid_dict[int(uid)] = 1
327
          except ValueError:
328
            selection_uid_dict[uid] = 1
329
        self.setSelectionCheckedUidsFor(list_selection_name, selection_uid_dict.keys(), REQUEST=REQUEST)
330 331 332
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string, no_reset=True)
333 334

    security.declareProtected(ERP5Permissions.View, 'uncheckAll')
335
    def uncheckAll(self, list_selection_name, listbox_uid=[], REQUEST=None,
336
                   query_string=None, form_id=None):
337
      """
338
        Uncheck uids in a given listbox_uid list for a given list_selection_name
339
      """
340
      selection_object = self.getSelectionFor(list_selection_name, REQUEST)
341 342
      if selection_object:
        selection_uid_dict = {}
343
        for uid in selection_object.checked_uids:
344 345
          selection_uid_dict[uid] = 1
        for uid in listbox_uid:
346 347 348
          try:
            if selection_uid_dict.has_key(int(uid)): del selection_uid_dict[int(uid)]
          except ValueError:
349
            if selection_uid_dict.has_key(uid): del selection_uid_dict[uid]
350
        self.setSelectionCheckedUidsFor(list_selection_name, selection_uid_dict.keys(), REQUEST=REQUEST)
351 352 353
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string, no_reset=True)
354

Jean-Paul Smets's avatar
Jean-Paul Smets committed
355 356 357 358 359 360 361
    security.declareProtected(ERP5Permissions.View, 'getSelectionListUrlFor')
    def getSelectionListUrlFor(self, selection_name, REQUEST=None):
      """
        Returns the URL of the list mode of selection instance
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection:
362
        return selection.getListUrl()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
363 364
      else:
        return None
365

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
    security.declareProtected(ERP5Permissions.View, 'getSelectionInvertModeFor')
    def getSelectionInvertModeFor(self, selection_name, REQUEST=None):
      """Get the 'invert_mode' parameter of a selection.
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        return selection.isInvertMode()
      return 0

    security.declareProtected(ERP5Permissions.View, 'setSelectionInvertModeFor')
    def setSelectionInvertModeFor(self, selection_name,
                                  invert_mode, REQUEST=None):
      """Change the 'invert_mode' parameter of a selection.
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        selection.edit(invert_mode=invert_mode)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
383

384
    security.declareProtected(ERP5Permissions.View, 'getSelectionInvertModeUidListFor')
385 386 387 388 389 390 391 392
    def getSelectionInvertModeUidListFor(self, selection_name, REQUEST=None):
      """Get the 'invert_mode' parameter of a selection.
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        return selection.getInvertModeUidList()
      return 0

393 394 395 396 397 398 399 400 401
    security.declareProtected(ERP5Permissions.View, 'getSelectionIndexFor')
    def getSelectionIndexFor(self, selection_name, REQUEST=None):
      """Get the 'index' parameter of a selection.
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        return selection.getIndex()
      return None

Jean-Paul Smets's avatar
Jean-Paul Smets committed
402 403 404 405 406 407 408
    security.declareProtected(ERP5Permissions.View, 'setSelectionToIds')
    def setSelectionToIds(self, selection_name, selection_uids, REQUEST=None):
      """
        Sets the selection to a small list of uids of documents
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
409
        selection.edit(invert_mode=1, uids=selection_uids, checked_uids=selection_uids)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
410 411

    security.declareProtected(ERP5Permissions.View, 'setSelectionToAll')
412 413
    def setSelectionToAll(self, selection_name, REQUEST=None,
                          reset_domain_tree=False, reset_report_tree=False):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
414 415 416 417 418
      """
        Resets the selection
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
419
        selection.edit(invert_mode=0, params={}, checked_uids=[], report_opened=1)
420
        if reset_domain_tree:
421
          selection.edit(domain=None, domain_path=None, domain_list=None)
422
        if reset_report_tree:
423
          selection.edit(report=None, report_path=None, report_list=None)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
424 425 426 427 428 429 430 431 432 433 434

    security.declareProtected(ERP5Permissions.View, 'setSelectionSortOrder')
    def setSelectionSortOrder(self, selection_name, sort_on, REQUEST=None):
      """
        Defines the sort order of the selection
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        selection.edit(sort_on=sort_on)

    security.declareProtected(ERP5Permissions.View, 'setSelectionQuickSortOrder')
435
    def setSelectionQuickSortOrder(self, selection_name=None, sort_on=None, REQUEST=None,
436
                                   query_string=None, form_id=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
437 438 439 440
      """
        Defines the sort order of the selection directly from the listbox
        In this method, sort_on is just a string that comes from url
      """
441 442
      # selection_name, sort_on and form_id params are kept only for bacward compatibilty
      # as some test call setSelectionQuickSortOrder in url with these params
Aurel's avatar
Aurel committed
443
      listbox_id = None
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
444
      form = REQUEST.form
445
      if sort_on is None:
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
446
        listbox_id, sort_on = form["setSelectionQuickSortOrder"].split(".", 1)
447 448

      if form_id is None:
Aurel's avatar
Aurel committed
449
        if REQUEST is not None:
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
450 451
          if form.has_key('dialog_id'):
            form_id = form['dialog_id']
Aurel's avatar
Aurel committed
452
          else:
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
453
            form_id = form['form_id']
Aurel's avatar
Aurel committed
454 455 456

      if listbox_id is not None:
          selection_name_key = "%s_list_selection_name" %listbox_id
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
457
          selection_name = form[selection_name_key]
Aurel's avatar
Aurel committed
458
      elif selection_name is None:
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
459
          selection_name = form['selection_name']
Aurel's avatar
Aurel committed
460
          
Jean-Paul Smets's avatar
Jean-Paul Smets committed
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        current_sort_on = self.getSelectionSortOrder(selection_name)
        # We must first switch from asc to desc and vice-versa if sort_order exists
        # in selection
        n = 0
        for current in current_sort_on:
          if current[0] == sort_on:
            n = 1
            if current[1] == 'ascending':
              new_sort_on = [(sort_on, 'descending')]
              break
            else:
              new_sort_on = [(sort_on,'ascending')]
              break
        # And if no one exists, we just set ascending sort
        if n == 0:
          new_sort_on = [(sort_on,'ascending')]
        selection.edit(sort_on=new_sort_on)

481
      if REQUEST is not None:
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
482 483
        if form.has_key('listbox_uid') and \
            form.has_key('uids'):
484 485 486
          self.uncheckAll(selection_name, REQUEST.get('listbox_uid'))
          self.checkAll(selection_name, REQUEST.get('uids'))

487 488
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string, no_reset=True)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
489 490 491 492 493 494 495 496

    security.declareProtected(ERP5Permissions.View, 'getSelectionSortOrder')
    def getSelectionSortOrder(self, selection_name, REQUEST=None):
      """
        Returns the sort order of the selection
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is None: return ()
497
      return selection.sort_on
Jean-Paul Smets's avatar
Jean-Paul Smets committed
498 499 500 501 502 503 504 505 506 507

    security.declareProtected(ERP5Permissions.View, 'setSelectionColumns')
    def setSelectionColumns(self, selection_name, columns, REQUEST=None):
      """
        Defines the columns in the selection
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      selection.edit(columns=columns)

    security.declareProtected(ERP5Permissions.View, 'getSelectionColumns')
508
    def getSelectionColumns(self, selection_name, columns=None, REQUEST=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
509
      """
510 511
        Returns the columns in the selection if not empty, otherwise
        returns the value of columns argument
Jean-Paul Smets's avatar
Jean-Paul Smets committed
512
      """
513
      if columns is None: columns = []
Jean-Paul Smets's avatar
Jean-Paul Smets committed
514 515
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
516 517
        if len(selection.columns) > 0:
          return selection.columns
518
      return columns
Jean-Paul Smets's avatar
Jean-Paul Smets committed
519 520 521 522 523 524 525 526 527 528 529


    security.declareProtected(ERP5Permissions.View, 'setSelectionStats')
    def setSelectionStats(self, selection_name, stats, REQUEST=None):
      """
        Defines the stats in the selection
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      selection.edit(stats=stats)

    security.declareProtected(ERP5Permissions.View, 'getSelectionStats')
530
    def getSelectionStats(self, selection_name, stats=_MARKER, REQUEST=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
531 532 533
      """
        Returns the stats in the selection
      """
534 535 536 537
      if stats is not _MARKER:
        default_stats = stats
      else:
        default_stats = [' '] * 6
Jean-Paul Smets's avatar
Jean-Paul Smets committed
538 539
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
540
        return getattr(aq_base(selection), 'stats', default_stats)
541
      return default_stats
Jean-Paul Smets's avatar
Jean-Paul Smets committed
542 543 544 545 546 547 548 549 550 551 552


    security.declareProtected(ERP5Permissions.View, 'viewFirst')
    def viewFirst(self, selection_index='', selection_name='', form_id='view', REQUEST=None):
      """
        Access first item in a selection
      """
      if not REQUEST:
        REQUEST = get_request()
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection:
553
        method = self.unrestrictedTraverse(selection.method_path)
554
        selection_list = selection(method = method, context=self, REQUEST=REQUEST)
555 556 557 558
        if len(selection_list):
          o = selection_list[0]
          url = o.absolute_url()
        else:
559
          url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
560
      else:
561
        url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
562 563 564 565 566 567
      url = '%s/%s?selection_index=%s&selection_name=%s' % (url, form_id, 0, selection_name)
      REQUEST.RESPONSE.redirect(url)

    security.declareProtected(ERP5Permissions.View, 'viewLast')
    def viewLast(self, selection_index='', selection_name='', form_id='view', REQUEST=None):
      """
568
        Access last item in a selection
Jean-Paul Smets's avatar
Jean-Paul Smets committed
569 570 571 572 573
      """
      if not REQUEST:
        REQUEST = get_request()
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection:
574
        method = self.unrestrictedTraverse(selection.method_path)
575
        selection_list = selection(method = method, context=self, REQUEST=REQUEST)
576 577 578 579 580
        if len(selection_list):
          o = selection_list[-1]
          url = o.absolute_url()
        else:
          url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
581
      else:
582
        url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
583 584 585 586 587 588 589 590 591 592 593 594
      url = '%s/%s?selection_index=%s&selection_name=%s' % (url, form_id, -1, selection_name)
      REQUEST.RESPONSE.redirect(url)

    security.declareProtected(ERP5Permissions.View, 'viewNext')
    def viewNext(self, selection_index='', selection_name='', form_id='view', REQUEST=None):
      """
        Access next item in a selection
      """
      if not REQUEST:
        REQUEST = get_request()
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection:
595
        method = self.unrestrictedTraverse(selection.method_path)
596
        selection_list = selection(method = method, context=self, REQUEST=REQUEST)
Aurel's avatar
Aurel committed
597
        if len(selection_list):
598 599 600 601
          o = selection_list[(int(selection_index) + 1) % len(selection_list)]
          url = o.absolute_url()
        else:
          url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
602
      else:
603
        url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
604 605 606 607 608 609 610 611 612 613 614 615
      url = '%s/%s?selection_index=%s&selection_name=%s' % (url, form_id, int(selection_index) + 1, selection_name)
      REQUEST.RESPONSE.redirect(url)

    security.declareProtected(ERP5Permissions.View, 'viewPrevious')
    def viewPrevious(self, selection_index='', selection_name='', form_id='view', REQUEST=None):
      """
        Access previous item in a selection
      """
      if not REQUEST:
        REQUEST = get_request()
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection:
616
        method = self.unrestrictedTraverse(selection.method_path)
617
        selection_list = selection(method = method, context=self, REQUEST=REQUEST)
618 619 620 621 622
        if len(selection_list):
          o = selection_list[(int(selection_index) - 1) % len(selection_list)]
          url = o.absolute_url()
        else:
          url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
623
      else:
624
        url = REQUEST.getURL()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
625 626 627 628 629
      url = '%s/%s?selection_index=%s&selection_name=%s' % (url, form_id, int(selection_index) - 1, selection_name)
      REQUEST.RESPONSE.redirect(url)


    # ListBox related methods
630 631

    security.declareProtected(ERP5Permissions.View, 'firstPage')
Vincent Pelletier's avatar
Vincent Pelletier committed
632
    def firstPage(self, list_selection_name, listbox_uid, uids=None, REQUEST=None):
633 634
      """
        Access the first page of a list
635 636 637
        XXX: As its complementary (lastPage) is broken, this method is
        probably not used either. If so, it should be removed along with
        lastPage.
638 639
      """
      if uids is None: uids = []
Vincent Pelletier's avatar
Vincent Pelletier committed
640 641 642 643
      selection = self.getSelectionFor(list_selection_name, REQUEST)
      REQUEST.form['list_start'] = 0
      self.uncheckAll(list_selection_name, listbox_uid)
      return self.checkAll(list_selection_name, uids, REQUEST=REQUEST)
644 645

    security.declareProtected(ERP5Permissions.View, 'lastPage')
Vincent Pelletier's avatar
Vincent Pelletier committed
646
    def lastPage(self, list_selection_name, listbox_uid, uids=None, REQUEST=None):
647 648
      """
        Access the last page of a list
649 650 651
        XXX: This method is broken, since "total_size" field is not
        present in the listbox rendering any longer. It should be
        removed.
652 653
      """
      if uids is None: uids = []
Vincent Pelletier's avatar
Vincent Pelletier committed
654
      selection = self.getSelectionFor(list_selection_name, REQUEST)
655 656 657 658 659 660
      params = selection.getParams()
      # XXX This will not work if the number of lines shown in the listbox is greater
      #       than the BIG_INT constan. Such a case has low probability but is not
      #       impossible. If you are in this case, send me a mail ! -- Kev
      BIG_INT = 10000000
      last_page_start = BIG_INT
Vincent Pelletier's avatar
Vincent Pelletier committed
661
      total_lines = REQUEST.form.get('total_size', BIG_INT)
662 663 664
      if total_lines != BIG_INT:
        lines_per_page  = params.get('list_lines', 1)
        last_page_start = int(total_lines) - (int(total_lines) % int(lines_per_page))
Vincent Pelletier's avatar
Vincent Pelletier committed
665 666 667
      REQUEST.form['list_start'] = last_page_start
      self.uncheckAll(list_selection_name, listbox_uid)
      return self.checkAll(list_selection_name, uids, REQUEST=REQUEST)
668

Jean-Paul Smets's avatar
Jean-Paul Smets committed
669
    security.declareProtected(ERP5Permissions.View, 'nextPage')
Vincent Pelletier's avatar
Vincent Pelletier committed
670
    def nextPage(self, list_selection_name, listbox_uid, uids=None, REQUEST=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
671 672 673
      """
        Access the next page of a list
      """
674
      if uids is None: uids = []
Vincent Pelletier's avatar
Vincent Pelletier committed
675
      selection = self.getSelectionFor(list_selection_name, REQUEST)
676
      params = selection.getParams()
Vincent Pelletier's avatar
Vincent Pelletier committed
677
      lines = params.get('list_lines', 0)
678 679 680
      start = REQUEST.form.pop('list_start', 0)
      params['list_start'] = int(start) + int(lines)
      selection.edit(params=params)
Vincent Pelletier's avatar
Vincent Pelletier committed
681 682
      self.uncheckAll(list_selection_name, listbox_uid)
      return self.checkAll(list_selection_name, uids, REQUEST=REQUEST)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
683 684

    security.declareProtected(ERP5Permissions.View, 'previousPage')
Vincent Pelletier's avatar
Vincent Pelletier committed
685
    def previousPage(self, list_selection_name, listbox_uid, uids=None, REQUEST=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
686 687 688
      """
        Access the previous page of a list
      """
689
      if uids is None: uids = []
Vincent Pelletier's avatar
Vincent Pelletier committed
690
      selection = self.getSelectionFor(list_selection_name, REQUEST)
691
      params = selection.getParams()
Vincent Pelletier's avatar
Vincent Pelletier committed
692
      lines = params.get('list_lines', 0)
693 694 695
      start = REQUEST.form.pop('list_start', 0)
      params['list_start'] = max(int(start) - int(lines), 0)
      selection.edit(params=params)
Vincent Pelletier's avatar
Vincent Pelletier committed
696 697
      self.uncheckAll(list_selection_name, listbox_uid)
      return self.checkAll(list_selection_name, uids, REQUEST=REQUEST)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
698 699

    security.declareProtected(ERP5Permissions.View, 'setPage')
Vincent Pelletier's avatar
Vincent Pelletier committed
700
    def setPage(self, list_selection_name, listbox_uid, query_string=None, uids=None, REQUEST=None):
701
      """
Jean-Paul Smets's avatar
Jean-Paul Smets committed
702
         Sets the current displayed page in a selection
703
      """
704
      if uids is None: uids = []
Vincent Pelletier's avatar
Vincent Pelletier committed
705 706
      selection = self.getSelectionFor(list_selection_name, REQUEST)
      params = selection.getParams()
707
      params['list_start'] = int(REQUEST.form.pop('list_start', 0))
Vincent Pelletier's avatar
Vincent Pelletier committed
708 709 710
      selection.edit(params=params)
      self.uncheckAll(list_selection_name, listbox_uid)
      return self.checkAll(list_selection_name, uids, REQUEST=REQUEST, query_string=query_string)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
711

712
    # PlanningBox related methods
713 714
    security.declareProtected(ERP5Permissions.View, 'setLanePath')
    def setLanePath(self, uids=None, REQUEST=None, form_id=None,
715
                     query_string=None):
716 717 718
      """
      Set graphic zoom level in PlanningBox
      """
719 720
      if uids is None:
        uids = []
721 722 723 724 725
      request = REQUEST
      selection_name=request.list_selection_name
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        params = selection.getParams()
726 727 728
        lane_path = request.form.get('lane_path', None)
        if lane_path is None:
          # If lane_path is not defined try to 
729
          # use the last one from params
730 731 732 733 734 735
          lane_path = params.get('lane_path',1)
        bound_start = request.form.get('bound_start', None)
        if bound_start is not None:
          params['bound_start'] = bound_start
        params['lane_path'] = lane_path     
        params['zoom_variation'] = 0
736
        selection.edit(params=params)
737
      if REQUEST is not None:
738 739 740
        return self._redirectToOriginalForm(REQUEST=REQUEST,
                                            form_id=form_id,
                                            query_string=query_string)
741

742 743
    security.declareProtected(ERP5Permissions.View, 'nextLanePage')
    def nextLanePage(self, uids=None, REQUEST=None, form_id=None, query_string=None):
744 745 746
      """
      Set next graphic zoom start in PlanningBox
      """
747 748
      if uids is None:
        uids = []
749 750 751 752 753
      request = REQUEST
      selection_name=request.list_selection_name
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        params = selection.getParams()
754
        params['bound_variation'] = 1
755
        selection.edit(params=params)
756
      if REQUEST is not None:
757 758 759
        return self._redirectToOriginalForm(REQUEST=REQUEST,
                                            form_id=form_id,
                                             query_string=query_string)
760

761 762
    security.declareProtected(ERP5Permissions.View, 'previousLanePage')
    def previousLanePage(self, uids=None, REQUEST=None, form_id=None, query_string=None):
763 764 765
      """
      Set previous graphic zoom in PlanningBox
      """
766 767
      if uids is None:
        uids = []
768 769 770 771 772
      request = REQUEST
      selection_name=request.list_selection_name
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
      if selection is not None:
        params = selection.getParams()
773
        params['bound_variation'] = -1
774 775 776 777 778
        selection.edit(params=params)
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST,
                                            form_id=form_id,
                                             query_string=query_string)
779

Jean-Paul Smets's avatar
Jean-Paul Smets committed
780
    security.declareProtected(ERP5Permissions.View, 'setDomainRoot')
781
    def setDomainRoot(self, REQUEST, form_id=None, query_string=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
782 783 784
      """
        Sets the root domain for the current selection
      """
785
      selection_name = REQUEST.list_selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
786
      selection = self.getSelectionFor(selection_name, REQUEST)
787
      root_url = REQUEST.form.get('domain_root_url','portal_categories')
788
      selection.edit(domain_path=root_url, domain_list=())
Jean-Paul Smets's avatar
Jean-Paul Smets committed
789

790 791 792
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string)
793

794 795 796 797 798 799
    security.declareProtected(ERP5Permissions.View, 'setDomainRootFromParam')
    def setDomainRootFromParam(self, REQUEST, selection_name, domain_root):
      if REQUEST is None:
        return
      selection = self.getSelectionFor(selection_name, REQUEST)
      selection.edit(domain_path=domain_root, domain_list=())
Jean-Paul Smets's avatar
Jean-Paul Smets committed
800

801
    security.declareProtected(ERP5Permissions.View, 'unfoldDomain')
802
    def unfoldDomain(self, REQUEST, form_id=None, query_string=None):
803 804 805
      """
        Unfold domain for the current selection
      """
806
      selection_name = REQUEST.list_selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
807
      selection = self.getSelectionFor(selection_name, REQUEST)
808 809
      domain_url = REQUEST.form.get('domain_url',None)
      domain_depth = REQUEST.form.get('domain_depth',0)
810 811
      domain_list = list(selection.getDomainList())
      domain_list = domain_list[0:min(domain_depth, len(domain_list))]
812
      if isinstance(domain_url, str):
813
        selection.edit(domain_list = domain_list + [domain_url])
Jean-Paul Smets's avatar
Jean-Paul Smets committed
814

815 816 817
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
818

819
    security.declareProtected(ERP5Permissions.View, 'foldDomain')
820
    def foldDomain(self, REQUEST, form_id=None, query_string=None):
821 822 823
      """
        Fold domain for the current selection
      """
824
      selection_name = REQUEST.list_selection_name
825
      selection = self.getSelectionFor(selection_name, REQUEST)
826 827
      domain_url = REQUEST.form.get('domain_url',None)
      domain_depth = REQUEST.form.get('domain_depth',0)
828 829
      domain_list = list(selection.getDomainList())
      domain_list = domain_list[0:min(domain_depth, len(domain_list))]
830
      selection.edit(domain_list=[x for x in domain_list if x != domain_url])
831

832 833 834
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string)
835

836

Jean-Paul Smets's avatar
Jean-Paul Smets committed
837
    security.declareProtected(ERP5Permissions.View, 'setReportRoot')
838
    def setReportRoot(self, REQUEST, form_id=None, query_string=None):
839 840 841
      """
        Sets the root report for the current selection
      """
842
      selection_name = REQUEST.list_selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
843
      selection = self.getSelectionFor(selection_name, REQUEST)
844
      root_url = REQUEST.form.get('report_root_url','portal_categories')
845
      selection.edit(report_path=root_url, report_list=())
Jean-Paul Smets's avatar
Jean-Paul Smets committed
846

847 848 849
      if REQUEST is not None:
        return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                            query_string=query_string)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
850 851

    security.declareProtected(ERP5Permissions.View, 'unfoldReport')
852
    def unfoldReport(self, REQUEST, form_id=None, query_string=None):
853 854 855
      """
        Unfold report for the current selection
      """
856
      selection_name = REQUEST.list_selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
857
      selection = self.getSelectionFor(selection_name, REQUEST)
858
      report_url = REQUEST.form.get('report_url',None)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
859
      if type(report_url) == type('a'):
860
        selection.edit(report_list=list(selection.getReportList()) + [report_url])
Jean-Paul Smets's avatar
Jean-Paul Smets committed
861

862 863 864
      return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                          query_string=query_string,
                                          no_report_depth=True)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
865 866

    security.declareProtected(ERP5Permissions.View, 'foldReport')
867
    def foldReport(self, REQUEST, form_id=None, query_string=None):
868 869 870
      """
        Fold domain for the current selection
      """
871
      selection_name = REQUEST.list_selection_name
Jean-Paul Smets's avatar
Jean-Paul Smets committed
872
      selection = self.getSelectionFor(selection_name, REQUEST)
873
      report_url = REQUEST.form.get('report_url',None)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
874
      if type(report_url) == type('a'):
875
        report_list = selection.getReportList()
876
        selection.edit(report_list=[x for x in report_list if x != report_url])
Jean-Paul Smets's avatar
Jean-Paul Smets committed
877

878 879 880
      return self._redirectToOriginalForm(REQUEST=REQUEST, form_id=form_id,
                                          query_string=query_string,
                                          no_report_depth=True)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
881

882 883 884 885
    security.declareProtected(ERP5Permissions.View, 'getListboxDisplayMode')
    def getListboxDisplayMode(self, selection_name, REQUEST=None):
      if REQUEST is None:
        REQUEST = get_request()
886
      selection = self.getSelectionFor(selection_name, REQUEST)
887

888 889 890 891 892
      if getattr(selection, 'report_tree_mode', 0):
        return 'ReportTreeMode'
      elif getattr(selection, 'domain_tree_mode', 0):
        return 'DomainTreeMode'
      return 'FlatListMode'
893

Jean-Paul Smets's avatar
Jean-Paul Smets committed
894
    security.declareProtected(ERP5Permissions.View, 'setListboxDisplayMode')
895
    def setListboxDisplayMode(self, REQUEST, listbox_display_mode,
896 897
                              selection_name=None, redirect=0,
                              form_id=None, query_string=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
898
      """
899
        Toggle display of the listbox
Jean-Paul Smets's avatar
Jean-Paul Smets committed
900 901
      """
      request = REQUEST
902 903 904 905 906 907 908
      # XXX FIXME
      # Dirty fix: we must be able to change the display mode of a listbox
      # in form_view
      # But, form can have multiple listbox...
      # This need to be cleaned
      # Beware, this fix may break the report system...
      # and we don't have test for this
909 910
      # Possible fix: currently, display mode icon are implemented as
      # method. It could be easier to generate them as link (where we
911 912 913 914 915 916 917 918 919
      # can define explicitely parameters through the url).
      try:
        list_selection_name = request.list_selection_name
      except AttributeError:
        pass
      else:
        if list_selection_name is not None:
          selection_name = request.list_selection_name
      # Get the selection
Jean-Paul Smets's avatar
Jean-Paul Smets committed
920
      selection = self.getSelectionFor(selection_name, REQUEST)
921 922
      if selection is None:
        selection = Selection()
923
        self.setSelectionFor(selection_name, selection, REQUEST=REQUEST)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
924 925 926 927 928 929 930 931 932 933 934 935 936

      if listbox_display_mode == 'FlatListMode':
        flat_list_mode = 1
        domain_tree_mode = 0
        report_tree_mode = 0
      elif listbox_display_mode == 'DomainTreeMode':
        flat_list_mode = 0
        domain_tree_mode = 1
        report_tree_mode = 0
      elif listbox_display_mode == 'ReportTreeMode':
        flat_list_mode = 0
        domain_tree_mode = 0
        report_tree_mode = 1
937 938 939
      else:
        flat_list_mode = 0
        domain_tree_mode = 0
940
        report_tree_mode = 0
941

942 943 944
      selection.edit(flat_list_mode=flat_list_mode,
                     domain_tree_mode=domain_tree_mode,
                     report_tree_mode=report_tree_mode)
945
      # It is better to reset the query when changing the display mode.
946 947
      params = selection.getParams()
      if 'where_expression' in params: del params['where_expression']
948
      selection.edit(params=params)
949

950
      if redirect:
951 952 953
        return self._redirectToOriginalForm(REQUEST=request, form_id=form_id,
                                            query_string=query_string,
                                            no_reset=True)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
954 955

    security.declareProtected(ERP5Permissions.View, 'setFlatListMode')
956
    def setFlatListMode(self, REQUEST, selection_name=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
957 958 959
      """
        Set display of the listbox to FlatList mode
      """
960
      return self.setListboxDisplayMode(
961
                       REQUEST=REQUEST, listbox_display_mode='FlatListMode',
962
                       selection_name=selection_name, redirect=1)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
963 964

    security.declareProtected(ERP5Permissions.View, 'setDomainTreeMode')
965
    def setDomainTreeMode(self, REQUEST, selection_name=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
966 967 968
      """
         Set display of the listbox to DomainTree mode
      """
969
      return self.setListboxDisplayMode(
970
                       REQUEST=REQUEST, listbox_display_mode='DomainTreeMode',
971
                       selection_name=selection_name, redirect=1)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
972 973

    security.declareProtected(ERP5Permissions.View, 'setReportTreeMode')
974
    def setReportTreeMode(self, REQUEST, selection_name=None):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
975 976 977
      """
        Set display of the listbox to ReportTree mode
      """
978 979 980
      return self.setListboxDisplayMode(
                       REQUEST=REQUEST, listbox_display_mode='ReportTreeMode',
                       selection_name=selection_name, redirect=1)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
981

982 983 984 985 986 987
    security.declareProtected(ERP5Permissions.View, 'getSelectionSelectedValueList')
    def getSelectionSelectedValueList(self, selection_name, REQUEST=None, selection_method=None, context=None):
      """
        Get the list of values selected for 'selection_name'
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
988 989
      if selection is None:
        return []
990
      return selection(method=selection_method, context=context, REQUEST=REQUEST)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
991

992 993 994 995 996 997
    security.declareProtected(ERP5Permissions.View, 'getSelectionCheckedValueList')
    def getSelectionCheckedValueList(self, selection_name, REQUEST=None):
      """
        Get the list of values checked for 'selection_name'
      """
      selection = self.getSelectionFor(selection_name, REQUEST=REQUEST)
998 999
      if selection is None:
        return []
1000
      uid_list = selection.getCheckedUids()
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
      value_list = self.portal_catalog.getObjectList(uid_list)
      return value_list

    security.declareProtected(ERP5Permissions.View, 'getSelectionValueList')
    def getSelectionValueList(self, selection_name, REQUEST=None, selection_method=None, context=None):
      """
        Get the list of values checked or selected for 'selection_name'
      """
      value_list = self.getSelectionCheckedValueList(selection_name, REQUEST=REQUEST)
      if len(value_list) == 0:
1011 1012
        value_list = self.getSelectionSelectedValueList(
                                            selection_name,
1013 1014
                                            REQUEST=REQUEST,
                                            selection_method=selection_method,
1015
                                            context=context)
1016
      return value_list
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1017

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1018 1019 1020 1021 1022
    security.declareProtected(ERP5Permissions.View, 'getSelectionUidList')
    def getSelectionUidList(self, selection_name, REQUEST=None, selection_method=None, context=None):
      """
        Get the list of values checked or selected for 'selection_name'
      """
1023
      return [x.getObject().getUid() for x in self.getSelectionValueList(selection_name, REQUEST=REQUEST, selection_method=selection_method, context=context)]
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1024

Sebastien Robin's avatar
Sebastien Robin committed
1025 1026 1027 1028 1029
    security.declareProtected(ERP5Permissions.View, 'selectionHasChanged')
    def selectionHasChanged(self, md5_string, object_uid_list):
      """
        We want to be sure that the selection did not change
      """
1030
      # XXX To avoid the difference of the string representations of int and long,
1031
      # convert each element to a string.
1032 1033 1034 1035
      object_uid_list = [str(x) for x in object_uid_list]
      object_uid_list.sort()
      new_md5_string = md5.new(str(object_uid_list)).hexdigest()
      return md5_string != new_md5_string
Sebastien Robin's avatar
Sebastien Robin committed
1036

Sebastien Robin's avatar
Sebastien Robin committed
1037

1038
    # Related document searching
1039
    def viewSearchRelatedDocumentDialog(self, index, form_id,
1040
                                        REQUEST=None, sub_index=None, **kw):
1041
      """
1042 1043
      Returns a search related document dialog
      A set of forwarders us defined to circumvent limitations of HTML
1044
      """
Romain Courteaud's avatar
Romain Courteaud committed
1045 1046
      if sub_index != None:
        REQUEST.form['sub_index'] = sub_index
1047
      object_path = REQUEST.form['object_path']
1048
      # Find the object which needs to be updated
1049
      o = self.restrictedTraverse(object_path)
1050
      # Find the field which was clicked on
1051
      # Important to get from the object instead of self
1052
      form = getattr(o, form_id)
1053
      field = None
1054 1055
      # Search the correct field
      relation_field_found = 0
1056
      relation_index = 0
1057
      # XXX may be should support another parameter,
1058
      for field in form.get_fields(include_disabled=0):
1059 1060
        if field.get_value('editable', REQUEST=REQUEST):
          try:
1061 1062
           field.get_value('is_relation_field')
          except KeyError:
1063
            pass
1064
          else:
1065 1066 1067 1068 1069
            if index == relation_index:
              relation_field_found = 1
              break
            else:
              relation_index += 1
1070
      if not relation_field_found:
1071
        # We didn't find the field...
1072
        raise SelectionError, "SelectionTool: can not find the relation" \
1073
                              " field %s" % index
1074 1075 1076 1077
      else:
        # Field found
        field_key = field.generate_field_key()
        field_value = REQUEST.form[field_key]
1078 1079
        dialog_id = field.get_value('relation_form_id') or \
                                                   'Base_viewRelatedObjectList'
1080
        redirect_form = getattr(o, dialog_id)
1081 1082 1083 1084 1085 1086 1087 1088
        # XXX Hardcoded listbox field
        selection_name = redirect_form.listbox.get_value('selection_name')
        # Reset current selection
        self.portal_selections.setSelectionFor(selection_name, None)


        if (field.get_value('is_multi_relation_field')) and \
           (sub_index is None):
1089 1090 1091 1092
          # user click on the wheel, not on the validation button
          # we need to facilitate user search

          # first: store current field value in the selection
1093
          base_category = field.get_value('base_category')
1094

1095 1096 1097 1098 1099 1100
          property_get_related_uid_method_name = \
            "get%sUidList" % ''.join(['%s%s' % (x[0].upper(), x[1:]) \
                                      for x in base_category.split('_')])
          current_uid_list = getattr(o, property_get_related_uid_method_name)\
                               (portal_type=[x[0] for x in \
                                  field.get_value('portal_type')])
Romain Courteaud's avatar
Romain Courteaud committed
1101 1102 1103
          # Checked current uid
          kw ={}
          kw[field.get_value('catalog_index')] = field_value
1104
          self.portal_selections.setSelectionParamsFor(selection_name,
1105 1106
                                                       kw.copy())
          self.portal_selections.setSelectionCheckedUidsFor(
1107
                                             selection_name,
1108
                                             current_uid_list)
1109
          field_value = str(field_value).splitlines()
1110 1111 1112 1113 1114
          # Prevent displaying useless empty list or list with only one element
          if not field_value:
            field_value = ''
          if len(field_value) == 1:
            field_value = field_value[0]
1115 1116
          if len(field_value) > 1 and isinstance(field_value, type([])):
            field_value = ' OR '.join(field_value)
1117
          REQUEST.form[field_key] = field_value
1118
          portal_status_message = translateString("Please select one (or more) object.")
1119
        else:
1120
          portal_status_message = translateString("Please select one object.")
1121 1122


1123 1124
        # Save the current REQUEST form
        # We can't put FileUpload instances because we can't pickle them
1125 1126 1127 1128
        saved_form_data = {}
        for key, value in REQUEST.form.items():
          if not isinstance(value, FileUpload):
              saved_form_data[key] = value
1129

1130 1131
        base_category = None
        kw = {}
1132
        kw['dialog_id'] = dialog_id
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
        kw['selection_name'] = selection_name
        kw['selection_index'] = 0 # We start on the first page
        kw['field_id'] = field.id
        parameter_list = field.get_value('parameter_list')
        if len(parameter_list) > 0:
          for k,v in parameter_list:
            kw[k] = v
        kw['reset'] = 0
        kw['base_category'] = field.get_value( 'base_category')
        kw['cancel_url'] = REQUEST.get('HTTP_REFERER')
1143
        kw['form_id'] = form_id
1144 1145
        kw[field.get_value('catalog_index')] = field_value
        kw['portal_status_message'] = portal_status_message
1146
        kw['saved_form_data'] = saved_form_data
1147

1148 1149 1150 1151 1152 1153 1154 1155 1156
        proxy_listbox_ids = field.get_value('proxy_listbox_ids')
        REQUEST.set('proxy_listbox_ids', proxy_listbox_ids)
        if len(proxy_listbox_ids) > 0:
          REQUEST.set('proxy_listbox_id', proxy_listbox_ids[0][0])
        else:
          REQUEST.set('proxy_listbox_id', \
                       "Base_viewRelatedObjectListBase/listbox")

        # Empty the selection (uid)
1157 1158
        REQUEST.form = kw # New request form
        # Define new HTTP_REFERER
Romain Courteaud's avatar
Romain Courteaud committed
1159
        REQUEST.HTTP_REFERER = '%s/%s' % (o.absolute_url(),
1160
                                          dialog_id)
1161 1162 1163 1164 1165

        # If we are called from a Web Site, we should return
        # in the context of the Web Section
        if self.getApplicableLayout() is not None:
          return getattr(o.__of__(self.getWebSectionValue()), dialog_id)(REQUEST=REQUEST)
1166
        # Return the search dialog
1167
        return getattr(o, dialog_id)(REQUEST=REQUEST)
1168

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
    security.declarePublic('buildSQLJoinExpressionFromDomainSelection')
    def buildSQLJoinExpressionFromDomainSelection(self, selection_domain,
                                                  domain_id=None,
                                                  exclude_domain_id=None,
                                                  category_table_alias='category'):
      if isinstance(selection_domain, DomainSelection):
        warnings.warn("To pass a DomainSelection instance is deprecated.\n"
                      "Please use a domain dict instead.",
                      DeprecationWarning)
      else:
        selection_domain = DomainSelection(selection_domain).__of__(self)
1180 1181
      return selection_domain.asSQLJoinExpression(
          category_table_alias=category_table_alias)
1182 1183 1184

    security.declarePublic('buildSQLExpressionFromDomainSelection')
    def buildSQLExpressionFromDomainSelection(self, selection_domain,
1185
                                              table_map=None, domain_id=None,
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
                                              exclude_domain_id=None,
                                              strict_membership=0,
                                              join_table="catalog",
                                              join_column="uid",
                                              base_category=None,
                                              category_table_alias='category'):
      if isinstance(selection_domain, DomainSelection):
        warnings.warn("To pass a DomainSelection instance is deprecated.\n"
                      "Please use a domain dict instead.",
                      DeprecationWarning)
      else:
        selection_domain = DomainSelection(selection_domain).__of__(self)
1198 1199 1200 1201 1202 1203
      return selection_domain.asSQLExpression(
          strict_membership = strict_membership,
          join_table=join_table,
          join_column=join_column,
          base_category=base_category,
          category_table_alias = category_table_alias)
1204

1205 1206
    def _aq_dynamic(self, name):
      """
1207
        Generate viewSearchRelatedDocumentDialog0,
1208
                 viewSearchRelatedDocumentDialog1,... if necessary
1209 1210 1211
      """
      aq_base_name = getattr(aq_base(self), name, None)
      if aq_base_name == None:
1212 1213 1214
        DYNAMIC_METHOD_NAME = 'viewSearchRelatedDocumentDialog'
        method_name_length = len(DYNAMIC_METHOD_NAME)

1215
        zope_security = '__roles__'
1216
        if (name[:method_name_length] == DYNAMIC_METHOD_NAME) and \
1217
           (name[-len(zope_security):] != zope_security):
1218
          method_count_string_list = name[method_name_length:].split('_')
1219 1220 1221 1222
          method_count_string = method_count_string_list[0]
          # be sure that method name is correct
          try:
            method_count = string.atoi(method_count_string)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
1223
          except TypeError:
1224
            return aq_base_name
1225
          else:
1226 1227 1228
            if len(method_count_string_list) > 1:
              # be sure that method name is correct
              try:
Romain Courteaud's avatar
Romain Courteaud committed
1229
                sub_index = string.atoi(method_count_string_list[1])
Yoshinori Okuji's avatar
Yoshinori Okuji committed
1230
              except TypeError:
1231 1232
                return aq_base_name
            else:
Romain Courteaud's avatar
Romain Courteaud committed
1233
              sub_index = None
1234

1235
            # generate dynamicaly needed forwarder methods
1236
            def viewSearchRelatedDocumentDialogWrapper(self, form_id,
1237
                                                       REQUEST=None, **kw):
1238 1239 1240
              """
                viewSearchRelatedDocumentDialog Wrapper
              """
1241 1242
#               LOG('SelectionTool.viewSearchRelatedDocumentDialogWrapper, kw',
#                   0, kw)
1243
              return self.viewSearchRelatedDocumentDialog(
1244
                                   method_count, form_id,
1245
                                   REQUEST=REQUEST, sub_index=sub_index, **kw)
1246
            setattr(self.__class__, name,
1247
                    viewSearchRelatedDocumentDialogWrapper)
1248 1249

            klass = aq_base(self).__class__
1250 1251 1252 1253
            security_property_id = '%s__roles__' % (name, )
            # Declare method as public
            setattr(klass, security_property_id, None)

1254 1255 1256 1257
            return getattr(self, name)
        else:
          return aq_base_name
      return aq_base_name
1258

1259 1260
    def _getUserId(self):
      return self.portal_membership.getAuthenticatedMember().getUserName()
1261 1262
      # XXX It would be good to add somthing here
      # So that 2 anonymous users do not share the same selection
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281

    def _getSelectionFromContainer(self, selection_name):
      user_id = self._getUserId()
      if user_id is None: return None
      if self.isMemcachedUsed():
        return self._getMemcachedContainer().get('%s-%s' %
                                                 (user_id, selection_name))
      else:
        return self._getPersistentContainer(user_id).get(selection_name,
                                                         None)

    def _setSelectionToContainer(self, selection_name, selection):
      user_id = self._getUserId()
      if user_id is None: return
      if self.isMemcachedUsed():
        self._getMemcachedContainer().set('%s-%s' % (user_id, selection_name), aq_base(selection))
      else:
        self._getPersistentContainer(user_id)[selection_name] = aq_base(selection)

1282 1283 1284 1285 1286 1287 1288 1289
    def _deleteSelectionFromContainer(self, selection_name):
      user_id = self._getUserId()
      if user_id is None: return None
      if self.isMemcachedUsed():
        del(self._getMemcachedContainer()['%s-%s' % (user_id, selection_name)])
      else:
        del(self._getPersistentContainer(user_id)[selection_name])

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
    def _deleteGlobalSelectionFromContainer(self, selection_name):
      id_list = []
      if self.isMemcachedUsed():
        for k in self._getMemcachedContainer().keys():
          if k.split('-')[1] == selection_name:
            del(self._getMemcachedContainer()[k])
      else:
        if getattr(aq_base(self), 'selection_data', None) is not None:
          for user_id in self.selection_data.keys():
            mapping = self._getPersistentContainer(user_id)
            if mapping.has_key(selection_name):
              del(mapping[selection_name])

1303 1304 1305 1306 1307 1308 1309 1310 1311
    def _getSelectionNameListFromContainer(self):
      if self.isMemcachedUsed():
        return []
      else:
        user_id = self._getUserId()
        if user_id is None: return []
        return self._getPersistentContainer(user_id).keys()

    def _getMemcachedContainer(self):
1312
      value = getattr(aq_base(self), '_v_selection_data', None)
1313 1314 1315 1316 1317 1318
      if value is None:
        value = self.getPortalObject().portal_memcached.getMemcachedDict(key_prefix='selection_tool')
        setattr(self, '_v_selection_data', value)
      return value

    def _getPersistentContainer(self, user_id):
1319
      if getattr(aq_base(self), 'selection_data', None) is None:
1320 1321 1322 1323 1324
        self.selection_data = PersistentMapping()
      if not self.selection_data.has_key(user_id):
        self.selection_data[user_id] = SelectionPersistentMapping()
      return self.selection_data[user_id]

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1325
InitializeClass( SelectionTool )
1326

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340

class SelectionPersistentMapping(PersistentMapping):
  """A conflict-free PersistentMapping.

  Like selection objects, the purpose is to only prevent restarting
  transactions.
  """
  def _p_independent(self) :
    return 1

  def _p_resolveConflict(self, oldState, savedState, newState):
    # update keys that only savedState has
    oldState = newState
    # dict returned by PersistentMapping.__getstate__ contains the data
1341
    # under '_container' key in zope 2.7 and 'data' in zope 2.8
Kazuhiko Shiozaki's avatar
typo.  
Kazuhiko Shiozaki committed
1342
    if 'data' in oldState:
1343 1344 1345
      oldState['data'].update(savedState['data'])
    else:
      oldState['_container'].update(savedState['_container'])
1346 1347 1348
    return oldState


1349 1350 1351 1352 1353 1354 1355 1356
class TreeListLine:
  def __init__(self,object,is_pure_summary,depth, is_open,select_domain_dict,exception_uid_list):
    self.object=object
    self.is_pure_summary=is_pure_summary
    self.depth=depth
    self.is_open=is_open
    self.select_domain_dict=select_domain_dict
    self.exception_uid_list=exception_uid_list
1357

1358 1359
  def getObject(self):
    return self.object
1360

1361 1362
  def getIsPureSummary(self):
    return self.is_pure_summary
1363

1364 1365
  def getDepth(self):
    return self.depth
1366

1367 1368
  def getIsOpen(self):
    return self.is_open
1369 1370

  def getSelectDomainDict(self):
1371
    return self.select_domain_dict
1372

1373 1374
  def getExceptionUidList(self):
    return self.exception_uid_list
1375

1376

1377 1378
def makeTreeList(here, form, root_dict, report_path, base_category,
		  depth, unfolded_list, form_id, selection_name,
1379
		  report_depth, is_report_opened=1, list_method=None,
1380
		  filtered_portal_types=[] ,sort_on = (('id', 'ASC'),)):
1381 1382 1383 1384 1385
  """
    (object, is_pure_summary, depth, is_open, select_domain_dict)

    select_domain_dict is a dictionary of  associative list of (id, domain)
  """
1386 1387
  if isinstance(report_path, str):
    report_path = report_path.split('/')
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402

  portal_categories = getattr(form, 'portal_categories', None)
  portal_domains = getattr(form, 'portal_domains', None)
  portal_object = form.portal_url.getPortalObject()
  if len(report_path):
    base_category = report_path[0]

  if root_dict is None:
    root_dict = {}

  is_empty_level = 1
  while is_empty_level:
    if not root_dict.has_key(base_category):
      root = None
      if portal_categories is not None:
1403
        if portal_categories._getOb(base_category, None) is not None:
1404 1405 1406 1407
          if base_category == 'parent':
            # parent has a special treatment
            root = root_dict[base_category] = root_dict[None] = here
            report_path = report_path[1:]
1408
          else:
1409 1410
            root = root_dict[base_category] = root_dict[None] = \
                                               portal_categories[base_category]
1411 1412
            report_path = report_path[1:]
      if root is None and portal_domains is not None:
1413 1414 1415
        if portal_domains._getOb(base_category, None) is not None:
          root = root_dict[base_category] = root_dict[None] = \
                                               portal_domains[base_category]
1416 1417 1418
          report_path = report_path[1:]
      if root is None:
        try:
1419 1420
          root = root_dict[None] = \
              portal_object.unrestrictedTraverse(report_path)
1421
        except KeyError:
1422
          LOG('SelectionTool', INFO, "Not found %s" % str(report_path))
1423 1424 1425 1426 1427
          root = None
        report_path = ()
    else:
      root = root_dict[None] = root_dict[base_category]
      report_path = report_path[1:]
1428 1429
    is_empty_level = (root is not None) and \
        (root.objectCount() == 0) and (len(report_path) != 0)
1430
    if is_empty_level:
1431
      base_category = report_path[0]
1432 1433

  tree_list = []
1434
  if root is None:
1435
    return tree_list
1436

1437
  if base_category == 'parent':
1438 1439 1440 1441 1442
    # Use searchFolder as default
    if list_method is None:
      if hasattr(aq_base(root), 'objectValues'):
        # If this is a folder, try to browse the hierarchy
        object_list = root.searchFolder(sort_on=sort_on)
1443
    else:
1444
      if filtered_portal_types not in [[],None,'']:
1445 1446
        object_list = list_method(portal_type=filtered_portal_types,
                                  sort_on=sort_on)
1447
      else:
1448
        object_list = list_method(sort_on=sort_on)
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
    for zo in object_list:
      o = zo.getObject()
      if o is not None:
        new_root_dict = root_dict.copy()
        new_root_dict[None] = new_root_dict[base_category] = o

        selection_domain = DomainSelection(domain_dict = new_root_dict)
        if (report_depth is not None and depth <= (report_depth - 1)) or \
                                          o.getRelativeUrl() in unfolded_list:
          exception_uid_list = [] # Object we do not want to display

          for sub_zo in o.searchFolder(sort_on=sort_on):
            sub_o = sub_zo.getObject()
            if sub_o is not None and hasattr(aq_base(root), 'objectValues'):
              exception_uid_list.append(sub_o.getUid())
          # Summary (open)
1465
          tree_list += [TreeListLine(o, 1, depth, 1, selection_domain, exception_uid_list)]
1466 1467
          if is_report_opened :
            # List (contents, closed, must be strict selection)
1468 1469 1470
            tree_list += [TreeListLine(o, 0, depth, 0, selection_domain, exception_uid_list)]

          tree_list += makeTreeList(here, form, new_root_dict, report_path,
1471
      		    base_category, depth + 1, unfolded_list, form_id,
1472
      		    selection_name, report_depth,
1473 1474 1475
      		    is_report_opened=is_report_opened, sort_on=sort_on)
        else:
          tree_list += [TreeListLine(o, 1, depth, 0, selection_domain, ())] # Summary (closed)
1476
  else:
1477 1478 1479 1480 1481 1482
    # process to recover objects in case a generation script is used
    if hasattr(root,'getChildDomainValueList'):
      oblist = root.getChildDomainValueList(root,depth=depth)
    else:
      oblist = root.objectValues()
    for o in oblist:
1483 1484 1485 1486 1487 1488 1489
      new_root_dict = root_dict.copy()
      new_root_dict[None] = new_root_dict[base_category] = o
      selection_domain = DomainSelection(domain_dict = new_root_dict)
      if (report_depth is not None and depth <= (report_depth - 1)) or o.getRelativeUrl() in unfolded_list:
        tree_list += [TreeListLine(o, 1, depth, 1, selection_domain, None)] # Summary (open)
        if is_report_opened :
          tree_list += [TreeListLine(o, 0, depth, 0, selection_domain, None)] # List (contents, closed, must be strict selection)
1490 1491
        tree_list += makeTreeList(here, form, new_root_dict, report_path, base_category, depth + 1,
            unfolded_list, form_id, selection_name, report_depth,
1492 1493 1494 1495
            is_report_opened=is_report_opened, sort_on=sort_on)
      else:

        tree_list += [TreeListLine(o, 1, depth, 0, selection_domain, None)] # Summary (closed)
1496

1497 1498
  return tree_list

1499
# Automaticaly add wrappers on Folder so it can access portal_selections.
1500
# Cannot be done in ERP5Type/Document/Folder.py because ERP5Type must not
1501
# depend on ERP5Form.
1502 1503

from Products.CMFCore.utils import getToolByName
1504
from Products.ERP5Type.Core.Folder import FolderMixIn
1505 1506
from ZPublisher.mapply import mapply

1507 1508
method_id_filter_list = [x for x in FolderMixIn.__dict__ if callable(getattr(FolderMixIn, x))]
candidate_method_id_list = [x for x in SelectionTool.__dict__ if callable(getattr(SelectionTool, x)) and not x.startswith('_') and not x.endswith('__roles__') and x not in method_id_filter_list]
1509

1510 1511 1512
# Monkey patch FolderMixIn with SelectionTool methods
#   kept here for compatibility with previous implementations
#   of Listbox HTML renderer. See bellow new implementation
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
for property_id in candidate_method_id_list:
  def portal_selection_wrapper(self, wrapper_property_id=property_id, *args, **kw):
    """
      Wrapper method for SelectionTool.
    """
    portal_selection = getToolByName(self, 'portal_selections')
    request = self.REQUEST
    method = getattr(portal_selection, wrapper_property_id)
    return mapply(method, positional=args, keyword=request,
                  context=self, bind=1)
1523
  setattr(FolderMixIn, property_id, portal_selection_wrapper)
1524 1525 1526
  security_property_id = '%s__roles__' % (property_id, )
  security_property = getattr(SelectionTool, security_property_id, None)
  if security_property is not None:
1527
    setattr(FolderMixIn, security_property_id, security_property)
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573

def createFolderMixInPageSelectionMethod(listbox_id):
  """
  This method must be called by listbox at rendering time.
  It dynamically creates methods on FolderMixIn in line
  with the naming of the listbox field. Generated method
  are able to convert request parameters in order to
  mimic the API of a listbox with ID "listbox". This
  approach was required for example to implement
  multiple multi-page listboxes in view mode. It also
  opens the way towards multiple editable listboxes in the same
  page although this is something which we can not recommend.
  """
  # Immediately return in the method already exists
  test_method_id = "%s_nextPage" % listbox_id
  if hasattr(FolderMixIn, test_method_id):
    return
  # Monkey patch FolderMixIn
  for property_id in candidate_method_id_list:
    def portal_selection_wrapper(self, wrapper_listbox_id=listbox_id,
                                       wrapper_property_id=property_id, *args, **kw):
      """
        Wrapper method for SelectionTool.
      """
      portal_selection = getToolByName(self, 'portal_selections')
      request = self.REQUEST
      selection_name_property_id = "%s_list_selection_name" % listbox_id
      listbox_uid_property_id = "%s_uid" % listbox_id
      list_start_property_id = "%s_list_start" % listbox_id
      # Rename request parameters
      if request.has_key(selection_name_property_id):
        request.form['list_selection_name'] = request[selection_name_property_id]
      if request.has_key(listbox_uid_property_id):
        request.form['listbox_uid'] = request[listbox_uid_property_id]
      if request.has_key(list_start_property_id):
        request.form['list_start'] = request[list_start_property_id]
      # Call the wrapper
      method = getattr(portal_selection, wrapper_property_id)
      return mapply(method, positional=args, keyword=request,
                    context=self, bind=1)
    new_property_id = "%s_%s" % (listbox_id, property_id)
    setattr(FolderMixIn, new_property_id, portal_selection_wrapper)
    security_property_id = '%s__roles__' % (property_id, )
    security_property = getattr(SelectionTool, security_property_id, None)
    if security_property is not None:
      new_security_property_id = '%s__roles__' % (new_property_id, )
1574
      setattr(FolderMixIn, new_security_property_id, security_property)