class RegisterForm(
model_form(models.Userperson),
model_form(models.Person),
model_form(models.Address)):
person = None
instance = None
company = None
Address = None
submit = SubmitField('Save')
def test_form_with_only_exclude(self):
frm = model_form(Entry, only=(
'title',
'content',
))()
self.assertEqual(sorted(frm._fields.keys()), ['content', 'title'])
frm = model_form(Entry, exclude=(
'title',
'content',
))()
self.assertEqual(sorted(frm._fields.keys()), ['blog', 'pub_date'])
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
class WebhookForm(
model_form(
models.Organisation,
base_class=FlaskForm,
only=[
"webhook_enabled",
"webhook_url",
"email_notifications_enabled",
"notification_email",
],
field_args=dict(
notification_email=dict(
render_kw={
"data-toggle":
"tooltip",
"title":
"Alternative notification e-mail address (defaut: the technical constact e-mail address)"
},
validators=[optional(), email()]),
webhook_url=dict(validators=[optional(), url()])))):
"""Webhoook form."""
save_webhook = SubmitField(
"Save",
render_kw={
"class": "btn btn-success",
"data-toggle": "tooltip",
"title": "Save Organisation webhook"
})
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 __new__(mcs, name, bases, params):
"""Create a class."""
model = params.get('model')
if model:
params.setdefault('name', model._meta.db_table)
params.setdefault('columns',
[f.name for f in model._meta.sorted_fields])
cls = super(PWAdminHandlerMeta, mcs).__new__(mcs, name, bases, params)
if not cls.form and cls.model and model_form and ModelConverter:
converter = ModelConverter(overrides=cls.form_overrides)
cls.form = model_form(cls.model,
base_class=cls.form_base_class,
allow_pk=cls.form_allow_pk,
only=cls.form_only,
exclude=cls.form_exclude,
field_args=cls.form_field_args,
converter=converter)
if cls.columns_exclude:
cls.columns = [
col for col in cls.columns if col not in cls.columns_exclude
]
return cls
def gen_view(self, table, model_name):
view_dir = output_dir + '/views/models/'
view_dir_all = output_dir + '/views/all/'
view_file = view_dir + table + '.html'
view_file_all = view_dir_all + table + '.html'
if os.path.exists(view_dir) is False:
os.makedirs(view_dir)
if os.path.exists(view_dir_all) is False:
os.makedirs(view_dir_all)
from model import *
mode_class = eval(model_name)
EntryForm = model_form(mode_class)
form = EntryForm()
fields = self.table_data[table].get('fields')
for field in form:
field_name = field.__dict__.get('short_name')
field.__dict__.update(fields.get(field_name))
field.label = '<label for="' + field.__dict__[
'comment'] + '">' + field.__dict__['comment'] + '</label>'
field.description = field.__dict__['comment']
primary_field = mode_class._meta.primary_key.db_column
t = Template(self.form_template + '\n\n' + self.footer_js_template)
all_content = t.render(table_name=table,
model_name=model_name,
form=form,
primary_field=primary_field)
with open(view_file_all, 'w+') as fout:
fout.writelines(self.header_content + '\n' + self.nav_content +
'\n' + all_content + '\n' + self.footer_content)
with open(view_file, 'w+') as fout:
fout.writelines(all_content)
def test_defaults(self):
defaults = {
'title': {
'default': 'hello world'
},
'number': {
'default': 1
},
'show': {
'default': None
},
}
EpisodeFormDef = model_form(Episode, field_args=defaults)
form = EpisodeFormDef()
self.assertEqual(
form.data, {
'title': defaults['title']['default'],
'number': defaults['number']['default'],
'show': defaults['show']['default']
})
form = EpisodeFormDef(obj=self.episode_a1)
self.assertEqual(
form.data, {
'title': self.episode_a1.title,
'number': self.episode_a1.number,
'show': self.episode_a1.show
})
def contribute(self, converter, model, form_class, inline_model):
# Find property from target model to current model
reverse_field = None
info = self.get_info(inline_model)
for field in get_meta_fields(info.model):
field_type = type(field)
if field_type == ForeignKeyField:
if field.rel_model == model:
reverse_field = field
break
else:
raise Exception("Cannot find reverse relation for model %s" %
info.model)
# Remove reverse property from the list
ignore = [reverse_field.name]
if info.form_excluded_columns:
exclude = ignore + info.form_excluded_columns
else:
exclude = ignore
# Create field
child_form = info.get_form()
if child_form is None:
child_form = model_form(
info.model,
base_class=form.BaseForm,
only=info.form_columns,
exclude=exclude,
field_args=info.form_args,
allow_pk=True,
converter=converter,
)
try:
prop_name = reverse_field.related_name
except AttributeError:
prop_name = reverse_field.backref
label = self.get_label(info, prop_name)
setattr(
form_class,
prop_name,
self.inline_field_list_type(
child_form,
info.model,
reverse_field.name,
info,
label=label or info.model.__name__,
),
)
return form_class
def test_defaults(self):
BlogFormDef = model_form(Blog, field_args={'title': {'default': 'hello world'}})
form = BlogFormDef()
self.assertEqual(form.data, {'title': 'hello world'})
form = BlogFormDef(obj=self.blog_a)
self.assertEqual(form.data, {'title': 'a'})
def test_defaults(self):
BlogFormDef = model_form(Blog, field_args={'title': {'default': 'hello world'}})
form = BlogFormDef()
self.assertEqual(form.data, {'title': 'hello world'})
form = BlogFormDef(obj=self.blog_a)
self.assertEqual(form.data, {'title': 'a'})
def get_form(self, adding=False):
allow_pk = adding and not self.model._meta.auto_increment
return model_form(self.model,
allow_pk=allow_pk,
only=self.fields,
exclude=self.exclude,
converter=self.form_converter(self),
)
def get_context(self):
form_cls = model_form(User, exclude=('password_hash'))
if request.method == 'POST':
form = form_cls(request.form)
else:
form = form_cls(obj=current_user)
return form
def get_form(self, adding=False):
allow_pk = adding and not self.model._meta.auto_increment
return model_form(self.model,
allow_pk=allow_pk,
only=self.fields,
exclude=self.exclude,
converter=self.form_converter(self),
)
def __new__(mcs, name, bases, params):
""" Prepare handler params. """
model = params.get('model')
params.setdefault('name', model and model._meta.db_table.lower() or name.lower())
cls = super(PWRESTHandlerMeta, mcs).__new__(mcs, name, bases, params)
if not cls.form and cls.model and model_form:
cls.form = model_form(cls.model, base_class=Form, **cls.form_meta)
return cls
def test_defaults(self):
BlogFormDef = model_form(Blog, field_args={"title": {"default": "hello world"}})
form = BlogFormDef()
self.assertEqual(form.data, {"title": "hello world"})
form = BlogFormDef(obj=self.blog_a)
self.assertEqual(form.data, {"title": "a"})
def contribute_inline(model, form_class, inline_models):
# Contribute columns
for p in inline_models:
# Figure out settings
if isinstance(p, tuple):
info = InlineFormAdmin(p[0], **p[1])
elif isinstance(p, InlineFormAdmin):
info = p
elif isinstance(p, BaseModel):
info = InlineFormAdmin(p)
else:
raise Exception('Unknown inline model admin: %s' % repr(p))
# Find property from target model to current model
reverse_field = None
for field in info.model._meta.get_fields():
field_type = type(field)
if field_type == ForeignKeyField:
if field.to == model:
reverse_field = field
break
else:
raise Exception('Cannot find reverse relation for model %s' % info.model)
# Remove reverse property from the list
ignore = [reverse_field.name]
if info.excluded_form_columns:
exclude = ignore + info.excluded_form_columns
else:
exclude = ignore
# Create field
converter = CustomModelConverter()
child_form = model_form(info.model,
base_class=form.BaseForm,
only=info.form_columns,
exclude=exclude,
field_args=info.form_args,
allow_pk=True,
converter=converter)
prop_name = 'fa_%s' % model.__name__
setattr(form_class,
prop_name,
InlineModelFormList(child_form,
info.model,
reverse_field.name,
label=info.model.__name__))
setattr(field.to,
prop_name,
property(lambda self: self.id))
return form_class
def test_duplicate_validators(self):
''' Test whether validators are duplicated when forms share field_args
'''
shared_field_args = {'id': {'validators': [Regexp('test')]}}
ValueIncludedForm = model_form(NonIntPKModel,
field_args=shared_field_args,
allow_pk=True)
ValueExcludedForm = model_form(NonIntPKModel,
field_args=shared_field_args,
allow_pk=True,
exclude=['value'])
value_included_form = ValueIncludedForm()
self.assertEqual(len(value_included_form.id.validators), 2)
value_excluded_form = ValueExcludedForm()
self.assertEqual(len(value_excluded_form.id.validators), 2)
def contribute_inline(model, form_class, inline_models):
# Contribute columns
for p in inline_models:
# Figure out settings
if isinstance(p, tuple):
info = InlineFormAdmin(p[0], **p[1])
elif isinstance(p, InlineFormAdmin):
info = p
elif isinstance(p, BaseModel):
info = InlineFormAdmin(p)
else:
raise Exception('Unknown inline model admin: %s' % repr(p))
# Find property from target model to current model
reverse_field = None
for field in info.model._meta.get_fields():
field_type = type(field)
if field_type == ForeignKeyField:
if field.to == model:
reverse_field = field
break
else:
raise Exception('Cannot find reverse relation for model %s' %
info.model)
# Remove reverse property from the list
ignore = [reverse_field.name]
if info.excluded_form_columns:
exclude = ignore + info.excluded_form_columns
else:
exclude = ignore
# Create field
converter = CustomModelConverter()
child_form = model_form(info.model,
base_class=form.BaseForm,
only=info.form_columns,
exclude=exclude,
field_args=info.form_args,
allow_pk=True,
converter=converter)
prop_name = 'fa_%s' % model.__name__
setattr(
form_class, prop_name,
InlineModelFormList(child_form,
info.model,
reverse_field.name,
label=info.model.__name__))
setattr(field.to, prop_name, property(lambda self: self.id))
return form_class
def test_duplicate_validators(self):
''' Test whether validators are duplicated when forms share field_args
'''
shared_field_args = {'id': {'validators': [Regexp('test')]}}
ValueIncludedForm = model_form(NonIntPKModel,
field_args=shared_field_args,
allow_pk=True)
ValueExcludedForm = model_form(NonIntPKModel,
field_args=shared_field_args,
allow_pk=True,
exclude=['value'])
value_included_form = ValueIncludedForm()
self.assertEqual(len(value_included_form.id.validators), 2)
value_excluded_form = ValueExcludedForm()
self.assertEqual(len(value_excluded_form.id.validators), 2)
def login():
next_url = request.args.get('next') or request.form.get('next')
LoginForm = model_form(User, exclude=('join_date',))
form = LoginForm()
if request.method == 'POST' and request.form['username']:
try:
user = User.get(
username=request.form['username'],
password=md5((request.form['password']).encode('utf-8')).hexdigest())
except User.DoesNotExist:
errors = "Неверное имя пользователя или пароль. Повторите попытку"
return render_template('acc/login.html', form=form, next=next_url, error_message=errors)
else:
auth_user(user)
return redirect(next_url) # or url_for('group.groups_list'))
LoginForm = model_form(User, exclude=('join_date',))
form = LoginForm()
return render_template('acc/login.html', form=form, next=next_url)
def listAndEdit(modelname, entryid=0, entries=False, action=False, **kwargs):
try:
model = models.ALL_MODELS_DICT[modelname]
except KeyError:
abort(404)
if not entries:
entries = model.select()
modelForm = model_form(model)
fields = getFields(model)
try:
entry = model.get(id=int(entryid))
dependencies = getRelatedModels(entry)
except:
entry = model()
dependencies = False
form = modelForm(obj=entry)
if request.method == 'POST':
if request.form['submit'] == 'Save':
form = modelForm(request.values, obj=entry)
if form.validate():
form.populate_obj(entry)
entry.save()
if action == 'AddTo':
addForeignKey(model, entry, kwargs['foreign_table'],
kwargs['foreign_key'])
redirect(
url_for('edit',
modelname=model,
entryid=kwargs['foreign_key']))
flash('Your entry has been saved')
print 'saved'
elif request.form['submit'] == 'Delete':
try:
model.get(model.id == int(entryid)).delete_instance(
recursive=True)
#redirect(url_for('add', modelname = modelname))
except:
pass
finally:
entry = model()
form = modelForm(obj=entry)
kwargs = dict(
links=[x.__name__ for x in models.ALL_MODELS],
header=model.__name__,
form=form,
entry=entry,
entries=entries,
fields=fields,
dependencies=dependencies,
)
return kwargs
def scaffold_form(self):
form_class = model_form(
self.model,
base_class=BaseForm,
allow_pk=False,
only=None,
exclude=self.form_exclude,
field_args=self.field_args,
converter=ModelConverter(overrides=self.form_overrides))
return form_class
def stud_delete(stud_id, group_id):
stud = get_object_or_404(Stud, Stud.id == stud_id)
try:
stud.delete_instance()
return redirect(url_for('group.studs_list',
group_id=group_id))
except Exception as e:
StudForm = model_form(Stud)
form = StudForm(obj=stud)
return render_template('students/stud_form.html',
form=form, stud=stud, error_message=e)
def group_create():
GroupForm = model_form(Group)
group = Group()
if request.method == 'POST':
form = GroupForm(request.form, obj=group)
if form.validate():
form.populate_obj(group)
group.save()
return redirect(url_for('group.groups_list'))
else:
form = GroupForm(obj=group)
return render_template('groups/group_form.html', form=form)
def scaffold_form(self):
form_class = model_form(self.model,
base_class=form.BaseForm,
only=self.form_columns,
exclude=self.excluded_form_columns,
field_args=self.form_args,
converter=CustomModelConverter())
if self.inline_models:
form_class = contribute_inline(self.model, form_class, self.inline_models)
return form_class
def contribute(self, converter, model, form_class, inline_model):
# Find property from target model to current model
reverse_field = None
info = self.get_info(inline_model)
for field in info.model._meta.get_fields():
field_type = type(field)
if field_type == ForeignKeyField:
if field.rel_model == model:
reverse_field = field
break
else:
raise Exception('Cannot find reverse relation for model %s' % info.model)
# Remove reverse property from the list
ignore = [reverse_field.name]
if info.form_excluded_columns:
exclude = ignore + info.form_excluded_columns
else:
exclude = ignore
# Create field
child_form = info.get_form()
if child_form is None:
child_form = model_form(info.model,
base_class=form.BaseForm,
only=info.form_columns,
exclude=exclude,
field_args=info.form_args,
allow_pk=True,
converter=converter)
prop_name = 'fa_%s' % model.__name__
label = self.get_label(info, prop_name)
setattr(form_class,
prop_name,
self.inline_field_list_type(child_form,
info.model,
reverse_field.name,
info,
label=label or info.model.__name__))
setattr(field.rel_model,
prop_name,
property(lambda self: self.id))
return form_class
def scaffold_form(self):
form_class = model_form(self.model,
base_class=form.BaseForm,
only=self.form_columns,
exclude=self.form_excluded_columns,
field_args=self.form_args,
converter=self.model_form_converter())
if self.inline_models:
form_class = self.scaffold_inline_form_models(form_class)
return form_class
def scaffold_form(self):
form_class = model_form(self.model,
base_class=form.BaseForm,
only=self.form_columns,
exclude=self.form_excluded_columns,
field_args=self.form_args,
converter=self.model_form_converter())
if self.inline_models:
form_class = self.scaffold_inline_form_models(form_class)
return form_class
def group_edit(group_id):
GroupForm = model_form(Group)
group = get_object_or_404(Group, Group.id == group_id)
if request.method == 'POST':
form = GroupForm(request.form, obj=group)
if form.validate():
form.populate_obj(group)
group.save()
return redirect(url_for('group.groups_list'))
else:
form = GroupForm(obj=group)
form.starosta.query = Stud.filter(cgroup=group)
return render_template('groups/group_form.html', form=form, group=group)
def stud_edit(stud_id, group_id):
StudForm = model_form(Stud, field_args={'dbirthday': dict(format='%d.%m.%Y')})
stud = get_object_or_404(Stud, Stud.id == stud_id)
if request.method == 'POST':
form = StudForm(request.form, obj=stud)
if form.validate():
form.populate_obj(stud)
stud.save()
return redirect(url_for('group.studs_list',
group_id=group_id))
else:
form = StudForm(obj=stud)
return render_template('students/stud_form.html',
form=form, stud=stud, group_id=group_id)
def stud_create(group_id):
StudForm = model_form(Stud)
stud = Stud()
if request.method == 'POST':
form = StudForm(request.form)
if form.validate():
form.populate_obj(stud)
stud.save()
return redirect(url_for('group.studs_list',
group_id=group_id))
else:
stud.cgroup = get_object_or_404(Group, Group.id == group_id)
form = StudForm(obj=stud)
return render_template('students/stud_form.html',
form=form, group_id=group_id)
def join():
if request.method == 'POST' and request.form['username']:
try:
with database.db.transaction():
user = User.create(
username=request.form['username'],
password=md5((request.form['password']).encode('utf-8')).hexdigest(),
join_date = datetime.datetime.now())
auth_user(user)
return redirect(url_for('group.groups_list'))
except IntegrityError:
flash('Пользователь с таким именем уже существует')
LoginForm = model_form(User, exclude=('join_date',))
form = LoginForm()
return render_template('acc/login.html', form=form)
def contribute(self, converter, model, form_class, inline_model):
# Find property from target model to current model
reverse_field = None
info = self.get_info(inline_model)
for field in info.model._meta.get_fields():
field_type = type(field)
if field_type == ForeignKeyField:
if field.rel_model == model:
reverse_field = field
break
else:
raise Exception('Cannot find reverse relation for model %s' %
info.model)
# Remove reverse property from the list
ignore = [reverse_field.name]
if info.form_excluded_columns:
exclude = ignore + info.form_excluded_columns
else:
exclude = ignore
# Create field
child_form = model_form(info.model,
base_class=form.BaseForm,
only=info.form_columns,
exclude=exclude,
field_args=info.form_args,
allow_pk=True,
converter=converter)
prop_name = 'fa_%s' % model.__name__
label = self.get_label(info, prop_name)
setattr(
form_class, prop_name,
InlineModelFormList(child_form,
info.model,
reverse_field.name,
label=label or info.model.__name__))
setattr(field.rel_model, prop_name, property(lambda self: self.id))
return form_class
def get_context(self, id=None):
form_cls = model_form(Staff)
if id:
query = Staff.select()
staff = get_object_or_404(query, Staff.id == id)
if request.method == 'POST':
form = form_cls(request.form, intial=staff.bio)
else:
form = form_cls(obj=staff)
else:
staff = Staff()
form = form_cls(request.form)
context = {'staff': staff, 'form': form, 'create': id is None}
return context
def get_context(self, slug=None):
form_cls = model_form(Post, exclude=('timestamp', 'slug'))
if slug:
query = Post.select()
post = get_object_or_404(query, Post.slug == slug)
if request.method == 'POST':
form = form_cls(request.form, intial=post.content)
else:
form = form_cls(obj=post)
else:
post = Post()
form = form_cls(request.form)
context = {'post': post, 'form': form, 'create': slug is None}
return context
def get_context(self, slug=None):
form_cls = model_form(Post, exclude=('timestamp', 'comments','slug','author'))
if slug:
query = Post.select()
post = get_object_or_404(query, Post.slug ==slug)
if request.method == 'POST':
form = form_cls(request.form, intial=post.content)
else:
form = form_cls(obj=post)
else:
post = Post()
form = form_cls(request.form)
context = {
'post': post,
'form': form,
'create': slug is None
}
return context
def test_form_with_only_exclude(self):
frm = model_form(Entry, only=('title', 'content',))()
self.assertEqual(sorted(frm._fields.keys()), ['content', 'title'])
frm = model_form(Entry, exclude=('title', 'content',))()
self.assertEqual(sorted(frm._fields.keys()), ['blog', 'pub_date'])
from flask_wtf import FlaskForm
from wtforms import SelectField, PasswordField, BooleanField, SubmitField, StringField, DateField
from wtforms.fields.html5 import DateField
from wtforms.validators import DataRequired, Length, EqualTo
from wtfpeewee.orm import model_form
import wtforms
from base.models import User, feed
SimpleUserForm = model_form(User)
SimpleFeedForm = model_form(feed)
class UserForm(FlaskForm):
user_username = StringField(
'Username', validators=[DataRequired(),
Length(min=3, max=20)])
user_password = PasswordField(' Password',
validators=[
DataRequired(),
EqualTo('password2',
message='Passwords must match')
])
password2 = PasswordField('Confirm password', validators=[DataRequired()])
class LoginForm(FlaskForm):
username = StringField('Username', validators=[DataRequired()])
password = PasswordField(' Password', validators=[DataRequired()])
remember_me = BooleanField('Remember Me')
submit = SubmitField('Sign In')
from flask_wtf import FlaskForm
from flask_security.forms import RegisterForm
from wtforms import StringField, SelectField
from wtforms.validators import DataRequired, Length
from wtfpeewee.orm import model_form
from model import Publication
class ExtendedRegisterForm(RegisterForm):
first_name = StringField('First Name', [DataRequired()])
last_name = StringField('Last Name', [DataRequired()])
username = StringField('Username', [DataRequired()])
class PublicationForm(FlaskForm):
title = StringField('Title', [DataRequired()])
body = StringField('Body', [DataRequired()])
SimplePublicationForm = model_form(Publication)
b = BooleanField(null=True)
class ChoicesModel(TestModel):
gender = CharField(choices=(('m', 'Male'), ('f', 'Female')))
status = IntegerField(choices=((1, 'One'), (2, 'Two')), null=True)
salutation = CharField(null=True)
true_or_false = BooleanField(choices=((True, 't'), (False, 'f')))
class NonIntPKModel(TestModel):
id = PrimaryKeyField(column_class=VarCharColumn)
value = CharField()
BlogForm = model_form(Blog)
EntryForm = model_form(Entry)
NullFieldsModelForm = model_form(NullFieldsModel)
ChoicesForm = model_form(ChoicesModel, field_args={'salutation': {'choices': (('mr', 'Mr.'), ('mrs', 'Mrs.'))}})
NonIntPKForm = model_form(NonIntPKModel, allow_pk=True)
class FakePost(dict):
def getlist(self, key):
val = self[key]
if isinstance(val, list):
return val
return [val]
class WTFPeeweeTestCase(unittest.TestCase):
def setUp(self):
import wtforms
from wtforms import Form, validators, ValidationError
from wtforms import fields as f
from wtfpeewee.orm import model_form
from wtfpeewee.fields import ModelSelectField
from yiyun.ext.database import WPSelectField
from yiyun.models import Team, Sport, ChinaCity, Article, ArticleCategory
from yiyun.ext.forms import Form, FileField, file_required, file_allowed,\
TextAreaField
article_exclude = ("id", "created", "created_by", "updated", "last_updated_by", "state",
"approved", "recommend", "cover_key", "views_count")
ArticleForm = model_form(Article, base_class=Form, field_args={},
exclude=article_exclude)
ArticleForm.category = wtforms.fields.SelectField("分类", choices=[])
ArticleForm.cover = wtforms.fields.FileField("封面")
ArticleForm.team_id = wtforms.fields.HiddenField("俱乐部")
category_exclude = ("id", "articles_count")
ArticleCategoryForm = model_form(ArticleCategory, base_class=Form,
field_args={}, exclude=category_exclude)
for h in hackathon_q:
if now < h.start_date:
hackathons_future.append(h)
elif now < h.end_date:
hackathons_now.append(h)
hackathon_query.append(h)
return render_template("index.html",
hackathons_now=hackathons_now,
hackathons_future=hackathons_future,
hackathon_query=hackathon_query,
active="home")
HackForm = model_form(Hack, exclude=("hackathon", ))
@app.route("/hackathon/<int:hackathon_id>/addhack", methods=["GET", "POST"])
def hack_create(hackathon_id):
hackathon = get_object_or_404(Hackathon, id=hackathon_id)
hack = Hack()
if request.method == "POST":
form = HackForm(request.form)
if form.validate():
form.populate_obj(hack)
hack.hackathon = hackathon
hack.save()
flash("Your hack was successfully added", "success")
return redirect(url_for("dash", hackathon_id=hackathon.id))
def test_defaults(self):
defaults = {
'episode': {
'default': self.episode_a2
},
'scene': {
'default': 'hello world'
},
'scene_modifier': {
'default': None
},
'width': {
'default': 5800
},
'height': {
'default': 3300
},
'overlay_count': {
'default': 2
},
'partial': {
'default': 0
},
'establishing_shot': {
'default': 0
},
'pull': {
'default': 1
},
'card': {
'default': 1
},
'location': {
'default': self.location_ext
},
'hours': {
'default': 2.5
},
'date_started': {
'default': '20148-02-01'
},
'date_finished': {
'default': ''
},
'approved': {
'default': 0
},
}
BGFormDef = model_form(Background, field_args=defaults)
form = BGFormDef()
self.assertEqual(
form.data, {
'episode': defaults['episode']['default'],
'scene': defaults['scene']['default'],
'scene_modifier': defaults['scene_modifier']['default'],
'width': defaults['width']['default'],
'height': defaults['height']['default'],
'overlay_count': defaults['overlay_count']['default'],
'partial': False,
'establishing_shot': False,
'pull': True,
'card': True,
'location': defaults['location']['default'],
'hours': defaults['hours']['default'],
'date_started': defaults['date_started']['default'],
'date_finished': None,
'approved': False,
})
form = BGFormDef(obj=self.bg_a1a)
self.assertEqual(
form.data, {
'episode': self.bg_a1a.episode,
'scene': self.bg_a1a.scene,
'scene_modifier': self.bg_a1a.scene_modifier,
'width': self.bg_a1a.width,
'height': self.bg_a1a.height,
'overlay_count': self.bg_a1a.overlay_count,
'partial': False,
'establishing_shot': True,
'pull': False,
'card': False,
'location': self.bg_a1a.location,
'hours': self.bg_a1a.hours,
'date_started': self.bg_a1a.date_started,
'date_finished': self.bg_a1a.date_finished,
'approved': False,
})
def get_form(self):
return model_form(self.model, converter=CustomModelConverter(self))
"""Used on User Model
"""
UserForm = model_form(User, field_args={
'itsc': dict(validators=[
InputRequired(message="ITSC required")
]),
'student_id': dict(validators=[
InputRequired(message="Student ID required"),
Regexp("^\d{8}$", message="Invalid Student ID")
]),
'university_id': dict(validators=[
Regexp("^\d{9}$", message="Invalid University ID")
]),
'mobile': dict(validators=[
Regexp("^\d{8}$", message="Invalid Mobile Phone")
]),
'member_type': dict(validators=[
InputRequired(message="Member Type required"),
AnyOf([
'Full', 'OneSem', 'OneYear', 'TwoYear',
'ThreeYear', 'Honour', 'Assoc', 'Expired'
], message="Invalid Member Type")
]),
'expire_at': dict(validators=[
InputRequired(message="Expire date required")
])
}, exclude=(
'last_login', 'this_login', 'login_count', 'rfs_count', 'full_name',
), converter=Converter())
def format_padded_scene(self):
"""
Returns the object's scene value padded with up to 2 zeros.
:return: Padded scene number as a string.
"""
return '{0:0>3}{1}'.format(
self.scene, self.scene_modifier if self.scene_modifier else '')
def __str__(self):
return 'Sc {}'.format(self.format_padded_scene())
class Meta:
db_table = 'background'
BGForm = model_form(Background)
class BGFormTestCase(unittest.TestCase):
def setUp(self):
Background.drop_table(True)
Location.drop_table(True)
Episode.drop_table(True)
Show.drop_table(True)
Show.create_table()
Episode.create_table()
Location.create_table()
Background.create_table()
self.show_a = Show.create(id=1, title='aa', season=1, code='abc')
from flask import abort
from flask import flash
from flask import Flask
from flask import render_template
from flask import request
from flask import url_for
from models import Listing
import peewee
from wtfpeewee.orm import model_form
ListingForm = model_form(Listing, exclude=['title', 'url', 'source_time'])
app = Flask(__name__)
@app.template_filter('NoNone')
def NoNone(val):
if val is not None:
return val
else:
return ''
@app.route('/')
def Index():
return render_template('index.html',
listings=Listing.select().order_by(Listing.year))
@app.route('/listing/<int:listing_id>/', methods=['GET', 'POST'])
def ListingDetail(listing_id):
from flask_wtf import FlaskForm
from wtforms import StringField, SelectField, TextField, TextAreaField
from wtforms.fields.html5 import DateField
from wtforms.validators import DataRequired, Length
from wtfpeewee.orm import model_form
from models import Publication, User
#Définition des différents formulaires
class PublicationForm(FlaskForm):
pass
NewPublicationForm = model_form(Publication,
exclude=('created_at', 'user', 'modified_at'))
class UserForm(FlaskForm):
pass
NewUserForm = model_form(User)
class EditPublicationForm(FlaskForm):
title = TextAreaField('title', validators=[DataRequired()])
body = TextAreaField('body', validators=[DataRequired()])
pass
class ListComment(Model):
list = ForeignKeyField(List, related_name='comments')
text = TextField(default="")
user = ForeignKeyField(User, related_name='list_comments')
class Meta:
database = db
class ItemComment(Model):
item = ForeignKeyField(Item, related_name='comments')
text = TextField(default="")
user = ForeignKeyField(User, related_name='item_comments')
class Meta:
database = db
UserForm = model_form(User)
ListForm = model_form(List)
ItemForm = model_form(Item)
ListCommentForm = model_form(ListComment)
ItemCommentForm = model_form(ItemComment)
def test_get_form_field(self):
form = model_form(User)(obj=self.admin)
self.assertEqual(self.th.get_form_field(form, 'username'), form.username)
self.assertEqual(self.th.get_form_field(form, 'username').data, 'admin')
pub_date = DateTimeField(default=datetime.datetime.now)
class Meta:
order_by = ('pub_date', )
# form classes
class HiddenForeignKeyConverter(ModelConverter):
def handle_foreign_key(self, model, field, **kwargs):
return field.name, ModelHiddenField(model=field.rel_model, **kwargs)
PostForm = model_form(
Post,
field_args={
'title': dict(validators=[Length(min=3, max=200)
]), # title must be at least 3 chars long
'content':
dict(description='this is the body of the post'), # a little help text
})
CommentForm = model_form(Comment,
exclude=('pub_date', ),
converter=HiddenForeignKeyConverter())
def get_or_404(query, *expr):
try:
return query.where(*expr).get()
except query.model_class.DoesNotExist:
abort(404)
database = db
class Address(baseModel):
postaddress = CharField()
postalcode = IntegerField()
country = CharField()
telephone = CharField()
def __unicode__(self):
return self.postaddress
ALL_MODELS.append(Address)
ALL_MODELS_DICT['Address'] = Address
AddressForm = model_form(Address)
class Instance(baseModel):
name = CharField()
address = ForeignKeyField(Address,
related_name='address_Instances',
null=True)
active = BooleanField()
category = CharField()
def __unicode__(self):
return self.name
ALL_MODELS.append(Instance)
def get_form(self):
return model_form(self.model, converter=converter)
per_source = per_source.limit(limit)
return per_source
@classmethod
def best_recipes(cls, limit=None):
best_recipes = cls.select().order_by(
cls.rating.desc()
)
if limit:
best_recipes = best_recipes.limit(limit)
return best_recipes
RecipeForm = model_form(Recipe,
exclude=['add_date', 'update_date', 'usage_count'],
field_args={
"name": {"label": "Nom"},
"ingredients": {"label": "Ingrédients"},
"preparation_time": {"label": "Temps de préparation"},
"cooking_time": {"label": "Temps de cuisson"},
"category": {"choices": categories,
"label": "Catégorie"},
"rating": {"validators": [],
"label": "Note"}})
# db.create_tables([Recipe])
name = CharField()
comment = TextField()
pub_date = DateTimeField(default=datetime.datetime.now)
class Meta:
ordering = (('pub_date', 'desc'),)
# form classes
class HiddenForeignKeyConverter(ModelConverter):
def handle_foreign_key(self, model, field, **kwargs):
return field.name, ModelHiddenField(model=field.to, **kwargs)
PostForm = model_form(Post, field_args={
'title': dict(validators=[Length(min=3, max=200)]), # title must be at least 3 chars long
'content': dict(description='this is the body of the post'), # a little help text
})
CommentForm = model_form(Comment, exclude=('pub_date',), converter=HiddenForeignKeyConverter())
def get_or_404(query, **kwargs):
try:
return query.get(**kwargs)
except query.model.DoesNotExist:
abort(404)
# views
@app.route('/')
def index():
posts = Post.select().join(Comment, 'left outer').annotate(Comment, Count('id', 'comment_count'))
return render_template('posts/index.html', posts=posts)
def get_form(self):
return model_form(self.model)
def __unicode__(self):
return self.title
class Entry(TestModel):
pk = PrimaryKeyField()
blog = ForeignKeyField(Blog)
title = CharField(verbose_name='Wacky title')
content = TextField()
pub_date = DateTimeField(default=datetime.datetime.now)
def __unicode__(self):
return '%s: %s' % (self.blog.title, self.title)
BlogForm = model_form(Blog)
EntryForm = model_form(Entry)
class FakePost(dict):
def getlist(self, key):
val = self[key]
if isinstance(val, list):
return val
return [val]
class WTFPeeweeTestCase(unittest.TestCase):
def setUp(self):
Entry.drop_table(True)
Blog.drop_table(True)
