def convert(self, model, field, field_args): # Check if it is overridden field if isinstance(field, FieldPlaceholder): return form.recreate_field(field.field) kwargs = { 'label': getattr(field, 'verbose_name', field.name), 'description': field.help_text or '', 'validators': [], 'filters': [], 'default': field.default } if field_args: kwargs.update(field_args) if field.required: kwargs['validators'].append(validators.Required()) elif not isinstance(field, ListField): kwargs['validators'].append(validators.Optional()) ftype = type(field).__name__ if field.choices: kwargs['choices'] = list(self._convert_choices(field.choices)) if ftype in self.converters: kwargs["coerce"] = self.coerce(ftype) if kwargs.pop('multiple', False): return fields.SelectMultipleField(**kwargs) return fields.SelectField(**kwargs) ftype = type(field).__name__ if hasattr(field, 'to_form_field'): return field.to_form_field(model, kwargs) override = self._get_field_override(field.name) if override: return override(**kwargs) if ftype in self.converters: return self.converters[ftype](model, field, kwargs)
def get_form(model, converter, base_class=form.BaseForm, only=None, exclude=None, field_args=None, allow_pk=False, extra_fields=None): """ Create form from peewee model and contribute extra fields, if necessary """ result = model_form(model, base_class=base_class, only=only, exclude=exclude, field_args=field_args, allow_pk=allow_pk, converter=converter) if extra_fields: for name, field in iteritems(extra_fields): setattr(result, name, form.recreate_field(field)) return result
def get_form(model, converter, base_class=form.BaseForm, only=None, exclude=None, field_args=None, extra_fields=None): """ Create a wtforms Form for a given mongoengine Document schema:: from flask_mongoengine.wtf import model_form from myproject.myapp.schemas import Article ArticleForm = model_form(Article) :param model: A mongoengine Document schema class :param base_class: Base form class to extend from. Must be a ``wtforms.Form`` subclass. :param only: An optional iterable with the property names that should be included in the form. Only these properties will have fields. :param exclude: An optional iterable with the property names that should be excluded from the form. All other properties will have fields. :param field_args: An optional dictionary of field names mapping to keyword arguments used to construct each field object. :param converter: A converter to generate the fields based on the model properties. If not set, ``ModelConverter`` is used. """ if isinstance(model, str): model = get_document(model) if not isinstance(model, (BaseDocument, DocumentMetaclass)): raise TypeError('Model must be a mongoengine Document schema') field_args = field_args or {} # Find properties properties = sorted(((k, v) for k, v in iteritems(model._fields)), key=lambda v: v[1].creation_counter) if only: props = dict(properties) def find(name): if extra_fields and name in extra_fields: return FieldPlaceholder(extra_fields[name]) p = props.get(name) if p is not None: return p raise ValueError('Invalid model property name %s.%s' % (model, name)) properties = ((p, find(p)) for p in only) elif exclude: properties = (p for p in properties if p[0] not in exclude) # Create fields field_dict = {} for name, p in properties: field = converter.convert(model, p, field_args.get(name)) if field is not None: field_dict[name] = field # Contribute extra fields if not only and extra_fields: for name, field in iteritems(extra_fields): field_dict[name] = form.recreate_field(field) field_dict['model_class'] = model return type(model.__name__ + 'Form', (base_class,), field_dict)