Skip to content

erp5
erp5
Commit 0db17646 authored by Ayush Tiwari's avatar Ayush Tiwari Committed by Ayush Tiwari
Browse files
Options

Business Manager: Introduction of Business Manager class and changes in... 

Business Manager: Introduction of Business Manager class and changes in template tool according to it
parent 16a9f0c0
Hide whitespace changes
Inline Side-by-side
Showing with 2773 additions and 17 deletions
product/ERP5/Document/BusinessManager.py 0 → 100644
View file @ 0db17646
# -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (c) 2017 Nexedi SARL and Contributors. All Rights Reserved.
# Ayush-Tiwari <ayush.tiwari@nexedi.com>
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
##############################################################################
import gc
import os
import posixpath
import transaction
import imghdr
import tarfile
import time
import hashlib
import fnmatch
import re
import threading
import pprint
from copy import deepcopy
from collections import defaultdict
from cStringIO import StringIO
from OFS.Image import Pdata
from lxml.etree import parse
from urllib import quote, unquote
from OFS import SimpleItem, XMLExportImport
from datetime import datetime
from itertools import chain
from operator import attrgetter
from persistent.list import PersistentList
from AccessControl import ClassSecurityInfo, Unauthorized, getSecurityManager
from Acquisition import Implicit, aq_base, aq_inner, aq_parent
from zLOG import LOG, INFO, WARNING
from Products.ERP5Type.XMLObject import XMLObject
from Products.ERP5Type.Core.Folder import Folder
from Products.CMFCore.utils import getToolByName
from Products.PythonScripts.PythonScript import PythonScript
from Products.ERP5Type.dynamic.lazy_class import ERP5BaseBroken
from Products.ERP5Type.Globals import Persistent, PersistentMapping
from Products.ERP5Type import Permissions, PropertySheet, interfaces
from Products.ERP5Type.Globals import InitializeClass
from Products.ERP5Type.TransactionalVariable import getTransactionalVariable
from Products.ERP5Type.patches.ppml import importXML
from Products.ERP5Type.Accessor.Constant import PropertyGetter as ConstantGetter
customImporters = {
XMLExportImport.magic: importXML,
}
CACHE_DATABASE_PATH = None
try:
if int(os.getenv('ERP5_BT5_CACHE', 0)):
from App.config import getConfiguration
import gdbm
instancehome = getConfiguration().instancehome
CACHE_DATABASE_PATH = os.path.join(instancehome, 'bt5cache.db')
except TypeError:
pass
cache_database = threading.local()
_MARKER = []
SEPARATELY_EXPORTED_PROPERTY_DICT = {
# For objects whose class name is 'class_name', the 'property_name'
# attribute is removed from the XML export, and the value is exported in a
# separate file, with extension specified by 'extension'.
# 'extension' must be None for auto-detection.
#
# class_name: (extension, unicode_data, property_name),
"Document Component": ("py", 0, "text_content"),
"DTMLDocument": (None, 0, "raw"),
"DTMLMethod": (None, 0, "raw"),
"Extension Component": ("py", 0, "text_content"),
"File": (None, 0, "data"),
"Image": (None, 0, "data"),
"OOoTemplate": ("oot", 1, "_text"),
"PDF": ("pdf", 0, "data"),
"PDFForm": ("pdf", 0, "data"),
"Python Script": ("py", 0, "_body"),
"PythonScript": ("py", 0, "_body"),
"Spreadsheet": (None, 0, "data"),
"SQL": ("sql", 0, "src"),
"SQL Method": ("sql", 0, "src"),
"Test Component": ("py", 0, "text_content"),
"Test Page": (None, 0, "text_content"),
"Web Page": (None, 0, "text_content"),
"Web Script": (None, 0, "text_content"),
"Web Style": (None, 0, "text_content"),
"ZopePageTemplate": ("zpt", 1, "_text"),
}
def _delObjectWithoutHook(obj, id):
"""OFS.ObjectManager._delObject without calling manage_beforeDelete."""
ob = obj._getOb(id)
if obj._objects:
obj._objects = tuple([i for i in obj._objects if i['id'] != id])
obj._delOb(id)
try:
ob._v__object_deleted__ = 1
except:
pass
def _recursiveRemoveUid(obj):
"""Recusivly set uid to None, to prevent (un)indexing.
This is used to prevent unindexing real objects when we delete subobjects on
a copy of this object.
"""
if getattr(aq_base(obj), 'uid', _MARKER) is not _MARKER:
obj.uid = None
# Make all objects and sub-object un-indexable
# XXX: Should be moved into another function or change the name and desc
# of this function
obj.isIndexable = ConstantGetter('isIndexable', value=False)
for subobj in obj.objectValues():
_recursiveRemoveUid(subobj)
# New BusinessItem addition function
def manage_addBusinessItem(self, item_path='', item_sign=1, item_layer=0, *args, **kw):
# Create BusinessItem object container
c = BusinessItem(item_path, item_sign, item_layer)
return c
# New BusinessPropertyItem addition function
def manage_addBusinessPropertyItem(self, item_path='', item_sign=1, item_layer=0, *args, **kw):
# Create BusinessPathItem object container
c = BusinessPropertyItem(item_path, item_sign, item_layer)
return c
# New BusinessPatchItem addition function
def manage_addBusinessPatchItem(self, item_path='', item_sign=1, item_layer=0, *args, **kw):
# Create BusinessPatchItem object container
c = BusinessPatchItem(item_path, item_sign, item_layer)
return c
class BusinessManager(Folder):
"""Business Manager is responsible for saving objects and properties in
an ERP5Site. Everything will be saved just via path"""
meta_type = 'ERP5 Business Manager'
portal_type = 'Business Manager'
add_permission = Permissions.AddPortalContent
template_format_version = 3
# Factory Type Information
factory_type_information = \
{ 'id' : portal_type
, 'meta_type' : meta_type
, 'icon' : 'file_icon.gif'
, 'product' : 'ERP5Type'
, 'factory' : ''
, 'type_class' : 'BusinessManager'
, 'immediate_view' : 'BusinessManager_view'
, 'allow_discussion' : 1
, 'allowed_content_types': ('Business Item',
'Business Property Item',
)
, 'filter_content_types' : 1
}
# Declarative security
security = ClassSecurityInfo()
security.declareObjectProtected(Permissions.AccessContentsInformation)
# Declarative properties
property_sheets = (
PropertySheet.Base,
PropertySheet.XMLObject,
PropertySheet.SimpleItem,
PropertySheet.CategoryCore,
PropertySheet.Version,
PropertySheet.BusinessManager,
)
def getShortRevision(self):
return None
def getVersion(self):
# Override the getter because currently we don't migrate the version, and
# this is used to find missing dependency list
return '5.4.7'
security.declareProtected(Permissions.AccessContentsInformation,
'getBuildingState')
def getBuildingState(self, default=None, id_only=1):
"""
Returns the current state in building
"""
portal_workflow = getToolByName(self, 'portal_workflow')
wf = portal_workflow.getWorkflowById(
'business_manager_building_workflow')
return wf._getWorkflowStateOf(self, id_only=id_only )
security.declareProtected(Permissions.AccessContentsInformation,
'getInstallationState')
def getInstallationState(self, default=None, id_only=1):
"""
Returns the current state in installation
"""
portal = self.getPortalObject()
portal_workflow = portal.portal_workflow
wf = portal_workflow.getWorkflowById(
'business_manager_installation_workflow')
return wf._getWorkflowStateOf(self, id_only=id_only )
def changeBuildingStatetoModified(self):
"""
Change building_state to 'modified'. This is needed specifically as we want
to update the building state even if we change any sub-objects(Business Item
or Business Property Item) of Business Manager.
"""
portal_workflow = self.getPortalObject().portal_workflow
wf = portal_workflow._getOb('business_manager_building_workflow')
wf._executeMetaTransition(self, 'modified')
def applytoERP5(self, DB):
"""Apply the flattened/reduced Business Manager to the DB"""
portal = self.getPortalObject()
pass
def _clean(self):
"""
Clean built information.
Remove all the built sub-objects from Business Item or Business Property
Item.
"""
for item in self.objectValues():
if item.getPortalType() == 'Business Item':
# Delete the sub-object
id_list = [l for l in item.objectIds()]
if id_list:
item.manage_delObjects(ids=id_list)
elif item.getPortalType() == 'Business Property Item':
# Add empty property item_property_name, value and type
# XXX: Shouldn't we check if the properties exist and then just delete
# them ?
item.setProperty('item_property_name', '')
item.setProperty('item_property_value', '')
item.setProperty('item_property_type', '')
security.declareProtected(Permissions.ManagePortal, 'preinstall')
def preinstall(self, check_dependencies=1, **kw):
"""
Preinstall for Business Manager comapres the installation state and returns
the changes in a manner which can keep up compatibilty with the view we use
in Business Template installation.
This function calls `portal_templates.updateInstallationState` to get the
change_list.
We don't care of check_dependencies here as this all would be taken care by
`udpateInstallationState` iteself.
"""
change_list = self.aq_parent.compareInstallationState([self])
modified_object_list = {}
for path in change_list:
type_name = 'Business Item'
if '#' in path[0]:
type_name = 'Business Property Item'
modified_object_list[path[0]] = [path[1], type_name]
return modified_object_list
security.declareProtected(Permissions.ManagePortal, 'clean')
clean = _clean
def _setTitle(self, value):
"""
Override required due to bootstrap
"""
self.title = value
def getPathItemList(self):
return self.objectValues()
# XXX: Change into property
security.declareProtected(Permissions.ManagePortal, 'getTemplateFormatVersion')
def getTemplateFormatVersion(self):
return self.template_format_version
# XXX: Change into property
def _setTemplateFormatVersion(self, value):
self.template_format_version = int(value)
def propertyMap(self):
prop_map = super(BusinessManager, self).propertyMap()
final_prop_map = prop_map+self._properties
return final_prop_map
def export(self, path=None, **kw):
"""
Export the object as zexp file
"""
if not self.getBuildingState() == 'built':
raise ValueError, 'Manager not built properly'
f = StringIO()
self._p_jar.exportFile(self._p_oid, f)
# XXX: Improve naming
name = self.getTitle()
name = posixpath.join(path, name)
# XXX required due to overuse of os.path
name = name.replace('\\', '/').replace(':', '/')
name = quote(name + '.zexp')
obj_path = name.replace('/', os.sep)
f.seek(0)
obj = f.read()
object_path = os.path.join(path, obj_path)
path = os.path.dirname(object_path)
os.path.exists(path) or os.makedirs(path)
f = open(object_path, 'wb')
try:
f.write(obj)
finally:
f.close()
security.declareProtected(Permissions.ManagePortal, 'importFile')
def importFile(self, path, connection=None):
"""
Import Business Manager object and all attribute to current BM itself
"""
if not connection:
connection = self.aq_parent._p_jar
file = open(path, 'rb')
imported_manager = connection.importFile(file)
self.title = imported_manager.title
for obj in imported_manager.objectValues():
delattr(obj, '__ac_local_roles__')
# XXX: Donot merge this, needed just for migrated erp5_core
try:
self._setObject(obj.id, aq_base(obj))
except Exception:
pass
obj.isIndexable = ConstantGetter('isIndexable', value=False)
def __add__(self, other):
"""
Adds the Business Item objects for the given Business Manager objects
"""
# XXX: Still to define
return self
__radd__ = __add__
def __sub__(self, other):
"""
Override subtract to find difference b/w the values in different cases.
"""
# Create the sha list for all path item list available in current object
sha_list = [item.sha for item in self._path_item_list]
# Reverse the sign of Business Item objects for the old Business Manager
# Trying comparing/subtracting ZODB with old installed object
for path_item in other._path_item_list:
if path_item.sha in sha_list:
self._path_item_list = [item for item
in self._path_item_list
if item.sha != path_item.sha]
else:
path_item.sign = -1
self._path_item_list.append(path_item)
return self
__rsub__ = __sub__
security.declareProtected(Permissions.ManagePortal, 'storeTemplateData')
def storeTemplateData(self, isBuild=False, **kw):
"""
Store data for objects in the ERP5.
Create Business Item sub-objects after resolving the paths. Also, add
layers to all Business Item objects
"""
portal = self.getPortalObject()
LOG('Business Manager', INFO, 'Storing Manager Data')
to_delete_id_list = []
for item in self.objectValues():
# Only try to resolve the Business Item objects
if item.getPortalType() != 'Business Item':
continue
item_path = item.getProperty('item_path')
# Resolve the path and update sub-objects lists
path_list = self._resolvePath(portal, [], item_path.split('/'))
if len(path_list) == 1 and path_list[0] == item_path:
continue
else:
item_sign = item.getProperty('item_sign')
item_layer = item.getProperty('item_layer')
# Create new Business Item objects with path in path_list and sign and
# layer same as that of the path used for resolving to new paths.
for path in path_list:
path_item = self.newContent(portal_type='Business Item')
path_item.edit(
item_path=path,
item_sign=item_sign,
item_layer=item_layer
)
# Add Id of BusinessItem to be deleted as we do already have resolved
# path and new sub-objects based on resolved paths
to_delete_id_list.append(item.getId())
# Now, delete the original Business Item(s) sub-object as we do have
# Business Item created from resolved paths
self.manage_delObjects(ids=to_delete_id_list)
def _resolvePath(self, folder, relative_url_list, id_list):
"""
For Business Manager, we expect to resolve the path incase we face
paths which expect to include sub-objects.
For example: 'portal_catalog/erp5_mysql_innodb/**' should only consider
the sub-objects of the object mentioned, and create separate BusinessItem
objects for all of them.
This method calls itself recursively.
The folder is the current object which contains sub-objects.
The list of ids are path components. If the list is empty,
the current folder is valid.
"""
if len(id_list) == 0:
return ['/'.join(relative_url_list)]
id = id_list[0]
if re.search('[\*\?\[\]]', id) is None:
# If the id has no meta character, do not have to check all objects.
obj = folder._getOb(id, None)
if obj is None:
raise AttributeError, "Could not resolve '%s' during business template processing." % id
return self._resolvePath(obj, relative_url_list + [id], id_list[1:])
path_list = []
for object_id in fnmatch.filter(folder.objectIds(), id):
if object_id != "":
path_list.extend(self._resolvePath(
folder._getOb(object_id),
relative_url_list + [object_id], id_list[1:]))
return path_list
def getPathList(self):
path_list = []
for item in self.objectValues():
path_list.append(item.getProperty('item_path'))
return path_list
def getPathItemDict(self):
path_item_dict = {}
# TODO: Handle error for BM with multiple items at same path
for item in self.objectValues():
path_item_dict[item.getProperty('item_path')] = item
return path_item_dict
def getBusinessItemByPath(self, path):
path_item_dict = self.getPathItemDict()
try:
return path_item_dict[path]
except KeyError:
return
def build(self, no_action=False, **kw):
"""Creates new values for business item from the values from
OFS Database"""
LOG('Business Manager', INFO, 'Building Business Manager')
removable_sub_object_path_list = kw.get('removable_sub_object_path', [])
removable_property_dict = kw.get('removable_property', {})
# Now, we need to put a check here for returning whih objects should be
# updated during rebuild of BM
checkNeeded = kw.get('checkNeeded', False)
# Build all paths if there is no check required(i.e, its a new build action)
if not checkNeeded:
if not no_action:
self.storeTemplateData(isBuild=True, **kw)
for path_item in self.objectValues():
kwargs = {}
item_path = path_item.getProperty('item_path')
kwargs['removable_property_list'] = removable_property_dict.get(item_path, [])
kwargs['remove_sub_objects'] = item_path in removable_sub_object_path_list
path_item.build(self, **kwargs)
return self
else:
item_path_list = kw.get('item_path_list', [])
if item_path_list:
for path in item_path_list:
item = self.getBusinessItemByPath(path)
item.build(self)
return self
def flattenBusinessManager(self):
"""
Flattening a reduced Business Manager with two path p1 and p2 where p1 <> p2:
flatten([(p1, s1, l1, v1), (p2, s2, l2, v2)]) = [(p1, s1, 0, v1), (p2, s2, 0, v2)]
A reduced Business Manager BT is said to be flattened if and only if:
flatten(BT) = BT
"""
pass
def reduceBusinessManager(self):
"""
Reduction is a function that takes a Business Manager as input and returns
a smaller Business Manager by taking out values with lower priority layers.
After taking out BusinessItem(s) with lower priority layer, we also go
through arithmetic in case there are multiple number of BI at the higher layer
Two path on different layer are reduced as a single path with the highest layer:
If l1 > l2,
reduce([(p, s, l1, (a, b, c)), (p, s, l2, (d, e))]) = [(p, s, l1, merge(a, b, c))]
A Business Manager BT is said to be reduced if and only if:
reduce(BT) = BT
"""
path_list = self.getPathList()
reduced_path_item_list = []
# We separate the path list in the ones which are repeated and the ones
# which are unique for the installation
seen_path_list = set()
unique_path_list = [x for x
in path_list
if x not in seen_path_list
and not seen_path_list.add(x)]
# Create an extra dict for values on path which are repeated in the path list
seen_path_dict = {path: [] for path in seen_path_list}
for item in self.objectValues():
if item.getProperty('item_path') in seen_path_list:
# In case the path is repeated keep the path_item in a separate dict
# for further arithmetic
seen_path_dict[item.getProperty('item_path')].append(item)
else:
# If the path is unique, add them in the list of reduced Business Item
reduced_path_item_list.append(item)
# Reduce the values and get the merged result out of it
for path, path_item_list in seen_path_dict.items():
# Create separate list of list items with highest priority
higest_priority_layer = max(path_item_list, key=attrgetter('item_layer')).item_layer
prioritized_path_item = [path_item for path_item
in path_item_list
if path_item.item_layer == higest_priority_layer]
# Separate the positive and negative sign path_item
if len(prioritized_path_item) > 1:
path_item_list_add = [item for item
in prioritized_path_item
if item.getProperty('item_sign') > 0]
path_item_list_subtract = [item for item
in prioritized_path_item
if item.getProperty('item_sign') < 0]
if path_item_list_add:
combined_added_path_item = reduce(lambda x, y: x+y, path_item_list_add)
if combined_added_path_item.getPortalType() == 'Business Item':
added_value = combined_added_path_item.objectValues()[0]
elif combined_added_path_item.getPortalType() == 'Business Property Item':
added_value = combined_added_path_item.getProperty('item_property_value')
reduced_path_item_list.append(combined_added_path_item)
if path_item_list_subtract:
combined_subtracted_path_item = reduce(lambda x, y: x+y, path_item_list_subtract)
if combined_subtracted_path_item.getPortalType() == 'Business Item':
added_value = combined_subtracted_path_item.objectValues()[0]
elif combined_subtracted_path_item.getPortalType() == 'Business Property Item':
added_value = combined_subtracted_path_item.getProperty('item_property_value')
reduced_path_item_list.append(combined_subtracted_path_item)
# XXX: For now, we just care about added items and append them in reduced
# path list.
#if added_value != subtracted_value:
# Append the arithmetically combined path_item objects in the final
# reduced list after removing the intersection
# added_value, subtracted_value = \
# self._simplifyValueIntersection(added_value, subtracted_value)
# combined_added_path_item.value = added_value
# combined_subtracted_path_item.value = subtracted_value
# Append the path_item to the final reduced path_item_list after
# doing required arithmetic on it. Make sure to first append
# subtracted item because while installation, we need to first
# uninstall the old object and then install new object at same path
# reduced_path_item_list.append(combined_subtracted_path_item)
# reduced_path_item_list.append(combined_added_path_item)
else:
reduced_path_item_list.append(prioritized_path_item[0])
id_list = [l for l in self.objectIds()]
for l in id_list:
try:
self._delObject(l)
except Exception:
# XXX: REMOVE/RECHEK BEFORE MERGE
# The reason for doing this horrible workaround is to delete object
# for 'portal_memcached/persistent_memcached_plugin' as it is not getting
# deleted in 1st attempt with failure :
# AttributeError: 'NoneType' object has no attribute 'getUid'
self._delObject(l)
for item in reduced_path_item_list:
item.isIndexable = ConstantGetter('isIndexable', value=False)
new_id = self.generateNewId()
self._setObject(new_id, aq_base(item),
suppress_events=True)
def _simplifyValueIntersection(self, added_value, subtracted_value):
"""
Returns values for the Business Item having same path and layer after
removing the intersection of the values
Parameters:
added_value - Value for the Business Item having sign = +1
subtracted_value - Value for Busienss Item having sign = -1
"""
built_in_number_type = (int, long, float, complex)
built_in_container_type = (tuple, list, dict, set)
built_in_type_list = built_in_number_type + built_in_container_type
# For ERP5 objects, we should return the added and subtracted values as it is
if type(added_value).__name__ not in built_in_type_list and \
type(subtracted_value).__name__ not in built_in_type_list:
return added_value, subtracted_value
# For all the values of container type, we remove the intersection
added_value = [x for x in added_value if x not in subtracted_value]
subtracted_value = [x for x in subtracted_value if x not in added_value]
return added_value, subtracted_value
def mergeBusinessPatchItem(self, item1, item2):
"""
Merge two BusinessPatchItem at same layer and same sign.
XXX: This function shouldn't be used at reduction, rather than during
updating the installation_state, because we need to know all the states to
be able to find out which patch needs to be used.
Cases:
1. Shouldn't matter if both have same new_value as we give preference to
the final result and try to remove conflict as much as possible.
2. If both have different old_value and different new_value, merge should
return both of them and let the updateInstallationState process decide
which one to apply and if needed, raise a conflict
"""
pass
class BusinessItem(XMLObject):
"""Saves the path and values for objects, properties, etc, the
attributes for a path configuration being:
- item_path (similar to an xpath expression)
Examples of path :
portal_type/Person
portal_type/Person#title
portal_type/Person#property_sheet?ancestor=DublinCore
portal_type/Person#property_sheet?position=2
- item_sign (+1/-1)
- item_layer (0, 1, 2, 3, etc.)
- item_value (a set of pickable value in python)"""
add_permission = Permissions.AddPortalContent
# Declarative security
security = ClassSecurityInfo()
security.declareObjectProtected(Permissions.AccessContentsInformation)
constructors = (manage_addBusinessItem,)
portal_type = 'Business Item'
meta_type = 'Business Item'
icon = None
isProperty = False
isIndexable = False
def _edit(self, item_path='', item_sign=1, item_layer=0, *args, **kw):
"""
Overriden function so that we can update attributes for BusinessItem objects
"""
return super(BusinessItem, self)._edit(item_path=item_path,
item_sign=item_sign,
item_layer=item_layer,
**kw)
def build(self, context, **kw):
"""
Extract value for the given path from the OFS
Three different situations to extract value:
1. For paths which point directly to an object in OFS
2. For paths which point to multiple objects inside a folder
3. For paths which point to property of an object in OFS : In this case,
we can have URL delimiters like ?, #, = in the path
"""
LOG('Business Manager', INFO, 'Building Business Item')
# Remove the old sub-objects if exisiting before building
id_list = [l for l in self.objectIds()]
if id_list:
self.manage_delObjects(ids=id_list)
p = context.getPortalObject()
path = self.getProperty('item_path')
obj = p.unrestrictedTraverse(path)
obj = obj._getCopy(context)
# We should remove the extra properties of object so that there
# shouldn't be redundancy of the proeprties
removable_property_list = kw.get('removable_property_list', [])
# We should also add extra parameter to remove sub-objects by removing
# `_tree` for any erp5 object. This way we can have control over adding
# sub-objects as new Business Item objects
remove_sub_objects = kw.get('remove_sub_objects', False)
if remove_sub_objects:
removable_property_list.append('_tree')
keep_workflow_history = False
# For portal_components object, we need validation_history
if self.getProperty('item_path').startswith('portal_components'):
keep_workflow_history = True
obj = self.removeProperties(obj,
1,
properties=removable_property_list,
keep_workflow_history=keep_workflow_history,
)
obj = obj.__of__(context)
# XXX: '_recursiveRemoveUid' is not working as expected
_recursiveRemoveUid(obj)
obj = aq_base(obj)
obj.isIndexable = ConstantGetter('isIndexable', value=False)
new_id = self.generateNewId()
self._setObject(new_id, obj, suppress_events=True)
def _resolvePath(self, folder, relative_url_list, id_list):
"""
We go through 3 types of paths:
1. General path we find in erp5 for objects
Ex: portal_type/Person
In this case, we import/export the object on the path
2. Path where we consider saving sub-objects also, in that case we create
new BusinessItem for those objects
Ex: portal_catalog/erp5_mysql_innodb/**
This should create BI for the catalog methods sub-objects present in the
erp5_catalog.
This method calls itself recursively.
The folder is the current object which contains sub-objects.
The list of ids are path components. If the list is empty,
the current folder is valid.
"""
if len(id_list) == 0:
return ['/'.join(relative_url_list)]
id = id_list[0]
if re.search('[\*\?\[\]]', id) is None:
# If the id has no meta character, do not have to check all objects.
obj = folder._getOb(id, None)
if obj is None:
raise AttributeError, "Could not resolve '%s' during BusinessItem processing." % id
return self._resolvePath(obj, relative_url_list + [id], id_list[1:])
path_list = []
for object_id in fnmatch.filter(folder.objectIds(), id):
if object_id != "":
path_list.extend(self._resolvePath(
folder._getOb(object_id),
relative_url_list + [object_id], id_list[1:]))
return path_list
def install(self, context, *args):
"""
Set the value to the defined path.
"""
# In case the path denotes property, we create separate object for
# ObjectTemplateItem and handle the installation there.
try:
portal = context.getPortalObject()
except AttributeError:
# This is a possibility during bootstrap where the context is not an
# erp5 object but a dynamic class
if args:
portal = args[0]
else:
raise AttributeError('No portal object found')
path = self.getProperty('item_path')
path_list = path.split('/')
container_path = path_list[:-1]
object_id = path_list[-1]
try:
container = self.unrestrictedResolveValue(portal, container_path)
except KeyError:
# parent object can be set to nothing, in this case just go on
container_url = '/'.join(container_path)
old_obj = container._getOb(object_id, None)
# delete the old object before installing a new object
if old_obj:
container._delObject(object_id)
# Create a new object only if sign is +1
# If sign is +1, set the new object on the container
if int(self.getProperty('item_sign')) == 1:
# install object
obj = self.objectValues()[0]
obj = obj._getCopy(container)
# Update the type_provider_list if needed
# XXX: Find a way to fiter and do this check only for tool, so that we
# don't lose on perfomance in checking this everytime
if interfaces.ITypeProvider.providedBy(obj):
type_container_id = obj.id
types_tool = portal.portal_types
if type_container_id not in types_tool.type_provider_list:
types_tool.type_provider_list = tuple(types_tool.type_provider_list) + \
(type_container_id,)
# Before making `obj` a sub-object of `container`, we should the acquired
# roles on obj
obj.isIndexable = ConstantGetter('isIndexable', value=False)
delattr(obj, '__ac_local_roles__')
container._setObject(object_id, obj, suppress_events=True)
obj = container._getOb(object_id)
skin_tool = portal.portal_skins
if obj.aq_parent.meta_type == 'CMF Skins Tool':
registerSkinFolder(skin_tool, obj)
def unrestrictedResolveValue(self, context=None, path='', default=_MARKER,
restricted=0):
"""
Get the value without checking the security.
This method does not acquire the parent.
"""
if isinstance(path, basestring):
stack = path.split('/')
else:
stack = list(path)
stack.reverse()
if stack:
if context is None:
portal = aq_inner(self.getPortalObject())
container = portal
else:
container = context
if restricted:
validate = getSecurityManager().validate
while stack:
key = stack.pop()
try:
value = container[key]
except KeyError:
LOG('BusinessManager', WARNING,
'Could not access object %s' % (path,))
if default is _MARKER:
raise
return default
if restricted:
try:
if not validate(container, container, key, value):
raise Unauthorized('unauthorized access to element %s' % key)
except Unauthorized:
LOG('BusinessManager', WARNING,
'access to %s is forbidden' % (path,))
if default is _MARKER:
raise
return default
container = value
return value
else:
return context
def __add__(self, other):
"""
Add the values from the path when the path is same for 2 objects
"""
if self.getProperty('item_path') != other.getProperty('item_path'):
raise ValueError, "BusinessItem are incommensurable, have different path"
elif self.getProperty('item_sign') != other.getProperty('item_sign'):
raise ValueError, "BusinessItem are incommensurable, have different sign"
else:
new_value = self._mergeValue(value_list=[self.objectValues()[0], other.objectValues()[0]])
# Remove old objects if it exists
old_id_list = [l for l in self.objectIds()]
if old_id_list:
self.manage_delObjects(ids=old_id_list)
# Add the new sub-object
self._setObject(new_value.id, new_value)
return self
__radd__ = __add__
def _mergeValue(self, value_list):
"""
Merge value in value list
merge(a, b, c) : A monotonic commutative function that depends on the
type of a, b and c:
if a, b and c are sets, merge = union
if a, b and c are lists, merge = ordered concatenation
if a, b and c are objects, merge = the object created the last
else merge = MAX
"""
builtin_number_type = (int, long, float, complex)
# Now, consider the type of both values
if all(isinstance(x, builtin_number_type) for x in value_list):
merged_value = max(value_list)
elif all(isinstance(x, set) for x in value_list):
merged_value = set(chain.from_iterable(value_list))
elif all(isinstance(x, list) for x in value_list):
merged_value = list(set(chain.from_iterable(value_list)))
elif all(isinstance(x, tuple) for x in value_list):
merged_value = tuple(set(chain.from_iterable(value_list)))
else:
# In all other case, check if the values are objects and then take the
# objects created last.
# XXX: Should we go with creation date or modification_date ??
# TODO:
# 1. Add check that the values are ERP5 objects
# 2. In case 2 maximum values are created at same time, prefer one with
# higher priority layer
merged_value = max([max(value, key=attrgetter('creation_date'))
for value in value_list],
key=attrgetter('creation_date'))
return merged_value
def removeProperties(self,
obj,
export,
properties=[],
keep_workflow_history=False,
keep_workflow_history_last_history_only=False):
"""
Remove unneeded properties for export
"""
obj._p_activate()
klass = obj.__class__
classname = klass.__name__
attr_set = {'_dav_writelocks', '_filepath', '_owner', '_related_index',
'last_id', 'uid',
'__ac_local_roles__', '__ac_local_roles_group_id_dict__'}
if properties:
for prop in properties:
if prop.endswith('_list'):
prop = prop[:-5]
attr_set.add(prop)
if export:
if keep_workflow_history_last_history_only:
self._removeAllButLastWorkflowHistory(obj)
elif not keep_workflow_history:
attr_set.add('workflow_history')
# PythonScript covers both Zope Python scripts
# and ERP5 Python Scripts
if isinstance(obj, PythonScript):
attr_set.update(('func_code', 'func_defaults', '_code',
'_lazy_compilation', 'Python_magic'))
for attr in 'errors', 'warnings', '_proxy_roles':
if not obj.__dict__.get(attr, 1):
delattr(obj, attr)
elif classname in ('File', 'Image'):
attr_set.update(('_EtagSupport__etag', 'size'))
elif classname == 'SQL' and klass.__module__ == 'Products.ZSQLMethods.SQL':
attr_set.update(('_arg', 'template'))
elif interfaces.IIdGenerator.providedBy(obj):
attr_set.update(('last_max_id_dict', 'last_id_dict'))
elif classname == 'Types Tool' and klass.__module__ == 'erp5.portal_type':
attr_set.add('type_provider_list')
for attr in obj.__dict__.keys():
if attr in attr_set or attr.startswith('_cache_cookie_'):
try:
delattr(obj, attr)
except AttributeError:
# XXX: Continue in cases where we want to delete some properties which
# are not in attribute list
# Raise an error
continue
if classname == 'PDFForm':
if not obj.getProperty('business_template_include_content', 1):
obj.deletePdfContent()
return obj
def getBusinessPath(self):
return self.getProperty('item_path')
def getBusinessPathSign(self):
return self.getProperty('item_sign', 1)
def getBusinessPathLayer(self):
return self.getProperty('item_layer', 1)
def getParentBusinessManager(self):
return self.aq_parent
class BusinessPropertyItem(XMLObject):
"""Class to deal with path(s) which refer to property of an ERP5 object.
Used to store property name, type and value for a given object and property"""
add_permission = Permissions.AddPortalContent
# Declarative security
security = ClassSecurityInfo()
security.declareObjectProtected(Permissions.AccessContentsInformation)
portal_type = 'Business Property Item'
meta_type = 'Business Property Item'
icon = None
isIndexable = False
isProperty = True
constructors = (manage_addBusinessPropertyItem,)
def _edit(self, item_path='', item_sign=1, item_layer=0, *args, **kw):
"""
Overriden function so that we can update attributes for BusinessItem objects
"""
return super(BusinessPropertyItem, self)._edit(item_path=item_path,
item_sign=item_sign,
item_layer=item_layer,
**kw)
def build(self, context, **kw):
p = context.getPortalObject()
path = self.getProperty('item_path')
relative_url, property_id = path.split('#')
obj = p.unrestrictedTraverse(relative_url)
property_value = obj.getProperty(property_id)
property_type = obj.getPropertyType(property_id)
self.setProperty('item_property_name', property_id)
self.setProperty('item_property_type', property_type)
self.setProperty('item_property_value', property_value)
def install(self, context, *args):
# Get portal object
try:
portal = context.getPortalObject()
except AttributeError:
# This is a possibility during bootstrap where the context is not an
# erp5 object but a dynamic class
if args:
portal = args[0]
else:
raise AttributeError('No portal object found')
path = self.getProperty('item_path')
relative_url, property_id = path.split('#')
obj = portal.unrestrictedTraverse(relative_url)
property_name = self.getProperty('item_property_name')
property_type = self.getProperty('item_property_type')
property_value = self.getProperty('item_property_value')
# First remove the property from the existing path and keep the default
# empty, and update only if the sign is +1
obj._delPropValue(property_name)
# Remove the '_list' from the end of property_name. This is required because
# of the way _setProperty is defined where if the type is list_type, it
# explicitly adds '_list' at the end of property_name before trying to call
# the accessor
if property_name.endswith('_list'):
property_name = property_name[:-5]
# XXX: Explicit addition of property_type for 'type_workflow' property on
# 'ERP5Type' objects. This is required as we have created an explicit
# property outside of property sheet for ERP5Type objects, but at the same
# time, the object(s) also have property sheet for them. Since, there is no
# functions like _setProperty, hasProperty, etc to combine both of them
# we have to end up using explicit mention of 'list' property_value here
# 1. Other option can be to override hasProperty or _setProperty for ERP5Type
# object and write it so that it can handle both _properties attribute as
# well as accessor holders generated from property sheet(s).
# 2. After that we can use hasProperty here for objects to check their
# property_type and then just use the generic '_setProperty' function.
# XXX: For now, we just put this explicitly/hard-code
if property_name == 'type_workflow':
property_type = 'multiple selection'
if int(self.getProperty('item_sign')) == 1:
obj._setProperty(property_name, property_value, property_type)
def getBusinessPath(self):
return self.getProperty('item_path')
def getBusinessPathSign(self):
return self.getProperty('item_sign', 1)
def getBusinessPathLayer(self):
return self.getProperty('item_layer', 1)
def getParentBusinessManager(self):
return self.aq_parent
def getBusinessItemPropertyName(self):
return self.getProperty('item_property_name')
def getBusinessItemPropertyType(self):
return self.getProperty('item_property_type')
def getBusinessItemPropertyValue(self):
return self.getProperty('item_property_value')
def __add__(self, other):
"""
Add the values from the path when the path is same for 2 objects
"""
if self.getProperty('item_path') != other.getProperty('item_path'):
raise ValueError, "BusinessItem are incommensurable, have different path"
elif self.getProperty('item_sign') != other.getProperty('item_sign'):
raise ValueError, "BusinessItem are incommensurable, have different sign"
else:
self.setProperty('item_property_value', self._mergeValue(value_list=[
self.getProperty('item_property_value'),
other.getProperty('item_property_value')]
))
return self
__radd__ = __add__
def _mergeValue(self, value_list):
"""
Merge value in value list
merge(a, b, c) : A monotonic commutative function that depends on the
type of a, b and c:
if a, b and c are sets, merge = union
if a, b and c are lists, merge = ordered concatenation
if a, b and c are objects, merge = the object created the last
else merge = MAX
"""
builtin_number_type = (int, long, float, complex)
# Now, consider the type of both values
if all(isinstance(x, builtin_number_type) for x in value_list):
merged_value = max(value_list)
elif all(isinstance(x, set) for x in value_list):
merged_value = set(chain.from_iterable(value_list))
elif all(isinstance(x, list) for x in value_list):
merged_value = list(set(chain.from_iterable(value_list)))
elif all(isinstance(x, tuple) for x in value_list):
merged_value = tuple(set(chain.from_iterable(value_list)))
else:
# In all other case, check if the values are objects and then take the
# objects created last.
# XXX: Should we go with creation date or modification_date ??
# TODO:
# 1. Add check that the values are ERP5 objects
# 2. In case 2 maximum values are created at same time, prefer one with
# higher priority layer
merged_value = max([max(value, key=attrgetter('creation_date'))
for value in value_list],
key=attrgetter('creation_date'))
return merged_value
class BusinessPatchItem(XMLObject):
"""
Business Item for saving patch and diff. This will help us to create a diff or
patch between the old value and current value.
item_sign -- +1 or -1
item_path -- extended OFS path (equivalent to deepdiff path)
ex. a/b/c#x/y/z:int/w
item_layer -- layer
old -- old value
new -- new value
dependency_list -- a list of bt5 identifiers useful to rebuild the
BusinesTemplatePatchItem instance
preserved_list -- a list of bt5 identifiers useful to rebuild the
BusinesTemplatePatchItem instance
(XXX: We don't use `preserved_list` for now)
Business Patch Item can be both PathItem or PropertyItem, but both of them are
quite distinguishable, so we prefer not to use them as base class for it.
"""
# CMF Type definition
portal_type = 'Business Patch Item'
meta_type = 'Business Patch Item'
# Declarative security
security = ClassSecurityInfo()
security.declareObjectProtected(Permissions.AccessContentsInformation)
icon = None
isIndexable = False
isProperty = False
constructors = (manage_addBusinessPatchItem,)
allowed_types = ('Business Item', 'Business Property Item',)
def _edit(self, **kw):
"""
Override _edit to create Business Item and BusinessPropertyItem for old and
new value
"""
dependency_list = kw.get('dependency_list', self.getProperty('dependency_list'))
# Raise error if no dependency_list, this way we ensure there are no useless
# patch_item objects
if not dependency_list:
raise ValueError('Please add dependency to the Business Patch Item')
super(BusinessPatchItem, self)._edit(**kw)
def build(self, context, **kw):
"""
Build should update the old and new value
"""
portal = self.getPortalObject()
portal_templates = portal.portal_templates
item_path = self.getProperty('item_path')
item_layer = self.getProperty('item_layer')
item_sign = self.getProperty('item_sign')
# Remove old objects if it exists
old_id_list = [l for l in self.objectIds()]
if old_id_list:
self.manage_delObjects(ids=old_id_list)
# Get the dependency Business Manager
dependency_list = self.getProperty('dependency_list')
if dependency_list:
dependency_title = dependency_list[0]
dependency_bm = portal_templates.getInstalledBusinessManager(dependency_title)
if not dependency_bm:
raise ValueError('Missing Installed Business Manager for dependecy_list \
which is required to build')
# Use item_path to determine if we need to create Business Item or
# Business Property Item for storing old and new values
if '#' in item_path:
# Create new_prop_item and build it from ZODB
new_item = self.newContent(portal_type='Business Property Item',
item_path=item_path,
item_layer=item_layer,
item_sign=item_sign,
id='new_item')
new_item.build(self)
else:
# Create new_item and build it from ZODB
new_item = self.newContent(portal_type='Business Item',
item_path=item_path,
item_layer=item_layer,
item_sign=item_sign,
id='new_item')
new_item.build(self)
updated_id = 'old_item'
# Copy old item/property item from the item at similar path in dependency_bm
dependency_item = dependency_bm.getBusinessItemByPath(item_path)
# Raise if there is no item exisiting in dependency Business Manager
if not dependency_item:
raise ValueError('No %s exist at path %s in installed version of %s'
% ( new_item.getPortalType(),
item_path,
dependency_title,))
cp_data = dependency_bm.manage_copyObjects([dependency_item.getId()])
new_id = self.manage_pasteObjects(cp_data)[0]['new_id']
self.manage_renameObject(id=new_id, new_id=updated_id)
# Get the copied object and update the properties
old_item = self._getOb(updated_id)
old_item.setProperty('item_layer', item_layer)
old_item.setProperty('item_sign', item_sign)
# Commit the transaction
transaction.commit()
def getOldValue(self):
"""
Returns old value for the BusinessPatchItem
"""
old_item = self._getOb('old_item')[0]
if old_item.getPortalType() == 'Business Item':
return old_item.objectValues()
else:
return old_item.getProperty('item_property_value')
def getNewValue(self, build=False):
"""
Returns new value for the given BusinessPatchItem
"""
old_item = self._getOb('new_item')
if old_item.getPortalType() == 'Business Item':
return old_item.objectValues()[0]
else:
return old_item.getProperty('item_property_value')
def getDiff(self, patch_format='deepdiff'):
"""
Use diff tool to find the diff between two values
XXX: For now we display the json format of the patched diff
"""
patch = self.getPatchObject(patch_format)
if patch_format == 'deepdiff':
return patch.asDeepDiffPatch().json
else:
# For json-patch object
return patch.asJSONPatch().to_string()
def getPatchObject(self, patch_format='deepdiff'):
portal = self.getPortalObject()
diff_tool = portal.portal_diff
old_item = self._getOb('old_item')
new_item = self._getOb('new_item')
if (old_item.getPortalType() == new_item.getPortalType() == 'Business Item'):
old = old_item.objectValues()[0]
new = new_item.objectValues()[0]
else:
old = old_item.getProperty('item_property_value')
new = new_item.getProperty('item_property_value')
patch = diff_tool.diffPortalObject(old=old,
new=new,
patch_format=patch_format
)
return patch
def install(self, context, *args):
"""
Install will call the apply function which puts the new value at the
path mentioned while checking if the old value exists.
"""
# Installation is basically running installation on the new_value
self.new_value.install(context)
def applyPatch(self):
"""
Apply the new value by removing the old value. Also, show conflict in case
the value at old_installation_state is not same as the old value.
"""
pass
def registerSkinFolder(skin_tool, skin_folder):
request = skin_tool.REQUEST
# XXX: Getting parameter from request instead of dialog is bad
# XXX: This is even non consistent with rest of parameters selected by user
# (like update_translation or update_catalog)
register_skin_selection = request.get('your_register_skin_selection', 1)
reorder_skin_selection = request.get('your_reorder_skin_selection', 1)
skin_layer_list = request.get('your_skin_layer_list',
skin_tool.getSkinSelections())
skin_folder_id = skin_folder.getId()
try:
skin_selection_list = skin_folder.getProperty(
'business_template_registered_skin_selections',
skin_tool.getSkinSelections()
)
except AttributeError:
skin_selection_list = skin_tool.getSkinSelections()
if isinstance(skin_selection_list, basestring):
skin_selection_list = skin_selection_list.split()
def skin_sort_key(skin_folder_id):
obj = skin_tool._getOb(skin_folder_id, None)
if obj is None:
return 0, skin_folder_id
return -obj.getProperty('business_template_skin_layer_priority',
obj.meta_type == 'Filesystem Directory View' and -1 or 0), skin_folder_id
for skin_name in skin_selection_list:
if (skin_name not in skin_tool.getSkinSelections()) and \
register_skin_selection:
createSkinSelection(skin_tool, skin_name)
# add newly created skins to list of skins we care for
skin_layer_list.append(skin_name)
selection = skin_tool.getSkinPath(skin_name) or ''
selection_list = selection.split(',')
if (skin_folder_id not in selection_list):
selection_list.insert(0, skin_folder_id)
if reorder_skin_selection:
# Sort by skin priority and ID
selection_list.sort(key=skin_sort_key)
if (skin_name in skin_layer_list):
skin_tool.manage_skinLayers(skinpath=selection_list,
skinname=skin_name, add_skin=1)
skin_tool.getPortalObject().changeSkin(None)
def createSkinSelection(skin_tool, skin_name):
# This skin selection does not exist, so we create a new one.
# We'll initialize it with all skin folders, unless:
# - they explictly define a list of
# "business_template_registered_skin_selections", and we
# are not in this list.
# - they are not registered in the default skin selection
skin_path = ''
for skin_folder in skin_tool.objectValues():
if skin_name in skin_folder.getProperty(
'business_template_registered_skin_selections',
(skin_name, )):
if skin_folder.getId() in \
skin_tool.getSkinPath(skin_tool.getDefaultSkin()):
if skin_path:
skin_path = '%s,%s' % (skin_path, skin_folder.getId())
else:
skin_path= skin_folder.getId()
# add newly created skins to list of skins we care for
skin_tool.addSkinSelection(skin_name, skin_path)
skin_tool.getPortalObject().changeSkin(None)
def deleteSkinSelection(skin_tool, skin_name):
# Do not delete default skin
if skin_tool.getDefaultSkin() != skin_name:
for skin_folder in skin_tool.objectValues():
try:
if skin_name in skin_folder.getProperty(
'business_template_registered_skin_selections', ()):
break
except AttributeError:
pass
else:
skin_tool.manage_skinLayers(chosen=[skin_name], del_skin=1)
skin_tool.getPortalObject().changeSkin(None)
def unregisterSkinFolderId(skin_tool, skin_folder_id, skin_selection_list):
for skin_selection in skin_selection_list:
selection = skin_tool.getSkinPath(skin_selection)
selection = selection.split(',')
if (skin_folder_id in selection):
selection.remove(skin_folder_id)
skin_tool.manage_skinLayers(skinpath=tuple(selection),
skinname=skin_selection, add_skin=1)
deleteSkinSelection(skin_tool, skin_selection)
skin_tool.getPortalObject().changeSkin(None)
product/ERP5/Tool/TemplateTool.py
View file @ 0db17646
......@@ -33,17 +33,22 @@ from App.config import getConfiguration
import os
import shutil
import sys
import hashlib
import pprint
import transaction
from Acquisition import Implicit, Explicit
from AccessControl import ClassSecurityInfo
from AccessControl.SecurityInfo import ModuleSecurityInfo
from Products.CMFActivity.ActiveResult import ActiveResult
from Products.PythonScripts.PythonScript import PythonScript
from Products.ERP5Type.Globals import InitializeClass, DTMLFile, PersistentMapping
from Products.ERP5Type.DiffUtils import DiffFile
from Products.ERP5Type.Tool.BaseTool import BaseTool
from Products.ERP5Type.Cache import transactional_cached
from Products.ERP5Type import Permissions
from Products.ERP5Type import Permissions, interfaces
from Products.ERP5.Document.BusinessTemplate import BusinessTemplateMissingDependency
from Products.ERP5Type.Accessor.Constant import PropertyGetter as ConstantGetter
from Products.ERP5.genbt5list import generateInformation
from Acquisition import aq_base
from tempfile import mkstemp, mkdtemp
......@@ -60,6 +65,8 @@ from base64 import b64encode, b64decode
from Products.ERP5Type.Message import translateString
from zLOG import LOG, INFO, WARNING
from base64 import decodestring
from difflib import unified_diff
from operator import attrgetter
import subprocess
import time
......@@ -101,7 +108,10 @@ class TemplateTool (BaseTool):
title = 'Template Tool'
meta_type = 'ERP5 Template Tool'
portal_type = 'Template Tool'
allowed_types = ('ERP5 Business Template', )
allowed_types = (
'ERP5 Business Template',
'ERP5 Business Manager',
)
# This stores information on repositories.
repository_dict = {}
......@@ -128,7 +138,14 @@ class TemplateTool (BaseTool):
# potential danger because business templates may exchange catalog
# methods, so the database could be broken temporarily.
last_bt = last_time = None
for bt in self.objectValues(portal_type='Business Template'):
for bt in self.objectValues(portal_type=['Business Template',
'Business Manager']):
if bt.getPortalType() == 'Business Manager':
if bt.getInstallationState() == 'installed' and bt.title == title:
return bt
else:
continue
return None
if bt.getTitle() == title or title in bt.getProvisionList():
state = bt.getInstallationState()
if state == 'installed':
......@@ -149,6 +166,22 @@ class TemplateTool (BaseTool):
last_time = t
return last_bt
security.declareProtected(Permissions.AccessContentsInformation,
'getInstalledBusinessManager')
def getInstalledBusinessManager(self, title, strict=False, **kw):
"""Returns an installed version of business manager of given title.
Returns None if business manager is not installed or has been uninstalled.
"""
last_bm = None
for bm in self.objectValues(portal_type='Business Manager'):
if bm.getTitle() == title:
state = bm.getInstallationState()
if state == 'installed':
return bm
return last_bm
security.declareProtected(Permissions.AccessContentsInformation,
'getInstalledBusinessTemplatesList')
def getInstalledBusinessTemplatesList(self):
......@@ -161,7 +194,8 @@ class TemplateTool (BaseTool):
"""Get the list of installed business templates.
"""
installed_bts = []
for bt in self.contentValues(portal_type='Business Template'):
for bt in self.contentValues(portal_type=['Business Template',
'Business Manager']):
if bt.getInstallationState() == 'installed':
bt5 = bt
if only_title:
......@@ -276,7 +310,7 @@ class TemplateTool (BaseTool):
if RESPONSE is not None:
RESPONSE.setHeader('Content-type','tar/x-gzip')
RESPONSE.setHeader('Content-Disposition', 'inline;filename=%s-%s.bt5'
% (business_template.getTitle(), business_template.getVersion()))
% (business_template.getTitle(), business_template.getVersion()))
return export_string.getvalue()
finally:
export_string.close()
......@@ -306,6 +340,7 @@ class TemplateTool (BaseTool):
self.deleteContent(id)
self._importObjectFromFile(StringIO(export_string), id=id)
security.declareProtected( Permissions.ManagePortal, 'manage_download' )
def manage_download(self, url, id=None, REQUEST=None):
"""The management interface for download.
......@@ -321,9 +356,14 @@ class TemplateTool (BaseTool):
REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
% (ret_url, psm))
def _download_local(self, path, bt_id):
def _download_local(self, path, bt_id, format_version=1):
"""Download Business Template from local directory or file
"""
if format_version == 3:
bm = self.newContent(bt_id, 'Business Manager')
bm.importFile(path)
return bm
bt = self.newContent(bt_id, 'Business Template')
bt.importFile(path)
return bt
......@@ -361,12 +401,17 @@ class TemplateTool (BaseTool):
# 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, path = splittype(url)
if WIN and urltype and '\\' in path:
urltype, name = splittype(url)
# Create a zexp path which would be used for Business Manager files
zexp_path = name + '/' + name.split('/')[-1] + '.zexp'
# Better to expand path as we now use ~software_release for the software
# folder
zexp_path = os.path.expanduser(zexp_path)
if WIN and urltype and '\\' in name:
urltype = None
path = url
if urltype and urltype != 'file':
......@@ -377,9 +422,28 @@ class TemplateTool (BaseTool):
del bt.uid
return self[self._setObject(id, bt)]
bt = self._download_url(url, id)
elif os.path.exists(zexp_path):
# If the path exists, we create a Business Manager object after
# downloading it from zexp path
bt = self._download_local(os.path.normpath(zexp_path), id, format_version=3)
else:
path = os.path.normpath(os.path.expanduser(path))
bt = self._download_local(path, id)
template_version_path_list = [
name+'/bt/template_format_version',
]
for path in template_version_path_list:
try:
file = open(os.path.normpath(path))
except IOError:
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
# XXX: Download only needed in case the file is in directory
bt = self._download_local(os.path.expanduser(os.path.normpath(name)), id, format_version)
bt.build(no_action=True)
return bt
......@@ -534,6 +598,413 @@ class TemplateTool (BaseTool):
self.activate(activity='SQLQueue').\
importAndReExportBusinessTemplateFromPath(template_path)
security.declareProtected( 'Import/Export objects', 'migrateBTToBM')
def migrateBTToBM(self, template_path, isReduced=False, REQUEST=None, **kw):
"""
Migrate business template repository to Business Manager repo.
Business Manager completely rely only on BusinessItem 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 Manager 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
manager there instead
5. Change the ID and title of the business manager
6. Export the business manager to the directory, leaving anything in
the installed erp5 unchanged
"""
import_template = self.download(url=template_path)
if import_template.getPortalType() == 'Business Manager':
LOG(import_template.getTitle(),0,'Already migrated')
return
export_dir = mkdtemp()
removable_property = {}
removable_sub_object_path = []
installed_bt_list = self.getInstalledBusinessTemplatesList()
installed_bt_title_list = [bt.title for bt in installed_bt_list]
is_installed = False
if import_template.getTitle() not in installed_bt_title_list:
# Install the business template
import_template.install(**kw)
is_installed = True
# Make list of object paths which needs to be added in the bm5
# 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.
portal_path = self.getPortalObject()
template_path_list = []
property_path_list = []
# For modules, we don't need to create path for the module
module_list = import_template.getTemplateModuleIdList()
for path in module_list:
template_path_list.append(path)
# For portal_types, we have to add path and subobjects
portal_type_id_list = import_template.getTemplatePortalTypeIdList()
portal_type_path_list = []
portal_type_workflow_chain_path_list = []
for id in portal_type_id_list:
portal_type_path_list.append('portal_types/'+id)
# Add type_worklow list separately in path
portal_type_workflow_chain_path_list.append('portal_types/'+id+'#type_workflow_list')
# Remove type_workflow_list from the objects, so that we don't end up in
# conflict
portal_type_path = 'portal_types/' + id
removable_property[portal_type_path] = ['type_workflow_list']
template_path_list.extend(portal_type_path_list)
template_path_list.extend(portal_type_workflow_chain_path_list)
# For categories, we create path for category objects as well as the subcategories
category_list = import_template.getTemplateBaseCategoryList()
category_path_list = []
for base_category in category_list:
category_path_list.append('portal_categories/'+base_category)
#category_path_list.append('portal_categories/'+base_category+'/**')
template_path_list.extend(category_path_list)
# Adding tools
template_tool_id_list = import_template.getTemplateToolIdList()
tool_id_list = []
for tool_id in template_tool_id_list:
tool_id_list.append(tool_id)
template_path_list.extend(tool_id_list)
# Adding business template skin selection property on the portal_tempaltes
template_skin_selection_list = import_template.getTemplateRegisteredSkinSelectionList()
selection_list = []
for selection in template_skin_selection_list:
skin, selection = selection.split(' | ')
selection_list.append('portal_skins/%s#business_template_registered_skin_selections'%skin)
# For portal_skins, we export the folder
portal_skin_list = import_template.getTemplateSkinIdList()
portal_skin_path_list = []
for skin in portal_skin_list:
portal_skin_path_list.append('portal_skins/'+skin)
#portal_skin_path_list.append('portal_skins/'+skin+'/**')
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:
workflow_path_list.append('portal_workflow/' + workflow)
#workflow_path_list.append('portal_workflow/' + workflow + '/**')
template_path_list.extend(workflow_path_list)
# For tests in portal components add them with portal_components head
test_id_list = import_template.getTemplateTestIdList()
test_path_list = []
for path in test_id_list:
test_path_list.append('portal_components/' + path)
template_path_list.extend(test_path_list)
# For documents in portal components add them with portal_components head
document_id_list = import_template.getTemplateDocumentIdList()
document_path_list = []
for path in document_id_list:
document_path_list.append('portal_components/' + path)
template_path_list.extend(document_path_list)
# For extensions in portal components add them with portal_components head
extension_id_list = import_template.getTemplateExtensionIdList()
extension_path_list = []
for path in extension_id_list:
extension_path_list.append('portal_components/' + path)
template_path_list.extend(extension_path_list)
# For paths, we add them directly to the path list
path_list = import_template.getTemplatePathList()
for path in path_list:
template_path_list.append(path)
# Catalog methods would be added as sub objects
catalog_method_item_list = import_template.getTemplateCatalogMethodIdList()
catalog_method_path_list = []
for method in catalog_method_item_list:
catalog_method_path_list.append('portal_catalog/' + method)
template_path_list.extend(catalog_method_path_list)
# For catalog objects, we check if there is any catalog object, and then
# add catalog object also in the path if there is
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()
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',
]
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'
removable_sub_object_path.append(catalog_path)
removable_property[catalog_path] = properties_removed
for prop in properties_removed:
property_path_list.append('%s#%s' % (catalog_path, prop))
# 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.append('portal_catalog/erp5_mysql_innodb')
# 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)
# Create new objects for business manager
migrated_bm = self.newContent(
portal_type='Business Manager',
title=import_template.getTitle()
)
template_path_list.extend(property_path_list)
template_path_list.extend(selection_list)
template_path_list = self.cleanTemplatePathList(template_path_list)
# XXX: Add layer=1 and sign=1 for default for all paths
template_path_list = [l + ' | 1 | 1' for l in template_path_list]
def reduceDependencyList(bt, template_path_list):
"""
Used for recursive udpation of layer for dependency in a BT
"""
dependency_list = bt.getDependencyList()
# XXX: Do not return template_path_list of the new BM incase there is no
# dependency_list, instead look for the latest updated version of
# new_template_path_list
if not dependency_list:
return template_path_list
else:
# Copy of the initial template list to be used to update the layer
new_template_path_list = list(template_path_list)
for item in dependency_list:
dependency = item.split(' ', 1)
if len(dependency) > 1:
version = dependency[1]
if version:
version = version[1:-1]
base_bt = self.getLastestBTOnRepos(dependency[0], version)
else:
try:
base_bt = self.getLastestBTOnRepos(dependency[0])
except BusinessTemplateIsMeta:
bt_list = self.getProviderList(dependency[0])
# We explicilty use the Business Template which is used the most
# while dealing with provision list
repository_list = self.getRepositoryList()
if dependency[0] == 'erp5_full_text_catalog':
base_bt = [repository_list[1], 'erp5_full_text_mroonga_catalog']
if dependency[0] == 'erp5_view_style':
base_bt = [repository_list[0], 'erp5_xhtml_style']
if dependency[0] == 'erp5_catalog':
base_bt = [repository_list[0], 'erp5_mysql_innodb_catalog']
# XXX: Create path for the BT(s) here
# Download the base_bt
base_bt_path = os.path.join(base_bt[0], base_bt[1])
base_bt = self.download(base_bt_path)
# Check for the item list and if the BT is Business Manager,
# if BM, then compare and update layer and if not run migration and
# then do it again
if base_bt.getPortalType() != 'Business Manager':
# If the base_bt is not Business Manager, run the migration on the
# base_bt
base_bt = self.migrateBTToBM(base_bt_path, isReduced=True)
# Check for item path which also exists in base_bt
base_path_list = base_bt.getPathList()
copy_of_template_path_list = new_template_path_list[:]
# Loop through all the paths in the new_template_path_list and
# check for their existence in base_path_list
for idx, path in enumerate(new_template_path_list):
path_list = path.split(' | ')
item_path = path_list[0]
item_layer = path_list[2]
if item_path in base_path_list:
# TODO: Increase the layer of the path item by +1 and save it
# back at updated_template_path_list
item_layer = int(item_layer) + 1
updated_path = item_path + ' | 1 | ' + str(item_layer)
copy_of_template_path_list[idx] = updated_path
new_template_path_list = copy_of_template_path_list
if base_bt.getPortalType() != 'Business Manager':
# Recursively reduce the base Business Templatem no need to do
# this for Business Manager(s) as it had already been migrated
# with taking care of layer
reduceDependencyList(base_bt, new_template_path_list)
return new_template_path_list
# Take care about the the dependency_list also and then update the layer
# accordingly for the path(s) that already exists in the dependencies.
template_path_list = reduceDependencyList(import_template, template_path_list)
# Create new sub-objects instead based on template_path_list
for path in template_path_list:
path_list = path.split(' | ')
# Create Business Property Item for objects with property in path
if '#' in path_list[0]:
migrated_bm.newContent(
portal_type='Business Property Item',
item_path=path_list[0],
item_sign=path_list[1],
item_layer=path_list[2],
)
else:
migrated_bm.newContent(
portal_type='Business Item',
item_path=path_list[0],
item_sign=path_list[1],
item_layer=path_list[2],
)
kw['removable_property'] = removable_property
kw['removable_sub_object_path'] = removable_sub_object_path
migrated_bm.build(**kw)
# Commit transaction to generate all oids before exporting
transaction.commit()
# Export the newly built business manager to the export directory
migrated_bm.export(path=export_dir, local=True)
if is_installed:
import_template.uninstall()
if isReduced:
return migrated_bm
def cleanTemplatePathList(self, path_list):
"""
Remove redundant paths and sub-objects' path if the object path already
exist.
"""
# Split path into list
a2 = [l.split('/') for l in path_list]
# Create new list for paths with **
a3 = [l for l in a2 if l[-1] in ('**', '*')]
# Create new list for paths without **
a4 = [l for l in a2 if l[-1] not in ('**', '*')]
# Remove ** from paths in a3
reserved_id = ('portal_transforms', 'portal_ids')
a3 = [l[:-1] for l in a3 if l[0] not in reserved_id] + [l for l in a3 if l[0] in reserved_id]
# Create new final path list
a2 = a3+a4
# Join the path list
a2 = [('/').join(l) for l in a2]
# Remove the redundant paths
seen = set()
seen_add = seen.add
# XXX: What about redundant signs with different layers
# Maybe we will end up reducing them
a2 = [x for x in a2 if not (x in seen or seen_add(x))]
return a2
security.declareProtected( 'Import/Export objects', 'migrateBTListToBM')
def migrateBTToBMRequest(self, bt_title_list, REQUEST=None, **kw):
"""
Run migration for BT5 one by one in a given repository. This will be done
via activities.
"""
if REQUEST is None:
REQUEST = getattr(self, 'REQUEST', None)
if len(bt_title_list) == 0 and REQUEST:
ret_url = self.absolute_url()
REQUEST.RESPONSE.redirect("%s?portal_status_message=%s"
% (ret_url, 'No BT title was given'))
repository_list = self.getRepositoryList()
for title in bt_title_list:
title = title.rstrip('\n')
title = title.rstrip('\r')
for repository in repository_list:
if title in os.listdir(repository):
template_path = os.path.join(repository, title)
else:
continue
if os.path.isfile(template_path):
LOG(title, 0, 'is file, so it is skipped')
else:
if not os.path.exists((os.path.join(template_path, 'bt'))):
LOG(title, 0, 'has no bt sub-folder, so it is skipped')
else:
self.migrateBTToBM(template_path)
security.declareProtected(Permissions.ManagePortal, 'getFilteredDiff')
def getFilteredDiff(self, diff):
"""
......@@ -676,6 +1147,212 @@ class TemplateTool (BaseTool):
finally:
f.close()
#XXX: Hardcoding 'erp5_core_proxy_field_legacy' BP in the list
bp_dict_1 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_core_proxy_field_legacy',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_core_proxy_field_legacy',
'version': '5.4.7'}
bp_dict_2 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_base',],
'description': '',
'force_install': 0,
'id': 'erp5_pdm',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_pdm',
'version': '5.4.7'}
bp_dict_3 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_ui_test',],
'description': '',
'force_install': 0,
'id': 'erp5_performance_test',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_performance_test',
'version': '5.4.7'}
bp_dict_4 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_ui_test_core',],
'description': '',
'force_install': 0,
'id': 'erp5_ui_test',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_ui_test',
'version': '5.4.7'}
bp_dict_5 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_core', 'erp5_xhtml_style',],
'description': '',
'force_install': 0,
'id': 'erp5_ui_test_core',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_ui_test_core',
'version': '5.4.7'}
bp_dict_6 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_core (>= 1.0rc12)',
'erp5_full_text_catalog',
'erp5_core_proxy_field_legacy',],
'description': '',
'force_install': 0,
'id': 'erp5_base',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_base',
'version': '5.4.7'}
bp_dict_7 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_full_text_mroonga_catalog',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': ['erp5_full_text_catalog'],
'title': 'erp5_full_text_mroonga_catalog',
'version': '5.4.7'}
if repository.endswith('/bt5'):
property_dict_list.append(bp_dict_1)
property_dict_list.append(bp_dict_2)
property_dict_list.append(bp_dict_3)
#property_dict_list.append(bp_dict_4)
property_dict_list.append(bp_dict_5)
property_dict_list.append(bp_dict_6)
property_dict_list.append(bp_dict_7)
bm_dict_1 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_mysql_innodb_catalog',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': ['erp5_catalog'],
'title': 'erp5_mysql_innodb_catalog',
'version': '5.4.7'}
bm_dict_2 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_core'],
'description': '',
'force_install': 0,
'id': 'erp5_xhtml_style',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': ['erp5_view_style'],
'title': 'erp5_xhtml_style',
'version': '5.4.7'}
bm_dict_3 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_mysql_ndb_catalog',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': ['erp5_catalog'],
'title': 'erp5_mysql_ndb_catalog',
'version': '5.4.7'}
bm_dict_4 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_view_style',],
'description': '',
'force_install': 0,
'id': 'erp5_jquery',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_jquery',
'version': '5.4.7'}
bm_dict_5 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_property_sheets',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_property_sheets',
'version': '5.4.7'}
bm_dict_6 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': ['erp5_catalog (>= 1.1)',
'erp5_core_proxy_field_legacy',
'erp5_property_sheets'],
'description': '',
'force_install': 0,
'id': 'erp5_core',
'license': 'GPL',
'revision': '',
'test_dependency_list': ['erp5_full_text_mroonga_catalog',
'erp5_base'],
'provision_list': ['erp5_auto_logout',],
'title': 'erp5_core',
'version': '5.4.7'}
bm_dict_7 ={
'copyright_list': ['Copyright (c) 2001-2017 Nexedi SA'],
'dependency_list': [],
'description': '',
'force_install': 0,
'id': 'erp5_business_package',
'license': 'GPL',
'revision': '',
'test_dependency_list': [],
'provision_list': [],
'title': 'erp5_business_package',
'version': '5.4.7'}
if repository.endswith('/bootstrap'):
property_dict_list.append(bm_dict_1)
#property_dict_list.append(bm_dict_2)
property_dict_list.append(bm_dict_3)
property_dict_list.append(bm_dict_4)
property_dict_list.append(bm_dict_5)
property_dict_list.append(bm_dict_6)
#property_dict_list.append(bm_dict_7)
self.repository_dict[repository] = tuple(property_dict_list)
if REQUEST is not None:
......@@ -1141,10 +1818,8 @@ class TemplateTool (BaseTool):
template_title_list,
with_test_dependency_list=False):
available_bt5_list = self.getRepositoryBusinessTemplateList()
template_title_list = set(template_title_list)
installed_bt5_title_list = self.getInstalledBusinessTemplateTitleList()
bt5_set = set()
for available_bt5 in available_bt5_list:
if available_bt5.title in template_title_list:
......@@ -1341,8 +2016,11 @@ class TemplateTool (BaseTool):
if update_catalog is CATALOG_UPDATABLE and install_kw != {}:
update_catalog = imported_bt5.isCatalogUpdatable()
imported_bt5.install(object_to_update=install_kw,
update_catalog=update_catalog)
if imported_bt5.getPortalType() == 'Business Manager':
self.updateInstallationState([imported_bt5])
else:
imported_bt5.install(object_to_update=install_kw,
update_catalog=update_catalog)
# Run After script list
for after_triggered_bt5_id in after_triggered_bt5_id_list:
......@@ -1357,6 +2035,598 @@ class TemplateTool (BaseTool):
return imported_bt5
security.declareProtected(Permissions.ManagePortal,
'installBusinessManager')
def installBusinessManager(self, bm):
"""
Run installation on flattened Business Manager
"""
# Run install on separate Business Item one by one
for path_item in bm._path_item_list:
path_item.install(self)
bm.setStatus('installed')
def updateHash(self, item):
"""
Function to update hash of Business Item or Business Property Item
"""
# Check for isProperty attribute
if item.isProperty:
value = item.getProperty('item_property_value')
else:
value_list = item.objectValues()
if value_list:
value = value_list[0]
else:
value = ''
if value:
item.setProperty('item_sha', self.calculateComparableHash(
value,
item.isProperty,
))
def rebuildBusinessManager(self, bm):
"""
Compare the sub-objects in the Business Manager to the previous built
state to give user powet to decide on which item to rebuild.
"""
checkNeeded = True
changed_path_list = []
if bm.getBuildingState() not in ['built', 'modified']:
# In case the building_state is not built, we build the BM without
# comparing anything
checkNeeded = False
return checkNeeded, changed_path_list
portal = self.getPortalObject()
for item in bm.objectValues():
# Check for the change compared to old building state, i.e, if there is
# some change made at ZODB state(it also count changes made due to
# change while installation of other BM)
path = item.getProperty('item_path')
try:
if item.isProperty:
# Get the value for Business Property Item
value = item.getProperty('item_property_value')
# Get the value at ZODB
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
obj = property_value
else:
# Get the value of the Business Path Item
value_list = item.objectValues()
if value_list:
value = value_list[0]
else:
# If there is no value, it means the path_item is new, thus no
# need to comapre hash and check anything
changed_path_list.append((path, 'New'))
continue
# Get the object at ZODB
obj = portal.restrictedTraverse(path)
# Calculate hash for value at ZODB
obj_sha = self.calculateComparableHash(obj, item.isProperty)
# Update hash for value at property_value
self.updateHash(item)
item_sha = item.getProperty('item_sha')
# Compare the hash with the item hash
if obj_sha != item_sha:
changed_path_list.append((path, 'Changed'))
else:
changed_path_list.append((path, 'Unchanged'))
# KeyError is raised in case the value/object has been deleted at ZODB
except KeyError:
changed_path_list.append((path, 'Deleted'))
return checkNeeded, changed_path_list
security.declareProtected(Permissions.ManagePortal,
'updateInstallationState')
def compareInstallationState(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
"""
# Create old installation state from Installed Business Manager
installed_bm_list = self.getInstalledBusinessManagerList()
combined_installed_path_item = [item for bm
in installed_bm_list
for item in bm.objectValues()]
# 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',
temp_object=True,
)
for item in combined_installed_path_item:
item.isIndexable = ConstantGetter('isIndexable', value=False)
# Better to use new ids so that we don't end up in conflicts
new_id = old_installation_state.generateNewId()
old_installation_state._setObject(new_id, aq_base(item),
suppress_events=True)
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.objectValues()]
# 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',
temp_object=True,
)
for item in combined_new_path_item:
item.isIndexable = ConstantGetter('isIndexable', value=False)
new_id = new_installation_state.generateNewId()
new_installation_state._setObject(new_id, aq_base(item),
suppress_events=True)
# 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',
temp_object=True,
)
# Reduce both old and new Installation State
old_installation_state.reduceBusinessManager()
new_installation_state.reduceBusinessManager()
# 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.setProperty('item_sign', '-1')
to_install_path_item_list.append(old_item)
# Reduce old_installation_state again as changes as new sub-objects maybe
# added to the old_installation_state
old_installation_state.reduceBusinessManager()
# XXX: At this point, we expect all the Business Manager objects as 'reduced',
# thus all the BusinessItem sub-objects should have single value
# Update hashes of item in old state before installation
for item in old_installation_state.objectValues():
# In case of Business Patch Item we need to update hash of both new and
# old value
if item.getPortalType() == 'Business Patch Item':
new_val = item._getOb('new_item')
old_val = item._getOb('old_item')
self.updateHash(new_val)
self.updateHash(old_val)
else:
self.updateHash(item)
# Path Item List for installation_process should be the difference between
# old and new installation state
for item in new_installation_state.objectValues():
# If the path has been removed, then add it with sign = -1
old_item = old_installation_state.getBusinessItemByPath(item.getProperty('item_path'))
# In case of Business Patch Item we need to update hash of both new and
# old value
if item.getPortalType() == 'Business Patch Item':
new_val = item._getOb('new_item')
old_val = item._getOb('old_item')
self.updateHash(new_val)
self.updateHash(old_val)
else:
self.updateHash(item)
if old_item:
to_be_installed_item = item
if old_item.getPortalType() == 'Business Patch Item':
# In case of Business Patch Item, we just need to compare the hash
# of old_item
old_item = old_item._getOb('old_item')
item = item._getOb('old_item')
# If the old_item exists, we match the hashes and if it differs, then
# add the new item
if old_item.getProperty('item_sha') != item.getProperty('item_sha'):
to_install_path_item_list.append(to_be_installed_item)
else:
to_install_path_item_list.append(item)
for item in to_install_path_item_list:
item.isIndexable = ConstantGetter('isIndexable', value=False)
new_id = new_installation_state.generateNewId()
installation_process._setObject(new_id, aq_base(item),
suppress_events=True)
change_list = self.compareOldStateToOFS(installation_process, old_installation_state)
if change_list:
change_list = [(l[0].item_path, l[1]) for l in change_list]
return change_list
def updateInstallationState(self, bm_list, force=1):
"""
First compare installation state and then install the final value
"""
change_list = self.compareInstallationState(bm_list)
if force:
to_install_path_list = [l[0] for l in change_list]
to_install_path_list = self.sortPathList(to_install_path_list)
# Install the path items with bm_list as context
self.installBusinessItemList(bm_list, to_install_path_list)
installMultipleBusinessManager = updateInstallationState
def installBusinessItemList(self, manager_list, item_path_list):
"""
Install Business Item/Business Property Item from the current Installation
Process given the change_list which carries the list of paths to be
installed
"""
LOG('INFO', 0, '%s' % [item_path_list])
# Create BM for new installation state and update its path item list
new_installation_state = self.newContent(
portal_type='Business Manager',
title='Final Installation State',
temp_object=True,
)
combined_new_path_item_list = [item for bm
in manager_list
for item in bm.objectValues()]
for item in combined_new_path_item_list:
item.isIndexable = ConstantGetter('isIndexable', value=False)
new_id = new_installation_state.generateNewId()
new_installation_state._setObject(new_id, aq_base(item),
suppress_events=True)
for path in item_path_list:
item = new_installation_state.getBusinessItemByPath(path)
if item is None:
raise ValueError("Couldn't find path in current Installation State")
item.install(new_installation_state)
# Update workflow history of the installed Business Manager(s)
# Get the 'business_manager_installation_workflow' as it is already
# bootstrapped and installed
portal_workflow = self.getPortalObject().portal_workflow
wf = portal_workflow._getOb('business_manager_installation_workflow')
# Change the installation state for all the BM(s) in manager_list.
for manager in manager_list:
wf._executeMetaTransition(manager, 'installed')
def calculateComparableHash(self, object, isProperty=False):
"""
Remove some attributes before comparing hashses
and return hash of the comparable object dict, in case the object is
an erp5 object.
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)
# XXX: Comparable hash shouldn't be used for BusinessPatchItem as whole.
We can compare the old_value and new_value, but there shouldn't be hash
for the Patch Item.
"""
if isProperty:
obj_dict = object
# Have compatibilty between tuples and list while comparing as we face
# this situation a lot especially for list type properties
if isinstance(obj_dict, list):
obj_dict = tuple(obj_dict)
else:
klass = object.__class__
classname = klass.__name__
obj_dict = object.__dict__.copy()
# If the dict is empty, do calculate hash of None as it stays same on
# one platform and in any case its impossiblt to move live python
# objects from one seeion to another
if not bool(obj_dict):
return hash(None)
attr_set = {'_dav_writelocks', '_filepath', '_owner', '_related_index',
'last_id', 'uid', '_mt_index', '_count', '_tree',
'__ac_local_roles__', '__ac_local_roles_group_id_dict__',
'workflow_history', 'subject_set_uid_dict', 'security_uid_dict',
'filter_dict', '_max_uid'}
attr_set.update(('isIndexable',))
if classname in ('File', 'Image'):
attr_set.update(('_EtagSupport__etag', 'size'))
elif classname == 'Types Tool' and klass.__module__ == 'erp5.portal_type':
attr_set.add('type_provider_list')
for attr in object.__dict__.keys():
if attr in attr_set or attr.startswith('_cache_cookie_') or attr.startswith('_v'):
try:
del obj_dict[attr]
except AttributeError:
# XXX: Continue in cases where we want to delete some properties which
# are not in attribute list
# Raise an error
continue
# Special case for configuration instance attributes
if attr in ['_config', '_config_metadata']:
import collections
# Order the dictionary so that comparison can be correct
obj_dict[attr] = collections.OrderedDict(sorted(obj_dict[attr].items()))
if 'valid_tags' in obj_dict[attr]:
try:
obj_dict[attr]['valid_tags'] = collections.OrderedDict(sorted(obj_dict[attr]['valid_tags'].items()))
except AttributeError:
# This can occur in case the valid_tag object is PersistentList
pass
if 'data' in obj_dict:
try:
obj_dict['data'] = obj_dict.get('data').__dict__
except AttributeError:
pass
obj_sha = hash(pprint.pformat(obj_dict))
return obj_sha
def sortPathList(self, path_list):
"""
Custom sort for path_list according to the priorities of paths
"""
def comparePath(path):
split_path_list = path.split('/')
# Paths with property item should have the least priority as they should
# be installed after installing the object only
if '#' in path:
return 11
if len(split_path_list) == 2 and split_path_list[0] in ('portal_types', 'portal_categories'):
return 1
# portal_transforms objects needs portal_components installed first so
# as to register the modules
if len(split_path_list) == 2 and split_path_list[0] == 'portal_transforms':
return 12
if len(split_path_list) > 2:
return 10
if len(split_path_list) == 1:
return 2
return 5
return sorted(path_list, key=comparePath)
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()
# List to store what changes will be done to which path. Here we compare
# with all the states (old version, new version and state of object at ZODB)
change_list = []
to_update_path_list = self.sortPathList(to_update_path_list)
for path in to_update_path_list:
try:
# Better to check for status of BusinessPatchItem separately as it
# can contain both BusinessItem as well as BusinessPropertyItem
new_item = installation_process.getBusinessItemByPath(path)
if new_item.getPortalType() == 'Business Patch Item':
patch_item = new_item
# If the value is in ZODB, then compare it to the old_value
if '#' in str(path):
isProperty = True
relative_url, property_id = path.split('#')
obj = portal.restrictedTraverse(relative_url)
property_value = obj.getProperty(property_id)
if not property_value:
raise KeyError
property_type = obj.getPropertyType(property_id)
obj = property_value
else:
# If the path is path on an object and not of a property
isProperty = False
obj = portal.restictedTraverse(path)
obj_sha = self.calculateComparableHash(obj, isProperty)
# Get the sha of new_item from the BusinessPatchItem object
new_item_sha = patch_item._getOb('new_item').getProperty('item_sha')
old_item_sha = patch_item._getOb('old_item').getProperty('item_sha')
if new_item_sha == obj_sha:
# If the new_item in the patch is same as the one at ZODB, do
# nothing
continue
elif old_item_sha == obj_sha:
change_list.append((patch_item._getOb('new_item'), 'Adding'))
else:
change_list.append((patch_item._getOb('new_item'), 'Removing'))
if '#' in str(path):
isProperty = True
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)
obj = property_value
else:
isProperty = False
# XXX: Hardcoding because of problem with 'resource' trying to access
# the resource via acqusition. Should be removed completely before
# merging (DONT PUSH THIS)
if path == 'portal_categories/resource':
path_list = path.split('/')
container_path = path_list[:-1]
object_id = path_list[-1]
container = portal.restrictedTraverse(container_path)
obj = container._getOb(object_id)
else:
obj = portal.restrictedTraverse(path)
obj_sha = self.calculateComparableHash(obj, isProperty)
# 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:
# Compare hash with ZODB
if old_item.getProperty('item_sha') == obj_sha:
# No change at ZODB on old item, so get the new item
new_item = installation_process.getBusinessItemByPath(path)
# Compare new item hash with ZODB
if new_item.getProperty('item_sha') == obj_sha:
if int(new_item.getProperty('item_sign')) == -1:
# If the sign is negative, remove the value from the path
change_list.append((new_item, 'Removing'))
else:
# If same hash, and +1 sign, do nothing
continue
else:
# Install the new_item
change_list.append((new_item, 'Adding'))
else:
# Change at ZODB, so get the new item
new_item = installation_process.getBusinessItemByPath(path)
# Compare new item hash with ZODB
if new_item.getProperty('item_sha') == obj_sha:
# If same hash, do nothing
continue
else:
# Trying to update change at ZODB
change_list.append((new_item, 'Updating'))
else:
# Object created at ZODB by the user
# Compare with the new_item
new_item = installation_process.getBusinessItemByPath(path)
if new_item.getProperty('item_sha') == obj_sha:
# If same hash, do nothing
continue
else:
# Trying to update change at ZODB
change_list.append((new_item, 'Updating'))
except (AttributeError, KeyError) as e:
# 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 int(new_item.getProperty('item_sign')) == 1:
# Object at ZODB has been removed by the user
change_list.append((new_item, 'Adding'))
else:
# If there is no item at old state, install the new_item
new_item = installation_process.getBusinessItemByPath(path)
# XXX: Hack for not trying to install the sub-objects from zexp,
# This should rather be implemented while exporting the object,
# where we shouldn't export sub-objects in the zexp
if not isProperty:
try:
value = new_item.objectValues()[0]
except IndexError:
continue
# Installing a new item
change_list.append((new_item, 'Adding'))
return change_list
def getInstalledBusinessManagerList(self):
bm_list = self.objectValues(portal_type='Business Manager')
installed_bm_list = [bm for bm in bm_list
if bm.getInstallationState() == '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
security.declareProtected(Permissions.ManagePortal,
'getBusinessTemplateUrl')
def getBusinessTemplateUrl(self, base_url_list, bt5_title):
......
product/ERP5/__init__.py
View file @ 0db17646
......@@ -54,10 +54,12 @@ from Tool import CategoryTool, SimulationTool, RuleTool, IdTool, TemplateTool,\
CertificateAuthorityTool, InotifyTool, TaskDistributionTool,\
DiffTool
import ERP5Site
from Document import PythonScript, SQLMethod
from Document import PythonScript, BusinessManager
object_classes = ( ERP5Site.ERP5Site,
PythonScript.PythonScriptThroughZMI,
SQLMethod.SQLMethod,
BusinessManager.BusinessItem,
BusinessManager.BusinessPropertyItem,
BusinessManager.BusinessPatchItem,
)
portal_tools = ( CategoryTool.CategoryTool,
SimulationTool.SimulationTool,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7