ERP5Site.py 83.9 KB
Newer Older
1
# -*- coding: utf-8 -*-
2
##############################################################################
Jean-Paul Smets's avatar
Jean-Paul Smets committed
3 4 5 6 7 8 9 10 11 12 13
#
# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
14 15
"""
  Portal class
Jean-Paul Smets's avatar
Jean-Paul Smets committed
16 17
"""

18 19
import threading
from weakref import ref as weakref
20
from OFS.Application import Application
21 22
from Products.ERP5Type import Globals
from Products.ERP5Type.Globals import package_home
23

24
from Products.SiteErrorLog.SiteErrorLog import manage_addErrorLog
25
from ZPublisher import BeforeTraverse
26
from ZPublisher.BaseRequest import RequestContainer
Jean-Paul Smets's avatar
Jean-Paul Smets committed
27
from AccessControl import ClassSecurityInfo
28
from Products.CMFDefault.Portal import CMFSite
29
from Products.ERP5Type import Permissions
Jean-Paul Smets's avatar
Jean-Paul Smets committed
30
from Products.ERP5Type.Core.Folder import FolderMixIn
31
from Acquisition import aq_base
32
from Products.ERP5Type import allowClassTool
33 34
from Products.ERP5Type.Accessor.Constant import PropertyGetter as ConstantGetter
from Products.ERP5Type.Cache import caching_instance_method
35
from Products.ERP5Type.Cache import CachingMethod, CacheCookieMixin
36
from Products.ERP5Type.ERP5Type import ERP5TypeInformation
37
from Products.ERP5Type.Log import log as unrestrictedLog
38
from Products.CMFActivity.Errors import ActivityPendingError
39
import ERP5Defaults
40
from Products.ERP5Type.TransactionalVariable import getTransactionalVariable
Nicolas Dumazet's avatar
Nicolas Dumazet committed
41
from Products.ERP5Type.dynamic.portal_type_class import synchronizeDynamicModules
Jean-Paul Smets's avatar
Jean-Paul Smets committed
42

43
from zLOG import LOG, INFO, WARNING, ERROR
Sebastien Robin's avatar
Sebastien Robin committed
44
from string import join
45
import os
46
import warnings
Romain Courteaud's avatar
Romain Courteaud committed
47
from App.config import getConfiguration
48 49
MARKER = []

50

Jean-Paul Smets's avatar
Jean-Paul Smets committed
51
# Site Creation DTML
52 53 54 55 56 57 58 59 60
manage_addERP5SiteFormDtml = Globals.HTMLFile('dtml/addERP5Site', globals())

def manage_addERP5SiteForm(*args, **kw):
  """
    Make getCatalogStorageList available from inside the dtml.
  """
  kw['getCatalogStorageList'] = getCatalogStorageList
  return manage_addERP5SiteFormDtml(*args, **kw)

Jean-Paul Smets's avatar
Jean-Paul Smets committed
61
# ERP5Site Constructor
62 63 64
def manage_addERP5Site(self,
                       id,
                       title='ERP5',
65 66
                       description='',
                       create_userfolder=1,
67
                       create_activities=True,
68 69 70
                       email_from_address='postmaster@localhost',
                       email_from_name='Portal Administrator',
                       validate_email=0,
71
                       erp5_catalog_storage='',
72 73
                       erp5_sql_connection_type='Z MySQL Database Connection',
                       erp5_sql_connection_string='test test',
74 75
                       erp5_sql_deferred_connection_type=\
                           'Z MySQL Deferred Database Connection',
76 77 78 79 80 81 82 83 84
                       cmf_activity_sql_connection_type= \
                           'Z MySQL Database Connection',
                       cmf_activity_sql_connection_string='test test',
                       light_install=0,
                       reindex=1,
                       RESPONSE=None):
  '''
  Adds a portal instance.
  '''
85
  gen = ERP5Generator()
86
  id = str(id).strip()
87 88
  p = gen.create(self,
                 id,
89
                 create_userfolder,
90
                 erp5_catalog_storage,
91 92
                 erp5_sql_connection_type,
                 erp5_sql_connection_string,
93
                 erp5_sql_deferred_connection_type,
94 95 96 97 98
                 cmf_activity_sql_connection_type,
                 cmf_activity_sql_connection_string,
                 create_activities=create_activities,
                 light_install=light_install,
                 reindex=reindex)
99 100
  gen.setupDefaultProperties(p,
                             title,
101
                             description,
102
                             email_from_address,
103 104
                             email_from_name,
                             validate_email)
105
  if RESPONSE is not None:
106 107
    RESPONSE.redirect(p.absolute_url())

108 109 110 111 112 113 114 115 116 117
def getCatalogStorageList(*args, **kw):
  """
    Returns the list of business templates available at install which can be
    used to setup a catalog storage.
  """
  result = []
  bootstrap_dir = getBootstrapDirectory()
  for item in os.listdir(bootstrap_dir):
    if item == '.svn':
      continue
118
    if item.endswith('.bt5') and os.path.isfile(item):
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
      # Simple heuristic to make it faster than extracting the whole bt
      if item.endswith('_catalog.bt5'):
        result.append((item, item))
    elif os.path.isdir(os.path.join(bootstrap_dir, item)):
      # Find if the business temlate provides erp5_catalog
      try:
        provides_file = open(os.path.join(bootstrap_dir, item, 'bt', 'provision_list'), 'r')
        provides_list = provides_file.readlines()
        provides_file.close()
      except IOError:
        provides_list = []
      if 'erp5_catalog' in provides_list:
        # Get a nice title (the first line of the description).
        try:
          title_file = open(os.path.join(bootstrap_dir, item, 'bt', 'description'), 'r')
          title = title_file.readline()
          title_file.close()
        except IOError:
          title = item
        result.append((item, title))
  return result
140

141 142 143 144 145 146 147 148
def addERP5Tool(portal, id, portal_type):
  if portal.hasObject(id):
    return
  import erp5.portal_type
  klass = getattr(erp5.portal_type, portal_type)
  obj = klass()
  portal._setObject(id, obj)

149 150 151 152 153 154 155 156 157 158 159 160 161 162
class ReferCheckerBeforeTraverseHook:
  """This before traverse hook checks the HTTP_REFERER argument in the request
  and refuses access to anything else that portal_url.

  This is enabled by calling the method enableRefererCheck on the portal.
  """
  handle = '_erp5_referer_check'

  def __call__(self, container, request):
    """Checks the request contains a valid referrer.
    """
    response = request.RESPONSE
    http_url = request.get('ACTUAL_URL', '').strip()
    http_referer = request.get('HTTP_REFERER', '').strip()
163

164 165 166 167 168 169 170
    user_password = request._authUserPW()
    if user_password:
      user = container.acl_users.getUserById(user_password[0]) or\
              container.aq_parent.acl_users.getUserById(user_password[0])
      # Manager can do anything
      if user is not None and 'Manager' in user.getRoles():
        return
171

172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
    portal_url = container.portal_url.getPortalObject().absolute_url()
    if http_referer != '':
      # if HTTP_REFERER is set, user can acces the object if referer is ok
      if http_referer.startswith(portal_url):
        return
      LOG('HTTP_REFERER_CHECK : BAD REFERER !', INFO,
          'request : "%s", referer : "%s"' % (http_url, http_referer))
      response.unauthorized()
    else:
      # no HTTP_REFERER, we only allow to reach portal_url
      for i in ('/', '/index_html', '/login_form', '/view'):
        if http_url.endswith(i):
          http_url = http_url[:-len(i)]
          break
      if len(http_url) == 0 or not portal_url.startswith(http_url):
        LOG('HTTP_REFERER_CHECK : NO REFERER !', INFO,
            'request : "%s"' % http_url)
        response.unauthorized()

191 192 193 194 195 196 197 198 199 200

class _site(threading.local):
  """Class for getting and setting the site in the thread global namespace
  """
  site = ()

  def __new__(cls):
    self = threading.local.__new__(cls)
    return self.__get, self.__set

201
  def __get(self, REQUEST=None):
202
    """Returns the currently processed site, optionally wrapped in a request
203
    """
204 205 206
    while True:
      app, site_id = self.site[-1]
      app = app()
207
      if app._p_jar.opened:
208 209 210 211
        if REQUEST is None:
          return getattr(app, site_id)
        return getattr(app.__of__(RequestContainer(REQUEST=REQUEST)), site_id)
      del self.site[-1]
212 213 214 215 216 217 218 219 220 221 222 223 224 225

  def __set(self, site):
    app = aq_base(site.aq_parent)
    self.site = [x for x in self.site if x[0]() is not app]
    # Use weak references for automatic cleanup. In practice, this is probably
    # useless, because there is no reason a thread reopen the database.
    self.site.append((weakref(app, self.__del), site.id))

  def __del(self, app):
    self.site = [x for x in self.site if x[0] is not app]

getSite, setSite = _site()


226
class ERP5Site(FolderMixIn, CMFSite, CacheCookieMixin):
227
  """
228 229
  The *only* function this class should have is to help in the setup
  of a new ERP5.  It should not assist in the functionality at all.
230
  """
231
  meta_type = 'ERP5 Site'
232
  portal_type = 'ERP5 Site'
233
  constructors = (('addERP5Site', manage_addERP5SiteForm), manage_addERP5Site, )
234 235 236
  uid = 0
  last_id = 0
  icon = 'portal.gif'
237 238
  # Default value, prevents error during upgrade
  isIndexable = ConstantGetter('isIndexable', value=True)
239 240

  _properties = (
241
      { 'id':'title',
242
        'type':'string'},
243
      { 'id':'description',
244 245
        'type':'text'},
      )
246 247 248 249 250 251 252
  title = ''
  description = ''

  # Declarative security
  security = ClassSecurityInfo()
  security.declareObjectProtected(Permissions.AccessContentsInformation)

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
  def _createInitialSiteManager(self):
    # This section of code is inspired by
    # Products.CMFDefault.upgrade.to21.upgrade_root_site_manager(),
    # specificallythe 'except ComponentLookupError:' clause, and also
    # by Products.CMFDefault.PortalObjectBase.__init__
    from zope.component.globalregistry import base
    from five.localsitemanager import (PersistentComponents,
                                       find_next_sitemanager)
    next = find_next_sitemanager(self)
    if next is None:
      next = base
    name = '++etc++site'
    sm = PersistentComponents(name, (next,))
    sm.__parent__ = aq_base(self)
    self.setSiteManager(sm)
    LOG('ERP5Site', 0, "Site manager '%s' added." % name)

  def _doTranslationDomainRegistration(self):
    from zope.i18n.interfaces import ITranslationDomain
272
    from Products.Localizer.MessageCatalog import (
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
      message_catalog_alias_sources
    )
    sm = self.getSiteManager()
    for message_catalog in self.Localizer.objectValues():
      sm.registerUtility(message_catalog,
                         provided=ITranslationDomain,
                         name=message_catalog.getId())
      for alias in message_catalog_alias_sources.get(message_catalog.getId()):
        sm.registerUtility(message_catalog,
                           provided=ITranslationDomain,
                           name=alias)

  def _doInitialSiteManagerMigration(self):
    self._createInitialSiteManager()
    # Now that we have a sitemanager, se can do things that require
    # one. Including setting up ZTK style utilities and adapters. We
    # can even call setSite(self), as long as we roll back that later,
    # since we are actually in the middle of a setSite() call.
    from zope.site.hooks import getSite, setSite
    old_site = getSite()
    try:
      setSite(self)
      # setSite(self) is not really necessary for the migration below, but
      # could be needed by other migrations to be added here.
      self._doTranslationDomainRegistration()
    finally:
      setSite(old_site)

  # backward compatibility auto-migration
  def getSiteManager(self):
    # NOTE: do not add a docstring! This method is private by virtue of
    # not having it.

    # XXX-Leo: Consider moving this method and all methods that it calls
    # into a monkeypatch of an optional product. This product could have
    # its own tests for migration without actually cluttering the original
    # source code and would only need to be installed in sites needing
    # migration from Zope 2.8

    # This code is an alteration of
    # OFS.ObjectManager.ObjectManager.getSiteManager(), and is exactly
    # as cheap as it is on the case that self._components is already
    # set.
    _components = self._components
    if _components is not None:
      return _components
    # This method below can take as (reasonably) long as it pleases
    # since it will not be run ever again
    self._doInitialSiteManagerMigration()
    assert self._components is not None, 'Migration Failed!'
    return self._components

325 326
  security.declareProtected(Permissions.View, 'view')
  def view(self):
327 328 329 330 331
    """
      Returns the default view.
      Implemented for consistency
    """
    return self.index_html()
332

333 334 335 336 337
  def __of__(self, parent):
    self = CMFSite.__of__(self, parent)
    # Use a transactional variable for performance reason,
    # since ERP5Site.__of__ is called quite often.
    tv = getTransactionalVariable()
338 339 340
    # Check 'parent' is the root because some objects like '_components'
    # store the site in '__parent__'.
    if 'ERP5Site.__of__' not in tv and type(parent) is Application:
341 342
      tv['ERP5Site.__of__'] = None
      setSite(self)
343 344

      try:
Arnaud Fontaine's avatar
Arnaud Fontaine committed
345
        component_tool = self.portal_components
346
      except AttributeError:
Arnaud Fontaine's avatar
Arnaud Fontaine committed
347 348 349 350 351
        # This should only happen before erp5_core is installed
        synchronizeDynamicModules(self)
      else:
        # If Components are reset, then portal type classes should be reset
        synchronizeDynamicModules(self, component_tool.reset())
352

353 354
    return self

355
  def manage_beforeDelete(self, item, container):
356
    # skin is setup during __before_publishing_traverse__, which
357 358 359 360 361 362 363 364
    # doesn't happen when the object is being deleted from the management
    # interface, but we need it to be set for portal_activities when we're
    # being deleted. 
    self.setupCurrentSkin(self.REQUEST)
    return ERP5Site.inheritedAttribute('manage_beforeDelete')(self,
                                                              item,
                                                              container)

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
  security.declareProtected( Permissions.ModifyPortalContent, 'manage_renameObject' )
  def manage_renameObject(self, id=None, new_id=None, REQUEST=None):
    """manage renaming an object while keeping coherency for contained
    and linked to objects inside the renamed object.

    XXX this is nearly a copy-and-paste from CopySupport.

    XXX this is not good enough when the module or the objects inside
    the module are referred to by outer objects. But addressing this problem
    requires a full traversal of the object tree, and the current
    implementation is not efficient enough for this.
    """
    ob = self.restrictedTraverse(id)
    if getattr(aq_base(ob), '_updateInternalRelatedContent', None) is not None:
      # Make sure there is no activities pending on that object
      try:
381
        portal_activities = self.portal_activities
382
      except AttributeError:
383 384
        pass
      else:
385 386 387 388 389 390 391 392 393 394 395 396 397 398
        if portal_activities.countMessage(path=ob.getPath())>0:
          raise ActivityPendingError, 'Sorry, pending activities prevent ' \
                         +  'changing id at this current stage'

      # Search for categories that have to be updated in sub objects.
      ob._recursiveSetActivityAfterTag(ob)
      path_item_list = ob.getRelativeUrl().split('/')
      ob._updateInternalRelatedContent(object=ob,
                                       path_item_list=path_item_list,
                                       new_id=new_id)
    # Rename the object
    return CMFSite.manage_renameObject(self, id=id, new_id=new_id,
                                       REQUEST=REQUEST)

399

400 401 402 403 404 405 406
  def _getAcquireLocalRoles(self):
    """
      Prevent local roles from being acquired outside of Portal object.
      See ERP5Security/__init__.py:mergedLocalRoles .
    """
    return False

407 408 409 410 411 412 413
  security.declareProtected(Permissions.ManagePortal, 'enableRefererCheck')
  def enableRefererCheck(self):
    """Enable a ReferCheckerBeforeTraverseHook to check users have valid
    HTTP_REFERER
    """
    BeforeTraverse.registerBeforeTraverse(self,
                                        ReferCheckerBeforeTraverseHook(),
414 415 416
                                        ReferCheckerBeforeTraverseHook.handle,
                             # we want to be registered _after_ CookieCrumbler
                                        100)
417

418 419 420 421
  def _disableRefererCheck(self):
    """Disable the HTTP_REFERER check."""
    BeforeTraverse.unregisterBeforeTraverse(self,
                                        ReferCheckerBeforeTraverseHook.handle)
422

423
  def hasObject(self, id):
424
    """
425
    Check if the portal has an id.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
426
    """
427
    return id in self.objectIds()
428

429
  security.declareProtected(Permissions.AccessContentsInformation,
430
                            'getPortalObject')
431 432
  def getPortalObject(self):
    return self
Jean-Paul Smets's avatar
Jean-Paul Smets committed
433

434 435 436 437 438
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalType')
  def getPortalType(self):
    return self.portal_type

439
  security.declareProtected(Permissions.AccessContentsInformation,
440
                            'getTitle')
441 442 443 444 445
  def getTitle(self):
    """
      Return the title.
    """
    return self.title
446

447
  security.declareProtected(Permissions.AccessContentsInformation,
448 449
                            'getVersionPriorityList')
  def getVersionPriorityList(self):
Arnaud Fontaine's avatar
Arnaud Fontaine committed
450
    """
451
    Return the Component version priorities defined on the site in descending
452
    order. Whatever happens, erp5 version must always be returned otherwise it
453
    may render the site unusable when all Products will have been migrated
Arnaud Fontaine's avatar
Arnaud Fontaine committed
454
    """
455
    return getattr(self, '_version_priority_list', None) or ('erp5 | 0.0',)
456 457

  security.declareProtected(Permissions.ModifyPortalContent,
458
                            'setVersionPriorityList' )
459
  def setVersionPriorityList(self, version_priority_tuple):
460
    """
461 462 463
    Set Version Priority List and make sure that erp5 version is always
    defined whatever the given value is

464 465
    XXX-arnau: must be written through an interaction workflow when ERP5Site
               will become a real ERP5 object...
466
    """
467 468 469 470 471 472 473 474 475 476
    if not isinstance(version_priority_tuple, tuple):
      version_priority_tuple = tuple(version_priority_tuple)

    # erp5 version must always be present, thus add it at the end if it's not
    # already there
    for version_priority in version_priority_tuple:
      if version_priority.split('|')[0].strip() == 'erp5':
        break
    else:
      version_priority_tuple = version_priority_tuple + ('erp5 | 0.0',)
477

478
    self._version_priority_list = version_priority_tuple
479

480 481 482 483 484 485
    # Reset cached value of getVersionPriorityNameList() if present
    try:
      del self._v_version_priority_name_list
    except AttributeError:
      pass

486
    # Make sure that reset is not performed when creating a new site
487
    if not getattr(self, '_v_bootstrapping', False):
488 489 490 491 492
      try:
        self.portal_components.resetOnceAtTransactionBoundary()
      except AttributeError:
        # This should only happen before erp5_core is installed
        pass
493

494 495
  version_priority_list = property(getVersionPriorityList,
                                   setVersionPriorityList)
496

497 498
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getVersionPriorityNameList')
499
  def getVersionPriorityNameList(self):
500 501 502 503 504 505 506 507 508
    """
    Get only the version names ordered by priority and cache it as it is used
    very often in Component import hooks
    """
    if getattr(self, '_v_version_priority_name_list', None) is None:
      self._v_version_priority_name_list = \
          [name.split('|')[0].strip() for name in self.getVersionPriorityList()]

    return self._v_version_priority_name_list
509

510 511 512 513 514 515
  security.declareProtected(Permissions.AccessContentsInformation, 'getUid')
  def getUid(self):
    """
      Returns the UID of the object. Eventually reindexes
      the object in order to make sure there is a UID
      (useful for import / export).
Jean-Paul Smets's avatar
Jean-Paul Smets committed
516

517 518 519
      WARNING : must be updates for circular references issues
    """
    return getattr(self, 'uid', 0)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
520

521
  security.declareProtected(Permissions.AccessContentsInformation,
522
                            'getParentUid')
523 524 525 526 527
  def getParentUid(self):
    """
      A portal has no parent
    """
    return self.getUid()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
528

529 530 531 532
  # Required to allow content creation outside folders
  security.declareProtected(Permissions.View, 'getIdGroup')
  def getIdGroup(self):
    return None
Jean-Paul Smets's avatar
Jean-Paul Smets committed
533

534 535 536 537
  # Required to allow content creation outside folders
  security.declareProtected(Permissions.ModifyPortalContent, 'setLastId')
  def setLastId(self, id):
    self.last_id = id
Jean-Paul Smets's avatar
Jean-Paul Smets committed
538

539 540
  security.declareProtected(Permissions.AccessContentsInformation, 'getUrl')
  def getUrl(self, REQUEST=None):
541 542 543 544
    """
      Returns the absolute path of an object
    """
    return join(self.getPhysicalPath(),'/')
Sebastien Robin's avatar
Sebastien Robin committed
545

546 547 548 549 550 551 552
  security.declareProtected(Permissions.AccessContentsInformation, 'getRelativeUrl')
  def getRelativeUrl(self):
    """
      Returns the url of an object relative to the portal site.
    """
    return self.getPortalObject().portal_url.getRelativeUrl(self)

553 554 555 556
  # Old name - for compatibility
  security.declareProtected(Permissions.AccessContentsInformation, 'getPath')
  getPath = getUrl

557 558 559 560 561 562
  security.declareProtected(Permissions.AccessContentsInformation, 'opaqueValues')
  def opaqueValues(self, *args, **kw):
    # XXX nonsense of inheriting from CMFSite that calls __before_traversal__
    # and tries to load subobjects of the portal too early
    return []

563
  security.declareProtected(Permissions.AccessContentsInformation, 'searchFolder')
564 565 566 567 568 569 570
  def searchFolder(self, **kw):
    """
      Search the content of a folder by calling
      the portal_catalog.
    """
    if not kw.has_key('parent_uid'):
      kw['parent_uid'] = self.uid
571
    return self.portal_catalog.searchResults(**kw)
572 573 574 575 576 577 578 579 580

  security.declareProtected(Permissions.AccessContentsInformation, 'countFolder')
  def countFolder(self, **kw):
    """
      Count the content of a folder by calling
      the portal_catalog.
    """
    if not kw.has_key('parent_uid'):
      kw['parent_uid'] = self.uid
581
    return self.portal_catalog.countResults(**kw)
582 583 584 585 586 587 588 589

  # Proxy methods for security reasons
  def getOwnerInfo(self):
    return self.owner_info()

  security.declarePublic('getOrderedGlobalActionList')
  def getOrderedGlobalActionList(self, action_list):
    """
590 591
    Returns a dictionnary of actions, sorted by type of object

592
    This should absolutely be rewritten by using clean
593
    concepts to separate worklists XXX
594 595 596 597 598 599
    """
    sorted_workflow_actions = {}
    sorted_global_actions = []
    other_global_actions = []
    for action in action_list:
      action['disabled'] = 0
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
600 601 602 603 604 605 606 607 608 609
      workflow_title = action.get('workflow_title', None)
      if workflow_title is not None:
        if not sorted_workflow_actions.has_key(workflow_title):
          sorted_workflow_actions[workflow_title] = [
            {'title':workflow_title,
             'disabled':1,
             'workflow_id':action['workflow_id']
             }
            ]
        sorted_workflow_actions[workflow_title].append(action)
610 611
      else:
        other_global_actions.append(action)
612
    for key in sorted(sorted_workflow_actions):
613 614 615 616 617 618
      sorted_global_actions.extend(sorted_workflow_actions[key])
    sorted_global_actions.append({'title': 'Others', 'disabled': 1})
    sorted_global_actions.extend(other_global_actions)
    return sorted_global_actions

  def setupDefaultProperties(self, p, title, description,
619 620 621
                             email_from_address, email_from_name,
                             validate_email
                             ):
622
    CMFSite.setupDefaultProperties(self, p, title, description,
623 624
                           email_from_address, email_from_name,
                           validate_email)
625

626 627 628
  # Portal methods are based on the concept of having portal-specific
  # parameters for customization. In the past, we used global parameters,
  # but it was not very good because it was very difficult
629
  # to customize the settings for each portal site.
630 631
  def _getPortalConfiguration(self, id):
    """
632
    Get a portal-specific configuration.
633

634 635
    Current implementation is using properties in a portal object.
    If not found, try to get a default value for backward compatibility.
636

637 638
    This implementation can be improved by gathering information
    from appropriate places, such as portal_types, portal_categories
639
    and portal_workflow.
640 641 642
    """
    if self.hasProperty(id):
      return self.getProperty(id)
643

644 645
    # Fall back to the default.
    return getattr(ERP5Defaults, id, None)
646

Romain Courteaud's avatar
Romain Courteaud committed
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
  security.declareProtected(Permissions.ManagePortal, 'getPromiseParameter')
  def getPromiseParameter(self, section, option):
    """
    Read external promise parameters.

    The parameters should be provided by an external configuration file.
    Location of this configuration file is defined in the zope configuration
    file in a product_config named as the path of the ERP5 site.
    Example if the site id is erp5:
      <product-config /erp5>
        promise_path /tmp/promise.cfg
      </product-config>

    The promise configuration is a simple ConfigParser readable file (a list of
    section containing a list of string parameters.

    getPromiseParameter returns None if the parameter isn't found.
    """
    config = getConfiguration()
    if getattr(config, 'product_config', None) is not None:
667
      parameter_dict = config.product_config.get(self.getPath(), {})
Romain Courteaud's avatar
Romain Courteaud committed
668 669 670 671 672 673 674 675 676 677 678
      if 'promise_path' in parameter_dict:
        promise_path = parameter_dict['promise_path']
        import ConfigParser
        configuration = ConfigParser.ConfigParser()
        configuration.read(promise_path)
        try:
          return configuration.get(section, option)
        except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
          pass
    return None

679
  def _getPortalGroupedTypeList(self, group, enable_sort=True):
680
    """
681
    Return a list of portal types classified to a specific group.
682 683
    The result is sorted by language (using the user language
    as default)
684 685 686

    Enable_sort parameter was added in order to allows looking groups
    of portal type without sorting. This is better for performance
687 688 689
    """
    def getTypeList(group):
      type_list = []
Sebastien Robin's avatar
Sebastien Robin committed
690
      for pt in self.portal_types.listTypeInfo():
691 692
        if group in getattr(pt, 'group_list', ()):
          type_list.append(pt.getId())
693

694 695 696 697
      if enable_sort and len(type_list) >= 2:
        # XXX (Seb), this code must be moved in another place.
        # It is inefficient to always sort here for some particular
        # needs of the user interface
Kazuhiko Shiozaki's avatar
Kazuhiko Shiozaki committed
698 699
        translate = localizer_tool.translate
        type_list.sort(key=lambda x:translate('ui', x))
700 701
      return tuple(type_list)

702 703
    if enable_sort:
      # language should be cached in Transaction Cache if performance issue
704
      localizer_tool = self.Localizer
705 706 707
      language = localizer_tool.get_selected_language()
    else:
      localizer_tool = language = None
708

709
    getTypeList = CachingMethod(getTypeList,
710 711 712 713
                                id=(('_getPortalGroupedTypeList', language), group,
                                    enable_sort),
                                cache_factory='erp5_content_medium',
                                )
714 715 716

    return getTypeList(group) # Although this method is called get*List, it
                              # returns a tuple - renaming to be considered
717

718 719 720 721 722 723 724 725 726
  @caching_instance_method(id='ERP5Site._getPortalGroupedTypeSet',
     cache_factory='erp5_content_long')
  def _getPortalGroupedTypeSet(self, group):
    """
    Same as _getPortalGroupedTypeList, but returns a set, better for
    performance when looking for matching portal types
    """
    return set(self._getPortalGroupedTypeList(group, enable_sort=False))

727
  def _getPortalGroupedCategoryList(self, group):
728
    """
729
    Return a list of base categories classified to a specific group.
730 731 732 733 734 735 736 737
    """
    def getCategoryList(group):
      category_list = []
      for bc in self.portal_categories.objectValues():
        if group in bc.getCategoryTypeList():
          category_list.append(bc.getId())
      return tuple(category_list)

738 739
    getCategoryList = CachingMethod(
                            getCategoryList,
740
                            id=('_getPortalGroupedCategoryList', group),
Aurel's avatar
Aurel committed
741
                            cache_factory='erp5_content_medium')
742 743 744
    return getCategoryList(group)

  def _getPortalGroupedStateList(self, group):
745
    """
746
    Return a list of workflow states classified to a specific group.
747 748 749 750 751 752 753 754 755 756
    """
    def getStateList(group):
      state_dict = {}
      for wf in self.portal_workflow.objectValues():
        if getattr(wf, 'states', None):
          for state in wf.states.objectValues():
            if group in getattr(state, 'type_list', ()):
              state_dict[state.getId()] = None
      return tuple(state_dict.keys())

757
    getStateList = CachingMethod(getStateList,
758
                                 id=('_getPortalGroupedStateList', group),
Aurel's avatar
Aurel committed
759
                                 cache_factory='erp5_content_medium')
760 761
    return getStateList(group)

762 763
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDefaultSectionCategory')
764 765
  def getPortalDefaultSectionCategory(self):
    """
766
    Return a default section category. This method is deprecated.
767 768 769 770
    """
    LOG('ERP5Site', 0, 'getPortalDefaultSectionCategory is deprecated;'+
        ' use portal_preferences.getPreferredSectionCategory instead.')
    section_category = self.portal_preferences.getPreferredSectionCategory()
771

772 773 774 775
    # XXX This is only for backward-compatibility.
    if not section_category:
      section_category = self._getPortalConfiguration(
                                'portal_default_section_category')
776

777
    return section_category
778

779 780 781 782 783 784
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalResourceTypeList')
  def getPortalResourceTypeList(self):
    """
      Return resource types.
    """
785 786 787
    return self._getPortalGroupedTypeList('resource') or \
           self._getPortalConfiguration('portal_resource_type_list')

788 789 790 791 792 793 794
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalSubVariationTypeList')
  def getPortalSubVariationTypeList(self):
    """
      Return resource types.
    """
    return self._getPortalGroupedTypeList('sub_variation')
795

796 797 798 799 800 801 802
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalSubVariationBaseCategoryList')
  def getPortalSubVariationBaseCategoryList(self):
    """
      Return variation base categories.
    """
    return self._getPortalGroupedCategoryList('sub_variation')
803

804 805 806 807 808 809
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalVariationTypeList')
  def getPortalVariationTypeList(self):
    """
      Return variation types.
    """
810 811 812
    return self._getPortalGroupedTypeList('variation') or \
           self._getPortalConfiguration('portal_variation_type_list')

813 814 815 816 817 818
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalNodeTypeList')
  def getPortalNodeTypeList(self):
    """
      Return node types.
    """
819 820 821
    return self._getPortalGroupedTypeList('node') or \
           self._getPortalConfiguration('portal_node_type_list')

822 823 824 825 826 827
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalPaymentNodeTypeList')
  def getPortalPaymentNodeTypeList(self):
    """
      Return payment node types.
    """
828 829 830
    return self._getPortalGroupedTypeList('payment_node') or \
           self._getPortalConfiguration('portal_payment_node_type_list')

831 832 833 834 835 836
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalInvoiceTypeList')
  def getPortalInvoiceTypeList(self):
    """
      Return invoice types.
    """
837 838 839
    return self._getPortalGroupedTypeList('invoice') or \
           self._getPortalConfiguration('portal_invoice_type_list')

840 841 842 843 844 845
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalOrderTypeList')
  def getPortalOrderTypeList(self):
    """
      Return order types.
    """
846 847 848
    return self._getPortalGroupedTypeList('order') or \
           self._getPortalConfiguration('portal_order_type_list')

849 850 851 852 853 854 855 856 857
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalOpenOrderTypeList')
  def getPortalOpenOrderTypeList(self):
    """
      Return open order types.
    """
    return self._getPortalGroupedTypeList('open_order') or \
           self._getPortalConfiguration('portal_open_order_type_list')

858 859 860 861 862 863
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDeliveryTypeList')
  def getPortalDeliveryTypeList(self):
    """
      Return delivery types.
    """
864 865 866
    return self._getPortalGroupedTypeList('delivery') or \
           self._getPortalConfiguration('portal_delivery_type_list')

867 868 869 870 871 872
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTransformationTypeList')
  def getPortalTransformationTypeList(self):
    """
      Return transformation types.
    """
873 874 875
    return self._getPortalGroupedTypeList('transformation') or \
           self._getPortalConfiguration('portal_transformation_type_list')

876 877 878 879 880 881 882 883 884
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalModelPathTypeList')
  def getPortalModelPathTypeList(self):
    """
      Return model_path types.
    """
    return self._getPortalGroupedTypeList('model_path') or \
           self._getPortalConfiguration('portal_model_path_type_list')

885 886 887 888 889 890
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalVariationBaseCategoryList')
  def getPortalVariationBaseCategoryList(self):
    """
      Return variation base categories.
    """
891 892 893
    return self._getPortalGroupedCategoryList('variation') or \
           self._getPortalConfiguration('portal_variation_base_category_list')

894 895 896 897 898 899
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalOptionBaseCategoryList')
  def getPortalOptionBaseCategoryList(self):
    """
      Return option base categories.
    """
900 901 902
    return self._getPortalGroupedCategoryList('option') or \
           self._getPortalConfiguration('portal_option_base_category_list')

903 904 905 906 907 908
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalInvoiceMovementTypeList')
  def getPortalInvoiceMovementTypeList(self):
    """
      Return invoice movement types.
    """
909 910 911
    return self._getPortalGroupedTypeList('invoice_movement') or \
           self._getPortalConfiguration('portal_invoice_movement_type_list')

912 913 914 915 916 917 918 919 920 921
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTaxMovementTypeList')
  def getPortalTaxMovementTypeList(self):
    """
      Return tax movement types.
    """
    return self._getPortalGroupedTypeList('tax_movement') or \
           self._getPortalConfiguration('portal_tax_movement_type_list')


922 923 924 925 926 927
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalOrderMovementTypeList')
  def getPortalOrderMovementTypeList(self):
    """
      Return order movement types.
    """
928 929 930
    return self._getPortalGroupedTypeList('order_movement') or \
           self._getPortalConfiguration('portal_order_movement_type_list')

931 932 933 934 935 936
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDeliveryMovementTypeList')
  def getPortalDeliveryMovementTypeList(self):
    """
      Return delivery movement types.
    """
937 938 939
    return self._getPortalGroupedTypeList('delivery_movement') or \
           self._getPortalConfiguration('portal_delivery_movement_type_list')

940
  security.declareProtected(Permissions.AccessContentsInformation,
941
                            'getPortalSupplyTypeList')
942 943 944 945
  def getPortalSupplyTypeList(self):
    """
      Return supply types.
    """
946 947 948
    return self._getPortalGroupedTypeList('supply') or \
           self._getPortalConfiguration('portal_supply_type_list')

949 950 951 952 953 954 955 956
  security.declareProtected(Permissions.AccessContentsInformation,
                              'getPortalConstraintTypeList')
  def getPortalConstraintTypeList(self):
    """
      Return rule types.
    """
    return self._getPortalGroupedTypeList('constraint')

957 958 959 960 961 962 963 964
  security.declareProtected(Permissions.AccessContentsInformation,
                              'getPortalRuleTypeList')
  def getPortalRuleTypeList(self):
    """
      Return rule types.
    """
    return self._getPortalGroupedTypeList('rule')

Jean-Paul Smets's avatar
Jean-Paul Smets committed
965 966 967 968
  security.declareProtected(Permissions.AccessContentsInformation,
                              'getPortalProjectTypeList')
  def getPortalProjectTypeList(self):
    """
969
      Return project types.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
970 971 972
    """
    return self._getPortalGroupedTypeList('project')

973
  security.declareProtected(Permissions.AccessContentsInformation,
974 975 976 977 978
                              'getPortalDocumentTypeList')
  def getPortalDocumentTypeList(self):
    """
      Return document types.
    """
979
    return self._getPortalGroupedTypeList('document')
980

981 982 983 984 985 986 987 988
  security.declareProtected(Permissions.AccessContentsInformation,
                              'getPortalEmbeddedDocumentTypeList')
  def getPortalEmbeddedDocumentTypeList(self):
    """
      Return embedded document types.
    """
    return self._getPortalGroupedTypeList('embedded_document')

989 990 991 992 993 994 995 996
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalWebDocumentTypeList')
  def getPortalWebDocumentTypeList(self):
    """
      Return web page types.
    """
    return self._getPortalGroupedTypeList('web_document')

997 998 999 1000
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalFileDocumentTypeList')
  def getPortalFileDocumentTypeList(self):
    """
1001
      Return file document types.
1002 1003 1004 1005 1006 1007 1008
    """
    return self._getPortalGroupedTypeList('file_document')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalRecentDocumentTypeList')
  def getPortalRecentDocumentTypeList(self):
    """
1009
      Return recent document types.
1010 1011 1012 1013 1014 1015 1016
    """
    return self._getPortalGroupedTypeList('recent_document')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTemplateDocumentTypeList')
  def getPortalTemplateDocumentTypeList(self):
    """
1017
      Return template document types.
1018 1019 1020 1021 1022 1023 1024
    """
    return self._getPortalGroupedTypeList('template_document')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalMyDocumentTypeList')
  def getPortalMyDocumentTypeList(self):
    """
1025
      Return my document types.
1026 1027 1028
    """
    return self._getPortalGroupedTypeList('my_document')

1029 1030 1031 1032
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalCrawlerIndexTypeList')
  def getPortalCrawlerIndexTypeList(self):
    """
1033
      Return crawler index types.
1034 1035 1036
    """
    return self._getPortalGroupedTypeList('crawler_index')

1037 1038 1039 1040 1041 1042 1043 1044
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalBudgetVariationTypeList')
  def getPortalBudgetVariationTypeList(self):
    """
      Return budget variation types.
    """
    return self._getPortalGroupedTypeList('budget_variation')

1045
  security.declareProtected(Permissions.AccessContentsInformation,
1046
                            'getPortalSupplyPathTypeList')
1047 1048
  def getPortalSupplyPathTypeList(self):
    """
1049
      Return supply path types.
1050
    """
1051 1052 1053
    return self._getPortalGroupedTypeList('supply_path') or \
           self._getPortalConfiguration('portal_supply_path_type_list')

1054 1055 1056 1057 1058 1059 1060
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalAcquisitionMovementTypeList')
  def getPortalAcquisitionMovementTypeList(self):
    """
      Return acquisition movement types.
    """
    return tuple(list(self.getPortalOrderMovementTypeList()) +
1061
                 list(self.getPortalDeliveryMovementTypeList()) +
1062
                 list(self.getPortalTaxMovementTypeList()) +
1063 1064
                 list(self.getPortalInvoiceMovementTypeList()))

1065 1066 1067 1068 1069 1070 1071
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalMovementTypeList')
  def getPortalMovementTypeList(self):
    """
      Return movement types.
    """
    return tuple(list(self.getPortalOrderMovementTypeList()) +
1072 1073
                 list(self.getPortalDeliveryMovementTypeList()) +
                 list(self.getPortalInvoiceMovementTypeList()) +
1074
                 list(self.getPortalTaxMovementTypeList()) +
1075
                 list(self.getPortalAccountingMovementTypeList()) +
1076
                 ['Simulation Movement'])
1077

1078 1079 1080 1081 1082 1083
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalSimulatedMovementTypeList')
  def getPortalSimulatedMovementTypeList(self):
    """
      Return simulated movement types.
    """
1084
    return tuple([x for x in self.getPortalMovementTypeList() \
1085
                  if x not in self.getPortalContainerTypeList()])
1086

1087 1088 1089 1090 1091 1092
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalContainerTypeList')
  def getPortalContainerTypeList(self):
    """
      Return container types.
    """
1093 1094 1095
    return self._getPortalGroupedTypeList('container') or \
           self._getPortalConfiguration('portal_container_type_list')

1096 1097 1098 1099 1100 1101
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalContainerLineTypeList')
  def getPortalContainerLineTypeList(self):
    """
      Return container line types.
    """
1102 1103 1104
    return self._getPortalGroupedTypeList('container_line') or \
           self._getPortalConfiguration('portal_container_line_type_list')

1105 1106 1107 1108 1109 1110
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalItemTypeList')
  def getPortalItemTypeList(self):
    """
      Return item types.
    """
1111 1112 1113
    return self._getPortalGroupedTypeList('item') or \
           self._getPortalConfiguration('portal_item_type_list')

1114 1115 1116 1117 1118 1119
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDiscountTypeList')
  def getPortalDiscountTypeList(self):
    """
      Return discount types.
    """
1120 1121 1122
    return self._getPortalGroupedTypeList('discount') or \
           self._getPortalConfiguration('portal_discount_type_list')

1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalProductTypeList')
  def getPortalProductTypeList(self):
    """
      Return physical goods types.
    """
    return self._getPortalGroupedTypeList('product') or \
           self._getPortalConfiguration('portal_product_type_list')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalServiceTypeList')
  def getPortalServiceTypeList(self):
    """
      Return immaterial services types.
    """
    return self._getPortalGroupedTypeList('service') or \
           self._getPortalConfiguration('portal_service_type_list')

1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalSaleTypeList')
  def getPortalSaleTypeList(self):
    """
    Return sale types.
    """
    return self._getPortalGroupedTypeList('sale')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalPurchaseTypeList')
  def getPortalPurchaseTypeList(self):
    """
    Return purchase types.
    """
    return self._getPortalGroupedTypeList('purchase')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalInternalTypeList')
  def getPortalInternalTypeList(self):
    """
    Return internal types.
    """
    return self._getPortalGroupedTypeList('internal')

1165 1166 1167 1168 1169 1170
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalAlarmTypeList')
  def getPortalAlarmTypeList(self):
    """
      Return alarm types.
    """
1171 1172 1173
    return self._getPortalGroupedTypeList('alarm') or \
           self._getPortalConfiguration('portal_alarm_type_list')

1174 1175 1176 1177 1178 1179
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalPaymentConditionTypeList')
  def getPortalPaymentConditionTypeList(self):
    """
      Return payment condition types.
    """
1180 1181 1182
    return self._getPortalGroupedTypeList('payment_condition') or \
           self._getPortalConfiguration('portal_payment_condition_type_list')

1183 1184 1185 1186 1187 1188
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalBalanceTransactionLineTypeList')
  def getPortalBalanceTransactionLineTypeList(self):
    """
      Return balance transaction line types.
    """
1189
    return self._getPortalGroupedTypeList('balance_transaction_line') or \
1190 1191
           self._getPortalConfiguration(
                  'portal_balance_transaction_line_type_list')
1192

1193 1194 1195 1196 1197 1198
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalCurrentInventoryStateList')
  def getPortalCurrentInventoryStateList(self):
    """
      Return current inventory states.
    """
1199 1200 1201
    return self._getPortalGroupedStateList('current_inventory') or \
           self._getPortalConfiguration('portal_current_inventory_state_list')

1202 1203 1204 1205 1206 1207 1208 1209 1210
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTransitInventoryStateList')
  def getPortalTransitInventoryStateList(self):
    """
      Return transit inventory states.
    """
    return self._getPortalGroupedStateList('transit_inventory') or \
           self._getPortalConfiguration('portal_transit_inventory_state_list')

1211 1212 1213 1214 1215 1216
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDraftOrderStateList')
  def getPortalDraftOrderStateList(self):
    """
      Return draft order states.
    """
1217 1218 1219
    return self._getPortalGroupedStateList('draft_order') or \
           self._getPortalConfiguration('portal_draft_order_state_list')

1220 1221 1222 1223 1224 1225
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalPlannedOrderStateList')
  def getPortalPlannedOrderStateList(self):
    """
      Return planned order states.
    """
1226 1227 1228
    return self._getPortalGroupedStateList('planned_order') or \
           self._getPortalConfiguration('portal_planned_order_state_list')

1229 1230 1231 1232 1233 1234
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalReservedInventoryStateList')
  def getPortalReservedInventoryStateList(self):
    """
      Return reserved inventory states.
    """
1235
    return self._getPortalGroupedStateList('reserved_inventory') or \
1236
        self._getPortalConfiguration('portal_reserved_inventory_state_list')
1237

1238 1239 1240 1241 1242 1243
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalFutureInventoryStateList')
  def getPortalFutureInventoryStateList(self):
    """
      Return future inventory states.
    """
1244 1245 1246
    return self._getPortalGroupedStateList('future_inventory') or \
           self._getPortalConfiguration('portal_future_inventory_state_list')

1247
  security.declareProtected(Permissions.AccessContentsInformation,
1248
                          'getPortalUpdatableAmortisationTransactionStateList')
1249 1250
  def getPortalUpdatableAmortisationTransactionStateList(self):
    """
1251
      Return states when Amortisation Transaction can be updated
1252
      by amortisation_transaction_builder.
1253
    """
1254 1255
    return self._getPortalConfiguration(
        'portal_updatable_amortisation_transaction_state_list')
1256

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalGroupedSimulationStateList')
  def getPortalGroupedSimulationStateList(self):
    """
      Return all states which is related to simulation state workflow and state type
    """
    def getStateList():
      state_dict = {}
      for wf in self.portal_workflow.objectValues():
        if getattr(wf, 'variables', None) and \
           wf.variables.getStateVar() == 'simulation_state':
          if getattr(wf, 'states', None):
            for state in wf.states.objectValues():
              if getattr(state, 'type_list', None):
                state_dict[state.getId()] = None
      return tuple(sorted(state_dict.keys()))

    getStateList = CachingMethod(getStateList,
                                 id=('getPortalGroupedSimulationStateList'),
                                 cache_factory='erp5_content_medium')
    return getStateList()

1279 1280 1281 1282 1283 1284
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalColumnBaseCategoryList')
  def getPortalColumnBaseCategoryList(self):
    """
      Return column base categories.
    """
1285 1286 1287
    return self._getPortalGroupedCategoryList('column') or \
           self._getPortalConfiguration('portal_column_base_category_list')

1288 1289 1290 1291 1292 1293
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalLineBaseCategoryList')
  def getPortalLineBaseCategoryList(self):
    """
      Return line base categories.
    """
1294 1295 1296
    return self._getPortalGroupedCategoryList('line') or \
           self._getPortalConfiguration('portal_line_base_category_list')

1297 1298 1299 1300 1301 1302
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTabBaseCategoryList')
  def getPortalTabBaseCategoryList(self):
    """
      Return tab base categories.
    """
1303 1304 1305
    return self._getPortalGroupedCategoryList('tab') or \
           self._getPortalConfiguration('portal_tab_base_category_list')

1306 1307 1308 1309
  def getPortalDefaultGapRoot(self):
    """
      Return the Accounting Plan to use by default (return the root node)
    """
1310
    LOG('ERP5Site', 0,
1311 1312 1313
        'getPortalDefaultGapRoot is deprecated; ' \
        'use portal_preferences.getPreferredAccountingTransactionGap instead.')

1314 1315
    return self.portal_preferences.getPreferredAccountingTransactionGap() or \
           self._getPortalConfiguration('portal_default_gap_root')
1316

1317 1318 1319 1320
  def getPortalAccountingMovementTypeList(self) :
    """
      Return accounting movement type list.
    """
1321
    return self._getPortalGroupedTypeList('accounting_movement') or \
1322
        self._getPortalConfiguration('portal_accounting_movement_type_list')
1323

1324 1325 1326 1327
  def getPortalAccountingTransactionTypeList(self) :
    """
      Return accounting transaction movement type list.
    """
1328
    return self._getPortalGroupedTypeList('accounting_transaction') or \
1329
      self._getPortalConfiguration('portal_accounting_transaction_type_list')
1330

1331 1332 1333 1334
  def getPortalAssignmentBaseCategoryList(self):
    """
      Return List of category values to generate security groups.
    """
1335
    return self._getPortalGroupedCategoryList('assignment') or \
1336
        self._getPortalConfiguration('portal_assignment_base_category_list')
1337

1338 1339
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTicketTypeList')
1340 1341 1342 1343 1344
  def getPortalTicketTypeList(self):
    """
    Return ticket types.
    """
    return self._getPortalGroupedTypeList('ticket')
1345

1346 1347
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalEventTypeList')
1348 1349 1350 1351 1352
  def getPortalEventTypeList(self):
    """
    Return event types.
    """
    return self._getPortalGroupedTypeList('event')
1353

1354 1355 1356 1357 1358 1359 1360 1361
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalDivergenceTesterTypeList')
  def getPortalDivergenceTesterTypeList(self):
    """
    Return divergence tester types.
    """
    return self._getPortalGroupedTypeList('divergence_tester')

1362 1363 1364 1365 1366 1367 1368 1369
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTargetSolverTypeList')
  def getPortalTargetSolverTypeList(self):
    """
    Return target solver types.
    """
    return self._getPortalGroupedTypeList('target_solver')

Sebastien Robin's avatar
Sebastien Robin committed
1370 1371 1372 1373 1374 1375 1376 1377
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTargetSolverTypeList')
  def getPortalDeliverySolverTypeList(self):
    """
    Return delivery solver types.
    """
    return self._getPortalGroupedTypeList('delivery_solver')

1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalAmountGeneratorTypeList')
  def getPortalAmountGeneratorTypeList(self):
    """
    Return amount generator types.
    """
    return self._getPortalGroupedTypeList('amount_generator')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalAmountGeneratorLineTypeList')
  def getPortalAmountGeneratorLineTypeList(self):
    """
    Return amount generator line types.
    """
    return self._getPortalGroupedTypeList('amount_generator_line')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalAmountGeneratorCellTypeList')
  def getPortalAmountGeneratorCellTypeList(self):
    """
    Return amount generator cell types.
    """
    return self._getPortalGroupedTypeList('amount_generator_cell')

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1402 1403 1404 1405 1406 1407 1408 1409
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalBusinessProcessTypeList')
  def getPortalBusinessProcessTypeList(self):
    """
    Return amount generator types.
    """
    return self._getPortalGroupedTypeList('business_process')

1410

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1411
  security.declareProtected(Permissions.AccessContentsInformation,
1412 1413
                            'getPortalBusinessLinkTypeList')
  def getPortalBusinessLinkTypeList(self):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1414
    """
1415 1416 1417 1418 1419 1420 1421 1422 1423
      Return business link types.
    """
    return self._getPortalGroupedTypeList('business_link')

  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalTradeModelPathTypeList')
  def getPortalTradeModelPathTypeList(self):
    """
      Return trade model path types.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1424
    """
1425
    return self._getPortalGroupedTypeList('trade_model_path')
Jean-Paul Smets's avatar
Jean-Paul Smets committed
1426

1427 1428 1429 1430 1431 1432 1433 1434
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalCalendarPeriodTypeList')
  def getPortalCalendarPeriodTypeList(self):
    """
    Return calendar period types.
    """
    return self._getPortalGroupedTypeList('calendar_period')

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1435 1436 1437 1438 1439 1440 1441 1442
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalModuleTypeList')
  def getPortalModuleTypeList(self):
    """
    Return module types.
    """
    return self._getPortalGroupedTypeList('module')

1443 1444 1445 1446 1447 1448 1449 1450
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalInventoryMovementTypeList')
  def getPortalInventoryMovementTypeList(self):
    """
    Return inventory movement types.
    """
    return self._getPortalGroupedTypeList('inventory_movement')

Sebastien Robin's avatar
Sebastien Robin committed
1451 1452 1453 1454 1455 1456 1457 1458
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalInventoryTypeList')
  def getPortalInventoryTypeList(self):
    """
    Return inventory types.
    """
    return self._getPortalGroupedTypeList('inventory')

1459 1460 1461 1462 1463 1464 1465 1466
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalMovementGroupTypeList')
  def getPortalMovementGroupTypeList(self):
    """
    Return movement group types.
    """
    return self._getPortalGroupedTypeList('movement_group')

1467 1468 1469 1470 1471 1472 1473 1474 1475
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getPortalEntityTypeList')
  def getPortalEntityTypeList(self):
    """
    Returns Entity types.
    """
    return self._getPortalGroupedTypeList('entity') or\
           self._getPortalConfiguration('portal_entity_type_list')

1476 1477
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getDefaultModuleId')
1478 1479
  def getDefaultModuleId(self, portal_type, default=MARKER):
    """
Romain Courteaud's avatar
Romain Courteaud committed
1480 1481
    Return default module id where a object with portal_type can
    be created.
1482 1483
    """
    portal_object = self
Romain Courteaud's avatar
Romain Courteaud committed
1484 1485 1486 1487 1488
    module_id = None
    # first try to find by naming convention
    expected_module_id = portal_type.lower().replace(' ','_')
    if portal_object._getOb(expected_module_id, None) is not None:
      module_id = expected_module_id
1489 1490 1491 1492 1493 1494
    else:
      expected_module_id += '_module'
      if portal_object._getOb(expected_module_id, None) is not None:
        module_id = expected_module_id
      # then look for module where the type is allowed
      else:
1495
        for expected_module_id in portal_object.objectIds(('ERP5 Folder',)):
1496 1497 1498 1499 1500 1501
          module = portal_object._getOb(expected_module_id, None)
          if module is not None:
            if portal_type in self.portal_types[module.getPortalType()].\
                                      allowed_content_types:
              module_id = expected_module_id
              break
Romain Courteaud's avatar
Romain Courteaud committed
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514

    if module_id is None:
      if default is not MARKER:
        return default
      else:
        # now we fail
        LOG('ERP5Site, getDefaultModuleId', 0,
            'Unable to find default module for portal_type: %s' % \
             portal_type)
        raise ValueError, 'Unable to find module for portal_type: %s' % \
               portal_type

    return module_id
1515

1516 1517
  security.declareProtected(Permissions.AccessContentsInformation,
                            'getDefaultModule')
1518
  def getDefaultModule(self, portal_type, default=MARKER):
1519 1520 1521
    """
      Return default module where a object with portal_type can be created
    """
1522 1523 1524 1525
    module_id = self.getDefaultModuleId(portal_type, default)
    if module_id:
      return getattr(self, module_id, None)
    return None
1526

1527
  security.declareProtected(Permissions.AddPortalContent, 'newContent')
1528
  def newContent(self, id=None, portal_type=None, **kw):
1529 1530 1531 1532 1533 1534 1535
    """
      Creates a new content
    """
    if id is None:
      raise ValueError, 'The id should not be None'
    if portal_type is None:
      raise ValueError, 'The portal_type should not be None'
1536 1537 1538 1539
    self.portal_types.constructContent(type_name=portal_type,
                                       container=self,
                                       id=id,
                                       ) # **kw) removed due to CMF bug
1540
    new_instance = self[id]
1541

1542
    if kw:
1543
      new_instance._edit(force_update=1, **kw)
1544 1545
    return new_instance

1546 1547 1548 1549 1550 1551
  security.declarePublic('getVisibleAllowedContentTypeList')
  def getVisibleAllowedContentTypeList(self):
    """Users cannot add anything in an ERP5Site using standard interface.
    """
    return ()

1552 1553 1554 1555 1556 1557
  def log(self, description, content='', level=INFO):
    """Put a log message """
    warnings.warn("The usage of ERP5Site.log is deprecated.\n"
                  "Please use Products.ERP5Type.Log.log instead.",
                  DeprecationWarning)
    unrestrictedLog(description, content = content, level = level)
1558

1559 1560 1561 1562 1563
  security.declarePublic('setPlacelessDefaultReindexParameters')
  def setPlacelessDefaultReindexParameters(self, **kw):
    # This method sets the default keyword parameters to reindex. This is useful
    # when you need to specify special parameters implicitly (e.g. to reindexObject).
    # Those parameters will affect all reindex calls, not just ones on self.
1564
    tv = getTransactionalVariable()
1565 1566 1567 1568 1569 1570 1571
    key = ('default_reindex_parameter', )
    tv[key] = kw

  security.declarePublic('getPlacelessDefaultReindexParameters')
  def getPlacelessDefaultReindexParameters(self):
    # This method returns default reindex parameters to self.
    # The result can be either a dict object or None.
1572
    tv = getTransactionalVariable()
1573 1574 1575
    key = ('default_reindex_parameter', )
    return tv.get(key)

1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
  security.declareProtected(Permissions.ManagePortal, 'getERP5SiteGlobalId')
  def getERP5SiteGlobalId(self):
    """Returns site global ID without any fallback"""
    return getattr(self, 'erp5_site_global_id', None)

  security.declareProtected(Permissions.ManagePortal, 'setERP5SiteGlobalId')
  def setERP5SiteGlobalId(self, global_id):
    """Sets site global ID, only in case if not set yet
    
    Such id should be very big and random, for example uuid version 4, as
    defined in RFC 4122.
    """
    if self.getERP5SiteGlobalId() in [None, '']:
      self.erp5_site_global_id = global_id

1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
  security.declareProtected(Permissions.ManagePortal,
                            'migrateToPortalTypeClass')
  def migrateToPortalTypeClass(self):
    from Products.ERP5Type.dynamic.persistent_migration import PickleUpdater
    from Products.ERP5Type.Tool.BaseTool import BaseTool
    PickleUpdater(self)
    for tool in self.objectValues():
      if isinstance(tool, BaseTool):
        tool_id = tool.id
        if tool_id != 'portal_property_sheets':
          if tool_id in ('portal_categories', ):
            tool = tool.activate()
          tool.migrateToPortalTypeClass(tool_id not in (
            'portal_activities', 'portal_simulation', 'portal_templates',
            'portal_trash'))
          if tool_id in ('portal_trash',):
            for obj in tool.objectValues():
              obj.migrateToPortalTypeClass()
1609

Jean-Paul Smets's avatar
Jean-Paul Smets committed
1610 1611
Globals.InitializeClass(ERP5Site)

1612 1613 1614 1615 1616 1617 1618
def getBootstrapDirectory():
  """
    Return the name of the bootstrap directory
  """
  product_path = package_home(globals())
  return os.path.join(product_path, 'bootstrap')

1619 1620 1621 1622 1623 1624 1625 1626
def getBootstrapBusinessTemplateUrl(bt_title):
  """
    Return the path to download the given bootstrap business template
  """
  path = os.path.join(getBootstrapDirectory(), bt_title)
  if not os.path.exists(path):
    path += '.bt5'
  return path
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719

# This PortalGenerator class was copied wholesale from CMF 1.5 which is
# identical to the one on 1.6, and hasn't been used by CMF itself since even
# 1.5, as they already used CMFSetup by then (later replaced by GenericSetup).


factory_type_information = () # No original CMF portal_types installed by default

class PortalGenerator:

    klass = CMFSite

    def setupTools(self, p):
        """Set up initial tools"""

        addCMFCoreTool = p.manage_addProduct['CMFCore'].manage_addTool
        addCMFCoreTool('CMF Actions Tool', None)
        addCMFCoreTool('CMF Catalog', None)
        addCMFCoreTool('CMF Member Data Tool', None)
        addCMFCoreTool('CMF Skins Tool', None)
        addCMFCoreTool('CMF Undo Tool', None)
        addCMFCoreTool('CMF URL Tool', None)
        addCMFCoreTool('CMF Workflow Tool', None)

        addCMFDefaultTool = p.manage_addProduct['CMFDefault'].manage_addTool
        addCMFDefaultTool('Default Discussion Tool', None)
        addCMFDefaultTool('Default Membership Tool', None)
        addCMFDefaultTool('Default Registration Tool', None)
        addCMFDefaultTool('Default Properties Tool', None)
        addCMFDefaultTool('Default Metadata Tool', None)
        addCMFDefaultTool('Default Syndication Tool', None)

        # try to install CMFUid without raising exceptions if not available
        try:
            addCMFUidTool = p.manage_addProduct['CMFUid'].manage_addTool
        except AttributeError:
            pass
        else:
            addCMFUidTool('Unique Id Annotation Tool', None)
            addCMFUidTool('Unique Id Generator Tool', None)
            addCMFUidTool('Unique Id Handler Tool', None)

    def setupMailHost(self, p):
        p.manage_addProduct['MailHost'].manage_addMailHost(
            'MailHost', smtp_host='localhost')

    def setupUserFolder(self, p):
        p.manage_addProduct['OFSP'].manage_addUserFolder()

    def setupCookieAuth(self, p):
        p.manage_addProduct['CMFCore'].manage_addCC(
            id='cookie_authentication')

    def setupRoles(self, p):
        # Set up the suggested roles.
        p.__ac_roles__ = ('Member', 'Reviewer',)

    def setupMimetypes(self, p):
        p.manage_addProduct[ 'CMFCore' ].manage_addRegistry()
        reg = p.content_type_registry

        reg.addPredicate( 'link', 'extension' )
        reg.getPredicate( 'link' ).edit( extensions="url, link" )
        reg.assignTypeName( 'link', 'Link' )

        reg.addPredicate( 'news', 'extension' )
        reg.getPredicate( 'news' ).edit( extensions="news" )
        reg.assignTypeName( 'news', 'News Item' )

        reg.addPredicate( 'document', 'major_minor' )
        reg.getPredicate( 'document' ).edit( major="text", minor="" )
        reg.assignTypeName( 'document', 'Document' )

        reg.addPredicate( 'image', 'major_minor' )
        reg.getPredicate( 'image' ).edit( major="image", minor="" )
        reg.assignTypeName( 'image', 'Image' )

        reg.addPredicate( 'file', 'major_minor' )
        reg.getPredicate( 'file' ).edit( major="application", minor="" )
        reg.assignTypeName( 'file', 'File' )

    def setupDefaultProperties(self, p, title, description,
                               email_from_address, email_from_name,
                               validate_email, default_charset=''):
        p._setProperty('email_from_address', email_from_address, 'string')
        p._setProperty('email_from_name', email_from_name, 'string')
        p._setProperty('validate_email', validate_email and 1 or 0, 'boolean')
        p._setProperty('default_charset', default_charset, 'string')
        p._setProperty('enable_permalink', 0, 'boolean')
        p.title = title
        p.description = description


Jean-Paul Smets's avatar
Jean-Paul Smets committed
1720 1721
class ERP5Generator(PortalGenerator):

1722
  klass = ERP5Site
1723

1724 1725 1726
  def create(self,
             parent,
             id,
1727
             create_userfolder,
1728
             erp5_catalog_storage,
1729
             erp5_sql_connection_type,
1730
             erp5_sql_connection_string,
1731
             erp5_sql_deferred_connection_type,
1732 1733
             cmf_activity_sql_connection_type,
             cmf_activity_sql_connection_string,
1734
             create_activities=True,
1735 1736
             reindex=1,
             **kw):
1737 1738
    id = str(id)
    portal = self.klass(id=id)
1739 1740
    # Make sure reindex will not be called until business templates
    # will be installed
1741
    setattr(portal, 'isIndexable', ConstantGetter('isIndexable', value=False))
1742 1743 1744 1745 1746 1747 1748

    # This is only used to refine log level.
    # Has no functional use, and should never have any:
    # if you use it for something else than a logging-oriented hint,
    # trolls *will* chase you and haunt you in your dreams
    portal._v_bootstrapping = True

1749 1750 1751
    parent._setObject(id, portal)
    # Return the fully wrapped object.
    p = parent.this()._getOb(id)
1752

1753 1754 1755 1756 1757 1758
    # setProperty cannot be used for this property as it is a property object
    # to _version_priority_list and valid_property_id doesn't accept property
    # name starting with '_'. The property getter always returns at least erp5
    # version so it only needs to be added to local properties
    p._local_properties = getattr(self, '_local_properties', ()) + \
        ({'id': 'version_priority_list', 'type': 'lines'},)
1759

1760
    erp5_sql_deferred_connection_string = erp5_sql_connection_string
1761 1762
    p._setProperty('erp5_catalog_storage',
                   erp5_catalog_storage, 'string')
1763
    p._setProperty('erp5_sql_connection_type',
1764
                   erp5_sql_connection_type, 'string')
1765
    p._setProperty('erp5_sql_connection_string',
1766
                   erp5_sql_connection_string, 'string')
1767
    p._setProperty('erp5_sql_deferred_connection_type',
1768
                   erp5_sql_deferred_connection_type, 'string')
1769
    p._setProperty('erp5_sql_deferred_connection_string',
1770
                   erp5_sql_deferred_connection_string, 'string')
1771
    p._setProperty('cmf_activity_sql_connection_type',
1772
                   cmf_activity_sql_connection_type, 'string')
1773
    p._setProperty('cmf_activity_sql_connection_string',
1774
                   cmf_activity_sql_connection_string, 'string')
1775
    p._setProperty('management_page_charset', 'UTF-8', 'string')
1776 1777
    self.setup(p, create_userfolder, create_activities=create_activities,
        reindex=reindex, **kw)
1778 1779 1780

    p._v_bootstrapping = False

1781 1782
    return p

1783 1784
  @classmethod
  def bootstrap(cls, context, bt_name, item_name, content_id_list):
1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
    bt_path = getBootstrapBusinessTemplateUrl(bt_name)
    from Products.ERP5.Document.BusinessTemplate import quote
    traverse = context.unrestrictedTraverse
    top = os.path.join(bt_path, item_name, context.id)
    prefix_len = len(os.path.join(top, ''))
    for root, dirs, files in os.walk(top):
      container_path = root[prefix_len:]
      load = traverse(container_path)._importObjectFromFile
      if container_path:
        id_set = set(x[:-4] for x in files if x[-4:] == '.xml')
      else:
        id_set = set(quote(x) for x in content_id_list
                              if not context.hasObject(x))
      dirs[:] = id_set.intersection(dirs)
      for file in id_set:
        load(os.path.join(root, file + '.xml'),
             verify=False, set_owner=False, suppress_events=True)
1802 1803

  def setupLastTools(self, p, **kw):
1804
    """
1805 1806 1807
    Set up finals tools
    We want to set the activity tool only at the end to
    make sure that we do not put un the queue the full reindexation
1808
    """
1809 1810 1811 1812
    addERP5Tool(p, 'portal_rules', 'Rule Tool')
    addERP5Tool(p, 'portal_simulation', 'Simulation Tool')
    addERP5Tool(p, 'portal_deliveries', 'Delivery Tool')
    addERP5Tool(p, 'portal_orders', 'Order Tool')
1813

1814 1815
  def setupTemplateTool(self, p, **kw):
    """
1816
    Setup the Template Tool. Security must be set strictly.
1817
    """
1818
    addERP5Tool(p, 'portal_templates', 'Template Tool')
1819 1820 1821 1822 1823 1824 1825
    context = p.portal_templates
    permission_list = context.possible_permissions()
    for permission in permission_list:
      context.manage_permission(permission, ['Manager'], 0)

  def setupTools(self, p,**kw):
    """
1826
    Set up initial tools.
1827 1828 1829 1830
    """
    if not 'portal_actions' in p.objectIds():
      PortalGenerator.setupTools(self, p)

1831
    # It is better to remove portal_catalog
1832
    # which is ZCatalog as soon as possible,
1833
    # because the API is not the completely same as ERP5Catalog,
1834
    # and ZCatalog is useless for ERP5 after all.
1835
    update = kw.get('update', 0)
1836 1837 1838 1839 1840
    try:
      if p.portal_catalog.meta_type != 'ZSQLCatalog' and not update:
        p._delObject('portal_catalog')
    except AttributeError:
      pass
1841 1842 1843

    # Add CMF Report Tool
    if not p.hasObject('portal_report'):
1844 1845 1846 1847 1848
      try:
        addTool = p.manage_addProduct['CMFReportTool'].manage_addTool
        addTool('CMF Report Tool', None)
      except AttributeError:
        pass
1849 1850

    # Add ERP5 Tools
1851 1852
    addERP5Tool(p, 'portal_categories', 'Category Tool')
    addERP5Tool(p, 'portal_ids', 'Id Tool')
1853 1854
    if not p.hasObject('portal_templates'):
      self.setupTemplateTool(p)
1855 1856 1857 1858 1859
    addERP5Tool(p, 'portal_trash', 'Trash Tool')
    addERP5Tool(p, 'portal_alarms', 'Alarm Tool')
    addERP5Tool(p, 'portal_domains', 'Domain Tool')
    addERP5Tool(p, 'portal_tests', 'Test Tool')
    addERP5Tool(p, 'portal_password', 'Password Tool')
1860
    addERP5Tool(p, 'portal_introspections', 'Introspection Tool')
1861
    addERP5Tool(p, 'portal_acknowledgements', 'Acknowledgement Tool')
Aurel's avatar
Aurel committed
1862

1863
    # Add ERP5Type Tool
1864 1865
    addERP5Tool(p, 'portal_caches', 'Cache Tool')
    addERP5Tool(p, 'portal_memcached', 'Memcached Tool')
1866

1867
    # Add ERP5Type Tools
1868 1869 1870 1871
    if allowClassTool():
      addERP5Tool(p, 'portal_classes', 'Class Tool')
    else:
      addERP5Tool(p, 'portal_classes', 'Dummy Class Tool')
1872 1873 1874 1875 1876

    # Add ERP5 SQL Catalog Tool
    addTool = p.manage_addProduct['ERP5Catalog'].manage_addTool
    if not p.hasObject('portal_catalog'):
      addTool('ERP5 Catalog', None)
Aurel's avatar
Aurel committed
1877

1878 1879 1880
    # Add Default SQL connection
    if p.erp5_sql_connection_type == 'Z MySQL Database Connection':
      if not p.hasObject('erp5_sql_connection'):
1881 1882
        addSQLConnection = p.manage_addProduct['ZMySQLDA'].\
                                     manage_addZMySQLConnection
1883 1884
        addSQLConnection('erp5_sql_connection',
                         'ERP5 SQL Server Connection',
1885
                         p.erp5_sql_connection_string)
1886 1887
    elif p.erp5_sql_connection_type == 'Z Gadfly':
      pass
1888 1889

    # Add Deferred SQL Connections
1890 1891
    if p.erp5_sql_deferred_connection_type == \
        'Z MySQL Deferred Database Connection':
1892
      if not p.hasObject('erp5_sql_deferred_connection'):
1893 1894
        addSQLConnection = p.manage_addProduct['ZMySQLDA'].\
            manage_addZMySQLConnection
1895 1896
        addSQLConnection('erp5_sql_deferred_connection',
                         'ERP5 SQL Server Deferred Connection',
1897 1898
                         p.erp5_sql_deferred_connection_string,
                         deferred=True)
1899 1900 1901 1902
    elif p.erp5_sql_deferred_connection_type == 'Z Gadfly':
      pass

    # Add Activity SQL Connections
1903 1904
    if p.cmf_activity_sql_connection_type == 'Z MySQL Database Connection':
      if not p.hasObject('cmf_activity_sql_connection'):
1905 1906
        addSQLConnection = p.manage_addProduct['CMFActivity'].\
                                     manage_addActivityConnection
1907 1908
        addSQLConnection('cmf_activity_sql_connection',
                         'CMF Activity SQL Server Connection',
1909
                         p.cmf_activity_sql_connection_string)
1910 1911 1912 1913 1914
      # Warning : This transactionless connection is created with
      # the activity connection string and not the catalog's because
      # it's not compatible with the hot reindexing feature.
      # Though, it has nothing to do with activities.
      # The only difference compared to activity connection is the
Vincent Pelletier's avatar
Vincent Pelletier committed
1915
      # minus prepended to the connection string.
1916 1917 1918 1919 1920
      if not p.hasObject('erp5_sql_transactionless_connection'):
        addSQLConnection = p.manage_addProduct['ZMySQLDA'].\
                                     manage_addZMySQLConnection
        addSQLConnection('erp5_sql_transactionless_connection',
                         'ERP5 Transactionless SQL Server Connection',
Vincent Pelletier's avatar
Typo.  
Vincent Pelletier committed
1921
                         '-%s' % p.cmf_activity_sql_connection_string)
1922 1923
    elif p.cmf_activity_sql_connection_type == 'Z Gadfly':
      pass
1924

1925
    # Add ERP5Form Tools
1926 1927
    addERP5Tool(p, 'portal_selections', 'Selection Tool')
    addERP5Tool(p, 'portal_preferences', 'Preference Tool')
1928 1929 1930 1931 1932

    # Add Message Catalog
    if not 'Localizer' in p.objectIds():
      addLocalizer = p.manage_addProduct['Localizer'].manage_addLocalizer
      addLocalizer('', ('en',))
1933
    localizer = p.Localizer
1934 1935
    addMessageCatalog = localizer.manage_addProduct['Localizer']\
                                      .manage_addMessageCatalog
1936 1937 1938
    if 'erp5_ui' not in localizer.objectIds():
      if 'default' in localizer.objectIds():
        localizer.manage_delObjects('default')
1939 1940 1941
      addMessageCatalog('default', 'ERP5 Localized Messages', ('en',))
      addMessageCatalog('erp5_ui', 'ERP5 Localized Interface', ('en',))
      addMessageCatalog('erp5_content', 'ERP5 Localized Content', ('en',))
1942

1943 1944 1945
    # Add an error_log
    if 'error_log' not in p.objectIds():
      manage_addErrorLog(p)
1946 1947 1948 1949
      p.error_log.setProperties(keep_entries=20,
                                copy_to_zlog=True,
                                ignored_exceptions=('NotFound', 'Redirect'))

1950 1951 1952

    # Remove unused default actions
    def removeActionsFromTool(tool, remove_list):
1953 1954 1955 1956 1957
      from Products.CMFCore.interfaces import IActionProvider
      if not IActionProvider.providedBy(tool):
        # On CMF 2.x, some tools (portal_membership)
        # are no longer action providers
        return
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
      action_id_list = [i.id for i in tool.listActions()]
      remove_index_list = []
      for i in remove_list:
        if i in action_id_list:
          remove_index_list.append(action_id_list.index(i))
      if remove_index_list:
        tool.deleteActions(remove_index_list)
    # membership tool
    removeActionsFromTool(p.portal_membership,
                          ('addFavorite', 'mystuff', 'favorites', 'logged_in',
                           'manage_members'))
    # actions tool
    removeActionsFromTool(p.portal_actions, ('folderContents',))
1971 1972
    # properties tool
    removeActionsFromTool(p.portal_properties, ('configPortal',))
1973 1974 1975 1976
    # remove unused action providers
    for i in ('portal_registration', 'portal_discussion', 'portal_syndication'):
      p.portal_actions.deleteActionProvider(i)

1977 1978
  def setupMembersFolder(self, p):
    """
1979
    ERP5 is not a CMS
1980 1981 1982
    """
    pass

1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
  # this lists only the skin layers of Products.CMFDefault we are actually
  # interested in.
  CMFDEFAULT_FOLDER_LIST = [ 'zpt_content'
                           , 'zpt_generic'
                           , 'zpt_control'
                           , 'Images'
                           ]
  def addCMFDefaultDirectoryViews(self, p):
    """Semi-manually create DirectoryViews since CMFDefault 2.X no longer
    registers the "skins" directory, only its subdirectories, making it
    unusable with Products.CMFCore.DirectoryView.addDirectoryViews."""
1994
    from Products.CMFCore.DirectoryView import createDirectoryView, _generateKey
1995 1996
    import Products.CMFDefault

1997
    ps = p.portal_skins
1998 1999
    # get the layer directories actually present
    for cmfdefault_skin_layer in self.CMFDEFAULT_FOLDER_LIST:
2000 2001
      reg_key = _generateKey(Products.CMFDefault.__name__,
                             'skins/' + cmfdefault_skin_layer)
2002 2003
      createDirectoryView(ps, reg_key)

2004 2005 2006
  def setupDefaultSkins(self, p):
    from Products.CMFCore.DirectoryView import addDirectoryViews
    from Products.CMFActivity import cmfactivity_globals
2007
    ps = p.portal_skins
2008
    self.addCMFDefaultDirectoryViews(p)
2009 2010 2011
    addDirectoryViews(ps, 'skins', cmfactivity_globals)
    ps.manage_addProduct['OFSP'].manage_addFolder(id='external_method')
    ps.manage_addProduct['OFSP'].manage_addFolder(id='custom')
2012
    # Set the 'custom' layer a high priority, so it remains the first
2013 2014 2015 2016 2017
    #   layer when installing new business templates.
    ps['custom'].manage_addProperty("business_template_skin_layer_priority", 100.0, "float")
    skin_folder_list = [ 'custom'
                       , 'external_method'
                       , 'activity'
2018
                       ] + self.CMFDEFAULT_FOLDER_LIST
2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
    skin_folders = ', '.join(skin_folder_list)
    ps.addSkinSelection( 'View'
                       , skin_folders
                       , make_default = 1
                       )
    ps.addSkinSelection( 'Print'
                       , skin_folders
                       , make_default = 0
                       )
    ps.addSkinSelection( 'CSV'
                       , skin_folders
                       , make_default = 0
                       )
2032 2033 2034 2035
    p.setupCurrentSkin()

  def setupWorkflow(self, p):
    """
2036
    Set up workflows for business templates
2037
    """
2038 2039
    workflow_list = ['business_template_building_workflow',
                     'business_template_installation_workflow']
2040
    tool = p.portal_workflow
2041 2042 2043
    tool.manage_delObjects(filter(tool.hasObject, workflow_list))
    self.bootstrap(tool, 'erp5_core', 'WorkflowTemplateItem', workflow_list)
    tool.setChainForPortalTypes(('Business Template',), workflow_list)
2044 2045 2046

  def setupIndex(self, p, **kw):
    # Make sure all tools and folders have been indexed
2047
    if not kw.get('reindex', 1):
2048
      return
2049
    # When no SQL connection was define on the site,
2050 2051
    # we don't want to make it crash
    if p.erp5_sql_connection_type is not None:
2052
      setattr(p, 'isIndexable', ConstantGetter('isIndexable', value=True))
2053 2054
      # Clear portal ids sql table, like this we do not take
      # ids for a previously created web site
Sebastien Robin's avatar
Sebastien Robin committed
2055
      p.portal_ids.clearGenerator(all=True)
2056
      # Then clear the catalog and reindex it
2057
      p.portal_catalog.manage_catalogClear()
2058
      # Calling ERP5Site_reindexAll is useless.
2059

2060 2061 2062
  def setupUserFolder(self, p):
      # Use Pluggable Auth Service instead of the standard acl_users.
      p.manage_addProduct['PluggableAuthService'].addPluggableAuthService()
2063
      pas_dispatcher = p.acl_users.manage_addProduct['PluggableAuthService']
2064
      # Add legacy ZODB support
2065 2066 2067
      pas_dispatcher.addZODBUserManager('zodb_users')
      pas_dispatcher.addZODBGroupManager('zodb_groups')
      pas_dispatcher.addZODBRoleManager('zodb_roles')
2068 2069 2070 2071
      # Add CMF Portal Roles
      p.acl_users.zodb_roles.addRole('Member')
      p.acl_users.zodb_roles.addRole('Reviewer')
      # Register ZODB Interface
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
      p.acl_users.zodb_users.manage_activateInterfaces(
                                       ('IAuthenticationPlugin',
                                        'IUserEnumerationPlugin',
                                        'IUserAdderPlugin'))
      p.acl_users.zodb_groups.manage_activateInterfaces(
                                       ('IGroupsPlugin',
                                       'IGroupEnumerationPlugin'))
      p.acl_users.zodb_roles.manage_activateInterfaces(
                                       ('IRoleEnumerationPlugin',
                                        'IRolesPlugin',
                                        'IRoleAssignerPlugin'))
2083
      # Add ERP5UserManager
2084 2085 2086 2087 2088
      erp5security_dispatcher = p.acl_users.manage_addProduct['ERP5Security']
      erp5security_dispatcher.addERP5UserManager('erp5_users')
      erp5security_dispatcher.addERP5GroupManager('erp5_groups')
      erp5security_dispatcher.addERP5RoleManager('erp5_roles')
      erp5security_dispatcher.addERP5UserFactory('erp5_user_factory')
2089
      # Register ERP5UserManager Interface
2090 2091 2092
      p.acl_users.erp5_users.manage_activateInterfaces(
                                        ('IAuthenticationPlugin',
                                        'IUserEnumerationPlugin',))
2093 2094
      p.acl_users.erp5_groups.manage_activateInterfaces(('IGroupsPlugin',))
      p.acl_users.erp5_roles.manage_activateInterfaces(('IRolesPlugin',))
2095 2096
      p.acl_users.erp5_user_factory.manage_activateInterfaces(
                                        ('IUserFactoryPlugin',))
2097 2098 2099 2100 2101 2102 2103 2104

  def setupPermissions(self, p):
    permission_dict = {
      'Access Transient Objects'     : ('Manager', 'Anonymous'),
      'Access contents information'  : ('Manager', 'Member', 'Anonymous'),
      'Access future portal content' : ('Manager', 'Reviewer'),
      'Access session data'          : ('Manager', 'Anonymous'),
      'AccessContentsInformation'    : ('Manager', 'Member'),
2105
      'Change local roles'           : ('Manager', ),
2106 2107 2108 2109 2110 2111
      'Add portal content'           : ('Manager', 'Owner'),
      'Add portal folders'           : ('Manager', 'Owner'),
      'Delete objects'               : ('Manager', 'Owner'),
      'FTP access'                   : ('Manager', 'Owner'),
      'List folder contents'         : ('Manager', 'Member'),
      'List portal members'          : ('Manager', 'Member'),
2112
      'List undoable changes'        : ('Manager', ),
2113 2114 2115 2116 2117
      'Manage properties'            : ('Manager', 'Owner'),
      'Modify portal content'        : ('Manager', 'Owner'),
      'Reply to item'                : ('Manager', 'Member'),
      'Review portal content'        : ('Manager', 'Reviewer'),
      'Search ZCatalog'              : ('Manager', 'Member'),
2118
      'Set own password'             : ('Manager', ),
2119
      'Set own properties'           : ('Manager', 'Member'),
2120
      'Use mailhost services'        : ('Manager', 'Member'),
2121
      'Undo changes'                 : ('Manager', 'Owner'),
2122
      'View'                         : ('Manager', 'Member',
2123
                                        'Owner', 'Anonymous'),
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
      'View management screens'      : ('Manager', 'Owner')
    }

    for permission in p.ac_inherited_permissions(1):
      name = permission[0]
      role_list = permission_dict.get(name, ('Manager',))
      p.manage_permission(name, roles=role_list, acquire=0)

  def setup(self, p, create_userfolder, **kw):
    update = kw.get('update', 0)

2135 2136 2137
    if getattr(p, 'setDefaultSorting', None) is not None:
      p.setDefaultSorting('id', 0)

2138 2139 2140 2141 2142
    self.setupTools(p, **kw)

    if not p.hasObject('MailHost'):
      self.setupMailHost(p)

Jérome Perrin's avatar
Jérome Perrin committed
2143 2144
    if create_userfolder and not p.hasObject('acl_users'):
      self.setupUserFolder(p)
2145 2146 2147 2148 2149 2150 2151 2152 2153

    if not p.hasObject('cookie_authentication'):
      self.setupCookieAuth(p)

    if 'Member' not in getattr(p, '__ac_roles__', ()):
      self.setupRoles(p)
    if not update:
      self.setupPermissions(p)
      self.setupDefaultSkins(p)
2154 2155 2156 2157
      assert not p.hasObject('portal_activities')
      addERP5Tool(p, 'portal_activities', 'Activity Tool')
      # Initialize Activities
      p.portal_activities.manageClearActivities(keep=0)
2158 2159 2160 2161 2162

    if not p.hasObject('content_type_registry'):
      self.setupMimetypes(p)

    if not update:
2163
      self.setupWorkflow(p)
2164
      self.setupERP5Core(p,**kw)
2165
      self.setupERP5Promise(p,**kw)
2166

2167 2168 2169
    # Make sure the cache is initialized
    p.portal_caches.updateCache()

2170 2171
    self.setupLastTools(p, **kw)

2172 2173 2174 2175 2176
    # Make sure tools are cleanly indexed with a uid before creating children
    # XXX for some strange reason, member was indexed 5 times
    if not update:
      self.setupIndex(p, **kw)

2177
  def setupERP5Core(self,p,**kw):
2178
    """
2179
    Install the core part of ERP5
2180
    """
2181
    template_tool = p.portal_templates
2182
    if template_tool.getInstalledBusinessTemplate('erp5_core') is None:
2183
      for bt in ('erp5_property_sheets', 'erp5_core', p.erp5_catalog_storage, 'erp5_jquery',
2184
                 'erp5_xhtml_style'):
2185 2186
        if not bt:
          continue
2187 2188 2189
        url = getBootstrapBusinessTemplateUrl(bt)
        bt = template_tool.download(url)
        bt.install(**kw)
2190 2191 2192 2193 2194 2195 2196 2197 2198

  def setupERP5Promise(self,p,**kw):
    """
    Install the ERP5 promise configurator
    """
    template_tool = p.portal_templates
    # Configure the bt5 repository
    repository = p.getPromiseParameter('portal_templates', 'repository')
    if repository is not None:
Łukasz Nowak's avatar
Łukasz Nowak committed
2199
      template_tool.updateRepositoryBusinessTemplateList(repository.split())
2200 2201 2202
      template_tool.installBusinessTemplateListFromRepository(
          ['erp5_promise'], activate=True, install_dependency=True)
      p.portal_alarms.subscribe()