def configura_imagens(portal):
folder = portal.imagens
behavior = ISelectableConstrainTypes(folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
# Permitimos apenas imagens
behavior.setImmediatelyAddableTypes(['Image'])
folder.setLayout('folder_summary_view')
def test_immediatelyAllowedTypesInvalidValuesGetFiltered(self):
behavior = ISelectableConstrainTypes(self.folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
self.folder.immediately_addable_types = self.types_id_subset + \
['invalid']
self.assertEqual(self.types_id_subset,
behavior.getImmediatelyAddableTypes())
def post_install(context):
"""Post install script"""
#if context.readDataFile('polklibraryslider_default.txt') is None:
# return
print "Running Post Install"
# Add Group plone.app.portlets.ManagePortlets
# plone.api.group.create(groupname='slider_image_editor', title='Slider Image Editor', description='Can edit and manage slider content')
# Add Slider Folder
site = api.portal.get()
obj = api.content.create(
type='Folder',
title='Slider Images',
description=
'This folder contains all the banner sliding images of your site. DO NOT DELETE, MOVE OR RENAME!',
container=site)
api.content.transition(obj, 'publish')
obj.exclude_from_nav = True
behavior = ISelectableConstrainTypes(obj)
behavior.setConstrainTypesMode(constrains.ENABLED)
behavior.setLocallyAllowedTypes(('linkable_image', ))
behavior.setImmediatelyAddableTypes(('linkable_image', ))
obj.reindexObject()
def allowedContentTypes(self, context=None):
"""
If constraints are enabled, return the locally allowed types.
If the setting is ACQUIRE, acquire the locally allowed types according
to the ACQUIRE rules, described in the interface.
If constraints are disabled, use the default addable types
This method returns the FTI, NOT the FTI id, like most other methods.
"""
if context is None:
context = self.context
mode = self.getConstrainTypesMode()
default_addable = self.getDefaultAddableTypes(context)
if mode == DISABLED:
return default_addable
elif mode == ENABLED:
if hasattr(self.context, 'locally_allowed_types'):
return [
t for t in default_addable
if t.getId() in self.context.locally_allowed_types
]
else:
return default_addable
elif mode == ACQUIRE:
parent = self.context.__parent__
parent_constrain_adapter = ISelectableConstrainTypes(parent, None)
if not parent_constrain_adapter:
return default_addable
return_tids = self._filterByDefaults(
parent_constrain_adapter.getLocallyAllowedTypes(context))
return [t for t in default_addable if t.getId() in return_tids]
else:
raise Exception("Wrong constraint setting. %i is an invalid value",
mode)
def configura_menu_relevancia(portal):
folder = portal['menu-de-relevancia']
behavior = ISelectableConstrainTypes(folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
# Permitimos apenas links
behavior.setImmediatelyAddableTypes(['Link'])
folder.setLayout('folder_summary_view')
def getImmediatelyAddableTypes(self, context=None):
"""
If constraints are enabled, return the locally immediately
addable tpes.
If the setting is ACQUIRE, acquire the immediately addable types from
the parent, according to the rules described in the interface.
If constraints are disabled, use the default addable types
"""
if context is None:
context = self.context
mode = self.getConstrainTypesMode()
default_addable = [
t.getId() for t in self.getDefaultAddableTypes(context)
]
if mode == DISABLED:
return default_addable
elif mode == ENABLED:
if hasattr(self.context, 'immediately_addable_types'):
return self._filterByDefaults(
self.context.immediately_addable_types)
elif mode == ACQUIRE:
parent = self.context.__parent__
parent_constrain_adapter = ISelectableConstrainTypes(parent, None)
if not parent_constrain_adapter:
return default_addable
return self._filterByDefaults(
parent_constrain_adapter.getImmediatelyAddableTypes(context))
else:
raise Exception("Wrong constraint setting. %i is an invalid value",
mode)
def createContentInFolder(folder_directori, folder_content):
# Create content
if folder_content[1] != "Folder":
content_props = {
'title': folder_content[0],
'checkConstraints': False,
'exclude_from_nav': folder_content[2],
'allow_discussion': folder_content[3]
}
if folder_content[6] is not None:
content_props['description'] = folder_content[6]
if folder_content[7] is not None:
content_props['text'] = IRichText['text'].fromUnicode(
folder_content[7])
if folder_content[5] is not None:
content_props['layout'] = folder_content[5]
content = createContentInContainer(folder_directori, folder_content[1],
**content_props)
if folder_content[4] is not None:
behavior = ISelectableConstrainTypes(content)
behavior.setConstrainTypesMode(1)
behavior.setLocallyAllowedTypes(folder_content[4])
behavior.setImmediatelyAddableTypes(folder_content[4])
else:
createFolderAndContents(folder_directori, folder_content)
def createFolderAndContents(folder_directori, folder_data):
# Create folder
folder_props = {
'title': folder_data[0],
'checkConstraints': False,
'exclude_from_nav': folder_data[2],
'allow_discussion': folder_data[3]
}
if folder_data[5] is not None:
folder_props['layout'] = folder_data[5]
folder = createContentInContainer(folder_directori, folder_data[1],
**folder_props)
behavior = ISelectableConstrainTypes(folder)
behavior.setConstrainTypesMode(1)
behavior.setLocallyAllowedTypes(folder_data[4])
behavior.setImmediatelyAddableTypes(folder_data[4])
folder.reindexObject()
# Create a contents
for folder_content in folder_data[7]:
createContentInFolder(folder, folder_content)
if folder_data[6] is not None:
folder.setDefaultPage(folder_data[6])
def configura_servicos(portal):
folder = portal.servicos
behavior = ISelectableConstrainTypes(folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
# Permitimos apenas links
behavior.setImmediatelyAddableTypes(['Link'])
folder.setLayout('folder_summary_view')
def __iter__(self):
for item in self.previous:
pathkey = self.pathkey(*item.keys())[0]
constrainkey = self.constrainkey(*item.keys())[0]
if not pathkey or not constrainkey or \
constrainkey not in item: # not enough info
yield item
continue
obj = self.context.unrestrictedTraverse(item[pathkey].lstrip('/'),
None)
if obj is None: # path doesn't exist
yield item
continue
constr = ISelectableConstrainTypes(obj, None)
if constr is not None:
constrain_dict = item[constrainkey]
mode = constrain_dict['mode']
allowedtypes = constrain_dict['locallyallowedtypes']
addabletypes = constrain_dict['immediatelyaddabletypes']
if mode not in (constrains.ACQUIRE, constrains.DISABLED,
constrains.ENABLED):
# mode not valid [-1, 0, 1]
yield item
continue
constr.setConstrainTypesMode(mode)
if allowedtypes:
constr.setLocallyAllowedTypes(allowedtypes)
if addabletypes:
constr.setImmediatelyAddableTypes(addabletypes)
yield item
def test_immediatelyAllowedTypesDefaultWhenDisabled(self):
"""
Constrain Mode Disabled.
We get the default addables, independent of what our parent folder
or we ourselves defined
"""
behavior = ISelectableConstrainTypes(self.inner_folder)
behavior.setConstrainTypesMode(constrains.DISABLED)
behavior.setImmediatelyAddableTypes([])
outer_behavior = ISelectableConstrainTypes(self.folder)
outer_behavior.setConstrainTypesMode(constrains.ENABLED)
outer_behavior.setImmediatelyAddableTypes([])
types = [t.getId() for t in self.default_types]
self.assertEqual(types, behavior.getImmediatelyAddableTypes())
def various_update(self):
# replace front-page
frontpage = getattr(self.portal, 'front-page')
frontpage.title = _translate("front_page_title")
frontpage.description = _translate("front_page_descr")
frontpage.text = richtextval(_translate("front_page_text"))
transitions(frontpage, ('retract', 'publish_internally'))
frontpage.reindexObject()
self.portal.templates.layout = 'dg-templates-listing'
# plonegroup-organization
pgo = get_own_organization()
behaviour = ISelectableConstrainTypes(pgo)
behaviour.setConstrainTypesMode(1)
behaviour.setLocallyAllowedTypes([])
behaviour.setImmediatelyAddableTypes([])
ISelectableConstrainTypes(pgo['echevins']).setConstrainTypesMode(0)
ISelectableConstrainTypes(pgo['services']).setConstrainTypesMode(0)
def set_constraintypes_config(self, obj, config):
self.assertEquals({'mode', 'locally allowed', 'immediately addable'},
set(config))
ctypes = ISelectableConstrainTypes(obj)
ctypes.setConstrainTypesMode(config['mode'])
ctypes.setLocallyAllowedTypes(config['locally allowed'])
ctypes.setImmediatelyAddableTypes(config['immediately addable'])
def test_immediatelyAllowedTypesDefaultWhenEnabled(self):
"""
Constrain Mode enabled
We get the set constrains, independent of what our parent folder
defined
"""
behavior = ISelectableConstrainTypes(self.inner_folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
behavior.setImmediatelyAddableTypes(self.types_id_subset)
outer_behavior = ISelectableConstrainTypes(self.folder)
outer_behavior.setConstrainTypesMode(constrains.ENABLED)
outer_behavior.setImmediatelyAddableTypes([])
types = self.types_id_subset
self.assertEqual(types, behavior.getImmediatelyAddableTypes())
def _showConstrainOptions(self):
addContext = self._addContext()
constrain = ISelectableConstrainTypes(addContext, None)
if constrain is None:
return False
elif constrain.canSetConstrainTypes() and constrain.getDefaultAddableTypes():
return True
elif len(constrain.getLocallyAllowedTypes()) < len(constrain.getImmediatelyAddableTypes()):
return True
def onEventsFolderCreate(context, event, sample=True):
# restrict what this folder can contain
behavior = ISelectableConstrainTypes(context)
behavior.setConstrainTypesMode(constrains.ENABLED)
behavior.setImmediatelyAddableTypes(['Event'])
behavior.setLocallyAllowedTypes(['Event', 'Collection'])
# Create sample event and set publishing date to 01-01-YYYY
if sample:
# Calculate dates
now = DateTime()
start_date = DateTime() + 30
end_date = start_date + 1.0 / 24
item = createContentInContainer(context,
"Event",
id="sample",
title="Sample Event",
description="This is a sample Event",
checkConstraints=False)
item.text = RichTextValue(raw='<p>You may delete this item</p>',
mimeType=u'text/html',
outputMimeType='text/x-html-safe')
item.setEffectiveDate(now)
acc = IEventAccessor(item)
acc.start = localize(start_date)
acc.end = localize(end_date)
# create 'upcoming' collection
if 'upcoming' not in context.objectIds():
item = createContentInContainer(
context,
"Collection",
id="upcoming",
title='Upcoming Events',
)
item.setQuery([{
u'i': u'path',
u'o': u'plone.app.querystring.operation.string.absolutePath',
u'v': u'%s::1' % context.UID()
}, {
u'i': u'portal_type',
u'o': u'plone.app.querystring.operation.selection.any',
u'v': [u'Event']
}])
item.setSort_on('start')
# Set default page to the latest news collection
context.setDefaultPage('upcoming')
def test_allowedContentTypesExit2(self):
"""
Constrains are acquired, parent folder is Plone Site
"""
behavior = ISelectableConstrainTypes(self.folder)
types = behavior._getAddableTypesFor(self.portal, self.folder)
behavior.setConstrainTypesMode(constrains.ACQUIRE)
self.assertEqual(types, behavior.allowedContentTypes())
def test_set_constrain_types(self):
constraints = ISelectableConstrainTypes(self.belleville)
self.assertListEqual(sorted(["Meeting", "Folder"]),
sorted(constraints.getLocallyAllowedTypes()))
utils.set_constrain_types(self.belleville, ["Meeting"])
self.assertListEqual(["Meeting"], constraints.getLocallyAllowedTypes())
utils.set_constrain_types(self.belleville, ["Meeting", "Folder"])
self.assertListEqual(["Folder", "Meeting"],
constraints.getLocallyAllowedTypes())
def test_allowedContentTypesExit1(self):
"""
Constrains are disabled, use the portal ones
"""
behavior = ISelectableConstrainTypes(self.folder)
types = behavior._getAddableTypesFor(self.portal, self.folder)
behavior.setConstrainTypesMode(constrains.DISABLED)
self.assertEqual(types, behavior.allowedContentTypes())
def get_dashboard(self):
write = False
with api.env.adopt_roles(['Manager']):
if 'dashboards' not in self.context.objectIds():
write = True
api.content.create(type='Folder',
title='Dashboards',
id='dashboards',
container=self.context,
exclude_from_nav=True)
dashboards = self.context['dashboards']
if not IHideFromBreadcrumbs.providedBy(dashboards):
alsoProvides(dashboards, IHideFromBreadcrumbs)
if api.content.get_state(
obj=dashboards,
default='Unknown') not in ('published',
'publish_internally'):
write = True
publish_content(dashboards)
member = api.user.get_current()
user_id = member.getId()
if user_id not in dashboards.objectIds():
with api.env.adopt_roles(['Manager']):
write = True
# first make sure it is in allowed types...
pts = api.portal.get_tool('portal_types')
Folder = pts['Folder']
if 'Dashboard' not in Folder.allowed_content_types:
allowed = list(Folder.allowed_content_types)
allowed.append('Dashboard')
Folder.allowed_content_types = tuple(allowed)
aspect = ISelectableConstrainTypes(dashboards)
if (aspect.getConstrainTypesMode() != 1 or
['Dashboard'] != aspect.getImmediatelyAddableTypes()):
aspect.setConstrainTypesMode(1)
aspect.setImmediatelyAddableTypes(['Dashboard'])
api.content.create(type='Dashboard',
title='Dashboard',
id=user_id,
container=dashboards,
exclude_from_nav=True)
dashboard = dashboards[user_id]
if dashboard.getOwner().getId() != user_id:
with api.env.adopt_roles(['Manager']):
write = True
dashboard.changeOwnership(member.getUser(), recursive=False)
dashboard.reindexObjectSecurity()
if write:
alsoProvides(self.request, IDisableCSRFProtection)
return dashboard
def test_allowed_contenttypes(self):
portal = self.layer['portal']
ff = ISelectableConstrainTypes(portal[defaults.FUNCTIONS_FOLDER_ID])
# not possible as test user
self.assertEqual(len(ff.allowedContentTypes()), 0)
# but if we become Manager
setRoles(portal, TEST_USER_ID, ['Manager'])
self.assertEqual(['Document', 'org.bccvl.content.function'],
[fti.id for fti in ff.allowedContentTypes()])
# let's be Member again
setRoles(portal, TEST_USER_ID, [])
def test_allowedContentTypesExit4(self):
"""
Constrains are enabled
"""
behavior = ISelectableConstrainTypes(self.folder)
behavior.setLocallyAllowedTypes(self.types_id_subset)
behavior.setConstrainTypesMode(constrains.ENABLED)
self.assertEqual(self.types_id_subset,
[x.getId() for x in behavior.allowedContentTypes()])
def export_constraints(self, item, obj):
constrains = ISelectableConstrainTypes(obj, None)
if constrains is None:
return item
if constrains.getConstrainTypesMode() == ENABLED:
key = "exportimport.constrains"
item[key] = {
"locally_allowed_types": constrains.getLocallyAllowedTypes(),
"immediately_addable_types": constrains.getImmediatelyAddableTypes(),
}
return item
def test_locallyAllowedTypesDefaultWhenEnabled(self):
"""
Constrain Mode enabled
We get the set constrains, independent of what our parent folder
defined
"""
behavior = ISelectableConstrainTypes(self.inner_folder)
behavior.setConstrainTypesMode(constrains.ENABLED)
behavior.setLocallyAllowedTypes(self.types_id_subset)
outer_behavior = ISelectableConstrainTypes(self.folder)
outer_behavior.setConstrainTypesMode(constrains.ENABLED)
outer_behavior.setLocallyAllowedTypes([])
types = [
t for t in self.default_types if t.getId() in self.types_id_subset
]
type_ids = self.types_id_subset
self.assertEqual(types, behavior.allowedContentTypes())
self.assertEqual(type_ids, behavior.getLocallyAllowedTypes())
def get_addable_types(self):
"""Return menu item entries in a TAL-friendly form."""
data = {
'types': [],
'templates': []
}
idnormalizer = queryUtility(IIDNormalizer)
constraints = ISelectableConstrainTypes(self.folder, None)
data['canConstrainTypes'] = False
if constraints is not None:
if constraints.canSetConstrainTypes() and \
constraints.getDefaultAddableTypes():
data.update({
'canConstrainTypes': True,
'constrainUrl': '%s/folder_constraintypes_form' % (
self.folder.absolute_url(),)
})
site_path = '/'.join(self.site.getPhysicalPath())
context = self.real_context
if not IDexterityContainer.providedBy(context):
context = aq_parent(context)
folder_path = '/'.join(context.getPhysicalPath())[len(site_path):]
if not folder_path:
folder_path = '/'
for t in self.folder.allowedContentTypes():
typeId = t.getId()
data['types'].append({
'id': typeId,
'safeId': idnormalizer.normalize(typeId),
'title': t.Title(),
'description': t.Description(),
'folderPath': folder_path
})
try:
site_templates = self.folder.template_list
for t in site_templates:
typeId = t.getId()
data['templates'].append({
'id': typeId,
'safeId': idnormalizer.normalize(typeId),
'title': t.Title(),
'description': t.Description(),
'folderPath': folder_path
})
except AttributeError:
pass
return data
def test_form_save_restrictions(self):
self.browser.open(self.folder_url)
self.browser.getLink('Restrictions').click()
ctrl = lambda name: self.browser.getControl(name=name)
self.browser.getControl("Type restrictions").value = ['1']
ctrl("form.widgets.allowed_types:list").value = ["Document", "Folder"]
ctrl("form.widgets.secondary_types:list").value = ["Document"]
self.browser.getControl("Save").click()
aspect = ISelectableConstrainTypes(self.folder)
self.assertEqual(1, aspect.getConstrainTypesMode())
self.assertEqual(["Document", "Folder"],
aspect.getLocallyAllowedTypes())
self.assertEqual(["Folder"], aspect.getImmediatelyAddableTypes())
def test_immediatelyAllowedTypesDefaultWhenAcquired(self):
"""
Constrain Mode set to ACQUIRE
Try to acquire the constrains, if that fails, use the defaults
"""
behavior = ISelectableConstrainTypes(self.inner_folder)
behavior.setConstrainTypesMode(constrains.ACQUIRE)
behavior.setImmediatelyAddableTypes([])
outer_behavior = ISelectableConstrainTypes(self.folder)
outer_behavior.setConstrainTypesMode(constrains.ENABLED)
outer_behavior.setImmediatelyAddableTypes(self.types_id_subset)
types = self.types_id_subset
self.assertEqual(types, behavior.getImmediatelyAddableTypes())
outer_behavior.setConstrainTypesMode(constrains.ACQUIRE)
types = [t.getId() for t in self.default_types]
self.assertEqual(types, outer_behavior.getImmediatelyAddableTypes())
def import_constrains(self, obj, item):
if not item.get("exportimport.constrains"):
return
constrains = ISelectableConstrainTypes(obj, None)
if constrains is None:
return
constrains.setConstrainTypesMode(ENABLED)
locally_allowed_types = item["exportimport.constrains"][
"locally_allowed_types"]
constrains.setLocallyAllowedTypes(locally_allowed_types)
immediately_addable_types = item["exportimport.constrains"][
"immediately_addable_types"]
constrains.setImmediatelyAddableTypes(immediately_addable_types)
def create_event_event(obj, event):
if IRegistration.providedBy(obj.aq_parent):
parent = obj.aq_parent
parent.setDefaultPage(obj.id)
create_registration_form(parent)
behavior = ISelectableConstrainTypes(parent)
behavior.setConstrainTypesMode(1)
behavior.setImmediatelyAddableTypes(("period", ))
request = getattr(event.object, "REQUEST", getRequest())
link_translations(request, parent)
url = obj.aq_parent.absolute_url()
obj.REQUEST.RESPONSE.redirect(url)
def render(self):
portal = getSite()
gestion = self.newPrivateFolder(portal, 'gestion', u'Gestión')
gestion.exclude_from_nav = False
gestion.setLayout('folder_listing')
behavior = ISelectableConstrainTypes(gestion)
behavior.setConstrainTypesMode(1)
behavior.setLocallyAllowedTypes((
'Folder',
'privateFolder',
))
behavior.setImmediatelyAddableTypes((
'Folder',
'privateFolder',
))
enlaces_cabecera = self.newPrivateFolder(gestion, 'menu', u'Menu')
enlaces_cabecera.exclude_from_nav = False
enlaces_cabecera.reindexObject()
for language in portal['portal_languages'].getSupportedLanguages():
language_folder = self.newPrivateFolder(enlaces_cabecera, language,
language)
language_folder.exclude_from_nav = False
language_folder.reindexObject()
behavior = ISelectableConstrainTypes(language_folder)
behavior.setConstrainTypesMode(1)
behavior.setLocallyAllowedTypes((
'Folder',
'privateFolder',
'Link',
))
behavior.setImmediatelyAddableTypes((
'Folder',
'privateFolder',
'Link',
))
