def __init__(self, data=None, auto_id='id_%s', prefix=None, initial=None, error_class=forms.util.ErrorList, label_suffix=':', empty_permitted=False, instance=None): assert isinstance(instance, (types.NoneType, Model)), \ 'instance must be a mongoengine document, ' \ 'not %s' % type(instance).__name__ assert hasattr(self, 'Meta'), 'Meta class is needed to use RediscoForm' if instance is None: if self._meta.model is None: raise ValueError('RediscoForm has no model class specified.') self.instance = self._meta.model() object_data = {} self.instance._adding = True else: self.instance = instance self.instance._adding = False object_data = {} for field_name, field in iter_valid_fields(self._meta): field_data = getattr(instance, field_name) object_data[field_name] = field_data if initial is not None: object_data.update(initial) self._validate_unique = False super(RediscoForm, self).__init__(data, None, auto_id, prefix, object_data, error_class, label_suffix, empty_permitted)
def __new__(cls, name, bases, attrs): fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields attrs['base_fields'] = SortedDict(fields) if ('Meta' in attrs and hasattr(attrs['Meta'], 'model') and issubclass(attrs['Meta'].model, Model)): doc_fields = SortedDict() formfield_generator = getattr(attrs['Meta'], 'formfield_generator', RediscoFormFieldGenerator)() for field_name, field in iter_valid_fields(attrs['Meta']): doc_fields[field_name] = formfield_generator.generate( field_name, field) doc_fields[field_name].clean = redisco_validate_wrapper( doc_fields[field_name].clean, field.validate) doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields attrs['_meta'] = attrs.get('Meta', object()) return super(RediscoFormMetaClass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): # get all valid existing Fields and sort them fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) # get all Fields from base classes for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields # add the fields as "our" base fields attrs['base_fields'] = SortedDict(fields) # Meta class available? if 'Meta' in attrs and hasattr(attrs['Meta'], 'document') and \ issubclass(attrs['Meta'].document, BaseDocument): doc_fields = SortedDict() formfield_generator = getattr(attrs['Meta'], 'formfield_generator', \ MongoFormFieldGenerator)() # walk through the document fields for field_name, field in iter_valid_fields(attrs['Meta']): # add field and override clean method to respect mongoengine-validator doc_fields[field_name] = formfield_generator.generate(field_name, field) if doc_fields[field_name] is not None: doc_fields[field_name].clean = mongoengine_validate_wrapper( doc_fields[field_name].clean, field._validate) # write the new document fields to base_fields doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields # sorting with respect to Meta.fields (like django forms) def get_indexes(x, y): meta_field_list = getattr(attrs['Meta'], 'fields') try: return meta_field_list.index(x[0]), meta_field_list.index(y[0]) except ValueError: return None, None if 'Meta' in attrs and hasattr(attrs['Meta'], 'fields'): flds = attrs['base_fields'].items() flds.sort(lambda x, y: cmp(*get_indexes(x,y))) attrs['base_fields']=SortedDict(flds) # maybe we need the Meta class later attrs['_meta'] = attrs.get('Meta', object()) return super(MongoFormMetaClass, cls).__new__(cls, name, bases, attrs)
def save(self, commit=True): for field_name, field in iter_valid_fields(self._meta): setattr(self.instance, field_name, self.cleaned_data.get(field_name)) if commit: self.instance.save() return self.instance
def save(self, commit=True): """save the instance or create a new one..""" # walk through the document fields for field_name, field in iter_valid_fields(self._meta): setattr(self.instance, field_name, self.cleaned_data.get(field_name)) if commit: self.instance.save() return self.instance
def __new__(cls, name, bases, attrs): # get all valid existing Fields and sort them fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) # get all Fields from base classes for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields # add the fields as "our" base fields # discards fields specified for embeddeddocuments attrs['base_fields'] = SortedDict([f for f in fields if '__' not in f[0]]) # Meta class available? if 'Meta' in attrs and hasattr(attrs['Meta'], 'document') and \ issubclass(attrs['Meta'].document, BaseDocument): labels = getattr(attrs['Meta'], 'labels', {}) doc_fields = SortedDict() meta_fields = list(getattr(attrs['Meta'], 'fields', [])) formfield_generator = getattr(attrs['Meta'], 'formfield_generator', \ MongoFormFieldGenerator)(meta_fields, overriden_fields=fields, exclude=getattr(attrs['Meta'], 'exclude', ())) overriden_fields = dict(fields) # walk through the document fields for field_name, field in iter_valid_fields(attrs['Meta']): if field_name == '_cls': continue # add field and override clean method to respect mongoengine-validator if field_name in overriden_fields: doc_fields[field_name] = overriden_fields[field_name] else: doc_fields[field_name] = formfield_generator.generate(field_name, field) doc_fields[field_name].clean = mongoengine_validate_wrapper( doc_fields[field_name].clean, field._validate, field.required) if labels.get(field_name): doc_fields[field_name].label = labels[field_name] # write the new document fields to base_fields doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields # maybe we need the Meta class later attrs['_meta'] = attrs.get('Meta', object()) return super(MongoFormMetaClass, cls).__new__(cls, name, bases, attrs)
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=forms.util.ErrorList, label_suffix=':', empty_permitted=False, instance=None): """ initialize the form""" assert isinstance(instance, (types.NoneType, BaseDocument)), \ 'instance must be a mongoengine document, not %s' % \ type(instance).__name__ assert hasattr(self, 'Meta'), 'Meta class is needed to use MongoForm' # new instance or updating an existing one? if instance is None: if self._meta.document is None: raise ValueError('MongoForm has no document class specified.') self.instance = self._meta.document() object_data = {} self.instance._adding = True else: self.instance = instance self.instance._adding = False object_data = {} # walk through the document fields for field_name, field in iter_valid_fields(self._meta): # add field data if needed if not hasattr(instance, field_name): continue field_data = getattr(instance, field_name) if not self._meta.document._dynamic: fields = self._meta.document._fields # add dfields if document is dynamic elif hasattr(self._meta.document, '_dfields'): fields = self._meta.document._dfields else: continue if field_name in fields: _field = fields[field_name] if isinstance(_field, ReferenceField): field_data = field_data and str(field_data.id) object_data[field_name] = field_data # additional initial data available? if initial is not None: object_data.update(initial) self._validate_unique = False super(MongoForm, self).__init__(data, files, auto_id, prefix, object_data, error_class, label_suffix, empty_permitted)
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=forms.util.ErrorList, label_suffix=':', empty_permitted=False, instance=None): """ initialize the form""" assert isinstance(instance, (types.NoneType, BaseDocument)), \ 'instance must be a mongoengine document, not %s' % \ type(instance).__name__ assert hasattr(self, 'Meta'), 'Meta class is needed to use MongoForm' # new instance or updating an existing one? if instance is None: if self._meta.document is None: raise ValueError('MongoForm has no document class specified.') self.instance = self._meta.document() object_data = {} self.instance._adding = True else: self.instance = instance self.instance._adding = False object_data = {} # walk through the document fields for field_name, field in iter_valid_fields(self._meta): # add field data if needed field_data = getattr(instance, field_name) if isinstance(self._meta.document._fields[field_name], ReferenceField): # field data could be None for not populated refs field_data = field_data and str(field_data.id) object_data[field_name] = field_data # additional initial data available? if initial is not None: object_data.update(initial) self._validate_unique = False super(MongoForm, self).__init__(data, files, auto_id, prefix, object_data, error_class, label_suffix, empty_permitted)
def __init__( self, data=None, auto_id="id_%s", prefix=None, initial=None, error_class=forms.util.ErrorList, label_suffix=":", empty_permitted=False, instance=None, ): """ initialize the form""" assert isinstance(instance, (types.NoneType, BaseDocument)), ( "instance must be a mongoengine document, not %s" % type(instance).__name__ ) assert hasattr(self, "Meta"), "Meta class is needed to use MongoForm" # new instance or updating an existing one? if instance is None: if self._meta.document is None: raise ValueError("MongoForm has no document class specified.") self.instance = self._meta.document() object_data = {} self.instance._adding = True else: self.instance = instance self.instance._adding = False object_data = {} # walk through the document fields for field_name, field in iter_valid_fields(self._meta): # add field data if needed field_data = getattr(instance, field_name) if isinstance(self._meta.document._fields[field_name], ReferenceField): field_data = str(field_data.id) object_data[field_name] = field_data # additional initial data available? if initial is not None: object_data.update(initial) self._validate_unique = False super(MongoForm, self).__init__( data, None, auto_id, prefix, object_data, error_class, label_suffix, empty_permitted )
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=forms.util.ErrorList, label_suffix=':', empty_permitted=False, instance=None): """ initialize the form""" assert isinstance(instance, (types.NoneType, BaseDocument)), \ 'instance must be a mongoengine document, not %s' % \ type(instance).__name__ assert hasattr(self, 'Meta'), 'Meta class is needed to use MongoForm' # new instance or updating an existing one? if instance is None: if self._meta.document is None: raise ValueError('MongoForm has no document class specified.') self.instance = self._meta.document() object_data = {} self.instance._adding = True else: self.instance = instance self.instance._adding = False object_data = {} # walk through the document fields for field_name, field in iter_valid_fields(self._meta): # add field data if needed field_data = getattr(instance, field_name) if isinstance(self._meta.document._fields[field_name], ReferenceField): # field data could be None for not populated refs field_data = field_data and str(field_data.id) object_data[field_name] = field_data # additional initial data available? if initial is not None: object_data.update(initial) self._validate_unique = False super(MongoForm, self).__init__(data, files, auto_id, prefix, object_data, error_class, label_suffix, empty_permitted) if prefix: for k, v in self.fields.items(): if isinstance(v, FormsetField): v.widget.name = "%s-%s" % (prefix, v.widget.name)
def __new__(cls, name, bases, attrs): # get all valid existing Fields and sort them fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) # get all Fields from base classes for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields # add the fields as "our" base fields attrs['base_fields'] = SortedDict(fields) # Meta class available? if 'Meta' in attrs and hasattr(attrs['Meta'], 'document') and \ issubclass(attrs['Meta'].document, BaseDocument): doc_fields = SortedDict() formfield_generator = getattr(attrs['Meta'], 'formfield_generator', \ MongoFormFieldGenerator)() dict_fields = dict(fields) # walk through the document fields for field_name, field in iter_valid_fields(attrs['Meta']): # add field and override clean method to respect mongoengine-validator if field_name in dict_fields: doc_fields[field_name] = dict_fields[field_name] else: doc_fields[field_name] = formfield_generator.generate(field_name, field) doc_fields[field_name].clean = mongoengine_validate_wrapper( doc_fields[field_name].clean, field._validate) # write the new document fields to base_fields doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields # maybe we need the Meta class later attrs['_meta'] = attrs.get('Meta', object()) return super(MongoFormMetaClass, cls).__new__(cls, name, bases, attrs)