def test_throws_exception_for_unknown_configuration_option(self):
self.init()
class SomeForm(Form):
pass
defaults = {'unknown': 'something'}
with raises(UnknownConfigurationOption):
model_form_factory(SomeForm, **defaults)
def test_throws_exception_for_unknown_configuration_option(self):
self.init()
class SomeForm(Form):
pass
defaults = {"unknown": "something"}
with raises(UnknownConfigurationOption):
model_form_factory(SomeForm, **defaults)
def test_inherit_without_new_session(self):
cls = model_form_factory(self.Base)
class Sub(cls):
pass
assert Sub.get_session() == 'TestSession'
def get_form_class(self):
"""
Returns the form class to use in this view.
"""
if self.form_class:
return self.form_class
else:
if self.model is not None:
# If a model has been explicitly provided, use it
model = self.model
elif hasattr(self, 'object') and self.object is not None:
# If this view is operating on a single object, use
# the class of that object
model = self.object.__class__
else:
# Try to get a query and extract the model class
# from that
model = get_model_from_obj(self.get_query())
# Create a new class to use as the base. We do this to ensure
# Meta.model is available when the form is generated by the factory.
model_ = model
class ModelFormWithModel(ModelForm):
class Meta:
model = model_
only = self.fields
model_form = model_form_factory(ModelFormWithModel)
model_form.Meta.model = model
return model_form
def test_inherit_with_new_session(self):
cls = model_form_factory(self.Base)
class Sub(cls):
@classmethod
def get_session(self):
return 'SubTestSession'
assert Sub.get_session() == 'SubTestSession'
def test_inherit_with_new_session(self):
cls = model_form_factory(self.Base)
class Sub(cls):
@classmethod
def get_session(self):
return 'SubTestSession'
assert Sub.get_session() == 'SubTestSession'
def add_dc(dc_id=None):
from flask_wtf import FlaskForm
from wtforms_alchemy import model_form_factory
ModelForm = model_form_factory(FlaskForm)
class DataCenterForm(ModelForm):
class Meta:
model = Datacenter
exclude = [
'b_slots',
]
if dc_id:
dc = Datacenter.query.get_or_404(dc_id)
if request.method == 'POST':
form = DataCenterForm(request.form, obj=dc)
else:
form = DataCenterForm(obj=dc)
else:
form = DataCenterForm(request.form)
if form.validate_on_submit():
if dc_id:
form.populate_obj(dc)
flash(u'Изменен датацентр %s' % dc.name, 'success')
else:
dc = Datacenter()
form.populate_obj(dc)
db.session.add(dc)
flash(u'Добавлен датацентр %s' % dc.name, 'success')
db.session.commit()
return redirect(url_for('datacentres'))
else:
if form.errors.items():
for field, errors in form.errors.iteritems():
for error in errors:
flash(
u"Ошибка в поле %s: %s" %
(getattr(form, field).label.text, error), 'error')
if dc_id:
return render_template(
"edit_dc.html",
form=form,
dc_id=dc_id,
)
else:
return render_template(
"add_dc.html",
form=form,
)
class CertificateForm(model_form_factory(Form)):
class Meta:
model = Certificate
only = ('content', )
def validate_content(self, field):
if field.data:
try:
crypto.load_certificate_request(crypto.FILETYPE_PEM,
field.data)
except crypto.Error:
raise ValidationError("Invalid certificate request.")
def test_raises_exception_if_no_session_set_for_unique_validators(self):
class ModelTest(self.base):
__tablename__ = 'model_test'
id = sa.Column(sa.Integer, primary_key=True)
test_column = sa.Column(sa.Unicode(255), unique=True)
Form = model_form_factory()
assert not Form.get_session
with raises(Exception):
class ModelTestForm(Form):
class Meta:
model = ModelTest
def test_raises_exception_if_no_session_set_for_unique_validators(self):
class ModelTest(self.base):
__tablename__ = 'model_test'
id = sa.Column(sa.Integer, primary_key=True)
test_column = sa.Column(sa.Unicode(255), unique=True)
Form = model_form_factory()
assert not Form.get_session
with raises(Exception):
class ModelTestForm(Form):
class Meta:
model = ModelTest
class ClientFormBase(model_form_factory(Form)):
"""Base class for Client form."""
class Meta:
model = Client
exclude = [
'client_secret',
'is_internal',
]
strip_string_fields = True
field_args = dict(website=dict(
validators=[validators.DataRequired(),
validators.URL()],
widget=widgets.TextInput(),
), )
class ClientFormBase(model_form_factory(AdsWSBaseForm)):
class Meta:
model = OAuthClient
exclude = [
'client_secret',
'is_internal',
'is_confidential',
]
strip_string_fields = True
field_args = dict(website=dict(
validators=[validators.Required(),
validators.URL()],
widget=widgets.TextInput(),
))
def test_supports_parameter_overriding(self):
self.init()
class MyFormGenerator(FormGenerator):
pass
defaults = {
'all_fields_optional': True,
'only_indexed_fields': True,
'include_primary_keys': True,
'include_foreign_keys': True,
'strip_string_fields': True,
'include_datetimes_with_default': True,
'form_generator': True,
'date_format': '%d-%m-%Y',
'datetime_format': '%Y-%m-%dT%H:%M:%S',
}
ModelForm = model_form_factory(Form, **defaults)
for key, value in defaults.items():
assert getattr(ModelForm.Meta, key) == value
def test_supports_parameter_overriding(self):
self.init()
class MyFormGenerator(FormGenerator):
pass
defaults = {
'all_fields_optional': True,
'only_indexed_fields': True,
'include_primary_keys': True,
'include_foreign_keys': True,
'strip_string_fields': True,
'include_datetimes_with_default': True,
'form_generator': True,
'date_format': '%d-%m-%Y',
'datetime_format': '%Y-%m-%dT%H:%M:%S',
}
ModelForm = model_form_factory(Form, **defaults)
for key, value in defaults.items():
assert getattr(ModelForm.Meta, key) == value
def test_supports_parameter_overriding(self):
self.init()
class MyFormGenerator(FormGenerator):
pass
defaults = {
"all_fields_optional": True,
"only_indexed_fields": True,
"include_primary_keys": True,
"include_foreign_keys": True,
"strip_string_fields": True,
"include_datetimes_with_default": True,
"form_generator": True,
"date_format": "%d-%m-%Y",
"datetime_format": "%Y-%m-%dT%H:%M:%S",
}
ModelForm = model_form_factory(Form, **defaults)
for key, value in defaults.items():
assert getattr(ModelForm.Meta, key) == value
class ModelForm(
model_form_factory(Form,
date_format='%d-%m-%Y',
datetime_format='%d-%m-%Y %H:%M')):
def __iter__(self):
''' make the 'only' attribute order-sensitive '''
field_order = getattr(self, 'only', None)
if field_order:
temp_fields = []
for name in field_order:
if name == '*':
temp_fields.extend([
f for f in self._unbound_fields
if f[0] not in field_order
])
else:
temp_fields.append([
f for f in self._unbound_fields if f[0] == name
][0])
self._unbound_fields = temp_fields
return super(Form, self).__iter__()
class _PrintableForm(model_form_factory(Form)):
def render(self):
fields = []
for f in self:
if isinstance(f, HiddenField):
fields.append(
'<input type="hidden" name="%(name)s" value="%(value)s">' %
{
'name': f.name,
'value': f._value(),
})
else:
if isinstance(f, ModelFieldList):
# import pdb; pdb.set_trace()
for form_class in f.unbound_field.args:
fields.append(form_class().render_selector(f.name))
else:
f.label.text = f.label.text or f.name.replace('_',
' ').title()
for error in f.errors:
fields.append('<span style="color:red">%s</span>' %
error)
fields.append('%s: %s' % (f.label, f()))
# TODO: Is this safe with user-submitted data on form edit?
return Markup('\n'.join(fields))
def render_selector(self, parent_field_name):
alternatives = self.Meta.model.query.all()
html = [
'<select name="%s">' % parent_field_name,
]
for alternative in alternatives:
html.append('<option value="%s">%s</option>' %
(alternative.id, alternative))
html.append('</select>')
return '\n'.join(html)
from wtforms.validators import ValidationError
from wtforms.widgets import HiddenInput, html_params
from wtforms_alchemy import model_form_factory
from yakbak.models import (
AgeGroup,
Category,
DemographicSurvey,
Ethnicity,
Gender,
ProgrammingExperience,
Talk,
User,
)
ModelForm = model_form_factory(FlaskForm) # type: FlaskForm
class TalkLengthChoices:
"""
Defer the determination of choices for talk lengths to runtime.
Because each conference might have different talk lengths, we can't
pre-define the choices in the way WTF usually wants for a select field,
so we use this trickery instead.
"""
def __iter__(self) -> Iterable[Tuple[int, str]]:
return iter([(length, f"{length} Minutes")
for length in g.conference.talk_lengths])
data[name] = f.data
return data
def patch_obj(self, obj):
"""
Patch the attributes of the passed `obj` with data from the form's
changed fields.
:note: This method like :meth:`~Form.populate_obj` is a destructive
operation; Any attribute with the same name as a filld will be
overridden. Use with caution.
"""
for name in self.patch_data:
field = self._fields.get(name)
field.populate_obj(obj, name)
options = {
'not_null_validator': DataRequired(),
'not_null_validator_type_map': {},
}
BaseModelForm = model_form_factory(Form, **options)
class ModelForm(BaseModelForm):
@classmethod
def get_session(self):
return db.session
def test_unique_validator(self):
form = model_form_factory(unique_validator=None)
assert form.Meta.unique_validator is None
__version__ = '0.1.0'
from flask.ext.wtf import Form
import wtforms
from wtforms_alchemy import model_form_factory
from ..database import db
BaseModelForm = model_form_factory(Form)
class ModelForm(BaseModelForm):
"""
wtforms-alchemy Flask-WTF compatible base model form.
Copied from:
http://wtforms-alchemy.readthedocs.org/en/latest/advanced.html#using-wtforms-alchemy-with-flask-wtf
"""
@classmethod
def get_session(self):
return db.session
BaseModelWtfForm = model_form_factory(wtforms.Form)
class ModelWtfForm(BaseModelWtfForm):
"""
Same as ModelForm (also defined in this file), but inherited
from regular wtforms base class, instead of Flask-WTF base
def test_length_validator(self):
form = model_form_factory(length_validator=None)
assert form.Meta.length_validator is None
def test_time_range_validator(self):
form = model_form_factory(time_range_validator=None)
assert form.Meta.time_range_validator is None
def test_unique_validator(self):
form = model_form_factory(unique_validator=None)
assert form.Meta.unique_validator is None
def model_form_all(request):
"""Returns one of each possible model form classes with custom and the
original metaclass."""
ModelForm = model_form_factory(meta=request.param)
return ModelForm
def test_time_range_validator(self):
form = model_form_factory(time_range_validator=None)
assert form.Meta.time_range_validator is None
def test_optional_validator(self):
form = model_form_factory(optional_validator=None)
assert form.Meta.optional_validator is None
def test_number_range_validator(self):
form = model_form_factory(number_range_validator=None)
assert form.Meta.number_range_validator is None
def test_length_validator(self):
form = model_form_factory(length_validator=None)
assert form.Meta.length_validator is None
def test_email_validator(self):
form = model_form_factory(email_validator=None)
assert form.Meta.email_validator is None
if e.args and e.args[0]:
self._form_level_errors.append(e.args[0])
break
except ValueError as e:
self._form_level_errors.append(e.args[0])
return fields_valid and not self._form_level_errors
@property
def form_errors(self):
return self._form_level_errors
@property
def errors(self):
if self._errors is None:
self._errors = {name: f.errors for name, f in six.iteritems(self._fields) if f.errors}
return self._errors
@property
def all_errors(self):
return namedtuple('Errors', ['field', 'form'])(self.errors, self.form_errors)
BaseModelForm = model_form_factory(Form, form_generator=FormGenerator)
class ModelForm(BaseModelForm):
@classmethod
def get_session(cls):
return db.session
# coding=utf-8
# Created 2014 by Janusz Skonieczny
import logging
from flask_wtf import Form
from flask_wtf.form import _Auto
from wtforms_alchemy import model_form_factory
class FormSetupError(Exception):
pass
BaseModelForm = model_form_factory(base=Form)
class ModelForm(BaseModelForm):
# model = None
def __init__(self, formdata=_Auto, obj=None, *args, **kwargs):
self.obj = obj
# if not self.Meta.model:
# self.Meta.model = kwargs.pop("model", None)
# self.parent = kwargs.pop("parent", None)
super(ModelForm, self).__init__(formdata=formdata, obj=obj, *args, **kwargs)
def save(self):
dbs = self.get_session()
if not self.obj:
if not self.Meta.model:
FormSetupError("Model was not configured, please setup property or provide model during init")
def add_ds(dc_id=None, ds_id=None):
if dc_id:
dc = Datacenter.query.filter_by(id=dc_id).first_or_404()
c_slots = dc.slots
s_slots = DataServer.query.filter_by(datacenter_id=dc_id).count()
if c_slots == s_slots:
flash(u'В датацентре %s заняты все слоты' % dc.name, 'error')
return redirect(url_for('view_dc', dc_id=dc_id))
from flask_wtf import FlaskForm
from wtforms_alchemy import model_form_factory
ModelForm = model_form_factory(FlaskForm)
class DataServerForm(ModelForm):
class Meta:
model = DataServer
if ds_id:
ds = DataServer.query.get_or_404(ds_id)
if request.method == 'POST':
form = DataServerForm(request.form, obj=ds)
else:
form = DataServerForm(obj=ds)
else:
dc = Datacenter.query.get_or_404(dc_id)
form = DataServerForm(request.form)
if form.validate_on_submit():
if ds_id:
form.populate_obj(ds)
flash(u'Изменен сервер %s' % ds.name, 'success')
dc_id = ds.datacenter_id
else:
ds = DataServer()
form.populate_obj(ds)
ds.datacenter_id = dc_id
db.session.add(ds)
if dc.b_slots:
dc.b_slots += 1
else:
dc.b_slots = 1
flash(u'Добавлен сервер в датацентр %s' % dc.name, 'success')
db.session.commit()
return redirect(url_for('view_dc', dc_id=dc_id))
else:
if form.errors.items():
for field, errors in form.errors.iteritems():
for error in errors:
flash(
u"Ошибка в поле %s: %s" %
(getattr(form, field).label.text, error), 'error')
if ds_id:
return render_template(
"edit_ds.html",
form=form,
ds_id=ds_id,
)
else:
return render_template(
"add_ds.html",
form=form,
dc_id=dc_id,
)
from wtforms import Form, TextField, IntegerField, DateField, BooleanField, StringField, PasswordField, validators
#from wtforms_alchemy import Unique
#для начала проверим, заняты ли слоты
dc = Datacenter.query.filter_by(id=dc_id).first_or_404()
c_slots = dc.slots
s_slots = DataServer.query.filter_by(datacenter_id=dc_id).count()
if c_slots == s_slots:
flash(u'В датацентре %s заняты все слоты' % dc.name, 'error')
return redirect(url_for('view_dc', dc_id=dc_id))
class DSForm(Form):
name = StringField(
validators=[validators.Required(message=u'Обязательное поле')],
label=u'Имя')
manufacturer = StringField(
validators=[validators.Required(message=u'Обязательное поле')],
label=u'Производитель')
model = StringField(
validators=[validators.Required(message=u'Обязательное поле')],
label=u'Модель')
s_number = StringField(
validators=[validators.Required(message=u'Обязательное поле')],
label=u'Серийный номер')
server_os = StringField(
validators=[validators.Required(message=u'Обязательное поле')],
label=u'Оп.система')
# from wtforms.ext.sqlalchemy.orm import model_form
# exclude = ['id', ]
# DCForm = model_form(Datacenter, Form, exclude=exclude, field_args = {
# 'slots' : {
# 'label':u'Слоты',
# 'validators' : [validators.NumberRange(min=1),],
# },
# 'name' : {
# 'label':u'Имя центра',
# },
# 'address' : {
# 'label':u'Адрес',
# },
# 'tier' : {
# 'label':u'Tier',
# 'validators' : [validators.NumberRange(min=1, max=3, message='1, 2 или 3'),],
# },
# } )
form = DSForm(request.form)
if request.method == 'POST' and form.validate():
ds = DataServer(
name=form.name.data,
manufacturer=form.manufacturer.data,
model=form.model.data,
s_number=form.s_number.data,
server_os=form.server_os.data,
datacenter_id=dc_id,
)
db.session.add(ds)
db.session.commit()
flash(u'Добавлен сервер в датацентр %s' % dc.name, 'success')
return redirect(url_for('view_dc', dc_id=dc_id))
else:
if form.errors.items():
for field, errors in form.errors.iteritems():
for error in errors:
flash(
u"Ошибка в поле %s: %s" %
(getattr(form, field).label.text, error), 'error')
return render_template(
"add_ds.html",
form=form,
dc_id=dc_id,
)
from wtforms_alchemy import model_form_factory
from wtforms import (
StringField,
PasswordField,
SubmitField,
)
from wtforms.validators import (
DataRequired,
Length,
Email,
EqualTo,
)
from .models import User, db
BaseModelForm = model_form_factory(Form, strip_string_fields=True)
class OrderFormMixin(object):
'''
To apply add to Meta 'order' iterable
'''
def __init__(self, *args, **kwargs):
super(OrderFormMixin, self).__init__(*args, **kwargs)
field_order = getattr(self.meta, 'order', [])
if field_order:
visited = []
new_fields = OrderedDict()
for field_name in field_order:
def test_email_validator(self):
form = model_form_factory(email_validator=None)
assert form.Meta.email_validator is None
def test_custom_base_without_session(self):
cls = model_form_factory(Form)
assert cls.get_session is None
def test_number_range_validator(self):
form = model_form_factory(number_range_validator=None)
assert form.Meta.number_range_validator is None
def test_custom_base_with_session(self):
cls = model_form_factory(self.Base)
assert cls.get_session() == 'TestSession'
def test_optional_validator(self):
form = model_form_factory(optional_validator=None)
assert form.Meta.optional_validator is None
QuerySelectMultipleField)
from wtforms_components import read_only
from wtforms_components import DateIntervalField
from wtforms_components.widgets import ReadOnlyWidgetProxy
from wtforms.validators import Required
from flask_ppt2 import app, db
import flask_ppt2.alchemy_models as alch
from config.settings_dev import (FISCAL_YEAR_FORMAT, YEAR_RANGE_MIN,
YEAR_RANGE_MAX, FISCAL_QUARTERS)
YEAR_RANGE_MIN = 2004
if os.environ["PPT_ENVIRONMENT"] == "dev":
import pydevd
BaseModelForm = model_form_factory(FlaskForm)
FISCAL_YEAR_OFFSET = app.config.get("FISCAL_YEAR_OFFSET")
FISCAL_QUARTERS = app.config.get("FISCAL_QUARTERS")
YEAR_RANGE_MIN = app.config.get("YEAR_RANGE_MIN")
YEAR_RANGE_MAX = app.config.get("YEAR_RANGE_MAX")
class ModelForm(BaseModelForm):
@classmethod
def get_session(cls):
return db.session
class FormlyAttributes:
"""Mixin class for forms to generate a list of form field descriptions.
# coding=utf-8
from abilian.web.forms import Form
from abilian.web.forms import widgets as abilian_widgets
from abilian.web.forms.fields import QuerySelect2Field
from abilian.web.forms.filters import strip
from abilian.web.forms.validators import optional, required
from flask_babel import lazy_gettext as _l
from wtforms import StringField, TextAreaField
from wtforms_alchemy import model_form_factory
from abilian.sbe.apps.communities.models import Community
ModelForm = model_form_factory(Form) # type: Form
class UserProfileForm(ModelForm):
pass
class UserProfileViewForm(UserProfileForm):
communautes = QuerySelect2Field(
"Communautés d'appartenance",
get_label="name",
view_widget=abilian_widgets.ListWidget(),
query_factory=lambda: Community.query.all(),
multiple=True,
validators=[optional()],
)
__version__ = '0.1.0'
from flask.ext.wtf import Form
import wtforms
from wtforms_alchemy import model_form_factory
from ..database import db
BaseModelForm = model_form_factory(Form)
class ModelForm(BaseModelForm):
"""
wtforms-alchemy Flask-WTF compatible base model form.
Copied from:
http://wtforms-alchemy.readthedocs.org/en/latest/advanced.html#using-wtforms-alchemy-with-flask-wtf
"""
@classmethod
def get_session(self):
return db.session
BaseModelWtfForm = model_form_factory(wtforms.Form)
class ModelWtfForm(BaseModelWtfForm):
"""
Same as ModelForm (also defined in this file), but inherited
from regular wtforms base class, instead of Flask-WTF base
class (for when one wants a non-Flask-WTF wtforms form that
works with wtforms-alchemy).
def model_form_custom(request):
"""Returns one of each possible model form classes with custom
metaclasses."""
return model_form_factory(meta=request.param)
from flask_wtf import Form
from wtforms import TextField, PasswordField, SelectField, TextAreaField, SubmitField, validators, widgets
from application.models import *
from wtforms_alchemy import ModelFieldList, model_form_factory
from wtforms.fields import FormField
from wtforms.widgets import TextArea
ModelForm = model_form_factory(Form)
class CKEditor(TextArea):
def __call__(self, field, **kwargs):
c = kwargs.pop('class', '') or kwargs.pop('class_', '')
kwargs['class'] = u'%s %s' % ('ckeditor', c)
return super(CKEditor, self).__call__(field, **kwargs)
class CKEditorField(TextAreaField):
widget = CKEditor()
import flask_wtf
import wtforms_alchemy
from flask_skeleton.models import db, User
class DeleteForm(flask_wtf.Form):
"""Dummy form to allow CSRF on requests without other fields, e.g. delete."""
pass
# plumbing to get flask integration between wtforms_alchemy and flask_wtf
# pylint: disable=invalid-name
BaseModelForm = wtforms_alchemy.model_form_factory(flask_wtf.Form)
class ModelForm(BaseModelForm):
@classmethod
def get_session(self):
return db.session
class UserForm(ModelForm):
class Meta:
model = User
only = ['email', 'password']
from sqlalchemy.sql import expression as ex
from sqlalchemy import desc, func
import json
from appshell.forms import FormEndpoint
from flask.ext.babelex import Babel, Domain
from appshell import View, url_for
from flask import flash, request, redirect
from appshell.endpoints import ConfirmationEndpoint
db = SQLAlchemy()
mydomain = Domain('appshell')
_ = mydomain.gettext
lazy_gettext = mydomain.lazy_gettext
BaseModelForm = model_form_factory(OrderedForm)
class ModelForm(BaseModelForm):
@classmethod
def get_session(self):
return db.session
def register_in_app(appshell, app):
db.init_app(app)
class SQLColumn(Column):
def __init__(self, name, expression, **kwargs):
super(SQLColumn, self).__init__(name, expression=expression, **kwargs)
此函数把这些无法被处理的值转换成每种字段对应的字符串形式"""
if value is None:
return ''
if isinstance(value, datetime.datetime):
return value.isoformat().split(".").pop(0)
if isinstance(value, int) or isinstance(value, float):
# 若不把数字类型转换为 str ，InputValidator() 会把 0 值视为未赋值，导致验证失败
return str(value)
return value
# ======================================
# 自定义 WTForms-alchemy ModelForm
# ======================================
ModelForm = model_form_factory(APIForm, strip_string_fields=True)
class _APIEditForm(APIForm):
def __init__(self, *args, **kwargs):
if not hasattr(self, '_obj'):
raise ValueError(u"""当前表单是编辑实体用的表单，应传入对应的实体对象以避免 unique 检查失败。
请通过命名参数的形式传递，即： TheForm(obj=instance) ，不要直接传递。
如果确实不需要传入 obj 参数，请这样： TheForm(obj=None)""")
super(_APIEditForm, self).__init__(*args, **kwargs)
ModelEditForm = model_form_factory(_APIEditForm,
strip_string_fields=True,
all_fields_optional=True)
import flask_wtf
import wtforms_alchemy
from flask_skeleton.models import db, User
class DeleteForm(flask_wtf.Form):
"""Dummy form to allow CSRF on requests without other fields, e.g. delete."""
pass
# plumbing to get flask integration between wtforms_alchemy and flask_wtf
# pylint: disable=invalid-name
BaseModelForm = wtforms_alchemy.model_form_factory(flask_wtf.Form)
class ModelForm(BaseModelForm):
@classmethod
def get_session(self):
return db.session
class UserForm(ModelForm):
class Meta:
model = User
only = ['email', 'password']
from wtforms.ext.sqlalchemy.fields import QuerySelectMultipleField
# generate forms from SQLAlchemy models
from wtforms.ext.sqlalchemy.orm import model_form as sa_model_form
###
# WTForms-Alchemy: a toolkit for easier creation of model based forms.
# This is a improved tool of the `wtforms.ext.sqlalchemy.orm.model_form`,
# while you can use QuerySelectField and QuerySelectMultipleField along
# with it.
###
from wtforms_alchemy import model_form_factory
from .db import db
from .utils import comma_separated_string_split
BaseModelForm = model_form_factory(BaseForm)
# You can super this class to create form class or use the following
# metaclass_form_factory.
class ModelForm(BaseModelForm):
@classmethod
def get_session(self):
return db.session
# from .models import User
# example of user form
# class UserForm(ModelForm):
# class Meta:
# model = User
from flask_wtf import FlaskForm
from wtforms_alchemy import model_form_factory
from perciapp.extensions import db
BaseModelForm = model_form_factory(FlaskForm)
class ModelForm(BaseModelForm):
"""
Allow WTForms-Alchemy to work with Flask-WTF.
"""
@classmethod
def get_session(self):
return db.session
def choices_from_dict(source, prepend_blank=True):
"""
Convert a dict to a format that's compatible with WTForm's choices. It also
optionally prepends a "Please select one..." value.
Example:
# Convert this data structure:
STATUS = OrderedDict([
('unread', 'Unread'),
('open', 'Open'),
('contacted', 'Contacted'),
('closed', 'Closed')
])
def __init__(self, model, *args, **kwargs):
model_form = model_form_factory(RelationshipFormMixin)
form_cls = form_class_factory(model, model_form, include_primary_keys=True)
super().__init__(form_cls, *args, **kwargs)
def test_custom_base_with_session(self):
cls = model_form_factory(self.Base)
assert cls.get_session() == 'TestSession'
def test_inherit_without_new_session(self):
cls = model_form_factory(self.Base)
class Sub(cls):
pass
assert Sub.get_session() == 'TestSession'
Regular forms use WTForms http://wtforms.simplecodes.com/docs/1.0.4/
Model CRUD/search forms use WTForms-Alchemy http://wtforms-alchemy.readthedocs.org/en/latest/
"""
from wtforms import Form
from wtforms_alchemy import model_form_factory, ModelFormField, ModelFieldList
from wtforms.validators import Email, URL
from feedduty.models import (
DBSession,
User,
Feed,
Tag,
)
# Create a custom ModelForm so that we can add common metadata
BaseModelForm = model_form_factory(Form, strip_string_fields=True, )
# Model Forms
#
# This forms are used to create or edit model instances
class ModelForm(BaseModelForm):
@classmethod
def get_session(cls):
"""
Get the SQLAlchemy database session
"""
return DBSession
class TestCustomBase(model_form_factory(SomeForm)):
class Meta:
model = self.ModelTest
#
# Lifewatch DAAP is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Lifewatch DAAP is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Lifewatch DAAP. If not, see <http://www.gnu.org/licenses/>.
from __future__ import absolute_import, print_function, unicode_literals
from invenio.utils.forms import InvenioBaseForm
from wtforms_alchemy import model_form_factory
from .models import UserProfile
ModelForm = model_form_factory(InvenioBaseForm)
class ProfileForm(ModelForm):
class Meta:
model = UserProfile
only = ['name', 'institution', 'email', 'social_profiles',
'ssh_public_key', 'user_db', 'pass_db',
'token_onedata']
from flask_wtf import Form
from flask_babel import gettext as _
from wtforms_alchemy import model_form_factory
from wtforms_alchemy.utils import choice_type_coerce_factory
from wtforms import StringField, TextAreaField, BooleanField, RadioField, HiddenField
from wtforms.validators import DataRequired
from .models import Work
from . import db
BaseModelForm = model_form_factory(Form) # Creates a model for inheriting Form
class ModelForm(BaseModelForm):
"""
Inherits BaseModelForm, this is just so we can add the get_session class method
"""
@classmethod
def get_session(cls):
return db.session
class CreateWorkForm(ModelForm):
"""
The work creation form; specifies basic fields as well as the first chapter's content
"""
title = StringField(_(u'Title'), validators=[DataRequired()])
synopsis = TextAreaField(_(u'Synopsis'), validators=[DataRequired()])
category = StringField(_(u'Fandom'), validators=[DataRequired()])
content_rating = RadioField(_(u'Content Rating'), choices=Work.CONTENT_RATINGS,
coerce=choice_type_coerce_factory(Work.content_rating.type),
validators=[DataRequired()])
# coding=utf-8
from __future__ import absolute_import, print_function, unicode_literals
from abilian.web.forms import Form
from abilian.web.forms import widgets as abilian_widgets
from abilian.web.forms.fields import QuerySelect2Field
from abilian.web.forms.filters import strip
from abilian.web.forms.validators import optional, required
from flask_babel import lazy_gettext as _l
from wtforms import StringField, TextAreaField
from wtforms_alchemy import model_form_factory
from abilian.sbe.apps.communities.models import Community
ModelForm = model_form_factory(Form) # type: Form
class UserProfileForm(ModelForm):
pass
class UserProfileViewForm(UserProfileForm):
communautes = QuerySelect2Field(
"Communautés d'appartenance",
get_label="name",
view_widget=abilian_widgets.ListWidget(),
query_factory=lambda: Community.query.all(),
multiple=True,
validators=[optional()],
)
"""Events forms."""
from flask_wtf import Form
from wtforms_alchemy import model_form_factory
from pygotham.models import Event
__all__ = ('EventForm',)
ModelForm = model_form_factory(Form)
class EventForm(ModelForm):
"""Form for creating :class:`~pygotham.models.Event` instances."""
class Meta:
model = Event
only = ('name', 'slug', 'begins', 'ends', 'proposals_begin', 'active')
def test_custom_base_without_session(self):
cls = model_form_factory(Form)
assert cls.get_session is None
