if 'eionet-nfp-cc-' in group[0]:
return group[0].replace('eionet-nfp-cc-', '')
if 'eionet-nfp-mc-' in group[0]:
return group[0].replace('eionet-nfp-mc-', '')
if 'eionet-nfp-oc-' in group[0]:
return group[0].replace('eionet-nfp-oc-', '')
def get_ldap_user_groups(self, user_id):
""" """
agent = self._get_ldap_agent(bind=True, secondary=True)
ldap_roles = sorted(
agent.member_roles_info('user', user_id, ('description', )))
return ldap_roles
InitializeClass(OrganisationsEditor)
id_re = re.compile(r'^[a-z]{2}_[a-z]+$')
phone_re = re.compile(r'^\+[\d ]+$')
postal_code_re = re.compile(r'^[a-zA-Z]{2}[a-zA-Z0-9\- ]+$')
_phone_help = ('Telephone numbers must be in international notation (they '
'must start with a "+" followed by digits which may be '
'separated using spaces).')
VALIDATION_ERRORS = {
'id': ('Invalid organisation ID. Mandatory format xx_yyyy - '
'It must start with a two letter lowercase country code, '
'followed by an underscore ("_") and then any number '
'of lowercase a-z letters (no accented characters - unlike the '
'title, which can contain any characters).'),
'name':
"""
Time column for DataGridField.
"""
__author__ = "T. Kim Nguyen <*****@*****.**>"
__docformat__ = 'plaintext'
# Zope imports
from AccessControl import ClassSecurityInfo
from App.class_init import InitializeClass
from Products.DataGridField.Column import Column
class TimeColumn(Column):
""" Time column """
security = ClassSecurityInfo()
security.declarePublic('getMacro')
def getMacro(self):
""" Return macro used to render this column in view/edit """
return "datagrid_time_cell"
# Initializes class security
InitializeClass(TimeColumn)
"""See IUniqueIdAnnotation.
"""
return self._uid
def getId(self):
"""See IUniqueIdAnnotation.
"""
return self.id
def setUid(self, uid):
"""See IUniqueIdAnnotation.
"""
self._uid = uid
InitializeClass(UniqueIdAnnotation)
def handleUidAnnotationEvent(ob, event):
""" Event subscriber for (IContentish, IObjectEvent) events
"""
if IObjectAddedEvent.providedBy(event):
if event.newParent is not None:
anno_tool = queryUtility(IUniqueIdAnnotationManagement)
uid_handler = getToolByName(ob, 'portal_uidhandler', None)
if anno_tool is not None:
remove_on_add = anno_tool.getProperty('remove_on_add', False)
remove_on_clone = anno_tool.getProperty(
'remove_on_clone', False)
assign_on_add = anno_tool.getProperty('assign_on_add', False)
ctool = queryUtility(ICatalogTool)
if ctool is not None:
results = self.getReplyResults()
rids = [x.data_record_id_ for x in results]
objects = list(map(ctool.getobject, rids))
return objects
def quotedContents(self):
"""
Return this object's contents in a form suitable for inclusion
as a quote in a response.
"""
return ""
InitializeClass(OldDiscussable)
@implementer(IOldstyleDiscussionTool)
class DiscussionTool(UniqueObject, SimpleItem, ActionProviderBase):
id = 'portal_discussion'
meta_type = 'Oldstyle CMF Discussion Tool'
# This tool is used to find the discussion for a given content object.
security = ClassSecurityInfo()
manage_options = (
({'label': 'Overview', 'action': 'manage_overview'},) +
SimpleItem.manage_options)
function = v.function()
info = {
'id': k,
'meta_type': v.meta_type,
'module': module,
'function': function,
'filename': filename
}
result.append(info)
return result
InitializeClass(WorkflowDefinitionConfigurator)
def _getScriptFilename(workflow_id, script_id, meta_type):
""" Return the name of the file which holds the script.
"""
wf_dir = workflow_id.replace(' ', '_')
suffix = _METATYPE_SUFFIXES.get(meta_type, None)
if suffix is None:
return ''
return 'workflows/%s/scripts/%s.%s' % (wf_dir, script_id, suffix)
def _extractCreationGuard(root, encoding=None):
if setCookieEverywhere and useCookie and langs[0] != langsCookie:
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)
"""
Return the Type of Criterion this object is. This
method can be overriden in subclasses, or those
concrete subclasses must define the 'meta_type'
attribute.
"""
return self.meta_type
security.declareProtected(AccessContentsInformation, 'Field')
def Field(self):
"""
Return the field that this criterion searches on. The
concrete subclasses can override this method, or have
the 'field' attribute.
"""
return self.field
security.declareProtected(AccessContentsInformation, 'Description')
def Description(self):
"""
Return a brief but helpful description of the Criterion type,
preferably based on the classes __doc__ string.
"""
lines = [line.strip() for line in self.__doc__.splitlines()]
return ' '.join([line for line in lines if line])
InitializeClass(AbstractCriterion)
m = import_from_name(self.module)
reload(m)
self._tr_init()
def preprocess_param(self, kwargs):
""" preprocess param fetched from an http post to handle
optional dictionary
"""
for param in self.get_parameters():
if self.get_parameter_infos(param)[0] == 'dict':
try:
keys = kwargs[param + '_key']
del kwargs[param + '_key']
except:
keys = ()
try:
values = kwargs[param + '_value']
del kwargs[param + '_value']
except:
values = ()
kwargs[param] = dict = {}
for key, value in zip(keys, values):
key = key.strip()
if key:
value = value.strip()
if value:
dict[key] = value
InitializeClass(Transform)
response.setStatus('200')
response.setBody(self.body)
# Keep HTTPResponse.exception() from further writing on the
# response body, without using HTTPResponse.write()
response._locked_status = True
response.setBody = self._setBody # Keep response.exception
return True
# Methods to override on response
def _setBody(self, body, *args, **kw):
pass
InitializeClass(InlineAuthHelper)
BASIC_LOGIN_FORM = """<html>
<head>
<title> Login Form </title>
</head>
<body>
<h3> Please log in </h3>
<form method="post">
<table cellpadding="2">
<tr>
<td><b>Login:</b> </td>
<td><input type="text" name="__ac_name" size="30" /></td>
plugins = pas_instance._getOb( 'plugins' )
active_interfaces = []
for iface_name in interfaces:
active_interfaces.append( plugins._getInterfaceFromName(
iface_name ) )
pt = plugins._plugin_types
id = self.getId()
for type in pt:
ids = plugins.listPluginIds( type )
if id not in ids and type in active_interfaces:
plugins.activatePlugin( type, id ) # turn us on
elif id in ids and type not in active_interfaces:
plugins.deactivatePlugin( type, id ) # turn us off
if RESPONSE is not None:
RESPONSE.redirect('%s/manage_workspace'
'?manage_tabs_message='
'Interface+activations+updated.'
% self.absolute_url())
security.declarePrivate( '_getPAS' )
def _getPAS( self ):
""" Canonical way to get at the PAS instance from a plugin """
return aq_parent( aq_inner( self ) )
InitializeClass(BasePlugin)
def _checkAvailable(self, ec):
""" Check if the action is available in the current context.
"""
return ec.contexts['folder'].getTypeInfo().allowType(self.getId())
def _checkAllowed(self, ec):
""" Check if the action is allowed in the current context.
"""
container = ec.contexts['folder']
if not _checkPermission(AddPortalContent, container):
return False
return self.isConstructionAllowed(container)
InitializeClass(TypeInformation)
class FactoryTypeInformation(TypeInformation):
""" Portal content factory.
"""
implements(ITypeInformation)
security = ClassSecurityInfo()
_properties = (TypeInformation._basic_properties +
({
'id': 'product',
'type': 'string',
'mode': 'w',
security.declarePrivate('listActions')
def listActions(self, info=None, object=None):
""" Returns a list of actions to be displayed to the user.
o Invoked by the portal_actions tool.
o Allows workflows to include actions to be displayed in the
actions box.
o Object actions are supplied by workflows that apply to the object.
"""
if object is not None or info is None:
info = self._getOAI(object)
chain = self.getChainFor(info.object)
actions = []
for wf_id in chain:
wf = self.getWorkflowById(wf_id)
if wf is not None:
a = wf.listObjectActions(info)
if a is not None:
actions.extend(a)
return actions
WorkflowTool.__doc__ = BaseTool.__doc__
InitializeClass(WorkflowTool)
@implementer(IExtractionPlugin)
class CookieCrumblingPlugin(Folder, BasePlugin):
"""Multi-plugin for injecting HTTP Basic Authentication
credentials from form credentials.
"""
meta_type = 'Cookie Crumbling Plugin'
security = ClassSecurityInfo()
def __init__(self, id, title=None):
self._setId(id)
self.title = title
def _getCC(self):
return getattr(aq_base(self), CC_ID, None)
@security.private
def extractCredentials(self, request):
""" Extract basic auth credentials from 'request'.
"""
try:
self._getCC().modifyRequest(request, request.RESPONSE)
except Exception as e:
logger.error("PlonePAS error: %s", e, exc_info=1)
return {}
InitializeClass(CookieCrumblingPlugin)
event.notify(UserLoggedInEvent(user))
# Expire the clipboard
if self.REQUEST.get('__cp', None) is not None:
self.REQUEST.RESPONSE.expireCookie('__cp', path='/')
# Create member area
mtool.createMemberArea(member_id=login)
def _signature_context(self, purge=False):
context = getattr(self, '_v_signature_context', None)
if purge or context is None:
context = SignatureContext()
key = Key.loadMemory(self.signing_cert, KeyDataFormatCertPem, None)
context.add_key(key, self.issuer_id)
setattr(self, '_v_signature_context', context)
return context
def _extract_attributes(self, assertion):
attrs = {}
for astmt in assertion.AttributeStatement:
for attr in astmt.Attribute:
key = attr.Name.encode('utf8')
value = xs_convert_from_xml(attr.AttributeValue,
ty='string').encode('utf8')
attrs[key] = value
return attrs
InitializeClass(Saml2WebSSOPlugin)
def may_accept_items(self):
if self.context.query_state(
) in self.cfg.getMeetingStatesAcceptingItemsForMeetingManagers():
return True
security.declarePublic('may_change_items_order')
def may_change_items_order(self):
res = True
if not _checkPermission(ModifyPortalContent, self.context) or \
self.context.query_state() in Meeting.MEETINGCLOSEDSTATES:
res = False
return res
InitializeClass(MeetingWorkflowConditions)
class MeetingWorkflowActions(object):
'''Adapts a meeting to interface IMeetingWorkflowActions.'''
implements(IMeetingWorkflowActions)
security = ClassSecurityInfo()
def __init__(self, meeting):
self.context = meeting
self.tool = api.portal.get_tool('portal_plonemeeting')
self.cfg = self.tool.getMeetingConfig(self.context)
security.declarePrivate('init_sequence_number')
def init_sequence_number(self):
full_path = os.path.join( self._profile_path, path )
if not os.path.exists( full_path ) or not os.path.isdir( full_path ):
return None
names = []
for name in os.listdir(full_path):
if name in skip:
continue
if [s for s in skip_suffixes if name.endswith(s)]:
continue
names.append(name)
return names
InitializeClass( DirectoryImportContext )
class DirectoryExportContext( BaseContext ):
implements(IChunkableExportContext)
security = ClassSecurityInfo()
def __init__( self, tool, profile_path, encoding=None ):
BaseContext.__init__( self, tool, encoding )
self._profile_path = profile_path
security.declareProtected( ManagePortal, 'openDataFile' )
def openDataFile( self, filename, content_type, subdir=None ):
def objectIds(self, spec=None):
return SequenceWrapper(self, self._histories.keys())
security.declarePrivate('objectValues')
def objectValues(self, spec=None):
return SequenceWrapper(self, self._histories.values())
security.declarePrivate('objectItems')
def objectItems(self, spec=None):
return SequenceWrapper(self, self._histories.items(), 1)
InitializeClass(ZopeRepository)
def addRepository(self, id, title='', REQUEST=None):
"""Zope object constructor function."""
object = ZopeRepository(title=title)
object._setId(id)
self._setObject(id, object)
object = self._getOb(id)
if REQUEST is not None:
try:
url = self.DestinationURL()
except:
url = REQUEST['URL1']
REQUEST.RESPONSE.redirect('%s/manage_main' % url)
return
filename = theFile.getId()
data = str(theFile.data)
content_type = content_type or theFile.content_type
elif isinstance(theFile, file):
filename = cookId(theFile.name)
data = theFile.read()
if content_type is None:
content_type, enc = guess_content_type(filename, data)
elif isinstance(theFile, FileUpload):
filename = cookId(theFile.filename)
data = theFile.read()
headers = theFile.headers
if content_type is None:
if 'content-type' in headers:
content_type = headers['content-type']
else:
content_type, enc = guess_content_type(filename, data)
else:
raise TypeError('Unknown object type found: %r' % theFile)
msg = MIMEBase(*content_type.split('/'))
msg.set_payload(data)
encode_base64(msg)
msg.add_header('Content-ID', '<%s>' % \
''.join(['%s' % ord(i) for i in filename]))
msg.add_header('Content-Disposition', 'attachment', filename=filename)
self.attach(msg)
InitializeClass(MTMultipart)
#posargs = (self, REQUEST, RESPONSE)
posargs = (self, REQUEST)
else:
posargs = ()
kwargs = {'cooked': self.cook()}
return template(*posargs, **kwargs)
security.declareProtected(FTPAccess, 'manage_FTPget')
def manage_FTPget(self):
""" Fetch our source for delivery via FTP.
"""
return self.raw
security.declareProtected(ViewManagementScreens, 'PrincipiaSearchSource')
def PrincipiaSearchSource(self):
""" Fetch our source for indexing in a catalog.
"""
return self.raw
security.declareProtected(ViewManagementScreens, 'document_src')
def document_src( self ):
""" Fetch our source for rendering in the ZMI.
"""
return self.raw
InitializeClass(FSSTXMethod)
registerFileExtension('stx', FSSTXMethod)
registerMetaType('STX Method', FSSTXMethod)
security.declareProtected(permissions.ModifyPortalContent,
'setDescription')
setDescription = BaseFolder.setDescription.im_func
manage_addFolder = BaseFolder.manage_addFolder.im_func
MKCOL = BaseFolder.MKCOL.im_func
MKCOL_handler = BaseFolder.MKCOL_handler.im_func
security.declareProtected(permissions.ModifyPortalContent, 'PUT')
PUT = WebDAVSupport.PUT
security.declareProtected(permissions.View, 'manage_FTPget')
manage_FTPget = WebDAVSupport.manage_FTPget
security.declarePrivate('manage_afterPUT')
manage_afterPUT = WebDAVSupport.manage_afterPUT
security.declareProtected(permissions.ModifyPortalContent, 'edit')
edit = BaseFolder.edit.im_func
InitializeClass(BaseBTreeFolder)
BaseBTreeFolderSchema = BaseBTreeFolder.schema
__all__ = (
'BaseBTreeFolder',
'BaseBTreeFolderSchema',
)
tool_id = self._extract(attrs, 'tool_id')
if tool_id not in self._forbidden:
self._forbidden.append(tool_id)
elif name == 'required':
tool_id = self._extract(attrs, 'tool_id')
dotted_name = self._extract(attrs, 'class')
self._required[tool_id] = dotted_name
else:
raise ValueError, 'Unknown element %s' % name
InitializeClass(_ToolsetParser)
class _ImportStepRegistryParser(_HandlerBase):
security = ClassSecurityInfo()
security.declareObjectPrivate()
security.setDefaultAccess('deny')
def __init__(self, encoding):
self._encoding = encoding
self._started = False
self._pending = None
self._parsed = []
class CMFBTreeFolder(BTreeFolder2Base, PortalFolderBase):
"""BTree folder for CMF sites.
"""
security = ClassSecurityInfo()
def __init__(self, id, title=''):
PortalFolderBase.__init__(self, id, title)
BTreeFolder2Base.__init__(self, id)
def _checkId(self, id, allow_dup=0):
PortalFolderBase._checkId(self, id, allow_dup)
BTreeFolder2Base._checkId(self, id, allow_dup)
security.declareProtected(AddPortalFolders, 'manage_addPortalFolder')
def manage_addPortalFolder(self, id, title='', REQUEST=None):
"""Add a new PortalFolder object with id *id*.
"""
ob = PortalFolder(id, title)
self._setObject(id, ob, suppress_events=True)
if REQUEST is not None:
return self.folder_contents( # XXX: ick!
self, REQUEST, portal_status_message="Folder added")
InitializeClass(CMFBTreeFolder)
CMFBTreeFolderFactory = Factory(CMFBTreeFolder)
# Prevent denial of service
raise ExhaustedUniqueIdsError
self._v_nextid = n + 1
return id
def __getattr__(self, name):
# Boo hoo hoo! Zope 2 prefers implicit acquisition over traversal
# to subitems, and __bobo_traverse__ hooks don't work with
# restrictedTraverse() unless __getattr__() is also present.
# Oh well.
try:
return self._htree_get(name)
except KeyError:
raise AttributeError(name)
InitializeClass(HBTreeFolder2Base)
class HBTreeFolder2(HBTreeFolder2Base, Folder):
"""BTreeFolder2 based on OFS.Folder.
"""
meta_type = 'HBTreeFolder2'
def _checkId(self, id, allow_dup=0):
Folder._checkId(self, id, allow_dup)
HBTreeFolder2Base._checkId(self, id, allow_dup)
InitializeClass(HBTreeFolder2)
security.declarePublic('getId')
def getId(self):
return self.id
security.declarePrivate('saveState')
def saveState(self, obj):
"""Save the state of object as the state for this version of
a version-controlled resource."""
self._data = self.stateCopy(obj, self)
security.declarePrivate('copyState')
def copyState(self):
"""Return an independent deep copy of the state of the version."""
data = self.__dict__.get('_data') # Avoid __of__ hooks
return self.stateCopy(data, self)
security.declarePrivate('stateCopy')
def stateCopy(self, obj, container):
"""Get a deep copy of the state of an object.
Breaks any database identity references.
"""
ignore = listNonVersionedObjects(obj)
res = cloneByPickle(aq_base(obj), ignore)
removeNonVersionedData(res)
return res
InitializeClass(Version)
security = ClassSecurityInfo()
security.declarePrivate('manage_addProperty')
security.declarePrivate('manage_delProperties')
security.declarePrivate('manage_changePropertyTypes')
def manage_propertiesForm(self, REQUEST, *args, **kw):
""" An override that makes the schema fixed.
"""
my_kw = kw.copy()
my_kw['property_extensible_schema__'] = 0
form = PropertyManager.manage_propertiesForm.__of__(self)
return form(self, REQUEST, *args, **my_kw)
InitializeClass(SimpleItemWithProperties)
#
# "Omnibus" factory framework for tools.
#
class ToolInit:
""" Utility class for generating the factories for several tools.
"""
__name__ = 'toolinit'
security = ClassSecurityInfo()
security.declareObjectPrivate() # equivalent of __roles__ = ()
def __init__(self, meta_type, tools, product_name=None, icon=None):
self.meta_type = meta_type
def __setitem__(self, i, y):
super(SortedDict, self).__setitem__(i, y)
if i not in self.pmt:
self.pmt.append(i)
security.declarePublic('pop')
def pop(self, k, *args, **kwargs):
super(SortedDict, self).pop(k, *args, **kwargs)
if k in self.pmt:
self.pmt.remove(k)
try:
InitializeClass(SortedDict)
except:
pass
def _group_unescape(m):
if m.group("ent"):
try:
return unescape(entitydefs[m.group("ent")])
except KeyError:
return m.group(0)
if m.group("dec"):
return unichr(int(m.group("dec")))
if m.group("hex"):
return unichr(int(m.group("hex"), 16))
def manage_updateProtocolMapping(self, mapping, REQUEST=None):
""" Update mapping of Request Type to Protocols
"""
for key, value in mapping.items():
value = filter(None, value)
if not value:
if self._map.has_key(key):
del self._map[key]
else:
self._map[key] = value
if REQUEST is not None:
REQUEST['RESPONSE'].redirect('%s/manage_editProtocolMapping'
'?manage_tabs_message='
'Protocol+Mappings+Changed.' %
self.absolute_url())
classImplements(
ChallengeProtocolChooser,
IChallengeProtocolChooserPlugin,
IChallengeProtocolChooser,
)
InitializeClass(ChallengeProtocolChooser)
for label, iface in (('Browser', IBrowserRequest), ('WebDAV', IWebDAVRequest),
('FTP', IFTPRequest), ('XML-RPC', IXMLRPCRequest)):
registerRequestType(label, iface)
self._members[id] = aq_base(m)
security.declarePrivate('deleteMemberData')
def deleteMemberData(self, member_id):
""" Delete member data of specified member.
"""
members = self._members
if members.has_key(member_id):
del members[member_id]
return 1
else:
return 0
InitializeClass(MemberDataTool)
registerToolInterface('portal_memberdata', IMemberDataTool)
class CleanupTemp:
"""Used to cleanup _v_temps at the end of the request."""
def __init__(self, tool):
self._tool = tool
def __del__(self):
try:
del self._tool._v_temps
except (AttributeError, KeyError):
# The object has already been deactivated.
pass
def vcs_view(self, REQUEST, RESPONSE):
"""vCalendar output
"""
RESPONSE.setHeader('Content-Type', 'text/x-vCalendar')
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s.vcs"' % self.getId())
out = StringIO()
out.write(VCS_HEADER % {
'prodid': PRODID,
})
out.write(self.getVCal())
out.write(VCS_FOOTER)
return n2rn(out.getvalue())
InitializeClass(CalendarSupportMixin)
def vformat(s):
# return string with escaped commas, colons and semicolons
return s.strip().replace(',', '\,').replace(':', '\:').replace(';', '\;')
def n2rn(s):
return s.replace('\n', '\r\n')
def rfc2445dt(dt):
# return UTC in RFC2445 format YYYYMMDDTHHMMSSZ
return dt.HTML4().replace('-', '').replace(':', '')
""" Create a column
@param hide Hide column from displaying
"""
Column.__init__(self, label, default, label_msgid)
self.visible = visible
security.declarePublic('getMacro')
def getMacro(self):
""" Return macro used to render this column in view/edit """
return "referencedatagrid_hidden_cell"
# Initializes class security
InitializeClass(HiddenColumn)
class BlockColumn(Column):
""" Column with possibility to block the cell data from changing,
based on the value of the row data.
"""
security = ClassSecurityInfo()
def __init__(self,
label,
default=None,
label_msgid=None,
column_on_class=None,
column_off_class=None,
columns=[],
