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 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 Venue(Base, JsonifyMixin):
__tablename__ = 'venue'
id = Column(
Integer,
primary_key=True,
info={'colanderalchemy': {
'widget': TextAreaWidget(readonly=True)
}})
name = Column(Unicode,
nullable=False,
info={'colanderalchemy': {
'title': 'Название'
}})
address = Column(Unicode,
nullable=False,
info={'colanderalchemy': {
'title': 'Адрес'
}})
venue_type_id = Column(Integer,
ForeignKey('venue_type.id'),
nullable=False)
venue_type = relationship('VenueType',
info={'colanderalchemy': {
'title': 'Тип'
}})
def __repr__(self):
return '%s' % (self.name, )
class FolderSchema(Schema):
title = SchemaNode(String())
description = SchemaNode(
String(),
widget=TextAreaWidget(rows=5),
missing=u"",
)
def prepare_for_render(self, items_for_selects):
widgets = {
'voting_type':
Select2Widget(values=items_for_selects['voting_type']),
'description': TextAreaWidget(rows=8),
}
self.set_widgets(widgets)
class Metadata(Base):
__tablename__ = 'metadata'
__table_args__ = {'schema': _schema}
id = Column(Integer,
primary_key=True,
info={'colanderalchemy': {
'widget': HiddenWidget()
}})
name = Column(Unicode, info={'colanderalchemy': {
'title': _('Name'),
}})
value = Column(Unicode, info={'colanderalchemy': {'exclude': True}})
description = Column(Unicode,
info={
'colanderalchemy': {
'title': _('Description'),
'widget': TextAreaWidget()
}
})
item_id = Column('item_id',
Integer,
ForeignKey(_schema + '.treeitem.id'),
nullable=False,
info={
'colanderalchemy': {
'exclude': True
},
'c2cgeoform': {
'duplicate': False
}
})
item = relationship(
'TreeItem',
info={
'c2cgeoform': {
'duplicate': False
},
'colanderalchemy': {
'exclude': True
}
},
backref=backref(
'metadatas',
cascade='save-update,merge,delete,delete-orphan,expunge',
order_by='Metadata.name',
info={
'colanderalchemy': {
'title': _('Metadatas'),
'exclude': True
}
}))
def __init__(self, name: str = '', value: str = '') -> None:
self.name = name
self.value = value
def __unicode__(self) -> str: # pragma: no cover
return '{0!s}: {1!s}'.format(self.name or '', self.value or '')
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 QuickReplySchema(MappingSchema):
title = SchemaNode(String(),
default=deferred_default_title,
widget=HiddenWidget())
body = SchemaNode(String(),
title='',
default='',
widget=TextAreaWidget(rows=5, cols=80))
class ContentSchema(colander.MappingSchema):
title = colander.SchemaNode(colander.String(), title=_(u'Title'))
description = colander.SchemaNode(
colander.String(),
title=_('Description'),
widget=TextAreaWidget(cols=40, rows=5),
missing=u"",
)
class Dimension(Base):
__tablename__ = 'dimension'
__table_args__ = {'schema': _schema}
id = Column(Integer, primary_key=True, info={'colanderalchemy': {'widget': HiddenWidget()}})
name = Column(Unicode, info={
'colanderalchemy': {
'title': _('Name')
}
})
value = Column(Unicode, info={
'colanderalchemy': {
'title': _('Value')
}
})
description = Column(Unicode, info={
'colanderalchemy': {
'title': _('Description'),
'widget': TextAreaWidget()
}
})
layer_id = Column('layer_id',
Integer,
ForeignKey(_schema + '.layer.id'),
nullable=False,
info={
'colanderalchemy': {
'exclude': True
},
'c2cgeoform': {
'duplicate': False
}})
layer = relationship(
'DimensionLayer',
info={'c2cgeoform': {'duplicate': False},
'colanderalchemy': {'exclude': True}
},
backref=backref(
'dimensions',
cascade='save-update,merge,delete,delete-orphan,expunge',
info={
'colanderalchemy': {
'title': _('Dimensions'),
'exclude': True
}
}
)
)
def __init__(self, name: str='', value: str='', layer: str=None) -> None:
self.name = name
self.value = value
if layer is not None:
self.layer = layer
def __unicode__(self) -> str: # pragma: no cover
return self.name or ''
class EditGameDepSchema(MappingSchema):
name = SchemaNode(String(),
widget=TextInputWidget(size=40),
validator=Regex(
"^[a-zA-Z_0-9]*$",
"Only characters a-z A-Z 0-9 _ " + "are accepted."))
display_name = SchemaNode(String(), widget=TextInputWidget(size=40))
description = SchemaNode(String(), widget=TextAreaWidget(cols=80, rows=20))
tags = SchemaNode(String(), widget=TextInputWidget(size=40), missing='')
class AccountDestroySchema(colander.MappingSchema):
reason = colander.SchemaNode(
colander.String(),
missing='',
widget=TextAreaWidget(rows=6),
title=_('Do you mind telling us your reasons?'),
description=_('We want to get better!'),
)
def prepare_for_render(self, items_for_selects):
self.set_widgets({
'editing_remarks':
TextAreaWidget(rows=4),
'area_id':
Select2Widget(values=items_for_selects['area']),
'proposition_type_id':
Select2Widget(values=items_for_selects['proposition_type']),
**common_widgets(items_for_selects)
})
def common_widgets(items_for_selects):
return {
'title':
TextAreaWidget(rows=2),
'abstract':
TextAreaWidget(rows=4),
'content':
TextAreaWidget(rows=8),
'motivation':
TextAreaWidget(rows=8),
'tags':
Select2Widget(multiple=True,
tags=True,
values=items_for_selects['tags']),
'relation_type':
HiddenWidget(),
'related_proposition_id':
HiddenWidget()
}
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):
self.set_widgets({
'proposition_id':
HiddenWidget(),
'user_id':
HiddenWidget(),
'notes':
TextAreaWidget(rows=8, missing=None),
'vote':
Select2Widget(values=items_for_selects['vote'])
})
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')))
class PostSchema(MappingSchema):
title = SchemaNode(String(),
default=deferred_default_title,
widget=TextInputWidget(),
location="body",
type='str')
body = SchemaNode(String(),
default=deferred_default_body,
widget=TextAreaWidget(rows=5, cols=80),
location="body",
type='str')
def prepare_for_render(self, items_for_selects):
common = common_widgets(items_for_selects)
self.set_widgets({
'document_id': HiddenWidget(),
'section': HiddenWidget(),
'editing_remarks': TextAreaWidget(rows=4),
'title': common['title'],
'abstract': common['abstract'],
'content': common['content'],
'motivation': common['motivation'],
'tags': common['tags']
})
def prepare_for_render(self, items_for_selects):
widgets = {
'result':
TextAreaWidget(rows=4),
'area_id':
Select2Widget(values=items_for_selects['area']),
'voting_id':
Select2Widget(values=items_for_selects['voting']),
'proposition_type_id':
Select2Widget(values=items_for_selects['proposition_type'])
}
self.set_widgets(widgets)
def field_metadata(self):
metadata = {
"title": self["title"],
"description": self["description"],
"required": self["required"],
"validators": [],
}
if self["primary_key"]:
metadata["index"] = True
if self["allow_invalid"]:
metadata["required"] = False
if not self["allow_invalid"]:
for v in self.validators():
metadata["validators"].append(v.field_validator())
de = self.dictionaryelement()
if de and not self["allow_invalid"]:
for v in de.validators():
metadata["validators"].append(v.field_validator())
if self["default_factory"]:
factory_name = self["default_factory"]
factory = self.request.app.config.default_factory_registry.get(
factory_name, self.request)
metadata["default_factory"] = factory
if self["type"] == "string":
if de and de["referencedata_name"]:
metadata["deform.widget"] = ReferenceDataWidget(
de["referencedata_name"], de["referencedata_property"])
if not self["allow_invalid"]:
metadata["validators"].append(
ReferenceDataValidator(de["referencedata_name"],
de["referencedata_property"]))
return metadata
if self["type"] == "text":
metadata.update({
"format": "text",
"deform.widget": TextAreaWidget()
})
return metadata
if self["type"] == "richtext":
metadata.update({
"format": "text/html",
"preparers": [HTMLSanitizer()],
"deform.widget": RichTextWidget(),
})
return metadata
return metadata
class ContactFormSchema(c.MappingSchema):
name = c.SchemaNode(c.Str(),
title=_('Name'),
validator=c.Length(**LEN_NAME))
email = c.SchemaNode(c.Str(), title=_('Email'), validator=c.Email())
subject = c.SchemaNode(c.Str(),
title=_('Subject'),
validator=c.Length(**LEN_SUBJECT))
message = c.SchemaNode(c.Str(),
title=_('Message'),
widget=TextAreaWidget(cols=40, rows=12),
validator=c.Length(**LEN_MESSAGE))
class EmbedSchema(MappingSchema):
"""Embed sheet data structure.
`embed_code`: html code to embed the `context` resource in web pages.
`external_url`: canonical URL that embeds the `context` resource.
"""
embed_code = Text(
default=deferred_default_embed_code,
widget=TextAreaWidget(rows=10),
)
external_url = URL()
def prepare_for_render(self, items_for_selects):
self.set_widgets({
'title':
TextAreaWidget(rows=2),
'abstract':
TextAreaWidget(rows=4),
'content':
TextAreaWidget(rows=8),
'motivation':
TextAreaWidget(rows=8),
'tags':
Select2Widget(multiple=True,
tags=True,
values=items_for_selects['tags']),
'relation_type':
HiddenWidget(),
'related_proposition_id':
HiddenWidget(),
'area_id':
Select2Widget(values=items_for_selects['area'])
})
class PageSchema(Schema):
title = SchemaNode(String())
description = SchemaNode(
String(),
widget=TextAreaWidget(rows=5),
missing=u"",
)
body = SchemaNode(
String(),
widget=RichTextWidget(),
missing=u"",
)
class FileSchema(MappingSchema):
title = SchemaNode(String(), title=_(u'Title'), missing=u'')
description = SchemaNode(
String(),
title=_('Description'),
missing=u"",
widget=TextAreaWidget(cols=40, rows=5),
)
file = SchemaNode(
FileData(),
title=_(u'File'),
widget=FileUploadWidget(tmpstore),
)
class ContentSchema(colander.MappingSchema):
title = colander.SchemaNode(colander.String(), title=_(u'Title'))
description = colander.SchemaNode(
colander.String(),
title=_('Description'),
widget=TextAreaWidget(cols=40, rows=5),
missing=u"",
)
tags = colander.SchemaNode(
ObjectType(),
title=_('Tags'),
widget=deferred_tag_it_widget,
missing=[],
)
def __init__(self, *args, **kw):
super().__init__(*args, **kw)
self.available_types: List[str] = []
self._add_value_node("string", colander.String())
self._add_value_node("liste", colander.String())
self._add_value_node("boolean", colander.Boolean())
self._add_value_node("int", colander.Int())
self._add_value_node("float", colander.Float())
self._add_value_node("url", colander.String(), validator=url)
self._add_value_node(
"json", colander.String(), widget=TextAreaWidget(rows=10), validator=json_validator
)
def __init__(self, *args, **kw):
super().__init__(*args, **kw)
self.available_types = []
self._add_value_node('string', colander.String())
self._add_value_node('liste', colander.String())
self._add_value_node('boolean', colander.Boolean())
self._add_value_node('int', colander.Int())
self._add_value_node('float', colander.Float())
self._add_value_node('url', colander.String(), validator=url)
self._add_value_node('json',
colander.String(),
widget=TextAreaWidget(rows=10),
validator=json_validator)
class ContactSchema(colander.MappingSchema):
name = colander.SchemaNode(
colander.String(),
title=_('Name'),
)
email = colander.SchemaNode(
colander.String(),
title=_('Email'),
)
message = colander.SchemaNode(
colander.String(),
widget=TextAreaWidget(rows=10),
title=_('Message'),
)