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)