class MessageForm(Form):
digest = TextField(
"Pyzor digest*",
validators=[length(40, 40, "Invalid Digest"),
required()])
message = FileField('Raw message*')
name = TextField('Name')
email = EmailField('Email')
comment = TextAreaField('Other details')
recaptcha = RecaptchaField()
submit = SubmitField()
def __init___(self, *args, **kwargs):
super(MessageForm, self).__init__(*args, **kwargs)
self.msg = None
self.raw_message = None
self.logger = app.logger
def validate(self):
if not Form.validate(self):
return False
self.raw_message = flask.request.files["message"].stream.read()
try:
digest = pyzor.digest.DataDigester(
email.message_from_string(self.raw_message)).value
if digest != self.digest.data:
self.add_error("digest", "Digest does not match message.")
return False
client = pyzor.client.Client(timeout=20)
try:
response = client.check(digest)
except pyzor.TimeoutError as e:
self.add_error("message", "Temporary error please try again.")
self.logger.warn("Timeout: %s", e)
return False
except pyzor.CommError as e:
self.add_error("message", "Temporary error please try again.")
self.logger.warn("Error: %s", e)
return False
if not response.is_ok():
self.add_error("message", "Temporary error please try again.")
self.logger.warn("Invalid response from server: %s", response)
return False
if int(response["Count"]) == 0:
self.add_error("message", "Message not reported as spam.")
return False
if int(response["WL-Count"]) != 0:
self.add_error("message", "Message is already whitelisted.")
return False
except AssertionError:
self.add_error("message", "Invalid message.")
return False
return True
def add_error(self, field, message):
try:
self.errors[field].append(message)
except (KeyError, TypeError):
self.errors[field] = [message]
class FormRegister(DefaultForm):
name = TextField(localize("administration", "client.field_username"),
validators=[DataRequired()])
email = TextField(localize("administration", "client.field_email"),
validators=[Email()])
password = PasswordField(localize("administration",
"client.field_password"),
validators=[DataRequired()])
class FormRole(DefaultForm):
name = TextField(localize("administration", "roles.field_name"),
validators=[DataRequired()])
description = TextField(localize("administration",
"roles.field_description"),
validators=[DataRequired()])
parent_id = SelectField(localize("administration",
"roles.field_parent_id"),
coerce=int)
class FormMenu(DefaultForm):
address = TextField(localize("administration", "menus.field_address"),
validators=[DataRequired()])
name = TextField(localize("administration", "menus.field_name"))
menubar = TextField(localize("administration", "menus.field_menubar"),
validators=[DataRequired()])
weight = IntegerField(localize("administration", "menus.field_weight"),
validators=[DataRequired()])
flags = IntegerField(localize("administration", "menus.field_flags"),
validators=[NumberRange(0, 10)])
image = TextField(localize("administration", "menus.field_image"))
class PasswordReminder(FlaskForm):
id = TextField(_("Project identifier"), validators=[Required()])
submit = SubmitField(_("Send me the code by email"))
def validate_id(form, field):
if not Project.query.get(field.data):
raise ValidationError(_("This project does not exists"))
class MemberForm(FlaskForm):
name = TextField(_("Name"), validators=[Required()])
weight = CommaDecimalField(_("Weight"), default=1)
submit = SubmitField(_("Add"))
def __init__(self, project, edit=False, *args, **kwargs):
super(MemberForm, self).__init__(*args, **kwargs)
self.project = project
self.edit = edit
def validate_name(form, field):
if field.data == form.name.default:
raise ValidationError(_("User name incorrect"))
if (not form.edit and Person.query.filter(
Person.name == field.data, Person.project == form.project,
Person.activated == True).all()):
raise ValidationError(_("This project already have this member"))
def save(self, project, person):
# if the user is already bound to the project, just reactivate him
person.name = self.name.data
person.project = project
person.weight = self.weight.data
return person
def fill(self, member):
self.name.data = member.name
self.weight.data = member.weight
class NewPostForm(Form):
id = HiddenField()
title = TextField('Title', validators=[Length(min=3, max=500)])
text = TextAreaField('Text', validators=[Required(), ])
url = URLField('URL')
image_url = URLField('Image URL')
publish_date = DateTimeField("Publish at date", default=datetime.datetime.now())
class TokenInterfaceForm(FlaskForm):
grant_type = TextField('grant_type', [])
client_id = TextField('client_id', [])
client_secret = TextField('client_secret', [])
redirect_uri = TextField('redirect_uri', [])
refresh_token = TextField('refresh_token', [])
scope = TextField('scope', [])
code = TextField('code', [])
class RegistrationForm(Form):
name = TextField('name', validators=[Required(), Length(max=300)])
email = TextField('email', validators=[Email(), Required(), Length(max=254)])
password = PasswordField('password', validators=[Required(), Length(min=5, max=300)],
widget=PasswordInput(False))
password2 = PasswordField('password2',
validators=[
Required(), EqualTo('password', "Passwords must be identical")
], widget=PasswordInput(False))
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if User.email_registred(self.email.data):
self.email.errors.append('Email already registred!')
return False
return True
class Chat(FlaskForm):
message = TextField(
"message",
validators=[
InputRequired(),
Length(min=1,
max=2000,
message="length cannot exceed 2000 characters"),
],
)
class FormRule(DefaultForm):
route = TextField(localize("administration", "rules.field_route"),
validators=[DataRequired()])
role_id = SelectField(localize("administration", "rules.field_role"),
coerce=int)
insert = SelectField(localize("administration", "rules.field_insert"),
choices=[(item, item) for item in Rule.permissions])
remove = SelectField(localize("administration", "rules.field_remove"),
choices=[(item, item) for item in Rule.permissions])
change = SelectField(localize("administration", "rules.field_change"),
choices=[(item, item) for item in Rule.permissions])
view = SelectField(localize("administration", "rules.field_view"),
choices=[(item, item) for item in Rule.permissions])
class EditProjectForm(FlaskForm):
name = TextField(_("Project name"), validators=[Required()])
password = TextField(_("Private code"), validators=[Required()])
contact_email = TextField(_("Email"), validators=[Required(), Email()])
def save(self):
"""Create a new project with the information given by this form.
Returns the created instance
"""
project = Project(name=self.name.data,
id=self.id.data,
password=self.password.data,
contact_email=self.contact_email.data)
return project
def update(self, project):
"""Update the project with the information from the form"""
project.name = self.name.data
project.password = self.password.data
project.contact_email = self.contact_email.data
return project
class addBook(FlaskForm):
title = StringField(
"Book Title",
validators=[
InputRequired("Enter a Valid Title"),
Length(max=255, message="Title Should be less than 255 charecters")
])
author = TextField("Authors",
validators=[InputRequired("Enter a Valid Title")])
price = IntegerField("Price",
validators=[InputRequired("Enter a Valid Price")])
stock = IntegerField(
"Available Stock",
validators=[InputRequired("Enter the number of books available")])
submit = SubmitField("Add Book")
class FormUserLogin(FlaskForm):
"""User login form."""
username = TextField(
"Username",
id="form-login-username",
validators=[DataRequired()],
render_kw={"placeholder": "vss365Writer"},
)
password = PasswordField(
"Password",
id="form-login-password",
validators=[DataRequired()],
)
submit = SubmitField("Login")
class ProjectForm(EditProjectForm):
id = TextField(_("Project identifier"), validators=[Required()])
password = PasswordField(_("Private code"), validators=[Required()])
submit = SubmitField(_("Create the project"))
def validate_id(form, field):
form.id.data = slugify(field.data)
if (form.id.data == "dashboard") or Project.query.get(form.id.data):
raise ValidationError(
Markup(
_("The project identifier is used "
"to log in and for the URL of the project. "
"We tried to generate an identifier for you but a project "
"with this identifier already exists. "
"Please create a new identifier "
"that you will be able to remember.")))
class BillForm(FlaskForm):
date = DateField(_("Date"), validators=[Required()], default=datetime.now)
what = TextField(_("What?"), validators=[Required()])
payer = SelectField(_("Payer"), validators=[Required()], coerce=int)
amount = CommaDecimalField(_("Amount paid"), validators=[Required()])
payed_for = SelectMultipleField(_("For whom?"),
validators=[Required()],
widget=select_multi_checkbox,
coerce=int)
submit = SubmitField(_("Submit"))
submit2 = SubmitField(_("Submit and add a new one"))
def save(self, bill, project):
bill.payer_id = self.payer.data
bill.amount = self.amount.data
bill.what = self.what.data
bill.date = self.date.data
bill.owers = [
Person.query.get(ower, project) for ower in self.payed_for.data
]
return bill
def fill(self, bill):
self.payer.data = bill.payer_id
self.amount.data = bill.amount
self.what.data = bill.what
self.date.data = bill.date
self.payed_for.data = [int(ower.id) for ower in bill.owers]
def set_default(self):
self.payed_for.data = self.payed_for.default
def validate_amount(self, field):
if field.data == 0:
raise ValidationError(_("Bills can't be null"))
class LoginForm(RedirectForm):
name = TextField('User', validators=[Required()])
password = PasswordField('Password', validators=[Required()])
class CSRFForm(FlaskForm):
csrf_token = TextField('csrf_token', validators = csrfValidator)
class ConfirmEmailChangeForm(FlaskForm):
confirm = BooleanField('confirm')
secret = TextField('secret', secretValidator)
class ChangeForm(Form): # pylint:disable=R0924,R0903
"""
User chooses a new screenname.
"""
change = TextField(label="New screenname:", validators=[Length(min=1)])
class LoginForm(Form):
email = TextField('email', validators=[Email(), Required(), Length(max=254)])
password = PasswordField('password', validators=[Required(), Length(min=5, max=300)],
widget=PasswordInput(False))
class CreateArchiveForm(FlaskForm):
name = TextField(_("Name for this archive (optional)"), validators=[])
start_date = DateField(_("Start date"), validators=[Required()])
end_date = DateField(_("End date"),
validators=[Required()],
default=datetime.now)
class NewBrandForm(Form):
id = HiddenField()
name = TextField('Name', validators=[Required(), Length(min=2, max=300)])
hashtags = TextField('Brand hash tags', validators=[Optional()])
profile_img_url = URLField("Add profile picture")
cover_img_url = URLField("Add cover picture")
class DeregisterDoitForm(CSRFForm):
deregister_secret = TextField('deregister_secret', secretValidator)
class AuthenticationForm(FlaskForm):
id = TextField(_("Project identifier"), validators=[Required()])
password = PasswordField(_("Private code"), validators=[Required()])
submit = SubmitField(_("Get in"))
class LoginForm(FlaskForm):
credentialType = TextField('credentialType', credentialValidator)
identifier = TextField('identifier', userNameValidator)
password = TextField('password', passwordValidator)
class FormBlog(Form):
title = TextField("Title", validators=[DataRequired()])
content = TextField("Content", validators=[DataRequired()])
confirm = SubmitField("Confirm")
cancel = SubmitField("Cancel")
class CredentialIdentifierForm(CSRFForm):
credentialType = TextField('credentialType', credentialValidator)
identifier = TextField('identifier', userNameValidator)
class NamesForm(FlaskForm):
name = TextField("Baby name")
submit = SubmitField("Send")
class KeygenForm(DigestForm):
pubkey = TextField('pubkey', secretValidator)
email = TextField('email', emailValidator)
createUser = BooleanField('createUser')
