class giantform(FlaskForm):
about_you = wtforms.FormField(EmployeeForm)
training = wtforms.FormField(whmisForm)
training2 = wtforms.FormField(ppeForm)
training3 = wtforms.FormField(fireextinguishersForm)
training4 = wtforms.FormField(emergencyproceduresForm)
training5 = wtforms.FormField(firstaidForm)
training6 = wtforms.FormField(foodhandlingForm)
training7 = wtforms.FormField(propaneForm)
training8 = wtforms.FormField(healthandsafetyForm)
training9 = wtforms.FormField(workingaloneForm)
training10 = wtforms.FormField(workplaceviolenceForm)
training11 = wtforms.FormField(jointhealthandsafetyForm)
training12 = wtforms.FormField(fuelpumpshutoffForm)
class DayForm(wtforms.Form):
"""A form for recording day actions."""
actions = wtforms.FieldList(wtforms.FormField(DayPlayerForm))
start_night = wtforms.SubmitField("Night Phase ->")
class ReservationPeopleEmail(FlaskForm):
guest = f.FieldList(f.FormField(SubReservationPeopleEmail), min_entries=1, max_entries=100)
display = ['guest']
class EditRestaurantForm(FlaskForm):
phone = f.StringField('Phone', validators=[DataRequired()])
#tables = f.FieldList(f.FormField(TableForm), min_entries=1, max_entries=100)
dishes = f.FieldList(f.FormField(DishForm), min_entries=1, max_entries=100)
display = ['phone']
def new_lista_ditte(label, m_entries=5):
"Instanzia una lista ditte con dato numero di campi"
return MyFieldList(wt.FormField(Ditta), label, True, min_entries=m_entries)
class GiantForm(FlaskForm):
mailID_submit = wtforms.FormField(AuthorizeMailForm)
Viewing_Details = wtforms.FormField(ViewingListForm)
class DepositForm(asb.forms.CSRFTokenForm):
"""A form for depositing money."""
transactions = wtforms.FieldList(
wtforms.FormField(TransactionForm, [wtforms.validators.Optional()]),
min_entries=5
)
resubmitted = wtforms.HiddenField()
add_rows = wtforms.SubmitField('+')
deposit = wtforms.SubmitField('Submit')
def check_for_dupes(self, request):
"""Check for posts that have been claimed multiple times, or that have
been claimed in the past.
"""
no_dupes = True
# Count duplicate submissions
post_ids = collections.Counter(
transaction.link.post_id for transaction in self.transactions
if transaction.link.post_id is not None
)
# Find past transactions for the same posts
past_transactions = (
db.DBSession.query(db.BankTransaction)
.filter_by(trainer_id=request.user.id)
.filter(db.BankTransaction.tcod_post_id.in_(post_ids))
.all()
)
past_transaction_dict = {}
for transaction in past_transactions:
ts = past_transaction_dict.setdefault(transaction.tcod_post_id, [])
ts.append(transaction)
# Handle resubmitted ids
if self.resubmitted.data:
resubmitted_ids = map(int, self.resubmitted.data.split(','))
else:
# ''.split(',') == ['']
resubmitted_ids = []
to_resubmit = []
# Go through and add appropriate error messages
for transaction in self.transactions:
id = transaction.link.post_id
if id is None:
continue
# Complain about duplicate submissions
if post_ids[id] > 1:
transaction.link.errors.append(
"You've entered the same link (post #{0}) for multiple "
"transactions.".format(id)
)
no_dupes = False
# If they're deliberately resubmitting this post, continue
to_resubmit.append(id)
if id in resubmitted_ids and transaction.notes.data:
continue
# If not, complain about past transactions
for past_t in past_transaction_dict.get(id, []):
message = ["You've claimed post #{0} before, and".format(id)]
if past_t.state == 'pending':
message.append("it's still pending.")
else:
message.append('it was {0}.'.format(past_t.state))
message.append('If you really want to claim it again,')
if not transaction.notes.data:
message.append('add a note explaining why and')
message.append('press "Submit" again.')
transaction.link.errors.append(' '.join(message))
no_dupes = False
self.resubmitted.data = ','.join(map(str, to_resubmit))
return no_dupes
class GrantForm(wtforms.Form):
amount = wtforms.FormField(custom_fields.MoneyForm, label='Requested Amount', widget=custom_fields.form_field_widget)
project = custom_fields.SelectField(coerce=data_models.create_key, validators=[wtforms.validators.InputRequired()])
target_date = wtforms.DateField(widget=widgets.MonthInput(), format='%Y-%m',
validators=[wtforms.validators.InputRequired()])
description = wtforms.TextAreaField()
def make_form(session,
schema,
entity=None,
formdata=None,
show_metadata=True,
transition=modes.AUTO,
allowed_versions=None):
"""
Converts a Datastore schema to a WTForm for data entry
Parameters:
session -- the database session to query for form metata
schema -- the assumed form for data entry
formdata -- (optional) incoming data for lookahead purposes:
* if ``version`` changes, then the specified version will
override the ``schema`` parameter
show_metadata -- (optional) includes entity metadata fields
allowed_versions -- list of schemata versions that can override ``schema``
Returns:
A WTForm class. The reason why an instance is not returns is in case
the user wants to sitch together multiple forms for Long Forms.
"""
class DatastoreForm(wtforms.Form):
class Meta:
pass
setattr(Meta, 'schema', schema)
setattr(Meta, 'entity', entity)
def validate(self, **kw):
status = True
if 'ofworkflow_' in self:
status = status and self.ofworkflow_.validate(self)
# No further validation needed if we're going to
# erase the data anyway
if self.ofworkflow_.state.data == states.PENDING_ENTRY:
return status
# Skip all validation if coming from a read-only state
if self.meta.entity \
and self.meta.entity.state.name == states.COMPLETE:
return status
if 'ofmetadata_' in self and self.ofmetadata_.not_done.data:
return status and self.ofmetadata_.validate(self)
else:
return status and super(DatastoreForm, self).validate(**kw)
if show_metadata:
# If there was a version change so we render the correct form
if formdata and 'ofmetadata_-version' in formdata:
schema = (session.query(datastore.Schema).filter_by(
name=schema.name,
publish_date=formdata['ofmetadata_-version']).one())
if not allowed_versions:
allowed_versions = []
allowed_versions.append(schema.publish_date)
allowed_versions = sorted(set(allowed_versions))
actual_versions = [(str(p), str(p)) for (p, ) in (
session.query(datastore.Schema.publish_date).filter(
datastore.Schema.name == schema.name).
filter(datastore.Schema.publish_date.in_(allowed_versions)).filter(
datastore.Schema.retract_date == sa.null()).order_by(
datastore.Schema.publish_date.asc()).all())]
if len(allowed_versions) != len(actual_versions):
log.warn('Inconsitent versions: %s != %s' %
(allowed_versions, actual_versions))
class Metadata(wtforms.Form):
not_done = wtforms.BooleanField(_(u'Not Collected'))
collect_date = wtforms.ext.dateutil.fields.DateField(
_(u'Collect Date'),
widget=wtforms.widgets.html5.DateInput(),
validators=[wtforms.validators.InputRequired()])
version = wtforms.SelectField(
_(u'Version'),
choices=actual_versions,
validators=[wtforms.validators.InputRequired()])
setattr(DatastoreForm, 'ofmetadata_', wtforms.FormField(Metadata))
if transition == modes.ALL:
allowed_states = TRANSITIONS.keys()
elif transition == modes.AVAILABLE:
try:
current_state = entity.state.name
except AttributeError:
current_state = states.PENDING_ENTRY
allowed_states = TRANSITIONS[current_state]
else:
allowed_states = []
if allowed_states:
allowed_states = (session.query(datastore.State).filter(
datastore.State.name.in_(allowed_states)).order_by(
datastore.State.title))
choices = [('', '')] \
+ [(state.name, state.title) for state in allowed_states]
class Workflow(wtforms.Form):
state = wtforms.SelectField(_(u'Set state to...'),
choices=choices,
validators=[
wtforms.validators.InputRequired(
_('Please select a state'))
])
setattr(DatastoreForm, 'ofworkflow_', wtforms.FormField(Workflow))
for attribute in schema.itertraverse():
setattr(DatastoreForm, attribute.name, make_field(attribute))
return DatastoreForm
class Form(ApprovalForm):
transactions = wtforms.FormField(Subform)
class FullBattleCloseForm(BattleCloseForm):
"""The full form, with Pokémon."""
db_pokemon = battle_pokemon
pokemon = wtforms.FormField(PokemonForm)
class CrudForm(wtforms.Form):
specimen = wtforms.FieldList(wtforms.FormField(SpecimenForm))
class PostSettings(FlaskForm):
interval = wtforms.FormField(AutoPostInterval)
duration = wtforms.FormField(AutoPostDuration)
refresh = wtforms.FormField(RefreshInterval)
class SelectDriver(FlaskForm):
driver_list = wtforms.FormField(DriverList)
class CombineForm(FlaskForm):
app_form = wtforms.FormField(ApplicationForm)
act_form = wtforms.FormField(ActionForm)
submit = SubmitField()
class EditMetaDataForm(wtforms.Form):
media_metadata = wtforms.FieldList(
wtforms.FormField(MetaDataForm, ""),
)
class DynoForm(FlaskForm):
fields = wtforms.FieldList(wtforms.FormField(DynoField),min_entries = 1)
def make_field(attribute):
"""
Converts an attribute to a WTForm field
"""
kw = {
'label': attribute.title,
'description': attribute.description,
'filters': [],
'validators': []
}
if attribute.type == 'section':
class Section(wtforms.Form):
pass
for subattribute in attribute.itertraverse():
setattr(Section, subattribute.name, make_field(subattribute))
return wtforms.FormField(Section,
label=attribute.title,
description=attribute.description)
elif attribute.type == 'number':
if attribute.decimal_places == 0:
field_class = wtforms.fields.html5.IntegerField
else:
field_class = wtforms.fields.html5.DecimalField
if attribute.decimal_places > 0:
ndigits = abs(attribute.decimal_places)
step = round(1 / pow(10, ndigits), ndigits)
kw['widget'] = wtforms.widgets.html5.NumberInput(step)
kw['places'] = attribute.decimal_places
kw['rounding'] = ROUND_UP
elif attribute.type == 'string':
field_class = wtforms.StringField
kw['filters'].append(strip_whitespace)
if attribute.widget == 'phone':
kw['widget'] = wtforms.widgets.html5.TelInput()
elif attribute.widget == 'email':
kw['widget'] = wtforms.widgets.html5.EmailInput()
elif attribute.type == 'text':
field_class = wtforms.TextAreaField
kw['filters'].append(strip_whitespace)
elif attribute.type == 'date':
field_class = wtforms.ext.dateutil.fields.DateField
kw['widget'] = wtforms.widgets.html5.DateInput()
kw['validators'].append(DateRange(min=date(1899, 12, 31)))
elif attribute.type == 'datetime':
field_class = wtforms.ext.dateutil.fields.DateTimeField
kw['widget'] = wtforms.widgets.html5.DateTimeInput()
kw['validators'].append(DateRange(min=datetime(1899, 12, 31)))
elif attribute.type == 'choice':
choices = list(attribute.iterchoices())
if len(choices) > 10:
attribute_widget = 'select'
label = '{choice.title} - [ {choice.name} ]'
else:
attribute_widget = None
label = '{choice.title}'
kw['choices'] = [(c.name, label.format(choice=c)) for c in choices]
# If true, parse as string, else return none
kw['coerce'] = lambda v: six.binary_type(v) if v else None
if attribute.is_collection:
field_class = wtforms.SelectMultipleField
if attribute_widget == 'select':
kw['widget'] = wtforms.widgets.Select(multiple=True)
else:
kw['widget'] = wtforms.widgets.ListWidget(prefix_label=False)
kw['option_widget'] = wtforms.widgets.CheckboxInput()
else:
field_class = wtforms.SelectField
if attribute_widget == 'select':
kw['widget'] = wtforms.widgets.Select()
else:
kw['widget'] = wtforms.widgets.ListWidget(prefix_label=False)
kw['option_widget'] = wtforms.widgets.RadioInput()
elif attribute.type == 'blob':
field_class = FileField
else:
raise Exception(u'Unknown type: %s' % attribute.type)
if attribute.is_required:
kw['validators'].append(wtforms.validators.InputRequired())
else:
kw['validators'].append(wtforms.validators.Optional())
if attribute.value_min or attribute.value_max:
# for string min and max are used to test length
if attribute.type == 'string':
if attribute.value_min == attribute.value_max:
message = u'Field must be %(min)s characters long.'
else:
message = None
kw['validators'].append(
wtforms.validators.Length(
min=attribute.value_min
if attribute.value_min is not None else -1,
max=attribute.value_max
if attribute.value_max is not None else -1,
message=message))
if attribute.type == 'choice' and attribute.is_collection:
if attribute.value_min == attribute.value_max:
message = u'Field must be %(min)s characters long.'
elif attribute.value_min is not None \
and attribute.value_max is None:
message = u'Field must have at least %(min)s selected.'
elif attribute.value_min is None \
and attribute.value_max is not None:
message = u'Field must have at most %(max)s selected.'
else:
message = None
kw['validators'].append(
wtforms.validators.Length(
min=attribute.value_min
if attribute.value_min is not None else -1,
max=attribute.value_max
if attribute.value_max is not None else -1,
message=message))
# for number min and max are used to test the value
elif attribute.type == 'number':
if attribute.value_min == attribute.value_max:
message = u'Number must be %(min)s.'
else:
message = None
kw['validators'].append(
wtforms.validators.NumberRange(min=attribute.value_min,
max=attribute.value_max,
message=message))
if attribute.pattern:
kw['validators'].append(wtforms.validators.Regexp(attribute.pattern))
return field_class(**kw)
class PaymentAmountForm(wtforms.Form):
amount = wtforms.FormField(custom_fields.MoneyForm,
label='Payment Amount',
widget=custom_fields.form_field_widget)
