def fakePutOrDelete(context, request):
"""Check whether to do fake PUT or DELETE.
If fake needs to be performed, return message of fake request.
If no faking is requested, return None.
"""
qs = request.environment['QUERY_STRING']
# this is an optimization so we don't have to do parse_qs all the time
if not '_method=' in qs:
return None
d = cgi.parse_qs(qs)
method = d.get('_method', None)
# there actually was no _method parameter after all
if method is None:
return None
method = method[0]
method = method.lower()
if method == 'put':
view = component.getMultiAdapter((context, request),
name='PUT')
return view()
elif method == 'delete':
view = component.getMultiAdapter((context, request),
name='DELETE')
return view()
# unknown fake HTTP method, ignore
return None
def test_multi_checkin_does_not_checkin_locked_documents(self, browser):
self.login(self.regular_user, browser)
browser.open(self.document, view='tabbedview_view-overview')
browser.find('Checkout and edit').click()
browser.open(self.subdocument, view='tabbedview_view-overview')
browser.find('Checkout and edit').click()
lockable = IRefreshableLockable(self.document)
lockable.lock()
browser.open(
self.dossier,
method='POST',
data={
'paths': [
obj2brain(self.document).getPath(),
obj2brain(self.subdocument).getPath(),
],
'checkin_without_comment:method': 1,
'_authenticator': createToken(),
},
)
manager = getMultiAdapter((self.document, self.portal.REQUEST), ICheckinCheckoutManager)
self.assertEquals('kathi.barfuss', manager.get_checked_out_by())
manager = getMultiAdapter((self.subdocument, self.portal.REQUEST), ICheckinCheckoutManager)
self.assertEquals(None, manager.get_checked_out_by())
self.assertEquals([u'Could not check in document Vertr\xe4gsentwurf'],
error_messages())
def getColumnsClass(self, view=None):
"""Determine whether a column should be shown. The left column is called
plone.leftcolumn; the right column is called plone.rightcolumn.
"""
context = aq_inner(self.context)
plone_view = getMultiAdapter((context, self.request), name=u'plone')
sl = plone_view.have_portlets('plone.leftcolumn', view=view);
sr = plone_view.have_portlets('plone.rightcolumn', view=view);
portal_state = getMultiAdapter((context, self.request), name=u'plone_portal_state')
if not sl and not sr:
# we don't have columns, thus conten takes the whole width
return "cell width-full position-0"
elif sl and sr:
# In case we have both columns, content takes 50% of the whole
# width and the rest 50% is spread between the columns
return "cell width-1:2 position-1:4"
elif (sr and not sl) and (portal_state.is_rtl()):
# We have right column and we are in RTL language
return "cell width-3:4 position-1:4"
elif (sr and not sl) and (not portal_state.is_rtl()):
# We have right column and we are NOT in RTL language
return "cell width-3:4 position-0"
elif (sl and not sr) and (portal_state.is_rtl()):
# We have left column and we are in RTL language
return "cell width-3:4 position-0"
elif (sl and not sr) and (not portal_state.is_rtl()):
# We have left column and we are in NOT RTL language
return "cell width-3:4 position-1:4"
def testExecuteCountMinMax(self):
e = ChildCondition()
e.check_types = set(['Document', 'Image'])
e.wf_states = None
e.recursive = False
e.min_count = 2
e.max_count = 3
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
self.folder.invokeFactory('Document', 'd1')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
self.folder.invokeFactory('Document', 'd2')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(True, ex())
self.folder.invokeFactory('Document', 'd3')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(True, ex())
self.folder.invokeFactory('Document', 'd4')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
def init(self):
self.resizer = getMultiAdapter((self.context, self.request), IMobileImageProcessor)
self.resizer.init()
sniffer = getMultiAdapter((self.context, self.request), IUserAgentSniffer)
self.ua = sniffer.getUserAgentRecord()
def testEquivalence(self):
mapping = getMultiAdapter((self.folder, self.manager), IPortletAssignmentMapping)
c = classic.Assignment()
mapping['foo'] = c
mapping2 = getMultiAdapter((self.folder, self.manager), IPortletAssignmentMapping)
self.assertEqual(mapping2['foo'], c)
def test_delete_tile_persistent_data(self):
permissions = getMultiAdapter(
(self.tile.context, self.request, self.tile), ITilesPermissions)
permissions.set_allowed_edit('masters_of_the_universe')
annotations = IAnnotations(self.tile.context)
self.assertIn('plone.tiles.permission.test-basic-tile', annotations)
configuration = getMultiAdapter(
(self.tile.context, self.request, self.tile),
ITilesConfigurationScreen)
configuration.set_configuration({
'title': {'order': u'0', 'visibility': u'on'},
'description': {'order': u'1', 'visibility': u'off'},
})
self.assertIn('plone.tiles.configuration.test-basic-tile',
annotations)
# Call the delete method
self.tile.delete()
# Now we should not see the stored data anymore
self.assertNotIn('plone.tiles.permission.test-basic-tile',
annotations)
self.assertNotIn('plone.tiles.configuration.test-basic-tile',
annotations)
def update(self):
super(View, self).update()
context = aq_inner(self.context)
parent = aq_parent(context)
if parent.portal_type=='apyb.papers.track':
track = parent
program = aq_parent(track)
else:
program = parent
self.context = context
self._path = '/'.join(context.getPhysicalPath())
self.state = getMultiAdapter((context, self.request),
name=u'plone_context_state')
self.tools = getMultiAdapter((context, self.request),
name=u'plone_tools')
self.portal = getMultiAdapter((context, self.request),
name=u'plone_portal_state')
self.helper = getMultiAdapter((program, self.request),
name=u'helper')
self._ct = self.tools.catalog()
self._mt = self.tools.membership()
self._wt = self.tools.workflow()
self.member = self.portal.member()
voc_factory = queryUtility(IVocabularyFactory,
'apyb.papers.talk.rooms')
self.rooms = voc_factory(self.context)
self.roles_context = self.member.getRolesInContext(context)
if not self.show_border:
self.request['disable_border'] = True
def __init__(self, context, request, view, manager):
ViewletBase.__init__(self, context, request, view, manager)
self.membership = getToolByName(self.context, 'portal_membership')
self.context_state = getMultiAdapter((context, request), name=u'plone_context_state')
self.portal_state = getMultiAdapter((context, request), name=u'plone_portal_state')
self.pas_info = getMultiAdapter((context, request), name=u'pas_info')
def test_multi_checkin_from_tabbedview_with_comment(self, browser):
document2 = create(Builder("document").checked_out().within(self.dossier))
browser.login().open(
self.dossier,
data={
"paths": [obj2brain(self.document).getPath(), obj2brain(document2).getPath()],
"checkin_documents:method": 1,
"_authenticator": createToken(),
},
)
# fill and submit checkin form
browser.fill({"Journal Comment Describe, why you checkin the selected documents": "Checkini"})
browser.css("#form-buttons-button_checkin").first.click()
manager1 = getMultiAdapter((self.document, self.portal.REQUEST), ICheckinCheckoutManager)
self.assertEquals(None, manager1.get_checked_out_by())
manager2 = getMultiAdapter((document2, self.portal.REQUEST), ICheckinCheckoutManager)
self.assertEquals(None, manager2.get_checked_out_by())
# check last history entry to verify the checkin
repository_tool = getToolByName(document2, "portal_repository")
history = repository_tool.getHistory(document2)
last_entry = repository_tool.retrieve(document2, len(history) - 1)
self.assertEquals("Checkini", last_entry.comment)
def _add_rule_action(self, rule, action_id, data):
action = component.getUtility(IRuleAction, name=action_id)
adding = component.getMultiAdapter((rule, self.request),
name='+action')
addview = component.getMultiAdapter((adding, self.request),
name=action.addview)
addview.createAndAdd(data=data)
def get_values_to_index(self):
request = getRequest()
items = super(FactsheetCataloguer, self).get_values_to_index()
view = getMultiAdapter((self.context, request), name='view')
contents = u''
for item in view.facts():
for fact in item.get('facts'):
contents += getMultiAdapter(
(fact.getObject(), request),
name='factrenderview')()
items['article[content]'] = contents
targets = []
for target in (self.context.targets or []):
targets.append(target)
items['article[target_list]'] = u','.join(targets)
actions = []
for action in (self.context.actions or []):
actions.append(action)
items['article[action_list]'] = u','.join(actions)
tags = []
for tag in (self.context.cataloguetags or []):
tagid, tagname = tag.split('-')
tags.append(tagname)
items['article[tag_list]'] = u','.join(tags)
items['article[countries]'] = \
(self.context.fact_countryCode or '').strip()
return items
def getResults(self):
context = Acquisition.aq_inner(self.context)
# try to get query parameters from Topic (if present)
query = hasattr(context, 'buildQuery') and context.buildQuery()
if query:
catalog = getToolByName(context, 'portal_catalog')
results = catalog(query)
# filter out results that are both outdated and expired
to_show = [
x for x in results if not (
getattr(x, 'outdated', False) and isExpired(x))
]
return to_show
# otherwise construct a query
portal_state = getMultiAdapter(
(self.context, self.request), name=u'plone_portal_state')
navigation_root_path = portal_state.navigation_root_path()
oshaview = getMultiAdapter(
(self.context, self.request), name=u'oshaview')
mySEP = oshaview.getCurrentSingleEntryPoint()
kw = ''
if mySEP:
kw = mySEP.getProperty('keyword', '')
query = '(portal_type:("News Item") OR isNews:true) AND '
'review_state:published AND path_parents:%s' % navigation_root_path
if kw != '':
query = ' AND '.join([query, 'Subject:(%s)' % ' OR '.join(kw)])
return search_solr(query, sort='Date desc')
def test_delete_confirmation_if_locked(self):
folder = self.portal['f1']
lockable = ILockable.providedBy(folder)
form = getMultiAdapter(
(folder, self.request), name='delete_confirmation')
form.update()
self.assertFalse(form.is_locked)
if lockable:
lockable.lock()
form = getMultiAdapter(
(folder, self.request), name='delete_confirmation')
form.update()
self.assertFalse(form.is_locked)
# After switching the user it should not be possible to delete the
# object. Of course this is only possible if our context provides
# ILockable interface.
if lockable:
logout()
login(self.portal, 'editor')
form = getMultiAdapter(
(folder, self.request), name='delete_confirmation')
form.update()
self.assertTrue(form.is_locked)
logout()
login(self.portal, TEST_USER_NAME)
ILockable(folder).unlock()
def __init__(self, context, request):
self.context = context
self.request = request
self.errors = {}
self.portal_state = getMultiAdapter((self.context, self.request), name=u'plone_portal_state')
self.tools = getMultiAdapter((self.context, self.request), name=u'plone_tools')
self.props = getToolByName(self.context, 'portal_properties')
self.utils = getToolByName(self.context, 'plone_utils')
self.site_properties = self.props['site_properties']
self.url_solicitacao_pesquisa = self.context.absolute_url()
self.url_sucess = self.context.absolute_url()
self.url_servico_ra = self.site_properties.URL_SERVICO_RA
self.lista = []
self.SiglaOsID = 'SUST'
if 'ordemServico' in request.form:
ordemServico = request.form['ordemServico']
request.set('ordemServico', ordemServico)
self.ordemServico = ordemServico
else:
self.ordemServico = None
if 'anoOS' in request.form:
anoOS = request.form['anoOS']
request.set('anoOS', anoOS)
self.anoOS = anoOS
else:
self.anoOS = None
def __call__(self):
portal_state = getMultiAdapter(
(self.context, self.request),
name=u'plone_portal_state'
)
context_state = getMultiAdapter(
(self.context, self.request),
name='plone_context_state'
)
# do not use getSite because it's possible it could be different
# than the actual portal url
portal_url = portal_state.portal_url()
result = {
'data-base-url': self.context.absolute_url(),
'data-view-url': context_state.view_url(),
'data-portal-url': portal_url,
'data-i18ncatalogurl': portal_url + '/plonejsi18n'
}
# first, check for any adapters that need pattern data defined
adapters = getAdapters(
(self.context, self.request, None),
IPatternsSettings
)
[result.update(x[1]()) for x in adapters]
# Resources Registered UI patterns can override adapters
registry = getUtility(IRegistry)
pattern_options = registry.get('plone.patternoptions', {})
for key, value in pattern_options.items():
result['data-pat-' + key] = value
return result
def update(self):
if not self.portal_state:
self.portal_state = component.getMultiAdapter((self.context,
self.request),
name="plone_portal_state")
if not self.portal_url:
self.portal_url = self.portal_state.portal_url()
if self.portal_path is None:
portal = self.portal_state.portal()
self.portal_path = '/'.join(portal.getPhysicalPath())
if self.portlet_url is None:
#http://stackoverflow.com/questions/11211134/how-do-i-get-the-kind-of-portlet-group-context-type-from-its-renderer-in-pl/11211893#11211893
retriever = component.getMultiAdapter((self.context, self.manager),
IPortletRetriever)
category = None
for info in retriever.getPortlets():
if info['assignment'] is self.data.aq_base:
category = info['category']
key = info['key']
break
if category is not None:
path = key[len(self.portal_path)+1:]
info = {'category': category,
'id': '%s' % self.data.id,
'manager': self.manager.__name__,
'context_path': path}
self.portlet_url = '%s/%s' % (self.portal_url,
PORTLET_PATH % info)
def get_form(self):
"""
fill out common stuff when creating a new experiment
"""
# setup request layer
self.request = TestRequest()
# get add view
form = getMultiAdapter((self.experiments, self.request),
name="newBiodiverse")
# update the form once to initialise all widgets
form.update()
# go through all widgets on the form and update the request with
# default values
data = {}
for widget in form.widgets.values():
data[widget.name] = widget.value
data.update({
'form.widgets.IDublinCore.title': u"My BD Experiment",
'form.widgets.IDublinCore.description': u'This is my experiment description',
'form.widgets.projection.count': '1',
'form.widgets.projection.item.0': unicode(self.sdmexp.UID()),
'form.widgets.projection.item.0.count': 1,
'form.widgets.projection.item.0.item.0.uuid': unicode(self.sdmproj.UID()),
'form.widgets.projection.item.0.item.0.threshold': u'0.5',
'form.widgets.cluster_size': '5000',
})
self.request.form.update(data)
form = getMultiAdapter((self.experiments, self.request),
name="newBiodiverse")
return form
def get_form(self):
"""
fill out common stuff when creating a new experiment
"""
# setup request layer
self.request = TestRequest()
# get add view
form = getMultiAdapter((self.experiments, self.request),
name="newEnsemble")
# update the form once to initialise all widgets
form.update()
# go through all widgets on the form and update the request with
# default values
data = {}
for widget in form.widgets.values():
data[widget.name] = widget.value
data.update({
'form.widgets.IDublinCore.title': u"My EN Experiment",
'form.widgets.IDublinCore.description': u'This is my experiment description',
'form.widgets.experiment_type': ISDMExperiment.__identifier__,
'form.widgets.datasets.count': '1',
'form.widgets.datasets.item.0': unicode(self.sdmexp.UID()),
'form.widgets.datasets.item.0.item': [unicode(self.sdmproj.UID())],
})
self.request.form.update(data)
form = getMultiAdapter((self.experiments, self.request),
name="newEnsemble")
return form
def getResult(self):
assert self._updated
result = []
qc = getMultiAdapter((self.context, self.request),
name='refbrowser_querycatalog')
if self.widget.show_results_without_query or self.search_text:
result = (self.widget.show_results_without_query or \
self.search_text) and \
qc(search_catalog=self.widget.search_catalog)
self.has_queryresults = bool(result)
elif self.widget.allow_browse:
ploneview = getMultiAdapter((self.context, self.request),
name="plone")
folder = ploneview.getCurrentFolder()
self.request.form['path'] = {
'query': '/'.join(folder.getPhysicalPath()),
'depth':1}
self.request.form['portal_type'] = []
self.request.form['sort_on'] = 'getObjPositionInParent'
result = qc(search_catalog=self.widget.search_catalog)
else:
result = []
b_size = int(self.request.get('b_size', 20))
b_start = int(self.request.get('b_start', 0))
return Batch(result, b_size, b_start, orphan=1)
def get_form(self):
"""
fill out common stuff when creating a new experiment
"""
# setup request layer
self.request = TestRequest()
# get add view
form = getMultiAdapter((self.experiments, self.request),
name="newProjection")
# update the form once to initialise all widgets
form.update()
# go through all widgets on the form and update the request with
# default values
data = {}
for widget in form.widgets.values():
data[widget.name] = widget.value
data.update({
'form.widgets.IDublinCore.title': u"My CC Experiment",
'form.widgets.IDublinCore.description': u'This is my experiment description',
'form.widgets.species_distribution_models.count': 1,
'form.widgets.species_distribution_models.item.0': unicode(self.sdmexp.UID()),
'form.widgets.species_distribution_models.item.0.item': [unicode(self.sdmmodel.UID())],
'form.widgets.future_climate_datasets': [unicode(self.future.UID())]
})
self.request.form.update(data)
form = getMultiAdapter((self.experiments, self.request),
name="newProjection")
return form
def test_exported_XML_valid_for_GS(self):
"""Test that exported XMLs can be parsed by GenericSetup's parser."""
self.portal = self.layer['portal']
self.request = self.layer['request']
# create a Dexterity item that we can export
self.item = add_item_type(self.portal)
# request is expected to have the 'selected' parameter set
self.request['selected'] = 'item'
# get the export view
dexterity_control_panel = getMultiAdapter(
(self.portal, self.request), name='dexterity-types')
types_export_view = getMultiAdapter(
(dexterity_control_panel, self.request), name='types-export')
# export the 'item' type and try to parse all XMLs
fd = StringIO.StringIO(types_export_view.__call__())
archive = zipfile.ZipFile(fd, mode='r')
filenames = archive.namelist()
for filename in filenames:
file_xml = archive.read(filename)
# if this passes then GenericSetup will be able to use this XML
try:
parseString(file_xml)
except ExpatError as e:
self.fail("Parsing XML failed with ExpatError: " + e.message)
def getRepliesStructure(self):
replyStructures = []
isTask = self.getType() == 'Task'
isDeadlinePassed = False
outOfTime = False
taskDeadline = getattr(self.context, 'deadline', None)
if taskDeadline is not None:
isDeadlinePassed = taskDeadline < datetime.datetime.now()
for reply_brain in self.replies:
reply = reply_brain.getObject()
if not outOfTime and isTask and isDeadlinePassed:
currentCreationDate = DT2dt(reply.created()).replace(tzinfo=None)
if currentCreationDate > taskDeadline:
outOfTime = True
expiredView = getMultiAdapter(
(self.context, self.request), name=u"expired")
replyStructures.append(expiredView)
view = getMultiAdapter((reply, self.request), name=u"thread")
replyStructures.append(view)
if replyStructures:
replyStructures[-1].isLast = True
if not outOfTime and isTask and isDeadlinePassed:
expiredView = getMultiAdapter((self.context, self.request), name=u"expired")
replyStructures.append(expiredView)
return replyStructures
def update(self):
context= aq_inner(self.context)
context_helper = getMultiAdapter((context, self.request), name="plone_context_state")
portal_helper = getMultiAdapter((context, self.request), name="plone_portal_state")
canonical = context_helper.canonical_object()
parent = aq_parent(canonical)
breadcrumbs_view = getView(self.context, self.request, 'breadcrumbs_view')
breadcrumbs = breadcrumbs_view.breadcrumbs()
if (len(breadcrumbs)==1):
self.backTitle = _(u"Home")
else:
if hasattr(parent, "Title"):
self.backTitle = parent.Title()
else:
self.backTitle = _(u"Back")
if hasattr(parent, "absolute_url"):
self.backUrl = parent.absolute_url()
else:
self.backUrl = portal_helper.portal_url()
self.isHome = len(breadcrumbs)==0
self.homeUrl = portal_helper.portal_url()
def test_spaces_are_not_escaped(self):
# Escaping spaces in URLs with %20 in LaTeX is bad because % is a comment.
chapter = create(Builder('chapter')
.within(self.book)
.titled('the chapter'))
document = create(Builder('file')
.within(chapter)
.titled('The File')
.with_id('the file'))
html = '<a class="internal-link" href="resolveuid/{0}">Link</a>'.format(
IUUID(document))
block = create(Builder('book textblock')
.within(chapter)
.having(text=html))
request = block.REQUEST
assembler = getMultiAdapter((self.book, request), IPDFAssembler)
latex_view = getMultiAdapter((block, request, assembler.get_layout()),
ILaTeXView)
self.assertEqual(
r'\hyperref[path:/plone/the-book/the-chapter/the file]{Link'
r'\footnote{See page'
r' \pageref{path:/plone/the-book/the-chapter/the file}}}',
latex_view.render().strip())
def renderViewlet(self, manager, name):
if isinstance(manager, basestring):
manager = getMultiAdapter((self.context, self.request, self), IViewletManager, name=manager)
renderer = getMultiAdapter((self.context, self.request, self, manager), IViewlet, name=name)
renderer = renderer.__of__(self.context)
renderer.update()
return renderer.render()
def __init__(self, context, request, view, manager, data):
BaseRenderer.__init__(self, context, request, view, manager, data)
portal_state = getMultiAdapter((context, request), name=u'plone_portal_state')
portal_tools = getMultiAdapter((context, request), name=u'plone_tools')
self.navigation_root_url = portal_state.navigation_root_url()
self.portal_types = portal_tools.types()
self.friendly_types = portal_state.friendly_types()
def test_delete_tile_persistent_data(self):
permissions = getMultiAdapter(
(self.tile.context, self.request, self.tile), ITilesPermissions)
permissions.set_allowed_edit('masters_of_the_universe')
annotations = IAnnotations(self.tile.context)
self.assertIn('plone.tiles.permission.test-pfg-tile', annotations)
uuid = IUUID(self.pfg, None)
configuration = getMultiAdapter(
(self.tile.context, self.request, self.tile),
ITilesConfigurationScreen)
configuration.set_configuration({
'uuid': uuid,
'title': self.pfg.Title(),
'description': self.pfg.Description(),
})
self.assertIn('plone.tiles.configuration.test-pfg-tile',
annotations)
# Call the delete method
self.tile.delete()
# Now we should not see the stored data anymore
self.assertNotIn('plone.tiles.permission.test-pfg-tile',
annotations)
self.assertNotIn('plone.tiles.configuration.test-pfg-tile',
annotations)
def testExecuteComplex(self):
e = ChildCondition()
e.check_types = set(['Folder', 'Document'])
e.wf_states = set(['published'])
e.recursive = True
e.min_count = 2
e.max_count = 3
self.folder.invokeFactory('Folder', 'f1')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
self.folder.f1.invokeFactory('Document', 'd1')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
self.portal.portal_workflow.doActionFor(self.folder.f1, 'publish')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(False, ex())
self.portal.portal_workflow.doActionFor(self.folder.f1.d1, 'publish')
ex = getMultiAdapter((self.portal, e, DummyEvent(self.folder)), IExecutable)
self.assertEquals(True, ex())
def test_crud(self):
# we start with an empty tile
self.assertTrue(self.tile.is_empty())
# now we add a couple of objects to the list
obj1 = self.portal['my-document']
obj2 = self.portal['my-image']
self.tile.populate_with_object(obj1)
self.tile.populate_with_object(obj2)
# tile's data attributed is cached so we should re-instantiate the tile
tile = getMultiAdapter((self.cover, self.request), name=self.name)
tile = tile['test']
self.assertEqual(len(tile.results()), 2)
self.assertTrue(obj1 in tile.results())
self.assertTrue(obj2 in tile.results())
# next, we replace the list of objects with a different one
obj3 = self.portal['my-news-item']
tile.replace_with_objects([IUUID(obj3, None)])
# tile's data attributed is cached so we should re-instantiate the tile
tile = getMultiAdapter((self.cover, self.request), name=self.name)
tile = tile['test']
self.assertTrue(obj1 not in tile.results())
self.assertTrue(obj2 not in tile.results())
self.assertTrue(obj3 in tile.results())
# finally, we remove it from the list; the tile must be empty again
tile.remove_item(obj3.UID())
# tile's data attributed is cached so we should re-instantiate the tile
tile = getMultiAdapter((self.cover, self.request), name=self.name)
tile = tile['test']
self.assertTrue(tile.is_empty())
def test_collection(self):
field = schema.List(
title=u'My field',
description=u'My great field',
min_length=1,
value_type=schema.TextLine(title=u'Text',
description=u'Text field',
default=u'Default text'),
default=['foobar'],
)
adapter = getMultiAdapter((field, self.portal, self.request),
IJsonSchemaProvider)
jsonschema = adapter.get_schema()
expected = {
'type': 'array',
'title': u'My field',
'description': u'My great field',
'default': ['foobar'],
'minItems': 1,
'uniqueItems': False,
'additionalItems': True,
'items': {
'type': 'string',
'title': u'Text',
'description': u'Text field',
'default': u'Default text',
}
}
self.assertEqual(jsonschema, expected)
# Test Tuple
field = schema.Tuple(
title=u'My field',
value_type=schema.Int(),
default=(1, 2),
)
adapter = getMultiAdapter((field, self.portal, self.request),
IJsonSchemaProvider)
jsonschema = adapter.get_schema()
expected = {
'type': 'array',
'title': u'My field',
'description': u'',
'uniqueItems': True,
'additionalItems': True,
'items': {
'title': u'',
'description': u'',
'type': 'integer',
},
'default': (1, 2),
}
self.assertEqual(jsonschema, expected)
# Test Set
field = schema.Set(
title=u'My field',
value_type=schema.TextLine(),
)
adapter = getMultiAdapter((field, self.portal, self.request),
IJsonSchemaProvider)
jsonschema = adapter.get_schema()
expected = {
'type': 'array',
'title': u'My field',
'description': u'',
'uniqueItems': True,
'additionalItems': True,
'items': {
'title': u'',
'description': u'',
'type': 'string',
}
}
self.assertEqual(jsonschema, expected)
# List of choices
field = schema.List(
title=u'My field',
value_type=schema.Choice(vocabulary=self.dummy_vocabulary, ),
)
adapter = getMultiAdapter((field, self.portal, self.request),
IJsonSchemaProvider)
jsonschema = adapter.get_schema()
expected = {
'type': 'array',
'title': u'My field',
'description': u'',
'uniqueItems': True,
'additionalItems': True,
'items': {
'title': u'',
'description': u'',
'type': 'string',
'enum': ['foo', 'bar'],
'enumNames': ['Foo', 'Bar'],
'choices': [('foo', 'Foo'), ('bar', 'Bar')],
}
}
self.assertEqual(jsonschema, expected)
def set_tile_configuration(self, configuration):
''' Set tile configuration
'''
tile_conf_adapter = getMultiAdapter((self.context, self.request, self),
ITilesConfigurationScreen)
tile_conf_adapter.set_configuration(configuration)
def get_tile_configuration(self):
tile_conf_adapter = getMultiAdapter((self.context, self.request, self),
ITilesConfigurationScreen)
configuration = tile_conf_adapter.get_configuration()
return configuration
def __getitem__(self, name):
return getMultiAdapter((self.ob, self.request), name=name)
def register_subscriber(self):
"""
"""
messages = IStatusMessage(self.request)
path_to_easynewsletter = self.request.get("newsletter")
# remove leading slash from paths like: /mynewsletter
path_to_easynewsletter = path_to_easynewsletter.strip("/")
newsletter_container = self.portal.unrestrictedTraverse(
path_to_easynewsletter)
subscriber = self.request.get("subscriber")
try:
validate_email(subscriber)
except EmailNotValidError as e:
messages.addStatusMessage(
_("Please enter a valid email address.\n{0}".format(e)),
"error")
return self._msg_redirect(newsletter_container)
lastname = self.request.get("name", "")
firstname = self.request.get("firstname", "")
name_prefix = self.request.get("name_prefix", "")
portal_state = getMultiAdapter((self.context.aq_inner, self.request),
name=u"plone_portal_state")
current_language = portal_state.language()
nl_language = self.request.get("nl_language", current_language)
salutation = self.request.get("salutation", "")
organization = self.request.get("organization", "")
norm = queryUtility(IIDNormalizer)
normalized_subscriber = norm.normalize(subscriber)
if normalized_subscriber in newsletter_container.objectIds():
messages.addStatusMessage(
_("Your email address is already registered."), "error")
return self._msg_redirect(newsletter_container)
subscriber_data = {}
subscriber_data["subscriber"] = subscriber
subscriber_data["lastname"] = lastname
subscriber_data["firstname"] = firstname
subscriber_data["name_prefix"] = name_prefix
subscriber_data["nl_language"] = nl_language
subscriber_data["salutation"] = salutation
subscriber_data["organization"] = organization
subscriber_data["path_to_easynewsletter"] = path_to_easynewsletter
# use password reset tool to create a hash
pwr_data = self._requestReset(subscriber)
hashkey = pwr_data["randomstring"]
enl_registration_tool = queryUtility(IENLRegistrationTool,
"enl_registration_tool")
if hashkey not in enl_registration_tool.objectIds():
enl_registration_tool[hashkey] = RegistrationData(
hashkey, **subscriber_data)
msg_subject = newsletter_container.subscriber_confirmation_mail_subject.replace(
"${portal_url}", self.portal_url.strip("http://"))
confirmation_url = (self.portal_url + "/confirm-subscriber?hkey=" +
str(hashkey))
confirmation_url = protect.utils.addTokenToUrl(confirmation_url)
msg_text = newsletter_container.subscriber_confirmation_mail_text.replace(
"${newsletter_title}", newsletter_container.title)
msg_text = msg_text.replace("${subscriber_email}", subscriber)
msg_text = msg_text.replace("${confirmation_url}",
confirmation_url)
settings = get_portal_mail_settings()
msg_sender = settings.email_from_address
msg_receiver = subscriber
msg = emails.Message(
text=msg_text,
subject=msg_subject,
mail_from=msg_sender,
mail_to=msg_receiver,
)
self.portal.MailHost.send(msg.as_string())
messages.addStatusMessage(
_("Your email has been registered. \
A confirmation email was sent to your address. Please check \
your inbox and click on the link in the email in order to \
confirm your subscription."),
"info",
)
return self._msg_redirect(newsletter_container)
def portal_state(self):
context = aq_inner(self.context)
return getMultiAdapter((context, self.request),
name=u"plone_portal_state")
def test_mailchimp_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="mailchimp-settings")
view = view.__of__(self.portal)
self.failUnless(view())
def info(self):
helpers = getMultiAdapter((self.context, self.request), name="helpers")
return helpers.info()
def cachedLinks(self, actions_category, default_icon, show_icons):
context_state = getMultiAdapter((aq_inner(self.context), self.request),
name=u'plone_context_state')
HAS_PLONE4 = False
try:
actions = context_state.actions(actions_category)
HAS_PLONE4 = True
except TypeError: # Plone < 4
actions = context_state.actions()
# Finding method for icons
# if show_icons:
# portal_actionicons = getToolByName(self.context, 'portal_actionicons')
# def render_icon(category, action, default):
# if action.has_key('icon') and action['icon']:
# # We have an icon *in* this action
# return action['icon']
# # Otherwise we look for an icon in portal_actionicons
# if category != 'object_buttons':
# return portal_actionicons.renderActionIcon(category, action['id'], default)
# else:
# # object_buttons
# plone_utils = getToolByName(self.context, 'plone_utils')
# return plone_utils.getIconFor(category, action['id'], default)
# else:
def render_icon(category, action_id, default):
# We don't show icons whatever
return None
# Building the result as list of dicts
result = []
if actions_category == "portal_tabs":
# Special case for portal_tabs (we rely on content in Plone root)
portal_tabs_view = getMultiAdapter(
(self.context, self.context.REQUEST), name='portal_tabs_view')
actions = portal_tabs_view.topLevelTabs(actions=actions)
for action in actions:
link = {
'id':
action['id'],
'url':
action['url'],
'title':
action['name'],
'icon':
render_icon(actions_category, action, default=default_icon)
}
result.append(link)
else:
if actions_category == 'object_buttons':
actions_tool = getMultiAdapter(
(aq_inner(self.context), self.context.request),
name=u'plone_tools').actions()
actions = actions_tool.listActionInfos(
object=aq_inner(self.context),
categories=(actions_category, ))
elif not HAS_PLONE4:
actions = actions.get(actions_category, [])
for action in actions:
if not (action['available'] and action['visible']
and action['allowed'] and action['url']):
continue
link = {
'id':
action['id'],
'url':
action['url'],
'title':
action['title'],
'icon':
render_icon(actions_category, action,
default=default_icon),
'modal':
action.get('modal'),
}
result.append(link)
return result
def items(self):
plone_utils = getToolByName(self.context, 'plone_utils')
portal_url = getToolByName(self.context, 'portal_url')
plone_view = getMultiAdapter((self.context, self.request),
name=u'plone')
plone_layout = getMultiAdapter((self.context, self.request),
name=u'plone_layout')
portal_workflow = getToolByName(self.context, 'portal_workflow')
portal_types = getToolByName(self.context, 'portal_types')
portal_membership = getToolByName(self.context, 'portal_membership')
registry = getUtility(IRegistry)
use_view_action = registry.get(
'plone.types_use_view_action_in_listings', ())
browser_default = plone_utils.browserDefault(self.context)
results = list()
if portal_membership.isAnonymousUser():
worklist = []
else:
worklist = portal_workflow.getWorklistsResults()
for i, obj in enumerate(worklist):
if i % 2 == 0:
table_row_class = "even"
else:
table_row_class = "odd"
url = obj.absolute_url()
path = '/'.join(obj.getPhysicalPath())
type_class = 'contenttype-' + plone_utils.normalizeString(
obj.portal_type)
review_state = portal_workflow.getInfoFor(obj, 'review_state', '')
state_class = 'state-' + plone_utils.normalizeString(review_state)
relative_url = portal_url.getRelativeContentURL(obj)
type_title_msgid = portal_types[obj.portal_type].Title()
url_href_title = u'%s: %s' % (translate(type_title_msgid,
context=self.request),
safe_unicode(obj.Description()))
getMember = getToolByName(obj, 'portal_membership').getMemberById
creator_id = obj.Creator()
creator = getMember(creator_id)
if creator:
creator_name = creator.getProperty('fullname',
'') or creator_id
else:
creator_name = creator_id
modified = ''.join(
map(safe_unicode, [
creator_name, ' - ',
plone_view.toLocalizedTime(obj.ModificationDate(),
long_format=1)
]))
is_structural_folder = obj.restrictedTraverse(
'@@plone').isStructuralFolder()
if obj.portal_type in use_view_action:
view_url = url + '/view'
elif is_structural_folder:
view_url = url + "/folder_contents"
else:
view_url = url
is_browser_default = len(
browser_default[1]) == 1 and (obj.id == browser_default[1][0])
results.append(
dict(url=url,
url_href_title=url_href_title,
id=obj.getId(),
quoted_id=quote_plus(obj.getId()),
path=path,
title_or_id=obj.pretty_title_or_id(),
description=obj.Description(),
obj_type=obj.Type,
size=human_readable_size(obj.get_size()),
modified=modified,
type_class=type_class,
wf_state=review_state,
state_title=portal_workflow.getTitleForStateOnType(
review_state, obj.portal_type),
state_class=state_class,
is_browser_default=is_browser_default,
folderish=is_structural_folder,
relative_url=relative_url,
view_url=view_url,
table_row_class=table_row_class,
is_expired=isExpired(obj)))
return results
def get_containing_subdossier(self):
# get the containing_dossier value directly with the indexer
catalog = getToolByName(self, 'portal_catalog')
return getMultiAdapter((self, catalog),
IIndexer,
name='containing_subdossier')()
def info_for(self, booking):
booking = self.context.publishTraverse(self.request, booking.uid)
helpers = getMultiAdapter((booking, self.request), name="helpers")
return helpers.info(self.context.__parent__)
def isAnonyme(self):
portal_state = getMultiAdapter((self.context, self.request),
name=u'plone_portal_state')
if portal_state.anonymous():
return True
return False
def update(self):
self.context_state = getMultiAdapter((self.context, self.request),
name=u'plone_context_state')
def test_adaptor(self):
"""Testing the annotation adaptor."""
request = TestRequest()
view = getMultiAdapter((self.document, request), name=u'annotate.html')
self.assertEquals(view.getBodyText(), u"body text",
"IAnnotatable views unable to access the description attribute.")
def formatted_date(self, item):
provider = getMultiAdapter(
(self.context, self.request, self),
IContentProvider, name='formatted_date'
)
return provider(item)
def test_portal_ical(self):
headers, output, request = make_fake_response(self.request)
view = getMultiAdapter((self.portal, request), name='ics_view')
view()
self.assertEqual(len(headers), 2)
self.assertEqual(headers['Content-Type'], 'text/calendar')
icalstr = ''.join(output)
# No occurrences in export. Otherwise count would be 8.
self.assertEqual(icalstr.count('BEGIN:VEVENT'), 4)
self.checkOrder(
icalstr,
'BEGIN:VCALENDAR',
'VERSION:2.0',
'PRODID:-//Plone.org//NONSGML plone.app.event//EN',
'X-WR-TIMEZONE:Europe/Vienna',
# whole_day event
'BEGIN:VEVENT',
'SUMMARY:Past Event',
'DTSTART;VALUE=DATE:20130425',
'DTEND;VALUE=DATE:20130426',
'DTSTAMP;VALUE=DATE-TIME:',
'UID:',
'RRULE:FREQ=DAILY;COUNT=3',
'CREATED;VALUE=DATE-TIME:',
'LAST-MODIFIED;VALUE=DATE-TIME:',
'LOCATION:Vienna',
'URL:http://nohost/plone/past',
'END:VEVENT',
'BEGIN:VEVENT',
'SUMMARY:Long Event',
'DTSTART;TZID=Europe/Vienna;VALUE=DATE-TIME:20130425T100000',
'DTEND;TZID=Europe/Vienna;VALUE=DATE-TIME:20130604T100000',
'DTSTAMP;VALUE=DATE-TIME:',
'UID:',
'CREATED;VALUE=DATE-TIME:',
'LAST-MODIFIED;VALUE=DATE-TIME:',
'LOCATION:Schaftal',
'URL:http://nohost/plone/sub/long',
'END:VEVENT',
'BEGIN:VEVENT',
'SUMMARY:Now Event',
'DTSTART;TZID=Europe/Vienna;VALUE=DATE-TIME:20130505T100000',
'DTEND;TZID=Europe/Vienna;VALUE=DATE-TIME:20130505T110000',
'DTSTAMP;VALUE=DATE-TIME:',
'UID:',
'RRULE:FREQ=DAILY;COUNT=3;INTERVAL=1',
'RDATE;TZID=Europe/Vienna:20130509T000000',
'EXDATE;TZID=Europe/Vienna:20130506T000000,20140404T000000',
'CATEGORIES:plone',
'CATEGORIES:testing',
'CONTACT:Auto Testdriver\\, +123456789\\, [email protected]\\, http://plone', # noqa
' .org',
'CREATED;VALUE=DATE-TIME:',
'LAST-MODIFIED;VALUE=DATE-TIME:',
'LOCATION:Vienna',
'URL:http://nohost/plone/now',
'END:VEVENT',
'BEGIN:VEVENT',
'SUMMARY:Future Event',
'DTSTART;TZID=Europe/Vienna;VALUE=DATE-TIME:20130515T100000',
'DTEND;TZID=Europe/Vienna;VALUE=DATE-TIME:20130515T110000',
'DTSTAMP;VALUE=DATE-TIME:',
'UID:',
'CREATED;VALUE=DATE-TIME:',
'LAST-MODIFIED;VALUE=DATE-TIME:',
'LOCATION:Graz',
'URL:http://nohost/plone/future',
'END:VEVENT',
'BEGIN:VTIMEZONE',
'TZID:Europe/Vienna',
'X-LIC-LOCATION:Europe/Vienna',
'BEGIN:DAYLIGHT',
'DTSTART;VALUE=DATE-TIME:20130331T030000',
'TZNAME:CEST',
'TZOFFSETFROM:+0100',
'TZOFFSETTO:+0200',
'END:DAYLIGHT',
'END:VTIMEZONE',
'END:VCALENDAR')
def publishTraverse(self, request, name):
traverser = component.getMultiAdapter((self.context, request),
IPublishTraverse)
return traverser.publishTraverse(request, name)
def add_level(self):
fields = ['active', 'skuCode', 'price', 'description']
request = getRequest()
pps = getMultiAdapter((self.context, request),
name='plone_portal_state')
language = pps.language()
if len(self.getVariationAttributes()) == 1:
new_value_1 = translate(_('label_new_value_1',
default=u'New value 1'),
domain='ftw.shop',
context=self.context,
target_language=language)
new_value_2 = translate(_('label_new_value_2',
default=u'New value 2'),
domain='ftw.shop',
context=self.context,
target_language=language)
new_attr = translate(_('label_new_attr', default=u'New attribute'),
domain='ftw.shop',
context=self.context,
target_language=language)
self.context.getField('variation2_values').set(
self.context, [new_value_1, new_value_2])
self.context.getField('variation2_attribute').set(
self.context, new_attr)
# Initialize var data for newly added level with default values
for i in range(len(self.getVariation1Values())):
for j in range(len(self.getVariation2Values())):
vardata = {}
for f in fields:
vcode = "var-%s-%s" % (i, j)
data = self.getVariationData(i, j, f)
vardata[f] = data
partial_vardict = {vcode: vardata}
self.updateVariationConfig(partial_vardict)
elif len(self.getVariationAttributes()) == 0:
new_value_1 = translate(_('label_new_value_1',
default=u'New value 1'),
domain='ftw.shop',
context=self.context,
target_language=language)
new_value_2 = translate(_('label_new_value_2',
default=u'New value 2'),
domain='ftw.shop',
context=self.context,
target_language=language)
new_attr = translate(_('label_new_attr', default=u'New attribute'),
domain='ftw.shop',
context=self.context,
target_language=language)
self.context.getField('variation1_values').set(
self.context, [new_value_1, new_value_2])
self.context.getField('variation1_attribute').set(
self.context, new_attr)
# Initialize var data for newly added level with default values
for i in range(len(self.getVariation1Values())):
vardata = {}
for f in fields:
vcode = "var-%s" % (i)
data = self.getVariationData(i, None, f)
vardata[f] = data
partial_vardict = {vcode: vardata}
self.updateVariationConfig(partial_vardict)
def __call__(self):
form = self.request.form
context = aq_inner(self.context)
request = context.REQUEST
authenticator = getMultiAdapter((context, request),
name=u"authenticator")
# CSRF should be disabled during tests
if (not IDisableCSRFProtection.providedBy(request)
and not authenticator.verify()):
raise Unauthorized
if not self.memship.checkPermission('Poi: Add Response', context):
raise Unauthorized
response_text = form.get('response', u'')
new_response = Response(response_text)
new_response.mimetype = self.mimetype
new_response.type = self.determine_response_type(new_response)
issue_has_changed = False
transition = form.get('transition', u'')
if transition and transition in self.available_transitions:
wftool = getToolByName(context, 'portal_workflow')
before = wftool.getInfoFor(context, 'review_state')
before = wftool.getTitleForStateOnType(before, 'PoiIssue')
wftool.doActionFor(context, transition)
after = wftool.getInfoFor(context, 'review_state')
after = wftool.getTitleForStateOnType(after, 'PoiIssue')
new_response.add_change('review_state', _(u'Issue state'), before,
after)
issue_has_changed = True
options = [
('severity', _(u'Severity'), 'available_severities'),
('current_assignee', _(u'Assignee'), 'available_assignees'),
('targetRelease', _(u'Target release'), 'available_releases'),
]
for option, title, vocab in options:
new = form.get(option, u'')
if new and new in self.__getattribute__(vocab):
current = self.__getattribute__(option)
if current == new:
continue
new_response.add_change(option, title, current, new)
issue_has_changed = True
if option == 'severity':
context.severity = new
elif option == 'targetRelease':
context.target_release = new
elif option == 'current_assignee':
context.assignee = new
if len(response_text) == 0 and not issue_has_changed:
status = IStatusMessage(self.request)
msg = _(u"No response text added and no issue changes made.")
msg = translate(msg, 'Poi', context=self.request)
status.addStatusMessage(msg, type='error')
else:
# Add response
self.folder.add(new_response)
context.reindexObject()
redirect_url = "{0}?_authenticator={1}".format(context.absolute_url(),
authenticator.token())
self.request.response.redirect(redirect_url)
def browserview(self, context, name):
return getMultiAdapter((context, self.aq_parent.REQUEST), name=name)
def __init__(self, *args):
base.Renderer.__init__(self, *args)
portal_state = getMultiAdapter((self.context, self.request),
name=u'plone_portal_state')
self.portal_url = portal_state.portal_url()
self.portal = portal_state.portal()
def prepareObjectTabs(self, default_tab='view',
sort_first=['folderContents']):
"""Prepare the object tabs by determining their order and working
out which tab is selected. Used in global_contentviews.pt
"""
context = aq_inner(self.context)
context_url = context.absolute_url()
context_fti = context.getTypeInfo()
context_state = getMultiAdapter(
(context, self.request), name=u'plone_context_state'
)
actions = context_state.actions
action_list = []
if context_state.is_structural_folder():
action_list = actions('folder')
action_list.extend(actions('object'))
tabs = []
found_selected = False
fallback_action = None
try:
request_url = self.request['ACTUAL_URL']
except KeyError:
# not a real request, could be a test. Let's not fail.
request_url = context_url
request_url_path = request_url[len(context_url):]
if request_url_path.startswith('/'):
request_url_path = request_url_path[1:]
for item in action_list:
item.update({'selected': False})
action_url = item['url'].strip()
starts = action_url.startswith
if starts('http') or starts('javascript'):
item['url'] = action_url
else:
item['url'] = '%s/%s' % (context_url, action_url)
item['url'] = addTokenToUrl(item['url'], self.request)
action_method = item['url'].split('/')[-1].split('?')[0]
# Action method may be a method alias:
# Attempt to resolve to a template.
action_method = context_fti.queryMethodID(
action_method, default=action_method
)
if action_method:
request_action = unquote(request_url_path).split('?')[0]
request_action = context_fti.queryMethodID(
request_action, default=request_action
)
if action_method == request_action:
item['selected'] = True
found_selected = True
current_id = item['id']
if current_id == default_tab:
fallback_action = item
modal = item.get('modal', None)
item['cssClass'] = ''
if modal:
item['cssClass'] += ' pat-plone-modal'
item['url'] += '?ajax_load=1'
tabs.append(item)
if not found_selected and fallback_action is not None:
fallback_action['selected'] = True
def sortOrder(tab):
try:
return sort_first.index(tab['id'])
except ValueError:
return 255
tabs.sort(key=sortOrder)
return tabs
def portal_url(self):
portal_state = getMultiAdapter((self.context, self.request),
name=u'plone_portal_state')
return portal_state.portal_url()
def update(self):
context_state = getMultiAdapter((self.context, self.request),
name=u'plone_context_state')
self.current_page_url = context_state.current_page_url
def update(self):
self.portal_state = getMultiAdapter((self.context, self.request),
name=u'plone_portal_state')
self.site_url = self.portal_state.portal_url()
self.navigation_root_url = self.portal_state.navigation_root_url()
def getMenuItems(self, context, request):
"""Return menu item entries in a TAL-friendly form."""
factories_view = getMultiAdapter((context, request),
name='folder_factories')
haveMore = False
include = None
addContext = factories_view.add_context()
allowedTypes = _allowedTypes(request, addContext)
constraints = IConstrainTypes(addContext, None)
if constraints is not None:
include = constraints.getImmediatelyAddableTypes()
if len(include) < len(allowedTypes):
haveMore = True
results = factories_view.addable_types(include=include)
if haveMore:
url = '{0}/folder_factories'.format(addContext.absolute_url())
results.append({
'title':
_(u'folder_add_more', default=u'More\u2026'),
'description':
_(u'Show all available content types'),
'action':
url,
'selected':
False,
'icon':
None,
'extra': {
'id': 'plone-contentmenu-more',
'separator': None,
'class': ''
},
'submenu':
None,
})
constraints = ISelectableConstrainTypes(addContext, None)
if constraints is not None:
if constraints.canSetConstrainTypes() and \
constraints.getDefaultAddableTypes():
url = '{0}/folder_constraintypes_form'.format(
addContext.absolute_url(), )
results.append({
'title':
_(u'folder_add_settings', default=u'Restrictions\u2026'),
'description':
_(u'title_configure_addable_content_types',
default=u'Configure which content types can be '
u'added here'),
'action':
url,
'selected':
False,
'icon':
None,
'extra': {
'id': 'plone-contentmenu-settings',
'separator': None,
'class': ''
},
'submenu':
None,
})
# Also add a menu item to add items to the default page
context_state = getMultiAdapter((context, request),
name='plone_context_state')
if context_state.is_structural_folder() and \
context_state.is_default_page() and \
self._contentCanBeAdded(context, request):
results.append({
'title':
_(u'default_page_folder', default=u'Add item to default page'),
'description':
_(u'desc_default_page_folder',
default=u'If the default page is also a folder, '
u'add items to it from here.'),
'action':
context.absolute_url() + '/@@folder_factories',
'selected':
False,
'icon':
None,
'extra': {
'id': 'plone-contentmenu-add-to-default-page',
'separator': None,
'class': 'pat-plone-modal'
},
'submenu':
None,
})
return results
def update(self):
context_state = getMultiAdapter((self.context, self.request),
name=u'plone_context_state')
self.site_actions = context_state.actions('site_actions')
def __init__(self, context, request):
super(ActionsSubMenuItem, self).__init__(context, request)
self.context_state = getMultiAdapter((context, request),
name='plone_context_state')
def __init__(self, context, request):
BrowserSubMenuItem.__init__(self, context, request)
self.context = context
self.context_state = getMultiAdapter((context, request),
name='plone_context_state')
