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)
