class QuestionForm(OrderFormMixin, ModelForm):
"""A dynamic Question form. Uses Question class fields as well as custom-ordered additional fields."""
def __init__(self, db_play, db_question=None):
super().__init__(
obj=db_question
) # 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
class Meta: # Supplies parameters to OrderFormMixin to arrange additional fields
model = Question
order_before = ["play"]
order_after = ["scenes", "characters", "submit"]
if db_question: # Used when an existing Question is used as the model object for the form
play = QuerySelectField(
"Play", query_factory=Play.query.all, default=db_question.play
) # Defaults to the existing Question's play
characters = QuerySelectMultipleField(
"Characters",
query_factory=Character.query.filter(
Character.play_id == db_play.id).order_by(
Character.id).all,
default=db_question.characters
) # Defaults to the existing Question's question
else:
play = QuerySelectField("Play",
query_factory=Play.query.all,
default=db_play)
characters = QuerySelectMultipleField(
"Characters",
query_factory=Character.query.filter(
Character.play_id == db_play.id).all,
default=db_question)
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 F(Form):
a = QuerySelectMultipleField(
get_label="name",
default=[first_test],
widget=LazySelect(),
query_factory=lambda: self.sess.query(self.Test),
)
class DestytojasForm(FlaskForm):
vardas = StringField('Vardas', [DataRequired()])
pavarde = StringField('Pavardė', [DataRequired()])
paskaitos = QuerySelectMultipleField(query_factory=app.Paskaita.query.all,
get_label="pavadinimas",
get_pk=lambda obj: str(obj))
submit = SubmitField('Įvesti')
class AddPageForm(FlaskForm):
title = StringField(f'Title', validators=[DataRequired(), Length(max=200)])
slug = StringField(f'Slug', validators=[DataRequired(), Length(max=200)])
template = SelectField(f'Template', choices=Page.TEMPLATE_CHOICES)
parent_id = SelectField('Parent', coerce=int)
cover = StringField('Cover Image', validators=[Length(max=500)])
banner = StringField('Banner Image', validators=[Length(max=500)])
summary = TextAreaField('Summary',
validators=[Length(max=300),
Optional()])
author_note = TextAreaField("Author's Note",
validators=[Length(max=5000),
Optional()],
render_kw={'rows': 4})
author_note_location = SelectField('Note Location',
coerce=str,
choices=Page.AUTHOR_NOTE_LOCATIONS)
sidebar = TextAreaField('Sidebar',
validators=[Length(max=5000),
Optional()])
body = TextAreaField(f'Body',
validators=[DataRequired(),
Length(max=10000000)])
notes = TextAreaField('Notes', validators=[Length(max=5000000)])
tags = QuerySelectMultipleField('Tags',
query_factory=all_tags,
allow_blank=True)
user_id = SelectField(f'Author', coerce=int, validators=[DataRequired()])
pub_date = DateField('Published Date', validators=[Optional()])
pub_time = TimeField('Published Date', validators=[Optional()])
published = BooleanField('Published?')
notify_subs = BooleanField('Notify Subscribers?')
notify_group = SelectField('Notify Group')
timezone = HiddenField('Timezone')
submit = SubmitField('Submit Post')
class PostForm(FlaskForm):
title = StringField(label='Title', validators=[InputRequired("Enter title.")])
feature = BooleanField(label='Feature')
description = TextAreaField(label='Description', validators=[InputRequired("Enter description"), Length(max=200)])
body = PageDownField(label='Body', validators=[Length(max=1000)])
# Use wtforms_sqlalchemy
tags = QuerySelectMultipleField(label='Tags' , query_factory=select_tag, allow_blank=True)
class PublicRecipeFilterForm(FlaskForm):
ingredient = QuerySelectField("obsahuje surovinu",
query_factory=public_ingredients,
allow_blank=True)
category = QuerySelectField("kategorie",
query_factory=categories,
allow_blank=True)
with_reaction = BooleanField("moje oblíbené")
dietary_labels = QuerySelectMultipleField("dietní omezení",
query_factory=dietary_labels)
difficulty_labels = QuerySelectMultipleField(
"obtížnost přípravy", query_factory=difficulty_labels)
labels = HiddenField()
submit = SubmitField("filtrovat")
class ReceitaForm(FlaskForm):
nome = StringField('Nome da Receita', validators=[DataRequired()])
autor = StringField('Autor da Receita', validators=[DataRequired()])
modo_preparo = TextAreaField('Modo de Preparo',
validators=[DataRequired()])
ingredientes = QuerySelectMultipleField(query_factory=ingredientes_query,
allow_blank=True)
publicar = SubmitField('Publicar Receita')
class OrderForm(FlaskForm):
client = QuerySelectField(query_factory=lambda: Client.query,
get_pk=lambda client: client.id,
validators=[InputRequired()])
products = QuerySelectMultipleField(
query_factory=lambda: Product.query.filter(Product.in_stock == True),
get_pk=lambda product: product.id,
validators=[InputRequired()])
class FilterLeads(FlaskForm):
txt_search = StringField()
lead_source = QuerySelectMultipleField(query_factory=lead_source_query, get_pk=lambda a: a.id,
get_label='source_name', allow_blank=False)
lead_status = QuerySelectMultipleField(query_factory=LeadStatus.lead_status_query, get_pk=lambda a: a.id,
get_label='status_name', allow_blank=False)
assignees = QuerySelectField(query_factory=User.user_list_query, get_pk=lambda a: a.id,
get_label=User.get_label, allow_blank=True, blank_text='[-- Select Owner --]')
advanced_admin = QuerySelectField(query_factory=filter_leads_adv_filters_admin_query,
get_pk=lambda a: a['id'],
get_label=lambda a: a['title'],
allow_blank=True, blank_text='[-- advanced filter --]')
advanced_user = QuerySelectField(query_factory=filter_leads_adv_filters_user_query,
get_pk=lambda a: a['id'],
get_label=lambda a: a['title'],
allow_blank=True, blank_text='[-- advanced filter --]')
submit = SubmitField('Filter Leads')
class PaskaitaForm(FlaskForm):
pavadinimas = StringField('Pavadinimas', [DataRequired()])
studentai = QuerySelectMultipleField(query_factory=app.Studentas.query.all,
get_label="vardas",
get_pk=lambda obj: str(obj))
destytojas = QuerySelectField(query_factory=destytojas_query,
allow_blank=True,
get_label="vardas_ir_pavarde",
get_pk=lambda obj: str(obj))
submit = SubmitField('Įvesti')
class EventForm(FlaskForm):
topic = StringField("Topic", validators=[DataRequired()])
date = DateField("Date", validators=[DataRequired()])
street = StringField("Street", validators=[DataRequired()])
city = StringField("City", validators=[DataRequired()])
state = StringField("State",
validators=[DataRequired(),
Length(min=2, max=2)])
zip = StringField("Zip", validators=[DataRequired()])
speakers = QuerySelectMultipleField("Speakers")
submit = SubmitField("Save")
class PostForm(Form):
short_title = StringField(
"Short Title",
validators=[Length(min=1, max=30, message="too long")],
render_kw={"placeholder": "max 30 characters"})
title = StringField("Title")
body = TextAreaField("Body")
category_id = QuerySelectField("Category",
query_factory=category_query,
allow_blank=True,
get_label="title",
get_pk=lambda x: x.id)
tags = QuerySelectMultipleField(
"Tags",
query_factory=tags_query,
allow_blank=True,
get_label="name",
get_pk=lambda x: x.id,
# _name="tags[]"
)
class F(Form):
a = QuerySelectMultipleField(get_label='name', widget=LazySelect())
class UserForm(FlaskForm):
username = StringField(_("Username"), validators=[
DataRequired(message=_("A valid username is required.")),
is_username])
email = StringField(_("Email address"), validators=[
DataRequired(message=_("A valid email address is required.")),
Email(message=_("Invalid email address."))])
password = PasswordField("Password", validators=[
DataRequired()])
birthday = DateField(_("Birthday"), format="%d %m %Y", validators=[
Optional()])
gender = StringField(_("Gender"), validators=[Optional()])
location = StringField(_("Location"), validators=[
Optional()])
website = StringField(_("Website"), validators=[
Optional(), URL()])
avatar = StringField(_("Avatar"), validators=[
Optional(), URL()])
signature = TextAreaField(_("Forum signature"), validators=[
Optional()])
notes = TextAreaField(_("Notes"), validators=[
Optional(), Length(min=0, max=5000)])
activated = BooleanField(_("Is active?"), validators=[
Optional()])
primary_group = QuerySelectField(
_("Primary group"),
query_factory=select_primary_group,
get_label="name")
secondary_groups = QuerySelectMultipleField(
_("Secondary groups"),
# TODO: Template rendering errors "NoneType is not callable"
# without this, figure out why.
query_factory=select_primary_group,
get_label="name")
submit = SubmitField(_("Save"))
def validate_username(self, field):
if hasattr(self, "user"):
user = User.query.filter(
db.and_(
User.username.like(field.data.lower()),
db.not_(User.id == self.user.id)
)
).first()
else:
user = User.query.filter(
User.username.like(field.data.lower())
).first()
if user:
raise ValidationError(_("This username is already taken."))
def validate_email(self, field):
if hasattr(self, "user"):
user = User.query.filter(
db.and_(
User.email.like(field.data.lower()),
db.not_(User.id == self.user.id)
)
).first()
else:
user = User.query.filter(
User.email.like(field.data.lower())
).first()
if user:
raise ValidationError(_("This email address is already taken."))
def validate_avatar(self, field):
if field.data is not None:
error, status = check_image(field.data)
if error is not None:
raise ValidationError(error)
return status
def save(self):
data = self.data
data.pop('submit', None)
data.pop('csrf_token', None)
user = User(**data)
return user.save()
class RecipeForm(FlaskForm):
name = StringField("název receptu",
[InputRequired("název musí být vyplněn")])
# description = StringField("Popis", widget=TextArea())
category = QuerySelectField("kategorie",
query_factory=categories,
allow_blank=True)
portion_count = IntegerField(
"počet porcí",
[NumberRange(message="musí být alespoň jedna porce", min=1)])
dietary_labels = QuerySelectMultipleField(
"dietní omezení",
query_factory=dietary_labels,
widget=ExtendedSelectWidget(multiple=True),
)
difficulty_label = QuerySelectField(
"obtížnost přípravy",
query_factory=difficulty_labels,
allow_blank=True,
widget=ExtendedSelectWidget(),
)
labels = HiddenField()
submit = SubmitField("přidat recept")
def __init__(self, formdata=None, obj=None, **kwargs):
super().__init__(formdata=formdata, obj=obj, **kwargs)
self.set_labels()
self.set_difficulty_label()
self.set_dietary_labels()
def set_dietary_labels(self):
from app.models.labels import Label
option_attr = {
f"dietary_labels-{i}": {
"data-color": label.color
}
for i, label in enumerate(Label.load_dietary())
}
self.dietary_labels.option_attr = option_attr
def set_difficulty_label(self):
from app.models.labels import Label
option_attr = {
f"difficulty_label-{i+1}": {
"data-color": label.color
}
for i, label in enumerate(Label.load_difficulty())
}
self.difficulty_label.option_attr = option_attr
def set_labels(self):
from app.models.label_categories import LabelCategory
self.labels.data = []
for category in LabelCategory.load_all():
if category.allow_multiple:
attr_name = f"{category.name}_labels"
else:
attr_name = f"{category.name}_label"
if field := getattr(self, attr_name, None):
specific_labels = field.data
if not specific_labels:
continue
elif type(specific_labels) == list:
self.labels.data.extend(specific_labels)
else:
self.labels.data.append(specific_labels)
class CustomerPaymentForm(InvoicePaymentForm):
invoices = QuerySelectMultipleField('Documentos a cancelar',
option_widget=widgets.CheckboxInput(),
get_label=lambda i: i.fulldesc)
class ForumForm(FlaskForm):
title = StringField(
_("Forum title"),
validators=[DataRequired(message=_("Please enter a forum title."))]
)
description = TextAreaField(
_("Description"),
validators=[Optional()],
description=_("You can format your description with Markdown.")
)
position = IntegerField(
_("Position"),
default=1,
validators=[DataRequired(message=_("Please enter a position for the"
"forum."))]
)
category = QuerySelectField(
_("Category"),
query_factory=selectable_categories,
allow_blank=False,
get_label="title",
description=_("The category that contains this forum.")
)
external = StringField(
_("External link"),
validators=[Optional(), URL()],
description=_("A link to a website i.e. 'http://flaskbb.org'.")
)
moderators = StringField(
_("Moderators"),
description=_("Comma separated usernames. Leave it blank if you do "
"not want to set any moderators.")
)
show_moderators = BooleanField(
_("Show moderators"),
description=_("Do you want to show the moderators on the index page?")
)
locked = BooleanField(
_("Locked?"),
description=_("Disable new posts and topics in this forum.")
)
groups = QuerySelectMultipleField(
_("Group access"),
query_factory=selectable_groups,
get_label="name",
description=_("Select the groups that can access this forum.")
)
submit = SubmitField(_("Save"))
def validate_external(self, field):
if hasattr(self, "forum"):
if self.forum.topics.count() > 0:
raise ValidationError(_("You cannot convert a forum that "
"contains topics into an "
"external link."))
def validate_show_moderators(self, field):
if field.data and not self.moderators.data:
raise ValidationError(_("You also need to specify some "
"moderators."))
def validate_moderators(self, field):
approved_moderators = []
if field.data:
moderators = [mod.strip() for mod in field.data.split(',')]
users = User.query.filter(User.username.in_(moderators))
for user in users:
if not Permission(IsAtleastModerator, identity=user):
raise ValidationError(
_("%(user)s is not in a moderators group.",
user=user.username)
)
else:
approved_moderators.append(user)
field.data = approved_moderators
def save(self):
data = self.data
# delete submit and csrf_token from data
data.pop('submit', None)
data.pop('csrf_token', None)
forum = Forum(**data)
return forum.save()
