def register_post():
form = RegisterForm(request.form)
# Get the values from the form
if form.validate():
# TODO: use managers and don't put logic in views
name = form.name.data
email = form.email.data
username = form.username.data
password = form.password.data
try:
user = Users(name=name, email=email, username=username)
user.set_password(password)
db.session.add(user)
db.session.commit()
except Exception:
flash("Could not register", "danger")
return redirect(url_for('register_get'))
else:
flash("You are now registered and can login", "success")
return redirect(url_for('login_get'))
flash("Check the values", "danger")
return render_template("register.html", form=form)
def register():
form = RegisterForm()
if form.register_submit.data and form.validate():
print(form.errors)
user = User.query.filter_by(username=form.username.data).first()
if user is None: #user does not exist
if form.password.data == form.password2.data: #password matches
new_user = User(username=form.username.data,
name=form.name.data,
email=form.email.data)
new_user.set_password(form.password.data)
db.session.add(new_user)
db.session.commit()
flash('Account created successfully. Kindly login now.',
'success')
return redirect(url_for('login'))
else: #user does not exist but password does not match
flash('Password does not match', 'danger')
return redirect(url_for('register'))
else: #user exist
flash('Account already exists', 'danger')
return redirect(url_for('register'))
return render_template('register.html',
form=form,
title='Register - Designer Concept')
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
login = form.login.data
q = User.query.filter_by(login=login).first()
if q is None:
user = User(login = login,
pass_hash = sha256(form.password.data.encode('UTF-8')).digest(),
role = 'patient')
db.session.add(user)
db.session.flush()
db.session.refresh(user)
patient = Patient(u_id = user.id,
name = form.name.data,
surname = form.surname.data,
patronymic = form.patronymic.data,
email = form.email.data,
phone = form.phone.data)
db.session.add(patient)
return 'Регистрация завершена!'
flash("Текущий пользователь уже существует!")
return render_template('register.html',
form = form)
def register():
if not app.config['APP_REGISTER']:
return render_template('user_register_disabled.html.j2')
form = RegisterForm()
if request.method == 'POST' and form.validate():
if User.objects(email=form.email.data).first() is None:
if User.objects().first() is None:
profile = "ADMIN" #make 1st user ADMIN
else:
profile = "USER"
new_user = User(
email=form.email.data,
password=form.password.data,
profile=profile,
).save()
send_confirmation_email(new_user)
login_user(new_user)
return redirect(url_for('user_unconfirmed'))
else:
flash('Email already registered "{}"'.format(form.email.data))
flash_form_errors(form)
return redirect(url_for('index'))
def register():
form = RegisterForm(
MultiDict({
**request.form.to_dict(),
**request.files.to_dict()
}))
if form.validate():
staff = Staff(number=form.number.data,
name=form.name.data,
branch=form.branch.data,
duty=form.duty.data)
img = cv2.imdecode(np.fromstring(form.img.data.read(), np.uint8),
cv2.IMREAD_COLOR)
emd = bytes(json.dumps(face_model.get_embedding(img).tolist()),
encoding='utf-8')
try:
db.session.add(staff)
db.session.commit()
except Exception:
db.session.rollback()
return make_response(jsonify({'msg': '写入数据库失败: add staff'}), 400)
sid = Staff.query.filter_by(number=form.number.data).first().id
embedding = Embedding(sid=sid, emd=emd)
try:
db.session.add(embedding)
db.session.commit()
except Exception:
db.session.rollback()
return make_response(jsonify({'msg': '写入数据库失败: add embedding'}),
400)
face_model.update_facebank()
return make_response(jsonify({'msg': '注册成功'}))
else:
return make_response(jsonify({'msg': '参数验证失败'}), 400)
def registerpage():
if current_user.is_authenticated:
flash("You are already logged in.", "warninglable")
return redirect(url_for("homepage"))
form = RegisterForm(request.form)
if request.method == "POST" and form.validate():
hashed = password.generate_password_hash(
form.password.data).decode('utf-8')
user = User(fname=form.fname.data,
lname=form.lname.data,
email=form.email.data,
password=hashed)
db.session.add(user)
db.session.commit()
flash("Account created for %s!" % (form.fname.data), "successlable")
return redirect(url_for("loginpage"))
return render_template("register.html", form=form)
def test_register_form_is_okay():
form_data = MultiDict(race='race-01',
username='******',
password='******',
passtest='somepass')
form = RegisterForm(form_data)
expect(form.validate()).to.be.true()
expect(form.errors).to.eq({})
def test_register_form_partial_is_invalid():
form_data = MultiDict(username='******', password='******')
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({
'passtest': ['This field is required.'],
'race': ['This field is required.']
})
def test_register_form_passwords_must_match():
form_data = MultiDict(race='race-01',
username='******',
password='******',
passtest='badpass')
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({'passtest': ['Passwords must match.']})
def test_validate_success_register_form(self):
"""Test the correct data is validated"""
form = RegisterForm(first_name="Janus",
last_name="Cascade",
username="******",
email="*****@*****.**",
password="******",
verify_password="******")
self.assertTrue(form.validate())
def test_checks_for_invalid_password_lengths(self):
"""Tests for incorrect password lengths"""
form = RegisterForm(first_name="Janus",
last_name="Cascade",
username="******",
email="*****@*****.**",
password="******",
verify_password="******")
self.assertFalse(form.validate())
def register():
if current_user.is_authenticated: #User already signed in -> shouldn't be able to register an account.
return redirect(url_for('index'))
form=RegisterForm()
if form.validate_on_submit():
#check if user already exists in database
form.validate()
present = User.query.filter_by(username=form.username.data).first()
if present is not None:
flash("Error: This username is taken")
return render_template("register.html", form=form)
user = User (username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash("Registration Completed!")
return redirect(url_for('index'))
return(render_template('register.html', form=form))
def admin_register():
register_form = RegisterForm(request.form)
if request.method == 'POST' and register_form.validate():
result = user.admin_register(request.form)
if result is None:
flash('Email exist. Please use another one', 'error')
return redirect(url_for('admin_register'))
flash('Registered successfully. Please login')
return redirect(url_for('admin_login'))
return render_template('admin/register.html', form=register_form)
def test_register_form_is_okay():
form_data = MultiDict(
race='race-01',
username='******',
password='******',
passtest='somepass'
)
form = RegisterForm(form_data)
expect(form.validate()).to.be.true()
expect(form.errors).to.eq({})
def register():
form = RegisterForm(meta=dict(csrf=False))
if form.validate():
user, msg = UserModel.register_user(form.form)
if user:
return dict(code=200, msg=msg, data=user.asdict())
else:
return dict(code=201, msg=msg, data=None)
else:
return form.errors
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
user = Auth.query.filter_by(email=request.form.get('email')).first()
if not user:
auth = Auth()
with db.submit_data():
auth.setter_data(request.form)
db.session.add(auth)
return redirect(url_for('web.login'))
return render_template('auth/register.html')
def test_register_form_partial_is_invalid():
form_data = MultiDict(
username='******',
password='******'
)
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({
'passtest': ['This field is required.'],
'race': ['This field is required.']
})
def test_validate_success_register_form(self):
"""Test the correct data is validated"""
form = RegisterForm(
first_name="Janus",
last_name="Cascade",
username="******",
email="*****@*****.**",
password="******",
verify_password="******"
)
self.assertTrue(form.validate())
def test_checks_for_invalid_password_lengths(self):
"""Tests for incorrect password lengths"""
form = RegisterForm(
first_name="Janus",
last_name="Cascade",
username="******",
email="*****@*****.**",
password="******",
verify_password="******"
)
self.assertFalse(form.validate())
def test_register_form_requires_valid_race():
form_data = MultiDict(
race='race-does-not-exist',
username='******',
password='******',
passtest='somepass'
)
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({
'race': ['Invalid value, must be one of: race-01, race-02, race-03, race-04, race-05.']
})
def test_register_form_passwords_must_match():
form_data = MultiDict(
race='race-01',
username='******',
password='******',
passtest='badpass'
)
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({
'passtest': ['Passwords must match.']
})
def register():
f = RegisterForm(data=request.form)
if f.validate():
new_user = User.create(email=f.email.data, password=f.password.data)
login_user(new_user)
return redirect(url_for('room_list_page'))
else:
flash('show form', 'show_form_register')
for field in f:
for error in field.errors:
flash(str(error), 'register_' + field.name)
return redirect(url_for('auth_page'))
def test_register_form_requires_valid_race():
form_data = MultiDict(race='race-does-not-exist',
username='******',
password='******',
passtest='somepass')
form = RegisterForm(form_data)
expect(form.validate()).to.be.false()
expect(form.errors).to.eq({
'race': [
'Invalid value, must be one of: race-01, race-02, race-03, race-04, race-05.'
]
})
def register():
form = RegisterForm()
if request.method == 'POST' and form.validate():
if form.password.data != form.repeat_password.data:
return render_template("auth/register.html", form=form, message="Passwords don't match")
else:
# -- Using the generate_password_hash and check_password_hash includes hash salting automatically
user = User(form.username.data, form.email.data,
generate_password_hash(form.password.data))
db.session.add(user)
db.session.commit()
return render_template("auth/register.html", form=form, message="User successfully made")
return render_template("auth/register.html", form=form)
def register():
form =RegisterForm(request.form)
if form.validate():
u = Users(username=form.username.data,
password=form.password.data,
email=form.email.data)
db.session.add(u)
db.session.commit()
token = u.generate_active_token()
send_mail(u.email,'账户激活','email/activate',username=u.username,token=token)
flash('该用户已经注册，请点击邮件中的链接完成激活')
return redirect(url_for('main.index'))
return render_template('users/register.html',form=form)
def post(self):
user = self.validate_user()
if user is not None:
self.redirect('/')
return
form = RegisterForm(self.request.params)
# validate form
if not form.validate():
self.r(form)
return
# validate csrf
if not self.validate_csrf(form.csrf_token.data):
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash('Please submit the form again'))
return
# check for an existing account
# using the lowercase username as a key
# to ensure users are unique
username = form.username.data
username = re.sub(
r'[\!\@\#\$\%\^\&\*\-_=\+\?<>,\.\"\':;\{\}\[\]|\\~\/`]', '',
username)
try:
user = Key("User", lower(username)).get()
except:
user = None
if user is not None:
self.r(form, flashes=flash('That username is taken'))
return
# create the user
try:
user = User(
username=username,
password=pw.gen_hash(form.password.data),
)
user.key = Key("User", lower(user.username))
user.put()
# create a hash with our secret so we know the cookie is legit later
self.generate_sig(user.username)
self.redirect('/?welcome=%s' % user.username)
return
except: # guess something happened eh?
self.r(form, flashes=flash())
return
def register():
from app.models import Users # corregir el llamado de forma global
form = RegisterForm(request.form)
if request.method == 'POST':
if form.validate():
user = Users.create_element(form.username.data, form.password.data,
form.email.data)
flash('USuario registrado exitosamente.')
# print("Usuario creado de forma exitosa")
# print(user.id)
return render_template('auth/register.html', title='Registro', form=form)
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
data = dict(form.data)
del data['confirm']
del data['register']
email = UserModel.query.filter_by(email=data['email']).first()
if email:
return render_template('register.html', form=form, error='Email is already exist')
user = UserModel(**data)
db.session.add(user)
db.session.commit()
return redirect(url_for('login'))
return render_template('register.html', form=form)
def post(self):
user = self.validate_user()
if user is not None:
self.redirect('/')
return
form = RegisterForm(self.request.params)
# validate form
if not form.validate():
self.r(form)
return
# validate csrf
if not self.validate_csrf(form.csrf_token.data):
form.csrf_token.data = self.generate_csrf()
self.r(form, flashes=flash('Please submit the form again'))
return
# check for an existing account
# using the lowercase username as a key
# to ensure users are unique
username = form.username.data
username = re.sub(r'[\!\@\#\$\%\^\&\*\-_=\+\?<>,\.\"\':;\{\}\[\]|\\~\/`]', '', username)
try:
user = Key("User", lower(username)).get()
except:
user = None
if user is not None:
self.r(form, flashes=flash('That username is taken'))
return
# create the user
try:
user = User(
username=username,
password=pw.gen_hash(form.password.data),
)
user.key = Key("User", lower(user.username))
user.put()
# create a hash with our secret so we know the cookie is legit later
self.generate_sig(user.username)
self.redirect('/?welcome=%s' % user.username)
return
except: # guess something happened eh?
self.r(form, flashes=flash())
return
def register():
form = RegisterForm(request.form)
if not form.validate():
return make_response(jsonify(), 400)
try:
user = create_user(form.username.data,
form.password.data,
form.nickname.data)
except Exception as e:
print(e)
return make_response(jsonify({
'error': str(e),
}), 400)
return make_response(jsonify(), 200)
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
data = dict(form.data)
del data['confirm_password']
del data['create']
user = UserModel.query.filter_by(email=data['email']).first()
if user:
return render_template('register.html',
form=form,
error='User with this email already exists')
new_user = UserModel(**data)
db.session.add(new_user)
db.session.commit()
return redirect(url_for('login'))
return render_template('register.html', form=form)
def register():
"""
用户注册
:return:
"""
if db_utils.get_option('open_user', {}).get('value') != '1':
abort(403)
user_form = RegisterForm()
if user_form.is_submitted():
if not user_form.validate():
return jsonify(
models.Response.fail(code_msg.PARAM_ERROR.get_msg(),
str(user_form.errors)))
utils.verify_code(user_form.verify_code.data)
user = mongo.db.users.find_one({'email': user_form.email.data})
if user:
return jsonify(code_msg.EMAIL_EXIST)
user_dict = {
'is_active':
False,
'coin':
0,
'email':
user_form.email.data,
'username':
user_form.username.data,
'vip':
0,
'reply_count':
0,
'avatar':
url_for('static',
filename='images/avatar/' + str(randint(0, 12)) + '.jpg'),
'password':
generate_password_hash(user_form.password.data),
'create_time':
datetime.utcnow(),
}
mongo.db.users.insert_one(user_dict)
send_active_email(user['username'], user['_id'], user['email'])
return jsonify(
code_msg.REGISTER_SUCCESS.put('action', url_for('user.login')))
verify_code = utils.generate_verify_code()
session['verify_code'] = verify_code['answer']
return render_template('user/register.html',
verify_code=verify_code['question'],
form=user_form)
def post_register(self):
form = RegisterForm(self.request.POST)
if not form.validate():
self.session.add_flash(form.errors, key='register_errors')
return self.redirect('/')
if User.exists(form.username.data):
self.session.add_flash(
{'username': ['User with this username exists.']},
key='register_errors')
return self.redirect('/')
user = User.new(form.username.data, form.password.data, form.race.data)
user.put()
self.start_user_session(user)
return self.redirect('/game/')
def register():
#logger.info('info log')
#logger.debug('debug log')
#logger.warning('warning log')
#logger.error('error log')
#logger.critical('critical')
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate(): #如果一个人重复提交多个send邮件则不行
user = User()
user.email = form.email.data
user.username = form.username.data
user.password = form.password.data
db.session.add(user)
logger.info(f'{user.username} registration success.')
flash('User registered successfully.', 'alert-success')
return redirect(url_for('auth.login'))
return render_template('register.html', form=form)
def route_register():
form = RegisterForm(request.form)
print(form.errors)
if request.method == 'POST':
login = request.form['login']
key = request.form['key']
print(login)
print(key)
if form.validate():
flash('Hello ' + login)
else:
flash('All the form fields are required. ')
return render_template("register.html",
title="EPYTODO register",
menu_url="http://127.0.0.1:5000/signin",
menu="signin",
myContent="register a new user",
form=form)
def post_register(self):
form = RegisterForm(self.request.POST)
if not form.validate():
self.session.add_flash(form.errors, key='register_errors')
return self.redirect('/')
if User.exists(form.username.data):
self.session.add_flash({
'username': ['User with this username exists.']
}, key='register_errors')
return self.redirect('/')
user = User.new(form.username.data,
form.password.data,
form.race.data)
user.put()
self.start_user_session(user)
return self.redirect('/game/')
def register():
form = RegisterForm()
if request.method == 'POST' and form.validate():
user = User.objects(email=form.email.data).first()
if user is None:
password_hash = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
new_user = User(
username=form.username.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
email=form.email.data,
password=password_hash,
).save()
login_user(new_user)
return redirect(url_for('index'))
else:
flash('El usuario con el correo {} ya existe'.format(
form.email.data))
return render_template('register.html.j2', title='Registrarse', form=form)
def render_register():
form = RegisterForm()
if request.method == 'GET':
return render_template('register.html', form=form)
elif request.method == 'POST':
mail = form.mail.data
username = form.username.data
password = form.password.data
password2 = form.password2.data
if not form.validate():
return render_template('register.html', form=form)
error_messages = []
if password != password2:
error_messages.append('Пароли не совпадают!')
existing_username = User.query.filter_by(username=username).first()
if existing_username:
error_messages.append(
'Пользователь с таким username уже существует!')
existing_mail = User.query.filter_by(mail=mail).first()
if existing_mail:
error_messages.append(
'Пользователь с такой электропочтой уже существует!')
if error_messages:
return render_template('register.html',
form=form,
error_msg=' '.join(error_messages))
user = User(mail=mail,
username=username,
password=password,
role='user')
db.session.add(user)
db.session.commit()
return render_template('register_success.html', username=username)
def user_register():
form = RegisterForm()
login_form = LoginForm()
#print("[+] _______________________[ registering ]")
if request.method == 'POST' and form.validate():
user = User.objects(email=form.email.data).first()
if user is None:
new_user = User(email=form.email.data,
password=form.password.data,
profile=form.profile.data).save()
send_confirmation_email(new_user)
flash('Confirmation email sent to "{0}"'.format(form.email.data))
login_user(new_user)
return redirect(url_for('user_unconfirmed'))
else:
flash('"{}" email has already been registered'.format(
form.email.data))
#print("[+] _______________________[ user not added ]")
return render_template('index.html',
registration_form=form,
login_form=login_form)
return redirect(url_for('index'))
def test_register_form_no_data():
form = RegisterForm(None)
expect(form.validate()).to.be.false()
form = RegisterForm(MultiDict())
expect(form.validate()).to.be.false()
