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 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 _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, )
#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):
_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 )
# -*- 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))
""" 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