def test_emailfield(self):
with self.app.test_request_context('/'):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def form(cls, fields=None):
if fields:
Teamform = model_form(cls, only=fields)
else:
Teamform = model_form(cls)
Teamform.photo = FileField()
Teamform.submit = SubmitField('Go')
return Teamform
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_model_form(self):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField(max_length=50))
class TextPost(BlogPost):
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True)
# Create a text-based post
TextPostForm = model_form(TextPost)
form = TextPostForm(**{
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']})
self.assertFalse(form.validate())
form = TextPostForm(**{
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']})
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 1)
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate selecting one item
form = DogOwnerForm(MultiDict({
'dog': dog.id,
}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({
'dog': u'__None',
}), dog=dog)
self.assertEqual(form.dog.data, None)
def incident_create():
IncidentForm = model_form(Incident, exclude=["created_at"])
form = IncidentForm(request.form)
if form.validate_on_submit():
new_incident = Incident()
form.populate_obj(new_incident)
new_incident.save()
for object in session["object_list"]:
infosource = InformationSource.objects.get_or_404(id=ObjectId(object[1]))
if object[0] == "Reporter":
new_incident.reporter_infosource = infosource
new_incident.save()
elif object[0] == "Responder":
new_incident.responder_infosource = infosource
new_incident.save()
elif object[0] == "Coordinator":
new_incident.coordinator_infosource = infosource
new_incident.save()
return redirect(url_for("incident_blueprint.incident_list"))
return render_template("incident/incident_create.html", form=form)
def get(self, _id):
student = models.Student.objects.get(id=_id)
StudentForm = model_form(models.Student, field_args={'sex': {'radio': True}})
form = StudentForm()
return render_template('surveys/edit.html',
document=student,
form=form)
def get_form(klass, override=None):
if override:
klass = override
form = model_form(klass, exclude=klass.exclude_fields)
form.tags = TagListField("Tags that will link to this entity")
form.links = EntityListField("Bind to entities")
return form
def get_form(klass, override=None):
if override:
klass = override
form = model_form(klass, exclude=klass.exclude_fields)
form.tags = TagListField("Tags that will link to this entity")
form.links = EntityListField("Bind to entities")
return form
def user_edit(user_id):
user_form = model_form(User)
if user_id != "0":
user = User.objects.get(id=user_id)
return render_template("admin/user/edit.html",
user=user,
form=user_form)
else:
return render_template("admin/user/edit.html", form=user_form)
def get_context(self, slug=None):
if slug:
post = Post.objects.get_or_404(slug=slug)
# Handle old posts types as well
cls = post.__class__ if post.__class__ != Post else BlogPost
form_cls = model_form(cls, exclude=('created_at', 'comments'))
if request.method == 'POST':
form = form_cls(request.form, inital=post._data)
else:
form = form_cls(obj=post)
else:
# Determine which post type we need
cls = self.class_map.get(request.args.get('type', 'post'))
post = cls()
form_cls = model_form(cls, exclude=('created_at', 'comments'))
form = form_cls(request.form)
context = {"post": post, "form": form, "create": slug is None}
return context
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_model_form_only(app, db):
with app.test_request_context("/"):
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=["tags"])
form = BlogPostForm()
assert hasattr(form, "tags")
assert not hasattr(form, "posted")
BlogPostForm = model_form(BlogPost, exclude=["posted"])
form = BlogPostForm()
assert hasattr(form, "tags")
assert not hasattr(form, "posted")
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def profile():
user = User.objects.get_or_404(id=current_user.id)
Userform = model_form(User, only=["name", "teams", "description"])
Userform.submit = SubmitField('Go')
form = Userform(request.form, user)
if form.validate_on_submit():
form.populate_obj(user)
user.save()
flash("Profile Updated", "success")
return (redirect("/index"))
return (render_template("form.html", form=form, title="profile"))
def test_binaryfield(app, db):
with app.test_request_context("/"):
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({"binary": "1"}))
assert form.validate()
form.save()
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def get_context(self, slug=None):
if slug:
post = Post.objects.get_or_404(slug=slug)
form_class = model_form(Post, exclude=('created_date',))
if request.method == 'POST':
form = form_class(request.form, initial=post._data)
else:
form = form_class(obj=post)
else:
post = Post()
form_class = model_form(Post, exclude=('created_date',))
form = form_class(request.form)
context = {
'post': post,
'form': form,
'create': slug is None
}
return context
def get_context(self, slug=None):
if slug:
tag = Tag.objects.get_or_404(slug=slug)
form_class = model_form(Tag)
if request.method == 'POST':
form = form_class(request.form, initial=tag._data)
else:
form = form_class(obj=tag)
else:
tag = Tag()
form_class = model_form(Tag)
form = form_class(request.form)
context = {
'tag': tag,
'form': form,
'create_tag': slug is None,
'tags': Tag.objects.all()
}
return context
def create_notification(): # Create a new person from notification image
NotificationForm = model_form(Notification,
field_args={'msg': {
'textarea': True
}})
form = NotificationForm(request.form)
if request.method == 'POST' and form.validate():
form.save(validate=False)
flash('success!', category='success')
return render_template('add_notification.html', form=form)
class ProjectGroupProjectPrefForm(
model_form(ProjectGroup,
only=('ban_create_project', ),
field_args={
'ban_create_project': {
'label':
lazy_gettext(u'프로젝트 생성 제한'),
'description':
lazy_gettext(u'관리자를 제외한 일반 사용자의 프로젝트 생성을 제한합니다.'),
}
})):
pass
class BoardForm(
model_form(Post,
only=[
'title',
'contents',
],
field_args={'contents': {
'widget': SummerNoteWidget(),
}})):
'''board contents shouldn't be escaped.
but default-wtforms-field does auto-escaping.'''
tmp_file = FileField()
def test_filefield(self):
with self.app.test_request_context("/"):
db = self.db
class FileUpload(db.Document):
file = db.FileField()
FileUploadForm = model_form(FileUpload)
form = FileUploadForm(file=None)
self.assertEqual(wtforms.widgets.FileInput, type(form.file.widget))
def test_passwordfield(app, db):
with app.test_request_context("/"):
class User(db.Document):
password = db.StringField()
UserForm = model_form(User,
field_args={"password": {
"password": True
}})
form = UserForm(password="******")
assert isinstance(form.password.widget, wtforms.widgets.PasswordInput)
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def get_form(klass):
"""Gets the appropriate form for a given investigation"""
form = model_form(klass, exclude=klass.exclude_fields)
# An empty name is the same as no name
form.name = WTFStringField(
'Name', filters=[lambda name: name or None])
form.created_by = WTFHiddenField(
'created_by', default=current_user.username)
return form
class DetailView(MethodView):
form = model_form(Comment, exclude=['created_at', 'author', 'id'])
def get(self, id):
post = Post.objects.get_or_404(id=id)
Post.objects(id=id).update_one(inc__views=1)
return render_template('posts/detail.html',
post=post,
Markdown=Markdown,
gen_author=gen_author,
gen_author_name=gen_author_name,
short_timesince=short_timesince)
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def edit_post(post_id):
post = Post.objects.get_or_404(id=post_id)
PostForm = model_form(Post, exclude=['internal'])
form = PostForm(request.form, obj=post)
if form.validate_on_submit():
form.save()
return redirect(url_for('hello'))
return render_template('edit_post.html', post=post, form=form)
def get_context(self, slug=None):
if slug:
post = Post.objects.get_or_404(slug=slug)
# Handle old posts types as well
cls = post.__class__ if post.__class__ != Post else BlogPost
form_cls = model_form(cls, exclude=('created_at', 'comments'))
if request.method == 'POST':
form = form_cls(request.form, inital=post._data)
else:
form = form_cls(obj=post)
else:
# Determine which post type we need
cls = self.class_map.get(request.args.get('type', 'post'))
post = cls()
form_cls = model_form(cls, exclude=('created_at', 'comments'))
form = form_cls(request.form)
context = {
"post": post,
"form": form,
"create": slug is None
}
return context
def get_context(self, slug=None):
if slug:
post = Post.objects.get_or_404(slug=slug)
cls = post.__class__
form_cls = model_form(cls, exclude=('created_at', 'comments', 'slug'))
if request.method == 'POST':
form = form_cls(request.form, initial=post._data)
else:
form = form_cls(obj=post)
else:
cls = self.class_map.get(request.args.get('type', 'post'))
post = cls()
form_cls = model_form(cls, exclude=('created_at', 'comments', 'slug'))
form = form_cls(request.form)
context = {
"post": post,
"form": form,
"create": slug is None
}
return context
def populate(collection):
# add models here to render them as a form
model = {"customers": Customer(), "employees": Employee()}.get(collection)
form = model_form(model.__class__)(request.form)
name = model.__class__.__name__
if form.validate_on_submit():
form.populate_obj(model)
model.save()
return redirect(url_for("populate", collection=collection))
return render_template("populate.html", name=name, form=form)
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def edit_course(_id):
# print(request.method)
course = CourseModel.objects.get_or_404(_id=_id)
CourseForm = model_form(CourseModel)
form = CourseForm(request.form)
courses = CourseModel.objects
concepts = []
for course_temp in courses:
if course_temp._id != course._id:
concepts_temp = course_temp.concept
for concept_temp in concepts_temp:
concepts.append(concept_temp.id)
# print(form.validate())
if request.method == 'POST':
course.title = form.title.data
course.text = form.text.data
course.frame_head = form.frame_head.data
course.frame_foot = form.frame_foot.data
course.code = form.code.data
course.course_id = form.course_id.data
course.goal = form.goal.data
concepts = Concept.objects
concepts_temp = request.form.get('concept_temp').strip().split(',')
concepts_list_temp = []
for string_temp in concepts_temp:
flag = False
# 如果存在相同concept则不保存
for concept in concepts:
if concept.name == string_temp:
flag = True
break
if not flag:
concept_save = Concept(name=string_temp)
concept_save.save()
concepts_list_temp.append(string_temp)
course.concept = concepts_list_temp
print(course.concept)
print(type(course.concept[0]))
course.save()
# flash('Course updated.','success')
return redirect(url_for('edit_course', _id=_id))
files = tools.listdir(app.config['COURSE_UPLOAD_FOLDER'])
# print(files)
return render_template('editcourse.html',
course=course,
form=form,
files=files,
concepts=concepts)
class ProjectGroupNoticePrefForm(
model_form(
ProjectGroup,
only=(
'show_notices',
'notices',
),
field_args={'notices': {
'label': lazy_gettext(u'공지사항목록'),
}})):
notices = FieldList(FormField(EmbeddedNoticeForm,
widget=_build_table_html),
label=lazy_gettext(u'공지사항목록'),
min_entries=1)
def renderMeterSettings():
'''
'''
# TODO select meter by id in request
meter = db.getMeters().first()
meter_settings = meter.meter_settings
MSForm = model_form(MeterSettings, Form)
meter_settings_form = MSForm(request.form, meter_settings)
if meter_settings_form.validate_on_submit():
meter_settings_form.populate_obj(meter_settings)
meter_settings.save()
return render_template('meter_settings.html', meter=meter, input_form=meter_settings_form)
def test_list_choices_coerce(app, db):
with app.test_request_context("/"):
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
assert form.validate()
form.save()
assert MyChoices.objects.first().pill[0] == 1
def renderKNNSettings():
'''
'''
# TODO select meter by id in request
meter = db.getMeters().first()
knn_settings = meter.knn_settings
KNNSForm = model_form(KNNSettings, Form)
knn_settings_form = KNNSForm(request.form, knn_settings)
if knn_settings_form.validate_on_submit():
knn_settings_form.populate_obj(knn_settings)
knn_settings.save()
return render_template('knn_settings.html', meter=meter, input_form=knn_settings_form)
def renderCiSettings():
'''
'''
# TODO select ci by id in request
camera_input = db.getCameraInputs().first()
CameraInputForm = model_form(CameraInput, Form)
camera_input_form = CameraInputForm(request.form, camera_input)
if camera_input_form.validate_on_submit():
camera_input_form.populate_obj(camera_input)
camera_input = camera_input.save()
return render_template('camera_input_settings.html', input_form=camera_input_form)
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_embedded_model_form(app, db):
with app.test_request_context("/"):
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
assert "content-text" in "%s" % form.content.text
def collab_model_form(model, only, field_args={}, **kwargs):
for field_name in only:
field = model._fields[field_name]
# generate/append field_args for each field; esp label
if field_name in field_args:
field_args[field_name]['label'] = labelize(field)
else:
field_args[field_name] = {'label': labelize(field)}
if type(field) == mdb.ReferenceField:
field_args[field_name] = {'label_attr' : 'value',
'queryset': SelectionField.objects(field_name=field_name),
'label' : labelize(field),
'allow_blank':True,
'blank_text':u'--Enter Selection--'}
return model_form(model, only=only, field_args=field_args, **kwargs)
def test_shared_field_args(app, db):
with app.test_request_context("/"):
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {
"title": {
"validators": [wtforms.validators.Regexp("test")]
}
}
TitleOnlyForm = model_form(BlogPost,
field_args=shared_field_args,
exclude=["content"])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
assert len(title_only_form.title.validators) == 2
blog_post_form = BlogPostForm()
assert len(blog_post_form.title.validators) == 2
def get_context(self, slug=None):
form_cls = model_form(BlogPost_Day, exclude=('created_at', 'comments'))
if slug:
post = BlogPost_Day.objects.get_or_404(slug=slug)
if request.method == 'POST':
form = form_cls(request.form, inital=post._data)
else:
form = form_cls(obj=post)
else:
post = BlogPost_Day()
form = form_cls(request.form)
context = {"post": post, "form": form, "create": slug is None}
return context
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_embedded_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
def test_modelradiofield(self):
with self.app.test_request_context('/'):
db = self.db
choices = (('male', 'Male'), ('female', 'Female'), ('other', 'Other'))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={'answer': {'radio': True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, 'RadioField')
self.assertEqual(form.answer.choices, choices)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner, field_args={
'dogs': {'allow_blank': True}
})
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate the options - both dogs should be selected and
# there should be an extra blank option.
choices = list(form.dogs)
self.assertEqual(len(choices), 3)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dogs[0].pk)
self.assertTrue(choices[2].checked)
self.assertEqual(choices[2].data, dogs[1].pk)
# Validate selecting two items
form = DogOwnerForm(MultiDict({
'dogs': [dog.id for dog in dogs],
}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({
'dogs': '__None',
}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def put(self, _id):
StudentForm = model_form(models.Student,
field_args={'sex': {'radio': True}})
data = request.get_json()
if not data:
abort(404)
form = StudentForm(**data)
if form.validate():
student = models.Student.objects.get_or_404(id=_id)
form.populate_obj(student)
student.save()
response = jsonify(student)
response.staus_code = 201
response.headers['Location'] = '/surveyResults/' + \
str(student.id)
return response
abort(400)
def mood(mood_id=None):
if mood_id:
m = Mood.objects.get_or_404(id=mood_id)
if not m.iseditable:
flash("Too old", "error")
return redirect("/mood/view/" + mood_id)
else:
m = Mood()
Moodform = model_form(Mood, only=["mood", "comment"])
Moodform.submit = SubmitField('Go')
form = Moodform(request.form, m)
if form.validate_on_submit():
form.populate_obj(m)
m.user = User.objects.get_or_404(id=current_user.id)
m.save()
flash("Thanks a lot", "success")
return redirect("/mood/list")
return render_template("form.html", form=form, title="How do you feel today ?")
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner, field_args={
'dog': {'allow_blank': True}
})
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate the options - should contain a dog (selected) and a
# blank option there should be an extra blank option.
choices = list(form.dog)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dog.pk)
# Validate selecting one item
form = DogOwnerForm(MultiDict({
'dog': dog.id,
}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({
'dog': u'__None',
}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_sub_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {'lst': {'label': 'Custom Label',
'field_args': {'widget': wtforms.widgets.HiddenInput(),
'label': "Hidden Input"}}}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def post(self):
logger.debug("new join_message")
JoinMessageForm = model_form(JoinMessage)
try:
form = JoinMessageForm(request.form)
if form.validate():
logger.debug("form validate.form data: {}".format(form.data))
join_message = JoinMessage()
form.populate_obj(join_message)
join_message.slug = str(uuid.uuid1())
join_message.save()
logger.debug("join_message saved.")
return _base_normal_resp()
else:
logger.error("form.errors-{}".format(form.errors))
return _base_err_resp("error in the form")
except Exception, e:
logger.error(str(e))
return _base_err_resp("something went wrong")
