From a86436c4f92f14417c94dac8cc344b73fcfd725b Mon Sep 17 00:00:00 2001 From: Jean-Paul Smets <jp@nexedi.com> Date: Thu, 29 Dec 2005 14:32:39 +0000 Subject: [PATCH] Renamed to follow naming convention. Added comments for implementation weaknesses. git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@4944 20353a03-c40f-0410-a6d1-a30d3c3de9de --- product/ERP5Form/PreferenceTool.py | 73 +++++++++++++++++++----------- 1 file changed, 46 insertions(+), 27 deletions(-) diff --git a/product/ERP5Form/PreferenceTool.py b/product/ERP5Form/PreferenceTool.py index 1e68d4f3b7..755fc672c2 100755 --- a/product/ERP5Form/PreferenceTool.py +++ b/product/ERP5Form/PreferenceTool.py @@ -52,16 +52,16 @@ class PreferenceTool(BaseTool): security.declareProtected( Permissions.ManagePortal, 'manage_overview' ) manage_overview = DTMLFile( 'explainPreferenceTool', _dtmldir ) - + security.declareProtected( Permissions.ManagePortal, 'manage_group_preferences' ) manage_group_preferences = DTMLFile( 'PreferenceTool_managePreferences', _dtmldir ) - + manage_options = ( BaseTool.manage_options + ( { 'label' : 'User Groups Preferences' , 'action' : 'manage_group_preferences'},)) - + security.declarePrivate('manage_afterAdd') def manage_afterAdd(self, item, container) : """ init the permissions right after creation """ @@ -70,7 +70,7 @@ class PreferenceTool(BaseTool): item.manage_permission(Permissions.View, ['Member', 'Auditor', 'Manager']) BaseTool.inheritedAttribute('manage_afterAdd')(self, item, container) - + def _aq_dynamic(self, name): """ if the name is a valid preference, then start a lookup on active preferences. """ @@ -80,16 +80,16 @@ class PreferenceTool(BaseTool): aq_base_name = getattr(aq_base(self), name, None) if aq_base_name is not None : return aq_base_name - if name in self.getValidPreferenceNames() : + if name in self.getValidPreferencePropertyIdList() : return self.getPreference(name) - + security.declareProtected(Permissions.View, "getPreference") def getPreference(self, pref_name) : """ get the preference on the most appopriate Preference object. """ def _getPreference(pref_name="", user_name="") : found = 0 MARKER = [] - for pref in self._getMostAppropriatePreferences() : + for pref in self._getSortedPreferenceList() : attr = getattr(pref, pref_name, MARKER) if attr is not MARKER : found = 1 @@ -106,17 +106,17 @@ class PreferenceTool(BaseTool): id='PreferenceTool.CachingMethod') user_name = getSecurityManager().getUser().getId() return _getPreference(pref_name=pref_name, user_name=user_name) - + security.declareProtected(Permissions.ModifyPortalContent, "setPreference") def setPreference(self, pref_name, value) : """ set the preference on the active Preference object""" self.getActivePreference()._edit(**{pref_name:value}) - - security.declareProtected(Permissions.View, "getValidPreferenceNames") - def getValidPreferenceNames(self) : + + security.declareProtected(Permissions.View, "getValidPreferencePropertyIdList") + def getValidPreferencePropertyIdList(self) : """ return the list of attributes that are preferences names and should be looked up on Preferences. """ - def _getValidPreferenceNames(self) : + def _getValidPreferencePropertyIdList(self) : """ a cache for this method """ attr_list = [] try : @@ -132,7 +132,7 @@ class PreferenceTool(BaseTool): zmi_property_sheet_list.append( getattr(__import__(property_sheet), property_sheet)) except ImportError, e : - LOG('PreferenceTool._getValidPreferenceNames', INFO, + LOG('PreferenceTool._getValidPreferencePropertyIdList', INFO, 'unable to import Property Sheet %s' % property_sheet, e) # 'Static' property sheets defined on the class class_property_sheet_list = Preference.property_sheets @@ -163,16 +163,22 @@ class PreferenceTool(BaseTool): 'get%sTitleList' % convertToUpperCase(attribute), 'get%sList' % convertToUpperCase(attribute), ] return attr_list - _getValidPreferenceNames = CachingMethod( - _getValidPreferenceNames, cache_duration = 600, + _getValidPreferencePropertyIdList = CachingMethod( + _getValidPreferencePropertyIdList, cache_duration = 600, id = 'PreferenceTool._getPreferenceAttributes') - return _getValidPreferenceNames(self) + return _getValidPreferencePropertyIdList(self) - security.declarePrivate('_getMostAppropriatePreferences') - def _getMostAppropriatePreferences(self) : + security.declarePrivate('_getSortedPreferenceList') + def _getSortedPreferenceList(self) : """ return the most appropriate preferences objects, - sorted so that the first in the list should be applied first """ + sorted so that the first in the list should be applied first + """ prefs = [] + # XXX This will not work with 1000000 users (searchFolder required) + # XXX will also cause problems with Manager (too long) + # XXX Use catalog instead of contentValues (ex. searchFolder) + # XXX For manager, create a manager specific preference + # or better solution for pref in self.contentValues(spec=('ERP5 Preference', )) : pref = pref.getObject() if pref.getPreferenceState() == 'enabled' : @@ -184,16 +190,19 @@ class PreferenceTool(BaseTool): def getActivePreference(self) : """ returns the current preference for the user. Note that this preference may be read only. """ - enabled_prefs = self._getMostAppropriatePreferences() + enabled_prefs = self._getSortedPreferenceList() if len(enabled_prefs) > 0 : return enabled_prefs[0] - security.declareProtected(Permissions.View, 'getDocumentTemplatesForFolder') - def getDocumentTemplatesForFolder(self, folder) : + security.declareProtected(Permissions.View, 'getDocumentTemplate') + def getDocumentTemplate(self, folder) : """ returns all document templates that are in acceptable Preferences - for the folder """ + based on different criteria such as folder, portal_type, etc. + + XXX This spec still needs to be refined before implementation + """ acceptable_templates = [] - for pref in self._getMostAppropriatePreferences() : + for pref in self._getSortedPreferenceList() : for doc in pref.objectValues() : if hasattr(doc, 'getTemplateDestinationUidList') and \ folder.getUid() in doc.getTemplateDestinationUidList() : @@ -201,9 +210,19 @@ class PreferenceTool(BaseTool): return acceptable_templates security.declareProtected(Permissions.ManagePortal, - 'manage_updateUserGroupsPreferences') - def manage_updateUserGroupsPreferences(self, REQUEST) : - """ action edit Users Groups Preferences from the management sceen """ + 'USELESS_manage_updateUserGroupsPreferences') + def USELESS_manage_updateUserGroupsPreferences(self, REQUEST) : + """ action edit Users Groups Preferences from the + management sceen + + XXX This is not compatible with 1,000,000 preferences + + Also, the type of preference (or, better, the priority) + must be *stored* on the preference itself and + set from the preference itself. + + This API is therefore useless. + """ for k, v in REQUEST.items() : if k.startswith("preference_priority_") : self[k[len('preference_priority_'):]].setPriority(v) -- 2.30.9