TemplateTool.py 91.6 KB
Newer Older
1
# -*- coding: utf-8 -*-
Jean-Paul Smets's avatar
Jean-Paul Smets committed
2 3 4
##############################################################################
#
# Copyright (c) 2002 Nexedi SARL and Contributors. All Rights Reserved.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
5
#                    Jean-Paul Smets-Solanes <jp@nexedi.com>
Jean-Paul Smets's avatar
Jean-Paul Smets committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################

30
from webdav.client import Resource
Jean-Paul Smets's avatar
Jean-Paul Smets committed
31

Yoshinori Okuji's avatar
Yoshinori Okuji committed
32
from App.config import getConfiguration
33
import os
34
import shutil
35
import sys
36
import hashlib
37
import pprint
Yoshinori Okuji's avatar
Yoshinori Okuji committed
38

39
from Acquisition import Implicit, Explicit
Jean-Paul Smets's avatar
Jean-Paul Smets committed
40
from AccessControl import ClassSecurityInfo
41
from AccessControl.SecurityInfo import ModuleSecurityInfo
42
from Products.CMFActivity.ActiveResult import ActiveResult
43
from Products.ERP5Type.Globals import InitializeClass, DTMLFile, PersistentMapping
44
from Products.ERP5Type.DiffUtils import DiffFile
Jean-Paul Smets's avatar
Jean-Paul Smets committed
45
from Products.ERP5Type.Tool.BaseTool import BaseTool
46
from Products.ERP5Type.Cache import transactional_cached
47
from Products.ERP5Type import Permissions
48
from Products.ERP5.Document.BusinessTemplate import BusinessTemplateMissingDependency
49
from Products.ERP5.genbt5list import generateInformation
50
from Acquisition import aq_base
51
from tempfile import mkstemp, mkdtemp
Jean-Paul Smets's avatar
Jean-Paul Smets committed
52
from Products.ERP5 import _dtmldir
Aurel's avatar
Aurel committed
53
from cStringIO import StringIO
54
from urllib import pathname2url, urlopen, splittype, urlretrieve
55
import urllib2
56 57
import re
from xml.dom.minidom import parse
58
from xml.parsers.expat import ExpatError
59 60
import struct
import cPickle
61
from base64 import b64encode, b64decode
62
from Products.ERP5Type.Message import translateString
63
from zLOG import LOG, INFO, WARNING
64
from base64 import decodestring
65
from difflib import unified_diff
66
from operator import attrgetter
67
import subprocess
68
import time
Jean-Paul Smets's avatar
Jean-Paul Smets committed
69

70
WIN = os.name == 'nt'
71

72 73
CATALOG_UPDATABLE = object()
ModuleSecurityInfo(__name__).declarePublic('CATALOG_UPDATABLE')
74

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
class BusinessTemplateUnknownError(Exception):
  """ Exception raised when the business template
      is impossible to find in the repositories
  """
  pass

class UnsupportedComparingOperator(Exception):
  """ Exception when the comparing string is unsupported
  """
  pass

class BusinessTemplateIsMeta(Exception):
  """ Exception when the business template is provided by another one
  """
  pass

91 92
ModuleSecurityInfo(__name__).declarePublic('BusinessTemplateUnknownError')

Jean-Paul Smets's avatar
Jean-Paul Smets committed
93
class TemplateTool (BaseTool):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
94
    """
95
      TemplateTool manages Business Templates.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
96

97 98 99 100 101 102
      TemplateTool provides some methods to deal with Business Templates:
        - download
        - publish
        - install
        - update
        - save
Jean-Paul Smets's avatar
Jean-Paul Smets committed
103 104
    """
    id = 'portal_templates'
105
    title = 'Template Tool'
Jean-Paul Smets's avatar
Jean-Paul Smets committed
106
    meta_type = 'ERP5 Template Tool'
Jean-Paul Smets's avatar
Jean-Paul Smets committed
107
    portal_type = 'Template Tool'
108 109 110 111 112
    allowed_types = (
      'ERP5 Business Template',
      'ERP5 Business Package',
      'ERP5 Business Manager',
      )
113

114 115
    # This stores information on repositories.
    repository_dict = {}
Jean-Paul Smets's avatar
Jean-Paul Smets committed
116 117 118 119

    # Declarative Security
    security = ClassSecurityInfo()

Rafael Monnerat's avatar
Rafael Monnerat committed
120 121
    security.declareProtected(Permissions.ManagePortal, 'manage_overview')
    manage_overview = DTMLFile('explainTemplateTool', _dtmldir)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
122

123 124
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getInstalledBusinessTemplate')
125
    def getInstalledBusinessTemplate(self, title, strict=False, **kw):
126
      """Returns an installed version of business template of a given title.
127

128
        Returns None if business template is not installed or has been uninstalled.
129 130
        It not "installed" business template is found, look at replaced ones.
        This is mostly usefull if we are looking for the installed business
131 132
        template in a transaction replacing an existing business template.
        If strict is true, we do not take care of "replaced" business templates.
133 134
      """
      # This can be slow if, say, 10000 business templates are present.
Vincent Pelletier's avatar
Vincent Pelletier committed
135 136 137
      # However, that unlikely happens, and using a Z SQL Method has a
      # potential danger because business templates may exchange catalog
      # methods, so the database could be broken temporarily.
138
      last_bt = last_time = None
139
      for bt in self.objectValues(portal_type=['Business Template', 'Business Package']):
140
        if bt.getTitle() == title or title in bt.getProvisionList():
141 142 143
          state = bt.getInstallationState()
          if state == 'installed':
            return bt
144 145 146 147 148 149 150 151 152
          if state == 'not_installed':
            last_transition = bt.workflow_history \
              ['business_template_installation_workflow'][-1]
            if last_transition['action'] == 'uninstall': # There is not uninstalled state !
              t = last_transition['time']
              if last_time < t:
                last_bt = None
                last_time = t
          elif state == 'replaced' and not strict:
153 154 155 156 157 158
            t = bt.workflow_history \
              ['business_template_installation_workflow'][-1]['time']
            if last_time < t:
              last_bt = bt
              last_time = t
      return last_bt
159

160 161
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getInstalledBusinessTemplatesList')
162
    def getInstalledBusinessTemplatesList(self):
163 164 165 166 167
      """Deprecated.
      """
      DeprecationWarning('getInstalledBusinessTemplatesList is deprecated; Use getInstalledBusinessTemplateList instead.', DeprecationWarning)
      return self.getInstalledBusinessTemplateList()

168
    def _getInstalledBusinessTemplateList(self, only_title=0):
169
      """Get the list of installed business templates.
170 171
      """
      installed_bts = []
172
      for bt in self.contentValues(portal_type=['Business Template', 'Business Package']):
173
        if bt.getInstallationState() == 'installed':
174 175 176 177
          bt5 = bt
          if only_title:
            bt5 = bt.getTitle()
          installed_bts.append(bt5)
178
      return installed_bts
179

180 181
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getInstalledBusinessTemplateList')
182 183 184 185 186
    def getInstalledBusinessTemplateList(self):
      """Get the list of installed business templates.
      """
      return self._getInstalledBusinessTemplateList(only_title=0)

187 188
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getInstalledBusinessTemplateTitleList')
189 190 191 192 193
    def getInstalledBusinessTemplateTitleList(self):
      """Get the list of installed business templates.
      """
      return self._getInstalledBusinessTemplateList(only_title=1)

194 195
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getInstalledBusinessTemplateRevision')
196 197 198 199 200 201
    def getInstalledBusinessTemplateRevision(self, title, **kw):
      """
        Return the revision of business template installed with the title
        given
      """
      bt = self.getInstalledBusinessTemplate(title)
202 203 204
      if bt is not None:
        return bt.getRevision()
      return None
205

206 207
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getBuiltBusinessTemplateList')
208 209
    def getBuiltBusinessTemplateList(self):
      """Get the list of built and not installed business templates.
210
      """
211 212 213
      return [bt for bt in self.objectValues(portal_type='Business Template')
                 if bt.getInstallationState() == 'not_installed' and
                    bt.getBuildingState() == 'built']
214

215 216 217 218 219 220
    @property
    def asRepository(self):
      class asRepository(Explicit):
        """Export business template by their title

        Provides a view of template tool allowing a user to download the last
221
        edited business template with a URL like:
222 223 224 225 226 227 228 229 230 231 232
          http://.../erp5/portal_templates/asRepository/erp5_core
        """
        def __before_publishing_traverse__(self, self2, request):
          path = request['TraversalRequestNameStack']
          self.subpath = tuple(reversed(path))
          del path[:]
        def __call__(self, REQUEST, RESPONSE):
          title, = self.subpath
          last_bt = None, None
          for bt in self.aq_parent.searchFolder(title=title):
            bt = bt.getObject()
233 234 235
            modified = bt.getModificationDate()
            if last_bt[0] < modified and bt.getInstallationState() != 'deleted':
              last_bt = modified, bt
236 237 238 239 240 241 242 243 244 245 246
          if last_bt[1] is None:
            return RESPONSE.notFoundError(title)
          RESPONSE.setHeader('Content-type', 'application/data')
          RESPONSE.setHeader('Content-Disposition',
                             'inline;filename=%s-%s.zexp' % (title, last_bt[0]))
          if REQUEST['REQUEST_METHOD'] == 'GET':
            bt = last_bt[1]
            if bt.getBuildingState() != 'built':
              bt.build()
            return self.aq_parent.manage_exportObject(bt.getId(), download=1)
      return asRepository().__of__(self)
247

248
    security.declareProtected(Permissions.ManagePortal,
249 250
                              'getDefaultBusinessTemplateDownloadURL')
    def getDefaultBusinessTemplateDownloadURL(self):
251 252 253 254 255
      """Returns the default download URL for business templates.
      """
      return "file://%s/" % pathname2url(
                  os.path.join(getConfiguration().instancehome, 'bt5'))

Rafael Monnerat's avatar
Rafael Monnerat committed
256
    security.declareProtected('Import/Export objects', 'save')
257
    def save(self, business_template, REQUEST=None, RESPONSE=None):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
258
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
259
        Save the BusinessTemplate in the servers's filesystem.
Yoshinori Okuji's avatar
Yoshinori Okuji committed
260 261
      """
      cfg = getConfiguration()
Vincent Pelletier's avatar
Vincent Pelletier committed
262 263
      path = os.path.join(cfg.clienthome,
                          '%s' % (business_template.getTitle(),))
264
      path = pathname2url(path)
265
      business_template.export(path=path, local=True)
266
      if REQUEST is not None:
267
        psm = translateString('Saved in ${path} .',
268
                              mapping={'path':pathname2url(path)})
269
        ret_url = '%s/%s?portal_status_message=%s' % \
Vincent Pelletier's avatar
Vincent Pelletier committed
270
                  (business_template.absolute_url(),
271
                   REQUEST.get('form_id', 'view'), psm)
Vincent Pelletier's avatar
Vincent Pelletier committed
272 273 274
        if RESPONSE is None:
          RESPONSE = REQUEST.RESPONSE
        return REQUEST.RESPONSE.redirect( ret_url )
275 276

    security.declareProtected( 'Import/Export objects', 'export' )
277
    def export(self, business_template, REQUEST=None, RESPONSE=None, is_package=False):
278
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
279 280
        Export the Business Template as a bt5 file and offer the user to
        download it.
281
      """
282
      export_string = business_template.export()
Aurel's avatar
Aurel committed
283
      try:
284 285
        if RESPONSE is not None:
          RESPONSE.setHeader('Content-type','tar/x-gzip')
286
          if not is_package:
287 288 289 290 291
            RESPONSE.setHeader('Content-Disposition', 'inline;filename=%s-%s.bt5'
              % (business_template.getTitle(), business_template.getVersion()))
          else:
            RESPONSE.setHeader('Content-Disposition', 'inline;filename=%s.bp5'
            % business_template.getTitle())
Aurel's avatar
Aurel committed
292 293 294
        return export_string.getvalue()
      finally:
        export_string.close()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
295

296
    security.declareProtected( 'Import/Export objects', 'publish' )
297 298
    def publish(self, business_template, url, username=None, password=None):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
299
        Publish the given business template at the given URL.
300 301
      """
      business_template.build()
Vincent Pelletier's avatar
Vincent Pelletier committed
302
      export_string = self.manage_exportObject(id=business_template.getId(),
303
                                               download=True)
304
      bt = Resource(url, username=username, password=password)
Vincent Pelletier's avatar
Vincent Pelletier committed
305 306
      bt.put(file=export_string,
             content_type='application/x-erp5-business-template')
307
      business_template.setPublicationUrl(url)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
308

309
    security.declareProtected(Permissions.ManagePortal, 'update')
310 311
    def update(self, business_template):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
312
        Update an existing template from its publication URL.
313 314 315 316 317 318
      """
      url = business_template.getPublicationUrl()
      id = business_template.getId()
      bt = Resource(url)
      export_string = bt.get().get_body()
      self.deleteContent(id)
Aurel's avatar
Aurel committed
319
      self._importObjectFromFile(StringIO(export_string), id=id)
320

321

322
    security.declareProtected( Permissions.ManagePortal, 'manage_download' )
323 324
    def manage_download(self, url, id=None, REQUEST=None):
      """The management interface for download.
325
      """
326 327
      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)
328

329
      bt = self.download(url, id=id)
330

331
      if REQUEST is not None:
332
        ret_url = bt.absolute_url()
Yusei Tahara's avatar
Yusei Tahara committed
333
        psm = translateString("Business template downloaded successfully.")
334
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
335
                                    % (ret_url, psm))
336

337
    def _download_local(self, path, bt_id, format_version=1):
338 339
      """Download Business Template from local directory or file
      """
340
      if format_version == 2:
341 342 343
        bp = self.newContent(bt_id, 'Business Package')
        bp.importFile(path)
        return bp
344 345 346 347
      elif format_version == 3:
        bm = self.newContent(bt_id, 'Business Manager')
        bm.importFile(path)
        return bm
348

349 350
      bt = self.newContent(bt_id, 'Business Template')
      bt.importFile(path)
351
      return bt
352 353 354 355

    def _download_url(self, url, bt_id):
      tempid, temppath = mkstemp()
      try:
356
        os.close(tempid) # Close the opened fd as soon as possible.
357
        file_path, headers = urlretrieve(url, temppath)
358
        if re.search(r'<title>.*Revision \d+:', open(file_path, 'r').read()):
359 360 361
          # this looks like a subversion repository, try to check it out
          LOG('ERP5', INFO, 'TemplateTool doing a svn checkout of %s' % url)
          return self._download_svn(url, bt_id)
Rafael Monnerat's avatar
Rafael Monnerat committed
362

363 364 365 366 367 368 369 370
        return self._download_local(file_path, bt_id)
      finally:
        os.remove(temppath)

    def _download_svn(self, url, bt_id):
      svn_checkout_tmp_dir = mkdtemp()
      svn_checkout_dir = os.path.join(svn_checkout_tmp_dir, 'bt')
      try:
371 372
        from Products.ERP5VCS.WorkingCopy import getVcsTool
        getVcsTool('svn').__of__(self).export(url, svn_checkout_dir)
373 374 375 376 377
        return self._download_local(svn_checkout_dir, bt_id)
      finally:
        shutil.rmtree(svn_checkout_tmp_dir)

    security.declareProtected( 'Import/Export objects', 'download' )
378
    def download(self, url, id=None, REQUEST=None):
379 380 381 382 383 384 385 386 387 388 389
      """
      Download Business Template from url, can be file or local directory
      """
      # For backward compatibility: If REQUEST is passed, it is likely that we
      # come from the management interface.
      if REQUEST is not None:
        return self.manage_download(url, id=id, REQUEST=REQUEST)
      if id is None:
        id = self.generateNewId()

      urltype, name = splittype(url)
390 391 392
      if WIN and urltype and '\\' in name:
        urltype = None
        name = url
393
      if urltype and urltype != 'file':
394
        if '/portal_templates/asRepository/' in url:
395 396 397 398 399
          # In this case, the downloaded BT is already built.
          bt = self._p_jar.importFile(urlopen(url))
          bt.id = id
          del bt.uid
          return self[self._setObject(id, bt)]
400 401
        bt = self._download_url(url, id)
      else:
402 403 404 405 406 407 408
        template_version_path_list = [
                                      name+'/bp/template_format_version',
                                      name+'/bm/template_format_version',
                                     ]

        for path in template_version_path_list:
          try:
409
            file = open(os.path.normpath(path))
410
          except IOError:
411 412 413 414 415 416 417
            continue
        try:
          format_version = int(file.read())
          file.close()
        except UnboundLocalError:
          # In case none of the above paths do have template_format_version
          format_version = 1
418
        # XXX: Download only needed in case the file is in directory
419
        bt = self._download_local(os.path.normpath(name), id, format_version)
420

421
      bt.build(no_action=True)
422
      return bt
Jean-Paul Smets's avatar
Jean-Paul Smets committed
423

424
    security.declareProtected('Import/Export objects', 'importBase64EncodedText')
425
    def importBase64EncodedText(self, file_data=None, id=None, REQUEST=None,
426
                                batch_mode=False, **kw):
427
      """
428 429 430
        Import Business Template from passed base64 encoded text.
      """
      import_file = StringIO(decodestring(file_data))
431
      return self.importFile(import_file = import_file, id = id, REQUEST = REQUEST,
432 433
                             batch_mode = batch_mode, **kw)

434
    security.declareProtected('Import/Export objects', 'importFile')
435
    def importFile(self, import_file=None, id=None, REQUEST=None,
436
                   batch_mode=False, **kw):
437
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
438
        Import Business Template from one file
439
      """
440 441
      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)
442

443 444 445 446 447
      if id is None:
        id = self.generateNewId()

      if (import_file is None) or (len(import_file.read()) == 0):
        if REQUEST is not None:
Yusei Tahara's avatar
Yusei Tahara committed
448
          psm = translateString('No file or an empty file was specified.')
449 450
          REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                    % (self.absolute_url(), psm))
Alexandre Boeglin's avatar
Alexandre Boeglin committed
451 452
          return
        else :
453
          raise RuntimeError, 'No file or an empty file was specified'
Aurel's avatar
Aurel committed
454
      # copy to a temp location
Alexandre Boeglin's avatar
Alexandre Boeglin committed
455
      import_file.seek(0) #Rewind to the beginning of file
456
      tempid, temppath = mkstemp()
457 458
      try:
        os.close(tempid) # Close the opened fd as soon as possible
459
        with open(temppath, 'wb') as tempfile:
460
          tempfile.write(import_file.read())
461
        bt = self._download_local(temppath, id)
462 463
      finally:
        os.remove(temppath)
464
      bt.build(no_action=True)
Aurel's avatar
Aurel committed
465
      bt.reindexObject()
466

467
      if not batch_mode and \
468
         (REQUEST is not None):
469
        ret_url = bt.absolute_url()
Yusei Tahara's avatar
Yusei Tahara committed
470
        psm = translateString("Business templates imported successfully.")
471 472
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                  % (ret_url, psm))
473
      elif batch_mode:
474
        return bt
475

476
    security.declareProtected(Permissions.ManagePortal, 'getDiffFilterScriptList')
477 478 479 480
    def getDiffFilterScriptList(self):
      """
      Return list of scripts usable to filter diff
      """
481
      # XXX, the "or ()" should not be there, the preference tool is
482 483
      # inconsistent, the called method should not return None when
      # nothing is selected
484
      portal = self.getPortalObject()
485 486 487 488 489 490 491 492
      script_list = []
      for script_id in portal.portal_preferences\
         .getPreferredDiffFilterScriptIdList() or ():
        try:
          script_list.append(getattr(portal, script_id))
        except AttributeError:
          LOG("TemplateTool", WARNING, "Unable to find %r script" % script_id)
      return script_list
493

494
    security.declareProtected(Permissions.ManagePortal, 'getFilteredDiffAsHTML')
495 496 497 498 499 500
    def getFilteredDiffAsHTML(self, diff):
      """
      Return the diff filtered by python scripts into html format
      """
      return self.getFilteredDiff(diff).toHTML()

501
    def _cleanUpTemplateFolder(self, folder_path):
502 503
      file_object_list = [x for x in os.listdir(folder_path)]
      for file_object in file_object_list:
504 505 506 507 508 509
        file_object_path = os.path.join(folder_path, file_object)
        if os.path.isfile(file_object_path):
          os.unlink(file_object_path)
        else:
          shutil.rmtree(file_object_path)

510 511
    security.declareProtected( 'Import/Export objects', 'importAndReExportBusinessTemplateFromPath' )
    def importAndReExportBusinessTemplateFromPath(self, template_path):
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
      """
        Imports the template that is in the template_path and exports it to the
        same path.

        We want to clean this directory, i.e. remove all files before
        the export. Because this is called as activity though, it could cause
        the following problem:
        - Activity imports the template
        - Activity removes all files from template_path
        - Activity fails in export.
        Then the folder contents will be changed, so when retrying the
        activity may succeed without the user understanding that files were
        erased. For this reason export is done in 3 steps:
        - First to a temporary directory
        - If there was no error delete contents of template_path
        - Copy the contents of the temporary directory to the template_path
      """
      import_template = self.download(url=template_path)
      export_dir = mkdtemp()
      try:
        import_template.export(path=export_dir, local=True)
        self._cleanUpTemplateFolder(template_path)
534 535 536 537 538
        file_name_list = [x for x in os.listdir(export_dir)]
        for file_name in file_name_list:
          temp_file_path = os.path.join(export_dir, file_name)
          destination_file_path = os.path.join(template_path, file_name)
          shutil.move(temp_file_path, destination_file_path)
539 540 541 542 543
      except:
        raise
      finally:
        shutil.rmtree(export_dir)

544 545
    security.declareProtected( 'Import/Export objects', 'importAndReExportBusinessTemplateListFromPath' )
    def importAndReExportBusinessTemplateListFromPath(self, repository_list, REQUEST=None, **kw):
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
      """
        Migrate business templates to new format where files like .py or .html
        are exported seprately than the xml.
      """
      repository_list = filter(bool, repository_list)

      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)
        
      if len(repository_list) == 0 and REQUEST:
        ret_url = self.absolute_url()
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                  % (ret_url, 'No repository was defined'))
                                    
      for repository in repository_list:
        repository = repository.rstrip('\n')
        repository = repository.rstrip('\r')
        for business_template_id in os.listdir(repository):
          template_path = os.path.join(repository, business_template_id)
          if os.path.isfile(template_path):
            LOG(business_template_id,0,'is file, so it is skipped')
          else:
            if not os.path.exists((os.path.join(template_path, 'bt'))):
              LOG(business_template_id,0,'has no bt sub-folder, so it is skipped')
            else:
571 572
              self.activate(activity='SQLQueue').\
                importAndReExportBusinessTemplateFromPath(template_path)
573

574 575 576 577 578 579 580 581 582 583 584 585 586 587
    security.declareProtected( 'Import/Export objects', 'migrateBTToBP')
    def migrateBTToBP(self, template_path, REQUEST=None, **kw):
      """
        Migrate business template repository to Business Package repo.
        Business Package completely rely only on PathTemplateItem and to show
        the difference between both of them

        So, the steps should be:
        1. Install the business template which is going to be migrated
        2. Create a new Business Package with random id and title
        3. Add the path, build and export the template
        4. Remove the business template from the directory and add the business
        package there instead
        5. Change the ID and title of the business package
588 589
        6. Export the business package to the directory, leaving anything in
        the installed erp5 unchanged
590 591
      """
      import_template = self.download(url=template_path)
592 593 594 595
      if import_template.getPortalType == 'Business Package':
        LOG(import_template.getTitle(),0,'Already migrated')
        return

596 597
      export_dir = mkdtemp()

598
      installed_bt_list = self.getInstalledBusinessTemplatesList()
599 600
      installed_bt_title_list = [bt.title for bt in installed_bt_list]

601
      is_installed = False
602 603 604
      if import_template.getTitle() not in installed_bt_title_list:
        # Install the business template
        import_template.install(**kw)
605
        is_installed = True
606 607 608 609 610 611 612 613 614 615 616

      # Make list of object paths which needs to be added in the bp5
      # This can be decided by looping over every type of items we do have in
      # bt5 and checking if there have been any changes being made to it via this
      # bt5 installation or not.
      # For ex:
      # CatalogTempalteMethodItem, CatalogResultsKeyItem, etc. do make some
      # changes in erp5_mysql_innodb(by adding properties, by adding sub-objects),
      # so we need to add portal_catalog/erp5_mysql_innodb everytime we find
      # a bt5 making changes in any of these items.

617 618
      portal_path = self.getPortalObject()
      template_path_list = []
619
      property_path_list = []
620 621

      # For modules, we don't need to create path for the module
622
      module_list = import_template.getTemplateModuleIdList()
623 624
      template_path_list.extend(module_list)

625 626 627
      # For portal_types, we have to add path and subobjetcs
      portal_type_id_list = import_template.getTemplatePortalTypeIdList()
      portal_type_path_list = []
628 629 630
      for id in portal_type_id_list:
        portal_type_path_list.append('portal_types/'+id)
        portal_type_path_list.append('portal_types/'+id+'/**')
631 632
      template_path_list.extend(portal_type_path_list)

633
      # For categories, we create path for category objects as well as the subcategories
634
      category_list = import_template.getTemplateBaseCategoryList()
635 636
      category_path_list = []
      for base_category in category_list:
637 638
        category_path_list.append('portal_categories/'+base_category)
        category_path_list.append('portal_categories/'+base_category+'/**')
639 640 641
      template_path_list.extend(category_path_list)

      # For portal_skins, we export the folder
642
      portal_skin_list = import_template.getTemplateSkinIdList()
643 644
      portal_skin_path_list = []
      for skin in portal_skin_list:
645 646
        portal_skin_path_list.append('portal_skins/'+skin)
        portal_skin_path_list.append('portal_skins/'+skin+'/**')
647 648 649 650 651 652 653 654 655 656 657 658
      template_path_list.extend(portal_skin_path_list)

      # For workflow chains,
      # We have 2 objects in the Business Template design where we deal with
      # workflow objects, we deal with the installation separately:
      # 1. Workflow_id : We export the whole workflow objects in this case
      # 2. Portal Workflow chain: It is already being exported via portal_types
      # XXX: CHECK For 2, keeping in mind the migration of workflow would be merged
      # before this part where we make workflow_list as property of portal_type
      workflow_id_list = import_template.getTemplateWorkflowIdList()
      workflow_path_list = []
      for workflow in workflow_id_list:
659 660
        workflow_path_list.append('portal_workflow/' + workflow)
        workflow_path_list.append('portal_workflow/' + workflow + '/**')
661 662 663 664 665
      template_path_list.extend(workflow_path_list)

      # For paths, we add them directly to the path list
      template_path_list.extend(import_template.getTemplatePathList())

666
      # Catalog methods would be added as sub objects
667 668 669
      catalog_method_item_list = import_template.getTemplateCatalogMethodIdList()
      catalog_method_path_list = []
      for method in catalog_method_item_list:
670
        catalog_method_path_list.append('portal_catalog/' + method)
671
      template_path_list.extend(catalog_method_path_list)
672 673

      # For catalog objects, we check if there is any catalog object, and then
674
      # add catalog object also in the path if there is
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
      template_catalog_datetime_key   = import_template.getTemplateCatalogDatetimeKeyList()
      template_catalog_full_text_key  = import_template.getTemplateCatalogFullTextKeyList()
      template_catalog_keyword_key    = import_template.getTemplateCatalogKeywordKeyList()
      template_catalog_local_role_key = import_template.getTemplateCatalogLocalRoleKeyList()
      template_catalog_multivalue_key = import_template.getTemplateCatalogMultivalueKeyList()
      template_catalog_related_key    = import_template.getTemplateCatalogRelatedKeyList()
      template_catalog_request_key    = import_template.getTemplateCatalogRequestKeyList()
      template_catalog_result_key     = import_template.getTemplateCatalogResultKeyList()
      template_catalog_result_table   = import_template.getTemplateCatalogResultTableList()
      template_catalog_role_key       = import_template.getTemplateCatalogRoleKeyList()
      template_catalog_scriptable_key = import_template.getTemplateCatalogScriptableKeyList()
      template_catalog_search_key     = import_template.getTemplateCatalogSearchKeyList()
      template_catalog_security_uid_column = import_template.getTemplateCatalogSecurityUidColumnList()
      template_catalog_topic_key      = import_template.getTemplateCatalogTopicKeyList()

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
      catalog_property_list = [
        template_catalog_datetime_key,
        template_catalog_full_text_key,
        template_catalog_keyword_key,
        template_catalog_local_role_key,
        template_catalog_multivalue_key,
        template_catalog_related_key,
        template_catalog_request_key,
        template_catalog_result_key,
        template_catalog_result_table,
        template_catalog_role_key,
        template_catalog_scriptable_key,
        template_catalog_search_key,
        template_catalog_security_uid_column,
        template_catalog_topic_key,
        ]
      is_property_added = any(catalog_property_list)

      properties_removed = [
        'sql_catalog_datetime_search_keys_list',
        'sql_catalog_full_text_search_keys_list',
        'sql_catalog_keyword_search_keys_list',
        'sql_catalog_local_role_keys_list',
        'sql_catalog_multivalue_keys_list',
        'sql_catalog_related_keys_list',
        'sql_catalog_request_keys_list',
        'sql_search_result_keys_list',
        'sql_search_tables_list',
        'sql_catalog_role_keys_list',
        'sql_catalog_scriptable_keys_list',
        'sql_catalog_search_keys_list',
        'sql_catalog_security_uid_columns_list',
        'sql_catalog_topic_search_keys_list'
        ]

      removable_property = {}

      if is_property_added:
        if catalog_method_path_list:
          catalog_path = catalog_method_path_list[0].rsplit('/', 1)[0]
        else:
          catalog_path = 'portal_catalog/erp5_mysql_innodb'
        template_path_list.append(catalog_path)
        removable_property[catalog_path] = properties_removed
        for prop in properties_removed:
            property_path_list.append(catalog_path + ' | ' + prop)

737 738 739 740
      # Add these catalog items in the object_property instead of adding
      # dummy path item for them
      if import_template.getTitle() == 'erp5_mysql_innodb_catalog':
        template_path_list.extend('portal_catalog/erp5_mysql_innodb')
741

742 743 744 745 746 747 748
      # Add portal_property_sheets
      property_sheet_id_list = import_template.getTemplatePropertySheetIdList()
      property_sheet_path_list = []
      for property_sheet in property_sheet_id_list:
        property_sheet_path_list.append('portal_property_sheets/' + property_sheet)
        property_sheet_path_list.append('portal_property_sheets/' + property_sheet + '/**')
      template_path_list.extend(property_sheet_path_list)
749

750
      # Create new objects for business package
751 752
      bp5_package = self.newContent(
                                    portal_type='Business Package',
753
                                    title=import_template.getTitle()
754
                                    )
755 756 757 758 759 760 761 762

      bp5_package.edit(
        template_path_list=template_path_list,
        template_object_property_list=property_path_list
        )

      kw['removable_property'] = removable_property
      bp5_package.build(**kw)
763
      # Export the newly built business package to the export directory
764 765
      bp5_package.export(path=export_dir, local=True)
      if is_installed:
766
        import_template.uninstall()
767

768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
    security.declareProtected( 'Import/Export objects', 'migrateBTListToBP')
    def migrateBTListToBP(self, repository_list, REQUEST=None, **kw):
      """
      Run migration for BT5 one by one in a given repository. This will be done
      via activities.
      """
      repository_list = filter(bool, repository_list)

      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)

      if len(repository_list) == 0 and REQUEST:
        ret_url = self.absolute_url()
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                  % (ret_url, 'No repository was defined'))

      for repository in repository_list:
        repository = repository.rstrip('\n')
        repository = repository.rstrip('\r')
        for business_template_id in os.listdir(repository):
          template_path = os.path.join(repository, business_template_id)
          if os.path.isfile(template_path):
            LOG(business_template_id,0,'is file, so it is skipped')
          else:
            if not os.path.exists((os.path.join(template_path, 'bt'))):
              LOG(business_template_id,0,'has no bt sub-folder, so it is skipped')
            else:
              self.migrateBTToBP(template_path)
              #self.activate(activity='SQLQueue').\
              #  migrateBTToBP(template_path)

799
    security.declareProtected(Permissions.ManagePortal, 'getFilteredDiff')
800 801 802 803 804 805
    def getFilteredDiff(self, diff):
      """
      Filter the diff using python scripts
      """
      diff_file_object = DiffFile(diff)
      diff_block_list = diff_file_object.getModifiedBlockList()
806 807 808 809
      if diff_block_list:
        script_list = self.getDiffFilterScriptList()
        for block, line_tuple in diff_block_list:
          for script in script_list:
810 811
            if script(line_tuple[0], line_tuple[1]):
              diff_file_object.children.remove(block)
812
              break
813 814 815 816
      # XXX-Aurel : this method should return a text diff but
      # DiffFile does not provide yet such feature
      return diff_file_object

817
    security.declareProtected(Permissions.ManagePortal, 'diffObjectAsHTML')
818 819 820
    def diffObjectAsHTML(self, REQUEST, **kw):
      """
        Convert diff into a HTML format before reply
821
        This is compatible with ERP5VCS look and feel but
822 823 824 825
        it is preferred in future we use more difflib python library.
      """
      return DiffFile(self.diffObject(REQUEST, **kw)).toHTML()

826
    security.declareProtected(Permissions.ManagePortal, 'diffObject')
827
    def diffObject(self, REQUEST, **kw):
Aurel's avatar
Aurel committed
828
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
829 830
        Make diff between two objects, whose paths are stored in values bt1
        and bt2 in the REQUEST object.
Aurel's avatar
Aurel committed
831
      """
832 833
      bt1_id = getattr(REQUEST, 'bt1', None)
      bt2_id = getattr(REQUEST, 'bt2', None)
834 835 836 837 838 839 840
      if bt1_id is not None and bt2_id is not None:
        bt1 = self._getOb(bt1_id)
        bt2 = self._getOb(bt2_id)
        if self.compareVersions(bt1.getVersion(), bt2.getVersion()) < 0:
          return bt2.diffObject(REQUEST, compare_with=bt1_id)
        else:
          return bt1.diffObject(REQUEST, compare_with=bt2_id)
Aurel's avatar
Aurel committed
841
      else:
842 843 844 845 846
        object_id = getattr(REQUEST, 'object_id', None)
        bt1_id = object_id.split('|')[0]
        bt1 = self._getOb(bt1_id)
        REQUEST.set('object_id', object_id.split('|')[1])
        return bt1.diffObject(REQUEST)
847

Vincent Pelletier's avatar
Vincent Pelletier committed
848 849 850 851
    security.declareProtected( 'Import/Export objects',
                               'updateRepositoryBusinessTemplateList' )

    def updateRepositoryBusinessTemplateList(self, repository_list,
852
        REQUEST=None, RESPONSE=None, genbt5list=0, **kw):
Vincent Pelletier's avatar
Vincent Pelletier committed
853 854
      """
        Update the information on Business Templates from repositories.
855 856 857

      For local repositories, if bt5list is missing or if genbt5list > 1,
      bt5list is automatically generated (but not saved on disk).
858 859
      """
      self.repository_dict = PersistentMapping()
860
      property_list = ('title', 'version', 'revision', 'description', 'license',
861 862
                       'dependency', 'test_dependency', 'provision', 'copyright',
                       'force_install')
Vincent Pelletier's avatar
Vincent Pelletier committed
863 864
      #LOG('updateRepositoryBusiessTemplateList', 0,
      #    'repository_list = %r' % (repository_list,))
865
      for repository in repository_list:
866 867 868 869 870 871 872 873 874 875 876 877 878
        urltype, url = splittype(repository)
        if WIN and urltype and '\\' in url:
          urltype = None
          url = repository
        if urltype and urltype != 'file':
          f = urlopen(repository + '/bt5list')
        else:
          bt5list = os.path.join(url, 'bt5list')
          if genbt5list > os.path.exists(bt5list):
            f = generateInformation(url)
            f.seek(0)
          else:
            f = open(bt5list, 'rb')
879
        try:
880 881 882 883 884 885 886 887 888 889 890
          try:
            doc = parse(f)
          except ExpatError:
            if REQUEST is not None:
              psm = translateString('Invalid repository: ${repo}',
                                    mapping={'repo':repository})
              REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                       % (self.absolute_url(), psm))
              return
            else:
              raise RuntimeError, 'Invalid repository: %s' % repository
891
          try:
892
            property_dict_list = []
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
            root = doc.documentElement
            for template in root.getElementsByTagName("template"):
              id = template.getAttribute('id')
              if type(id) == type(u''):
                id = id.encode('utf-8')
              temp_property_dict = {}
              for node in template.childNodes:
                if node.nodeName in property_list:
                  value = ''
                  for text in node.childNodes:
                    if text.nodeType == text.TEXT_NODE:
                      value = text.data
                      if type(value) == type(u''):
                        value = value.encode('utf-8')
                      break
                  temp_property_dict.setdefault(node.nodeName, []).append(value)

              property_dict = {}
              property_dict['id'] = id
              property_dict['title'] = temp_property_dict.get('title', [''])[0]
Vincent Pelletier's avatar
Vincent Pelletier committed
913 914
              property_dict['version'] = \
                  temp_property_dict.get('version', [''])[0]
Jérome Perrin's avatar
Jérome Perrin committed
915 916
              property_dict['revision'] = \
                  temp_property_dict.get('revision', [''])[0]
Vincent Pelletier's avatar
Vincent Pelletier committed
917 918 919 920 921 922
              property_dict['description'] = \
                  temp_property_dict.get('description', [''])[0]
              property_dict['license'] = \
                  temp_property_dict.get('license', [''])[0]
              property_dict['dependency_list'] = \
                  temp_property_dict.get('dependency', ())
923 924
              property_dict['test_dependency_list'] = \
                  temp_property_dict.get('test_dependency', ())
925 926
              property_dict['provision_list'] = \
                  temp_property_dict.get('provision', ())
Vincent Pelletier's avatar
Vincent Pelletier committed
927 928
              property_dict['copyright_list'] = \
                  temp_property_dict.get('copyright', ())
929 930
              property_dict['force_install'] = \
                  int(temp_property_dict.get('force_install', [0])[0])
931

932 933 934 935 936
              property_dict_list.append(property_dict)
          finally:
            doc.unlink()
        finally:
          f.close()
937

938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
        #XXX: Hardcoding 'erp5_mysql_innodb_catalog' BP in the list
        bp_dict ={
          'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
          'dependency_list': [],
          'description': '',
          'force_install': 0,
          'id': 'erp5_mysql_innodb_catalog',
          'license': 'GPL',
          'provision_list': ['erp5_catalog'],
          'revision': '',
          'test_dependency_list': [],
          'title': 'erp5_mysql_innodb_catalog',
          'version': '1.0'}
        if repository.endswith('/bt5'):
          property_dict_list.append(bp_dict)

954
        self.repository_dict[repository] = tuple(property_dict_list)
955

956
      if REQUEST is not None:
957
        ret_url = self.absolute_url() + '/' + REQUEST.get('dialog_id', 'view')
Yusei Tahara's avatar
Yusei Tahara committed
958
        psm = translateString("Business templates updated successfully.")
959 960
        REQUEST.RESPONSE.redirect("%s?cancel_url=%s&portal_status_message=%s&dialog_category=object_exchange&selection_name=business_template_selection"
                                  % (ret_url, REQUEST.form.get('cancel_url', ''), psm))
961

Vincent Pelletier's avatar
Vincent Pelletier committed
962 963
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getRepositoryList' )
964
    def getRepositoryList(self):
Vincent Pelletier's avatar
Vincent Pelletier committed
965 966
      """
        Get the list of repositories.
967 968
      """
      return self.repository_dict.keys()
969

970 971
    security.declarePublic( 'decodeRepositoryBusinessTemplateUid' )
    def decodeRepositoryBusinessTemplateUid(self, uid):
Vincent Pelletier's avatar
Vincent Pelletier committed
972 973 974
      """
        Decode the uid of a business template from a repository.
        Return a repository and an id.
975
      """
976
      return cPickle.loads(b64decode(uid))
977

978 979 980 981 982 983 984 985
    security.declarePublic( 'encodeRepositoryBusinessTemplateUid' )
    def encodeRepositoryBusinessTemplateUid(self, repository, id):
      """
        encode the repository and the id of a business template.
        Return an uid.
      """
      return b64encode(cPickle.dumps((repository, id)))

986
    security.declarePublic('compareVersionStrings')
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
    def compareVersionStrings(self, version, comparing_string):
      """
       comparing_string is like "<= 0.2" | "operator version"
       operators supported: '<=', '<' or '<<', '>' or '>>', '>=', '=' or '=='
      """
      operator, comp_version = comparing_string.split(' ')
      diff_version = self.compareVersions(version, comp_version)
      if operator == '<' or operator == '<<':
        if diff_version < 0:
          return True;
        return False;
      if operator == '<=':
        if diff_version <= 0:
          return True;
        return False;
      if operator == '>' or operator == '>>':
        if diff_version > 0:
          return True;
        return False;
      if operator == '>=':
        if diff_version >= 0:
          return True;
        return False;
      if operator == '=' or operator == '==':
        if diff_version == 0:
          return True;
        return False;
      raise UnsupportedComparingOperator, 'Unsupported comparing operator: %s'%(operator,)
1015

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
    security.declareProtected(Permissions.AccessContentsInformation,
                              'IsOneProviderInstalled')
    def IsOneProviderInstalled(self, title):
      """
        return true if a business template that
        provides the bt with the given title is
        installed
      """
      installed_bt_list = self.getInstalledBusinessTemplatesList()
      for bt in installed_bt_list:
        provision_list = bt.getProvisionList()
        if title in provision_list:
          return True
      return False
1030

1031 1032 1033 1034 1035
    security.declareProtected(Permissions.AccessContentsInformation,
                               'getLastestBTOnRepos')
    def getLastestBTOnRepos(self, title, version_restriction=None):
      """
       It's possible we have different versions of the same BT
1036
       available on various repositories or on the same repository.
1037 1038 1039 1040 1041 1042
       This function returns the latest one that meet the version_restriction
       (i.e "<= 0.2") in the following form :
       tuple (repository, id)
      """
      result = None
      for repository, property_dict_list in self.repository_dict.items():
Jérome Perrin's avatar
Jérome Perrin committed
1043
        for property_dict in property_dict_list:
1044 1045 1046
          provision_list = property_dict.get('provision_list', [])
          if title in provision_list:
            raise BusinessTemplateIsMeta, 'Business Template %s is provided by another one'%(title,)
Jérome Perrin's avatar
Jérome Perrin committed
1047
          if title == property_dict['title']:
1048 1049
            if (version_restriction is None) or (self.compareVersionStrings(property_dict['version'], version_restriction)):
              if (result is None) or (self.compareVersions(property_dict['version'], result[2]) > 0):
Rafael Monnerat's avatar
Rafael Monnerat committed
1050
                result = (repository, property_dict['id'], property_dict['version'])
1051 1052 1053 1054
      if result is not None:
        return (result[0], result[1])
      else:
        raise BusinessTemplateUnknownError, 'Business Template %s (%s) could not be found in the repositories'%(title, version_restriction or '')
1055

1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
    security.declareProtected(Permissions.AccessContentsInformation,
                              'getProviderList')
    def getProviderList(self, title):
      """
       return a list of business templates that provides
       the given business template
      """
      result_list = []
      for repository, property_dict_list in self.repository_dict.items():
        for property_dict in property_dict_list:
          provision_list = property_dict['provision_list']
          if (title in provision_list) and (property_dict['title'] not in result_list):
            result_list.append(property_dict['title'])
      return result_list
1070

1071 1072
    security.declareProtected(Permissions.AccessContentsInformation,
                               'getDependencyList')
1073 1074 1075
    @transactional_cached(lambda self, bt, with_test_dependency_list=False:
                          (bt, with_test_dependency_list))
    def getDependencyList(self, bt, with_test_dependency_list=False):
1076 1077 1078 1079
      """
       Return the list of missing dependencies for a business
       template, given a tuple : (repository, id)
      """
1080 1081 1082
      # We do not take into consideration the dependencies
      # for meta business templates
      if bt[0] != 'meta':
1083 1084 1085 1086 1087
        result_list = []
        for repository, property_dict_list in self.repository_dict.items():
          if repository == bt[0]:
            for property_dict in property_dict_list:
              if property_dict['id'] == bt[1]:
1088 1089 1090 1091 1092
                dependency_list = [q.strip() for q in
                                   property_dict['dependency_list'] if q]
                if with_test_dependency_list:
                  dependency_list.extend([q.strip() for q in
                                          property_dict['test_dependency_list'] if q])
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
                for dependency_couple in dependency_list:
                  # dependency_couple is like "erp5_xhtml_style (>= 0.2)"
                  dependency_couple_list = dependency_couple.split(' ', 1)
                  dependency = dependency_couple_list[0]
                  version_restriction = None
                  if len(dependency_couple_list) > 1:
                    version_restriction = dependency_couple_list[1]
                    if version_restriction.startswith('('):
                      # Something like "(>= 1.0rc6)".
                      version_restriction = version_restriction[1:-1]
                  require_update = False
                  if dependency not in result_list:
                    # Get the lastest version of the dependency on the
                    # repository that meet the version restriction
                    provider_installed = False
                    bt_dep = None
                    try:
                      bt_dep = self.getLastestBTOnRepos(dependency, version_restriction)
                    except BusinessTemplateUnknownError:
                      raise BusinessTemplateMissingDependency, 'While analysing %s the following dependency could not be satisfied: %s (%s)\nReason: Business Template could not be found in the repositories'%(bt[1], dependency, version_restriction or '')
                    except BusinessTemplateIsMeta:
                      provider_list = self.getProviderList(dependency)
                      for provider in provider_list:
1116
                        if self.getInstalledBusinessTemplate(provider) is not None:
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
                          bt_dep = self.getLastestBTOnRepos(provider)
                          break
                      if bt_dep is None:
                        bt_dep = ('meta', dependency)
                    sub_dep_list = self.getDependencyList(bt_dep)
                    for sub_dep in sub_dep_list:
                      if sub_dep not in result_list:
                        result_list.append(sub_dep)
                    result_list.append(bt_dep)
                return result_list
        raise BusinessTemplateUnknownError, 'The Business Template %s could not be found on repository %s'%(bt[1], bt[0])
1128
      return []
1129

1130 1131
    security.declareProtected(Permissions.ManagePortal,
                              'findProviderInBTList')
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
    def findProviderInBTList(self, provider_list, bt_list):
      """
       Find one provider in provider_list which is present in
       bt_list and returns the found tuple (repository, id)
       in bt_list.
      """
      for provider in provider_list:
        for repository, id in bt_list:
          if id.startswith(provider):
            return (repository, id)
      raise BusinessTemplateUnknownError, 'Provider not found in bt_list'
1143

1144 1145 1146 1147
    security.declareProtected(Permissions.AccessContentsInformation,
                              'sortBusinessTemplateList')
    def sortBusinessTemplateList(self, bt_list):
      """
1148 1149 1150 1151 1152 1153
      Sort a list of business template in repositories according to
      dependencies

      bt_list : list of (repository, id) tuple.
      """
      sorted_bt_list = []
1154
      title_id_mapping = {}
1155 1156 1157 1158 1159 1160 1161

      # Calculate the dependency graph
      dependency_dict = {}
      provition_dict = {}
      repository_dict = {}
      undependent_list = []

1162 1163 1164
      for repository, bt_id in bt_list:
        bt = [x for x in self.repository_dict[repository] \
              if x['id'] == bt_id][0]
1165 1166 1167 1168 1169 1170
        bt_title = bt['title']
        repository_dict[bt_title] = repository
        dependency_dict[bt_title] = [x.split(' ')[0] for x in bt['dependency_list']]
        title_id_mapping[bt_title] = bt_id
        if not dependency_dict[bt_title]:
          del dependency_dict[bt_title]
1171
        for provision in list(bt['provision_list']):
1172 1173
          provition_dict[provision] = bt_title
        undependent_list.append(bt_title)
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202

      # Calculate the reverse dependency graph
      reverse_dependency_dict = {}
      for bt_id, dependency_id_list in dependency_dict.items():
        update_dependency_id_list = []
        for dependency_id in dependency_id_list:

          # Get ride of provision id
          if dependency_id in provition_dict:
            dependency_id = provition_dict[dependency_id]
          update_dependency_id_list.append(dependency_id)

          # Fill incoming edge dict
          if dependency_id in reverse_dependency_dict:
            reverse_dependency_dict[dependency_id].append(bt_id)
          else:
            reverse_dependency_dict[dependency_id] = [bt_id]

          # Remove from free node list
          try:
            undependent_list.remove(dependency_id)
          except ValueError:
            pass

        dependency_dict[bt_id] = update_dependency_id_list

      # Let's sort the bt5!
      while undependent_list:
        bt_id = undependent_list.pop(0)
1203 1204 1205
        if bt_id not in repository_dict:
          continue
        sorted_bt_list.insert(0, (repository_dict[bt_id], title_id_mapping[bt_id]))
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
        for dependency_id in dependency_dict.get(bt_id, []):

          local_dependency_list = reverse_dependency_dict[dependency_id]
          local_dependency_list.remove(bt_id)
          if local_dependency_list:
            reverse_dependency_dict[dependency_id] = local_dependency_list
          else:
            del reverse_dependency_dict[dependency_id]
            undependent_list.append(dependency_id)

      if len(sorted_bt_list) != len(bt_list):
        raise NotImplementedError, \
          "Circular dependencies on %s" % reverse_dependency_dict.keys()
      else:
        return sorted_bt_list
1221

1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
    security.declareProtected(Permissions.AccessContentsInformation,
                              'sortDownloadedBusinessTemplateList')
    def sortDownloadedBusinessTemplateList(self, id_list):
      """
      Sort a list of already downloaded business templates according to
      dependencies

      id_list : list of business template's id in portal_templates.
      """
      def isDepend(a, b):
        # return True if a depends on b.
        dependency_list = [x.split(' ')[0] for x in a.getDependencyList()]
        provision_list = list(b.getProvisionList()) + [b.getTitle()]
        for i in provision_list:
          if i in dependency_list:
            return True
          return False

      sorted_bt_list = []
      for bt_id in id_list:
        bt = self._getOb(bt_id)
        for j in range(len(sorted_bt_list)):
          if isDepend(sorted_bt_list[j], bt):
            sorted_bt_list.insert(j, bt)
            break
        else:
           sorted_bt_list.append(bt)
      sorted_bt_list = [bt.getId() for bt in sorted_bt_list]
      return sorted_bt_list

Vincent Pelletier's avatar
Vincent Pelletier committed
1252 1253
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getRepositoryBusinessTemplateList' )
1254
    def getRepositoryBusinessTemplateList(self, update_only=False,
1255
             template_list=None, **kw):
1256
      """Get the list of Business Templates in repositories.
1257 1258 1259

         update_only: return only bt that needs to be updated
         template_list: only returns bt within the given list
1260 1261
      """
      from Products.ERP5Type.Document import newTempBusinessTemplate
1262 1263 1264 1265
      result_list = []
      template_set = None
      if template_list is not None:
        template_set = set(template_list)
1266 1267

      template_item_list = []
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
      # First of all, filter Business Templates in repositories.
      template_item_dict = {}
      for repository, property_dict_list in self.repository_dict.items():
        for property_dict in property_dict_list:
          title = property_dict['title']
          if template_set and not(title in template_set):
            continue
          if not update_only:
            template_item_list.append((repository, property_dict))
          else:
1278
            if title not in template_item_dict:
Vincent Pelletier's avatar
Vincent Pelletier committed
1279 1280
              # If this is the first time to see this business template,
              # insert it.
1281 1282
              template_item_dict[title] = (repository, property_dict)
            else:
Vincent Pelletier's avatar
Vincent Pelletier committed
1283 1284 1285 1286
              # If this business template has been seen before, insert it only
              # if this business template is newer.
              previous_repository, previous_property_dict = \
                  template_item_dict[title]
1287 1288
              if self.compareVersions(previous_property_dict['version'],
                                      property_dict['version']) < 0:
1289
                template_item_dict[title] = (repository, property_dict)
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
      # Next, select only updated business templates.
      if update_only:
        for repository, property_dict in template_item_dict.values():
          installed_bt = \
              self.getInstalledBusinessTemplate(property_dict['title'], strict=True)
          if installed_bt is not None:
            diff_version = self.compareVersions(installed_bt.getVersion(),
                                                property_dict['version'])
            if diff_version < 0:
              template_item_list.append((repository, property_dict))
            elif diff_version == 0 \
                  and property_dict['revision'] \
1302
                  and installed_bt.getRevision() != property_dict['revision']:
1303 1304
                    template_item_list.append((repository, property_dict))
          elif template_list is not None:
1305 1306 1307 1308 1309
            template_item_list.append((repository, property_dict))

      # Create temporary Business Template objects for displaying.
      for repository, property_dict in template_item_list:
        property_dict = property_dict.copy()
1310
        id = filename = property_dict.pop('id')
1311 1312 1313 1314
        installed_bt = \
            self.getInstalledBusinessTemplate(property_dict['title'])
        if installed_bt is not None:
          installed_version = installed_bt.getVersion()
1315 1316
          installed_revision = installed_bt.getShortRevision()
          if installed_bt.getRevision() == property_dict['revision']:
1317
            version_state = 'present'
1318 1319
          else:
            version_state = 'different'
1320 1321 1322
        else:
          installed_version = ''
          installed_revision = ''
1323
          version_state = 'new'
1324
        uid = self.encodeRepositoryBusinessTemplateUid(repository, id)
1325 1326
        obj = newTempBusinessTemplate(self, 'temp_' + uid,
                                      version_state = version_state,
1327
                                      version_state_title=version_state.title(),
1328
                                      filename = filename,
1329 1330
                                      installed_version = installed_version,
                                      installed_revision = installed_revision,
1331 1332
                                      repository = repository, **property_dict)
        obj.setUid(uid)
1333 1334 1335
        result_list.append(obj)
      result_list.sort(key=lambda x: x.getTitle())
      return result_list
1336

Vincent Pelletier's avatar
Vincent Pelletier committed
1337 1338
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getUpdatedRepositoryBusinessTemplateList' )
1339 1340 1341 1342
    def getUpdatedRepositoryBusinessTemplateList(self, **kw):
      """Get the list of updated Business Templates in repositories.
      """
      #LOG('getUpdatedRepositoryBusinessTemplateList', 0, 'kw = %r' % (kw,))
1343
      return self.getRepositoryBusinessTemplateList(update_only=True, **kw)
1344

1345
    security.declarePublic('compareVersions')
1346
    def compareVersions(self, version1, version2):
Vincent Pelletier's avatar
Vincent Pelletier committed
1347 1348 1349
      """
        Return negative if version1 < version2, 0 if version1 == version2,
        positive if version1 > version2.
1350 1351

      Here is the algorithm:
Vincent Pelletier's avatar
Vincent Pelletier committed
1352 1353
        - Non-alphanumeric characters are not significant, besides the function
          of delimiters.
1354 1355 1356 1357
        - If a level of a version number is missing, it is assumed to be zero.
        - An alphabetical character is less than any numerical value.
        - Numerical values are compared as integers.

Vincent Pelletier's avatar
Vincent Pelletier committed
1358
      This implements the following predicates:
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
        - 1.0 < 1.0.1
        - 1.0rc1 < 1.0
        - 1.0a < 1.0.1
        - 1.1 < 2.0
        - 1.0.0 = 1.0
      """
      r = re.compile('(\d+|[a-zA-Z])')
      v1 = r.findall(version1)
      v2 = r.findall(version2)

      def convert(v, i):
        """Convert the ith element of v to an interger for a comparison.
        """
        #LOG('convert', 0, 'v = %r, i = %r' % (v, i))
        try:
          e = v[i]
          try:
            e = int(e)
          except ValueError:
            # ASCII code is one byte, so this produces negative.
            e = struct.unpack('b', e)[0] - 0x200
        except IndexError:
          e = 0
        return e
1383

1384 1385 1386 1387 1388 1389 1390 1391
      for i in xrange(max(len(v1), len(v2))):
        e1 = convert(v1, i)
        e2 = convert(v2, i)
        result = cmp(e1, e2)
        if result != 0:
          return result

      return 0
1392

1393
    def _getBusinessTemplateUrlDict(self):
1394
      business_template_url_dict = {}
1395
      for bt in self.getRepositoryBusinessTemplateList():
1396
        url, name = self.decodeRepositoryBusinessTemplateUid(bt.getUid())
1397 1398 1399
        if name.endswith('.bt5'):
          name = name[:-4]
        business_template_url_dict[name] = {
Rafael Monnerat's avatar
Rafael Monnerat committed
1400
          'url': '%s/%s' % (url, bt.filename),
1401 1402 1403 1404 1405
          'revision': bt.getRevision()
          }
      return business_template_url_dict

    security.declareProtected(Permissions.ManagePortal,
Rafael Monnerat's avatar
Rafael Monnerat committed
1406
        'installBusinessTemplatesFromRepositories')
1407
    def installBusinessTemplatesFromRepositories(self, *args, **kw):
1408 1409
      """Deprecated.
      """
1410
      DeprecationWarning('installBusinessTemplatesFromRepositories is deprecated; Use self.installBusinessTemplateListFromRepository instead.', DeprecationWarning)
1411
      return self.installBusinessTemplateListFromRepository(*args, **kw)
1412

1413 1414
    security.declareProtected(Permissions.ManagePortal,
         'resolveBusinessTemplateListDependency')
1415 1416 1417
    def resolveBusinessTemplateListDependency(self,
                                              template_title_list,
                                              with_test_dependency_list=False):
1418
      available_bt5_list = self.getRepositoryBusinessTemplateList()
1419

1420
      template_title_list = set(template_title_list)
1421 1422
      installed_bt5_title_list = self.getInstalledBusinessTemplateTitleList()

1423
      bt5_set = set()
1424 1425
      for available_bt5 in available_bt5_list:
        if available_bt5.title in template_title_list:
1426
          template_title_list.remove(available_bt5.title)
1427 1428
          bt5 = self.decodeRepositoryBusinessTemplateUid(available_bt5.uid)
          bt5_set.add(bt5)
1429
          meta_dependency_set = set()
1430 1431 1432
          for dep_repository, dep_id in self.getDependencyList(
              bt5,
              with_test_dependency_list):
1433 1434 1435
            if dep_repository != 'meta':
              bt5_set.add((dep_repository, dep_id))
            else:
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
              meta_dependency_set.add((dep_repository, dep_id))
          for dep_repository, dep_id in meta_dependency_set:
            provider_list = self.getProviderList(dep_id)
            provider_installed = False
            provider_title = None
            for provider in provider_list:
              if provider in [i[1].replace(".bt5", "") for i in bt5_set] or \
                    provider in installed_bt5_title_list or \
                    provider in template_title_list:
                provider_title = provider
1446
                for candidate in available_bt5_list:
1447
                  if candidate.title == provider:
1448 1449 1450
                    bt5_set.add(\
                      self.decodeRepositoryBusinessTemplateUid(
                          candidate.uid))
1451
                    break
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
                break
            if provider_title is None and len(provider_list) == 1:
              provider_title = provider_list[0]
            LOG('resolveBT, provider_title', 0, provider_title)
            if provider_title:
              for candidate in available_bt5_list:
                if candidate.title == provider_title:
                  bt5_set.add(\
                    self.decodeRepositoryBusinessTemplateUid(
                        candidate.uid))
                  break
            else:
              raise BusinessTemplateMissingDependency,\
                "Unable to resolve dependencies for %s, options are %s" \
                    % (dep_id, provider_list)
1467 1468 1469 1470

      if len(template_title_list) > 0:
         raise BusinessTemplateUnknownError, 'The Business Template %s could not be found on repositories %s' % \
             (list(template_title_list), self.getRepositoryList())
1471 1472
      return self.sortBusinessTemplateList(list(bt5_set))

1473 1474 1475
    security.declareProtected(Permissions.ManagePortal,
        'installBusinessTemplateListFromRepository')
    def installBusinessTemplateListFromRepository(self, template_list,
1476
        only_different=True, update_catalog=False, activate=False,
1477
        install_dependency=False):
1478 1479 1480 1481
      """Installs template_list from configured repositories by default only newest"""
      # XXX-Luke: This method could replace
      # TemplateTool_installRepositoryBusinessTemplateList while still being
      # possible to reuse by external callers
1482

1483 1484
      operation_log = []
      resolved_template_list = self.resolveBusinessTemplateListDependency(
1485
                   template_list)
1486 1487
      installed_bt5_dict = {x.getTitle(): x.getRevision()
        for x in self.getInstalledBusinessTemplateList()}
1488 1489
      if only_different:
        template_url_dict = self._getBusinessTemplateUrlDict()
1490 1491

      def checkAvailability(bt_title):
1492
        return bt_title in template_list or bt_title in installed_bt5_dict
1493 1494 1495 1496 1497 1498 1499
      missing_dependency_list = [i for i in resolved_template_list
                                 if not checkAvailability(i[1].replace(".bt5", ""))]

      if not install_dependency and len(missing_dependency_list) > 0:
        raise BusinessTemplateMissingDependency,\
            "Impossible to install, please install the following dependencies before: %s" \
            % [x[1] for x in missing_dependency_list]
1500 1501

      activate_kw =  dict(activity="SQLQueue", tag="start_%s" % (time.time()))
1502
      for repository, bt_id in resolved_template_list:
1503 1504 1505
        if only_different:
          bt = template_url_dict.get(bt_id)
          if bt is not None and bt['revision'] == installed_bt5_dict.get(bt_id):
1506
            continue
1507
        bt_url = '%s/%s' % (repository, bt_id)
1508
        param_dict = dict(download_url=bt_url, only_different=only_different)
1509
        param_dict["update_catalog"] = update_catalog
1510 1511 1512 1513 1514 1515 1516

        if activate:
          self.activate(**activate_kw).\
                updateBusinessTemplateFromUrl(**param_dict)
          activate_kw["after_tag"] = activate_kw["tag"]
          activate_kw["tag"] = bt_id
          operation_log.append('Installed %s using activities' % (bt_id))
1517
        else:
1518 1519
          document = self.updateBusinessTemplateFromUrl(**param_dict)
          operation_log.append('Installed %s with revision %s' % (
1520
              document.getTitle(), document.getShortRevision()))
1521 1522

      return operation_log
1523

1524 1525 1526
    security.declareProtected(Permissions.ManagePortal,
            'updateBusinessTemplateFromUrl')
    def updateBusinessTemplateFromUrl(self, download_url, id=None,
1527 1528 1529
                                         keep_original_list=None,
                                         before_triggered_bt5_id_list=None,
                                         after_triggered_bt5_id_list=None,
1530
                                         update_catalog=False,
1531
                                         reinstall=False,
1532
                                         active_process=None,
Rafael Monnerat's avatar
Rafael Monnerat committed
1533
                                         force_keep_list=None,
1534
                                         only_different=True):
Rafael Monnerat's avatar
Rafael Monnerat committed
1535
      """
1536
        This method download and install a bt5, from a URL.
1537 1538 1539 1540 1541

        keep_original_list can be used to make paths not touched at all

        force_keep_list can be used to force path to be modified or removed
        even if template system proposes not touching it
1542
      """
1543 1544 1545 1546 1547 1548 1549 1550
      if keep_original_list is None:
        keep_original_list = []
      if before_triggered_bt5_id_list is None:
        before_triggered_bt5_id_list = []
      if after_triggered_bt5_id_list is None:
        after_triggered_bt5_id_list = []
      if force_keep_list is None:
        force_keep_list = []
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
      if active_process is None:
        installed_dict = {}
        def log(msg):
          LOG('TemplateTool.updateBusinessTemplateFromUrl', INFO, msg)
      else:
        active_process = self.unrestrictedTraverse(active_process)
        if getattr(aq_base(active_process), 'installed_dict', None) is None:
          active_process.installed_dict = PersistentMapping()
        installed_dict = active_process.installed_dict
        message_list = []
        log = message_list.append

      log("Installing %s ..." % download_url)
1564
      imported_bt5 = self.download(url = download_url, id = id)
1565 1566
      bt_title = imported_bt5.getTitle()

1567 1568 1569
      if reinstall:
        install_kw = None
      else:
1570 1571 1572 1573 1574 1575 1576
        if only_different:
          previous_bt5 = self.getInstalledBusinessTemplate(bt_title)
          if previous_bt5 and \
             imported_bt5.getRevision() == previous_bt5.getRevision():
            log("%s is already installed with revision %s"
                % (bt_title, imported_bt5.getShortRevision()))
            return imported_bt5
1577 1578 1579

        install_kw = {}
        for listbox_line in imported_bt5.BusinessTemplate_getModifiedObject():
1580 1581
          item = listbox_line.object_id
          state = listbox_line.object_state
1582
          if state.startswith('Removed'):
1583 1584 1585 1586 1587 1588 1589 1590
            # The following condition could not be used to automatically decide
            # if an item must be kept or not. For example, this would not work
            # for items installed by PortalTypeWorkflowChainTemplateItem.
            maybe_moved = installed_dict.get(listbox_line.object_id, '')
            log('%s: %s%s' % (state, item,
              maybe_moved and ' (moved to %s ?)' % maybe_moved))
          else:
            installed_dict[item] = bt_title
1591 1592 1593

          # For actions which suggest that item shall be kept and item is not
          # explicitely forced, keep the default -- do nothing
1594 1595
          # XXX: 'force_keep_list' variable is misnamed.
          should_keep = item not in force_keep_list and state in (
1596 1597
            'Modified but should be kept', 'Removed but should be kept')
          # If item is forced to be untouched, do not touch it
1598 1599
          if item in keep_original_list or should_keep:
            if not should_keep:
1600 1601 1602
              log('Item %r is in force_keep_list and keep_original_list,'
                  ' as keep_original_list has precedence item is NOT MODIFIED'
                  % item)
1603 1604 1605
            install_kw[item] = 'nothing'
          else:
            install_kw[item] = listbox_line.choice_item_list[0][1]
1606

1607 1608
      # Run before script list
      for before_triggered_bt5_id in before_triggered_bt5_id_list:
1609 1610 1611
        log('Execute %r' % before_triggered_bt5_id)
        imported_bt5.unrestrictedTraverse(before_triggered_bt5_id)()

1612 1613 1614 1615 1616 1617 1618
      # Note: CATALOG_UPDATABLE should only be used in eceptional cases
      #       where the caller installs several bts and does not know
      #       which ones need to update catalog. Handling catalog should be
      #       usually done at upgrader level.
      if update_catalog is CATALOG_UPDATABLE and install_kw != {}:
        update_catalog = imported_bt5.isCatalogUpdatable()

1619 1620
      imported_bt5.install(object_to_update=install_kw,
                           update_catalog=update_catalog)
1621

1622 1623
      # Run After script list
      for after_triggered_bt5_id in after_triggered_bt5_id_list:
1624 1625 1626 1627 1628 1629 1630 1631
        log('Execute %r' % after_triggered_bt5_id)
        imported_bt5.unrestrictedTraverse(after_triggered_bt5_id)()
      if active_process is not None:
        active_process.postResult(ActiveResult(
          '%03u. %s' % (len(active_process.getResultList()) + 1, bt_title),
          detail='\n'.join(message_list)))
      else:
        log("Updated %s from %s" % (bt_title, download_url))
1632

1633 1634
      return imported_bt5

1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
    security.declareProtected(Permissions.ManagePortal,
            'installMultipleBusinessPackage')
    def installMultipleBusinessPackage(self, bp5_list):
      """
      Install multiple Business Package at the same time
      """
      # XXX: Compare before calling install on path object property items
      from Products.ERP5.Document.BusinessPackage import \
                    ObjectPropertyTemplatePackageItem, PathTemplatePackageItem

      final_path_item = bp5_list[0]._path_item
      final_prop_item = bp5_list[0]._object_property_item

      for bp5 in bp5_list:
        final_path_item += bp5._path_item
        final_prop_item += bp5._object_property_item

      final_path_item.install()
      final_prop_item.install()

1655
    security.declareProtected(Permissions.ManagePortal,
1656 1657
            'installBusinessManager')
    def installBusinessManager(self, bm):
1658
      """
1659
      Run installation on flattened Business Manager
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
      # Run install on separate Business Item one by one
      for path_item in bm._path_item_list:
        path_item.install(self)

      bm.setStatus('installed')

    security.declareProtected(Permissions.ManagePortal,
            'updateInstallationState')
    def updateInstallationState(self, bm_list):
      """
      Run installation after comparing combined Business Manager status

      Steps:
      1. Create combinedBM for the bm_list
      2. Get the old combinedBM by checking the 'installed' status for it or
      by checking timestamp (?? which is better)
      CombinedBM: Collection of all Business item(s) whether installed or
      uninstalled
      3. Build BM from the filesystem
      4. Compare the combinedBM state to the last combinedBM state
      5. Compare the installation state to the OFS state
      6. If conflict while comaprison at 3, raise the error
      7. In all other case, install the BM List
      """
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 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
      # Create old installation state from Instsalled Business Manager
      installed_bm_list = self.getInstalledBusinessManagerList()
      combined_installed_path_item = [item for bm
                                      in installed_bm_list
                                      for item in bm._path_item_list]

      # Create BM for old installation state and update its path item list
      old_installation_state = self.newContent(
                                  portal_type='Business Manager',
                                  title='Old Installation State',
                                  )
      old_installation_state._path_item_list = combined_installed_path_item

      forbidden_bm_title_list = ['Old Installation State',]
      for bm in bm_list:
        forbidden_bm_title_list.append(bm.title)

      new_installed_bm_list = [l for l
                               in self.getInstalledBusinessManagerList()
                               if l.title not in forbidden_bm_title_list]
      new_installed_bm_list.extend(bm_list)

      combined_new_path_item = [item for bm
                                in new_installed_bm_list
                                for item in bm._path_item_list]

      # Create BM for new installation state and update its path item list
      new_installation_state = self.newContent(
                                  portal_type='Business Manager',
                                  title='New Installation State',
                                  )
      new_installation_state._path_item_list = combined_new_path_item

      # Create installation process, which have the changes to be made in the
      # OFS during installation. Importantly, it should also be a Business Manager
      installation_process = self.newContent(
                                  portal_type='Business Manager',
                                  title='Installation Process',
                                  )

      # Get path list for old and new states
      old_state_path_list = old_installation_state.getPathList()
      new_state_path_list = new_installation_state.getPathList()

      to_install_path_item_list = []

      # Get the path which has been removed in new installation_state
      removed_path_list = [path for path
                           in old_state_path_list
                           if path not in new_state_path_list]

      # Add the removed path with negative sign in the to_install_path_item_list
      for path in removed_path_list:
        old_item = old_installation_state.getBusinessItemByPath(path)
        old_item._sign = -1
        to_install_path_item_list.append(old_item)

1742 1743 1744 1745
      # Update hashes of item in old state before installation
      for item in old_installation_state._path_item_list:
        item._sha = self.calculateComparableHash(item._value)

1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
      # Path Item List for installation_process should be the difference between
      # old and new installation state
      for item in new_installation_state._path_item_list:
        # If the path has been removed, then add it with sign = -1
        old_item = old_installation_state.getBusinessItemByPath(item._path)
        if old_item:
          # If the old_item exists, we match the hashes and if it differs, then
          # add the new item
          if old_item._sha != item._sha:
            to_install_path_item_list.append(item)
        else:
          to_install_path_item_list.append(item)

      installation_process._path_item_list = to_install_path_item_list

1761
      error_list = self.compareOldStateToOFS(installation_process, old_installation_state)
1762 1763 1764 1765 1766

      # Change status of all BM installed
      for bm in bm_list:
        bm.setStatus('installed')

1767 1768 1769
      if error_list:
        raise ValueError(' '.join(error_list))

1770 1771
    installMultipleBusinessManager = updateInstallationState

1772 1773 1774
    def calculateComparableHash(self, object):
      """
      Remove some attributes before comparing hashses
Ayush Tiwari's avatar
Ayush Tiwari committed
1775 1776
      and return hash of the comparable object dict, in case the object is
      an erp5 object.
1777 1778 1779 1780 1781

      Use shallow copy of the dict of the object at ZODB after removing
      attributes which changes at small updation, like workflow_history,
      uid, volatile attributes(which starts with _v)
      """
Ayush Tiwari's avatar
Ayush Tiwari committed
1782 1783 1784 1785 1786 1787 1788
      if object.__class__.__name__ == 'PersistentMapping':
        obj_dict = object
      else:
        obj_dict = object.__dict__.copy()
        removable_attributes = [attr for attr
                                in obj_dict.keys()
                                if attr.startswith('_v')]
1789

Ayush Tiwari's avatar
Ayush Tiwari committed
1790 1791 1792
        removable_attributes.append('uid')
        for attr in removable_attributes:
          del obj_dict[attr]
1793 1794 1795 1796

      obj_sha = hash(pprint.pformat(obj_dict))
      return obj_sha

1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
    def compareOldStateToOFS(self, installation_process, old_state):

      # Get the paths about which we are concerned about
      to_update_path_list = installation_process.getPathList()
      portal = self.getPortalObject()

      error_list = []

      for path in to_update_path_list:

        try:
Ayush Tiwari's avatar
Ayush Tiwari committed
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
          if '#' in str(path):
            relative_url, property_id = path.split('#')
            obj = portal.restrictedTraverse(relative_url)
            property_value = obj.getProperty(property_id)

            # If the value at ZODB for the property is none, raise KeyError
            # This is important to have compatibility between the way we check
            # path as well as property. Otherwise, if we install a new property,
            # we are always be getting an Error that there is change made at
            # ZODB for this property
            if not property_value:
              raise KeyError
            property_type = obj.getPropertyType(property_id)
            # Create a persistent object to compare the hash
            value = PersistentMapping()
            value['name'] = property_id
            value['type'] = property_type
            value['value'] = property_value
            obj = value
          else:
            obj = portal.restrictedTraverse(path)

1830
          obj_sha = self.calculateComparableHash(obj)
1831

1832
          # Get item at old state
1833
          old_item = old_state.getBusinessItemByPath(path)
1834 1835 1836 1837 1838
          # Check if there is an object at old state at this path

          if old_item:
            # Compare hash with ZODB

1839
            if old_item._sha == obj_sha:
1840 1841 1842 1843
              # No change at ZODB on old item, so get the new item
              new_item = installation_process.getBusinessItemByPath(path)
              # Compare new item hash with ZODB

1844
              if new_item._sha == obj_sha:
1845 1846 1847 1848 1849 1850
                if new_item._sign == -1:
                  # If the sign is negative, remove the value from the path
                  new_item.install(installation_process)
                else:
                  # If same hash, and +1 sign, do nothing
                  continue
1851 1852 1853 1854 1855 1856 1857 1858 1859 1860

              else:
                # Install the new_item
                new_item.install(installation_process)

            else:
              # Change at ZODB, so get the new item
              new_item = installation_process.getBusinessItemByPath(path)
              # Compare new item hash with ZODB

1861
              if new_item._sha == obj_sha:
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
                # If same hash, do nothing
                continue

              else:
                # Raise error
                error_list.append('Trying to remove changes at ZODB at %s' % path)

          else:
            # Object created at ZODB by the user
            # Compare with the new_item

            new_item = installation_process.getBusinessItemByPath(path)
1874
            if new_item._sha == obj_sha:
1875 1876 1877 1878 1879 1880 1881
              # If same hash, do nothing
              continue

            else:
              # Raise error
              error_list.append('Trying to remove changes at ZODB at %s' % path)

1882
        except KeyError:
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
          # Get item at old state
          old_item = old_state.getBusinessItemByPath(path)
          # Check if there is an object at old state at this path

          if old_item:
            # This means that the user had removed the object at this path
            # Check what the sign is for the new_item
            new_item = installation_process.getBusinessItemByPath(path)
            # Check sign of new_item

            if new_item._sign == 1:
              error_list.append('Object at %s removed by user' % path)

          else:
            # If there is  no item at old state, install the new_item
            new_item = installation_process.getBusinessItemByPath(path)
1899 1900 1901 1902 1903
            # XXX: Hack for not trying to install the sub-objects from zexp,
            # This should rather be implemneted while exportign the object,
            # where we shouldn't export sub-objects in the zexp
            if new_item._value._tree:
              del new_item._value._tree
1904 1905
            new_item.install(installation_process)

1906 1907
      return error_list

1908 1909 1910 1911 1912 1913 1914 1915 1916
    security.declareProtected(Permissions.ManagePortal,
            'createNewInstallationState')
    def createNewInstallationState(self, bm_list, old_installation_state):
      """
      Combines multiple BM to form single BM which would be the new
      installtion state
      """
      new_bm_list = bm_list[:]

1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
      # Create a list of path and hashes to be used for comparison
      path_list = []
      sha_list = []
      forbidden_bm_title_list = ['Installation State',]

      for bm in new_bm_list:
        forbidden_bm_title_list.append(bm.title)
        for item in bm._path_item_list:
          path_list.append(item._path)
          sha_list.append(item._sha)

      installed_bm_list = [l for l
                           in self.getInstalledBusinessManagerList()
                           if l.title not in forbidden_bm_title_list]
      new_bm_list.extend(installed_bm_list)

1933 1934 1935 1936 1937 1938 1939 1940
      # Summation should also consider arithmetic on the Business Item(s)
      # having same path and layer and combine them.
      combinedBM = self.newContent(portal_type='Business Manager',
                                   title='Combined Business Manager')
      combinedBM.build()
      new_bm_list.insert(0, combinedBM)
      combinedBM = reduce(lambda x, y: x+y, new_bm_list)

1941
      final_path_list = combinedBM.getTemplatePathList()
1942 1943 1944 1945
      final_path_item_list = []

      final_path_item_list.extend(combinedBM._path_item_list)

1946 1947 1948
      removable_sha_list = []
      removable_path_list = []

1949
      for item in old_installation_state._path_item_list:
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
        if item._path in path_list and item._sha in sha_list:
          # If there is Business Item which have no change on updation, then
          # no need to reinstall it, cause in that case we prefer the changes
          # at ZODB

          # XXX: BAD DESIGN: Should compare both path as well as hash and keep
          # them together in a dictionary,using them separately can lead to
          # conflict in case two paths have same hash.
          removable_sha_list.append(item._sha)
          removable_path_list.append(item._path)
        else:
1961 1962 1963
          # If there is update of path item, change the sign of the last
          # version of that Business Item and add it to final_path_item_list
          item._sign = -1
1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976
          final_path_item_list.append(item)

      final_path_list.extend(old_installation_state.getTemplatePathList())

      # Remove the Business Item objects from final_path_item_list which have
      # same sha and path
      final_path_list = [path for path
                         in final_path_list
                         if path not in removable_path_list]

      final_path_item_list = [item for item
                              in final_path_item_list
                              if item._sha not in removable_sha_list]
1977 1978

      final_path_item_list.sort(key=lambda x: x._sign)
1979

1980 1981 1982
      # Remove the old installation state
      self._delObject(old_installation_state.getId())

1983 1984 1985 1986
      combinedBM._setTemplatePathList(final_path_list)
      combinedBM._path_item_list = final_path_item_list

      # Change the title of the combined BM
1987
      combinedBM.setTitle('Installation State')
1988 1989 1990

      # XXX: We are missing the part of creating installed_BM for all the BM
      # we have in bm_list, because this would be needed in case we build
1991
      # Business Manager again.
1992 1993

      # Reduce the final Business Manager
1994
      #combinedBM.reduceBusinessManager()
1995 1996

      return combinedBM
1997

1998
    security.declareProtected(Permissions.ManagePortal,
1999
            'compareInstallationStateWithOFS')
2000 2001
    def compareInstallationStateWithOFS(self, buildBM, new_installation_state,
            old_installation_state):
2002
      """
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
      Compare the buildBM and to be installed BM and show the changes in a way
      it can be notified or installed.

      1. Compare the hash of the objects and create a diff file in case of
      conflict
      2. If forced installation, delete the old object and install the ones
      from update Business Manager

      Returns:

      - has_confict: True , if there is a conflict between the 2 BMs
      - DiffFile: In case there is conflict between the two states
2015
      """
2016 2017 2018
      # XXX: BAD DESIGN: Should compare both path as well as hash, just path
      # can lead to conflict in case two paths have same sha.
      built_item_dict = {
2019 2020
                        item._path: item._sha for item
                        in buildBM._path_item_list
2021 2022 2023
                        }

      old_item_dict = {
2024 2025
                      item._path: item._sha for item
                      in old_installation_state._path_item_list
2026 2027 2028 2029 2030 2031
                      }

      # For creating new_item_dict, we have to take use of template_path_list
      # property as there can be case where we have path but not path_item as
      # the new state already gets filtered while creation
      new_item_dict = {
2032 2033 2034
                      item._path: item._sha for item
                      in new_installation_state._path_item_list
                      if item._sign == 1
2035 2036 2037
                      }

      build_sha_list = built_item_dict.values()
2038 2039
      final_item_list = []

2040 2041 2042 2043 2044 2045
      for item in new_installation_state._path_item_list:
        if item._sign == 1:
          if path in old_item_dict.keys():
            if old_item_dict[path] == item._sha:
              pass

2046 2047 2048 2049
      for item in new_installation_state._path_item_list:
        if item._sha in build_sha_list and item._sign == 1:
          # No need to install value which we already have
          continue
2050
        else:
2051 2052 2053
          final_item_list.append(item)

      new_installation_state._path_item_list = final_item_list
2054

2055
    security.declareProtected(Permissions.ManagePortal,
2056 2057
            'compareMultipleBusinessManager')
    def compareBusinessManager(self, new_bm, old_bm):
2058
      """
2059 2060 2061
      Compare two business manager and return a new Business manager based on
      the difference. This is specially required to compare two versions of
      Business Manager(s).
2062
      """
2063 2064 2065
      compared_bm = new_bm - old_bm
      # Return the subtraction of the Business Manager
      return compared_bm
2066

2067 2068
    security.declareProtected(Permissions.ManagePortal,
            'cleanInstallationState')
2069 2070 2071 2072
    def cleanInstallationState(self, installation_state):
      """
      Installation State is the Business Manager which has been installed
      Cleaning means removal of all the Business Item with negative sign
2073

2074 2075 2076
      **WARNING**:This should only be done after installing the Business Manager
      """
      if installation_state.getStatus() != 'installed':
2077
        LOG('WARNING', 0, 'Trying to clean installation state before installing')
2078
        raise ValueError, "Can't clean before installing"
2079

2080
      final_path_item_list = []
2081

2082 2083 2084
      for item in installation_state._path_item_list:
        if item._sign == 1:
          final_path_item_list.append(item)
2085

2086
      installation_state._path_item_list = final_path_item_list
2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099

    def getInstalledBusinessManagerList(self):
      bm_list = self.objectValues(portal_type='Business Manager')
      installed_bm_list = [bm for bm in bm_list if bm.getStatus() == 'installed']
      return installed_bm_list

    def getInstalledBusinessManagerTitleList(self):
      installed_bm_list = self.getInstalledBusinessManagerList()
      if not len(installed_bm_list):
        return []
      installed_bm_title_list = [bm.title for bm in installed_bm_list]
      return installed_bm_title_list

2100 2101 2102 2103 2104 2105 2106
    security.declareProtected(Permissions.ManagePortal,
            'getBusinessTemplateUrl')
    def getBusinessTemplateUrl(self, base_url_list, bt5_title):
      """
        This method verify if the business template are available
        into one url (repository).
      """
2107 2108
      if base_url_list is None:
        base_url_list = self.getRepositoryList()
2109 2110 2111 2112 2113
      # This list could be preconfigured at some properties or
      # at preferences.
      for base_url in base_url_list:
        url = "%s/%s" % (base_url, bt5_title)
        if base_url == "INSTANCE_HOME_REPOSITORY":
Rafael Monnerat's avatar
Rafael Monnerat committed
2114
          url = "file://%s/bt5/%s" % (getConfiguration().instancehome,
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
                                      bt5_title)
          LOG('ERP5', INFO, "TemplateTool: INSTANCE_HOME_REPOSITORY is %s." \
              % url)
        try:
          urllib2.urlopen(url)
          return url
        except (urllib2.HTTPError, OSError):
          # XXX Try again with ".bt5" in case the folder format be used
          # Instead tgz one.
          url = "%s.bt5" % url
          try:
            urllib2.urlopen(url)
            return url
          except (urllib2.HTTPError, OSError):
            pass
Rafael Monnerat's avatar
Rafael Monnerat committed
2130
      LOG('ERP5', INFO, 'TemplateTool: %s was not found into the url list: '
2131 2132 2133
                        '%s.' % (bt5_title, base_url_list))
      return None

2134 2135 2136
    security.declareProtected(Permissions.ManagePortal,
        'upgradeSite')
    def upgradeSite(self, bt5_list, deprecated_after_script_dict=None,
2137 2138
                    deprecated_reinstall_set=None, dry_run=False,
                    delete_orphaned=False,
2139 2140
                    keep_bt5_id_set=[],
                    update_catalog=False):
2141 2142 2143 2144 2145 2146 2147
      """
      Upgrade many business templates at a time. bt5_list should
      contains only final business templates, then all dependencies
      are calculated, and missing business templates will be added,
      old business templates will be updated, and orphelin business
      templates will be deleted

2148 2149 2150
      keep_bt5_id_set: business template that should not be deleted.
                       This is useful if we want to keep an old business
                       template without updating it and without removing it
2151

2152 2153
      deprecated_reinstall_set: this parameter is obsolete, please set
                                force_install property at business template level
2154 2155
                                It list all business templates who needs
                                reinstall
2156 2157 2158 2159 2160 2161

      update_catalog: handling catalog should be handled outside upgradeSite.
                      This option only exists for the case where it is not
                      known which bts need catalog update. In this case one
                      can pass CATALOG_UPDATABLE which will be propagated to
                      updateBusinessTemplateFromUrl.
2162
      """
2163
      # make sure that we updated information on repository
2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
      self.updateRepositoryBusinessTemplateList(self.getRepositoryList())
      # do upgrade
      message_list = []
      deprecated_reinstall_set = deprecated_reinstall_set or set()
      def append(message):
        message_list.append(message)
        LOG('upgradeSite', 0, message)
      dependency_list = [x[1] for x in \
        self.resolveBusinessTemplateListDependency(bt5_list)]
      update_bt5_list = self.getRepositoryBusinessTemplateList(
        template_list=dependency_list)
      update_bt5_list.sort(key=lambda x: dependency_list.index(x.title))
      for bt5 in update_bt5_list:
2177
        reinstall = bt5.title in deprecated_reinstall_set or bt5.force_install
2178 2179
        if (not(reinstall) and bt5.version_state == 'present') or \
            bt5.title in keep_bt5_id_set:
2180 2181 2182 2183 2184
          continue
        append("Update %s business template in state %s%s" % \
          (bt5.title, bt5.version_state, (reinstall and ' (reinstall)') or ''))
        if not(dry_run):
          bt5_url = "%s/%s" % (bt5.repository, bt5.title)
2185 2186
          self.updateBusinessTemplateFromUrl(bt5_url, reinstall=reinstall,
                                             update_catalog=update_catalog)
2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
      if delete_orphaned:
        if keep_bt5_id_set is None:
          keep_bt5_id_set = set()
        to_remove_bt5_list = [x for x in self.getInstalledBusinessTemplateList()
                              if x.title not in dependency_list]
        sorted_to_remove_bt5_id_list = self.sortDownloadedBusinessTemplateList(
                                  [x.id for x in to_remove_bt5_list])
        sorted_to_remove_bt5_id_list.reverse()
        to_remove_bt5_list.sort(
          key=lambda x: sorted_to_remove_bt5_id_list.index(x.id))
        for bt in to_remove_bt5_list:
          if bt.title in keep_bt5_id_set:
            continue
          append("Uninstall business template %s" % bt.title)
2201
          if not(dry_run):
2202 2203 2204
            # XXX Here is missing parameters to really remove stuff
            bt.uninstall()

2205 2206
      return message_list

Jean-Paul Smets's avatar
Jean-Paul Smets committed
2207
InitializeClass(TemplateTool)