def validate(self, value): if len(value) != SHA1Field.hash_length: raise ShieldException('SHA1 value is wrong length', self.field_name, value) try: int(value, 16) except: raise ShieldException('SHA1 value is not hex', self.field_name, value)
def validate(self, value): if not URLField.URL_REGEX.match(value): raise ShieldException('Invalid URL', self.field_name, value) if self.verify_exists: import urllib2 try: request = urllib2.Request(value) urllib2.urlopen(request) except Exception: message = 'URL does not exist' raise ShieldException(message, self.field_name, value)
def validate(self, value): """Make sure that a list of valid fields is being used. """ if not isinstance(value, (dict, MultiValueDict)): raise ShieldException( 'Only dictionaries or MultiValueDict may be ' 'used in a DictField', self.field_name, value) if any(('.' in k or '$' in k) for k in value): raise ShieldException( 'Invalid dictionary key name - keys may not ' 'contain "." or "$" characters', self.field_name, value)
def validate(self, value): assert isinstance(value, (str, unicode)) if self.max_length is not None and len(value) > self.max_length: raise ShieldException('String value is too long', self.field_name, value) if self.min_length is not None and len(value) < self.min_length: raise ShieldException('String value is too short', self.uniq_field, value) if self.regex is not None and self.regex.match(value) is None: message = 'String value did not match validation regex', raise ShieldException(message, self.uniq_field, value)
def validate(self, value): if not isinstance(value, bson.objectid.ObjectId): try: value = bson.objectid.ObjectId(unicode(value)) except Exception, e: raise ShieldException('Invalid ObjectId', self.field_name, value)
def validate(self, value): if not isinstance(value, (basestring, str)): try: value = self.encoder.encode_hex(value) except Exception, e: raise ShieldException('Invalid IntField', self.field_name, value)
def validate(self, validate_all=False): """ Taken from dictshield Ensure that all fields' values are valid and that required fields are present. Throws a ShieldDocException if Document is invalid """ # Get a list of tuples of field names and their current values fields = [(field, getattr(self, name)) for name, field in self._fields.items()] # Ensure that each field is matched to a valid value errs = [] for field, value in fields: err = None # treat empty strings as nonexistent if value is not None and value != '': try: field._validate(value) except ShieldException, e: err = e except (ValueError, AttributeError, AssertionError): err = ShieldException('Invalid value', field.field_name, value)
def validate(self, value): try: value = self.number_class(value) except: raise ShieldException('Not %s' % self.number_type, self.field_name, value) if self.min_value is not None and value < self.min_value: raise ShieldException( '%s value below min_value: %s' % (self.number_type, self.min_value), self.field_name, value) if self.max_value is not None and value > self.max_value: raise ShieldException( '%s value above max_value: %s' % (self.number_type, self.max_value), self.field_name, value)
def _validate_helper(cls, field_inspector, values, validate_all=False, delete_rogues=True): """This is a convenience function that loops over the given values and attempts to validate them against the class definition. It only validates the data in values and does not guarantee a complete document is present. 'not present' is defined as not having a value OR having '' (or u'') as a value. """ if not hasattr(cls, '_fields'): raise ValueError('cls is not a Document instance') internal_fields = cls._get_internal_fields() # Create function for handling exceptions exceptions = list() handle_exception = cls._gen_handle_exception(validate_all, exceptions) # Create function for handling a flock of frakkin palins (rogue fields) data_fields = set(values.keys()) class_fields = list() handle_class_field = cls._gen_handle_class_field( delete_rogues, class_fields) # Loop across fields present in model for k, v in cls._fields.items(): # handle common id name if k is 'id': k = '_id' handle_class_field(k) # we don't accept internal fields from users if k in internal_fields and k in values: value_is_default = (values[k] is v.default) if not value_is_default: error_msg = 'Overwrite of internal fields attempted' e = ShieldException(error_msg, k, v) handle_exception(e) continue if field_inspector(k, v): datum = values[k] # if datum is None, skip if datum is None: continue # treat empty strings as empty values and skip if isinstance(datum, (str, unicode)) and \ len(datum.strip()) == 0: continue try: v.validate(datum) except ShieldException, e: handle_exception(e)
def validate(self, value): """Make sure that a list of valid fields is being used. """ if not isinstance(value, (list, tuple)): error_msg = 'Only lists and tuples may be used in a list field' raise ShieldException(error_msg, self.field_name, value) if not self.fields: # if we want everything to validate return for item in value: try: for field in self.fields: field.validate(item) except Exception, e: raise ShieldException('Invalid ListField item', self.field_name, str(item))
def _validate(self, value): # check choices if self.choices is not None: if value not in self.choices: raise ShieldException("Value must be one of %s." % unicode(self.choices)) # check validation argument if self.validation is not None: if callable(self.validation): if not self.validation(value): raise ShieldException('Value does not match custom' \ 'validation method.') else: raise ValueError('validation argument must be a callable.') self.validate(value)
def validate(self, value): if not isinstance(value, decimal.Decimal): if not isinstance(value, basestring): value = str(value) try: value = decimal.Decimal(value) except Exception: raise ShieldException('Could not convert to decimal', self.field_name, value) if self.min_value is not None and value < self.min_value: raise ShieldException( 'Decimal value below min_value: %s' % self.min_value, self.field_name, value) if self.max_value is not None and value > self.max_value: raise ShieldException( 'Decimal value above max_value: %s' % self.max_value, self.field_name, value)
def validate(self, value): """Make sure that the document instance is an instance of the EmbeddedDocument subclass provided when the document was defined. """ # Using isinstance also works for subclasses of self.document if not isinstance(value, self.document_type): raise ShieldException( 'Invalid embedded document instance ' 'provided to an EmbeddedDocumentField', self.field_name, value) self.document_type.validate(value)
def __init__(self, document_type, **kwargs): is_embeddable = lambda dt: issubclass(dt, EmbeddedDocument) if not isinstance(document_type, basestring): if not document_type or not is_embeddable(document_type): raise ShieldException( 'Invalid embedded document class ' 'provided to an EmbeddedDocumentField', self.field_name, document_type) self.document_type_obj = document_type super(EmbeddedDocumentField, self).__init__(**kwargs)
def validate(self, value): """Make sure the value is a valid uuid representation. See http://docs.python.org/library/uuid.html for accepted formats. """ if not isinstance(value, (uuid.UUID, )): try: uuid.UUID(value) except ValueError: raise ShieldException('Not a valid UUID value', self.field_name, value)
def validate(self): """Ensure that all fields' values are valid and that required fields are present. """ # Get a list of tuples of field names and their current values fields = [(field, getattr(self, name)) for name, field in self._fields.items()] # Ensure that each field is matched to a valid value for field, value in fields: # treat empty strings is nonexistent if value is not None and value != '': try: field._validate(value) except (ValueError, AttributeError, AssertionError): raise ShieldException('Invalid value', field.field_name, value) elif field.required: raise ShieldException('Required field missing', field.field_name, value)
def validate(self, value): """Make sure that a geo-value is of type (x, y) """ if not len(value) == 2: raise ShieldException('Value must be a two-dimensional point', self.field_name, value) if isinstance(value, dict): for v in value.values(): if not isinstance(v, (float, int)): error_msg = 'Both values in point must be float or int' raise ShieldException(error_msg, self.field_name, value) elif isinstance(value, (list, tuple)): if (not isinstance(value[0], (float, int)) and not isinstance(value[1], (float, int))): error_msg = 'Both values in point must be float or int' raise ShieldException(error_msg, self.field_name, value) else: raise ShieldException( 'GeoPointField can only accept tuples, ' 'lists of (x, y), or dicts of {k1: v1, ' 'k2: v2}', self.field_name, value)
class BaseDocument(object): def __init__(self, **values): self._data = {} minimized_field_map = {} # Assign default values to instance for attr_name, attr_value in self._fields.items(): # Use default value if present value = getattr(self, attr_name, None) setattr(self, attr_name, value) if attr_value.minimized_field_name: field_name = attr_value.minimized_field_name minimized_field_map[field_name] = attr_value.uniq_field # Assign initial values to instance for attr_name, attr_value in values.items(): try: if attr_name == '_id': attr_name = 'id' setattr(self, attr_name, attr_value) if attr_name in minimized_field_map: setattr(self, minimized_field_map[attr_name], attr_value) # Put a diaper on the keys that don't belong and send 'em home except AttributeError: pass def validate(self, validate_all=False): """Ensure that all fields' values are valid and that required fields are present. Throws a ShieldDocException if Document is invalid """ # Get a list of tuples of field names and their current values fields = [(field, getattr(self, name)) for name, field in self._fields.items()] # Ensure that each field is matched to a valid value errs = [] for field, value in fields: err = None # treat empty strings as nonexistent if value is not None and value != '': try: field._validate(value) except ShieldException, e: err = e except (ValueError, AttributeError, AssertionError): err = ShieldException('Invalid value', field.field_name, value) elif field.required: err = ShieldException('Required field missing', field.field_name, value)
def date_to_iso8601(cls, dt, format): """Classmethod that goes the opposite direction of iso8601_to_date. Defaults to using isoformat(), but can use the optional format argument either as a strftime format string or as a custom date formatting function or lambda. """ if isinstance(format, str): iso_dt = dt.strftime(format) elif hasattr(format, '__call__'): iso_dt = format(dt) else: raise ShieldException( 'DateTimeField format must be a string or callable') return iso_dt
class Model(six.with_metaclass(ModelMetaClass)): #__metaclass__ = ModelMetaClass def __init__(self): self._data = {} def to_python(self): """ Returns a Python dictionary representing the Document's meta-structure and values. """ fun = lambda f, v: f.for_python(v) data = self._to_fields(fun) return data def _to_fields(self, field_converter): """ Returns a Python dictionary representing the Document's meta-structure and values. """ data = {} # First map the subclasses of BaseField for field_name, field in self._fields.items(): value = getattr(self, field_name, None) if value is not None: if field.id_field: data[field.field_name] = field_converter(field, value) else: data[field.uniq_field] = field_converter(field, value) return data def set_dict(self, dict_obj): self.dict_obj = dict_obj self.set_attr(dict_obj) def set_attr(self, dict_obj): for key, value in dict_obj.items(): if isinstance(value, dict): self.set_attr(value) if hasattr(self, key): setattr(self, key, value) def save_wide(self, key, ttl=None): """ Insert/updates a column into dynamic column family """ if not self.column_key: raise ValueError("Wide table requires a column key") try: if isinstance(self.column_key, basestring): self.column_key = uuid.UUID(self.column_key) except ValueError: print '-' self.objects.insert(str(key), { self.column_key: str(self.to_python()) }, ttl=ttl) def save(self, cols=None, ttl=None): """ Insert/updates a row """ try: key = getattr(self, self._key_field) except AttributeError: raise AttributeError("Key not set") if hasattr(self._meta, 'family_type') and \ self._meta.family_type == ColumnFamilyTypes.WIDE: return self.save_wide(key, ttl=ttl) row = self.to_python() if self._key_field in row: del row[self._key_field] self.objects.insert(key, row, ttl=ttl) def dict(self): """ Use this to serialise the object back into a dict object """ data = {} if hasattr(self, 'key'): data['key'] = str(self.key) if hasattr(self, 'column_key'): data['column_key'] = str(self.column_key) for key, value in self._data.items(): if isinstance(value, uuid.UUID): value = str(value) elif isinstance(value, datetime.datetime): value = value.strftime('%m/%d/%Y') if value is not None: data[key] = value return data # @property # def column_key(self): # return self._column_key # # @column_key.setter # def column_key(self, column_name): # self._column_key = column_name def validate(self, validate_all=False): """ Taken from dictshield Ensure that all fields' values are valid and that required fields are present. Throws a ShieldDocException if Document is invalid """ # Get a list of tuples of field names and their current values fields = [(field, getattr(self, name)) for name, field in self._fields.items()] # Ensure that each field is matched to a valid value errs = [] for field, value in fields: err = None # treat empty strings as nonexistent if value is not None and value != '': try: field._validate(value) except ShieldException, e: err = e except (ValueError, AttributeError, AssertionError): err = ShieldException('Invalid value', field.field_name, value) elif field.required: err = ShieldException('Required field missing', field.field_name, value)
def validate(self, value): if len(value) != BCryptField.hash_length: raise ShieldException('BCrypt value is wrong length', self.field_name, value) return value
def validate(self, value): if not isinstance(value, bool): raise ShieldException('Not a boolean', self.field_name, value)
def validate(self, value): try: bson.objectid.ObjectId(unicode(value)) except Exception, e: raise ShieldException('Invalid ObjectId', self.field_name, value)
def for_python(self, value): try: return bson.objectid.ObjectId(unicode(value)) except Exception, e: raise ShieldException('Invalid ObjectId', self.field_name, value)
def validate(self, value): if not EmailField.EMAIL_REGEX.match(value): raise ShieldException('Invalid email address', self.field_name, value)
def validate(self, value): if not isinstance(value, datetime.datetime): raise ShieldException('Not a datetime', self.field_name, value)