def setUp(self):
self.portal = self.layer['portal']
pp = self.portal.portal_properties
self.sheet = getattr(pp, 'brasil_gov', None)
# Como nao eh um teste funcional, este objeto
# REQUEST precisa ser anotado com o browser layer
alsoProvides(self.portal.REQUEST, IBarraInstalada)
def markTargetOnAdd(alias, event):
"""When the alias is added, mark the target with IHasAlias
"""
target = aq_inner(alias._target)
if target is not None and not IHasAlias.providedBy(target):
alsoProvides(target, IHasAlias)
def listing(self, **kwargs):
"""listing page"""
page = self.get_page(**kwargs)
fs = self.get_grid()
fs = fs.bind(instances=page, request=self.request)
fs.readonly = True
event = events.BeforeRenderEvent(self.request.model_class(), self.request, fs=fs, page=page)
alsoProvides(event, events.IBeforeListingRenderEvent)
zope.component.event.objectEventNotify(event)
if self.request.format == 'json':
values = []
request = self.request
for item in page:
pk = _pk(item)
fs._set_active(item)
value = dict(id=pk,
absolute_url=request.fa_url(request.model_name, pk))
if 'jqgrid' in request.GET:
fields = [_stringify(field.render_readonly()) for field in fs.render_fields.values()]
value['cell'] = [pk] + fields
else:
value.update(fs.to_dict(with_prefix=bool(request.params.get('with_prefix'))))
values.append(value)
return self.render_json_format(rows=values,
records=len(values),
total=page.page_count,
page=page.page)
if 'pager' not in kwargs:
pager = page.pager(**self.pager_args)
else:
pager = kwargs.pop('pager')
return self.render_grid(fs=fs, id=None, pager=pager)
def EnableCustomRisks(survey):
"""In order to allow the user to add custom risks, we create a new special
module (marked with ICustomRisksModule) in which they may be created.
"""
appconfig = component.getUtility(IAppConfig)
if not asBool(appconfig["euphorie"].get("allow_user_defined_risks")):
return 0
if "custom-risks" in survey.keys():
# We don't want to create the custom risks module twice.
return 0
args = dict(
container=survey,
type="euphorie.module",
id="custom-risks",
title=_(u"title_other_risks", default=u"Added risks (by you)"),
safe_id=False,
description=_(
u"description_other_risks", default=u"In case you have identified "
u"risks not included in the tool, you are able to add them now:"),
optional=True,
question=_(
u"question_other_risks", default=u"<p>Would you now like to add "
u"your own defined risks to this tool?</p><p><strong>Important:"
u"</strong> In order to avoid duplicating risks, we strongly "
u"recommend you to go first through all the previous modules, if "
u"you have not done it yet.</p><p>If you don't need to add risks, "
u"please select 'No.'</p>"),
)
try:
module = api.content.create(**args)
except api.exc.InvalidParameterError:
args['id'] = "custom-risks-"+str(random.randint(0, 99999999))
module = api.content.create(**args)
alsoProvides(module, ICustomRisksModule)
return args['id']
def __call__(self):
alsoProvides(self.request, IDisableCSRFProtection)
data = self.read_json()
response_data = {
'github_members': {},
'github_stats': {},
'stackoverflow': {},
'pypi': {},
'twitter': {},
'community': {},
}
members = api.user.get_users()
self.add_github_member_related_data(
members,
data,
response_data['github_members']
)
self.add_stackoverflow_data(
members,
data,
response_data['stackoverflow']
)
self.add_twitter_data(
members,
data,
response_data['twitter']
)
self.add_github_overall_stats(data, response_data['github_stats'])
# Disable pypi stats since they always return 0
# self.add_pypi_stats(data, response_data['pypi'])
self.add_community_stats(data, response_data['community'])
return self.json_success(response_data)
def update(self):
# check that either the secret_key was passed in the request or the user has modify rights
key = self.request.form.get('key', None)
if not key or key != self.context.secret_key:
sm = getSecurityManager()
if not sm.checkPermission(ModifyPortalContent, self.context):
raise Unauthorized
self.receipt = IDonationReceipt(self.context)()
# Create a wrapped form for inline rendering
from collective.salesforce.fundraising.forms import CreateDonationDonorQuote
# Only show the form if a donor quote can be created
if self.context.can_create_donor_quote():
self.donor_quote_form = CreateDonationDonorQuote(self.context, self.request)
alsoProvides(self.donor_quote_form, IWrappedForm)
self.donor_quote_form.update()
self.donor_quote_form.widgets.get('name').value = u'%s %s' % (self.context.first_name, self.context.last_name)
if self.context.contact_sf_id and self.donor_quote_form.widgets.get('contact_sf_id'):
self.donor_quote_form.widgets.get('contact_sf_id').value = unicode(self.context.contact_sf_id)
self.donor_quote_form.widgets.get('key').value = unicode(self.context.secret_key)
self.donor_quote_form.widgets.get('amount').value = int(self.context.amount)
self.donor_quote_form_html = self.donor_quote_form.render()
# Determine any sections that should be collapsed
self.hide = self.request.form.get('hide', [])
if self.hide:
self.hide = self.hide.split(',')
def set_browserlayer(request):
"""Set the BrowserLayer for the request.
We have to set the browserlayer manually, since importing the profile alone
doesn't do it in tests.
"""
alsoProvides(request, IPlonesocialNetworkLayer)
def test_basic_tile_purge_cache(self):
provideHandler(queuePurge)
request = self.request
alsoProvides(request, IAttributeAnnotatable)
setRequest(request)
registry = queryUtility(IRegistry)
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://*****:*****@@collective.cover.basic/test',
'/c1/@@collective.cover.basic/test/@@images/image',
'/c1/@@collective.cover.basic/test/@@images/icon',
'/c1/@@collective.cover.basic/test/@@images/mini',
'/c1/@@collective.cover.basic/test/@@images/large',
'/c1/@@collective.cover.basic/test/@@images/listing',
'/c1/@@collective.cover.basic/test/@@images/thumb',
'/c1/@@collective.cover.basic/test/@@images/preview',
'/c1/@@collective.cover.basic/test/@@images/tile']),
IAnnotations(request)['plone.cachepurging.urls'])
def _create_site_with_request(self):
request = Dummy(getPreferredLanguages=lambda: [])
alsoProvides(request, IUserPreferredLanguages)
site = Dummy(REQUEST=request,
getSiteManager=getGlobalSiteManager)
return site
def test_viewlet(self):
request = self.folder.REQUEST
view = self.folder.restrictedTraverse('@@plone')
alsoProvides(view, IViewView)
self.assertTrue(IViewView.providedBy(view))
viewlet_manager = queryMultiAdapter(
(self.folder, request, view),
IContentProvider,
'plone.abovecontentbody')
viewlet = queryMultiAdapter(
(self.folder, request, view, viewlet_manager),
IViewlet,
'collective.calltoaction')
self.assertTrue(viewlet is not None)
viewlet.update()
# We expect data from the portlet assignment in
# profiles/testfixture/portlets.xml.
self.assertEqual(len(viewlet.data), 1)
portlet = viewlet.data[0]
self.assertIn('assignment', portlet.keys())
self.assertIn('html', portlet.keys())
assignment = portlet['assignment']
self.assertEqual(assignment.milli_seconds_until_overlay, 1000)
portlet_html = portlet['html']
self.assertIn('portletCallToAction', portlet_html)
self.assertIn('portletCallToAction', portlet_html)
viewlet_html = viewlet.render()
self.assertIn(portlet_html, viewlet_html)
self.assertIn('data-timeout="1000"', viewlet_html)
def test_portlet_inheritance(self):
portal = self.layer['portal']
folder = portal.folder2
request = folder.REQUEST
view = folder.restrictedTraverse('@@plone')
alsoProvides(view, IViewView)
self.assertTrue(IViewView.providedBy(view))
viewlet_manager = queryMultiAdapter(
(folder, request, view),
IContentProvider,
'plone.abovecontentbody')
viewlet = queryMultiAdapter(
(folder, request, view, viewlet_manager),
IViewlet,
'collective.calltoaction')
self.assertTrue(viewlet is not None)
viewlet.update()
# The portlet from the test fixture is blocked.
self.assertEqual(len(viewlet.data), 0)
# Show the action globally. This ignores portlet inheritance.
registry = getUtility(IRegistry)
settings = registry.forInterface(
ICollectiveCalltoactionSettings, check=False)
self.assertFalse(settings.show_global)
settings.show_global = True
# Now we should see the portlet
viewlet.update()
self.assertEqual(len(viewlet.data), 1)
def __call__(self):
"""Sync a single user profile with external property providers"""
alsoProvides(self.request, IDisableCSRFProtection)
userprofile = self.context
IUserProfileManager(userprofile).sync()
api.portal.show_message(message=_("External property sync complete."), request=self.request)
return self.request.response.redirect(userprofile.absolute_url())
def test_export_with_missing_schema_does_not_error(self):
xml = """\
<registry>
<record name="test.export.simple" interface="non.existant.ISchema" field="blah">
<field type="plone.registry.field.TextLine">
<default>N/A</default>
<title>Simple record</title>
</field>
<value>Sample value</value>
</record>
</registry>"""
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"), value=u"Sample value")
# Note: These are nominally read-only!
self.registry.records['test.export.simple'].field.interfaceName = 'non.existant.ISchema'
self.registry.records['test.export.simple'].field.fieldName = 'blah'
alsoProvides(self.registry.records['test.export.simple'], IInterfaceAwareRecord)
context = DummyExportContext(self.site)
exportRegistry(context)
self.assertEquals('registry.xml', context._wrote[0][0])
self.assertXmlEquals(xml, context._wrote[0][1])
def apply_request_layer_by_url(event):
"""Apply a request layer by URL.
This subscriber applies a request-layer on the ``request`` object
based on the request to allow layer-based component registration
of user interface elements.
NOTE: only one layer is applied -- the first one to match.
"""
request = event.request
#path = "/".join(reversed(request.getTraversalStack()))
path = url.get_destination_url_path(request)
path_info = request.get("PATH_INFO")
log.debug(" [apply_request_layer_by_url] path=%s path_info=%s" % (
path, path_info))
for condition, layer in mapping_on_path:
if condition.match(path) is not None:
log.debug("Adding %s layer to request for path <%s>" % (layer, path))
interface.alsoProvides(request, layer)
break # only apply first matching layer
else: # there was no break, no mapping_on_path layer added
# !+IResourceNonLayer(mr, nov-2010) almost never passes thru here
for condition, layer in mapping_on_path_info:
if condition.match(path_info) is not None:
log.debug("Adding %s layer to request for path_info <%s>" % (
layer, path_info))
interface.alsoProvides(request, layer)
break
def test_multiple_selection(self):
"""The pattern_options key maximumSelectionSize shouldn't be
set when the field allows multiple selections"""
from plone.app.widgets.dx import RelatedItemsFieldWidget
from zope.schema.interfaces import ISource
from zope.schema.vocabulary import VocabularyRegistry
context = Mock(absolute_url=lambda: 'fake_url')
context.portal_properties.site_properties\
.getProperty.return_value = ['SomeType']
field = List(
__name__='selectfield',
value_type=Choice(vocabulary='foobar')
)
widget = RelatedItemsFieldWidget(field, self.request)
widget.context = context
vocab = Mock()
alsoProvides(vocab, ISource)
with mock.patch.object(VocabularyRegistry, 'get', return_value=vocab):
widget.update()
base_args = widget._base_args()
patterns_options = base_args['pattern_options']
self.assertFalse('maximumSelectionSize' in patterns_options)
self.assertEqual(
patterns_options['vocabularyUrl'],
'/@@getVocabulary?name=foobar&field=selectfield',
)
def update(self):
super(TwitterSearchViewlet, self).update()
z2.switch_on(self, request_layer=IFormLayer)
self.form = SearchForm(aq_inner(self.context), self.request)
# necessary to avoid maximum recursion error
alsoProvides(self.form, IWrappedForm)
self.form.update()
def set_browserlayer(request):
"""Set the BrowserLayer for the request.
We have to set the browserlayer manually, since importing the profile alone
doesn't do it in tests.
"""
alsoProvides(request, IProductShopExtensionLayer)
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.portal.invokeFactory('Folder', 'test-folder')
self.folder = self.portal['test-folder']
interface.alsoProvides(
self.request,
interfaces.IDiscussionLayer
)
self.workflowTool = getToolByName(self.portal, 'portal_workflow')
self.workflowTool.setDefaultChain('one_state_workflow')
typetool = self.portal.portal_types
typetool.constructContent('Document', self.portal, 'doc1')
self.portal_discussion = getToolByName(
self.portal,
'portal_discussion',
None
)
self.membershipTool = getToolByName(self.folder, 'portal_membership')
self.memberdata = self.portal.portal_memberdata
context = getattr(self.portal, 'doc1')
self.viewlet = CommentsViewlet(context, self.request, None, None)
# Allow discussion
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings)
settings.globally_enabled = True
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.portal.invokeFactory('Folder', 'test-folder')
self.folder = self.portal['test-folder']
interface.alsoProvides(
self.portal.REQUEST,
interfaces.IDiscussionLayer,
)
typetool = self.portal.portal_types
typetool.constructContent('Document', self.portal, 'doc1')
wftool = getToolByName(self.portal, "portal_workflow")
wftool.doActionFor(self.portal.doc1, action='publish')
self.discussionTool = getToolByName(
self.portal,
'portal_discussion',
None
)
self.discussionTool.overrideDiscussionFor(self.portal.doc1, False)
self.membershipTool = getToolByName(self.folder, 'portal_membership')
self.memberdata = self.portal.portal_memberdata
self.context = getattr(self.portal, 'doc1')
# Allow discussion
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings)
settings.globally_enabled = True
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
alsoProvides(self.request, IBrowserLayer)
with api.env.adopt_roles(['Manager']):
self.journal = api.content.create(
self.portal, 'Journal', 'journal')
def __iter__(self):
for item in self.previous:
pathkey = self.pathkey(*item.keys())[0]
fileskey = self.fileskey(*item.keys())[0]
if not (pathkey and fileskey):
yield item
continue
if 'interfaces' not in item[fileskey]:
yield item
continue
path = item[pathkey]
obj = self.context.unrestrictedTraverse(path, None)
if obj is None: # path doesn't exist
yield item
continue
ifaces = self.extractIfaces(obj, item[fileskey]['interfaces']['data'])
if ifaces == []: # no interfaces
yield item
continue
alsoProvides(obj, *ifaces)
yield item
self.catalog.reindexIndex('object_provides', None)
def update(self):
""" Update form - see interfaces.IForm """
self.formMaybeForceSSL()
super(EasyFormForm, self).update()
self.template = self.form_template
if self.request.method == 'POST' and \
not self.context.thanksPageOverride:
data, errors = self.extractData()
if errors:
return
data = self.updateServerSideData(data)
self.thanksPage = True
self.template = self.thank_you_template
if self.context.showFields:
self.fields = self.setThanksFields(self.base_fields)
for group in self.groups:
group.fields = self.setThanksFields(
self.base_groups.get(group.label))
self.mode = DISPLAY_MODE
# we need to update the widgets in display mode again
super(EasyFormForm, self).update()
prologue = self.context.thanksPrologue
epilogue = self.context.thanksEpilogue
self.thanksPrologue = prologue and dollar_replacer(
prologue.output, data)
self.thanksEpilogue = epilogue and dollar_replacer(
epilogue.output, data)
alsoProvides(self.request, IEasyFormThanksPage)
def testViewlet(self):
viewlets = self._get_viewlets(self.portal, 'plone.htmlhead.links')
self.assertFalse(VIEWLET_NAME in viewlets.keys())
alsoProvides(self.portal, IOpengraphable)
viewlets = self._get_viewlets(self.portal, 'plone.htmlhead.links')
self.assertTrue(VIEWLET_NAME in viewlets.keys())
def __call__(self):
alsoProvides(self, IViewView)
manager = queryMultiAdapter(
(self.context, self.request, self),
IViewletManager, name='plone.belowcontent'
)
viewlet = queryMultiAdapter(
(self.context, self.request, self, manager),
IViewlet, name='plone.comments'
)
if viewlet is not None:
viewlet.form = TileCommentForm
viewlet.update()
if isinstance(viewlet.form, TileCommentForm):
viewlet.form.action = self.url
# Fix submit redirect from tile to context
if 'location' in self.request.response.headers:
location = self.request.response.getHeader('location')
self.request.response.redirect(''.join([
self.context.absolute_url(), '#', location.split('#')[-1]
]))
return protect(u'<html><body>%s</body></html>' % viewlet.render())
else:
return u'<html><body></body></html>'
def __call__(self, *args, **kw):
obj = self._callable(*args, **kw)
if self.provides:
alsoProvides(obj, self.provides)
obj.title = kw.pop("title", self.title)
obj.description = kw.pop("description", self.description)
return obj
def _fixup_zope_interface():
# Make sure the provided and implementedBy objects
# can be iterated.
# Note that we DO NOT use the _iteratorChecker, but instead
# we use NoProxy to be sure that the results (of iteration or not) are not
# proxied. On Python 2, these objects are builtin and don't go through the
# checking process at all, much like BTrees, so NoProxy is necessary for
# compatibility. On Python 3, prior to this, iteration was simply not allowed.
from zope.interface import providedBy
from zope.interface import alsoProvides
class I1(Interface):
pass
class I2(Interface):
pass
@implementer(I1)
class O(object):
pass
o = O()
# This will be athe zope.interface.implementedBy from the class
# a zope.interface.declarations.Implements
_default_checkers[type(providedBy(o))] = NoProxy
alsoProvides(o, I2)
# This will be the zope.interface.Provides from the instance
_default_checkers[type(providedBy(o))] = NoProxy
def test_deny_dublincore_view(self):
"""Tests the denial of dublincore view permissions to anonymous.
Users who can view a folder contents page but cannot view dublin core
should still be able to see the folder items' names, but not their
title, modified, and created info.
"""
# add an item that can be viewed from the root folder
obj = OrderedContainer()
alsoProvides(obj, IAttributeAnnotatable)
self.getRootFolder()['obj'] = obj
IZopeDublinCore(obj).title = u'My object'
# deny zope.app.dublincore.view to zope.Anonymous
prm = IRolePermissionManager(self.getRootFolder())
prm.denyPermissionToRole('zope.dublincore.view', 'zope.Anonymous')
# Try both spellings just in case we are used with an older zope.dc
prm.denyPermissionToRole('zope.app.dublincore.view', 'zope.Anonymous')
transaction.commit()
response = self.publish('/')
self.assertEquals(response.getStatus(), 200)
body = response.getBody()
# confirm we can see the file name
self.assert_(body.find('<a href="obj">obj</a>') != -1)
# confirm we *cannot* see the metadata title
self.assert_(body.find('My object') == -1)
def test_converter_RelationList(self):
from plone.app.z3cform.converters import RelatedItemsDataConverter
from z3c.relationfield.interfaces import IRelationList
field = List()
alsoProvides(field, IRelationList)
brain1 = Mock(getObject=Mock(return_value='obj1'), UID='id1')
brain2 = Mock(getObject=Mock(return_value='obj2'), UID='id2')
portal_catalog = Mock(return_value=[brain1, brain2])
widget = Mock(separator=';')
converter = RelatedItemsDataConverter(field, widget)
self.assertEqual(converter.toWidgetValue(None), None)
with mock.patch(
'plone.app.z3cform.converters.IUUID',
side_effect=['id1', 'id2']
):
self.assertEqual(
converter.toWidgetValue(['obj1', 'obj2']), 'id1;id2')
self.assertEqual(converter.toFieldValue(None), None)
with mock.patch(
'plone.app.z3cform.converters.getToolByName',
return_value=portal_catalog):
self.assertEqual(
converter.toFieldValue('id1;id2'), ['obj1', 'obj2'])
def process(self):
alsoProvides(self.request, IDisableCSRFProtection)
""" do main work here """
context = api.content.get(path='/library/ws/resources')
computer_id = self.request.form.get('computerId','')
print computer_id
print idnormalizer.normalize(computer_id)
available = True
if int(self.request.form.get('status', -1)) <= 0:
available = False
brains = api.content.find(context=context, portal_type='polklibrary.type.computeravailability.models.resource', id=idnormalizer.normalize(computer_id))
if brains:
obj = brains[0].getObject()
obj.activated = available
obj.reindexObject()
self._data['status'] = 'Updated'
else:
obj = api.content.create(
type='polklibrary.type.computeravailability.models.resource',
title=computer_id,
container=context,
)
obj.activated = available
obj.resources = u"PC" # Default since most are
api.content.transition(obj=obj, transition='publish')
obj.reindexObject()
self._data['status'] = 'Created'
def factory(self):
#base = cachedItemMixin()
#base._key = self.key()
ci = type('SimpleItemMapperCachedItem', (cachedItemMixin,), {key:None for key in self.mapper.keys()})()
ci._key = self.key()
alsoProvides(ci, ICachedItem)
return ci
def __init__(self, portal_setup):
self.portal_setup = portal_setup
alsoProvides(portal_setup.REQUEST, IDuringUpgrade)
def setUp(self):
self.portal = self.layer['portal']
alsoProvides(self.portal.REQUEST, ISocialLikeLayer)
self.plugins = dict(getUtilitiesFor(IPlugin))
def setUp(self):
self.portal = self.layer['portal']
# Como nao eh um teste funcional, este objeto
# REQUEST precisa ser anotado com o browser layer
alsoProvides(self.portal.REQUEST, IBarraInstalada)
)
dexteritytextindexer.searchable('title')
title = schema.TextLine(title=_(u'label_title', default=u'Title'),
required=True)
dexteritytextindexer.searchable('description')
description = schema.Text(
title=_(u'label_description', default=u'Description'),
required=False,
missing_value=u'',
default=u'',
)
alsoProvides(IOpenGeverBase, form.IFormFieldProvider)
class IOpenGeverBaseMarker(Interface):
pass
class OpenGeverBase(metadata.MetadataBase):
def _get_title(self):
return self.context.title
def _set_title(self, value):
if isinstance(value, str):
raise ValueError('Title must be unicode.')
self.context.title = value
def provide_storagetype_interfaces(self, instance, storage_types):
"""Assign any selected storage type interfaces to the storage.
"""
for storage_type in storage_types:
inter = resolve(storage_type)
alsoProvides(instance, inter)
class IRelatedItems(Interface):
"""Behavior interface to make a Dexterity type support related items.
"""
if HAS_CONTENTTREE and not HAS_WIDGETS:
relatedItems = RelationList(title=_(u'label_related_items',
default=u'Related Items'),
default=[],
value_type=RelationChoice(
title=u"Related",
source=ObjPathSourceBinder()),
required=False)
else:
relatedItems = RelationList(
title=_(u'label_related_items', default=u'Related Items'),
default=[],
value_type=RelationChoice(
title=u"Related", vocabulary="plone.app.vocabularies.Catalog"),
required=False)
fieldset = Fieldset('categorization',
label=_(u'Categorization'),
fields=['relatedItems'])
IRelatedItems.setTaggedValue(FIELDSETS_KEY, [fieldset])
alsoProvides(IRelatedItems, IFormFieldProvider)
def __init__(self, context, request):
super(FolderContentsView, self).__init__(context, request)
alsoProvides(request, IContentsPage)
def setUp(self):
self.portal = self.layer["portal"]
self.request = self.layer["request"]
alsoProvides(self.request, IKitconceptDsgvoLayer)
self.view = api.content.get_view("export-users", self.portal, self.request)
from z3c.form import group, field
from plone.namedfile.interfaces import IImageScaleTraversable
from plone.namedfile.field import NamedImage, NamedFile
from plone.namedfile.field import NamedBlobImage, NamedBlobFile
from plone.app.z3cform.wysiwyg import WysiwygFieldWidget
from plone.app.textfield import RichText
from z3c.relationfield.schema import RelationList, RelationChoice
from plone.formwidget.contenttree import ObjPathSourceBinder
from plone.multilingualbehavior.directives import languageindependent
from collective import dexteritytextindexer
from interfaithclimate.signup import MessageFactory as _
# Interface class; used to define content-type schema.
class IStatement(form.Schema, IImageScaleTraversable):
"""
Statement
"""
form.widget(body=WysiwygFieldWidget)
body = schema.Text(title=u"Body")
pass
alsoProvides(IStatement, IFormFieldProvider)
def update(self):
super(Renderer, self).update()
z2.switch_on(self, request_layer=IFormLayer)
self.form = self.form(aq_inner(self.context), self.request)
alsoProvides(self.form, IWrappedForm)
self.form.update()
request=context.REQUEST,
)
utility = queryUtility(IPolls, name='collective.polls')
navigation_root = portal_state.navigation_root()
polls = utility.recent_polls(context=navigation_root,
show_all=False,
limit=999999)
values = [SimpleTerm(value='latest', title=_(u'Latest opened poll'))]
values.extend(
SimpleTerm(value=i.UID, title=i.Title.decode('utf-8')) for i in polls)
return SimpleVocabulary(values)
alsoProvides(PossiblePolls, IContextSourceBinder)
class IVotePortlet(IPortletDataProvider):
"""A portlet."""
header = schema.TextLine(
title=_(u'Header'),
description=_(u'The header for the portlet. Leave empty for none.'),
required=False,
)
poll = schema.Choice(
title=_(u'Poll'),
description=_(u'Which poll to show in the portlet.'),
required=True,
def fix_frontpage_permissions(self, portal):
if 'front-page' in portal:
obj = portal['front-page']
alsoProvides(obj, IHaveNoBreadCrumbs)
mp = obj.manage_permission
mp(permissions.View, ['Anonymous'], 1)
def reply(self):
# Disable CSRF protection
if "IDisableCSRFProtection" in dir(plone.protect.interfaces):
alsoProvides(self.request,
plone.protect.interfaces.IDisableCSRFProtection)
portal = getSite()
# validate important data
data = json_body(self.request)
self.errors = []
self.validate_input_data(portal, data)
security = getAdapter(self.context, ISecuritySchema)
registration = getToolByName(self.context, "portal_registration")
general_usage_error = (
"Either post to @users to create a user or use "
"@users/<username>/reset-password to update the password.")
if len(self.params) not in [0, 2]:
raise Exception(general_usage_error)
if len(self.params) == 2:
if self.params[1] == "reset-password":
return self.update_password(data)
raise Exception("Unknown Endpoint @users/%s/%s" % self.params)
# Add a portal member
if not self.can_add_member:
return self._error(403, "Forbidden",
"You need AddPortalMember permission.")
if self.errors:
self.request.response.setStatus(400)
return dict(error=dict(
type="WrongParameterError",
message="Error in fields. {}".format(self.errors_to_string()),
errors=self.errors,
))
username = data.pop("username", None)
email = data.pop("email", None)
password = data.pop("password", None)
roles = data.pop("roles", ["Member"])
send_password_reset = data.pop("sendPasswordReset", None)
properties = data
if PLONE5:
# We are improving the way the userid/login_name is generated using
# Plone's plone.app.users utilities directly. Plone 4 lacks of the
# login_name one, so we leave it as it is, improving the Plone 5
# story
user_id_login_name_data = {
"username": username,
"email": email,
"fullname": data.get("fullname", ""),
}
register_view = getMultiAdapter((self.context, self.request),
name="register")
register_view.generate_user_id(user_id_login_name_data)
register_view.generate_login_name(user_id_login_name_data)
user_id = user_id_login_name_data.get("user_id",
data.get("username"))
login_name = user_id_login_name_data.get("login_name",
data.get("username"))
username = user_id
properties["username"] = user_id
else:
# set username based on the login settings (username or email)
if security.use_email_as_login:
username = email
properties["username"] = email
else:
properties["username"] = username
properties["email"] = email
if not self.can_manage_users and not security.enable_user_pwd_choice:
send_password_reset = True
if send_password_reset:
password = registration.generatePassword()
# Create user
try:
registration = getToolByName(portal, "portal_registration")
user = registration.addMember(username,
password,
roles,
properties=properties)
except ValueError as e:
self.request.response.setStatus(400)
return dict(
error=dict(type="MissingParameterError", message=str(e)))
if PLONE5:
# After user creation, we have to fix the login_name if it differs.
# That happens when the email login is enabled and we are using
# UUID as user ID security settings.
if user_id != login_name:
# The user id differs from the login name. Set the login
# name correctly.
pas = getToolByName(self.context, "acl_users")
pas.updateLoginName(user_id, login_name)
if send_password_reset:
registration.registeredNotify(username)
self.request.response.setStatus(201)
self.request.response.setHeader(
"Location",
portal.absolute_url() + "/@users/" + username)
serializer = queryMultiAdapter((user, self.request), ISerializeToJson)
return serializer()
def setUp(self):
layer = self.globs['layer']
# Update global variables within the tests.
self.globs.update({
'portal': layer['portal'],
'portal_url': layer['portal'].absolute_url(),
'browser': Browser(layer['app']),
})
ztc.utils.setupCoreSessions(layer['app'])
portal = self.globs['portal']
browser = self.globs['browser']
portal_url = self.globs['portal_url']
browser.setBaseUrl(portal_url)
browser.handleErrors = True
portal.error_log._ignored_exceptions = ()
setRoles(portal, TEST_USER_ID, ['Manager'])
portal.invokeFactory('CartFolder', 'cfolder')
portal.invokeFactory(
'ShippingMethod',
'method01',
title="ShippingMethod01",
base_charge=10.0,
weight_charge=5.0,
)
method01 = portal.method01
method01.reindexObject()
## Create Product00
portal.invokeFactory(
'Document',
'doc00',
title='Product00',
description='Description of Product00',
)
doc00 = portal.doc00
alsoProvides(doc00, IAddableToCart)
IAnnotations(doc00)['collective.cart.core'] = ProductAnnotations()
product00 = IProduct(doc00)
product00.price = Decimal('100.00')
product00.unlimited_stock = True
product00.max_addable_quantity = 5
## Create Product01
portal.invokeFactory(
'Document',
'doc01',
title='Product01',
description='Description of Product01',
)
doc01 = portal.doc01
alsoProvides(doc01, IAddableToCart)
IAnnotations(doc01)['collective.cart.core'] = ProductAnnotations()
product01 = IProduct(doc01)
product01.price = Decimal('10.00')
product01.stock = 50
product01.max_addable_quantity = 30
## Create Product02
portal.invokeFactory(
'Document',
'doc02',
title='Product02',
description='Description of Product02',
)
doc02 = portal.doc02
alsoProvides(doc02, IAddableToCart)
IAnnotations(doc02)['collective.cart.core'] = ProductAnnotations()
product02 = IProduct(doc02)
product02.price = Decimal('5.00')
product02.stock = 20
product02.max_addable_quantity = 50
transaction.commit()
"""Add SQL content"""
sql_id = schema.Choice(
title=_(u"label_sql_id", default=u"SQL Item ID"),
description=_(u"help_sql_id_column",
default=u"The ID of the SQL content item"),
required=False,
vocabulary="collective.behavior.sql.AvailableSQLAlchemyItemIDs")
form.omitted('sql_virtual')
sql_virtual = schema.Bool(title=_(u"label_sql_virtual",
default=u"SQL Virtual"),
default=False)
alsoProvides(ISQLContent['sql_id'], ILanguageIndependentField)
@implementer(ISchemaPlugin)
class SQLContentSchemaAdapter(object):
def __call__(self):
raise ValueError(self)
@implementer(ISQLContent)
@adapter(IDexterityContent)
class SQLContent(object):
def __init__(self, context):
self.context = context
def _get_sql_id(self):
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer["request"]
alsoProvides(self.request, IFormLayer)
self.view = FaleConoscoForm(self.portal, self.request)
self.request.form['form.widgets.nome'] = '123123132131'
# changes title and buttons (what to add) in view for AceItem
# extracted from JAVA code:
_datatypes = """
acesearch-datainfotype-lbl-DOCUMENT=Publications and reports
acesearch-datainfotype-lbl-INFORMATIONSOURCE=Information portals
acesearch-datainfotype-lbl-MAPGRAPHDATASET=Maps, graphs and datasets
acesearch-datainfotype-lbl-INDICATOR=Indicators
acesearch-datainfotype-lbl-GUIDANCE=Guidance
acesearch-datainfotype-lbl-TOOL=Tools
acesearch-datainfotype-lbl-RESEARCHPROJECT=Research and knowledge projects
acesearch-datainfotype-lbl-ORGANISATION=Organisations
acesearch-datainfotype-lbl-MEASURE=Adaptation options
acesearch-datainfotype-lbl-ACTION=Case studies
"""
aceitem_datatypes_vocabulary = vocab_from_labels(_datatypes)
alsoProvides(aceitem_datatypes_vocabulary, IVocabularyFactory)
# changes how the view for AceItem behaves (what it shows)
_storagetypes = [
"PLAINMETADATA",
"PROJECT",
"MAPLAYER",
"URL",
"SETOFMAPS",
"MEASURE",
]
aceitem_storagetypes_vocabulary = generic_vocabulary(_storagetypes)
alsoProvides(aceitem_storagetypes_vocabulary, IVocabularyFactory)
_sectors = """
acesearch-sectors-lbl-AGRICULTURE=Agriculture and Forest
title=_(u"Subtitle file"),
description=_(u"Provide a file in srt format"),
required=False)
form.omitted('metadata')
metadata = schema.Text(required=False)
transcript = RichText(title=_(u"Transcript"),
default_mime_type='text/html',
output_mime_type='text/html',
allowed_mime_types=('text/html', 'text/plain'),
default=u"",
required=False)
alsoProvides(IVideo, IFormFieldProvider)
class IAudio(model.Schema):
# main file will always be converted to mp4
form.widget(audio_file=StreamNamedFileFieldWidget)
model.primary('audio_file')
audio_file = namedfile.NamedBlobFile(title=_(u"Audio File"),
description=u"",
required=True,
constraint=valid_audio)
form.omitted('metadata')
metadata = schema.Text(required=False)
def __init__(self, context, request):
alsoProvides(request, IDisableCSRFProtection)
self.context = context
self.request = request
self.no_duplicate_login = context.unrestrictedTraverse(
"acl_users/no_duplicate_login")
class IOGMailMarker(Interface):
"""Marker Interface for opengever mails."""
class IOGMail(form.Schema):
"""Opengever specific behavior,
which add a title Field to the form."""
dexteritytextindexer.searchable('title')
title = schema.TextLine(
title=_(u'label_title', default=u'Title'),
required=False,
)
alsoProvides(IOGMail, IFormFieldProvider)
class OGMail(Item):
"""Opengever specific mail class."""
@property
def msg(self):
""" returns an email.Message instance
(copied from ftw.mail inheritance hasn't worked)
"""
if self.message is not None:
data = self.message.data
temp_msg = email.message_from_string(data)
if temp_msg.get('Subject') and '\n\t' in temp_msg['Subject']:
# It's a long subject header than has been separated by
# line break and tab - fix it
def setUp(self):
# Make sure our browserlayer is applied
alsoProvides(IPloneLoginLayer)
self.browser = Browser(self.layer['app'])
) # makes sure repo has all branches and tags, cleans out old
try:
r.head.reference
except TypeError:
r.head.reference = r.heads[
0] # make sure we're not in a detached head state (otherwise, pull won't work)
r.head.reset(index=True, working_tree=True)
origin.pull()
#the git file provider factory expects a config with both 'GitReposBaseDir'
# and MellonSnippet. We have both of those...but not in the same
# namespace. We'll create a new config that contains our desired
# values.
config = component.createObject(u'sparc.configuration.container.dict')
config['GitReposBaseDir'] = self.config['StashProjectRepos'][
'GitReposBaseDir']
config['MellonSnippet'] = self.config['MellonSnippet']
git_file_provider = component.createObject(\
u'mellon.factories.git.file_provider_from_git_repos_base_directory',
config)
for f in git_file_provider:
yield f
MellonFileProviderFromStashConfigFactory = Factory(
MellonFileProviderFromStashConfig)
interface.alsoProvides(MellonFileProviderFromStashConfigFactory,
IMellonFileProviderFactory)
def feed_to_microsite(self):
alsoProvides(self.context, IMicroSiteFeed)
self.context.reindexObject(idxs=['object_provides'])
url = self.context.absolute_url()
return self.request.response.redirect(url)
def _update(self):
if self.available:
z2.switch_on(self, request_layer=IFormLayer)
self.form = self.form(aq_inner(self.context), self.request)
alsoProvides(self.form, IWrappedForm)
self.form.update()
def driver(request, driver_interface):
""" All drivers """
mock = Mock()
alsoProvides(mock, driver_interface)
return mock
if nm not in terms:
terms[nm] = vocabulary.SimpleTerm(
nm,
nm.encode('base64').strip(),
i18n.Message(UTILITY_TITLE, mapping={'name': nm}))
if isPAU:
for nm in set(getattr(context, attr_name)):
if nm not in terms:
terms[nm] = vocabulary.SimpleTerm(
nm,
nm.encode('base64').strip(),
i18n.Message(MISSING_TITLE, mapping={'name': nm}))
return vocabulary.SimpleVocabulary(
[term for nm, term in sorted(terms.items())])
def authenticatorPlugins(context):
return _pluginVocabulary(context, interfaces.IAuthenticatorPlugin,
'authenticatorPlugins')
interface.alsoProvides(authenticatorPlugins, IVocabularyFactory)
def credentialsPlugins(context):
return _pluginVocabulary(context, interfaces.ICredentialsPlugin,
'credentialsPlugins')
interface.alsoProvides(credentialsPlugins, IVocabularyFactory)
u'label_dossier_manager',
default=u'Dossier manager',
),
description=_(
u'description_dossier_manager',
default=(
u'This user or group will get the dossier manager role after '
u'protecting the dossier.')),
source=AllUsersAndGroupsSourceBinder(),
defaultFactory=current_user,
required=False,
missing_value=None,
)
alsoProvides(IProtectDossier, IFormFieldProvider)
class DossierProtection(AnnotationsFactoryImpl):
"""Implement protected dossiers."""
READING_ROLES = [
'Reader',
]
READING_AND_WRITING_ROLES = READING_ROLES + [
'Editor',
'Contributor',
'Reviewer',
'Publisher',
]
changeNote = schema.TextLine(
title=_(u'label_change_note', default=u'Change Note'),
description=_(
u'help_change_note',
default=u'Enter a comment that describes the changes you made. '
u'If versioning is manual, you must set a change note '
u'to create the new version.'),
required=False)
form.omitted('changeNote')
form.no_omit(IEditForm, 'changeNote')
form.no_omit(IAddForm, 'changeNote')
alsoProvides(IVersionable, IFormFieldProvider)
class IVersioningSupport(Interface):
"""
Marker Interface for the IVersionable behavior.
"""
@implementer(IVersionable)
class Versionable(object):
""" The Versionable adapter prohibits dexterity from saving the changeNote
on the context. It stores it in a request-annotation for later use in
event-handlers
"""
adapts(IDexterityContent)
def refresh_issue(self, REQUEST=None): # noqa
"""Refresh the aggregate body when using collections.
"""
alsoProvides(self.request, IDisableCSRFProtection)
self.context.loadContent()
self.request.response.redirect(self.context.absolute_url())
submission_whole_day = Bool(title=_(u'All day'), required=False)
submission_recurrence = Text(title=_(u'Recurrence'), required=False)
submission_days = List(title=_(u'On these days'),
value_type=Choice(vocabulary=days),
required=False,
default=days.keys)
form.widget('submission_recurrence',
RecurrenceWidget,
start_field='IEventSubmissionData.submission_date',
first_day=first_weekday_sun0)
alsoProvides(IEventSubmissionData, IFormFieldProvider)
class IExternalEventSource(form.Schema):
"""Marker for external event sources (content type)"""
title = TextLine(title=_(u'Name'), )
enabled = Bool(title=_(u'Enabled'), required=True, default=True)
limit = Int(
title=_(u'Limit'),
description=_(u'The number of events to import every 15 minutes.'),
required=True,
default=25)
