def __init__(self, filename, contentType='text/html', form=None,
request=None):
self.template = ViewPageTemplateFile(filename, content_type=contentType)
zope.component.adapter(
util.getSpecification(form),
util.getSpecification(request))(self)
zope.interface.implementer(IPageTemplate)(self)
def WidgetValidatorDiscriminators(
validator, context=None, request=None, view=None, field=None, widget=None):
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(field),
util.getSpecification(widget))(validator)
def WidgetValidatorDiscriminators(
validator, context=None, request=None, view=None, field=None, widget=None):
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(field),
util.getSpecification(widget))(validator)
def WidgetsValidatorDiscriminators(
validator,
context=None, request=None, view=None, schema=None, manager=None):
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(schema),
util.getSpecification(manager))(validator)
def WidgetsValidatorDiscriminators(
validator,
context=None, request=None, view=None, schema=None, manager=None):
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(schema),
util.getSpecification(manager))(validator)
def __init__(self, filename, contentType='text/html',
context=None, request=None, view=None,
field=None, widget=None):
self.template = ViewPageTemplateFile(filename, content_type=contentType)
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(field),
util.getSpecification(widget))(self)
zope.interface.implementer(interfaces.IWidgetLayoutTemplate)(self)
def __init__(self, filename, contentType='text/html',
context=None, request=None, view=None,
field=None, widget=None):
self.template = ViewPageTemplateFile(filename, content_type=contentType)
zope.component.adapter(
util.getSpecification(context),
util.getSpecification(request),
util.getSpecification(view),
util.getSpecification(field),
util.getSpecification(widget))(self)
zope.interface.implementer(interfaces.IWidgetLayoutTemplate)(self)
def _disable_custom_widget(field):
base.unregisterAdapter(
required=(
getSpecification(field),
IWidgetsLayer,
),
provided=IFieldWidget,
)
def _add_validator(self, field, value):
validator = resolveDottedName(value)
if not IValidator.implementedBy(validator):
raise ValueError(
"z3c.form.interfaces.IValidator not implemented by %s."
% value)
provideAdapter(validator,
(None, None, None, getSpecification(field), None),
IValidator,
)
def addHandler(self, button, handler):
"""See interfaces.IButtonHandlers"""
# Create a specification for the button
buttonSpec = util.getSpecification(button)
if isinstance(buttonSpec, util.classTypes):
buttonSpec = zope.interface.implementedBy(buttonSpec)
# Register the handler
self._registry.register(
(buttonSpec,), interfaces.IButtonHandler, '', handler)
self._handlers += ((button, handler),)
def _add_validator(self, field, value):
validator = resolveDottedName(value)
if not IValidator.implementedBy(validator):
msg = 'z3c.form.interfaces.IValidator not implemented by {0}.'
raise ValueError(msg.format(value))
provideAdapter(
validator,
(None, None, None, getSpecification(field), None),
IValidator,
)
def addHandler(self, button, handler):
"""See interfaces.IButtonHandlers"""
# Create a specification for the button
buttonSpec = util.getSpecification(button)
if isinstance(buttonSpec, util.classTypes):
buttonSpec = zope.interface.implementedBy(buttonSpec)
# Register the handler
self._registry.register((buttonSpec, ), interfaces.IButtonHandler, '',
handler)
self._handlers += ((button, handler), )
def ErrorViewDiscriminators(errorView, error=None, request=None, widget=None, field=None, form=None, content=None):
zope.component.adapter(
util.getSpecification(error),
util.getSpecification(request),
util.getSpecification(widget),
util.getSpecification(field),
util.getSpecification(form),
util.getSpecification(content),
)(errorView)
class EmailValidator(validator.SimpleFieldValidator, grok.MultiAdapter):
grok.adapts(Interface, Interface, Interface,
util.getSpecification(ISubscriberSchema['title']), Interface)
grok.provides(IValidator)
def validate(self, value):
super(EmailValidator, self).validate(value)
subscriber = type('subscriber', (object, ), dict(title=value))
if ISubscriberSchema.providedBy(self.context):
container = self.context.__parent__
checkEmailUniqueness(container, self.context.__name__, subscriber)
return
checkEmailUniqueness(self.context, None, subscriber)
def __call__(self, value, **kws):
# Step 1: Check that the keyword argument names match the
# discriminators
if set(kws).difference(set(self.discriminators)):
raise ValueError('One or more keyword arguments did not match the '
'discriminators.')
# Step 2: Create an attribute value factory
factory = ValueFactory(value, self.valueClass, self.discriminators)
# Step 3: Build the adaptation signature
signature = []
for disc in self.discriminators:
spec = util.getSpecification(kws.get(disc))
signature.append(spec)
# Step 4: Assert the adaptation signature onto the factory
zope.component.adapter(*signature)(factory)
zope.interface.implementer(interfaces.IValue)(factory)
return factory
def __call__(self, value, **kws):
# Step 1: Check that the keyword argument names match the
# discriminators
if set(kws).difference(set(self.discriminators)):
raise ValueError(
'One or more keyword arguments did not match the '
'discriminators.')
# Step 2: Create an attribute value factory
factory = ValueFactory(value, self.valueClass, self.discriminators)
# Step 3: Build the adaptation signature
signature = []
for disc in self.discriminators:
spec = util.getSpecification(kws.get(disc))
signature.append(spec)
# Step 4: Assert the adaptation signature onto the factory
zope.component.adapter(*signature)(factory)
zope.interface.implementer(interfaces.IValue)(factory)
return factory
def ErrorViewDiscriminators(errorView,
error=None,
request=None,
widget=None,
field=None,
form=None,
content=None):
zope.component.adapter(util.getSpecification(error),
util.getSpecification(request),
util.getSpecification(widget),
util.getSpecification(field),
util.getSpecification(form),
util.getSpecification(content))(errorView)
# -*- coding: utf-8 -*-
"""Module providing subject widget adapter"""
from collective.z3cform.widgets.token_input_widget import TokenInputFieldWidget
from plone.app.dexterity.behaviors.metadata import ICategorization
from plone.app.z3cform.interfaces import IPloneFormLayer
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from z3c.form.widget import FieldWidget
from zope.component import adapter
from zope.interface import implementer
@adapter(getSpecification(ICategorization['subjects']), IPloneFormLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
widget = FieldWidget(field, TokenInputFieldWidget(field, request))
return widget
default=1000,
min=1,
)
view_template = schema.Choice(title=_(u"Display mode"),
source=_(u"Available Listing Views"),
required=True)
class IContentListingTileLayer(Interface):
"""Layer (request marker interface) for content listing tile views"""
@implementer(IValue)
@adapter(None, None, None, getSpecification(IContentListingTile['query']), None) # noqa
class DefaultQuery(object):
def __init__(self, context, request, form, field, widget):
self.context = context
def get(self):
if IFolderish.providedBy(self.context):
return [{
'i': 'path',
'o': 'plone.app.querystring.operation.string.relativePath',
'v': '::1'
}]
else:
return [{
'i': 'path',
'o': 'plone.app.querystring.operation.string.relativePath',
payload = schema.Text(
title=_(u"JSON Payload"),
description=_(u"The message you want to publish in JSON"),
required=False,
constraint=validate_payload,
default="""\
{
"text": "Hello ${title}!",
"destination": "${url}"
}
""",
)
@implementer(IValidator)
@adapter(None, None, None, getSpecification(IWebSocketAction["payload"]), None)
class PayloadValidator(object):
def __init__(self, context, request, form, field, widget):
self.field = field
def validate(self, value):
try:
if value is not None:
json.loads(value)
except (ValueError, TypeError) as e:
raise Invalid(e)
@implementer(IWebSocketAction, IRuleElementData)
class WebSocketAction(SimpleItem):
"""
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from zope.component import adapter
from zope.interface import implementer
from zope.interface import implements
import json
import z3c.form.widget
class MinSizeImageWidget(NamedImageWidget):
"""A widget for a named file object
"""
implements(IMinSizeImageWidget)
def pattern_options(self):
# provide the pattern options
return json.dumps({'minHeight': 300, 'minWidth': 300})
def render(self):
# add the registered resource
add_resource_on_request(self.request, 'exercise7')
return super(MinSizeImageWidget, self).render()
@adapter(getSpecification(ILeadImage['image']), IExercise7Layer)
@implementer(IFieldWidget)
def LeadImageMinSizeImageFieldWidget(field, request):
widget = z3c.form.widget.FieldWidget(field, MinSizeImageWidget(request))
return widget
if invitations_nr > allowed:
if allowed <= 0:
msg = _(u'error_participation_quota_reached',
default=u'The participation quota is reached, '
'you cannot add any further participants.')
else:
msg = _('error_too_many_participants',
default=u'You cannot invite so many participants '
'any more. Can only add ${num} more participants.',
mapping={'num': allowed})
raise Invalid(msg)
return errors
WidgetsValidatorDiscriminators(NumberOfAdressesAndUsersValidator,
schema=getSpecification(IInviteSchema,
force=True))
provideAdapter(NumberOfAdressesAndUsersValidator)
class RolesValidator(SimpleFieldValidator):
"""Validator for validating the e-mail addresses field
"""
def validate(self, roles):
registry = getUtility(IRegistry)
config = registry.forInterface(IParticipationRegistry)
if not config.allow_multiple_roles and not roles:
msg = _(u'error_no_roles', default=u'Please select a role')
raise Invalid(msg)
'required': self.required,
'allow_nochange': self.allow_nochange,
'name': self.name,
'disabled': self.disabled,
'maxlength': self.maxlength
}
is_string = isinstance(self.value, basestring)
if (IReferenceNamedImage.providedBy(self.value)
or (is_string and self.value.startswith('reference:'))):
result.update(self.get_reference_options())
else:
result.update(self.get_image_options())
return json.dumps(result)
@adapter(getSpecification(ILeadImage['image']), ICastleLayer)
@implementer(IFieldWidget)
def LeadImageFocalNamedImageFieldWidget(field, request):
widget = z3c.form.widget.FieldWidget(field, FocalNamedImageWidget(request))
return widget
@adapter(getSpecification(IRequiredLeadImage['image']), ICastleLayer)
@implementer(IFieldWidget)
def RequiredLeadImageFocalNamedImageFieldWidget(field, request):
widget = z3c.form.widget.FieldWidget(field, FocalNamedImageWidget(request))
return widget
@adapter(INamedImageField, ICastleLayer)
@implementer(IFieldWidget)
@implementer(IFieldWidget)
def AjaxSelectFieldWidget(field, request, extra=None):
if extra is not None:
request = extra
return FieldWidget(field, AjaxSelectWidget(request))
@implementer(IFieldWidget)
def RelatedItemsFieldWidget(field, request, extra=None):
if extra is not None:
request = extra
return FieldWidget(field, RelatedItemsWidget(request))
if HAS_PAC:
@adapter(getSpecification(IDXCollection['query']), IFormLayer)
@implementer(IFieldWidget)
def QueryStringFieldWidget(field, request):
return FieldWidget(field, QueryStringWidget(request))
@adapter(getSpecification(IRichText['text']), IFormLayer)
@implementer(IFieldWidget)
def RichTextFieldWidget(field, request):
return FieldWidget(field, RichTextWidget(request))
class MockRequest(TestRequest):
implements(IWidgetsLayer)
class DXFieldPermissionChecker(object):
def _enable_custom_widget(field):
provideAdapter(_custom_field_widget, adapts=
(getSpecification(field), IWidgetsLayer),
provides=IFieldWidget)
return value
@implementer(IDataConverter)
class PatDatePickerDataConverter(DateDataConverter):
"""A special data converter for dates."""
adapts(IDate, IPatDatePickerWidget)
def toFieldValue(self, value):
"""See interfaces.IDataConverter"""
if isinstance(value, datetime):
return value
return super(PatDatePickerDataConverter).toFieldValue(value)
@adapter(getSpecification(IEventBasic['start']), IPloneintranetFormLayer)
@implementer(IFieldWidget)
def StartPatDatePickerFieldWidget(field, request):
return FieldWidget(field, PatDatePickerWidget(request))
@adapter(getSpecification(IEventBasic['end']), IPloneintranetFormLayer)
@implementer(IFieldWidget)
def EndPatDatePickerFieldWidget(field, request):
return FieldWidget(field, PatDatePickerWidget(request))
@adapter(getSpecification(IBaseWorkspaceFolder['archival_date']),
IWorkspaceAppFormLayer)
@implementer(IFieldWidget)
def ArchivalDatePickerFieldWidget(field, request):
from z3c.form.widget import FieldWidget
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from zope.interface import implementer
from zope.component import adapter
from plone.app.dexterity.behaviors.metadata import ICategorization
from plone.app.dexterity.behaviors.metadata import IOwnership
from plone.app.widgets.dx.select2 import TagsWidget
from plone.app.widgets.interfaces import IWidgetsLayer
@adapter(getSpecification(ICategorization['subjects']), IWidgetsLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
widget = FieldWidget(field, TagsWidget(request))
widget.ajax_suggest = 'plone.app.vocabularies.Keywords'
return widget
@adapter(getSpecification(IOwnership['contributors']), IWidgetsLayer)
@implementer(IFieldWidget)
def ContributorsFieldWidget(field, request):
widget = FieldWidget(field, TagsWidget(request))
widget.ajax_suggest = 'plone.app.vocabularies.Users'
return widget
@adapter(getSpecification(IOwnership['creators']), IWidgetsLayer)
@implementer(IFieldWidget)
def CreatorsFieldWidget(field, request):
widget = FieldWidget(field, TagsWidget(request))
try:
from plone.app.relationfield.behavior import IRelatedItems
HAS_RF = True
except ImportError:
HAS_RF = False
try:
from plone.app.contenttypes.behaviors.collection import ICollection
from plone.app.contenttypes.behaviors.richtext import IRichText
HAS_PAC = True
except ImportError:
HAS_PAC = False
@adapter(getSpecification(ICategorization['subjects']), IWidgetsLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
widget = FieldWidget(field, AjaxSelectWidget(request))
widget.vocabulary = 'plone.app.vocabularies.Keywords'
return widget
@adapter(getSpecification(ICategorization['language']), IWidgetsLayer)
@implementer(IFieldWidget)
def LanguageFieldWidget(field, request):
widget = FieldWidget(field, SelectWidget(request))
return widget
@adapter(getSpecification(IPublication['effective']), IWidgetsLayer)
from zope.i18nmessageid import MessageFactory
# Set up the i18n message factory for our package
MessageFactory = MessageFactory('collective.publications')
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from z3c.form.interfaces import IFormLayer
from plone.app.dexterity.behaviors.metadata import ICategorization
from five import grok
from collective.z3cform.widgets.token_input_widget import TokenInputFieldWidget
def SubjectsFieldWidget(field, request):
field.index_name = 'Subject'
return TokenInputFieldWidget(field, request)
grok.global_adapter(
SubjectsFieldWidget,
(getSpecification(ICategorization['subjects']),
IFormLayer),
IFieldWidget,
)
try:
dr = DateRange(obj.first, obj.last)
try:
validateTermsForOverlap(self.view.context, dr, None)
except TermOverlapError, e:
errors += (e, )
except ValueError, e:
errors += (Invalid(_("Term must begin before it ends.")), )
except NoInputData:
return errors
return errors
WidgetsValidatorDiscriminators(
AddTermFormValidator,
view=TermAddForm,
schema=getSpecification(ITermForm, force=True))
class EditTermFormValidator(InvariantsValidator):
def validateObject(self, obj):
errors = super(EditTermFormValidator, self).validateObject(obj)
try:
dr = DateRange(obj.first, obj.last)
try:
validateTermsForOverlap(self.view.context.__parent__, dr,
self.view.context)
except TermOverlapError, e:
errors += (e, )
except ValueError, e:
errors += (Invalid(_("Term must begin before it ends.")), )
# -*- coding: UTF-8 -*-
from collective.z3cform.widgets.token_input_widget import TokenInputFieldWidget
from plone.app.dexterity.behaviors.metadata import ICategorization
from plone.app.z3cform.interfaces import IPloneFormLayer
from z3c.form.interfaces import IFieldWidget
from z3c.form.util import getSpecification
from z3c.form.widget import FieldWidget
from zope.component import adapter
from zope.interface import implementer
@adapter(getSpecification(ICategorization['subjects']), IPloneFormLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
widget = FieldWidget(field, TokenInputFieldWidget(field, request))
return widget
""" Recurring Event Schema.
"""
recurrence = schema.Text(
title=_(
u'label_event_recurrence',
default=u'Recurrence'
),
description=_(
u'help_event_recurrence',
default=u'Define the event recurrence rule.'
),
required=False
)
@adapter(getSpecification(IEventRecurrence['recurrence']), IPloneFormLayer)
@implementer(IFieldWidget)
def RecurrenceFieldWidget(field, request):
# Please note: If you create a new behavior with superclasses IEventBasic
# and IRecurrence, then you have to reconfigure the dotted path value of
# the start_field parameter for the RecurrenceWidget to the new
# behavior name, like: IMyNewBehaviorName.start.
widget = FieldWidget(field, RecurrenceWidget(request))
widget.start_field = 'IEventBasic.start'
widget.first_day = first_weekday_sun0
widget.show_repeat_forever = False
return widget
class IEventLocation(model.Schema):
""" Event Location Schema.
keyword = data.get('keyword', None)
objects = data.get('ccaitems', [])
if keyword:
for obj in objects:
if isinstance(obj.keywords, (list, tuple)):
obj.keywords = list(obj.keywords)
obj.keywords.append(keyword)
obj._p_changed = True
obj.reindexObject()
self.status = "Keyword added"
return self.status
@adapter(getSpecification(IAddKeywordForm['ccaitems']), IWidgetsLayer)
@implementer(IFieldWidget)
def CcaItemsFieldWidget(field, request):
""" The vocabulary view is overridden so that
the widget will show all cca items
Check browser/overrides.py for more details
"""
widget = FieldWidget(field, RelatedItemsWidget(request))
widget.vocabulary = 'eea.climateadapt.cca_items'
widget.vocabulary_override = True
return widget
class KeywordsAdminView (BrowserView):
""" Custom view for the administration of keywords
class CommaSeparatedConverter(BaseDataConverter):
adapts(ITuple, ICommaSeparatedWidget)
def toFieldValue(self, value):
"""Return the tuple of strings
:rtype tuple of strings:
"""
if value is None:
return self.field.missing_value
return value
# plone intranet uses a dublincore override
@adapter(getSpecification(pi_IDublinCore['subjects']), IWorkspaceAppFormLayer)
@implementer(IFieldWidget)
def CommaSeparatedFieldWidget(field, request):
return FieldWidget(field, CommaSeparatedWidget(request))
class IPatDatePickerWidget(IWidget):
""" Marker interface """
@implementer_only(IPatDatePickerWidget)
class PatDatePickerWidget(Widget):
"""pat-date-picker gives us a list of strings with the date first and the
time second. To extract the value we need to convert that to a datetime
object.
if widget is not None:
return self._wrap_widget(widget.render())
return u'<html></html>'
_titleDisplayTemplate = ViewPageTemplateFile('templates/title.pt',
content_type='text/html')
_descriptionDisplayTemplate = ViewPageTemplateFile('templates/description.pt',
content_type='text/html')
_namedImageDisplayTemplate = ViewPageTemplateFile('templates/namedimage.pt',
content_type='text/html')
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, DexterityFieldTile,
getSpecification(IDublinCore['title']), TextWidget)
def titleDisplayTemplate(context, request, form, field, widget):
return _titleDisplayTemplate
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, DexterityFieldTile,
getSpecification(IDublinCore['description']), TextAreaWidget)
def descriptionDisplayTemplate(context, request, form, field, widget):
return _descriptionDisplayTemplate
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, IDexterityFieldTileFormOrGroup, None,
NamedImageWidget)
def namedImageDisplayTemplate(context, request, form, field, widget):
def _disable_custom_widget(field):
base.unregisterAdapter(
required=(getSpecification(field), IPloneFormLayer, ),
provided=IFieldWidget,
)
class CommaSeparatedConverter(BaseDataConverter):
adapts(ITuple, ICommaSeparatedWidget)
def toFieldValue(self, value):
"""Return the tuple of strings
:rtype tuple of strings:
"""
if value is None:
return self.field.missing_value
return value
# plone intranet uses a dublincore override
@adapter(getSpecification(pi_IDublinCore['subjects']), IWorkspaceAppFormLayer)
@implementer(IFieldWidget)
def CommaSeparatedFieldWidget(field, request):
return FieldWidget(field, CommaSeparatedWidget(request))
class IPatDatePickerWidget(IWidget):
""" Marker interface """
@implementer_only(IPatDatePickerWidget)
class PatDatePickerWidget(Widget):
"""pat-date-picker gives us a list of strings with the date first and the
time second. To extract the value we need to convert that to a datetime
object.
#except validator.NoInputData:
# return errors
#return errors
return []
class SelectedPeriodsAddFormValidator(validator.InvariantsValidator):
def getOthers(self, schedule):
container = self.context
return container.values()
validator.WidgetsValidatorDiscriminators(
SelectedPeriodsAddFormValidator,
view=SelectedPeriodsAddView,
schema=getSpecification(ISelectedPeriodsAddForm, force=True))
class SelectedPeriodsContent(ContentProvider):
implements(IRenderDayTableCells)
def __init__(self, *args, **kw):
ContentProvider.__init__(self, *args, **kw)
self.owner = IHaveSchedule(self.context)
def renderCells(self, schedule, day, item):
timetable = self.context.timetable
if sameProxiedObjects(schedule, timetable.periods):
if self.context.hasPeriod(item):
return (item.title,
self.owner.title)
from plone.app.z3cform.interfaces import IDateField, IDatetimeField
@adapter(IDateField, IFormLibraryProductLayer)
@implementer(IFieldWidget)
def TypeADateFieldWidget(field, request, extra=None):
return FieldWidget(field, TypeADateWidget(request))
@adapter(IDatetimeField, IFormLibraryProductLayer)
@implementer(IFieldWidget)
def TypeADatetimeFieldWidget(field, request, extra=None):
return FieldWidget(field, TypeADatetimeWidget(request))
@adapter(getSpecification(IPublication["effective"]), IFormLibraryProductLayer)
@implementer(IFieldWidget)
def EffectiveDateFieldWidget(field, request):
widget = FieldWidget(field, TypeADatetimeWidget(request))
widget.pattern_options.setdefault("date", {})
widget.pattern_options["date"]["firstDay"] = first_weekday()
return widget
@adapter(getSpecification(IPublication["expires"]), IFormLibraryProductLayer)
@implementer(IFieldWidget)
def ExpirationDateFieldWidget(field, request):
widget = FieldWidget(field, TypeADatetimeWidget(request))
widget.pattern_options.setdefault("date", {})
widget.pattern_options["date"]["firstDay"] = first_weekday()
return widget
try:
from plone.app.widgets.interfaces import IWidgetsLayer
from plone.app.widgets.dx import (RelatedItemsFieldWidget,
AjaxSelectWidget,
RelatedItemsWidget)
HAS_W = True
except ImportError:
HAS_W = False
from plone.formwidget.contenttree import ObjPathSourceBinder
_ = MessageFactory('rbins_masschange')
logger = logging.getLogger('rbins_masschange.masschange')
@adapter(getSpecification(IOwnership['contributors']), IFormLayer)
@implementer(IFieldWidget)
def ContributorsFieldWidget(field, request):
widget = textlines.TextLinesFieldWidget(field, request)
return widget
def make_vocabulary(*items):
terms = [SimpleTerm(value=value, token=value, title=label)
for value, label in items]
return SimpleVocabulary(terms)
def safe_encode(s, coding='utf-8', errors='surrogateescape'):
"""encode str to bytes, with round-tripping "invalid" bytes"""
if s is None:
if portal_type is None:
return ''
types_tool = api.portal.get_tool('portal_types')
fti = getattr(types_tool, portal_type, None)
if fti is None:
return ''
behaviors = getattr(fti, 'behaviors', None) or []
if 'plone.app.blocks.layoutbehavior.ILayoutAware' not in behaviors:
return ''
return fti.default_view
def _context_selected_layout(self):
"""Return the current layout for the layout aware context if we
are on the layout aware context
"""
if not ILayoutAware(self.context, None):
return ''
selectable_layout = ISelectableBrowserDefault(self.context, None)
if not selectable_layout:
return ''
return selectable_layout.getLayout()
@adapter(getSpecification(ILayoutAware['content']), IMosaicLayer)
@implementer(IFieldWidget)
def LayoutFieldWidget(field, request): # noqa
return FieldWidget(field, LayoutWidget(request))
class TileRichTextWidget(RichTextWidget):
""" """
def _base_args(self):
args = {
'pattern': self.pattern,
'pattern_options': self.pattern_options.copy(),
}
context = aq_parent(self.wrapped_context())
args['name'] = self.name
properties = getToolByName(context, 'portal_properties')
charset = properties.site_properties.getProperty('default_charset',
'utf-8')
value = self.value and self.value.raw_encoded or ''
args['value'] = (self.request.get(
self.field.getName(), value)).decode(charset)
args.setdefault('pattern_options', {})
merged = dict_merge(get_tinymce_options(context, self.field, self.request), # noqa
args['pattern_options'])
args['pattern_options'] = merged
return args
@adapter(getSpecification(IRichTextTile['text']), IFormLayer)
@implementer(IFieldWidget)
def TileRichTextFieldWidget(field, request):
return FieldWidget(field, TileRichTextWidget(request))
try:
dr = DateRange(obj.first, obj.last)
try:
validateScholYearsForOverlap(self.view.context, dr, None)
except SchoolYearOverlapError, e:
errors += (e, )
except ValueError, e:
errors += (Invalid(_("School year must begin before it ends.")), )
except NoInputData:
return errors
return errors
WidgetsValidatorDiscriminators(AddSchoolYearOverlapValidator,
view=SchoolYearAddView,
schema=getSpecification(ISchoolYearAddForm,
force=True))
class EditSchoolYearValidator(InvariantsValidator):
def validateObject(self, obj):
errors = super(EditSchoolYearValidator, self).validateObject(obj)
try:
dr = DateRange(obj.first, obj.last)
try:
validateScholYearsForOverlap(self.view.context.__parent__, dr,
self.view.context)
except SchoolYearOverlapError, e:
errors += (e, )
try:
validateScholYearForOverflow(dr, self.view.context)
required=False,
default=100,
min=1,
)
view_template = schema.Choice(title=_(u'Display mode'),
source=_(u'Available Listing Views'),
required=True)
class IContentListingTileLayer(Interface):
"""Layer (request marker interface) for content listing tile views"""
@implementer(IValue)
@adapter(None, None, None, getSpecification(IContentListingTile['query']),
None)
class DefaultQuery(object):
def __init__(self, context, request, form, field, widget):
self.context = context
def get(self):
if IFolderish.providedBy(self.context):
value = '::1'
else:
value = '..::1'
return [{
'i': 'path',
'o': 'plone.app.querystring.operation.string.relativePath',
'v': value
}]
# icalendar event uid
sync_uid = schema.TextLine(required=False)
form.mode(sync_uid='hidden')
@invariant
def validate_start_end(data):
# data_postprocessing sets end=start if open_end
if data.start > data.end and not data.open_end:
raise StartBeforeEnd(
_("error_end_must_be_after_start_date",
default=u"End date must be after start date.")
)
@adapter(getSpecification(IEventBasic['start']), IPloneFormLayer)
@implementer(IFieldWidget)
def StartDateFieldWidget(field, request):
widget = FieldWidget(field, DatetimeWidget(request))
widget.default_timezone = default_timezone
return widget
@adapter(getSpecification(IEventBasic['end']), IPloneFormLayer)
@implementer(IFieldWidget)
def EndDateFieldWidget(field, request):
widget = FieldWidget(field, DatetimeWidget(request))
widget.default_timezone = default_timezone
return widget
try:
dr = DateRange(obj.first, obj.last)
try:
validateScholYearsForOverlap(self.view.context, dr, None)
except SchoolYearOverlapError, e:
errors += (e, )
except ValueError, e:
errors += (Invalid(_("School year must begin before it ends.")), )
except NoInputData:
return errors
return errors
WidgetsValidatorDiscriminators(
AddSchoolYearOverlapValidator,
view=SchoolYearAddView,
schema=getSpecification(ISchoolYearAddForm, force=True))
class EditSchoolYearValidator(InvariantsValidator):
def validateObject(self, obj):
errors = super(EditSchoolYearValidator, self).validateObject(obj)
try:
dr = DateRange(obj.first, obj.last)
try:
validateScholYearsForOverlap(self.view.context.__parent__, dr, self.view.context)
except SchoolYearOverlapError, e:
errors += (e, )
try:
validateScholYearForOverflow(dr, self.view.context)
vocabulary="plone.app.event.AvailableTimezones")
# icalendar event uid
sync_uid = schema.TextLine(required=False)
form.mode(sync_uid='hidden')
@invariant
def validate_start_end(data):
# data_postprocessing sets end=start if open_end
if data.start > data.end and not data.open_end:
raise StartBeforeEnd(
_("error_end_must_be_after_start_date",
default=u"End date must be after start date."))
@adapter(getSpecification(IEventBasic['start']), IPloneFormLayer)
@implementer(IFieldWidget)
def StartDateFieldWidget(field, request):
widget = FieldWidget(field, DatetimeWidget(request))
widget.first_day = first_weekday_sun0
return widget
@adapter(getSpecification(IEventBasic['end']), IPloneFormLayer)
@implementer(IFieldWidget)
def EndDateFieldWidget(field, request):
widget = FieldWidget(field, DatetimeWidget(request))
widget.first_day = first_weekday_sun0
return widget
try:
from plone.app.contenttypes.behaviors.collection import ICollection
from plone.app.contenttypes.behaviors.richtext import IRichText
HAS_PAC = True
except ImportError:
HAS_PAC = False
try:
from plone.app.event.dx.behaviors import IEventBasic
HAS_PAE = True
except ImportError:
HAS_PAE = False
@adapter(getSpecification(ICategorization['subjects']), IWidgetsLayer)
@implementer(IFieldWidget)
def SubjectsFieldWidget(field, request):
widget = FieldWidget(field, AjaxSelectWidget(request))
widget.vocabulary = 'plone.app.vocabularies.Keywords'
return widget
@adapter(getSpecification(ICategorization['language']), IWidgetsLayer)
@implementer(IFieldWidget)
def LanguageFieldWidget(field, request):
widget = FieldWidget(field, SelectWidget(request))
return widget
@adapter(getSpecification(IPublication['effective']), IWidgetsLayer)
)
spatial_values = List(
title=_(u"Countries"),
description=_(u"European countries"),
required=False,
value_type=Choice(vocabulary="eea.climateadapt.ace_countries"),
)
partners_source_link = URI(
title=_(u"Partners Source Link"),
description=(u"Provide URL from project partners"),
required=False,
)
@adapter(getSpecification(IAceProject["keywords"]), IWidgetsLayer)
@implementer(IFieldWidget)
def KeywordsFieldWidget(field, request):
widget = FieldWidget(field, BetterAjaxSelectWidget(request))
widget.vocabulary = "eea.climateadapt.keywords"
return widget
@adapter(getSpecification(IAceProject["special_tags"]), IWidgetsLayer)
@implementer(IFieldWidget)
def SpecialTagsFieldWidget(field, request):
widget = FieldWidget(field, BetterAjaxSelectWidget(request))
widget.vocabulary = "eea.climateadapt.special_tags"
return widget
required=False,
)
bottomLevel = schema.Int(
title=_(u'Navigation tree depth'),
description=_(
u'How many folders should be included before the navigation '
u'tree stops. 0 means no limit. 1 only includes the root '
u'folder.'),
default=0,
required=False,
)
@implementer(IValue)
@adapter(None, None, None, getSpecification(INavigationTile['root']), None)
class DefaultRoot(object):
def __init__(self, context, request, form, field, widget):
self.context = context
def get(self):
# Return UUID for the closest container or None for the site root
if not IFolderish.providedBy(self.context):
return IUUID(aq_parent(self.context), None)
else:
return IUUID(self.context, None)
@implementer(INavigationTile)
class NavigationTile(PersistentTile):
def __init__(self, context, *args, **kwargs):
class CommaSeparatedConverter(BaseDataConverter):
adapts(ITuple, ICommaSeparatedWidget)
def toFieldValue(self, value):
"""Return the tuple of strings
:rtype tuple of strings:
"""
if value is None:
return self.field.missing_value
return value
# plone intranet uses a dublincore override
@adapter(getSpecification(pi_IDublinCore['subjects']), IWorkspaceAppFormLayer)
@implementer(IFieldWidget)
def CommaSeparatedFieldWidget(field, request):
return FieldWidget(field, CommaSeparatedWidget(request))
class IPatDatePickerWidget(IWidget):
""" Marker interface """
@implementer_only(IPatDatePickerWidget)
class PatDatePickerWidget(Widget):
"""pat-date-picker gives us a list of strings with the date first and the
time second. To extract the value we need to convert that to a datetime
object.
_titleDisplayTemplate = ViewPageTemplateFile(
'templates/title.pt',
content_type='text/html'
)
_descriptionDisplayTemplate = ViewPageTemplateFile(
'templates/description.pt',
content_type='text/html'
)
_namedImageDisplayTemplate = ViewPageTemplateFile(
'templates/namedimage.pt',
content_type='text/html')
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, DexterityFieldTile,
getSpecification(IDublinCore['title']), TextWidget)
def titleDisplayTemplate(context, request, form, field, widget):
return _titleDisplayTemplate
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, DexterityFieldTile,
getSpecification(IDublinCore['description']), TextAreaWidget)
def descriptionDisplayTemplate(context, request, form, field, widget):
return _descriptionDisplayTemplate
@implementer(IPageTemplate)
@adapter(None, ITilesFormLayer, DexterityFieldTile,
None, NamedImageWidget)
def namedImageDisplayTemplate(context, request, form, field, widget):
def _enable_custom_widget(field):
provideAdapter(
_custom_field_widget,
adapts=(getSpecification(field), IPloneFormLayer),
provides=IFieldWidget
)
if portal_type is None:
return ''
types_tool = api.portal.get_tool('portal_types')
fti = getattr(types_tool, portal_type, None)
if fti is None:
return ''
behaviors = getattr(fti, 'behaviors', None) or []
if 'plone.app.blocks.layoutbehavior.ILayoutAware' not in behaviors:
return ''
return fti.default_view
def _context_selected_layout(self):
"""Return the current layout for the layout aware context if we
are on the layout aware context
"""
if not ILayoutAware(self.context, None):
return ''
selectable_layout = ISelectableBrowserDefault(self.context, None)
if not selectable_layout:
return ''
return selectable_layout.getLayout()
@adapter(getSpecification(ILayoutAware['content']), IMosaicLayer)
@implementer(IFieldWidget)
def LayoutFieldWidget(field, request): # noqa
return FieldWidget(field, LayoutWidget(request))
# -*- coding: utf-8 -*-
from zope.component import adapter
from z3c.form.interfaces import IFormLayer
from z3c.form.util import getSpecification
from plone.formwidget.querystring.widget import QueryStringFieldWidget
from plone.app.contenttypes.behaviors.collection import ICollection
QueryStringFieldWidget = adapter(
getSpecification(ICollection['query']),
IFormLayer
)(QueryStringFieldWidget)
@indexer(ITask)
def index_project_manager(context):
return [i.getId() for i in ITaskAccessor(context).project_manager]
@indexer(ITask)
def index_assignee(context):
return [i.getId() for i in ITaskAccessor(context).assignee]
@indexer(ITask)
def index_state(context):
return ITaskAccessor(context).state
@indexer(ITask)
def index_due(context):
return ITaskAccessor(context).due
@adapter(getSpecification(ITaskPlannerSchema['text']), IFormLayer)
@implementer(IFieldWidget)
def TaskPlannerTextFieldWidget(field, request):
return FieldWidget(field, RichTextWidget(request))
@adapter(getSpecification(ITaskSchema['text']), IFormLayer)
@implementer(IFieldWidget)
def TaskTextFieldWidget(field, request):
return FieldWidget(field, RichTextWidget(request))
@implementer(IFieldWidget)
def AjaxSelectFieldWidget(field, request, extra=None):
if extra is not None:
request = extra
return FieldWidget(field, AjaxSelectWidget(request))
@implementer(IFieldWidget)
def RelatedItemsFieldWidget(field, request, extra=None):
if extra is not None:
request = extra
return FieldWidget(field, RelatedItemsWidget(request))
if HAS_PAC:
@adapter(getSpecification(IDXCollection['query']), IFormLayer)
@implementer(IFieldWidget)
def QueryStringFieldWidget(field, request):
return FieldWidget(field, QueryStringWidget(request))
@adapter(getSpecification(IRichText['text']), IFormLayer)
@implementer(IFieldWidget)
def RichTextFieldWidget(field, request):
return FieldWidget(field, RichTextWidget(request))
class MockRequest(TestRequest):
implements(IWidgetsLayer)
class DXFieldPermissionChecker(object):
"""
args = super(PatternWidget, self)._base_args()
args['name'] = self.name
args['value'] = self.value
if (IAddForm.providedBy(self.form) and
self.form.portal_type == 'uu.taskplanner') or \
(not IAddForm.providedBy(self.form) and
ITaskPlanner.providedBy(self.context) and
'pattern_options' in args):
args['pattern_options']['date'] = False
return args
@adapter(getSpecification(ITaskCommon['project_manager']), IFormLayer)
@implementer(IFieldWidget)
def ProjectManagerFieldWidget(field, request):
widget = FieldWidget(field, AjaxSelectWidget(request))
widget.vocabulary = 'uu.task.Users'
widget.pattern_options['allowNewItems'] = False
alsoProvides(widget, IInheritParentValue)
return widget
@adapter(getSpecification(ITaskCommon['assignee']), IFormLayer)
@implementer(IFieldWidget)
def AssigneeFieldWidget(field, request):
widget = FieldWidget(field, AjaxSelectWidget(request))
widget.vocabulary = 'uu.task.Users'
widget.pattern_options['allowNewItems'] = False
