class ProjectBudgetItemOverallForm(ModelForm):
class Meta:
model = ProjectBudgetItemOverall
sub_category = QuerySelectField(
ProjectBudgetSubCategory,
query_factory=lambda: ProjectBudgetSubCategory.query.all(),
widget=Select())
class LabQualTestForm(ModelForm):
class Meta:
model = LabQualTest
choice_set = QuerySelectField('Choice Set',
widget=Select(),
allow_blank=True,
blank_text='ไม่ใช้ชุดคำตอบ',
validators=[Optional()]
)
class ProjectPublicationForm(ModelForm):
class Meta:
model = ProjectPublication
journals = QuerySelectField(
ProjectPublicationJournal,
query_factory=lambda: ProjectPublicationJournal.query.all(),
get_label=lambda x: x.name,
widget=Select())
class ProjectPublicationAuthorForm(ModelForm):
class Meta:
model = ProjectPublicationAuthor
users = QuerySelectField(
User,
query_factory=lambda: sorted([u for u in User.query.filter_by(role=2)],
key=lambda x: x.fullname_thai),
get_label=lambda x: x.profile.fullname_th,
widget=Select(),
validators=[Optional()])
class OutsideVerificationForm(Form):
standard = AllStandardsData('Choose Standard')
student = StringField(u'Student Name (Full Name)', widget=TextInput(), validators=[validators.input_required(message=NO_INPUT_ERROR)])
verifier_name = StringField(u'Teacher name (Verifier)', widget=TextInput(), validators=[validators.input_required(message=NO_INPUT_ERROR)])
verifier_school = StringField(u'School of Verifier', widget=TextInput())
verifiers_grade = SelectField(u'Assessment judgement', widget=Select(), choices=GRADES, validators=[validators.NoneOf(values='No Grade',message='Please enter appropriate grade')])
discussion = StringField(u'Discussion', widget=TextArea())
finished = BooleanField(u"<p id='finished_p'>", widget=CheckboxInput(),validators=[validators.required(message="The sign off box above must be checked to submit data")])
class CoveredArea(InsecureForm):
name = TextField(_(u'name'), widget=partial(TextInput(), class_='input-medium', placeholder=_(u'Area')))
technologies = SelectMultipleField(_(u'technologies'), choices=TECHNOLOGIES_CHOICES,
widget=partial(Select(True), **{'class': 'selectpicker', 'data-title': _(u'Technologies deployed')}))
area = GeoJSONField(_('area'), widget=partial(TextArea(), class_='geoinput'))
def validate(self, *args, **kwargs):
r = super(CoveredArea, self).validate(*args, **kwargs)
if bool(self.name.data) != bool(self.technologies.data):
self._fields['name'].errors += [_(u'You must fill both fields')]
r = False
return r
class ProjectMemberForm(ModelForm):
class Meta:
model = ProjectMember
users = QuerySelectField(
'User',
query_factory=lambda: sorted([u for u in User.query.filter_by(role=2)],
key=lambda x: x.fullname_thai),
get_label='fullname_thai',
allow_blank=True,
blank_text='กรุณาเลือกนักวิจัย',
widget=Select())
class CompareForm(FlaskForm):
"""Contact form."""
task_from = SelectMultipleField(
"Task from",
validators=[
DataRequired(message="Please choose a task to compare from.")
],
widget=Select(multiple=False))
task_to = SelectField(
"Task to",
validators=[
DataRequired(message="Please choose a task to compare to.")
])
submit = SubmitField('Compare tasks')
class _SingleChoiceQuerySelectMultipleField(IndicoQuerySelectMultipleField):
# single-choice version of the multi select field that uses
# a collection instead of a single value for `data`
widget = Select()
def iter_choices(self):
yield ('__None', self.blank_text, self.data is None)
yield from super().iter_choices()
def process_formdata(self, valuelist):
# remove "no value" indicator. QuerySelectMultipleField validation
# is broken in WTForms so it never causes a validation error to have
# invalid data in valuelist but maybe it gets fixed at some point...
valuelist = list(set(valuelist) - {'__None'})
if len(valuelist) > 1:
raise ValueError('Received more than one value')
super().process_formdata(valuelist)
class WrappedSelect(Select):
"""Widget to wrap select input in further markup."""
wrapper = '<div>%(field)s</div>'
wrapped_widget = Select()
def __init__(self, widget=None, wrapper=None, **kwargs):
"""Initialize wrapped input with widget and wrapper."""
self.wrapped_widget = widget or self.wrapped_widget
self.wrapper_args = kwargs
if wrapper is not None:
self.wrapper = wrapper
def __call__(self, field, **kwargs):
"""Render wrapped input."""
return HTMLString(self.wrapper % dict(
field=self.wrapped_widget(field, **kwargs), **self.wrapper_args))
class PlacementForm(Form):
component = HiddenField()
name = StringField("Name",[validators.required()],
#widget=StaticIfExists(),
render_kw={'class':'form-control'})
cls = SelectField("Type", [validators.required()],
choices=[(d,d) for d in ('Component','Assembly')],
widget=StaticIfExists(Select()),
render_kw={'class':'form-control'})
weight = NumericField("Quantity", [validators.required()] ,
render_kw={'size':1, 'class':'form-control'})
querymod = JSONField("Querymod")
#edit = StaticField("Edit", default="link goes here");
#override BaseForm process to restructure placements
class _FakePlacement(object):
def __init__(self, placement):
self.component = (placement.component.id
if hasattr(placement.component,'id')
else placement.component)
self.name = placement.name
self.cls = (type(placement.component).__name__
if self.component else None)
self.weight = placement.weight
self.querymod = placement.querymod
def process(self, formdata=None, obj=None, data=None, **kwargs):
if isinstance(obj, component.Placement):
obj = self._FakePlacement(obj)
super().process(formdata=formdata, obj=obj, data=data, **kwargs)
#override populate_obj to make new component if necessary
def populate_obj(self, obj):
comp = self.component.data
if not comp or comp == str(None):
comp = component.buildcomponentfromdict({
'__class__': self.cls.data,
'name': self.name.data
})
obj.component = comp
obj.name = self.name.data
obj.weight = self.weight.data
obj.querymod = self.querymod.data
class Many2manyField(Field):
widget = Select(multiple=True)
def __init__(self, label, model, validators=None, **kwargs):
self.model = model
# fixme
self.available_records = self.model.query.all()
super(Many2manyField, self).__init__(label=label,
validators=validators,
**kwargs)
def iter_choices(self):
for record in self.available_records:
selected = self.data is not None and record in self.data
yield (record, record.name, selected)
def _value(self):
return list(map(self.model.name_get, self.data))
def process_data(self, value):
try:
self.data = list(map(self.model.name_get, value))
except (ValueError, TypeError):
self.data = None
def process_formdata(self, valuelist):
self.data = list(map(self.model.name_get, valuelist))
if not all(self.data):
raise ValueError(
self.gettext(
'Invalid choice(s): one or more data inputs could not be coerced'
))
def pre_validate(self, form):
if self.data:
for d in self.data:
if not d:
raise ValueError(
self.gettext(
"'%(value)s' is not a valid choice for this field")
% dict(value=d))
class RegisterStep2Form(ModelForm):
class Meta: #pylint: disable=no-init,missing-docstring,old-style-class,too-few-public-methods
model = User
only = ['position', 'organization', 'country']
@classmethod
def is_not_empty(cls, user):
'''
Returns whether or not the user has filled out any of the
fields in the form. Used to determine whether to skip past
this form when resuming the registration process.
'''
for attr in cls.Meta.only:
if getattr(user, attr):
return True
return False
expertise_domain_names = CallableChoicesSelectMultipleField(
label=lazy_gettext('Fields of Work'),
widget=Select(multiple=True),
choices=lambda: [(v, lazy_gettext(v))
for v in current_app.config['DOMAINS']])
class IndicoEnumSelectField(_EnumFieldMixin, SelectFieldBase):
"""Select field backed by a :class:`RichEnum`."""
widget = Select()
def __init__(self,
label=None,
validators=None,
enum=None,
sorted=False,
only=None,
skip=None,
none=None,
titles=None,
keep_enum=True,
**kwargs):
super(IndicoEnumSelectField, self).__init__(label, validators,
**kwargs)
self.enum = enum
self.sorted = sorted
self.only = set(only) if only is not None else None
self.skip = set(skip or set())
self.none = none
self.keep_enum = keep_enum
self.titles = titles
def iter_choices(self):
items = (
x for x in self.enum
if x not in self.skip and (self.only is None or x in self.only))
if self.sorted:
items = sorted(items, key=attrgetter('title'))
if self.none is not None:
yield ('__None', self.none, self.data is None)
for item in items:
title = item.title if self.titles is None else self.titles[item]
yield (item.name, title, item == self.data)
class ArtistSelect(Form):
artist_display = SelectField('artist_options',
coerce=int,
option_widget=Select(multiple=False))
confirm_button = SubmitField("Add!")
class LoginForm(Form): """General Login Form""" school = AllSchoolsData(u'Choose School', widget=Select()) password = PasswordField(u'Password', widget=PasswordInput(), validators=[validators.input_required(message='Please input password')])
class AdminStandardCreate(Form): school = AllSchoolsData(u'Choose School', widget=Select()) year = SelectField(u'Year', widget=Select(), choices=YEARS) filename = StringField(u'Cloud Storage Filename or Filename', widget=TextInput())
class KeyPropertyMultiField(KeyPropertyField):
"""Multi choice `KeyPropertyField`."""
widget = Select(multiple=True)
reference_class = None
def __init__(self, *args, **kwargs):
"""Set reference_class."""
super(KeyPropertyMultiField, self).__init__(*args, **kwargs)
self.reference_class = kwargs.get('reference_class')
def iter_choices(self):
"""Iterate on field choices.
Yield:
(Key, str, bool) -- Entity key, label, field data exists
"""
for obj in self.query:
key = str(obj.key.id())
label = self.get_label(obj)
yield (key, label, (obj.key in self.data) if self.data else False)
def pre_validate(self, form):
"""Pre-validate keys data."""
if self.data is not None:
choices = [entity.key for entity in self.query]
for value in self.data:
if hasattr(value, 'key') and value.key in choices:
pass
elif value in choices:
pass
else:
raise ValueError(self.gettext('Not a valid choice'))
elif not self.allow_blank:
raise ValueError(self.gettext('Not a valid choice'))
def populate_obj(self, obj, name):
"""Populate `obj.<name>` with the field's data.
Note:
This is a destructive operation. If `obj.<name>` already exists, it
will be overridden. Use with caution.
"""
if self.data is not None:
values = self.data if hasattr(self.data,
'__iter__') else [self.data]
else:
values = []
try:
setattr(obj, name, [value.key for value in values])
except AttributeError:
setattr(obj, name, values)
def process_formdata(self, valuelist):
"""Process data received over the wire from a form.
This will be called during form construction with data supplied
through the `formdata` argument.
Args:
valuelist -- (list) A list of strings to process.
"""
if valuelist:
self._data = None
self._formdata = valuelist
def _get_data(self):
if self._formdata is not None:
try:
data = [
ndb.Key(self.reference_class, int(key_id))
for key_id in self._formdata
]
except (TypeError, ValueError):
data = [
ndb.Key(self.reference_class, key_id)
for key_id in self._formdata
]
self._set_data(data)
return self._data
def _set_data(self, data):
self._data = data
self._formdata = None
data = property(_get_data, _set_data)
class StaffToUsersForm(Form): school = AllSchoolsData(u'Choose School', widget=Select()) year = SelectField(u'Year', widget=Select(), choices=YEARS)
class CodeForm(Form): school = AllSchoolsData(u'School', widget=Select()) code = StringField(u'Code', widget=TextInput())
