class EditTicketForm(FlaskForm):
assigned_employee = QuerySelectField(
"Assigned Person",
query_factory=lambda: db.session.query(User).order_by("last_name"),
get_pk=lambda a: a.id,
get_label=lambda a: str(a.first_name) + " " + str(a.last_name),
allow_blank=True,
)
reclamation = QuerySelectField(
"Reclamation",
query_factory=lambda: db.session.query(Reclamation).order_by("due_date"
),
get_pk=lambda a: a.id,
get_label=lambda a: str(a.id) + " " + str(a.reclamation_customer.name)
+ " " + str(a.reclamation_part_sn_id.part_sn),
allow_blank=True,
)
due_date = DateField("Due Date", format="%Y-%m-%d")
description_ticket = TextAreaField("Description of the ticket")
finished_date = DateTimeField(
"Finished Date",
format="%Y-%m-%d %H:%M",
render_kw={"readonly": True},
validators=[validators.Optional()],
)
class AppConfigForm(FlaskForm):
default_currency = QuerySelectField('Default Currency',
query_factory=Currency.get_list_query,
get_pk=lambda a: a.id,
get_label='name')
default_timezone = QuerySelectField('Default TimeZone',
query_factory=TimeZone.get_list_query,
get_pk=lambda a: a.name,
get_label='name')
date_format = QuerySelectField('Date Format',
query_factory=date_format_query,
get_pk=lambda a: a['key'],
get_label=lambda a: a['val'])
address_format = TextAreaField('Default Address Format',
default=DEFAULT_ADDRESS)
smtp_server = StringField('SMTP Mail Server')
smtp_port = StringField('SMTP Port')
smtp_encryption = QuerySelectField('E-MAIL Encryption',
query_factory=email_enc_query,
get_pk=lambda a: a['key'],
get_label=lambda a: a['val'])
smtp_charset = StringField('SMTP Charset', default='utf-8')
sender_name = StringField('Sender Name')
sender_email = StringField('Sender Email')
submit = SubmitField('Save')
class NewEmployeeForm(FlaskForm):
firstname = StringField('', validators=[DataRequired()])
lastname = StringField('', validators=[DataRequired()])
dob = DateField('', validators=[DataRequired()])
doj = DateField('', validators=[DataRequired()])
address = StringField('', validators=[DataRequired()])
city = StringField('', validators=[DataRequired()])
state = StringField('', validators=[DataRequired()])
phone = StringField('', validators=[DataRequired()])
nin = StringField('', validators=[DataRequired()])
id_card = FileField('', validators=[FileAllowed(['jpg','png', 'jpeg','JPG','JPEG','PNG'])])
email = StringField('', validators=[DataRequired()])
department = QuerySelectField(query_factory=department_query, allow_blank=False, get_label='name')
grade = QuerySelectField(query_factory=grade_query, allow_blank=False, get_label='name')
def __init__(self, *args, **kwargs):
kwargs['csrf_enabled'] = False
super(NewEmployeeForm, self).__init__(*args, **kwargs)
def validate_nin(self, nin):
nin_id = Employee.query.filter_by(nin=nin.data).first()
if nin_id:
raise ValidationError('Employee already exists!')
def validate_email(self, email):
user_email = Employee.query.filter_by(email=email.data).first()
if user_email:
raise ValidationError('Employee already exists!')
class OtherPermissionsForm(FlaskForm):
module = QuerySelectField(
"action",
query_factory=lambda: DB.session.query(TModules).order_by(TModules.module_label).all(),
get_pk=lambda mod: str(mod.id_module),
get_label=lambda mod: mod.module_label,
)
action = QuerySelectField(
"action",
query_factory=lambda: DB.session.query(TActions).all(),
get_pk=lambda act: str(act.id_action),
get_label=lambda act: act.description_action,
)
filter = SelectField("filtre",)
submit = SubmitField("Valider")
def __init__(self, id_filter_type, *args, **kwargs):
super(OtherPermissionsForm, self).__init__(*args, **kwargs)
# id_filter_type = args[0]
self.filter.choices = [
(str(filt.id_filter), filt.label_filter)
for filt in DB.session.query(TFilters)
.filter(TFilters.id_filter_type == id_filter_type)
.all()
]
class EditReclamationForm(FlaskForm):
customer = QuerySelectField(
"Customer",
query_factory=lambda: db.session.query(Customer).order_by("name"),
get_pk=lambda a: a.id,
get_label=lambda a: a.name,
allow_blank=True,
)
informed_date = DateField("Informed Date", format="%Y-%m-%d")
due_date = DateField("Due Date", format="%Y-%m-%d")
part_model = QuerySelectField(
"Part Model",
query_factory=lambda: db.session.query(PartNo).order_by("model"),
get_pk=lambda a: a.id,
get_label=lambda a: a.model,
allow_blank=True,
)
part_sn = StringField("Serial Number")
part_prod_date = DateField("Part Production Date", format="%Y-%m-%d")
description = TextAreaField("Description of the issue")
finished_date = DateTimeField(
"Finished Date",
format="%Y-%m-%d %H:%M",
validators=[validators.Optional()],
render_kw={"readonly": True},
)
submit = SubmitField("Edit the claim")
class F(Form):
a = QuerySelectField(get_label=(lambda model: model.name),
query_factory=lambda: sess.query(self.Test),
widget=LazySelect())
b = QuerySelectField(allow_blank=True,
query_factory=lambda: sess.query(self.PKTest),
widget=LazySelect())
class FilmForm(OrderFormMixin, ModelForm):
"""A dynamic Film form. Uses Film class fields as well as custom-ordered additional fields."""
def __init__(self, db_film=None):
super().__init__(
obj=db_film
) # The parent FlaskWTForms-Alchemy ModelForm class accepts an existing database object as a form model
class Meta: # Supplies parameters to OrderFormMixin to arrange additional fields
model = Film
order_before = ["delete"]
order_after = ["submit"]
if db_film: # Used when an existing Film is used as the model object for the form
play = QuerySelectField(
"Play", query_factory=Play.query.all,
default=db_film.play) # Defaults to the existing Film's play
else:
play = QuerySelectField("Play",
query_factory=Play.query.all,
default=db_film.play)
delete = BooleanField(label="Delete record?")
submit = SubmitField("Submit")
class ConvertLead(FlaskForm):
title = StringField('Deal Title', validators=[DataRequired('Deal title is mandatory')])
use_account_information = BooleanField('Use Account Information', default=True)
account_name = StringField('Account Name')
account_email = StringField('Account Email')
accounts = QuerySelectField('Account', query_factory=Account.account_list_query, get_pk=lambda a: a.id,
get_label=Account.get_label, blank_text='Select An Account', allow_blank=True)
use_contact_information = BooleanField('Use Contact Information', default=False)
contact_first_name = StringField('Contact First Name')
contact_last_name = StringField('Contact Last Name')
contact_email = StringField('Contact Email',
validators=[Optional(), Email(message='Invalid email address!')])
contact_phone = StringField('Contact Phone')
contacts = QuerySelectField('Contact', query_factory=Contact.contact_list_query, get_pk=lambda a: a.id,
get_label=Contact.get_label, blank_text='Select A Contact', allow_blank=True)
create_deal = BooleanField('Create Deal', default=True)
expected_close_price = FloatField('Expected Close Price',
validators=[DataRequired('Expected Close Price is mandatory')])
expected_close_date = DateField('Expected Close Date', format='%Y-%m-%d',
validators=[Optional()])
deal_stages = QuerySelectField('Deal Stage', query_factory=DealStage.deal_stage_list_query, get_pk=lambda a: a.id,
get_label=DealStage.get_label, allow_blank=False,
validators=[DataRequired(message='Please select deal stage')])
assignees = QuerySelectField('Assign To', query_factory=User.user_list_query, get_pk=lambda a: a.id,
get_label=User.get_label, default=User.get_current_user)
submit = SubmitField('Covert Lead')
class CurrencyTz(FlaskForm):
currency = QuerySelectField('Default Currency', query_factory=Currency.get_list_query, get_pk=lambda a: a.id,
get_label='name',
validators=[DataRequired(message='Please select default currency')])
time_zone = QuerySelectField('Your Time Zone', query_factory=TimeZone.get_list_query, get_pk=lambda a: a.id,
get_label='name',
validators=[DataRequired(message='Please select your timezone')])
submit = SubmitField('Next: Finish Installation')
class GenerateReportForm(FlaskForm): grade = QuerySelectField(query_factory=grade_query, allow_blank=True, get_label='name') salary = QuerySelectField(query_factory=grade_query, allow_blank=True, get_label='salary') department = QuerySelectField(query_factory=department_query, allow_blank=True, get_label='name') def __init__(self, *args, **kwargs): kwargs['csrf_enabled'] = False super(GenerateReportForm, self).__init__(*args, **kwargs)
class AddGameForm(FlaskForm):
first_team = QuerySelectField(query_factory=choice_query,
allow_blank=True,
get_label='name')
second_team = QuerySelectField(query_factory=choice_query,
allow_blank=True,
get_label='name')
scheduled_date = DateField('date', format='%Y-%m-%d')
class TeamCaptainForm(FlaskForm):
team_captain_one = QuerySelectField('Teamcaptain',
allow_blank=True,
blank_text='No teamcaptain')
team_captain_two = QuerySelectField('Teamcaptain',
allow_blank=True,
blank_text='No teamcaptain')
submit = SubmitField('Set teamcaptain')
class AbstractJudgmentFormBase(IndicoForm):
"""Form base class for abstract judgment operations."""
_order = ('judgment', 'accepted_track', 'accepted_contrib_type', 'session', 'duplicate_of', 'merged_into',
'merge_persons', 'judgment_comment', 'send_notifications')
accepted_track = QuerySelectField(_('Track'), [HiddenUnless('judgment', AbstractAction.accept)],
get_label=lambda obj: obj.title_with_group,
allow_blank=True, blank_text=_('Choose a track...'),
description=_('The abstract will be accepted in this track'))
accepted_contrib_type = QuerySelectField(_('Contribution type'), [HiddenUnless('judgment', AbstractAction.accept)],
get_label=lambda x: x.name.title(), allow_blank=True,
blank_text=_('You may choose a contribution type...'),
description=_('The abstract will be converted '
'into a contribution of this type'))
session = QuerySelectField(_('Session'), [HiddenUnless('judgment', AbstractAction.accept)],
get_label='title', allow_blank=True, blank_text=_('You may choose a session...'),
description=_('The generated contribution will be allocated in this session'))
duplicate_of = AbstractField(_('Duplicate of'),
[HiddenUnless('judgment', AbstractAction.mark_as_duplicate), DataRequired()],
description=_('The current abstract will be marked as duplicate of the selected one'),
ajax_endpoint='abstracts.other_abstracts')
merged_into = AbstractField(_('Merge into'), [HiddenUnless('judgment', AbstractAction.merge), DataRequired()],
description=_('The current abstract will be merged into the selected one'),
ajax_endpoint='abstracts.other_abstracts')
merge_persons = BooleanField(_('Merge persons'), [HiddenUnless('judgment', AbstractAction.merge)],
description=_('Authors and speakers of the current abstract will be added to the '
'selected one'))
judgment_comment = TextAreaField(_('Comment'), render_kw={'placeholder': _('Leave a comment for the submitter...'),
'class': 'grow'})
# TODO: show only if notifications apply?
send_notifications = BooleanField(_('Send notifications to submitter'), default=True)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.session.query = Session.query.with_parent(self.event).order_by(Session.title)
if not self.session.query.count():
del self.session
self.accepted_track.query = Track.query.with_parent(self.event).order_by(Track.position)
if not self.accepted_track.query.count():
del self.accepted_track
self.accepted_contrib_type.query = (ContributionType.query
.with_parent(self.event)
.order_by(ContributionType.name))
if not self.accepted_contrib_type.query.count():
del self.accepted_contrib_type
@property
def split_data(self):
abstract_data = self.data
judgment_data = {
'judgment': abstract_data.pop('judgment'),
'send_notifications': abstract_data.pop('send_notifications'),
'contrib_session': abstract_data.pop('session', None),
'merge_persons': abstract_data.pop('merge_persons', None)
}
return judgment_data, abstract_data
class EmployeeAssignForm(FlaskForm):
"""
Form for admin to assign departments and roles to employees
"""
department = QuerySelectField(query_factory=lambda: Department.query.all(),
get_label="name")
role = QuerySelectField(query_factory=lambda: Role.query.all(),
get_label="name")
submit = SubmitField('Submit')
class AddGradesForm(FlaskForm):
course_id = 0
student_id = 0
value = IntegerField("Grade",
validators=[InputRequired(),
NumberRange(0, 100)])
student = QuerySelectField(get_pk=get_pk)
assignment = QuerySelectField(get_pk=get_pk)
submit_grade = SubmitField("Add Grade")
class InterpretationForm(OrderFormMixin, ModelForm):
"""A dynamic Interpretation form. Uses Interpretation class fields as well as custom-ordered additional fields."""
def __init__(self, db_play, db_question=None, db_object=None):
super().__init__(
obj=db_object
) # The parent FlaskWTForms-Alchemy ModelForm class accepts an existing database object as a form model
self.db_play = db_play
self.db_question = db_question
self.db_interpretation = db_interpretation
class Meta: # Supplies parameters to OrderFormMixin to arrange additional fields
model = Interpretation
order_before = ["delete", "play", "question", "film"]
order_after = ["scenes", "submit"]
if db_interpretation: # Used when an existing Interpretation is used as the model object for the form
play = QuerySelectField(
"Play",
query_factory=Play.query.all,
default=db_interpretation.play
) # Defaults to the existing Interpretation's play
question = QuerySelectField(
"Question",
query_factory=Question.query.filter(
Question.play_id == db_play.id).all,
default=db_interpretation.question
) # Defaults to the existing Interpretation's question
else:
play = QuerySelectField("Play",
query_factory=Play.query.all,
default=db_play)
question = QuerySelectField(
"Question",
query_factory=Question.query.filter(
Question.play_id == db_play.id).all,
default=db_question)
delete = BooleanField(label="Delete record?")
film = QuerySelectField(
"Related Film",
query_factory=Film.query.filter(Film.play_id == db_play.id).all)
scenes = QuerySelectMultipleField(
"Related Scenes",
query_factory=Scene.query.filter(
Scene.play_id == db_play.id).order_by(Scene.act,
Scene.scene).all)
image = FileField("Image",
validators=[
FileAllowed(["jpg", "jpeg", "png", "bmp", "gif"],
"Images files only.")
],
render_kw={"class": "form-control"})
image_url = StringField("Image URL")
submit = SubmitField("Submit")
class CopyForm(FlaskForm):
signature_mark = StringField('Singature mark')
collection = QuerySelectField(query_factory=all_collections,
allow_blank=True)
room = QuerySelectField(query_factory=all_rooms, allow_blank=True)
shelf = QuerySelectField(query_factory=all_shelves, allow_blank=True)
section = StringField('Section')
remarques = StringField('Remarques')
on_shelf = BooleanField('On shelf')
submit = SubmitField('Submit')
class AddsForm(FlaskForm):
wazon = QuerySelectField(query_factory=wazon_query, allow_blank=True, get_label='name')
info1 = TextAreaField('Info')
podstawa = QuerySelectField(query_factory=podst_query, allow_blank=True, get_label='name')
info2 = TextAreaField('Info')
lampion = QuerySelectField(query_factory=lampion_query, allow_blank=True, get_label='name')
info3 = TextAreaField('Info')
photo = QuerySelectField(query_factory=photo_query, allow_blank=True, get_label='name')
info4 = TextAreaField('Info')
cross = QuerySelectField(query_factory=cross_query, allow_blank=True, get_label='name')
info5 = TextAreaField('Info')
class ProductForm(FlaskForm):
kind = StringField('Kind', validators=[DataRequired()])
finish = StringField('Finish', validators=[DataRequired()])
parapet = StringField('Parapet', validators=[DataRequired()])
mat1 = QuerySelectField(query_factory=mat_query, allow_blank=True, get_label='name')
cokoly = StringField('Cokoly', validators=[DataRequired()])
mat2 = QuerySelectField(query_factory=mat_query, allow_blank=True, get_label='name')
plyta = StringField('Plyta', validators=[DataRequired()])
thick = StringField('Thick', validators=[DataRequired()])
mat3 = QuerySelectField(query_factory=mat_query, allow_blank=True, get_label='name')
info11 = TextAreaField('Info')
class CommercialForm(FlaskForm):
unit = StringField('Name of the Unit',
validators=[DataRequired(),
Length(0, 64)],
render_kw={'placeholder': 'Enter name of the Unit'})
constitution = QuerySelectField('Constitution Type',
query_factory=constitution_query,
get_pk=get_pk,
allow_blank=False,
get_label='constitution_type')
activity = QuerySelectField('Class of Activity',
query_factory=activity_query,
get_pk=get_pk,
allow_blank=False,
get_label='class_of_activity')
pan = StringField('PAN No.',
validators=[DataRequired(),
Length(0, 10)],
render_kw={'placeholder': 'Enter your PAN Number'})
address = StringField('Registered Office Address',
validators=[DataRequired(),
Length(0, 50)],
render_kw={'placeholder': 'Enter your address'})
state = QuerySelectField('State',
query_factory=state_query,
get_pk=get_pk,
allow_blank=False,
get_label='state')
city = StringField('City',
validators=[DataRequired(),
Length(0, 50)],
render_kw={'placeholder': 'Enter your city'})
pin = IntegerField('Pin code',
validators=[DataRequired()],
render_kw={'placeholder': 'Enter pin code'})
enquiry_purpose = QuerySelectField('Enquiry_purpose',
query_factory=enquiry_purpose_query,
get_pk=get_pk,
allow_blank=False,
get_label='enquiry_purpose')
ref_no = StringField(
'Member Reference No.',
validators=[DataRequired(), Length(0, 10)],
render_kw={'placeholder': 'Enter Member Reference No.'})
loan = IntegerField('Loan amount',
validators=[DataRequired()],
render_kw={'placeholder': 'Enter loan amount'})
enquiry_type = QuerySelectField('Enquiry_type',
query_factory=enquiry_type_query,
get_pk=get_pk,
allow_blank=False,
get_label='enquiry_type')
submit = SubmitField('Submit')
class FunctionForm(FlaskForm):
number = StringField('Number', validators=[DataRequired()])
name = StringField('Function Name', validators=[DataRequired()])
rating = IntegerField('rating', validators=[DataRequired()])
motor = StringField('Motor')
location = QuerySelectField(query_factory=location_query,
allow_blank=False,
get_label='location')
starter = QuerySelectField(query_factory=starter_query,
allow_blank=False,
get_label='name')
submit = SubmitField('Submit')
class AddSongForm(FlaskForm):
title = StringField(
'Song name',
validators=[
validators.DataRequired(message='Song name required'),
validators.Regexp(
'^[a-zA-Z0-9 \']*$',
message="Must contain only letters numbers or underscore")
])
artists = QuerySelectField(query_factory=all_artists, get_label='name')
albums = QuerySelectField(query_factory=all_albums, get_label='name')
file = FileField('MP3 file', validators=[FileRequired()])
class CreateCharacterForm(FlaskForm):
"""
Форма создания персонажа
"""
name = wtforms.StringField(
'Имя персонажа',
validators=[validators.Required(message=('Это обязательное поле'))],
render_kw={'placeholder': 'Имя персонажа'})
gender = QuerySelectField(query_factory=gender_query)
race = QuerySelectField(query_factory=race_query)
profession = QuerySelectField(query_factory=profession_query)
submit = wtforms.SubmitField('Создать')
class SensorCreateForm(Form):
# uuid = StringField('uuid', validators=[InputRequired()])
uuid = SelectField('UUID')
type = SelectField('Type', choices=[('door', 'door'), ('motion', 'motion')], validators=[InputRequired()])
facility = QuerySelectField(query_factory=facility_query, allow_blank=False, get_label='fullname')
location = SelectField('location', choices=[('bedroom', 'bedroom'), ('toilet', 'toilet')],
validators=[InputRequired()])
description = StringField('Description')
resident = QuerySelectField(query_factory=resident_query, allow_blank=False, get_label='name')
# juvo_target = IntegerField('juvo target', validators=[InputRequired()])
# facility_abrv = StringField('facility abbreviation', validators=[InputRequired()])
submit = SubmitField('Submit')
class RegisterProduct(FlaskForm):
title = StringField('Title', validators=[Length(2, 40), DataRequired()])
description = TextAreaField('Description', validators=[DataRequired()])
short_description = StringField(
'Short Description', validators=[Length(max=100),
DataRequired()])
image = FileField(label='Image', validators=[FileRequired()])
price = IntegerField('Price')
is_published = BooleanField('Is active')
city_id = QuerySelectField('City', query_factory=city_choice)
type_id = QuerySelectField('Type', query_factory=type_choice)
status_id = QuerySelectField('Status', query_factory=status_choice)
class MatchScoutingForm(Form):
competition = QuerySelectField(
query_factory=lambda: Competition.query.all(), get_label='Name')
team = QuerySelectField(query_factory=lambda: Team.query.all(),
get_label='Number')
scout = QuerySelectField(query_factory=lambda: Users.query.filter(
Users.username != 'admin').all(),
get_label='username')
match = IntegerField(
'Match Number?',
[validators.DataRequired('Please enter the match number')],
default=1)
move = BooleanField('Did the robot move?', default=False)
a_climbers = BooleanField('Deliver climbers?', default=False)
beacon = BooleanField('Push Beacon?', default=False)
a_park = SelectField('Highest Parking Level?',
choices=[(0, 'Cannot Park'), (1, 'Floor/Partial Low'),
(2, 'Low Zone'), (3, 'Mid Zone'),
(4, 'High Zone')],
coerce=int)
t_climbers = BooleanField('Deliver climbers?', default=False)
score = BooleanField('Did the robot score?', default=False)
cycles = SelectField('How many scoring cycles?',
choices=[(0, '0'), (1, '1'), (2, '2'), (3, '3'),
(4, '4'), (5, '5'), (6, '6')],
coerce=int)
scorelow = BooleanField('Score in low zone?', default=False)
scoremid = BooleanField('Score in mid zone?', default=False)
scorehigh = BooleanField('Score in high zone?', default=False)
lowclimber = BooleanField('Release low climber?', default=False)
midclimber = BooleanField('Release mid climber?', default=False)
highclimber = BooleanField('Release high climber?', default=False)
t_park = SelectField('Highest Parking Level?',
choices=[(0, 'Cannot Park'), (1, 'Floor/Partial Low'),
(2, 'Low Zone'), (3, 'Mid Zone'),
(4, 'High Zone')],
coerce=int)
hang = BooleanField('Did the robot hang?', default=False)
allclear = BooleanField('Did the robot trigger the all clear?',
default=False)
comments = TextAreaField('General Comments')
submit = SubmitField('Add Report')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
else:
return True
class ConsumerForm(FlaskForm):
loan = IntegerField('Loan amount',
validators=[DataRequired()],
render_kw={'placeholder': 'Enter loan amount'})
purpose = QuerySelectField('Purpose',
query_factory=purpose_query,
get_pk=get_pk,
allow_blank=False,
get_label='purpose')
name = StringField('Name',
validators=[DataRequired(),
Length(0, 64)],
render_kw={'placeholder': 'Enter your name'})
gender = RadioField('Gender',
choices=[('male', 'Male'), ('female', 'Female'),
('others', 'Others')],
default='male')
dob = DateField('Date of birth',
validators=[DataRequired()],
format='%Y-%m-%d')
pan = StringField('PAN No.',
validators=[DataRequired()],
render_kw={'placeholder': 'Enter your PAN Number'})
aadhaar = IntegerField(
'Aadhaar No.',
render_kw={'placeholder': 'Enter your Aadhaar Number if any'})
voter_id = StringField(
'Voter Id.', render_kw={'placeholder': 'Enter your Voter ID if any'})
passport = StringField(
'Paassport',
render_kw={'placeholder': 'Enter your Passport Number if any'})
driving_lic = StringField(
'Driving License',
render_kw={'placeholder': 'Enter your Driving License Number if any'})
address = StringField('Address',
validators=[DataRequired(),
Length(0, 50)],
render_kw={'placeholder': 'Enter your address'})
state = QuerySelectField('State',
query_factory=state_query,
get_pk=get_pk,
allow_blank=False,
get_label='state')
pin = IntegerField('Pin code',
validators=[DataRequired()],
render_kw={'placeholder': 'Enter pin code'})
address_category = QuerySelectField('Address Category',
query_factory=address_category_query,
get_pk=get_pk,
allow_blank=False,
get_label='address_category')
submit = SubmitField('Submit')
class DancingInfoForm(FlaskForm):
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not g.sc.breitensport_obliged_blind_date:
self.latin_blind_date.data = str(False)
self.ballroom_blind_date.data = str(False)
ballroom_level = SelectField('Level', validators=[Level()])
ballroom_role = SelectField('Role',
validators=[Role('ballroom_level')],
choices=[(k, v) for k, v in ROLES.items()])
ballroom_blind_date = SelectField('Mandatory blind dating',
validators=[Role('ballroom_level')],
choices=[(k, v)
for k, v in BLIND_DATE.items()])
ballroom_partner = QuerySelectField(
validators=[Role('ballroom_level'), Level()],
allow_blank=True,
blank_text=PARTNER_TEXT)
latin_level = SelectField('Level', validators=[Level()])
latin_role = SelectField('Role',
validators=[Role('latin_level')],
choices=[(k, v) for k, v in ROLES.items()])
latin_blind_date = SelectField('Mandatory blind dating',
validators=[Role('latin_level')],
choices=[(k, v)
for k, v in BLIND_DATE.items()])
latin_partner = QuerySelectField(validators=[Role('latin_level'),
Level()],
allow_blank=True,
blank_text=PARTNER_TEXT)
def custom_validate(self):
if self.ballroom_level.data == BEGINNERS:
self.ballroom_blind_date.data = str(False)
if self.ballroom_level.data == CLOSED or self.ballroom_level.data == OPEN_CLASS:
self.ballroom_blind_date.data = str(True)
if self.latin_level.data == BEGINNERS:
self.latin_blind_date.data = str(False)
if self.latin_level.data == CLOSED or self.latin_level.data == OPEN_CLASS:
self.latin_blind_date.data = str(True)
if self.ballroom_level.data == NO:
self.ballroom_role.data = NO
self.ballroom_blind_date.data = str(False)
self.ballroom_partner.data = None
if self.latin_level.data == NO:
self.latin_role.data = NO
self.latin_blind_date.data = str(False)
self.latin_partner.data = None
class ChoiceForm(FlaskForm):
stream = QuerySelectField(query_factory=Details_query,
allow_blank=True,
get_label='Name')
course = QuerySelectField(query_factory=Details_query,
allow_blank=True,
get_label='Course')
locality = QuerySelectField(query_factory=Details_query,
allow_blank=True,
get_label='Locality')
exam = QuerySelectField(query_factory=Details_query,
allow_blank=True,
get_label='Exam')
class ProductForm(FlaskForm):
name = StringField(validators=[InputRequired()])
manufacturer = QuerySelectField(
query_factory=lambda: Manufacturer.query,
get_pk=lambda manufacturer: manufacturer.id,
validators=[InputRequired()])
category = QuerySelectField(query_factory=lambda: Category.query,
get_pk=lambda category: category.id,
validators=[InputRequired()])
home_page = URLField(validators=[URL(), Optional()])
price = IntegerField(validators=[InputRequired(), NumberRange(min=1)])
