コード例 #1
0
ファイル: observation.py プロジェクト: amolk4games/ichnaea
class ValidWifiReportSchema(ValidWifiSignalSchema):
    """A schema which validates the wifi specific fields in a report."""

    mac = MacNode(colander.String())

    def validator(self, node, cstruct):
        super(ValidWifiReportSchema, self).validator(node, cstruct)

        accuracy = cstruct.get('accuracy', None)
        if (accuracy is not None and accuracy > constants.MAX_ACCURACY_WIFI):
            raise colander.Invalid(node, 'Invalid accuracy.')
コード例 #2
0
class ValidWifiLookupSchema(colander.MappingSchema, ValidatorNode):
    """A schema which validates the fields in a WiFi lookup."""

    macAddress = MacNode(colander.String())
    ssid = DefaultNode(colander.String(), missing=None)

    age = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(constants.MIN_AGE, constants.MAX_AGE),
    )

    channel = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(constants.MIN_WIFI_CHANNEL,
                                 constants.MAX_WIFI_CHANNEL),
    )

    frequency = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(constants.MIN_WIFI_FREQUENCY,
                                 constants.MAX_WIFI_FREQUENCY),
    )

    signalStrength = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(constants.MIN_WIFI_SIGNAL,
                                 constants.MAX_WIFI_SIGNAL),
    )

    signalToNoiseRatio = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(constants.MIN_WIFI_SNR,
                                 constants.MAX_WIFI_SNR),
    )

    def deserialize(self, data):
        data = super(ValidWifiLookupSchema, self).deserialize(data)
        if data and data is not colander.drop and data is not colander.null:
            channel = data.get("channel")
            frequency = data.get("frequency")
            if (frequency is None
                    and channel is not None) or (frequency is not None
                                                 and channel is None):
                # shallow copy
                data = dict(data)
                data["channel"], data["frequency"] = channel_frequency(
                    channel, frequency)

        return data
class ValidBlueReportSchema(colander.MappingSchema, ValidatorNode):
    """A schema which validates the Bluetooth specific fields in a report."""

    mac = MacNode(colander.String())

    age = DefaultNode(colander.Integer(),
                      missing=None,
                      validator=colander.Range(constants.MIN_AGE,
                                               constants.MAX_AGE))

    signal = DefaultNode(colander.Integer(),
                         missing=None,
                         validator=colander.Range(constants.MIN_BLUE_SIGNAL,
                                                  constants.MAX_BLUE_SIGNAL))
class ValidBlueLookupSchema(colander.MappingSchema, ValidatorNode):
    """A schema which validates the fields in a Bluetooth lookup."""

    macAddress = MacNode(colander.String())
    name = DefaultNode(colander.String(), missing=None)

    age = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(
            constants.MIN_AGE, constants.MAX_AGE))

    signalStrength = DefaultNode(
        colander.Integer(),
        missing=None,
        validator=colander.Range(
            constants.MIN_BLUE_SIGNAL, constants.MAX_BLUE_SIGNAL))
class ValidWifiReportSchema(colander.MappingSchema, ValidatorNode):
    """A schema which validates the wifi specific fields in a report."""

    mac = MacNode(colander.String())

    age = DefaultNode(colander.Integer(),
                      missing=None,
                      validator=colander.Range(constants.MIN_AGE,
                                               constants.MAX_AGE))

    channel = DefaultNode(colander.Integer(),
                          missing=None,
                          validator=colander.Range(constants.MIN_WIFI_CHANNEL,
                                                   constants.MAX_WIFI_CHANNEL))

    frequency = DefaultNode(colander.Integer(),
                            missing=None,
                            validator=colander.Range(
                                constants.MIN_WIFI_FREQUENCY,
                                constants.MAX_WIFI_FREQUENCY))

    signal = DefaultNode(colander.Integer(),
                         missing=None,
                         validator=colander.Range(constants.MIN_WIFI_SIGNAL,
                                                  constants.MAX_WIFI_SIGNAL))

    snr = DefaultNode(colander.Integer(),
                      missing=None,
                      validator=colander.Range(constants.MIN_WIFI_SNR,
                                               constants.MAX_WIFI_SNR))

    def deserialize(self, data):
        data = super(ValidWifiReportSchema, self).deserialize(data)
        if (data and data is not colander.drop and data is not colander.null):
            channel = data.get('channel')
            frequency = data.get('frequency')
            if ((frequency is None and channel is not None)
                    or (frequency is not None and channel is None)):
                # shallow copy
                data = dict(data)
                data['channel'], data['frequency'] = channel_frequency(
                    channel, frequency)

        return data
コード例 #6
0
ファイル: schema.py プロジェクト: amolk4games/ichnaea
class ValidBlueLookupSchema(ValidBlueSignalSchema):
    """A schema which validates the fields in a Bluetooth lookup."""

    mac = MacNode(colander.String())
    name = DefaultNode(colander.String(), missing=None)
コード例 #7
0
ファイル: schema.py プロジェクト: amolk4games/ichnaea
class ValidWifiLookupSchema(ValidWifiSignalSchema):
    """A schema which validates the fields in a WiFi lookup."""

    mac = MacNode(colander.String())
    ssid = DefaultNode(colander.String(), missing=None)