def prepare_for_render(self, items_for_selects): widgets = { 'description': TextAreaWidget(rows=8), 'majority': SelectWidget(values=items_for_selects['majority']), 'voting_system': SelectWidget(values=items_for_selects['voting_system']), } self.set_widgets(widgets)
class DictionaryElementSchema(morpfw.Schema): name: typing.Optional[str] = field(default=None, metadata={ "required": True, "validators": [valid_identifier] }) dictionaryentity_uuid: typing.Optional[str] = field( default=None, metadata={ "format": "uuid", "validators": [ReferenceValidator("morpcc.dictionaryentity", "uuid")], "deform.widget": ReferenceWidget("morpcc.dictionaryentity", "title", "uuid"), }, ) type: typing.Optional[str] = field( default=None, metadata={ "required": True, "validators": [valid_type], "deform.widget": SelectWidget(values=ACCEPTED_TYPES), }, ) title: typing.Optional[str] = field(default=None, metadata={"required": True}) description: typing.Optional[str] = field(default=None, metadata={"format": "text"}) notes: typing.Optional[str] = field( default=None, metadata={ "format": "text", "preparers": [HTMLSanitizer()], "deform.widget": RichTextWidget(), }, ) referencedata_name: typing.Optional[str] = field( default=None, metadata={ "validators": [ReferenceValidator("morpcc.referencedata", "name")], "deform.widget": ReferenceWidget("morpcc.referencedata", "title", "name"), }, ) referencedata_property: typing.Optional[str] = field( default=None, metadata={ "validators": [valid_property_types], "deform.widget": SelectWidget(values=PROPERTY_TYPES), }, ) __unique_constraint__ = ["name"] __validators__ = [valid_refdata]
def __init__(self, model, id_field='id', label_field='label', default_value=None, order_by=None, **kw): RelationMultiSelectMixin.__init__(self, model, id_field, label_field, default_value, order_by) SelectWidget.__init__(self, **kw)
def prepare_for_render(self, items_for_selects): self.set_widgets({ 'status': SelectWidget(values=items_for_selects['status']), 'visibility': SelectWidget(values=items_for_selects['visibility']), 'external_fields': TextAreaWidget(rows=4), **common_widgets(items_for_selects) })
def prepare_for_render(self, items_for_selects): widgets = { 'title': TextAreaWidget(rows=2), 'description': TextAreaWidget(rows=8), 'status': SelectWidget(values=items_for_selects['status']), 'phase_type_id': SelectWidget(values=items_for_selects['phase_type']), 'department_id': SelectWidget(values=items_for_selects['department']) } self.set_widgets(widgets)
class IndexSchema(morpfw.Schema): name: typing.Optional[str] = field(default=None, metadata={ "required": True, "editable": False }) title: typing.Optional[str] = field(default=None, metadata={"required": True}) type: typing.Optional[str] = field( default=None, metadata={ "required": True, "editable": False, "deform.widget": SelectWidget(values=[ ("fulltextindex", "Full Text Index"), ("keywordindex", "Keyword Index"), ]), }, ) description: typing.Optional[str] = field(default=None, metadata={"format": "text"})
class SetpointInterpolationSchema(MappingSchema): name = SchemaNode(typ=String(), title='Name') order = SchemaNode(typ=Int(), title='Type (order)', default=deferred_order_default, widget=SelectWidget(values=[(0, 'Constant'), (1, 'Linear'), (2, 'Quadratic'), (3, 'Cubic'), (4, 'Spline')])) start_value = SchemaNode(typ=Float(), title='Start Value', default=deferred_start_value_default) end_time = SchemaNode(typ=Int(), title='End Time', default=deferred_end_time_default) end_value = SchemaNode(typ=Float(), title='End Value', default=deferred_end_value_default, missing=None) description = SchemaNode(typ=String(), title='Description', default=deferred_description_default, missing=None)
class LayerWMTS(DimensionLayer): __tablename__ = 'layer_wmts' __table_args__ = {'schema': _schema} __colanderalchemy_config__ = { 'title': _('WMTS Layer'), 'plural': _('WMTS Layers') } __c2cgeoform_config__ = { 'duplicate': True } __mapper_args__ = {'polymorphic_identity': 'l_wmts'} id = Column(Integer, ForeignKey(_schema + '.layer.id'), primary_key=True, info={ 'colanderalchemy': { 'missing': None, 'widget': HiddenWidget() }}) url = Column(Unicode, nullable=False, info={ 'colanderalchemy': { 'title': _('GetCapabilities URL'), 'column': 2 }}) layer = Column(Unicode, nullable=False, info={ 'colanderalchemy': { 'title': _('WMTS layer name'), 'column': 2 }}) style = Column(Unicode, info={ 'colanderalchemy': { 'title': _('Style'), 'column': 2 }}) matrix_set = Column(Unicode, info={ 'colanderalchemy': { 'title': _('Matrix set'), 'column': 2 }}) image_type = Column( Enum( 'image/jpeg', 'image/png', native_enum=False ), nullable=False, info={ 'colanderalchemy': { 'title': _('Image type'), 'column': 2, 'widget': SelectWidget(values=( ('image/jpeg', 'image/jpeg'), ('image/png', 'image/png'))) }}) def __init__(self, name: str='', public: bool=True, image_type: str='image/png') -> None: DimensionLayer.__init__(self, name=name, public=public) self.image_type = image_type @staticmethod def get_default(dbsession: Session) -> DimensionLayer: return dbsession.query(LayerWMTS).filter(LayerWMTS.name == 'wmts-defaults').one_or_none()
class ReferenceDataPropertySchema(morpfw.Schema): name: typing.Optional[str] = field( default=None, metadata={ "required": True, "validators": [valid_property_types], "deform.widget": SelectWidget(values=PROPERTY_TYPES), }, ) value: typing.Optional[str] = field(default=None, metadata={"required": True}) description: typing.Optional[str] = field(default=None, metadata={"format": "text"}) referencedatakey_uuid: typing.Optional[str] = field( default=None, metadata={ "format": "uuid", "required": True, "editable": False, "validators": [ReferenceValidator("morpcc.referencedatakey", "uuid")], "deform.widget": ReferenceWidget("morpcc.referencedatakey", "name", "uuid"), }, ) __unique_constraint__ = ["referencedatakey_uuid", "name"]
def widget(node: MappingSchema, kw: dict) -> SelectWidget: """Return widget to select the wanted workflow.""" valid_names = deferred_workflow_validator(node, kw).choices choices = [(w, w) for w in valid_names] choices.remove(('', '')) choices.append(('', 'No workflow')) return SelectWidget(values=choices)
def prepare_for_render(self, items_for_selects): self.set_widgets({ 'area_id': HiddenWidget(), 'status': SelectWidget(values=items_for_selects['status']), **common_widgets(items_for_selects) })
def widget(self, kw: dict) -> []: """Return widget based on the `/principals/groups` service.""" from adhocracy_core.resources.principal import IGroup context = kw['context'] groups = find_service(context, 'principals', 'groups') values = [('group:' + x, x) for x, y in groups.items() if IGroup.providedBy(y)] return SelectWidget(values=values)
def deferred_actuator_widget(node, kw): query = DBSession.query(Actuator) if 'device' in kw: query = query.filter_by(device_type_id=kw['device'].device_type_id) actuators = query.all() choices = [(None, '--select--')] for a in actuators: choices.append((a.id, a.periphery_controller.name + '->' + a.name)) return SelectWidget(values=choices)
def deferred_sensor_widget(node, kw): query = DBSession.query(Sensor) if 'parameter' in kw: query = query.filter_by(parameter_type_id=kw['parameter'].parameter_type_id) sensors = query.all() choices = [(None, '--select--')] for s in sensors: choices.append((s.id, s.periphery_controller.name + '->' + s.name)) return SelectWidget(values=choices)
class SettingsSchema(MappingSchema): """This is the form schema used for the account view. """ first_name = SchemaNode(String()) last_name = SchemaNode(String()) time_zone = SchemaNode( String(), default=u'US/Eastern', widget=SelectWidget(values=zip(all_timezones, all_timezones), ), )
class StageConfigurationSchema(MappingSchema): parameter = SchemaNode( typ=Int(), title='Parameter', widget=SelectWidget(values=[(_id, name) for _id, name in DBSession.query( Parameter._id, Parameter.name)])) time = SchemaNode(typ=Time(), title='Time', default=time(0, 0)) setpoint = SchemaNode(typ=Float(), title='Setpoint') upper_limit = SchemaNode(typ=Float(), title='Upper limit') lower_limit = SchemaNode(typ=Float(), title='Lower limit')
def group_organization_select_widget(node, kw): orgs = kw["organizations"] org_labels = [] org_pubids = [] for org in orgs.values(): org_labels.append("{} ({})".format(org.name, org.authority)) org_pubids.append(org.pubid) # `zip` returns an iterator. The `SelectWidget` constructor requires an # actual list. return SelectWidget(values=list(zip(org_pubids, org_labels)))
class CreateAdminGroupSchema(CSRFSchema): group_type = colander.SchemaNode( colander.String(), title=_('Group Type'), widget=SelectWidget(values=(('', _('Select')), ) + VALID_GROUP_TYPES), validator=group_type_validator, ) name = colander.SchemaNode( colander.String(), title=_('Group Name'), validator=validators.Length(min=GROUP_NAME_MIN_LENGTH, max=GROUP_NAME_MAX_LENGTH), ) authority = colander.SchemaNode( colander.String(), title=_('Authority'), description=_("The group's authority"), hint=_('The authority within which this group should be created.' ' Note that only users within the designated authority' ' will be able to be associated with this group (as' ' creator or member).')) creator = colander.SchemaNode( colander.String(), title=_('Creator'), description=_("Username for this group's creator"), hint=_( 'This user will be set as the "creator" of the group. Note that' ' the user must be on the same authority as the group authority'), ) description = colander.SchemaNode( colander.String(), title=_('Description'), description=_('Optional group description'), validator=colander.Length(max=GROUP_DESCRIPTION_MAX_LENGTH), widget=TextAreaWidget(rows=3), missing=None) origins = colander.SequenceSchema( colander.Sequence(), colander.SchemaNode(colander.String(), name='origin', validator=colander.url), title=_('Scope Origins'), hint=_( 'Origins where this group appears (e.g. "https://example.com")'), widget=SequenceWidget(add_subitem_text_template=_('Add origin'), min_len=1), validator=colander.Length( min=1, min_err=_('At least one origin must be specified')))
def deferred_favorite_widget(node, kw): jobs = kw.get('jobs', []) last = kw.get('last', False) gentitle = lambda job: "{0} - {1} - {2}".format( job.get('title'), job.get('caption', '???'), time_ago_in_words(job.get('finished'))) choices = [('', 'No Favorite')] if last: choices.append(('last', 'Last Run')) logger.debug('jobs %s', jobs) choices.extend([(job['identifier'], gentitle(job)) for job in jobs]) return SelectWidget(values=choices)
class Event(Base): __tablename__ = "event" __table_args__ = {"schema": schema} __colanderalchemy_config__ = {"title": _("Event"), "plural": _("Events")} id = Column( Integer, primary_key=True, info={"colanderalchemy": {"title": _("Identifier"), "widget": HiddenWidget()}}, ) issue_id = Column( Integer, ForeignKey("{}.issue.id".format(schema)), nullable=False, info={"colanderalchemy": {"title": _("Type"), "widget": HiddenWidget()}}, ) status = Column( Enum(*tuple(STATUSES.keys()), native_enum=False, name="status"), nullable=False, info={ "colanderalchemy": { "title": _("Status"), "widget": SelectWidget( values=list(STATUSES.items()), item_css_class="item-status" ), } }, ) date = Column( DateTime(timezone=True), nullable=False, server_default=func.now(), info={"colanderalchemy": {"title": _("Date"), "widget": HiddenWidget()}}, ) comment = Column( Text, info={"colanderalchemy": {"title": _("Comment"), "missing": ""}} ) private = Column( Boolean, info={ "colanderalchemy": { "title": _("Private"), "widget": CheckboxWidget(item_css_class="item-private"), } }, ) author = Column( Enum(*tuple(USER_AUTHORS.keys()), native_enum=False, name="author"), nullable=False, default="new", info={"colanderalchemy": {"title": _("Author"), "widget": HiddenWidget()}}, )
class DeviceLinkSchema(MappingSchema): device = SchemaNode(typ=Int(), title='Parameter', default=deferred_device_default, widget=deferred_device_widget) target = SchemaNode(typ=String(), title='Target Log', default='value', widget=SelectWidget(values=[('value', 'Values'), ('setpoint', 'Setpoints')])) color = SchemaNode(typ=String(), title='Color', default='#FF0000', widget=TextInputWidget())
class CreateAdminGroupSchema(CSRFSchema): group_type = colander.SchemaNode( colander.String(), title=_('Group Type'), widget=SelectWidget(values=(('', _('Select')), ) + VALID_GROUP_TYPES), validator=colander.OneOf([key for key, title in VALID_GROUP_TYPES])) name = colander.SchemaNode( colander.String(), title=_('Group Name'), validator=validators.Length(min=GROUP_NAME_MIN_LENGTH, max=GROUP_NAME_MAX_LENGTH), ) authority = colander.SchemaNode( colander.String(), title=_('Authority'), description=_("The group's authority"), hint=_('The authority within which this group should be created.' ' Note that only users within the designated authority' ' will be able to be associated with this group (as' ' creator or member).')) creator = colander.SchemaNode( colander.String(), title=_('Creator'), description=_("Username for this group's creator"), hint=_( 'This user will be set as the "creator" of the group. Note that' ' the user must be on the same authority as the group authority'), ) description = colander.SchemaNode( colander.String(), title=_('Description'), description=_('Optional group description'), validator=colander.Length(max=GROUP_DESCRIPTION_MAX_LENGTH), widget=TextAreaWidget(rows=3), missing=None) origins = colander.SchemaNode( colander.String(), title=_('Scope Origins'), widget=TextAreaWidget(rows=5), hint=_( 'Enter scope origins (e.g. "http://www.foo.com"), one per line'), preparer=_split_origins, missing=None)
class ParameterLinkSchema(MappingSchema): parameter = SchemaNode(typ=Int(), title='Parameter', default=deferred_parameter_default, widget=deferred_parameter_widget) target = SchemaNode( typ=String(), title='Target Log', default=deferred_target_default, widget=SelectWidget(values=[('value', 'Values'), ('setpoint', 'Setpoints')])) color = SchemaNode(typ=String(), title='Color', default=deferred_color_default, widget=TextInputWidget())
class LinkActionSchema(DocumentSchema): link = colander.SchemaNode( colander.String(), title=_('Link'), validator=link_validator, missing=u'', ) target = colander.SchemaNode( colander.String(), title=_('Target'), widget=SelectWidget(values=[('', ''), ('_blank', '_blank')]), missing=u'', ) def after_bind(self, node, kw): del node['body'] del node['tags']
class BlogEntrySchema(Schema): name = SchemaNode( String(), validator=make_name_validator('Blog Entry'), ) title = SchemaNode(String(), ) entry = SchemaNode( String(), widget=TextAreaWidget(rows=20, cols=70), ) format = SchemaNode( String(), validator=OneOf(['rst', 'html']), widget=SelectWidget(values=[('rst', 'rst'), ('html', 'html')]), ) pubdate = SchemaNode( DateTime(default_tzinfo=eastern), default=now_default, )
class AttributeValidatorSchema(morpfw.Schema): name: typing.Optional[str] = field( default=None, metadata={ "required": True, "editable": False, "validators": [valid_namespaced_identifier], }, ) title: typing.Optional[str] = field(default=None, metadata={"required": True}) description: typing.Optional[str] = field(default=None, metadata={"format": "text"}) type: typing.Optional[str] = field( default=None, metadata={ "required": True, "editable": False, "validators": [valid_type], "deform.widget": SelectWidget(values=ACCEPTED_TYPES), }, ) notes: typing.Optional[str] = field( default=None, metadata={ "format": "text/html", "preparers": [HTMLSanitizer()], "deform.widget": RichTextWidget(), }, ) code: typing.Optional[str] = field( default="def validate(value):\n return True", metadata={ "format": "text/python", "required": True, "deform.widget": CodeWidget(), }, ) error_message: typing.Optional[str] = field(default=None, metadata={"required": True})
def __init__(self, context, request, **kwargs): super(SlotsEditView, self).__init__(context, request, **kwargs) self.schema = colander.SchemaNode(colander.Mapping(), name="slots") view_name = context.default_view or "view" for name, title in get_registered_slots(view_name): choices = self._available_snippets(self.request.context, name) choices = map(lambda s: ("snippet-%d" % s.id, s.title), choices) snippet = colander.SchemaNode(colander.Mapping(), name="snippet-mapping", title=_(u'Snippet')) snippet.add( colander.SchemaNode(colander.String(), widget=SelectWidget(values=choices), name='snippet')) self.schema.add( colander.SchemaNode(colander.Sequence(), snippet, name=name, title=title, missing=[], widget=SequenceWidget(orderable=True), validator=validate_list))
class EndpointHandlerSchema(morpfw.Schema): endpoint_uuid: typing.Optional[str] = field( default=None, metadata={ "format": "uuid", "required": True, "index": True, "deform.widget": ReferenceWidget("morpcc.endpoint", term_field="title", value_field="uuid"), "validators": [ReferenceValidator("morpcc.endpoint", "uuid")], }, ) method: typing.Optional[str] = field( default=None, metadata={ "required": True, "index": True, "deform.widget": SelectWidget(values=[(k, k) for k in ALLOWED_METHODS]), "validators": [valid_method], }, ) code: typing.Optional[str] = field( default="def handle(context, request):\n return True", metadata={ "format": "text/python", "required": True, "deform.widget": CodeWidget(), }, ) __unique_constraint__ = ["endpoint_uuid", "method"]
class CreateAdminGroupSchema(CSRFSchema): group_type = colander.SchemaNode( colander.String(), title=_('Group Type'), widget=SelectWidget(values=(('', _('Select')), ) + VALID_GROUP_TYPES)) name = colander.SchemaNode( colander.String(), title=_('Group Name'), validator=validators.Length(min=GROUP_NAME_MIN_LENGTH, max=GROUP_NAME_MAX_LENGTH), ) authority = colander.SchemaNode( colander.String(), title=_('Authority'), description=_("The group's authority"), hint=_('The authority within which this group should be created.' ' Note that only users within the designated authority' ' will be able to be associated with this group (as' ' creator or member).')) creator = colander.SchemaNode( colander.String(), title=_('Creator'), description=_("Username for this group's creator"), hint=_( 'This user will be set as the "creator" of the group. Note that' ' the user must be on the same authority as the group authority'), ) description = colander.SchemaNode( colander.String(), title=_('Description'), description=_('Optional group description'), validator=colander.Length(max=GROUP_DESCRIPTION_MAX_LENGTH), widget=TextInputWidget(rows=3), missing=None)
def municipality_widget(node, kw): values = [('', '---')] [values.append((m.id, fmt(m.name))) for m in Municipality.all()] return SelectWidget(values=values)
def __init__(self, class_, label, value, order_by=None, *filters, **kw): SQLAlchemyWidget.__init__(self, class_, label, value, order_by, *filters) SelectWidget.__init__(self, **kw)
def deserialize(self, field, pstruct): if self.multiple: return RelationMultiSelectMixin.deserialize(self, field, pstruct) else: return SelectWidget.deserialize(self, field, pstruct)
def serialize(self, field, cstruct, **kw): if self.multiple: cstruct = RelationMultiSelectMixin.serialize( self, field, cstruct, **kw) return SelectWidget.serialize(self, field, cstruct, **kw)
def __init__( self, model, id_field='id', label_field='label', default_value=None, order_by=None, **kw): RelationMultiSelectMixin.__init__( self, model, id_field, label_field, default_value, order_by) SelectWidget.__init__(self, **kw)