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)