def setUp(self): from Products.CMFCore.CatalogTool import CatalogTool from Products.CMFCore.utils import registerToolInterface from Products.CMFUid.interfaces import IUniqueIdHandler from Products.CMFUid.UniqueIdAnnotationTool \ import UniqueIdAnnotationTool from Products.CMFUid.UniqueIdGeneratorTool \ import UniqueIdGeneratorTool SecurityTest.setUp(self) self.app._setObject('dummy', DummyContent(id='dummy')) self.app._setObject('dummy2', DummyContent(id='dummy2')) self.ctool = CatalogTool().__of__(self.app) self.uidhandler = self._makeOne() sm = getSiteManager() sm.registerUtility(self.ctool, ICatalogTool) registerToolInterface('portal_catalog', ICatalogTool) sm.registerUtility(self.uidhandler, IUniqueIdHandler) sm.registerUtility(UniqueIdAnnotationTool(), IUniqueIdAnnotationManagement) sm.registerUtility(UniqueIdGeneratorTool(), IUniqueIdGenerator) sm.registerUtility(provided=IPortalCatalogQueueProcessor, factory=PortalCatalogProcessor) # Make sure we have our indices/columns uid_name = self.uidhandler.UID_ATTRIBUTE_NAME self.ctool.addIndex(uid_name, 'FieldIndex') self.ctool.addColumn(uid_name)
def setUp(self): from Products.CMFUid.interfaces import IUniqueIdAnnotationManagement from Products.CMFCore.utils import registerToolInterface SecurityTest.setUp(self) self.uidannotation = self._makeOne() registerToolInterface('portal_uidhandler', IUniqueIdHandler) sm = getSiteManager() sm.registerUtility(self.uidannotation, IUniqueIdAnnotationManagement) sm.registerUtility(DummyUniqueIdHandlerTool(), IUniqueIdHandler) self.app._setObject('dummy', DummyContent(id='dummy')) self.app._setObject('site', Folder('site')) transaction.savepoint(optimistic=True)
# security.declarePrivate('ZCacheManager_getCache') def ZCacheManager_getCache(self): """ Retrieve a cache object """ cache = getattr(self, '_cache', None) if cache is None: self._cache = CPMCache() cache = self._cache return cache InitializeClass( CachingPolicyManager ) registerToolInterface('caching_policy_manager', ICachingPolicyManager) def handleCachingPolicyManagerEvent(ob, event): """ Event subscriber for (un)registering a CPM as CacheManager """ if not ICachingPolicyManager.providedBy(ob): return if IObjectMovedEvent.providedBy(event): if event.newParent is not None: ids = getVerifiedManagerIds(event.newParent) id = ob.getId() if id not in ids: setattr(event.newParent, ZCM_MANAGERS, ids + (id,))
try: registration.addMember(user_id, password, REQUEST=request) except (AttributeError, ValueError), err: logging.exception(err) IStatusMessage(request).addStatusMessage(err, type="error") return # set additional properties using the user schema adapter schema = getUtility(IUserDataSchemaProvider).getSchema() adapter = getAdapter(portal, schema) adapter.context = mt.getMemberById(user_id) for name in getFieldNamesInOrder(schema): if name in data: setattr(adapter, name, data[name]) notify(UserApprovedEvent(data)) del self._data[key] def reject(self, key): if key not in self._data.keys(): return data = self._data[key] notify(UserRejectedEvent(data)) del self._data[key] InitializeClass(RegistrationApproval) registerToolInterface('wcc_membership_registration_approval', IRegistrationApproval)
def initialize(context): from Products.CMFCore.utils import ToolInit from Products.CMFCore.utils import ContentInit from Products.CMFCore.utils import registerIcon from Products.CMFDefault.permissions import AddPortalContent import DefaultWorkflow import DiscussionTool import Document import factory import Favorite import File import Image import Link import MembershipTool import MetadataTool import NewsItem import Portal import PropertiesTool import RegistrationTool import SkinnedFolder import SyndicationTool # Make sure security is initialized import DiscussionItem import DublinCore import utils contentConstructors = ( Document.addDocument , File.addFile , Image.addImage , Link.addLink , Favorite.addFavorite , NewsItem.addNewsItem , SkinnedFolder.addSkinnedFolder ) tools = ( DiscussionTool.DiscussionTool , MembershipTool.MembershipTool , RegistrationTool.RegistrationTool , PropertiesTool.PropertiesTool , MetadataTool.MetadataTool , SyndicationTool.SyndicationTool ) # Register the ID to interface data for those items that don't have their # own module from Products.CMFCore.utils import registerToolInterface from Products.GenericSetup.interfaces import ISetupTool registerToolInterface('portal_setup', ISetupTool) from Products.MailHost.interfaces import IMailHost registerToolInterface('MailHost', IMailHost) ToolInit( 'CMF Default Tool' , tools=tools , icon='tool.gif' ).initialize( context ) # BBB: register oldstyle constructors ContentInit( 'CMF Default Content' , content_types=() , permission=AddPortalContent , extra_constructors=contentConstructors , visibility=None ).initialize( context ) context.registerClass( Portal.CMFSite , constructors=(factory.addConfiguredSiteForm, factory.addConfiguredSite) , icon='images/portal.gif' ) registerIcon( DefaultWorkflow.DefaultWorkflowDefinition , 'images/workflow.gif' , globals() ) # make registerHelp work with 2 directories help = context.getProductHelp() lastRegistered = help.lastRegistered context.registerHelp(directory='help', clear=1) context.registerHelp(directory='interfaces', clear=1) if help.lastRegistered != lastRegistered: help.lastRegistered = None context.registerHelp(directory='help', clear=1) help.lastRegistered = None context.registerHelp(directory='interfaces', clear=0) context.registerHelpTitle('CMF Default Help')
a1['action'] = a.getActionExpression() a1['condition'] = a.getCondition() a1['appId'] = a.getAppId() a1['description'] = a.getDescription() a1['icon_expr'] = a.getIconExpression() actions.append(a1) # possible_permissions is in OFS.role.RoleManager. pp = self.possible_permissions() return self._actions_form( self, REQUEST, actions=actions, possible_permissions=pp, management_view='Actions', manage_tabs_message=manage_tabs_message, ) @property def site_url(self): """Return the absolute URL to the current site, which is likely not necessarily the portal root. Used by ``portlet_prefs`` to construct the URL to ``@@overview-controlpanel``. """ return getSite().absolute_url() InitializeClass(PloneControlPanel) registerToolInterface('portal_controlpanel', IControlPanel)
, MembershipTool.MembershipTool , RegistrationTool.RegistrationTool , PropertiesTool.PropertiesTool , MetadataTool.MetadataTool , SyndicationTool.SyndicationTool ) # Make the skins available as DirectoryViews. registerDirectory('skins', globals()) registerDirectory('help', globals()) # Register the ID to interface data for those items that don't have their # own module from Products.CMFCore.utils import registerToolInterface from Products.GenericSetup.interfaces import ISetupTool registerToolInterface('portal_setup', ISetupTool) from Products.MailHost.interfaces import IMailHost registerToolInterface('MailHost', IMailHost) def initialize(context): ToolInit( 'CMF Default Tool' , tools=tools , icon='tool.gif' ).initialize( context ) # BBB: register oldstyle constructors ContentInit( 'CMF Default Content' , content_types=() , permission=AddPortalContent , extra_constructors=contentConstructors
"""Remove from catalog. """ url = self.__url(object) self.uncatalog_object(url) security.declarePrivate('reindexObject') def reindexObject(self, object, idxs=[], update_metadata=1, uid=None): """Update catalog after object data has changed. The optional idxs argument is a list of specific indexes to update (all of them by default). The update_metadata flag controls whether the object's metadata record is updated as well. If a non-None uid is passed, it will be used as the catalog uid for the object instead of its physical path. """ if uid is None: uid = self.__url(object) if idxs != []: # Filter out invalid indexes. valid_indexes = self._catalog.indexes.keys() idxs = [i for i in idxs if i in valid_indexes] self.catalog_object(object, uid, idxs, update_metadata) InitializeClass(CatalogTool) registerToolInterface('portal_catalog', ICatalogTool)
settings = registry.forInterface(ISiteSyndicationSettings) return settings.allowed def isSyndicationAllowed(self, obj=None): """ Check whether syndication is enabled for the site. This provides for extending the method to check for whether a particular obj is enabled, allowing for turning on only specific folders for syndication. """ settings = IFeedSettings(obj) return settings.enabled def enableSyndication(self, obj): """ Enable syndication for the obj """ if not _checkPermission(ModifyPortalContent, obj): raise Unauthorized settings = IFeedSettings(obj) settings.enabled = True def disableSyndication(self, obj): if not _checkPermission(ModifyPortalContent, obj): raise Unauthorized settings = IFeedSettings(obj) settings.enabled = False registerToolInterface('portal_syndication', ISyndicationTool)
def findTypeName(self, name, typ, body): """ Perform a lookup over a collection of rules, returning the the name of the Type object corresponding to name/typ/body. Return None if no match found. """ for predicate_id in self.predicate_ids: pred, typeObjectName = self.predicates[predicate_id] if pred(name, typ, body): return typeObjectName return None InitializeClass(ContentTypeRegistry) registerToolInterface('content_type_registry', IContentTypeRegistry) def manage_addRegistry(self, REQUEST=None): """ Add a CTR to self. """ CTRID = ContentTypeRegistry.id reg = ContentTypeRegistry() self._setObject(CTRID, reg) reg = self._getOb(CTRID) if REQUEST is not None: REQUEST['RESPONSE'].redirect(self.absolute_url() + '/manage_main' + '?manage_tabs_message=Registry+added.')
def initialize(context): from Products.CMFCore.utils import ToolInit from Products.CMFCore.utils import ContentInit from Products.CMFCore.utils import registerIcon from Products.CMFDefault.permissions import AddPortalContent import DefaultWorkflow import DiscussionTool import Document import factory import Favorite import File import Image import Link import MembershipTool import MetadataTool import NewsItem import Portal import PropertiesTool import RegistrationTool import SkinnedFolder import SyndicationTool # Make sure security is initialized import DiscussionItem import DublinCore import utils contentConstructors = (Document.addDocument, File.addFile, Image.addImage, Link.addLink, Favorite.addFavorite, NewsItem.addNewsItem, SkinnedFolder.addSkinnedFolder) tools = (DiscussionTool.DiscussionTool, MembershipTool.MembershipTool, RegistrationTool.RegistrationTool, PropertiesTool.PropertiesTool, MetadataTool.MetadataTool, SyndicationTool.SyndicationTool) # Register the ID to interface data for those items that don't have their # own module from Products.CMFCore.utils import registerToolInterface from Products.GenericSetup.interfaces import ISetupTool registerToolInterface('portal_setup', ISetupTool) from Products.MailHost.interfaces import IMailHost registerToolInterface('MailHost', IMailHost) ToolInit('CMF Default Tool', tools=tools, icon='tool.gif').initialize(context) # BBB: register oldstyle constructors ContentInit('CMF Default Content', content_types=(), permission=AddPortalContent, extra_constructors=contentConstructors, visibility=None).initialize(context) context.registerClass(Portal.CMFSite, constructors=(factory.addConfiguredSiteForm, factory.addConfiguredSite), icon='images/portal.gif') registerIcon(DefaultWorkflow.DefaultWorkflowDefinition, 'images/workflow.gif', globals()) # make registerHelp work with 2 directories help = context.getProductHelp() lastRegistered = help.lastRegistered context.registerHelp(directory='help', clear=1) context.registerHelp(directory='interfaces', clear=1) if help.lastRegistered != lastRegistered: help.lastRegistered = None context.registerHelp(directory='help', clear=1) help.lastRegistered = None context.registerHelp(directory='interfaces', clear=0) context.registerHelpTitle('CMF Default Help')
def _makeWorkflowPolicyFactoryKey(factory, id=None, title=None): # The factory should take one argument, id. if id is None: id = getattr(factory, 'id', '') or getattr(factory, 'meta_type', '') if title is None: title = getattr(factory, 'title', '') key = id if title: key = key + ' (%s)' % title return key def addWorkflowPolicyFactory(factory, id=None, title=None): key = _makeWorkflowPolicyFactoryKey(factory, id, title) _workflow_policy_factories[key] = factory def _removeWorkflowPolicyFactory(factory, id=None, title=None): """ Make teardown in unitcase cleaner. """ key = _makeWorkflowPolicyFactoryKey(factory, id, title) try: del _workflow_policy_factories[key] except KeyError: pass InitializeClass(PlacefulWorkflowTool) registerToolInterface('portal_placeful_workflow', IPlacefulWorkflowTool)
@security.protected(AddPortalMember) def isMemberIdAllowed(self, id): '''Returns 1 if the ID is not in use and is not reserved. ''' if len(id) < 1 or id == 'Anonymous User': return 0 if not self._ALLOWED_MEMBER_ID_PATTERN.match(id): return 0 mtool = getUtility(IMembershipTool) if mtool.getMemberById(id) is not None: return 0 return 1 security.declarePublic('afterAdd') def afterAdd(self, member, id, password, properties): '''Called by portal_registration.addMember() after a member has been added successfully.''' pass @security.protected(MailForgottenPassword) def mailPassword(self, forgotten_userid, REQUEST): '''Email a forgotten password to a member. Raises an exception if user ID is not found. ''' raise NotImplementedError InitializeClass(RegistrationTool) registerToolInterface('portal_registration', IRegistrationTool)
def createChangeSet(self, ob1, ob2, id1=None, id2=None): """Returns a ChangeSet object that represents the differences between ob1 and ob2 (ie. ob2 - ob1) .""" # FIXME: Pick a better ID cs = BaseChangeSet('Changes').__of__(self) cs.computeDiff(ob1, ob2, id1=id1, id2=id2) return aq_base(cs) def registerDiffType(klass): """Register a class for computing differences. Instances of the class must implement the IDifference interface.""" CMFDiffTool._difftypes[klass.meta_type] = klass def unregisterDiffType(klass): """Register a class for computing differences. Instances of the class must implement the IDifference interface.""" del CMFDiffTool._difftypes[klass.meta_type] InitializeClass(CMFDiffTool) registerToolInterface('portal_diff', IDiffTool)
</object> </object> """ _REMOVE_IMPORT = """\ <?xml version="1.0"?> <object name="portal_actions"> <action-provider name="portal_actions" remove=""/> <action-provider name="not_existing" remove=""/> <action-provider name="portal_bar" remove=""/> </object> """ class IFoo(Interface): """ Foo interface """ registerToolInterface('portal_foo', IFoo) class IBar(Interface): """ Bar interface """ registerToolInterface('portal_bar', IBar) class DummyTool(OrderedFolder, ActionProviderBase): __implements__ = IActionProvider class DummyUser(Implicit): def getId(self): return 'dummy'
from Products.PluggableAuthService.interfaces.authservice import \ IPluggableAuthService from Products.PluggableAuthService.interfaces.plugins import \ IAuthenticationPlugin from Products.PluggableAuthService.interfaces.plugins import \ IGroupEnumerationPlugin from Products.PluggableAuthService.interfaces.plugins import \ IRoleAssignerPlugin from Products.PluggableAuthService.interfaces.plugins import \ IUserEnumerationPlugin from zope.event import notify import logging logger = logging.getLogger('PlonePAS') registerToolInterface('acl_users', IPluggableAuthService) ################################# # helper functions def _userSetGroups(pas, user_id, groupnames): """method was used at GRUF level, but is used inside this monkies at several places too. We no longer provide it on PAS to clean up patches """ plugins = pas.plugins gtool = getToolByName(pas, "portal_groups")
) return transactions security.declarePublic('undo') def undo(self, object, transaction_info): """ Undo the list of transactions passed in 'transaction_info', first verifying that the current user is allowed to undo them. """ # Belt and suspenders: make sure that the user is actually # allowed to undo the transation(s) in transaction_info. xids = {} # set of allowed transaction IDs allowed = self.listUndoableTransactionsFor( object ) for xid in map( lambda x: x['id'], allowed ): xids[xid] = 1 if type( transaction_info ) == type( '' ): transaction_info = [ transaction_info ] for tinfo in transaction_info: if not xids.get( tinfo, None ): raise AccessControl_Unauthorized object.manage_undo_transactions(transaction_info) InitializeClass(UndoTool) registerToolInterface('portal_undo', IUndoTool)
from OFS.SimpleItem import SimpleItem from Products.CMFCore.utils import registerToolInterface from zope.interface import Interface MetadataTool = SimpleItem class FactoryTool(SimpleItem): ''' Compatibility code for portal_factory ''' def __nonzero__(self): ''' Always evealuate to False ''' return 0 class IFactoryTool(Interface): pass registerToolInterface('portal_factory', IFactoryTool)
try: registration.addMember(user_id, password, REQUEST=request) except (AttributeError, ValueError), err: logging.exception(err) IStatusMessage(request).addStatusMessage(err, type="error") return # set additional properties using the user schema adapter schema = getUtility(IUserDataSchemaProvider).getSchema() adapter = getAdapter(portal, schema) adapter.context = mt.getMemberById(user_id) for name in getFieldNamesInOrder(schema): if name in data: setattr(adapter, name, data[name]) notify(UserApprovedEvent(data)) del self._data[key] def reject(self, key): if key not in self._data.keys(): return data = self._data[key] notify(UserRejectedEvent(data)) del self._data[key] InitializeClass(RegistrationApproval) registerToolInterface('portal_registration_approval', IRegistrationApproval)
security = ClassSecurityInfo() security.declarePrivate('__init__') def __init__(self): """Initialize the generator """ # The previous ``BTrees.Length.Length`` implementation may cause # double unique ids under high load. So for the moment we just use # a simple counter. self._uid_counter = 0 security.declarePrivate('__call__') def __call__(self): """See IUniqueIdGenerator. """ # For sites that have already used CMF 1.5.1 (and older) the # BTrees.Length.Length object has to be migrated to an integer. if isinstance(self._uid_counter, Length): self._uid_counter = self._uid_counter() self._uid_counter += 1 return self._uid_counter security.declarePrivate('convert') def convert(self, uid): """See IUniqueIdGenerator. """ return int(uid) InitializeClass(UniqueIdGeneratorTool) registerToolInterface('portal_uidgenerator', IUniqueIdGenerator)
if test: self.testSkinPath(skinpath) sels[str(skinname)] = skinpath if make_default: self.default_skin = skinname @security.protected(AccessContentsInformation) def getDiff(self, item_one_path, item_two_path, reverse=0): """ Return a diff between one and two. """ if not reverse: item_one = self.unrestrictedTraverse(item_one_path) item_two = self.unrestrictedTraverse(item_two_path) else: item_one = self.unrestrictedTraverse(item_two_path) item_two = self.unrestrictedTraverse(item_one_path) res = unified_diff(item_one.read().splitlines(), item_two.read().splitlines(), item_one_path, item_two_path, '', '', lineterm="") return res InitializeClass(SkinsTool) registerToolInterface('portal_skins', ISkinsTool)
# the user as context. return portal_group.__of__(self).__of__(g) security.declarePrivate('registerGroupData') def registerGroupData(self, g, id): ''' Adds the given member data to the _members dict. This is done as late as possible to avoid side effect transactions and to reduce the necessary number of entries. ''' self._members[id] = aq_base(g) InitializeClass(GroupDataTool) registerToolInterface('portal_groupdata', IGroupDataTool) class GroupData(SimpleItem): implements(IGroupData, IManageCapabilities) security = ClassSecurityInfo() id = None _tool = None def __init__(self, tool, id): self.id = id # Make a temporary reference to the tool. # The reference will be removed by notifyModified().
{ 'id': 'remove_on_clone', 'type': 'boolean', 'mode': 'w', 'label': 'Remove the objects unique id on clone (CAUTION !!!)' }, { 'id': 'assign_on_add', 'type': 'boolean', 'mode': 'w', 'label': "Assign a unique ID when an object is added" }, { 'id': 'assign_on_clone', 'type': 'boolean', 'mode': 'w', 'label': "Assign a unique ID when an object is cloned" }, ) security.declarePrivate('__call__') def __call__(self, obj, id): """See IUniqueIdAnnotationManagement. """ return UniqueIdAnnotation(obj, id) InitializeClass(UniqueIdAnnotationTool) registerToolInterface('portal_uidannotation', IUniqueIdAnnotationManagement)
self.portal_workflow.updateRoleMappings() self._needUpdateRole = 0 except (ConflictError, KeyboardInterrupt): raise except: logger.error("Exception was thrown while updating " "role mappings", exc_info=True) if not swallow_errors: raise logger.info("Your Plone instance is now up-to-date.") if dry_run: logger.info("Dry run selected, transaction aborted") transaction.abort() return stream.getvalue() finally: logger.removeHandler(handler) gslogger.removeHandler(handler) upgrade = postonly(upgrade) def registerUpgradePath(oldversion, newversion, function): """ Basic register func """ pass InitializeClass(MigrationTool) registerToolInterface('portal_migration', IMigrationTool)
def __init__(self): """Initialize the generator """ # The previous ``BTrees.Length.Length`` implementation may cause # double unique ids under high load. So for the moment we just use # a simple counter. self._uid_counter = 0 security.declarePrivate('__call__') def __call__(self): """See IUniqueIdGenerator. """ # For sites that have already used CMF 1.5.1 (and older) the # BTrees.Length.Length object has to be migrated to an integer. if isinstance(self._uid_counter, Length): self._uid_counter = self._uid_counter() self._uid_counter += 1 return self._uid_counter security.declarePrivate('convert') def convert(self, uid): """See IUniqueIdGenerator. """ return int(uid) InitializeClass(UniqueIdGeneratorTool) registerToolInterface('portal_uidgenerator', IUniqueIdGenerator)
id = 'portal_uidannotation' alternative_id = "portal_standard_uidannotation" meta_type = 'Unique Id Annotation Tool' security = ClassSecurityInfo() remove_on_add = True remove_on_clone = True assign_on_add = False assign_on_clone = False _properties = ( {'id': 'remove_on_add', 'type': 'boolean', 'mode': 'w', 'label': "Remove the objects unique id on add (and import)"}, {'id': 'remove_on_clone', 'type': 'boolean', 'mode': 'w', 'label': 'Remove the objects unique id on clone (CAUTION !!!)'}, {'id': 'assign_on_add', 'type': 'boolean', 'mode': 'w', 'label': "Assign a unique ID when an object is added"}, {'id': 'assign_on_clone', 'type': 'boolean', 'mode': 'w', 'label': "Assign a unique ID when an object is cloned"}, ) security.declarePrivate('__call__') def __call__(self, obj, id): """See IUniqueIdAnnotationManagement. """ return UniqueIdAnnotation(obj, id) InitializeClass(UniqueIdAnnotationTool) registerToolInterface('portal_uidannotation', IUniqueIdAnnotationManagement)
""" if id is None: member = self.getAuthenticatedMember() if not hasattr(member, 'getMemberId'): return None id = member.getMemberId() members = self.getMembersFolder() if members: try: folder = members._getOb(id) if verifyPermission and not _checkPermission(View, folder): # Don't return the folder if the user can't get to it. return None return folder except (AttributeError, TypeError, KeyError): pass return None def getHomeUrl(self, id=None, verifyPermission=0): """ Return the URL to a member's home folder, or None. """ home = self.getHomeFolder(id, verifyPermission) if home is not None: return home.absolute_url() else: return None InitializeClass(MembershipTool) registerToolInterface('portal_membership', IMembershipTool)
security.declareProtected(ManagePortal, 'upgradeProduct') def upgradeProduct(self, pid): profile = self.getInstallProfile(pid) if profile is None: # No upgrade profiles return self.reinstallProducts(products=[pid]) profile_id = profile['id'] setup = getToolByName(self, 'portal_setup') upgrades = setup.listUpgrades(profile_id) for upgrade in upgrades: # An upgrade may be a single step (for a bare upgradeStep) # or a list of steps (for upgradeSteps containing upgradeStep # directives). if not type(upgrade) is list: upgrade = [upgrade] for upgradestep in upgrade: step = upgradestep['step'] step.doStep(setup) version = str(profile['version']) if version == 'latest': version = self.getLatestUpgradeStep(profile_id) setup.setLastVersionForProfile(profile_id, version) QuickInstallerTool.__doc__ = BaseTool.__doc__ InitializeClass(QuickInstallerTool) registerToolInterface('portal_quickinstaller', IQuickInstallerTool)
""" Get boolean indicating whether discussion is allowed for content. """ if hasattr(aq_base(content), 'allow_discussion'): return bool(content.allow_discussion) if IDynamicType.providedBy(content): # Grabbing type information objects only works for dynamic types typeInfo = content.getTypeInfo() if typeInfo: return bool(typeInfo.allowDiscussion()) return False # # Utility methods # security.declarePrivate('_createDiscussionFor') def _createDiscussionFor(self, content): """ Create DiscussionItemContainer for content, if allowed. """ if not self.isDiscussionAllowedFor(content): raise DiscussionNotAllowed content.talkback = DiscussionItemContainer() return content.talkback InitializeClass(DiscussionTool) registerToolInterface('portal_discussion', IDiscussionTool)
if portal_obj is None: # fallback for bootstrap portal_obj = aq_parent(aq_inner(self)) return portal_obj.__of__(request_container) security.declarePublic('getRelativeContentPath') def getRelativeContentPath(self, content): """ Get the path for an object, relative to the portal root. """ portal_path_length = len( self.getPortalObject().getPhysicalPath() ) content_path = content.getPhysicalPath() return content_path[portal_path_length:] security.declarePublic('getRelativeContentURL') def getRelativeContentURL(self, content): """ Get the URL for an object, relative to the portal root. """ return '/'.join( self.getRelativeContentPath(content) ) security.declarePublic('getRelativeUrl') getRelativeUrl = getRelativeContentURL security.declarePublic('getPortalPath') def getPortalPath(self): """ Get the portal object's URL without the server URL component. """ return '/'.join( self.getPortalObject().getPhysicalPath() ) InitializeClass(URLTool) registerToolInterface('portal_url', IURLTool)
""" self._members[id] = aq_base(m) @security.private def deleteMemberData(self, member_id): """ Delete member data of specified member. """ members = self._members if member_id in members: del members[member_id] return 1 else: return 0 InitializeClass(MemberDataTool) registerToolInterface('portal_memberdata', IMemberDataTool) class MemberData(Persistent): def __init__(self, id): self.id = id @implementer(IMember) class MemberAdapter(object): """Member data adapter. """ adapts(IUser, IMemberDataTool)
setter( policy.defaultValue() ) elif policy.isRequired(): raise MetadataError, \ 'Metadata element %s is required.' % element # TODO: Call initial_values_hook, if present security.declareProtected(View, 'validateMetadata') def validateMetadata( self, content ): """ See IMetadataTool. """ for schema_id, schema in self.listSchemas(): for element, policy in schema.listPolicies( content.getPortalTypeName()): value = getattr( content, element )() if not value and policy.isRequired(): raise MetadataError, \ 'Metadata element %s is required.' % element if value and policy.enforceVocabulary(): values = policy.isMultiValued() and value or [ value ] for value in values: if not value in policy.allowedVocabulary(): raise MetadataError, \ 'Value %s is not in allowed vocabulary for ' \ 'metadata element %s.' % ( value, element ) InitializeClass( MetadataTool ) registerToolInterface('portal_metadata', IMetadataTool)
if not IImageContent.isImplementedBy(obj): continue try: state = obj._p_changed except (ConflictError, KeyboardInterrupt): raise except: state = 0 field = obj.getField('image') if field is not None: print >> out, 'Updating %s' % obj.absolute_url(1) field.removeScales(obj) field.createScales(obj) if state is None: obj._p_deactivate() print >> out, "Updated AT Image scales" return out.getvalue() security.declareProtected(ManagePortal, 'listContentTypes') def listContentTypes(self): """List all content types. Used for image/folder_types property. """ ttool = getToolByName(self, 'portal_types') return ttool.listContentTypes() InitializeClass(ATCTTool) registerToolInterface('portal_atct', IATCTTool)
if REQUEST: REQUEST.RESPONSE.redirect('%s/manage_keys?manage_tabs_message=%s' % (self.absolute_url(), 'New+key+created.')) security.declareProtected(ManagePortal, 'manage_clearAndRegenerate') def manage_clearAndRegenerate(self, REQUEST=None): """ Clear all existing keys and create a new keyset. """ self.crypter.clearKeys() if REQUEST: REQUEST.RESPONSE.redirect('%s/manage_keys?manage_tabs_message=%s' % (self.absolute_url(), 'All+keys+cleared.')) security.declareProtected(ManagePortal, 'manage_clearLogs') def manage_clearLogs(self, REQUEST=None): """ create a new key for cryptography """ self.crypter.clearLogs() if REQUEST: REQUEST.RESPONSE.redirect('%s/manage_keys?manage_tabs_message=%s' % (self.absolute_url(), 'All+logs+removed.')) InitializeClass(PloneCryptoTool) registerToolInterface('leocornus_crypto', IPloneCryptoTool)
return when.HTML4() syInfo = getattr(obj, 'syndication_information', None) if syInfo is not None: when = syInfo.syUpdateBase return when.HTML4() else: return 'Syndication is not Allowed' def getMaxItems(self, obj=None): """ Return the max_items to be displayed in the syndication """ if not self.isSiteSyndicationAllowed(): raise 'Syndication is not Allowed' if obj is None: return self.max_items syInfo = getattr(obj, 'syndication_information', None) if syInfo is not None: return syInfo.max_items else: return 'Syndication is not Allowed' InitializeClass(SyndicationTool) registerToolInterface('portal_syndication', ISyndicationTool)
actions = list(oldstyle_actions) if object is None and info is not None: object = info.object if object is not None: type_info = self.getTypeInfo(object) if type_info is not None: actions.extend(type_info.listActions(info, object)) add_actions = [ti for ti in self.objectValues() if IAction.providedBy(ti)] actions.extend(add_actions) return actions @security.protected(ManagePortal) def listMethodAliasKeys(self): """ List all defined method alias names. """ _dict = {} for ti in self.listTypeInfo(): aliases = ti.getMethodAliases() for k in aliases.keys(): _dict[k] = 1 rval = sorted(_dict.keys()) return rval InitializeClass(TypesTool) registerToolInterface('portal_types', ITypesTool)
''' b = getattr(g, 'aq_base', None) if b is None: # u isn't wrapped at all. Wrap it in self.acl_users. b = g g = g.__of__(self.acl_users) if (b is nobody and not wrap_anon) or hasattr(b, 'getMemberId'): # This user is either not recognized by acl_users or it is # already registered with something that implements the # member data tool at least partially. return g parent = aq_parent(aq_inner(self)) base = getattr(parent, 'aq_base', None) if hasattr(base, 'portal_groupdata'): # Get portal_groupdata to do the wrapping. gd = getToolByName(parent, 'portal_groupdata') try: portal_group = gd.wrapGroup(g) return portal_group except ConflictError: raise except: logger.exception('Error during wrapGroup') # Failed. return g InitializeClass(GroupsTool) registerToolInterface('portal_groups', igroup.IGroupTool)
setter(policy.defaultValue()) elif policy.isRequired(): raise MetadataError('Metadata element %s is required.' % element) # TODO: Call initial_values_hook, if present security.declareProtected(View, 'validateMetadata') def validateMetadata(self, content): """ See IMetadataTool. """ for _schema_id, schema in self.listSchemas(): for element, policy in schema.listPolicies( content.getPortalTypeName()): value = getattr(content, element)() if not value and policy.isRequired(): raise MetadataError('Metadata element %s is required.' % element) if value and policy.enforceVocabulary(): values = policy.isMultiValued() and value or [value] for value in values: if not value in policy.allowedVocabulary(): raise MetadataError( 'Value %s is not in allowed vocabulary for ' 'metadata element %s.' % (value, element)) InitializeClass(MetadataTool) registerToolInterface('portal_metadata', IMetadataTool)
b = getattr(g, 'aq_base', None) if b is None: # u isn't wrapped at all. Wrap it in self.acl_users. b = g g = g.__of__(self.acl_users) if (b is nobody and not wrap_anon) or hasattr(b, 'getMemberId'): # This user is either not recognized by acl_users or it is # already registered with something that implements the # member data tool at least partially. return g parent = self.aq_inner.aq_parent base = getattr(parent, 'aq_base', None) if hasattr(base, 'portal_groupdata'): # Get portal_groupdata to do the wrapping. gd = getToolByName(parent, 'portal_groupdata') try: #log("wrapping group %s" % g) portal_group = gd.wrapGroup(g) return portal_group except ConflictError: raise except: logger.exception('Error during wrapGroup') # Failed. return g InitializeClass(GroupsTool) registerToolInterface('portal_groups', igroup.IGroupTool)
# @security.private def ZCacheManager_getCache(self): """ Retrieve a cache object """ cache = getattr(self, '_cache', None) if cache is None: self._cache = CPMCache() cache = self._cache return cache InitializeClass(CachingPolicyManager) registerToolInterface('caching_policy_manager', ICachingPolicyManager) def handleCachingPolicyManagerEvent(ob, event): """ Event subscriber for (un)registering a CPM as CacheManager """ if not ICachingPolicyManager.providedBy(ob): return if IObjectMovedEvent.providedBy(event): if event.newParent is not None: ids = getVerifiedManagerIds(event.newParent) id = ob.getId() if id not in ids: setattr(event.newParent, ZCM_MANAGERS, ids + (id, ))
pass class ITinyMCE(Interface): pass class ICalendarTool(Interface): pass class IActionIconsTool(Interface): pass registerToolInterface('portal_actionicons', IActionIconsTool) class ActionIcon(SimpleItem): _title = None _category = 'object' _action_id = 'view' _icon_expr_text = 'document_icon' def __init__(self, category, action_id, icon_expr_text='', title=None): self._category = category self._action_id = action_id self._icon_expr_text = icon_expr_text self._title = title
# Include actions from specific tools. for provider_name in self.listActionProviders(): provider = getToolByName(self, provider_name) if IActionProvider.providedBy(provider): actions.extend(provider.listActionInfos(object=object)) # Include actions from object. if object is not None: if IActionProvider.providedBy(object): actions.extend(object.listActionInfos(object=object)) # Reorganize the actions by category. filtered_actions = { 'user': [], 'folder': [], 'object': [], 'global': [], 'workflow': [] } for action in actions: catlist = filtered_actions.setdefault(action['category'], []) catlist.append(action) return filtered_actions InitializeClass(ActionsTool) registerToolInterface('portal_actions', IActionsTool)
# Delete members' home folders including all content items. if delete_memberareas: for member_id in member_ids: self.deleteMemberArea(member_id) # Delete members' local roles. if delete_localroles: self.deleteLocalRoles(getUtility(ISiteRoot), member_ids, reindex=1, recursive=1) return tuple(member_ids) security.declarePublic('getHomeFolder') def getHomeFolder(self, id=None, verifyPermission=0): """Returns a member's home folder object or None. Set verifyPermission to 1 to return None when the user doesn't have the View permission on the folder. """ return None security.declarePublic('getHomeUrl') def getHomeUrl(self, id=None, verifyPermission=0): """Returns the URL to a member's home folder or None. Set verifyPermission to 1 to return None when the user doesn't have the View permission on the folder. """ return None InitializeClass(MembershipTool) registerToolInterface('portal_membership', IMembershipTool)
icon_path, binary=0, globs=None, REQUEST=None): """Edit a mime type by name """ mt = self.lookup(name)[0] self.unregister(mt) mt.edit(new_name, mimetypes, extensions, icon_path=icon_path, binary=binary, globs=globs) self.register(mt) if REQUEST is not None: REQUEST['RESPONSE'].redirect(self.absolute_url() + '/manage_main') InitializeClass(MimeTypesRegistry) registerToolInterface('mimetypes_registry', IMimetypesRegistryTool) def split(name): """ split a mime type in a (major / minor) 2-uple """ try: major, minor = name.split('/', 1) except: raise MimeTypeException('Malformed MIME type (%s)' % name) return major, minor
tool.setLanguageCookie(langs[0], noredir=True) self.default_language = langs[-1] self.language = langs[0] self.language_list= langs[1:-1] class PrefsForPTS: """A preference to hook into PTS.""" def __init__(self, context): self._env = context self.languages = [] binding = context.get('LANGUAGE_TOOL') if not isinstance(binding, LanguageBinding): return None self.pref = binding.getLanguageBindings() self.languages = [self.pref[0]] + self.pref[2] + [self.pref[1]] return None def getPreferredLanguages(self): """Returns the list of the bound languages.""" return self.languages if _hasPTS: registerLangPrefsMethod({'klass':PrefsForPTS, 'priority':100 }) InitializeClass(LanguageTool) registerToolInterface('portal_languages', ILanguageTool)
security.declarePrivate('unrestrictedGetBrain') def unrestrictedGetBrain(self, uid): """See IUniqueIdUnrestrictedQuery. """ return self._getBrain(uid, self.unrestrictedQueryBrain) security.declarePrivate('unrestrictedGetObject') def unrestrictedGetObject(self, uid): """See IUniqueIdUnrestrictedQuery. """ return self.unrestrictedGetBrain(uid).getObject() security.declarePrivate('unrestrictedQueryObject') def unrestrictedQueryObject(self, uid, default=None): """See IUniqueIdUnrestrictedQuery. """ try: return self.unrestrictedGetObject(uid) except UniqueIdError: return default security.declareProtected(ManagePortal, 'manage_queryObject') manage_queryObject = PageTemplateFile('queryUID.pt', _wwwdir) InitializeClass(UniqueIdHandlerTool) registerToolInterface('portal_uidhandler', IUniqueIdHandler)
security.declarePublic( 'isDiscussionAllowedFor' ) def isDiscussionAllowedFor( self, content ): """ Get boolean indicating whether discussion is allowed for content. """ if hasattr( aq_base(content), 'allow_discussion' ): return bool(content.allow_discussion) if IDynamicType.providedBy(content): # Grabbing type information objects only works for dynamic types typeInfo = content.getTypeInfo() if typeInfo: return bool( typeInfo.allowDiscussion() ) return False # # Utility methods # security.declarePrivate( '_createDiscussionFor' ) def _createDiscussionFor( self, content ): """ Create DiscussionItemContainer for content, if allowed. """ if not self.isDiscussionAllowedFor( content ): raise DiscussionNotAllowed content.talkback = DiscussionItemContainer() return content.talkback InitializeClass( DiscussionTool ) registerToolInterface('portal_discussion', IDiscussionTool)
security.declarePublic('createChangeSet') def createChangeSet(self, ob1, ob2, id1=None, id2=None): """Returns a ChangeSet object that represents the differences between ob1 and ob2 (ie. ob2 - ob1) .""" # FIXME: Pick a better ID cs = BaseChangeSet('Changes').__of__(self) cs.computeDiff(ob1, ob2, id1=id1, id2=id2) return aq_base(cs) def registerDiffType(klass): """Register a class for computing differences. Instances of the class must implement the IDifference interface.""" CMFDiffTool._difftypes[klass.meta_type] = klass def unregisterDiffType(klass): """Register a class for computing differences. Instances of the class must implement the IDifference interface.""" del CMFDiffTool._difftypes[klass.meta_type] InitializeClass(CMFDiffTool) registerToolInterface('portal_diff', IDiffTool)
) # # ZMI methods # security.declareProtected(ManagePortal, 'manage_overview') manage_overview = DTMLFile( 'explainPropertiesTool', _dtmldir ) # # 'portal_properties' interface methods # security.declareProtected(ManagePortal, 'editProperties') def editProperties(self, props): '''Change portal settings''' site = getUtility(ISiteRoot) site.manage_changeProperties(props) getUtility(IMailHost).smtp_host = props['smtp_server'] if hasattr(self, 'propertysheets'): ps = self.propertysheets if hasattr(ps, 'props'): ps.props.manage_changeProperties(props) def title(self): return getUtility(ISiteRoot).title def smtp_server(self): return getUtility(IMailHost).smtp_host InitializeClass(PropertiesTool) registerToolInterface('portal_properties', IPropertiesTool)
""" if not self._default_cataloging: return if hasattr(aq_base(ob), 'reindexObject'): # XXX We only need the keys here, no need to compute values. mapping = self.getCatalogVariablesFor(ob) or {} vars = mapping.keys() ob.reindexObject(idxs=vars) # Reindex security of subobjects. if hasattr(aq_base(ob), 'reindexObjectSecurity'): ob.reindexObjectSecurity() InitializeClass(WorkflowTool) registerToolInterface('portal_workflow', IWorkflowTool) class DefaultWorkflowStatus(object): implements(IWorkflowStatus) adapts(IWorkflowAware, IWorkflowDefinition) def __init__(self, context, workflow): self.context = aq_base(context) self.wf_id = workflow.getId() def get(self): history = getattr(self.context, 'workflow_history', {}) wfh = history.get(self.wf_id) if wfh: return wfh[-1]
year = int(year) begin = DateTime('%d/%02d/%02d 00:00:00' % (year, month, day)) end = DateTime('%d/%02d/%02d 23:59:59' % (year, month, day)) return (begin, end) security.declarePublic('getNextEvent') def getNextEvent(self, start_date=None): """ Get the next event that starts after start_date start_date is expected to be a DateTime instance """ if start_date is None: start_date = DateTime() ctool = getUtility(ICatalogTool) query = ctool( portal_type=self.getCalendarTypes(), review_state=self.getCalendarStates(), start={'query': start_date, 'range': 'min'}, sort_on='start') results = unique_results(query) if results: results.sort(sort_by_date) return results[0] InitializeClass(CalendarTool) registerToolInterface('portal_calendar', ICalendarTool)
raise except: logger.error( "Exception was thrown while updating " "role mappings", exc_info=True) if not swallow_errors: raise logger.info("Your Plone instance is now up-to-date.") if dry_run: logger.info("Dry run selected, transaction aborted") transaction.abort() return stream.getvalue() finally: logger.removeHandler(handler) gslogger.removeHandler(handler) upgrade = postonly(upgrade) def registerUpgradePath(oldversion, newversion, function): """ Basic register func """ pass InitializeClass(MigrationTool) registerToolInterface('portal_migration', IMigrationTool)
new_filelist = [x.getId() for x in result] old_filelist = hassession and request.SESSION.get('ploneboard_uploads', []) or [] for removed in [f for f in old_filelist if f not in new_filelist]: del request.SESSION[f] if hassession or new_filelist: request.SESSION['ploneboard_uploads'] = new_filelist return result security.declareProtected(View, 'clearUploadedFiles') def clearUploadedFiles(self): # Get previously uploaded files with a reference in request # + files uploaded in this request # XXX Add variable to keep track of filenames? request = self.REQUEST sdm = getToolByName(self, 'session_data_manager', None) if sdm is not None: if sdm.hasSessionData(): old_filelist = request.SESSION.get('ploneboard_uploads', None) if old_filelist is not None: for file in old_filelist: if request.SESSION.has_key(file): del request.SESSION[file] del request.SESSION['ploneboard_uploads'] Globals.InitializeClass(PloneboardTool) registerToolInterface(PLONEBOARD_TOOL, IPloneboardTool)
# -*- coding: utf-8 -*- from plone.i18n.interfaces import ILanguageUtility from Products.CMFCore.utils import registerToolInterface registerToolInterface('portal_languages', ILanguageUtility)
"""Set the max workflow chain length""" safeEditProperty(self, 'max_chain_length', max_chain_length, data_type='int') _workflow_policy_factories = {} def _makeWorkflowPolicyFactoryKey(factory, id=None, title=None): # The factory should take one argument, id. if id is None: id = getattr(factory, 'id', '') or getattr(factory, 'meta_type', '') if title is None: title = getattr(factory, 'title', '') key = id if title: key = key + ' (%s)' % title return key def addWorkflowPolicyFactory(factory, id=None, title=None): key = _makeWorkflowPolicyFactoryKey( factory, id, title ) _workflow_policy_factories[key] = factory def _removeWorkflowPolicyFactory( factory, id=None, title=None ): """ Make teardown in unitcase cleaner. """ key = _makeWorkflowPolicyFactoryKey( factory, id, title ) try: del _workflow_policy_factories[key] except KeyError: pass InitializeClass(PlacefulWorkflowTool) registerToolInterface('portal_placeful_workflow', IPlacefulWorkflowTool)
security.declarePublic('undo') def undo(self, object, transaction_info): """ Undo the list of transactions passed in 'transaction_info', first verifying that the current user is allowed to undo them. """ # Belt and suspenders: make sure that the user is actually # allowed to undo the transation(s) in transaction_info. xids = {} # set of allowed transaction IDs allowed = self.listUndoableTransactionsFor(object) for xid in map(lambda x: x['id'], allowed): xids[xid] = 1 if type(transaction_info) == type(''): transaction_info = [transaction_info] for tinfo in transaction_info: if not xids.get(tinfo, None): raise AccessControl_Unauthorized object.manage_undo_transactions(transaction_info) InitializeClass(UndoTool) registerToolInterface('portal_undo', IUndoTool)