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

29
from webdav.client import Resource
Jean-Paul Smets's avatar
Jean-Paul Smets committed
30 31
from Products.CMFCore.utils import UniqueObject

Yoshinori Okuji's avatar
Yoshinori Okuji committed
32
from App.config import getConfiguration
Aurel's avatar
Aurel committed
33
import os, tarfile, string, commands, OFS
Yoshinori Okuji's avatar
Yoshinori Okuji committed
34

35
from Acquisition import Implicit, aq_base
Jean-Paul Smets's avatar
Jean-Paul Smets committed
36
from AccessControl import ClassSecurityInfo
37
from Globals import InitializeClass, DTMLFile, PersistentMapping
Jean-Paul Smets's avatar
Jean-Paul Smets committed
38
from Products.ERP5Type.Tool.BaseTool import BaseTool
Jean-Paul Smets's avatar
Jean-Paul Smets committed
39
from Products.ERP5Type import Permissions
Aurel's avatar
Aurel committed
40
from Products.ERP5.Document.BusinessTemplate import TemplateConditionError
41
from Products.ERP5.Document.BusinessTemplate import BusinessTemplateMissingDependency
42
from tempfile import mkstemp, mkdtemp
Jean-Paul Smets's avatar
Jean-Paul Smets committed
43
from Products.ERP5 import _dtmldir
Aurel's avatar
Aurel committed
44 45 46
from OFS.Traversable import NotFound
from difflib import unified_diff
from cStringIO import StringIO
Jean-Paul Smets's avatar
Jean-Paul Smets committed
47
from zLOG import LOG
48
from urllib import pathname2url, urlopen, splittype, urlretrieve, quote
49 50 51 52
import re
from xml.dom.minidom import parse
import struct
import cPickle
53 54 55 56
try:
  from base64 import b64encode, b64decode
except ImportError:
  from base64 import encodestring as b64encode, decodestring as b64decode
57 58
from Products.ERP5Type.Message import Message
N_ = lambda msgid, **kw: Message('ui', msgid, **kw)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
59

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
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

76 77
class LocalConfiguration(Implicit):
  """
Vincent Pelletier's avatar
Vincent Pelletier committed
78
    Contains local configuration information
79 80 81 82 83 84 85
  """
  def __init__(self, **kw):
    self.__dict__.update(kw)

  def update(self, **kw):
    self.__dict__.update(kw)

Jean-Paul Smets's avatar
Jean-Paul Smets committed
86
class TemplateTool (BaseTool):
Jean-Paul Smets's avatar
Jean-Paul Smets committed
87
    """
88
      TemplateTool manages Business Templates.
Jean-Paul Smets's avatar
Jean-Paul Smets committed
89

90 91 92 93 94 95
      TemplateTool provides some methods to deal with Business Templates:
        - download
        - publish
        - install
        - update
        - save
Jean-Paul Smets's avatar
Jean-Paul Smets committed
96 97
    """
    id = 'portal_templates'
98
    title = 'Template Tool'
Jean-Paul Smets's avatar
Jean-Paul Smets committed
99
    meta_type = 'ERP5 Template Tool'
Jean-Paul Smets's avatar
Jean-Paul Smets committed
100
    portal_type = 'Template Tool'
101
    allowed_types = ( 'ERP5 Business Template',)
102 103 104
    
    # This stores information on repositories.
    repository_dict = {}
Jean-Paul Smets's avatar
Jean-Paul Smets committed
105 106 107 108 109

    # Declarative Security
    security = ClassSecurityInfo()

    security.declareProtected( Permissions.ManagePortal, 'manage_overview' )
Aurel's avatar
Aurel committed
110
    manage_overview = DTMLFile( 'explainTemplateTool', _dtmldir )
Jean-Paul Smets's avatar
Jean-Paul Smets committed
111

112 113
    def getInstalledBusinessTemplate(self, title, **kw):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
114
        Return an installed version of business template of a certain title.
115 116
      """
      # This can be slow if, say, 10000 business templates are present.
Vincent Pelletier's avatar
Vincent Pelletier committed
117 118 119
      # 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.
120 121 122 123
      for bt in self.contentValues(filter={'portal_type':'Business Template'}):
        if bt.getInstallationState() == 'installed' and bt.getTitle() == title:
          return bt
      return None
124
        
125
    # Christophe Dumez <christophe@nexedi.com>
126 127 128 129 130 131 132 133
    def getInstalledBusinessTemplatesList(self):
      """Get list of installed business templates
      """
      installed_bts = []
      for bt in self.contentValues(filter={'portal_type':'Business Template'}):
        if bt.getInstallationState() == 'installed':
          installed_bts.append(bt)
      return installed_bts
134 135 136 137 138 139 140 141 142 143
        
    # Christophe Dumez <christophe@nexedi.com>
    def getBuiltBusinessTemplatesList(self):
      """Get list of built and not_installed business templates
      """
      built_bts = []
      for bt in self.contentValues(filter={'portal_type':'Business Template'}):
        if bt.getInstallationState() == 'not_installed' and bt.getBuildingState() == 'built':
          built_bts.append(bt)
      return built_bts
144

145 146 147 148 149 150 151 152
    security.declareProtected(Permissions.ManagePortal,
                              'getDefaultBusinessTemplateDownladURL')
    def getDefaultBusinessTemplateDownladURL(self):
      """Returns the default download URL for business templates.
      """
      return "file://%s/" % pathname2url(
                  os.path.join(getConfiguration().instancehome, 'bt5'))

153
    def updateLocalConfiguration(self, template, **kw):
Vincent Pelletier's avatar
Vincent Pelletier committed
154 155 156 157
      """
        Call the update method on the configuration, create if it doesn't
        exists.
      """
158
      template_id = template.getId()
Vincent Pelletier's avatar
Vincent Pelletier committed
159 160
      if getattr(self, '_local_configuration', None) is None:
        self._local_configuration = PersistentMapping()
161 162 163 164 165 166
      if not self._local_configuration.has_key(template_id):
        self._local_configuration[template_id] = LocalConfiguration(**kw)
      else:
        self._local_configuration[template_id].update(**kw)

    def getLocalConfiguration(self, template):
Vincent Pelletier's avatar
Vincent Pelletier committed
167 168 169 170
      """
        Return the configuration for the given business template, or None if
        it's not defined.
      """
171
      template_id = template.getId()
Vincent Pelletier's avatar
Vincent Pelletier committed
172 173
      if getattr(self, '_local_configuration', None) is None:
        self._local_configuration = PersistentMapping()
174 175
      local_configuration = self._local_configuration.get(template_id, None)
      if local_configuration is not None:
176
        return local_configuration.__of__(template)
177 178
      return None

179 180
    security.declareProtected( 'Import/Export objects', 'save' )
    def save(self, business_template, REQUEST=None, RESPONSE=None):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
181
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
182
        Save the BusinessTemplate in the servers's filesystem.
Yoshinori Okuji's avatar
Yoshinori Okuji committed
183 184
      """
      cfg = getConfiguration()
Vincent Pelletier's avatar
Vincent Pelletier committed
185 186
      path = os.path.join(cfg.clienthome,
                          '%s' % (business_template.getTitle(),))
187
      path = pathname2url(path)
Aurel's avatar
Aurel committed
188
      business_template.export(path=path, local=1)
189
      if REQUEST is not None:
190 191 192
        psm = N_('Saved+in+${path}+.',
                  mapping={'path': pathname2url(path)})
        ret_url = '%s/%s?portal_status_message=%s' % \
Vincent Pelletier's avatar
Vincent Pelletier committed
193
                  (business_template.absolute_url(),
194
                   REQUEST.get('form_id', 'view'), psm)
Vincent Pelletier's avatar
Vincent Pelletier committed
195 196 197
        if RESPONSE is None:
          RESPONSE = REQUEST.RESPONSE
        return REQUEST.RESPONSE.redirect( ret_url )
198 199 200 201

    security.declareProtected( 'Import/Export objects', 'export' )
    def export(self, business_template, REQUEST=None, RESPONSE=None):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
202 203
        Export the Business Template as a bt5 file and offer the user to
        download it.
204
      """
205
      path = business_template.getTitle()
206
      path = pathname2url(path)
207 208 209 210
      # XXX Why is it necessary to create a temporary directory?
      tmpdir_path = mkdtemp() 
      # XXX not thread safe
      current_directory = os.getcwd() 
211
      os.chdir(tmpdir_path)
Aurel's avatar
Aurel committed
212
      export_string = business_template.export(path=path)
213
      os.chdir(current_directory)
214
      if RESPONSE is not None:
215
        RESPONSE.setHeader('Content-type','tar/x-gzip')
216
        RESPONSE.setHeader('Content-Disposition',
217
                           'inline;filename=%s-%s.bt5' % \
218
                               (path, 
219
                                business_template.getVersion()))
Aurel's avatar
Aurel committed
220 221 222 223
      try:
        return export_string.getvalue()
      finally:
        export_string.close()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
224

225
    security.declareProtected( 'Import/Export objects', 'publish' )
226 227
    def publish(self, business_template, url, username=None, password=None):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
228
        Publish the given business template at the given URL.
229 230
      """
      business_template.build()
Vincent Pelletier's avatar
Vincent Pelletier committed
231 232
      export_string = self.manage_exportObject(id=business_template.getId(),
                                               download=1)
233
      bt = Resource(url, username=username, password=password)
Vincent Pelletier's avatar
Vincent Pelletier committed
234 235
      bt.put(file=export_string,
             content_type='application/x-erp5-business-template')
236
      business_template.setPublicationUrl(url)
Jean-Paul Smets's avatar
Jean-Paul Smets committed
237

238 239
    def update(self, business_template):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
240
        Update an existing template from its publication URL.
241 242 243 244 245 246
      """
      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
247
      self._importObjectFromFile(StringIO(export_string), id=id)
248

Aurel's avatar
Aurel committed
249 250
    def _importBT(self, path=None, id=id):
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
251
        Import template from a temp file (as uploaded by the user)
Aurel's avatar
Aurel committed
252 253
      """
      file = open(path, 'r')
254 255 256 257 258 259 260
      try:
        # read magic key to determine wich kind of bt we use
        file.seek(0)
        magic = file.read(5)
      finally:
        file.close()
        
Aurel's avatar
Aurel committed
261 262 263 264
      if magic == '<?xml': # old version
        self._importObjectFromFile(path, id=id)
        bt = self[id]
        bt.id = id # Make sure id is consistent
265
        bt.setProperty('template_format_version', 0, type='int')
Aurel's avatar
Aurel committed
266
      else: # new version
Vincent Pelletier's avatar
Vincent Pelletier committed
267 268
        # XXX: should really check for a magic and offer a falback if it
        # doens't correspond to anything handled.
Aurel's avatar
Aurel committed
269
        tar = tarfile.open(path, 'r:gz')
270 271
        try:
          # create bt object
272
          bt = self.newContent(portal_type='Business Template', id=id)
273 274
          prop_dict = {}
          for prop in bt.propertyMap():
Aurel's avatar
Aurel committed
275
            prop_type = prop['type']
276 277 278 279 280 281 282
            pid = prop['id']
            prop_path = os.path.join(tar.members[0].name, 'bt', pid)
            try:
              info = tar.getmember(prop_path)
            except KeyError:
              continue
            value = tar.extractfile(info).read()
Jean-Paul Smets's avatar
Jean-Paul Smets committed
283 284
            if prop_type == 'text' or prop_type == 'string' \
                                   or prop_type == 'int':
285
              prop_dict[pid] = value
Aurel's avatar
Aurel committed
286
            elif prop_type == 'lines' or prop_type == 'tokens':
287 288 289 290 291
              prop_dict[pid[:-5]] = value.split(str(os.linesep))
          prop_dict.pop('id', '')
          bt.edit(**prop_dict)
          # import all other files from bt
          fobj = open(path, 'r')
292
          try:
293 294 295 296 297
            bt.importFile(file=fobj)
          finally:
            fobj.close()
        finally:
          tar.close()
Aurel's avatar
Aurel committed
298 299
      return bt

300
    security.declareProtected( Permissions.ManagePortal, 'manage_download' )
301 302
    def manage_download(self, url, id=None, REQUEST=None):
      """The management interface for download.
303
      """
304 305
      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)
306

307
      bt = self.download(url, id=id)
308 309
            
      if REQUEST is not None:
310 311 312 313
        ret_url = bt.absolute_url() + '/view'
        psm = N_("Business+Template+Downloaded+Successfully")
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s" 
                                    % (ret_url, psm))
314 315 316 317

    security.declareProtected( 'Import/Export objects', 'download' )
    def download(self, url, id=None, REQUEST=None):
      """
318
      Download Business Template from url, can be file or local directory
319
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
320 321
      # For backward compatibility: If REQUEST is passed, it is likely that we
      # come from the management interface.
322
      if REQUEST is not None:
323
        return self.manage_download(url, id=id, REQUEST=REQUEST)
324 325 326
      
      if id is None:
        id = self.generateNewId()
327

Aurel's avatar
Aurel committed
328
      urltype, name = splittype(url)
Vincent Pelletier's avatar
Vincent Pelletier committed
329 330
      if os.path.isdir(name): # new version of business template in plain
                              # format (folder)
331 332
        file_list = []
        def callback(arg, directory, files):
Vincent Pelletier's avatar
Vincent Pelletier committed
333 334
          if 'CVS' not in directory and '.svn' not in directory: # XXX:
                                                        # possible side-effects
335 336
            for file in files:
              file_list.append(os.path.join(directory, file))
337

Yoshinori Okuji's avatar
Yoshinori Okuji committed
338
        os.path.walk(name, callback, None)
Aurel's avatar
Aurel committed
339 340
        file_list.sort()
        # import bt object
341 342
        bt = self.newContent(portal_type='Business Template', id=id)
        id = bt.getId()
Aurel's avatar
Aurel committed
343 344 345
        bt_path = os.path.join(name, 'bt')

        # import properties
346
        prop_dict = {}
Aurel's avatar
Aurel committed
347
        for prop in bt.propertyMap():
Aurel's avatar
Aurel committed
348
          prop_type = prop['type']
Aurel's avatar
Aurel committed
349
          pid = prop['id']
350 351 352
          prop_path = os.path.join('.', bt_path, pid)
          if not os.path.exists(prop_path):
            continue          
Aurel's avatar
Aurel committed
353
          value = open(prop_path, 'r').read()
Aurel's avatar
Aurel committed
354
          if prop_type in ('text', 'string', 'int', 'boolean'):
355
            prop_dict[pid] = value
Aurel's avatar
Aurel committed
356
          elif prop_type in ('lines', 'tokens'):
357
            prop_dict[pid[:-5]] = value.split(str(os.linesep))
358
        prop_dict.pop('id', '')
359
        bt.edit(**prop_dict)
Aurel's avatar
Aurel committed
360 361 362
        # import all others objects
        bt.importFile(dir=1, file=file_list, root_path=name)
      else:
363 364 365 366 367 368 369 370 371
        tempid, temppath = mkstemp()
        try:
          os.close(tempid) # Close the opened fd as soon as possible.    
          file, headers = urlretrieve(url, temppath)
          if id is None:
            id = str(self.generateNewId())
          bt = self._importBT(temppath, id)
        finally:
          os.remove(temppath)
372
      bt.build(no_action=1)
373
      bt.reindexObject()
374
      return bt
Jean-Paul Smets's avatar
Jean-Paul Smets committed
375

376 377
    def importFile(self, import_file=None, id=None, REQUEST=None, 
                   batch_mode=0, **kw):
378
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
379
        Import Business Template from one file
380
      """
381 382
      if REQUEST is None:
        REQUEST = getattr(self, 'REQUEST', None)
383 384 385 386 387 388 389 390 391
      
      if id is None:
        id = self.generateNewId()

      if (import_file is None) or (len(import_file.read()) == 0):
        if REQUEST is not None:
          psm = N_('No+file+or+an+empty+file+was+specified')
          REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                    % (self.absolute_url(), psm))
Alexandre Boeglin's avatar
Alexandre Boeglin committed
392 393
          return
        else :
394
          raise RuntimeError, 'No file or an empty file was specified'
Aurel's avatar
Aurel committed
395
      # copy to a temp location
Alexandre Boeglin's avatar
Alexandre Boeglin committed
396
      import_file.seek(0) #Rewind to the beginning of file
397
      tempid, temppath = mkstemp()
398 399 400 401 402 403 404 405 406 407
      try:
        os.close(tempid) # Close the opened fd as soon as possible
        tempfile = open(temppath, 'w')
        try:
          tempfile.write(import_file.read())
        finally:
          tempfile.close()
        bt = self._importBT(temppath, id)
      finally:
        os.remove(temppath)
408
      bt.build(no_action=1)
Aurel's avatar
Aurel committed
409
      bt.reindexObject()
410

411 412
      if (batch_mode == 0) and \
         (REQUEST is not None):
413 414 415 416
        ret_url = bt.absolute_url() + '/view'
        psm = N_("Business+Templates+Imported+Successfully")
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
                                  % (ret_url, psm))
417 418
      elif (batch_mode == 1):
        return bt
419

Vincent Pelletier's avatar
Vincent Pelletier committed
420
    def runUnitTestList(self, test_list=[], **kwd):
421 422 423
      """
        Runs Unit Tests related to this Business Template
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
424 425
      # XXX: should check for file presence before trying to execute.
      # XXX: should check if the unit test file is configured in the BT
426
      from Products.ERP5Type.tests.runUnitTest import getUnitTestFile
Vincent Pelletier's avatar
Vincent Pelletier committed
427 428
      return os.popen('/usr/bin/python %s %s 2>&1'
                      % (getUnitTestFile(), ' '.join(test_list))).read()
429 430

    def diffObject(self, REQUEST, **kw):
Aurel's avatar
Aurel committed
431
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
432 433
        Make diff between two objects, whose paths are stored in values bt1
        and bt2 in the REQUEST object.
Aurel's avatar
Aurel committed
434
      """
435 436
      bt1_id = getattr(REQUEST, 'bt1', None)
      bt2_id = getattr(REQUEST, 'bt2', None)
437 438 439 440 441 442 443
      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
444
      else:
445 446 447 448 449
        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)
450

Vincent Pelletier's avatar
Vincent Pelletier committed
451 452 453 454 455 456 457
    security.declareProtected( 'Import/Export objects',
                               'updateRepositoryBusinessTemplateList' )

    def updateRepositoryBusinessTemplateList(self, repository_list,
                                             REQUEST=None, RESPONSE=None, **kw):
      """
        Update the information on Business Templates from repositories.
458 459
      """
      self.repository_dict = PersistentMapping()
460
      property_list = ('title', 'version', 'revision', 'description', 'license',
461
                       'dependency', 'provision', 'copyright')
Vincent Pelletier's avatar
Vincent Pelletier committed
462 463
      #LOG('updateRepositoryBusiessTemplateList', 0,
      #    'repository_list = %r' % (repository_list,))
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
      for repository in repository_list:
        url = '/'.join([repository, 'bt5list'])
        f = urlopen(url)
        property_dict_list = []
        try:
          doc = parse(f)
          try:
            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
491 492
              property_dict['version'] = \
                  temp_property_dict.get('version', [''])[0]
493 494
	      property_dict['revision'] = \
	          temp_property_dict.get('revision', [''])[0]
Vincent Pelletier's avatar
Vincent Pelletier committed
495 496 497 498 499 500
              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', ())
501 502
              property_dict['provision_list'] = \
                  temp_property_dict.get('provision', ())
Vincent Pelletier's avatar
Vincent Pelletier committed
503 504
              property_dict['copyright_list'] = \
                  temp_property_dict.get('copyright', ())
505 506 507 508 509 510 511 512 513 514
              
              property_dict_list.append(property_dict)
          finally:
            doc.unlink()
        finally:
          f.close()
        
        self.repository_dict[repository] = tuple(property_dict_list)
        
      if REQUEST is not None:
515
        ret_url = self.absolute_url() + '/' + REQUEST.get('dialog_id', 'view')
516
        psm = N_("Business+Templates+Updated+Successfully")
517
        REQUEST.RESPONSE.redirect("%s?portal_status_message=%s&dialog_category=object_exchange&selection_name=business_template_selection"
518
                                  % (ret_url, psm))
519
                
Vincent Pelletier's avatar
Vincent Pelletier committed
520 521
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getRepositoryList' )
522
    def getRepositoryList(self):
Vincent Pelletier's avatar
Vincent Pelletier committed
523 524
      """
        Get the list of repositories.
525 526 527 528 529
      """
      return self.repository_dict.keys()
      
    security.declarePublic( 'decodeRepositoryBusinessTemplateUid' )
    def decodeRepositoryBusinessTemplateUid(self, uid):
Vincent Pelletier's avatar
Vincent Pelletier committed
530 531 532
      """
        Decode the uid of a business template from a repository.
        Return a repository and an id.
533
      """
534
      return cPickle.loads(b64decode(uid))
535 536 537 538 539 540 541 542 543 544 545 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 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 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
    
    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)))

    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,)
    
    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
    
    security.declareProtected(Permissions.AccessContentsInformation,
                               'getLastestBTOnRepos')
    def getLastestBTOnRepos(self, title, version_restriction=None):
      """
       It's possible we have different versions of the same BT
       available on various repositories or on the same repository. 
       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():
	for property_dict in property_dict_list:
          provision_list = property_dict.get('provision_list', [])
          if title in provision_list:
            raise BusinessTemplateIsMeta, 'Business Template %s is provided by another one'%(title,)
	  if title == property_dict['title']:
            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):
                result = (repository,  property_dict['id'], property_dict['version'])
      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 '')
    
    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
     
    security.declareProtected(Permissions.AccessContentsInformation,
                               'getDependencyList')
    def getDependencyList(self, bt):
      """
       Return the list of missing dependencies for a business
       template, given a tuple : (repository, id)
      """
      # We do not take into consideration the dependencies
      # for meta business templates
      if bt[0] == 'meta':
        return []
      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]:
              dependency_list = property_dict['dependency_list']
              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:
                  # remove parenthesis to get something like ">= O.2"
                  version_restriction = dependency_couple_list[1][1:-1]
                require_update = False
                installed_bt = self.portal_templates.getInstalledBusinessTemplate(dependency)
                if version_restriction is not None:
                  if installed_bt is not None:
                    # Check if the installed version require an update
                    if not self.compareVersionStrings(installed_bt.getVersion(), version_restriction):
                      operator = version_restriction.split(' ')[0]
                      if operator in ('<', '<<', '<='):
                        raise BusinessTemplateMissingDependency, '%s (%s) is present but %s require: %s (%s)'%(dependency, installed_bt.getVersion(), property_dict['title'], dependency, version_restriction)
                      else:
                        require_update = True
                if (require_update or installed_bt is None) \
                  and dependency not in result_list:
                  # Get the lastest version of the dependency on the
                  # repository that meet the version restriction
                  provider_installed = False
                  try:
                    bt_dep = self.getLastestBTOnRepos(dependency, version_restriction)
                  except BusinessTemplateUnknownError:
                    raise BusinessTemplateMissingDependency, 'The following dependency could not be satisfied: %s (%s)\nReason: Business Template could not be found in the repositories'%(dependency, version_restriction or '')
                  except BusinessTemplateIsMeta:
                    provider_list = self.getProviderList(dependency)
                    for provider in provider_list:
                      if self.portal_templates.getInstalledBusinessTemplate(provider) is not None:
                        provider_installed = True
                        break
                    if not provider_installed:
                      bt_dep = ('meta', dependency)
                  if not provider_installed:
                    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])
                
    security.declareProtected(Permissions.AccessContentsInformation,
                              'urlQuote')
    def urlQuote(self, url):
      """ wrapper for urllib.quote()
      """
      return quote(url)
    
    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'
    
    security.declareProtected(Permissions.AccessContentsInformation,
                              'sortBusinessTemplateList')
    def sortBusinessTemplateList(self, bt_list):
      """
       Sort a list of bt according to dependencies
      """
      result_list = []
      for repository, id in bt_list:
        dependency_list = self.getDependencyList((repository, id))
        dependency_list.append((repository, id))
        for dependency in dependency_list:
          if dependency[0] == 'meta':
            provider_list = self.getProviderList(dependency[1])
            dependency = self.findProviderInBTList(provider_list, bt_list)
          if dependency not in result_list:
            result_list.append(dependency)
      return result_list
    
Vincent Pelletier's avatar
Vincent Pelletier committed
727 728
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getRepositoryBusinessTemplateList' )
729 730 731
    def getRepositoryBusinessTemplateList(self, update_only=0, **kw):
      """Get the list of Business Templates in repositories.
      """
Vincent Pelletier's avatar
Vincent Pelletier committed
732 733
      version_state_title_dict = { 'new' : 'New', 'present' : 'Present',
                                   'old' : 'Old' }
734 735 736 737 738 739 740 741 742 743 744 745

      from Products.ERP5Type.Document import newTempBusinessTemplate
      template_list = []

      template_item_list = []
      if update_only:
        # 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 title not in template_item_dict:
Vincent Pelletier's avatar
Vincent Pelletier committed
746 747
              # If this is the first time to see this business template,
              # insert it.
748 749
              template_item_dict[title] = (repository, property_dict)
            else:
Vincent Pelletier's avatar
Vincent Pelletier committed
750 751 752 753
              # 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]
754 755 756
	      diff_version = self.compareVersions(previous_property_dict['version'],
                                                  property_dict['version'])
              if diff_version < 0:
757
                template_item_dict[title] = (repository, property_dict)
758 759 760 761 762
              elif diff_version == 0 \
	           and previous_property_dict['revision'] \
	           and property_dict['revision'] \
		   and previous_property_dict['revision'] < property_dict['revision'] :
		      template_item_dict[title] = (repository, property_dict)
763 764
        # Next, select only updated business templates.
        for repository, property_dict in template_item_dict.values():
Vincent Pelletier's avatar
Vincent Pelletier committed
765 766
          installed_bt = \
              self.getInstalledBusinessTemplate(property_dict['title'])
767
          if installed_bt is not None:
768 769 770
	    diff_version = self.compareVersions(installed_bt.getVersion(),
                                                property_dict['version'])
            if diff_version < 0:
771
              template_item_list.append((repository, property_dict))
772 773 774 775 776
	    elif diff_version == 0 \
	         and installed_bt.getRevision() \
	         and property_dict['revision'] \
		 and installed_bt.getRevision() < property_dict['revision'] :
		   template_item_list.append((repository, property_dict))
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
      else:
        for repository, property_dict_list in self.repository_dict.items():
          for property_dict in property_dict_list:
            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()
        id = property_dict['id']
        del property_dict['id']
        version = property_dict['version']
        version_state = 'new'
        for bt in self.searchFolder(title = property_dict['title']):
          result = self.compareVersions(version, bt.getObject().getVersion())
          if result == 0:
            version_state = 'present'
            break
          elif result < 0:
            version_state = 'old'
        version_state_title = version_state_title_dict[version_state]
797
        uid = b64encode(cPickle.dumps((repository, id)))
798 799 800 801 802 803
        obj = newTempBusinessTemplate(self, 'temp_' + uid,
                                      version_state = version_state,
                                      version_state_title = version_state_title,
                                      repository = repository, **property_dict)
        obj.setUid(uid)
        template_list.append(obj)
804
      template_list.sort(lambda x,y:cmp(x.getTitle(), y.getTitle()))
805 806
      return template_list

Vincent Pelletier's avatar
Vincent Pelletier committed
807 808
    security.declareProtected( Permissions.AccessContentsInformation,
                               'getUpdatedRepositoryBusinessTemplateList' )
809 810 811 812 813 814 815
    def getUpdatedRepositoryBusinessTemplateList(self, **kw):
      """Get the list of updated Business Templates in repositories.
      """
      #LOG('getUpdatedRepositoryBusinessTemplateList', 0, 'kw = %r' % (kw,))
      return self.getRepositoryBusinessTemplateList(update_only=1, **kw)
      
    def compareVersions(self, version1, version2):
Vincent Pelletier's avatar
Vincent Pelletier committed
816 817 818
      """
        Return negative if version1 < version2, 0 if version1 == version2,
        positive if version1 > version2.
819 820

      Here is the algorithm:
Vincent Pelletier's avatar
Vincent Pelletier committed
821 822
        - Non-alphanumeric characters are not significant, besides the function
          of delimiters.
823 824 825 826
        - 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
827
      This implements the following predicates:
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
        - 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
        
      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
      
Jean-Paul Smets's avatar
Jean-Paul Smets committed
862
InitializeClass(TemplateTool)