class BaseDocumentSchema(MappingSchema):
"""Base document schema"""
title = SchemaNode(String(), title=_("Document title"), missing=drop)
application_name = SchemaNode(String(),
title=_("Source application name"),
missing=drop)
filename = SchemaNode(String(), title=_("File name"), missing=drop)
properties = SchemaNode(PropertiesMapping(),
title=_("Document custom properties"),
missing=drop)
tags = StringListSchema(title=_("List of document tags"), missing=drop)
owner = SchemaNode(String(),
title=_("Current document owner"),
missing=drop)
status = SchemaNode(String(),
title=_("Document status"),
validator=OneOf((DRAFT_STATE, PUBLISHED_STATE,
ARCHIVED_STATE, DELETED_STATE)),
default=DRAFT_STATE,
missing=drop)
access_mode = SchemaNode(String(),
title=_("Access mode"),
validator=OneOf(ACCESS_MODE_IDS),
default='private',
missing=drop)
readers = StringListSchema(title=_("Document readers IDs"), missing=drop)
update_mode = SchemaNode(String(),
title=_("Update mode"),
validator=OneOf(ACCESS_MODE_IDS),
default='private',
missing=drop)
managers = StringListSchema(title=_("Document managers IDs"), missing=drop)
def ballot_voting_form(ballot_voting, request):
yes_no_choices = [(True, _('Yes')), (False, _('No')), (None, _('Abstention'))]
max_points = 9 if len(ballot_voting.options) > 3 else 3
point_choices = [(i, str(i)) for i in range(max_points+1)]
schema = Schema()
for option in ballot_voting.options:
option_schema = SchemaNode(Mapping(), name=str(option.uuid), title=option.title)
option_schema.add(SchemaNode(
Boolean(),
validator=OneOf([x[0] for x in yes_no_choices]),
widget=RadioChoiceWidget(values=yes_no_choices, inline=True),
name='yes_no',
title=f'Stimmst du dem Antrag zu?'))
option_schema.add(SchemaNode(
Int(),
validator=OneOf([x[0] for x in point_choices]),
widget=RadioChoiceWidget(values=point_choices, inline=True, null_value='0'),
name='points',
title='Welche Punktzahl gibst du dem Antrag?',
missing=0))
schema.add(option_schema)
form = Form(schema, request, buttons=[Button(title=_('check'))])
return form
class FilterPreferencesSchema(MappingSchema):
activities = SchemaNode(Sequence(),
SchemaNode(String(), validator=OneOf(activities)),
missing=required)
langs = SchemaNode(Sequence(),
SchemaNode(String(), validator=OneOf(default_langs)),
missing=required)
areas = SchemaNode(Sequence(), SchemaAssociationDoc(), missing=required)
followed_only = SchemaNode(Boolean(), missing=required)
def deferred_validator(node, kw):
""" This is a deferred validator that changes its own behavior based on
request object being passed, thus allowing for validation of fields
depending on other field values.
This example shows how to validate a body field based on a
dummy header value, using OneOf validator with different choices
"""
request = kw['request']
if request['x-foo'] == 'version_a':
return OneOf(['a', 'b'])
else:
return OneOf(['c', 'd'])
class DatasetForm(Schema):
label = SchemaNode(String(),
preparer=prepare_name,
validator=Length(min=2))
name = SchemaNode(String(), preparer=prepare_name, validator=dataset_name)
description = SchemaNode(String(), missing=drop)
private = SchemaNode(Boolean(), missing=drop)
currency = SchemaNode(String(),
missing=drop,
validator=OneOf(CURRENCIES.keys()))
category = SchemaNode(String(),
missing=drop,
validator=OneOf(CATEGORIES.keys()))
languages = DatasetLanguages(missing=drop)
territories = DatasetTerritories(missing=drop)
class Attribute(MappingSchema):
label = SchemaNode(String(), missing=drop)
description = SchemaNode(String(), missing='')
column = SchemaNode(String(), validator=Length(min=1))
type = SchemaNode(String(),
missing='string',
validator=OneOf(TYPES.keys()))
class WebhookSchema(MappingSchema):
url = SchemaNode(String(), location='body', validator=url)
event_type = SchemaNode(String(),
location='body',
validator=OneOf(
[value for value, label in Webhook.TYPES]))
active = SchemaNode(Boolean(), location='body')
class OrganizationInfoSchema(MappingSchema):
"""Data structure for organizational information."""
name = SingleLine(missing=drop)
validator = OneOf([
'registered_nonprofit',
'planned_nonprofit',
'support_needed',
'other',
])
city = SingleLine(missing=drop)
country = ISOCountryCode(missing=drop)
help_request = Text(validator=Length(max=300))
registration_date = DateTime(missing=drop, default=None)
website = URL(missing=drop)
status = OrganizationStatusEnum(missing=required)
status_other = Text(validator=Length(max=300))
def validator(self, node, value):
"""Extra validation depending on the status of the organisation.
Make `status_other` required if `status` == `other` and
`help_request` required if `status` == `support_needed`.
"""
status = value.get('status', None)
if status == 'support_needed':
if not value.get('help_request', None):
help_request = node['help_request']
raise Invalid(help_request,
msg='Required iff status == support_needed')
elif status == 'other':
if not value.get('status_other', None):
status_other = node['status_other']
raise Invalid(status_other, msg='Required iff status == other')
class ItemTypeGroup(colander.SchemaNode):
"""Item Type Group
Values: saatgut | pflanzgut | sonstiges
"""
schema_type = colander.String
validator = OneOf(["saatgut", "pflanzgut", "sonstiges"])
class WindMoverSchema(WindMoverSchema):
default_name = 'Wind Mover'
name = SchemaNode(String(), default=default_name, missing=default_name)
uncertain_angle_scale_units = SchemaNode(String(),
default='rad',
missing='rad',
validator=OneOf(['rad', 'deg']))
class CellTowerSchema(MappingSchema):
# mapped to 'radio' for submit
radioType = SchemaNode(String(),
validator=OneOf(RADIO_STRINGS),
missing=None)
# mapped to 'cid' for submit
cellId = SchemaNode(Integer(), missing=None)
# mapped to 'lac' for submit
locationAreaCode = SchemaNode(Integer(), missing=None)
# mapped to 'mcc' for submit
mobileCountryCode = SchemaNode(Integer())
# mapped to 'mnc' for submit
mobileNetworkCode = SchemaNode(Integer())
# optional
age = SchemaNode(Integer(), missing=0)
# mapped to 'signal' for submit
signalStrength = SchemaNode(Integer(), missing=0)
# mapped to 'ta' for submit
timingAdvance = SchemaNode(Integer(), missing=0)
# The fields below are extra fields which are not part of the
# geolocate API, but assist with data submission
psc = SchemaNode(Integer(), missing=-1)
asu = SchemaNode(Integer(), missing=-1)
def definition(cls, **kwargs):
schema = SchemaNode(Mapping(unknown="preserve"))
schema.add(SchemaNode(String(), name='label', missing=u''))
schema.add(
SchemaNode(String(), name='type', validator=OneOf(["annotation"])))
return schema
class WindSchema(base_schema.ObjTypeSchema):
'''
validate data after deserialize, before it is given back to pyGnome's
from_dict to set _state of object
'''
name = SchemaNode(String(), test_equal=False)
description = SchemaNode(String())
filename = FilenameSchema(isdatafile=True, update=False,
test_equal=False) #Thanks to CyTimeseries
updated_at = SchemaNode(LocalDateTime())
latitude = SchemaNode(Float())
longitude = SchemaNode(Float())
source_id = SchemaNode(String())
source_type = SchemaNode(String(),
validator=OneOf(wind_datasources._attr),
default='undefined',
missing='undefined')
units = SchemaNode(String(), default='m/s')
speed_uncertainty_scale = SchemaNode(Float())
timeseries = WindTimeSeriesSchema(
test_equal=False
) #Because comparing datetimevalue2d arrays does not play nice
extrapolation_is_allowed = SchemaNode(Boolean())
data_start = SchemaNode(LocalDateTime(),
read_only=True,
validator=convertible_to_seconds)
data_stop = SchemaNode(LocalDateTime(),
read_only=True,
validator=convertible_to_seconds)
class Category(BasicNode):
"""Webshop category entity
value:
<BasicNode> fields
__type__ : String # sortenuebersicht" | "category"
synonyms : sequence of SynonymsTranslation
text_attributes : sequence of TextAttribute
measure_attributes : sequence of MeasureAttribute
bool_attributes : sequence of BoolAttribute
weekmatrix_attributes : sequence of WeekmatrixAttribute
file_attributes : sequence of FileAttribute
link_attributes : sequence of LinkAttribute
"""
__type__ = String(validator=OneOf(["sortenuebersicht", "category"]))
synonyms = SynonymsTranslation(default={}, missing={}, required=False)
text_attributes = TextAttributes(default=[], missing=[], required=False)
measure_attributes = MeasureAttributes(default=[],
missing=[],
required=False)
bool_attributes = BoolAttributes(default=[], missing=[], required=False)
weekmatrix_attributes = WeekmatrixAttributes(default=[],
missing=[],
required=False)
file_attributes = FileAttributes(default=[], missing=[], required=False)
link_attributes = LinkAttributes(default=[], missing=[], required=False)
class ItemGroup(Category):
"""Webshop item group entity
value:
<BasicNode> fields
<Category> fields
__type__ : String # sortendetail
category_ids : sequence of IDList
description : StringTranslation
certificates : sequence of DList # psr | bioverita ...
qualities : sequence of Qualtity
"""
__type__ = String(validator=OneOf(["sortendetail"]))
category_ids = IDList(default=[], missing=[], required=False)
description = StringTranslation()
certificates = IDList(default=[], missing=[], required=False)
qualities = Qualtities(default=[], missing=[], required=False)
def definition(cls):
schema = SchemaNode(Mapping())
schema.add(SchemaNode(String(), name='name'))
schema.add(SchemaNode(String(), name='description'))
schema.add(
SchemaNode(String(), name='type', validator=OneOf(types.names)))
return schema
class ColanderSchemaTestModel(Base, ColanderAlchemyMixin):
__tablename__ = 'colander_schema_test'
id = sa.Column(BigInteger, autoincrement=True, primary_key=True)
foreign_key_field = sa.Column(None, sa.ForeignKey(RelatedClassA.id))
foreign_key_field2 = sa.Column(None, sa.ForeignKey(RelatedClassB.id))
foreign_key_field3 = sa.Column(None, sa.ForeignKey(RelatedClassC.id))
big_integer_field = sa.Column(BigInteger)
integer_field = sa.Column(sa.Integer, nullable=False)
numeric_field = sa.Column(sa.Numeric)
float_field = sa.Column(sa.Float)
datetime_field = sa.Column(sa.DateTime, index=True)
date_field = sa.Column(sa.Date)
time_field = sa.Column(sa.Time)
text_field = sa.Column(sa.Text)
unicode_field = sa.Column(sa.Unicode(255))
unicode_field2 = sa.Column(sa.Unicode(20))
unicode_field3 = sa.Column(sa.Unicode(20))
unicode_field4 = sa.Column(sa.Unicode(20))
unicode_text_field = sa.Column(sa.UnicodeText)
field_with_range = sa.Column(sa.Integer)
nullable_field = sa.Column(sa.Boolean, nullable=True)
not_nullable_field = sa.Column(sa.Boolean, nullable=False, default=False)
read_only_field = sa.Column(sa.Integer)
whitelisted_relation = orm.relationship(RelatedClassA)
read_only_relation = orm.relationship(RelatedClassB)
not_nullable_relation = orm.relationship(RelatedClassC)
__schema__ = {
'read_only_field': {
'readonly': True
},
'field_with_range': {
'validator': Range(min=1, max=99)
},
'whitelisted_relation': {},
'not_nullable_relation': {
'nullable': False
},
'unicode_field3': {
'validator': OneOf(['choice'])
},
'unicode_field4': {
'validator': All(OneOf(['choice']), Email())
}
}
class SearchSchema(MappingSchema):
radio = SchemaNode(String(),
location="body",
type='str',
validator=OneOf(RADIO_TYPE_KEYS),
missing='')
cell = CellsSchema(missing=())
wifi = WifisSchema(missing=())
def deferred_validate_post_content_type(node, kw):
"""Validate the addable content type for post requests."""
context = kw['context']
registry = kw['registry']
request = kw['request']
addables = registry.content.get_resources_meta_addable(context, request)
addable_iresources = [r.iresource for r in addables]
return OneOf(addable_iresources)
def validator(self, kw: dict):
from adhocracy_core.resources.principal import IGroup
context = kw['context']
groups = find_service(context, 'principals', 'groups')
groupids = [
'group:' + x for x, y in groups.items() if IGroup.providedBy(y)
]
return OneOf(groupids)
def validator(self, kw: dict):
"""Validator."""
workflow = kw['workflow']
if workflow is None:
states = []
else:
states = workflow._states.keys()
return OneOf(states)
class UnitsSchema(MappingSchema):
temperature = SchemaNode(String(),
description='SI units for temp',
validator=OneOf(_valid_temp_units))
# for now salinity only has one units
salinity = SchemaNode(String(),
description='SI units for salinity',
validator=OneOf(_valid_salinity_units))
# sediment load units? Concentration In Water?
sediment = SchemaNode(String(),
description='SI units for density',
validator=OneOf(_valid_sediment_units))
# wave height and fetch have distance units
wave_height = SchemaNode(String(),
description='SI units for distance',
validator=OneOf(_valid_dist_units))
fetch = SchemaNode(String(),
description='SI units for distance',
validator=OneOf(_valid_dist_units))
kinematic_viscosity = SchemaNode(String(),
description='SI units for viscosity',
validator=OneOf(_valid_kvis_units))
density = SchemaNode(String(),
description='SI units for density',
validator=OneOf(_valid_density_units))
class GeoLocateSchema(MappingSchema):
homeMobileCountryCode = SchemaNode(Integer(), missing=None)
homeMobileNetworkCode = SchemaNode(Integer(), missing=None)
radioType = SchemaNode(String(),
validator=OneOf(RADIO_STRINGS),
missing=None)
carrier = SchemaNode(String(), missing='')
cellTowers = CellTowersSchema(missing=())
wifiAccessPoints = WifiAccessPointsSchema(missing=())
class CellTowerSchema(MappingSchema):
cellId = SchemaNode(Integer(), missing=None)
locationAreaCode = SchemaNode(Integer(), missing=None)
mobileCountryCode = SchemaNode(Integer())
mobileNetworkCode = SchemaNode(Integer())
age = SchemaNode(Integer(), missing=0)
signalStrength = SchemaNode(Integer(), missing=0)
timingAdvance = SchemaNode(Integer(), missing=0)
# The fields below are extra fields which are not part of the
# official geolocate API
# radio is a FxOS specific undocumented workaround,
# radioType is a deliberate addition
radio = SchemaNode(String(), validator=OneOf(RADIO_STRINGS), missing=None)
radioType = SchemaNode(String(),
validator=OneOf(RADIO_STRINGS),
missing=None)
psc = SchemaNode(Integer(), missing=None)
class InventoryStatus(colander.SchemaNode):
"""Iventory status, Integer
values: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
You can buy only items with status 2, 7 or 8
"""
schema_type = colander.Integer
validator = OneOf([1, 2, 3, 4, 5, 6, 7, 8])
class OrdersGet(colander.MappingSchema):
"""Get Orders data
* status: pending | processing | complete
"""
status = String(validator=OneOf(["pending", "processing", "complete"]),
location="querystring")
def deferred_validate_aggregateby(node: SchemaNode, kw):
"""Validate if `value` is an catalog index name`."""
# TODO In the future we may have indexes where aggregateby doesn't make
# sense, e.g. username or email. We should have a blacklist to prohibit
# calling aggregateby on such indexes.
context = kw['context']
indexes = _get_indexes(context)
index_names = [x.__name__ for x in indexes if hasattr(x, 'unique_values')]
return OneOf(index_names)
class HomerSchema(MappingSchema):
q = SchemaNode(String(), location='querystring')
lang = SchemaNode(String(), location='querystring')
wt = SchemaNode(String(),
location='querystring',
missing='json',
validator=OneOf(['json']))
start = SchemaNode(Integer(), location='querystring')
rows = SchemaNode(Integer(), location='querystring')
class ActivitySchema(MappingSchema):
"""Activity entry."""
subject = Reference(reftype=SubjectReference)
type = SingleLine(validator=OneOf(
[activity_type.value for activity_type in ActivityType]))
object = Reference(reftype=ObjectReference)
target = Reference(reftype=TargetReference)
name = SingleLine()
published = DateTime()
class CellSchema(MappingSchema):
radio = SchemaNode(String(), validator=OneOf(RADIO_TYPE_KEYS), missing='')
mcc = SchemaNode(Integer(), missing=-1)
mnc = SchemaNode(Integer(), missing=-1)
lac = SchemaNode(Integer(), missing=-1)
cid = SchemaNode(Integer(), missing=-1)
psc = SchemaNode(Integer(), missing=-1)
asu = SchemaNode(Integer(), missing=-1)
signal = SchemaNode(Integer(), missing=0)
ta = SchemaNode(Integer(), missing=0)