def getForm( tag ):
     f = model_form( DynamicHTML )
     if id is None:
         return f()
     html = DynamicHTML.getHTMLbyTag( tag )
     form  = f( None, html )
     return form

    def test_not_implemented_properties(self):
        # This should not raise NotImplementedError.
        form_class = model_form(AllPropertiesModel)

        # These should be set.
        self.assertEqual(hasattr(form_class, 'prop_string'), True)
        self.assertEqual(hasattr(form_class, 'prop_byte_string'), True)
        self.assertEqual(hasattr(form_class, 'prop_boolean'), True)
        self.assertEqual(hasattr(form_class, 'prop_integer'), True)
        self.assertEqual(hasattr(form_class, 'prop_float'), True)
        self.assertEqual(hasattr(form_class, 'prop_date_time'), True)
        self.assertEqual(hasattr(form_class, 'prop_date'), True)
        self.assertEqual(hasattr(form_class, 'prop_time'), True)
        self.assertEqual(hasattr(form_class, 'prop_string_list'), True)
        self.assertEqual(hasattr(form_class, 'prop_reference'), True)
        self.assertEqual(hasattr(form_class, 'prop_self_refeference'), True)
        self.assertEqual(hasattr(form_class, 'prop_blob'), True)
        self.assertEqual(hasattr(form_class, 'prop_text'), True)
        self.assertEqual(hasattr(form_class, 'prop_category'), True)
        self.assertEqual(hasattr(form_class, 'prop_link'), True)
        self.assertEqual(hasattr(form_class, 'prop_email'), True)
        self.assertEqual(hasattr(form_class, 'prop_geo_pt'), True)
        self.assertEqual(hasattr(form_class, 'prop_phone_number'), True)
        self.assertEqual(hasattr(form_class, 'prop_postal_address'), True)
        self.assertEqual(hasattr(form_class, 'prop_rating'), True)

        # These should NOT be set.
        self.assertEqual(hasattr(form_class, 'prop_list'), False)
        self.assertEqual(hasattr(form_class, 'prop_user'), False)
        self.assertEqual(hasattr(form_class, 'prop_im'), False)

    def test_field_attributes(self):
        form_class = model_form(Author, field_args={
            'name': {
                'label': 'Full name',
                'description': 'Your name',
            },
            'age': {
                'label': 'Age',
                'validators': [validators.NumberRange(min=14, max=99)],
            },
            'city': {
                'label': 'City',
                'description': 'The city in which you live, not the one in which you were born.',
            },
            'is_admin': {
                'label': 'Administrative rights',
            },
        })
        form = form_class()

        self.assertEqual(form.name.label.text, 'Full name')
        self.assertEqual(form.name.description, 'Your name')

        self.assertEqual(form.age.label.text, 'Age')

        self.assertEqual(form.city.label.text, 'City')
        self.assertEqual(form.city.description, 'The city in which you live, not the one in which you were born.')

        self.assertEqual(form.is_admin.label.text, 'Administrative rights')

    def get(self):
        
        self.context['message'] = 'Hello, World!'
        if self.request.args.has_key('key') and\
           self.request.args.has_key('remove'):
            
            key =  self.request.args.get('key')
            obj = SiteMonitor.getByID(key)
            obj.delete()
            
            return redirect('/sites')
        
        elif self.request.args.has_key('key'):
            key =  self.request.args.get('key')
            obj = SiteMonitor.getByID(key)
            
            MyForm = model_form(SiteMonitor, SiteMonitorForm)
            form = MyForm(self.request.form, obj)

            self.context['form'] = form
            
        else:
            self.context['form'] = SiteMonitorForm()
        
        return self.render_response('views/manage_sites.html', **self.context)

    def get_form(self, **kwargs):
        """Erzeuge Formularklasse für das Model"""

        # Erstmal nur das Form zurückgeben.
        # Soll sich doch jeder selbst um 'only' und 'exclude' kümmern,
        # bei model_form gehen aber leider alle Labels und Descriptions verloren.
        if hasattr(self, 'form'):
            return getattr(self, 'form')

        if self.exclude is None:
            exclude = []
        else:
            exclude = list(self.exclude)

        defaults = {
            'base_class': self.form,
            'only': self.fields,
            'exclude': (exclude + kwargs.get('exclude', [])) or None,
        }

        klass = model_form(self.model, **defaults)

        # label könnte man noch setzbar machen
        for blob_upload_field in self.blob_upload_fields:
            field = wtforms.FileField()
            setattr(klass, blob_upload_field, field)

        return klass

    def test_required_field(self):
        form_class = model_form(Author)

        form = form_class()
        self.assertEqual(form.name.flags.required, True)
        self.assertEqual(form.city.flags.required, False)
        self.assertEqual(form.age.flags.required, True)
        self.assertEqual(form.is_admin.flags.required, False)

    def test_default_value(self):
        form_class = model_form(Author)

        form = form_class()
        self.assertEqual(form.name.default, None)
        self.assertEqual(form.city.default, None)
        self.assertEqual(form.age.default, None)
        self.assertEqual(form.is_admin.default, False)

def model_form(model, *args, **kwargs):
    """
    Generates a Form class automatically from a Model class.
    For more information an the full list of arguments, see the `wtforms documentation <http://wtforms.simplecodes.com/docs/1.0.2/ext.html#module-wtforms.ext.appengine>`_.
    """
    if issubclass(model, db.Model):
        return wtfdb.model_form(model, *args, **kwargs)
    elif issubclass(model, ndb.Model):
        return wtfndb.model_form(model, *args, **kwargs)

def edit(id):
    MyForm = model_form(MyModel, Form)
    model = MyModel.get(id)
    form = MyForm(request.form, model)

    if form.validate_on_submit():
        form.populate_obj(model)
        model.put() 
        flash("MyModel updated")
        return redirect(url_for("index"))
    return render_template("edit.html", form=form)

    def test_model_form_only(self):
        form_class = model_form(Author, only=['name', 'age'])

        self.assertEqual(hasattr(form_class, 'name'), True)
        self.assertEqual(hasattr(form_class, 'city'), False)
        self.assertEqual(hasattr(form_class, 'age'), True)
        self.assertEqual(hasattr(form_class, 'is_admin'), False)

        form = form_class()
        self.assertEqual(isinstance(form.name, f.TextField), True)
        self.assertEqual(isinstance(form.age, f.IntegerField), True)

    def test_populate_form(self):
        entity = Author(key_name='test', name='John', city='Yukon', age=25, is_admin=True)
        entity.put()

        obj = Author.get_by_key_name('test')
        form_class = model_form(Author)

        form = form_class(obj=obj)
        self.assertEqual(form.name.data, 'John')
        self.assertEqual(form.city.data, 'Yukon')
        self.assertEqual(form.age.data, 25)
        self.assertEqual(form.is_admin.data, True)

 def get(self, key):
     
     _m = db.get(db.Key(key))
     if _m is not None:
         form = model_form(_m,exclude=_m.FORM_EXCLUDE)
         form.submit = fields.SubmitField()
         if self.request.args.get('edit', False):
             editform = True
         else:
             editform = False
     
     return self.render('admin/crud-view.html', object=_m, form=form(self.request.form, obj=_m), editform=editform)

def edit(id):
    MyForm = model_form(BlogPost, Form)
    post = BlogPost.get_by_id(int(id))
    form = MyForm(request.form, post)

    if request.method == "POST":
        form.populate_obj(post)
        post.put()
        print post
        flash("Post updated")
        return redirect(url_for("admin_view"))
    return render_template("edit.html", form=form)

    def test_model_form_basic(self):
        form_class = model_form(Author)

        self.assertEqual(hasattr(form_class, 'name'), True)
        self.assertEqual(hasattr(form_class, 'age'), True)
        self.assertEqual(hasattr(form_class, 'city'), True)
        self.assertEqual(hasattr(form_class, 'is_admin'), True)

        form = form_class()
        self.assertEqual(isinstance(form.name, f.TextField), True)
        self.assertEqual(isinstance(form.city, f.TextField), True)
        self.assertEqual(isinstance(form.age, f.IntegerField), True)
        self.assertEqual(isinstance(form.is_admin, f.BooleanField), True)

    def test_datetime_model(self):
        """Fields marked as auto_add / auto_add_now should not be included."""
        form_class = model_form(DateTimeModel)

        self.assertEqual(hasattr(form_class, 'prop_date_time_1'), True)
        self.assertEqual(hasattr(form_class, 'prop_date_time_2'), False)
        self.assertEqual(hasattr(form_class, 'prop_date_time_3'), False)

        self.assertEqual(hasattr(form_class, 'prop_date_1'), True)
        self.assertEqual(hasattr(form_class, 'prop_date_2'), False)
        self.assertEqual(hasattr(form_class, 'prop_date_3'), False)

        self.assertEqual(hasattr(form_class, 'prop_time_1'), True)
        self.assertEqual(hasattr(form_class, 'prop_time_2'), False)
        self.assertEqual(hasattr(form_class, 'prop_time_3'), False)

    def test_reference_property(self):
        keys = set(['__None'])
        for name in ['foo', 'bar', 'baz']:
            author = Author(name=name, age=26)
            author.put()
            keys.add(str(author.key()))

        form_class = model_form(Book)
        form = form_class()

        for key, name, value in form.author.iter_choices():
            assert key in keys
            keys.remove(key)

        assert not keys

    def test_reference_property(self):
        keys = ['__None']
        for name in ['foo', 'bar', 'baz']:
            author = Author(name=name, age=26)
            author.put()
            keys.append(str(author.key()))

        form_class = model_form(Book)
        form = form_class()

        choices = []
        i = 0
        for key, name, value in form.author.iter_choices():
            self.assertEqual(key, keys[i])
            i += 1

    def get_context(self, slug=None):
        postform = model_form(Post, exclude='slug, datepublished')

        if slug:
            post = Post.all().filter('slug =', slug).get()
            if request.method == 'POST':
                form = postform(request.form, inital=post._entity)
            else:
                form = postform(obj=post)
        else:
            post = Post(title='Untitled', content='Empty', slug='Empty')
            form = postform(request.form)

        context = {
            "post": post,
            "form": form,
            "create": slug is None
        }
        return context

def add_notes(agency):
 	MyForm = model_form(ProviderNotes, Form)
 	entity = db.Query(ProviderNotes).filter('provider_name =', agency).get()
 	if entity != None:
		form = MyForm(request.form, obj=entity)
		if form.validate_on_submit():
			form.populate_obj(entity)
			entity.put()
			flash(u'Example successfully saved.', 'success')
			return redirect(url_for('list_provs'))
	else:
		form = MyForm(request.form)
		if form.validate_on_submit():
			notes = ProviderNotes(
				provider_name=agency,
				provider_notes=form.provider_notes.data)
			notes.put()
			flash(u'Example successfully saved.', 'success')
			return redirect(url_for('list_provs'))
	return render_template('provider_notes.html', form=form, programs=list_addresses(agency), pname=agency, notes=list_notes(agency))

def create(model, only=None, exclude=None, base_class=WTForm, converter=None,
           pre_init=None, post_init=None, pre_save=None, post_save=None,
           field_validators=None):
  '''Factory for admin forms.

  Input:
    * model - class to be used for wtforms creation
    * only - tuple of field names that should be exposed in the form
    * exclude - marked separately as read-only when editing,
                but still editable for new instances

  All the following receive the form and the object as parameters:
  (Note that the object may be None for new model instances)
    * pre_init - hook called before initializing the form, for a chance to
                 modify the instance before editing
    * post_init - hook called immediately after initializing the form, can be useful
                  to modify the form before display
    * pre_save, post_save - hooks called before/after saving an item

  All the following receive the form and the field as parameters:
    * field_validators - a dict of field -> callback function for validating
                         individual properties
  '''
  converter = converter or AdminConverter(model)
  form = model_form(
    model=model, base_class=base_class, only=only, exclude=exclude, converter=converter)
  form.model = model
  form.pre_init = pre_init
  form.post_init = post_init
  form.pre_save = pre_save
  form.post_save = post_save
  if field_validators:
    for field_name, validators in field_validators.items():
      if not isinstance(validators, (list, tuple)):
        field_validators[field_name] = [validators]
  form.field_validators = field_validators
  form.converter = converter
  return form