def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if len(str(self.postalcode.data)) is 5 and int(self.postalcode.data):
return True
self.postalcode.data = re.sub(r'\s', r'', self.postalcode.data)
if not len(str(self.postalcode.data)) is 6:
self.postalcode.errors.append('Invalid postal code (length)')
return False
if not ''.join([
str(self.postalcode.data)[0],
str(self.postalcode.data)[2],
str(self.postalcode.data)[4]
]).isalpha():
self.postalcode.errors.append(
'Invalid postal code (example: A1A1A1)'
)
return False
if not ''.join([
str(self.postalcode.data)[1],
str(self.postalcode.data)[3],
str(self.postalcode.data)[5]
]).isdigit():
self.postalcode.errors.append(
'Invalid postal code (example: A1A1A1)'
)
return False
return True
def validate(self):
# Validate all other fields with default validators
if not FlaskForm.validate(self):
return False
result = True
archive_date = self.archive_date.data
publish_date = self.publish_date.data
if archive_date and publish_date > archive_date:
self.archive_date.errors.append(
_('Archive date needs to be after the publish date.'))
result = False
# Test if either english or dutch is entered
if not (self.nl_title.data or self.en_title.data):
self.nl_title.errors.append(
_('Either Dutch or English title required'))
result = False
if not (self.nl_content.data or self.en_content.data):
self.nl_content.errors.append(
_('Either Dutch or English content required'))
result = False
# XOR the results to test if both of a language was given
if bool(self.nl_title.data) != bool(self.nl_content.data):
self.nl_title.errors.append(
_('Dutch title requires Dutch content and vice versa'))
result = False
if bool(self.en_title.data) != bool(self.en_content.data):
self.en_title.errors.append(
_('English title requires English content and vice versa'))
result = False
return result
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = authenticate_user(current_user.username, self.password.data)
if user is None:
return False
return True
def validate(self): if not Form.validate(self): return False if self.username.data == self.original_username: return True user = User.query.filter_by(username = self.username.data).first() if user != None: return False return True
def validate(self):
if not FlaskForm.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user:
self.email.errors.append("That email is already taken")
return False
else:
return True
def validate(self):
if not FlaskForm.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user and user.check_password(self.password.data):
return True
else:
self.email.errors.append("Invalid e-mail or password")
return False
def validate(self):
if not FlaskForm.validate(self):
return False
if self.open.data:
self.desired_state = DoorState.Open
elif self.present.data:
self.desired_state = DoorState.Present
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user and user.username.lower() != g.user.username.lower():
self.username.errors.append('Username already in use')
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = authenticate_user(self.username.data, self.password.data)
if user is None:
self.username.errors.append("Invalid username or password")
return False
else:
self.user = user
return True
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = User.objects(username__iexact=self.username.data).first()
if user is None:
return True
else:
self.username.errors.append("Username is already taken - try again")
return False
def validate(self):
rv = Form.validate(self)
if not rv:
return False
captcha = session['captcha']
captcha_data = self.captcha.data
if captcha_data.lower() != captcha.lower():
self.captcha.errors.append(_('The captcha is error'))
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
config = ConfigParser.RawConfigParser()
config.read('swingflask.conf')
if (
self.username.data == config.get('admin', 'username')
and self.password.data == config.get('admin', 'password')
):
return True
else:
self.username.errors.append('Invalid credentials')
return False
def validate(self):
# check default validation
if not FlaskForm.validate(self):
return False
# check nested forms
for t in self.target_set:
if not t.form.validate():
error_fields = ','.join(t.form.errors.keys())
self.target_set.errors.append({'target': t.name, 'message': 'Invalid target ' + error_fields})
return False
return True
def validate(self):
if not FlaskForm.validate(self):
print "wrong two"
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.verify_password(self.password_hash.data):
return True
else:
flash('invalid username or password')
self.username.errors.append("Invalid username or password")
return False
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.verify_password(self.password_hash.data):
print "login 1 working"
return True
else:
flash("Invalid username or password")
#self.username.errors.append("Invalid username or password")
return False
def validate(self, *args, **kwargs):
"""
Validates the form by calling `validate` on each field, passing any
extra `Form.validate_<fieldname>` validators to the field validator.
also calls `validate_ldap`
"""
valid = FlaskForm.validate(self, *args, **kwargs)
if not valid:
logging.debug("Form validation failed before we had a change to "
"check ldap. Reasons: '{0}'".format(self.errors))
return valid
return self.validate_ldap()
def validate(self):
# Validate all other fields with default validators
if not FlaskForm.validate(self):
return False
# Test if either english or dutch is entered
if self.start_time.data >= self.end_time.data:
self.start_time.errors.append(
_("Start time must be before end time"))
# Append empty string to mark the field red.
self.end_time.errors.append('')
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
print "hello worlkd"
username = User.query.filter(func.lower(User.username) == func.lower(self.username.data)).first()
if username:
self.username.errors.append("Invalid username or password")
flash('username taken')
return False
else:
print "Register Validate success"
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if self.action.data not in ('edit', 'new'):
return False
has_error = False
if self.action.data in ('edit', 'new'):
if type(self.name.data) not in (str, unicode) or not re.search(r'[A-Za-z0-9]', self.name.data):
self.name.errors.append(word("The name must be filled in."))
has_error = True
if type(self.method.data) not in (str, unicode) or self.method.data not in ('referer', 'ip', 'none'):
self.name.errors.append(word("You must select an option."))
has_error = True
if has_error:
return False
return True
def validate(self):
self.user = None
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user is None:
self.username.errors.append('Unknown username')
return False
if not user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
self.user = user
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(email=self.email.data).first()
if user is not None:
error = 'Email already in use'
self.email.errors.append(error)
print(("ERROR: %s" % error))
return False
user = User(username=self.username.data, email=self.email.data)
user.password = self.password.data
self.user = user
return True
def validate(self):
if not self.url.data.startswith((r"http://", r"https://")):
self.url.data = "".join(["https://",self.url.data])
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
if not self.user.data:
self.user.data = current_user.username
# filter out the tags from the system
stripped = set(filter(None, [t.strip() for t in self.tags.data.split(",")]))
self.tags.data=",".join(sorted(stripped))
return True
def validate(self):
if not (self.url.data.startswith("http://")
or self.url.data.startswith("https://")):
self.url.data = "http://" + self.url.data
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
#filter out empty and duplicate tag names
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag] #remove empty strings
tagset = set(not_empty) #to remove duplicates
self.tags.data = ",".join(tagset) #creating comma seperated values
return True
def validate(self):
if not FlaskForm.validate(self):
return False
institution_class = InstitutionClass.query.get(self.class_id.data)
if institution_class is None:
self.class_id.errors.append('Le type d\'institution n\'existe pas!')
return False
wilaya = Wilaya.query.get(self.wilaya_id.data)
if wilaya is None:
self.wilaya_id.errors.append('La wilaya n\'existe pas!')
return False
commune = Commune.query.get(self.commune_id.data)
if commune is None or commune.wilaya_id is not wilaya.id:
self.commune_id.errors.append('La commune n\'existe pas!')
return False
return True
def validate(self):
if not (self.url.data.startswith("http://") or\
self.url.data.startswith("https://")):
self.url.data = "http://" + self.url.data
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
# filter out empty and duplicate tag names
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tagset = set(not_empty)
self.tags.data = ','.join(tagset)
return True
def validate(self):
# check that all required fields have been filled
rv = FlaskForm.validate(self)
if not rv:
return False
# check if given student reg no. is already registered
student_ = Student.query.filter_by(reg_num=self.reg_num.data).first()
if not student_:
self.reg_num.errors.append("Unknown Registration Number")
return False
# save lecturer
self.student_ = student_
# log staff in
login_user(student_)
# successful validation
return True
def validate(self):
"""
custom validation method
:return: boolean
"""
result = True
if not FlaskForm.validate(self):
result = False
if not self.comm.data and not self.extcomm.data and not self.larcomm.data:
err_message = "At last one of those values could not be empty"
self.comm.errors.append(err_message)
self.larcomm.errors.append(err_message)
self.extcomm.errors.append(err_message)
result = False
return result
def validate(self):
if not FlaskForm.validate(self):
return False
if self.nickname.data == self.original_nickname:
return True
if self.nickname.data != User.make_valid_nickname(self.nickname.data):
self.nickname.errors.append(
gettext(
'This nickname has invalid characters. '
'Please use letters, numbers, dots and underscores only.'))
return False
user = User.query.filter_by(nickname=self.nickname.data).first()
if user is not None:
self.nickname.errors.append(
gettext('This nickname is already in use. '
'Please choose another one.'))
return False
return True
def validate(self):
"""
Validation of the Things form checking for tags separated by comma.
Returns:
True if the form is validated by it parent, else False.
"""
if not FlaskForm.validate(self):
return False
# Filter out empty and duplicate tag names
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tagset = set(not_empty)
self.tags.data = ",".join(tagset)
return True
def validate(self):
"""
Send a test request to see if this API credentials are valid
"""
rv = FlaskForm.validate(self)
if not rv:
return False
client = ZoomClient(api_key=self.api_key.data, api_secret=self.api_secret.data)
response = json.loads(client.user.list().content)
# If invalid credentials, raise error to the form.
if response.get("code") != 200:
self.api_key.errors.append(response.get("message"))
self.api_secret.errors.append(response.get("message"))
return False
return True
def validate(self):
bad_names = [
'delete', 'admin', 'bitcoin', 'bitcoincash', 'answer.cash',
'username', 'user_name', 'room', 'business', 'answer_bot', 'all',
'rooms', 'people', 'followers', 'monero', 'btc', 'btccash',
'answer'
]
rv = FlaskForm.validate(self)
if rv is True:
if self.subcommonname.data.lower() in bad_names:
flash('Name is not allowed.', category="danger")
return False
else:
return True
def validate(self):
# check default validation
if not FlaskForm.validate(self):
return False
# check nested forms
for t in self.target_set:
if not t.form.validate():
error_fields = ','.join(t.form.errors.keys())
self.target_set.errors.append({
'target':
t.name,
'message':
'Invalid target ' + error_fields
})
return False
return True
def validate(self):
return True
rv = FlaskForm.validate(self)
if not rv:
return False
start_date = self.start_date.data
end_date = self.end_date.data
today_date = date.today()
if start_date > end_date:
self.start_date.errors.append('Invalid start date ')
return False
if start_date < today_date:
self.start_date.errors.append('Invalid start date')
return False
if start_date < today_date:
self.end_date.errors.append('Invalid end date')
return False
return True
def validate(self):
valid = FlaskForm.validate(self)
if not valid:
return False
# make sure username exists in database
user = User.query.filter_by(username=self.username.data).first()
if user is None:
self.username.errors.append(
'Unrecognized username. Please try again')
return False
# make sure password matches
if not check_password_hash(user.password, self.password.data):
self.password.errors.append('Password incorrect. Please try again')
return False
return True
def validate(self):
return_value = Form.validate(self)
if not return_value:
return False
if not self.first_name.data:
self.first_name.errors.append({
"id": "firstNameInputLink",
"message": "Enter your first name",
"href": "firstNameContainer",
"error_alert": "Enter your first name"
})
return_value = False
else:
result = re.match(r"^[a-zA-Z0-9,-.'\s]+$", self.first_name.data)
if not result:
self.first_name.errors.append({
"id": "firstNameInputLink",
"message": "Check your first name",
"href": "firstNameContainer",
"error_alert": "Check that you've entered your first name correctly"
})
return_value = False
if not self.last_name.data:
self.last_name.errors.append({
"id": "lastNameInputLink",
"message": "Enter your last name",
"href": "lastNameContainer",
"error_alert": "Enter your last name"
})
return_value = False
else:
result = re.match(r"^[a-zA-Z0-9,-.'\s]+$", self.last_name.data)
if not result:
self.last_name.errors.append({
"id": "lastNameInputLink",
"message": "Check your last name",
"href": "lastNameContainer",
"error_alert": "Check that you've entered your last name correctly"
})
return_value = False
return return_value
def validate(self):
""" handles all address validation """
rv = FlaskForm.validate(self)
if not rv:
return False
# Validate Addresses
origin_validator = AddressValidator()
# Check if not valid origin
if not origin_validator.is_valid_address(self.startLocation.data):
self.startLocation.errors.append('Origin: Invalid Location')
return False
dest_validator = AddressValidator()
# check if not valid destination
if not dest_validator.is_valid_address(self.endLocation.data):
self.endLocation.errors.append('Destination: Invalid Location')
return False
# check if origin and destination are the same
if origin_validator.address == dest_validator.address:
self.startLocation.errors.append('Origin cannot match destination')
self.endLocation.errors.append('Destination cannot match origin')
return False
# check if there are logged in drivers
users = User.query.all()
drivers = []
for u in users:
if u.has_roles('driver') and u.is_logged_in():
drivers.append(u)
if len(drivers) == 0:
self.startLocation.errors.append(
'There are no available drivers at this time')
self.endLocation.errors.append(
'There are no available drivers at this time')
return False
# If address validation passes, check for available drivers
self.startLocation = origin_validator.address
self.endLocation = dest_validator.address
# all vaidations passed
return True
def validate(self):
if not (self.nm_url.data.startswith('https://')
or self.nm_url.data.startswith('http://')):
self.nm_url.data = "http://" + self.nm_url.data
if not Form.validate(self):
return False
if not self.nm_description.data:
self.nm_description.data = self.nm_url.data
#filter our empty and duplicate tag names
stripped = [t.strip()
for t in self.tags.data.split(',')] #retira os espaços
not_empty = [tag for tag in stripped if tag] #retira os vazios
tagset = set(not_empty) #retira os duplicados
self.tags.data = ','.join(tagset)
return True
def validate(self):
"""Validate the form."""
rv = FlaskForm.validate(self)
if not rv:
return False
user = db.session.query(User).filter_by(email=self.email.data).first()
if user is None:
self.email.errors.append(u'Unknown email.')
return False
if not user.check_password(self.password.data):
self.password.errors.append(u'Invalid password.')
return False
self.user = user
return True
def validate(self):
"""
Validate this form as usual and check for any form-level validation errors based on question type
:return: boolean
"""
valid_fields = FlaskForm.validate(self)
valid_date_range_form = True
valid_calculated_form = True
valid_mutually_exclusive_form = True
for question in self.schema.get_questions_for_block(self.block_json):
if question['type'] == 'DateRange' and valid_date_range_form:
valid_date_range_form = self.validate_date_range_question(question)
elif question['type'] == 'Calculated' and valid_calculated_form:
valid_calculated_form = self.validate_calculated_question(question)
elif question['type'] == 'MutuallyExclusive' and valid_mutually_exclusive_form and valid_fields:
valid_mutually_exclusive_form = self.validate_mutually_exclusive_question(question)
return valid_fields and valid_date_range_form and valid_calculated_form and valid_mutually_exclusive_form
def validate(self) -> bool:
valid = FlaskForm.validate(self)
hash_ = bcrypt.hashpw(
self.password_old.data.encode('utf-8'),
current_user.password.encode('utf-8'))
if hash_ != current_user.password.encode('utf-8'):
self.password_old.errors.append(_('error wrong password'))
valid = False
if self.password.data != self.password2.data:
self.password.errors.append(_('error passwords must match'))
self.password2.errors.append(_('error passwords must match'))
valid = False
if self.password_old.data == self.password.data:
self.password.errors.append(_('error new password like old password'))
valid = False
if len(self.password.data) < session['settings']['minimum_password_length']:
self.password.errors.append(_('error password too short'))
valid = False
return valid
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user and user.username.lower() != g.user.username.lower():
self.username.errors.append('Username already in use')
return False
if self.password.data:
if self.old_password.data == '':
self.old_password.errors.append('Please enter your old password')
return False
elif not user.check_password(self.old_password.data):
self.old_password.errors.append('Incorrect password')
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
birth_date = str_to_date(self.birth_date.data)
if not birth_date:
self.birth_date.errors.append("Invalid birth date")
return False
if birth_date >= datetime.date(datetime.today()):
self.birth_date.errors.append(
"A birth date can not be today or later.")
return False
self.birth_date.data = birth_date
start_date = str_to_date(self.start_date.data)
if not start_date:
start_date = datetime.date(datetime.today())
self.start_date.data = start_date
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if len(self.foldername.data) > 15:
flash("Invalid name: " + self.foldername.data)
flash("Name can be at most 15 characters.")
return False
if self.foldername.data.find('#') != -1:
flash("Invalid name: " + self.foldername.data)
flash("Name cannot contain character '#'.")
return False
if self.foldername.data.find(' ') != -1:
flash("Invalid name: " + self.foldername.data)
flash("Name cannot contain spaces.")
return False
return True
def validate(self):
valid = FlaskForm.validate(self)
if not valid:
return False
# make sure user entered a unique username
user = User.query.filter_by(username=self.username.data).first()
if user is not None:
self.username.errors.append(
'Username already taken. Please try again')
return False
# make sure user entered a unique email
user = User.query.filter_by(email=self.email.data).first()
if user is not None:
self.email.errors.append('Email already taken. Please try again')
return False
return True
def validate(self):
if not FlaskForm.validate(self):
return False
if self.name.data and self.password.data and self.role.data:
from peerplaysbase.account import PasswordKey
pkey = PasswordKey(self.name.data, self.password.data,
self.role.data)
self.privateKey.data = pkey.get_private_key()
if self.privateKey.data:
try:
Node().validateAccount(self.privateKey.data),
return True
except Exception:
self.privateKey.errors.append(
"No account connected to this private key")
return False
else:
return False
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if self.action.data not in ('edit', 'new'):
return False
has_error = False
if self.action.data in ('edit', 'new'):
if (not isinstance(self.name.data, string_types)) or not re.search(
r'[A-Za-z0-9]', self.name.data):
self.name.errors.append(word("The name must be filled in."))
has_error = True
if (not isinstance(self.method.data, string_types)
) or self.method.data not in ('referer', 'ip', 'none'):
self.name.errors.append(word("You must select an option."))
has_error = True
if has_error:
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
# parse invitation token
invitation = self.invitation.data
email = ""
try:
if current_app.config['ACCOUNT_CREATION_NEEDS_INVITATION']:
seed, email = serialiser.loads(invitation)
if seed != "invitation":
raise ValueError("")
if self.email.data == "":
self.email.data = email
except Exception as err:
self.invitation.errors.append('Wrong token' + err.message)
return False
rv = self.email.validate(email)
if rv:
self.username.errors.append('Adresse invalide.')
# uniqness
if Users.has_pseudo(self.username.data):
self.username.errors.append('Ce pseudo utilisé')
rv = False
user = Users.get_by_email(self.email.data)
if user:
message = 'Un compte est déja enregistré pour cette adresse %s' % email
self.email.errors.append(message)
raise EmailExistsValidationError(message, user)
# password complexity
if not self.password.data or len(self.password.data) < 8:
self.password.errors.append(
'La longueur de password minimal est de 8 caractères')
rv = False
return rv
def validate(self):
"""Extra validation, used to validate gene list."""
# Default validation as defined in field validators
self.transcripts = [] # Reset transcripts on validation
if not FlaskForm.validate(self):
return False
if self.gene_list.data:
# Parse gene_list
errors, self.transcripts = parse_gene_list(self.gene_list.data, self.transcripts)
if errors:
self.gene_list.errors.extend(errors)
return False
if self.gene_list.errors:
return False
return True
def validate(self):
if not self.url.data.startswith(
"http://") and not self.url.data.startswith("https://"):
self.url.data = "https://" + self.url.data
# print(self.url.data)
# sys.stdout.flush()
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tagset = set(not_empty)
self.tags.data = ",".join(tagset)
return True
def validate(self):
if not Form.validate(self):
return False
try:
idInput = self.username.data
pswInput = self.password.data
hashed_psw = hashlib.sha256(pswInput).hexdigest()
dataDict = [
dict(p.to_dict(), **dict(id=p.key.id()))
for p in model.UserAccount.query(
model.UserAccount.username == idInput)
]
accountPsw = dataDict[0]['password']
if accountPsw == hashed_psw:
return True
else:
self.username.errors.append("Invalid username or password")
except:
self.username.errors.append("Invalid username or password")
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
pw = self.password.data
if len(pw) < 6:
self.password.errors.append('Password must be\
at least 6 characters,\
contain upper and lower\
case letters, and at least,\
one number')
return False
elif len(set(string.ascii_lowercase).intersection(pw)) == 0:
self.password.errors.append('Password must be\
at least 6 characters,\
contain upper and lower\
case letters, and at least,\
one number')
return False
elif len(set(string.ascii_uppercase).intersection(pw)) == 0:
self.password.errors.append('Password must be\
at least 6 characters,\
contain upper and lower\
case letters, and at least,\
one number')
return False
elif len(set(string.digits).intersection(pw)) == 0:
self.password.errors.append('Password must be\
at least 6 characters,\
contain upper and lower\
case letters, and at least,\
one number')
return False
user = User.query.filter_by(username=self.username.data).first()
if user is not None:
self.username.errors.append('Username already in use. \
Please choose another one')
return False
email = User.query.filter_by(email=self.email.data).first()
if email is not None:
self.email.errors.append('Email already in use')
return False
return True
def skip():
assert g.get('csrf_valid')
# don't pass the token, then validate the form
# this would fail if CSRFProtect didn't run
form = FlaskForm(None)
assert form.validate()
def validate(self):
if not Form.validate(self):
return False
return True
def validate(self):
if request.form.get('message'): # super simple bot test (advanced bots will get by this)
log.warning("Suspect form submission from (put IP here), ignoring")
abort(404)
return FlaskForm.validate(self)
