def validate(self):
"""
Validation for Login
:return:
"""
Form.validate(self)
if authenticate_user(self.net_id.data, self.password.data, self.instructor_type.data):
return True
self.password.errors.append('Password and Username do not match')
return False
def AuthenticatedGet(self, org, event):
site_proj = db.Query(
Site,
projection=('county', 'state'),
distinct=True
).filter('event', event)
counties_and_states = {
site.county_and_state : (site.county, site.state) for site
in site_proj
}
Form = create_site_filter_form(counties_and_states)
form = Form(self.request.GET)
if not form.validate():
form = Form() # => use defaults
# construct query
query = Site.all().filter('event', event.key())
if form.county_and_state.data:
county, state = counties_and_states[form.county_and_state.data]
query = query.filter('county', county).filter('state', state)
if form.order.data:
query = query.order(form.order.data)
# run query
sites = list(query.run(
offset=form.page.data * self.SITES_PER_PAGE,
limit=self.SITES_PER_PAGE
))
self.response.out.write(template.render(dict(
page_db.get_page_block_dict(), **{
"form": form,
"sites": sites,
"sites_per_page": self.SITES_PER_PAGE,
})))
def validate(self):
"""
Validation for Registration Forms
Checks for type of user and checks if "net id" has already been registered
Performs sanity checks as well (same passwords)
If There are errors, appends errors to the form
:return: True if no Errors else False
"""
# Authenticate USER
if Form.validate(self) == False:
return False
if self.instructor_type.data == "TA":
if TA.check_in_ta_list(self.net_id.data) == False:
self.net_id.errors.append("This Net ID is not a valid TA")
elif TA.check_ta_registration(self.net_id.data) == True:
self.net_id.errors.append("This Net ID has already been registered")
else:
return True
elif self.instructor_type.data == "student":
if student.check_in_student_list(self.net_id.data) == False:
self.net_id.errors.append("This NETID is not a valid Student")
elif student.check_student_registration(self.net_id.data) == True:
self.net_id.errors.append("This Net ID has already been registered")
else:
return True
return False
def login(self):
error = None
Form = self.get_login_form()
if request.method == 'POST':
form = Form(request.form)
next_url = request.form.get('next') or self.default_next_url
if form.validate():
authenticated_user = self.authenticate(
form.username.data,
form.password.data,
)
if authenticated_user:
self.login_user(authenticated_user)
return redirect(next_url)
else:
flash('Incorrect username or password')
else:
form = Form()
next_url = request.args.get('next')
return render_template(
'auth/login.html',
error=error,
form=form,
login_url=url_for('%s.login' % self.blueprint.name),
next=next_url)
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
# Query data from database
user = savvy_collection.find_one({ EMAIL: self.email.data.rstrip() })
if user:
email = user.get(EMAIL, None)
hash_password = user.get(PASSWORD, None)
user_password = self.password.data.rstrip()
account_token = user.get(TOKEN, '')
if User.validate_login(hash_password, user_password):
userObj = User(email)
login_user(userObj)
return True
else:
flash('Incorrect login credentials', 'error')
else:
flash('Incorrect login credentials', 'error')
return False
def validate(self):
"""
Validate user email and password is correct.
"""
if not Form.validate(self):
return False
user = User.query.filter(User.email == self.email.data).first()
if user is not None:
sha1 = hashlib.sha1()
sha1.update(self.password.data)
if user.password == sha1.hexdigest():
self.user = user
is_user_valid = True
else:
self.user = None
is_user_valid = False
flash(u'邮箱或密码错误', 'error')
else:
self.user = None
is_user_valid = False
flash(u'邮箱或密码错误', 'error')
return is_user_valid
def validate(self):
rv = Form.validate(self)
if not rv:
return False
u = self.get_user()
if not u:
return False
else:
return True
def validate(self):
if not Form.validate(self):
return False
if not(self.temperature_min_val.data.isdigit() and self.temperature_max_val.data.isdigit()):
return False
else:
if int(self.temperature_min_val.data)>int(self.temperature_max_val.data):
return False
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.check_password(self.password.data):
return True
else:
self.username.errors.append('Invalid username or password')
return False
def validate(self,):
if not Form.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 email or password')
return False
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if not self.login_validator(self.username.data, self.password.data):
self.username.errors.append("Invalid login.")
return False
return True
def validate(self):
if not Form.validate(
self): ## Recomendable primero las demas validaciones
return False
if len(self.password.data) < 3:
self.password.errors.append('El password es demasiado corto!')
return False
return True ## Obligatorio retornar un booleano
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
return True
def validate(self):
validate = Form.validate(self)
if self.username.data:
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append('An account already exists with that username')
validate = False
return validate
def validate(self):
if not Form.validate(self):
return False, str(self.errors)
if len(self.answers.data) < 1:
e = "Must provide at least one answer for the question"
self.errors["answers"] = e
return False,e
return True, "Valid"
def upgrade(self, shop):
rv = Form.validate(self)
if rv:
shop.name = self.name.data
shop.address = self.address.data
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def validate(self):
validate = Form.validate(self)
if self.email.data:
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append('An account already exists with that e-mail')
validate = False
return validate
def validate(self):
if not Form.validate(self):
return False
# Cusmtom Clave de 2 o más caracteres
if len(self.clave.data) < 3:
self.clave.errors.append('Clave muy Corta.')
return False
return True
def validate(self):
if not Form.validate(self):
return False
# Validaciones propias
if len(self.password.data) < 4:
self.password.errors.append('La contraseña es demasiado corta.')
return False
return True
def validate(self):
validate = Form.validate(self)
if self.filename.data:
other_file = File.query.filter_by(name=self.filename.data).first()
if other_file:
self.filename.errors.append('A file with this name already exists.')
validate = False
return validate
def validate(self):
if not Form.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):
rv = Form.validate(self)
if not rv:
message = ""
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ": " + err + "\n"
flash(message, "error")
return False
return True
def validate(self):
if not Form.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 create_new(self):
rv = Form.validate(self)
if rv:
category = Category()
category.init(self.name.data, self.num.data, self.parentid.data, self.visible.data, self.paid.data, self.dcost.data)
db.session.add(category)
db.session.commit()
self.category = category
return True
return False
def validate(self, extra_validators=None):
if not Form.validate(self):
return False
if len(self.password.data) <= 4:
self.password.errors.append('Password is too short')
return False
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username= self.username.data).first()
if user:
self.username.errors.append("That username is already taken")
return False
else:
return True
def create_new(self):
rv = Form.validate(self)
if rv:
shop = Shop()
shop.init(self.name.data, self.address.data)
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
user = savvy_collection.find_one({EMAIL: self.email.data.rstrip()})
if user:
flash('Email has already been taken', 'warning')
return False
else:
raw_token = self.email.data + 'verification code'
token = md5(raw_token.encode('utf-8')).hexdigest()
user = {
PASSWORD:
md5(self.password.data.rstrip().encode('utf-8')).hexdigest(),
EMAIL:
self.email.data.rstrip(),
CATEGORY:
self.category.data,
TOKEN:
token
}
# insert into database
employerId = savvy_collection.insert_one(user).inserted_id
if self.category.data == EMPL:
jobs_collection.insert({EMPLID: employerId})
# url = os.getenv('SCRIPT_URI') <----------------get this to work when server is up
# url = '127.0.0.1:5000'
# message = """
# Hi {},
#
# You need to confirm your account by clicking this link:
# {}/confirmEmail/{}/{}
#
# Best,
# Team SavvyHire
# """.format(self.username.data.rstrip(),url, self.username.data.rstrip(), token)
#
# cmd="""echo '{}' | mail -s 'Confirm account' {}""".format(message, self.email.data.rstrip())
# p=subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
# p.communicate()
# log in
userObj = User(user[EMAIL])
login_user(userObj)
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter(
User.username == self.username.data.lower()).first()
if user and user.check_password(self.password.data):
return True
else:
self.username.errors.append("Invalid username or password")
return False
def validate(self):
"""验证nickname是否合法"""
if not Form.validate(self): # ？？？？
return False
if self.nickname.data == self.original_nickname: # ??
return True
user = User.query.filter_by(nickname=self.nickname.data).first()
if user is not None: # 判断数据库中是否有这个用户名
self.nickname.errors.append('This nickname is already in use. Please choose another one.')
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
username = User.query.filter_by(username=self.username.data).first()
if username is None:
self.username.errors.append('Unknown username')
return False
return True
def validate(self):
if not Form.validate(self):
return False
user = User.objects(email=self.email.data).first()
if not user:
self.email.errors.append(u'用户不存在')
return False
return True
def validate(self):
rv = Form.validate(self)
if Video.query.filter(Video.url==self.video_url.data).count() != 1:
self.video_url.errors.append('Video url not found')
return False
if not rv:
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if self.location.data == -1 and (
len(self.new_location_name.data) < 4
or len(self.new_location_name.data) > 40):
self.new_location_name.errors.append(
'The place name must be filled.')
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if not validate_credentials(self.username.data, self.password.data):
# use same error message in same location with random delay - ACCOUNT ENUMERATION PROTECTION
enumeration_delay()
self.password.errors.append(self.login_error)
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
_passwd = md5.new(self.password.data).hexdigest()
user = User.validate(self.username.data, _passwd)
if not user:
self.username.errors.append(u'用户名或密码错误')
return False
self.user = user
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if self.language.data not in language_list:
self.language.errors.append(
"Please specify a valid language for the paste.")
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if 0 == 1:
# use same error message in same location with random delay - ACCOUNT ENUMERATION PROTECTION
enumeration_delay()
self.old_password.errors.append(default_account_error)
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append('Email is already in use!')
return False
return True
def validate(self, data, isValid):
rv = Form.validate(self)
if not rv:
return False
if not data:
self.email.errors.append('Unknown Email')
return False
if not isValid:
self.password.errors.append('Invalid Password')
return False
return True
def validate(self):
"""Sobrescribimos la funcion validate. Primero validamos las que estan utilizadas
en el formulario y luego las que sobreescribimos"""
if not Form.validate(self):
return False
if len(self.password.data) < 3:
self.password.errors.append("El password es demasiado Corto")
return False
return True
def validate_on_submit(self):
print "hello there"
if not Form.validate(self):
print "not validated"
return False
# user = User.query.find(username = self.username)
# print user
# if user:
# self.username.errors.append("Username taken")
# return False
return True
def create_new(self):
rv = Form.validate(self)
if rv:
category = Category()
category.init(self.name.data, self.num.data, self.parentid.data,
self.visible.data, self.paid.data, self.dcost.data)
db.session.add(category)
db.session.commit()
self.category = category
return True
return False
def validate(self):
if not Form.validate(self):
return False
if self.nickname.data == self.original_nickname:
return True
user = User.query.filter_by(nickname=self.nickname.data).first()
if user is not None:
self.nickname.errors.append(
'This nickname is already in use. Please choose another one.')
return False
return True
def validate_length(self, field1, field2, field3):
val = Form.validate(self)
if not val:
return False
if field3 == 'hamming':
if len(field1) != len(field2):
self.message = "The strings must be equal in length for Hamming distance"
#raise ValidationError("The two strings must be equal in length.")
self.str2.errors.append(self.message)
return False
def validate_on_submit(self):
print "hello there"
if not Form.validate(self):
print "not validated"
return False
# user = User.query.find(username = self.username)
# print user
# if user:
# self.username.errors.append("Username taken")
# return False
return True
def validate(self):
if not Form.validate(self):
return None
user = User.query.filter_by(username=self.username.data).first()
if not user:
self.username.errors.append('User doesn\'t exist')
return None
if not user.check_password(self.password.data):
self.password.errors.append('Incorrect password')
return None
return user
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if not check_if_username_exists(
self.username.data) and check_if_email_exists(self.email.data):
# use same error message in same location with random delay - ACCOUNT ENUMERATION PROTECTION
enumeration_delay()
self.confirm.errors.append(self.registration_error)
return False
return True
def validate(self):
lf = Form.validate(self)
if not lf:
return False
admin = Admin.query.filter_by(userd=self.admin.data).first()
if admin is None:
self.admin.errors.append('Unknown admin')
return False
self.admin = admin
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = Account.find_by_username(self.username.data)
if not user.password_correct(self.currentPassword.data):
self.currentPassword.errors.append("Password is incorrect.")
return False
return user
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = Users.query.filter_by(
username=self.username.data).first()
if user:
self.username.errors.append('Username already exist, Please choose different username')
return False
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter(User.email==self.email.data.lower()).first()
username = User.query.filter(User.username==self.username.data.lower()).first()
if user and username:
self.email.errors.append("That email is already taken.")
self.username.errors.append("That username is already taken.")
return False
else:
return True
def validate(self):
lf = Form.validate(self)
if not lf:
return False
admin = Admin.query.filter_by(userd=self.admin.data).first()
if admin is None:
self.admin.errors.append('Unknown admin')
return False
self.admin = admin
return True
def validate(self):
#Returns false if a field does not meet at least 1 validation
if not Form.validate(self):
return False
#Validates password is > 2 chars
if len(self.password.data) < 3:
self.password.errors.append(
'Password does not meet length requirements')
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = User.query.filter_by(email=self.email.data).first()
if user is not None:
self.email.errors.append('Email in use.')
return False
self.user = user
return True
def post_validate(self):
if not Form.validate(self):
return False
valid = True
if not (datetime.datetime.now().year - self.birthday.data.year >= 18):
valid = False
self.birthday.errors.append("You are too young")
elif not (datetime.datetime.now().year - self.birthday.data.year <
130):
valid = False
self.birthday.errors.append("Your age seems to be unreal")
return valid
def validate(self) -> bool:
rv = Form.validate(self)
if not rv:
return False
dns_exists = Blacklist.query.filter_by(dns=self.dns.data).first()
if dns_exists:
self.dns.errors.append(
gettext('DNS %(dns)s already exists.', dns=self.dns.data))
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
checkIndex = agency_collection.find_one({INDEX: float(self.index.data.rstrip())}) if self.index.data.rstrip() is not '' else ''
if checkIndex:
flash('Agency already exists and will be updated', 'warning')
bufferName = self.agencyName.data.rstrip() or checkIndex[NAME]
bufferWebsite = self.website.data.rstrip() or checkIndex[WEBSITE]
bufferLocation = self.location.data.rstrip() or checkIndex[LOCATION]
bufferDescription = self.description.data.rstrip() or checkIndex[DESCRIPTION]
agency_collection.update({
NAME: self.agencyName.data.rstrip()
}, {
'$set':{
NAME : bufferName,
WEBSITE : bufferWebsite,
LOCATION : bufferLocation,
DESCRIPTION: bufferDescription
}})
return True
else:
document = meta_data.find_one({META:INDEX})
newIndex = int(document[INDEX]) + 1
agency = {
INDEX : newIndex,
NAME : self.agencyName.data.rstrip(),
WEBSITE : self.website.data.rstrip(),
LOCATION : self.location.data.rstrip(),
DESCRIPTION : self.description.data
}
# insert into database
agency_collection.insert_one(agency)
#update index
meta_data.update({META : INDEX}, {"$set" : { INDEX : newIndex}})
return True
