def __call__(self, form, field):
schema = PasswordValidator()
schema \
.min(6) \
.has().digits()
if not schema.validate(field.data):
raise ValidationError(self.message)
def __call__(self, form: FlaskForm, field: Field):
the_schema = PasswordValidator()
the_schema \
.min(8) \
.has().lowercase() \
.has().digits()
if not the_schema.validate(field.data):
raise ValidationError(self.message)
def register():
error_list = []
form = RegistrationForm()
if request.method == 'POST':
#print(request.form['user_name'])
try:
user_name = form.user_name.data
password = form.password.data
if len(user_name) < 3:
#print("a")
if len(user_name) == 0:
error_list.append('Your username is required.')
else:
error_list.append('Your username is too short.')
schema = PasswordValidator()
schema.min(8) \
.has().uppercase() \
.has().lowercase() \
.has().digits()
if not schema.validate(password):
#print("b")
if len(password) == 0:
error_list.append("Your password is required.")
error_list.append('Your password is invalid, please refer to Account notes.')
#print(error_list)
if len(error_list) == 0:
services.add_user(user_name, password, repo.repo_instance)
# All is well, redirect the user to the login page.
return redirect(url_for('authen_bp.login'))
else:
return render_template(
'authen/credentials.html',
title='Register',
form=form,
error_list=error_list,
handler_url=url_for('authen_bp.register'),
)
except services.NameNotUniqueException:
error_list.append("Your username is already taken - please supply another.")
# For a GET or a failed POST request, return the Registration Web page.
return render_template(
'authen/credentials.html',
title='Register',
form=form,
error_list=error_list,
handler_url=url_for('authen_bp.register'),
)
@login_manager.unauthorized_handler
def unauthorized():
# Handle message when unauthorized
message.set_data({"login": "******"})
return message.UNAUTHORIZED
@login_manager.user_loader
def user_loader(id):
# user loader for login manager
user = User.query.filter_by(id=id).first()
return user
# Create a password schema
schema = PasswordValidator()
schema\
.min(8)\
.max(100)\
.has().uppercase()\
.has().lowercase()\
.has().digits()\
.has().no().spaces()\
def type_required(type):
# Decorator to check if user is certain type
def type_required_sub(func):
@wraps(func)
def wrapper(*args, **kwargs):
from password_validator import PasswordValidator
with open("input.txt") as file:
lines = file.readlines()
ans = len([l for l in lines if PasswordValidator(l).is_valid()])
print(ans)
"""
User model module
"""
from email_validator import validate_email
from password_validator import PasswordValidator
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import validates
from lib.pass_tools import hash_password
from models.base import BASE
# Password valid schema
password_schema = PasswordValidator().min(8).max(100).has().uppercase().has(
).lowercase().has().digits().has().symbols().has().no().spaces()
class User(BASE):
"""
User model
"""
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
username = Column(String(50), unique=True)
password = Column(String(255))
first_name = Column(String(255), nullable=False)
last_name = Column(String(255), nullable=False)
email = Column(String(255), nullable=False)
@validates('username')
def validate_username(self, key: str, value: str):
def main(argv: List):
ih = InputHandler(argv[0])
v = PasswordValidator(ih.inputs)
v.calculate_valids()
print(v.valid_count)
