class SettingsForm(FlaskForm):
name: fields.Field = StringField(lazy_gettext('Site Name'))
description: fields.Field = StringField(lazy_gettext('Site Description'))
avatar: fields.Field = StringField(lazy_gettext('Avatar URL'))
cover_url: fields.Field = StringField(lazy_gettext('Cover Image URL'))
locale: fields.Field = fields.SelectField(
lazy_gettext('Language'),
choices=[
('en', lazy_gettext('English')),
('zh_Hans_CN', lazy_gettext('Chinese')),
],
default='en',
)
google_site_verification: fields.Field = StringField(
lazy_gettext('Google Site Verification Code'))
disqus_shortname: fields.Field = StringField(
lazy_gettext('Disqus Shortname'))
sociallinks: fields.Field = fields.FieldList(fields.FormField(SocialLink),
lazy_gettext('Social Links'),
min_entries=1)
icp: fields.Field = StringField(lazy_gettext('ICP No.'))
links: fields.Field = fields.FieldList(fields.FormField(FriendLink),
lazy_gettext('Friend Links'),
min_entries=1)
@classmethod
def from_local(cls) -> "SettingsForm":
return cls(data=g.site)
class SampleForm(FlaskForm):
"""Form for creating a new Samples document."""
session = fields.IntegerField('Session', validators=[validators.required()])
position = fields.IntegerField(
'Sample Position/FOV', validators=[validators.required()]
)
time_step = fields.StringField('Time Step', validators=[validators.Length(0, 255)])
z_step = fields.StringField('Z Step', validators=[validators.Length(0, 255)])
specimen = fields.StringField(
'Specimen Name', validators=[validators.Length(0, 1000)]
)
# imaging parameters (embedded document fields)
imaging_params = fields.FormField(ImagingParametersForm)
# dimensions (embedded document fields)
dimensions = fields.FormField(DimensionsForm)
# modality (embedded document fields)
modality = fields.FormField(ModalityInformationForm)
# location in the ontology
kinetics = fields.RadioField(
choices=('static', 'dynamic'), validators=[validators.required()]
)
spatial_dim = fields.RadioField(
choices=('2d', '3d'), validators=[validators.required()]
)
class MasterDataForm(BaseForm):
pg_name = fields.StringField(('Name'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
sport = fields.SelectField(u'Sport', choices=[(key, value) for key, value in constants.SPORTS_LIST.items()], default='others')
locality_id = fields.HiddenField()
business_id = fields.HiddenField()
address = fields.FormField(Address)
contact_pg = fields.FormField(BasicContact)
public = fields.SelectField(u'Open for Public?', choices=[(key, value) for key, value in constants.OPEN_DICT.items()], default=0)
booking_days = fields.SelectField(u'Public Booking Day(s)', choices=[(key, value) for key, value in constants.DAYS_LIST.items()], default='sunday')
regular_time = fields.StringField('Regular Timings')
ground_type = fields.SelectField(u'Ground Type', choices=[(key, value) for key, value in constants.GROUND_TYPE.items()], default='both')
surface_type = fields.StringField('Types of Surfaces')
tot_fields = fields.IntegerField(('No.of Courts'), [validators.Optional()])
ground_rules = fields.TextAreaField('Ground Rules')
tc_name = fields.StringField(('Club Name'), [validators.Optional(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
tc_open_days = fields.SelectField(u'Club Open Day(s)', choices=[(key, value) for key, value in constants.DAYS_LIST.items()], default='sunday')
age_limit = fields.StringField('Age Limits')
tc_participants = fields.IntegerField(('No.of Participants'), [validators.Optional()])
contact_tc = fields.FormField(BasicContact)
se_name = fields.StringField(('Event Name'), [validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
start_datetime = fields.DateField(('Start Date'), [validators.Optional()])
end_datetime = fields.DateField(('End Date'), [validators.Optional()])
contact_se = fields.FormField(BasicContact)
pass
def editUsersFormFactory(users):
class F(FlaskForm):
pass
for user in users:
editUserForm = editUserFormFactory(user)
form_name = f"user-{user.id}"
setattr(F, form_name, fields.FormField(editUserForm))
setattr(F, "new-user", fields.FormField(NewUserForm))
return F
class ChildEventForm(BaseForm):
name = fields.StringField(('Name'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
description = fields.TextAreaField('Description')
media = fields.FieldList(fields.FormField(MediaForm), min_entries=5)
parent_event_id = fields.HiddenField()
start_datetime = fields.DateTimeField('Start Date Time', [validators.Required()])
end_datetime = fields.DateTimeField('End Date Time', [validators.Required()])
contact_info = fields.FormField(ContactInfo)
custom_info = fields.FieldList(fields.FormField(CustomInfo), min_entries=2)
pass
def editContactsFormFactory(contacts):
class F(FlaskForm):
pass
for contact in contacts:
form_name = f"contact-{contact.id}"
editContactForm = editContactFormFactory(contact)
setattr(F, form_name, fields.FormField(editContactForm))
newContactForm = newContactFormFactory()
setattr(F, "new-contact", fields.FormField(newContactForm))
return F
class RuleForm(BaseForm):
name = fields.StringField('Rule name', [DataRequired(), Length(max=64)])
conditions = fields.FieldList(fields.FormField(ConditionForm),
min_entries=1)
actions = fields.FieldList(fields.FormField(ActionForm), min_entries=1)
def __init__(self, *args, **kwargs):
self.rule = rule = kwargs.pop('rule', None)
formdata = args[0] if args else None
super(RuleForm, self).__init__(*args, **kwargs)
if rule:
self.name.process(formdata, rule.name)
def validate_name(self, field):
if self.rule and (field.data == self.rule.name):
return
try:
Rule.query.filter_by(name=field.data,
meeting=g.meeting,
rule_type=g.rule_type).one()
raise ValidationError('Name must be unique')
except NoResultFound:
pass
def validate_actions(self, field):
condition_fields = set([i['field'] for i in self.conditions.data])
action_fields = set([i['field'] for i in self.actions.data])
if condition_fields & action_fields:
raise ValidationError('Action fields should be different '
'from condition fields')
if len(action_fields) != len(self.actions.data):
raise ValidationError('Actions fields should be different')
def save(self):
rule = self.rule or Rule(meeting=g.meeting)
rule.name = self.name.data
rule.rule_type = g.rule_type
# if edit, delete all conditions and actions for this rule and their
# corresponding values
if rule.id:
Condition.query.filter_by(rule=rule).delete()
Action.query.filter_by(rule=rule).delete()
for condition_form in self.conditions:
condition_form.save(rule)
for action_form in self.actions:
action_form.save(rule)
if not rule.id:
db.session.add(rule)
db.session.commit()
class ClassForm(FlaskForm):
name = fields.StringField(
'Name',
validators=[validators.InputRequired(),
validators.Length(min=3)])
description = fields.StringField('Description',
validators=[validators.InputRequired()],
widget=widgets.TextArea())
code = fields.StringField('Code')
course = fields.SelectField('Course',
validators=[validators.InputRequired()])
limited = fields.BooleanField('Limited Class', default=True)
limited_enrollment = fields.FormField(LimitedEnrollmentForm)
started_date = fields.DateField(
'Started Date',
format='%Y-%m-%d',
widget=widgets.TextInput()
)
ended_date = fields.DateField(
'Ended Data',
format='%Y-%m-%d',
widget=widgets.TextInput(),
)
# owner = fields.SelectMultipleField('Owner')
# contributors = fields.SelectMultipleField('Contributors')
tags = TagListField('Tags',
validators=[validators.InputRequired(),
validators.Length(min=3)])
class NewPubKeyStoreAndPayPayloadForm(ProtoForm):
pub_key_payload = fields.FormField(NewPublicKeyPayloadForm)
owner_public_key = fields.StringField(
validators=[validators.DataRequired()])
signature_by_owner = fields.StringField(
validators=[validators.DataRequired()])
def conv_EmbeddedDocument(self, model, field, kwargs):
kwargs = {
'validators': [],
'filters': [],
}
form_class = model_form(field.document_type_obj, field_args={})
return f.FormField(form_class, **kwargs)
def BulkTransactionFormFactory(active=True):
class BulkTransactionForm(flask_wtf.FlaskForm):
pass
if active:
users = models.User.query.filter_by(active=True)
else:
users = models.User.query.all()
for user in users:
class UserTransactionForm(flask_wtf.FlaskForm):
user_name = fields.HiddenField('Namn', default=user.full_name)
user_id = fields.HiddenField('ID', default=user.id)
value = html5_fields.DecimalField('Transaktionsvärde',
render_kw={
'step': .01,
'min': -10000,
'max': 10000
},
validators=[
validators.NumberRange(
min=-10000, max=10000),
validators.Optional()
])
text = fields.StringField('Meddelande')
transaction_form = fields.FormField(UserTransactionForm)
setattr(BulkTransactionForm, "user-{}".format(user.id),
transaction_form)
return BulkTransactionForm()
class BusinessForm(BaseForm):
name = fields.StringField(('Name'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
description = fields.TextAreaField('Description')
logo = fields.FileField('Logo')
contact_info = fields.FormField(ContactInfo)
pass
class PlaygroundForm(BaseForm):
name = fields.StringField(('Name'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
sport = fields.SelectField(u'Sport', choices=[(key, value) for key, value in constants.SPORTS_LIST.items()], default='others')
locality = fields.StringField(('Area/Locality'), [validators.Required(), validators.Length(max=NAME_FILED_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
city = fields.StringField(('City'), [validators.Required(), validators.Length(max=NAME_FILED_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
description = fields.TextAreaField('Description')
featured = fields.BooleanField('Featured')
media = fields.FieldList(fields.FormField(MediaForm), min_entries=1)
address = fields.FormField(Address)
contact_info = fields.FormField(ContactInfo)
locality_id = fields.HiddenField()
#custom_info = fields.FieldList(fields.FormField(CustomInfo), min_entries=2)
pass
class AddPageForm(Form):
date_added = fields.DateField('Publish On:',format="%m-%d-%Y",widget=DateWidget())
date_end = fields.DateField('Expire On:',format="%m-%d-%Y",validators=[validators.Optional()],widget=DateWidget())
name = fields.StringField('Page Name',validators=[validators.InputRequired()])
description = fields.TextAreaField('Description',validators=[validators.Optional()])
slug = fields.StringField('Page Slug',validators=[validators.InputRequired()])
short_url = fields.StringField('Url',validators=[validators.Optional()])
title = fields.StringField('Page Title',validators=[validators.InputRequired()])
add_to_nav = fields.BooleanField('Add to Navbar')
add_sidebar = fields.BooleanField('Add Sidebar')
visible = fields.SelectField(choices=((1,'Publish'),(0,'Draft')))
meta_title = fields.StringField('Meta Title',validators=[validators.InputRequired()])
content = CodeMirrorField('Content',language='xml',config={'lineNumbers':'true'})
template = fields.FormField(BaseTemplateForm,label="Template",separator='_')
blocks = fields.SelectMultipleField(label="blocks",choices=[('a','a'),('b','b'),('c','c')])
category = QuerySelectField('category')
tags = TagField('Tags')
use_base_template = fields.BooleanField('Use Base Template')
base_template = fields.SelectField(
'base template',validators=[
validators.InputRequired()
],choices=[
(x,x) for x in sorted(get_page_templates()) \
if not x.startswith('_') and not \
x.startswith('.') and x.endswith('.html')
]
)
submit = fields.SubmitField('Save')
class HomeInputForm(form.Form):
majors =fields.SelectMultipleField(label="majors", validators=[validators.DataRequired()])
specs =fields.SelectMultipleField(label="specs")
firstQuarter = fields.SelectField(label="start quarter for scheduling", default=(0,0))
quarterCreditDefault = fields.SelectField(label="default maximum credits per quarter" ,validators=[validators.DataRequired()],
choices=[(x,x) for x in range(30)], default=(16,16))
quarterCredits = fields.FieldList(fields.FormField(QuarterCreditForm),
label="maximum credits per quarter", validators=[validators.Optional()],
min_entries=1, max_entries=15)
next = fields.SubmitField('next')
def validate_on_submit(self):
"""
Checks if form has been submitted and if so runs validate. This is
a shortcut, equivalent to ``form.is_submitted() and form.validate()``
"""
return self.is_submitted() and self.validate()
def is_submitted(self):
"""
Checks if form has been submitted. The default case is if the HTTP
method is **POST**.
"""
return request and request.method == "POST"
class ReceiptForm(ModelForm):
class Meta:
model = Receipt
name = fields.StringField("Name", [va.length(min=1)])
amount = fields.DecimalField("Decimal", [va.NumberRange(min=0)])
tax = fields.DecimalField("Decimal", [va.NumberRange(min=0)])
receipt_items = fields.FieldList(fields.FormField(ReceiptItemForm))
def conv_EmbeddedDocument(self, model, field, kwargs):
kwargs = {
"validators": [],
"filters": [],
"default": field.default or field.document_type_obj,
}
form_class = model_form(field.document_type_obj, field_args={})
return f.FormField(form_class, **kwargs)
class CreateContactInfoForm(Form):
title = fields.StringField()
user_id = fields.HiddenField()
phone_number = TelField("Phone Number", validators=[validators.Optional()])
email = EmailField("Email Address",
validators=[validators.Optional(),
validators.Email()])
message = fields.TextAreaField()
address = fields.FormField(AddressForm)
def conv_EmbeddedDocument(self, model, field, kwargs):
kwargs = {
'validators': [],
'filters': [],
}
print dir(field.model_class)
form_class = model_form(field.model_class, field_args={})
return f.FormField(form_class, **kwargs)
class TardisForm(Form):
supernova = fields.FormField(SupernoveForm)
atom_data = fields.FormField(AtomForm)
plasma = fields.FormField(PlasmaForm)
structure_model = fields.FormField(StructureForm)
abundances_model = fields.FormField(AbundanceForm)
montecarlo = fields.FormField(MonteCarloForm)
spectrum = fields.FormField(SpectrumForm)
class TeamForm(BaseForm):
importfile = fields.FileField(('Excel/CSV'))
name = fields.StringField(('Team Name'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH, message=(
"Field cannot be longer than %(max)d characters."))])
sport = fields.SelectField(u'Sport', choices=[(key, value) for key, value in constants.SPORTS_LIST.items()], default='others')
logo = fields.FileField('Logo')
category = fields.SelectField(u'Category', choices=[(key, value) for key, value in constants.CATEGORY_DICT.items()], default='open')
new_player = fields.FieldList(fields.FormField(PlayerForm), min_entries=1)
#players = fields.FieldList(fields.FormField(MyForm))
pass
class NewPublicKeyPayloadForm(ProtoForm):
hashing_algorithm = fields.SelectField(
choices=NewPubKeyPayload.HashingAlgorithm.items())
entity_hash = fields.StringField(validators=[validators.DataRequired()])
entity_hash_signature = fields.StringField(
validators=[validators.DataRequired()])
valid_from = fields.IntegerField(validators=[validators.DataRequired()])
valid_to = fields.IntegerField(validators=[validators.DataRequired()])
rsa = fields.FormField(RSAConfigurationForm)
ecdsa = fields.FormField(ECDSAConfigurationForm)
ed25519 = fields.FormField(Ed25519ConfigurationForm)
def validate(self):
is_valid = super().validate()
pt_error_keys = ['rsa', 'ecdsa', 'ed25519']
if all((ek in self.errors for ek in pt_error_keys)):
msg = [
'At least one of RSAConfiguration, ECDSAConfiguration or '
'Ed25519Configuration must be set'
]
self._errors['configuration'] = msg
for cfg in pt_error_keys:
del self._errors[cfg]
is_valid = False
else:
for ek in pt_error_keys:
if ek not in self.errors:
cp_errs = pt_error_keys[:]
cp_errs.remove(ek)
for cfg in cp_errs:
del self._errors[cfg]
if not self._errors:
is_valid = True
break
return is_valid
class Event(topics.Topic):
started_date = fields.DateTimeField(
'Start Date',
format='%d/%m/%Y %H:%M',
validators=[validators.InputRequired()])
ended_date = fields.DateTimeField('End Date',
format='%d/%m/%Y %H:%M',
validators=[validators.InputRequired()])
venue = fields.StringField('Where')
all_day = fields.BooleanField()
repeat = fields.BooleanField()
repeat = fields.FormField(RepeatableEvent)
event_type = fields.SelectField('Event Type',
validators=[validators.InputRequired()],
choices=[(t, t.title())
for t in models.events.EVENT_TYPES
])
conference = fields.FormField(ConferenceEvent)
class EditFrontpageForm(FlaskForm):
frontpage_image = fields.FormField(UploadForm)
flash_sv = fields.StringField(
'Flash',
description=('Text i flashen. Kan innehålla html, som '
'<a href="https://example.com">en länk</a>.'))
flash_en = fields.StringField('Flash (engelska)')
flash_type = fields.SelectField('Flash-typ',
description='Vilken färg flashen har',
choices=[('success', 'Grön'),
('warning', 'Gul'),
('error', 'Röd'),
('info', 'Blå')])
class datasetEditorForm(FlaskForm):
columnSelections = f.FieldList(f.FormField(SelectForm))
finalText = f.TextAreaField(
'Edit your dataset to remove unwanted data', [
v.length(min=1000,
message=
'The final text cannot be shorter than 1,000 characters.')
],
render_kw={
'rows':
'20',
'cols':
'100',
'placeholder':
'Click \\"refresh dataset text\\"; to automatically fill out this field'
})
datasetRefresh = f.SubmitField('Refresh dataset text', render_kw=w3Button)
class OTRSubmissionForm(BJSubmissionForm):
introduction = fields.TextAreaField(
'General introduction/description', validators=[DataRequired()]
)
pictures = fields.FieldList(
fields.FormField(PictureForm),
min_entries=config.MAX_PICTURES,
max_entries=config.MAX_PICTURES,
validators=[Optional()]
)
verification_error = ("Something went wrong verifying this "
"email and username combination. If you haven't "
"commented at Balloon-Juice before, go comment in an "
"active thread, wait for it to get approved, and come "
"submit your pictures again. Alternatively, email your "
"pictures to [email protected]"
)
class RegistrationRequestForm(UniqueEmailForm):
first_name = fields.StringField(
_l('Förnamn'),
validators=[validators.InputRequired(),
validators.Length(max=50)],
)
last_name = fields.StringField(
_l('Efternamn'),
validators=[validators.InputRequired(),
validators.Length(max=50)],
)
phone = html5_fields.TelField(
_l('Telefon'),
description=_l("Ett telefonnummer. Landskod kan utelämnas för svenska"
" nummer, men behövs för utländska nummer."))
message = fields.TextAreaField(_l('Meddelande till QM'))
are_you_a_robot = fields.FormField(AreYouARobotFormFactory)
def get_field_dict(self, node=None, prefix=None):
field_dict = {}
node = node or self._field_tree
for field in node.fields:
op_field = self.get_operation_field(field)
val_field = self.get_value_field(field)
field_dict['%s%s' % (self.field_operation_prefix, field.name)] = op_field
field_dict['%s%s' % (self.field_value_prefix, field.name)] = val_field
for prefix, node in node.children.items():
child_fd = self.get_field_dict(node, prefix)
field_dict['%s%s' % (self.field_relation_prefix, prefix)] = fields.FormField(
self.get_form(child_fd),
separator=self.separator,
)
return field_dict
class BaseProductForm(Form):
product_id = fields.StringField(_name='id')
active = fields.BooleanField()
attributes = fields.FieldList(fields.StringField(),
min_entries=1,
max_entries=5)
caption = fields.StringField()
deactivate_on = fields.DateField()
description = fields.TextAreaField()
images = fields.MultipleFileField()
livemode = fields.BooleanField()
product_metadata = fields.TextAreaField(_name='metadata')
name = fields.StringField()
package_dimensions = fields.FormField(PackageDimensionsForm)
shippable = fields.BooleanField()
product_type = MyRadioField(choices=[('service',
'service'), ('good', 'good')])
url = fields.StringField()
def construct_form(meta):
subfs = OrderedDict()
for field in meta:
kind = field['kind']
name = field['name']
label = field['label']
required = field['required']
checkers = []
if required:
if kind == 'int':
checkers.append(validators.InputRequired('这个字段必填'))
else:
checkers.append(validators.Required('这个字段必填'))
else:
checkers.append(validators.Optional())
if kind == 'int':
f = html5.IntegerField(label,
description='输入' + label,
validators=checkers)
elif kind == 'bool':
f = fields.BooleanField(label,
description=label,
validators=[validators.Optional()])
elif kind == 'string':
f = fields.StringField(label,
description='输入' + label,
validators=checkers)
elif kind == 'url':
checkers.append(validators.URL())
f = html5.URLField(label,
description='输入' + label,
validators=checkers)
else:
raise NotImplementedError('%s kind not supported' % kind)
subfs[name] = f
subform_class = type(b'_Registry_Sub_Form', (WTForm, ), subfs)
value_field = fields.FieldList(fields.FormField(subform_class),
default=[{}])
form_class = type(b'_Registry_Form', (Form, ),
OrderedDict(value=value_field))
return form_class
