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 __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 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 __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 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 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)