def register():
form = RegisterForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash(_l('Congratulations! you can log with it now!'))
return redirect(url_for('auth.login'))
return render_template("auth/register.html", title='Sign up', form=form)
def test_follow(self):
user1 = User(username='******', email='*****@*****.**')
user2 = User(username='******', email='*****@*****.**')
db.session.add(user1)
db.session.add(user2)
db.session.commit()
self.assertEqual(user1.followed.all(), [])
self.assertEqual(user1.followers.all(), [])
user1.follow(user2)
db.session.commit()
self.assertTrue(user1.is_following(user2))
self.assertEqual(user1.followed.count(), 1)
self.assertEqual(user1.followed.first().username, 'Susan')
self.assertEqual(user2.followers.count(), 1)
self.assertEqual(user2.followers.first().username, 'John')
user1.unfollow(user2)
db.session.commit()
self.assertFalse(user1.is_following(user2))
self.assertEqual(user1.followed.count(), 0)
self.assertEqual(user2.followers.count(), 0)
def register():
if current_user.is_authenticated:
return redirect(url_for('main.dashboard'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash(_('Congratulations, you are now a registered user!'), 'success')
return redirect(url_for('auth.login'))
return render_template('auth/register.html',
title='Registration',
form=form)
def create_user():
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request('must include username, email and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def registration_user(payload):
"""
e.orig.pgcode=='23505' -- UniqueViolation Error
:param payload:
:return: {
'status': 'success' or 'fail',
'message': 'Some message'
}
"""
try:
user = User(username=payload['username'],
email=payload['email'],
password=user_manager.hash_password(payload['password']))
user.roles.append(Role.query.filter_by(name='Author').first())
db.session.add(user)
db.session.commit()
db.session.remove()
return {'status': 'success', 'message': 'You have been registered'}
except IntegrityError as e:
return {
'status':
'fail',
'message':
'User already exists'
if e.orig.pgcode == '23505' else 'Invalid Data'
}
def test_user_create_with_roles():
user = User(username='******',
email='*****@*****.**',
password=user_manager.hash_password('admin_pass'))
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Author'))
db.session.add(user)
db.session.commit()
db.session.remove()
def test_user_create_without_roles():
payload = {
'username': '******',
'email': '*****@*****.**',
'password': '******'
}
resp = User.registration(payload)
assert resp['status'] == 'success'
assert resp['message'] == 'You have been registered'
def reset_password(token):
if current_user.is_authenticated:
return redirect(url_for('main.index'))
user = User.verify_reset_password_token(token)
if not user:
return redirect(url_for('main.index'))
form = ResetPasswordForm()
if form.validate_on_submit():
user.set_password(form.password.data)
db.session.commit()
flash(_l('Your password has been reset.'))
return redirect(url_for('auth.login'))
return render_template('auth/reset_password.html', form=form)
def test_follow(self):
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
self.assertEqual(u1.followed.all(), [])
self.assertEqual(u1.followers.all(), [])
u1.follow(u2)
db.session.commit()
self.assertTrue(u1.is_following(u2))
self.assertEqual(u1.followed.count(), 1)
self.assertEqual(u1.followed.first().username, 'B')
self.assertEqual(u2.followers.count(), 1)
self.assertEqual(u2.followers.first().username, 'A')
u1.unfollow(u2)
db.session.commit()
self.assertFalse(u1.is_following(u2))
self.assertEqual(u1.followed.count(), 0)
self.assertEqual(u2.followers.count(), 0)
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
user = User(username=form.username.data,
email=form.email.data,
password=hashed_password)
db.session.add(user)
db.session.commit()
flash(f'Account created for {form.username.data}!', 'success')
return redirect(url_for('home'))
return render_template('register.html', title='Register', form=form)
def reset_token(token):
if current_user.is_authenticated:
return redirect(url_for('main.home'))
user = User.verify_reset_token(token)
if user is None:
flash('That is an invalid or expired token', 'warning')
return redirect(url_for('users.reset_request'))
form = ResetPasswordForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
user.password = hashed_password
db.session.commit()
flash('Your password has been updated! You are now able to log in',
'success')
return redirect(url_for('users.login'))
return render_template('reset_token.html',
title='Reset Password',
form=form)
def reset_password(token):
if current_user.is_authenticated:
return redirect(url_for('main.dashboard'))
user = User.verify_reset_password_token(token)
if not user:
flash(_('Your token has expired, please restart the process'),
'warning')
return redirect(url_for('main.home'))
form = ResetPasswordForm()
if form.validate_on_submit():
user.set_password(form.new_password.data)
db.session.commit()
flash(_('Your password has been reset'), 'success')
return redirect(url_for('auth.login'))
return render_template('auth/reset_password.html',
title='Reset Password',
form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
#hash and verify p/w
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
#create and adding a new user after p/w hashing and verification
user = User(username=form.username.data,
email=form.email.data,
password=hashed_password)
db.session.add(user)
db.session.commit()
# flash(f'Account created for {form.username.data}!', 'success')
flash('Your account has been created! you are now able to log in',
'success')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def test_avatar(self):
user = User(username='******', email='*****@*****.**')
self.assertEqual(user.avatar(128), ('https://www.gravatar.com/avatar/'
'd4c74594d841139328695756648b6bd6'
'?d=identicon&s=128'))
def test_password_hashing(self):
user = User(username='******')
user.set_password('cat')
self.assertFalse(user.check_password('dog'))
self.assertTrue(user.check_password('cat'))
from base import Session, engine, Base
from blog_app.models import User, Post
Base.metadata.create_all(engine)
session = Session()
admin_user = User('admin', '*****@*****.**', hash('default'))
first_post = Post(body='My First Post Body',
user_id=1,
title='My first Post title')
session.add(admin_user)
session.add(first_post)
session.commit()
session.close()
def verify_token(token):
return User.check_token(token) if token else None
def test_password_hashing(self):
u = User(username='******')
u.set_password('123456')
self.assertFalse(u.check_password('dog'))
self.assertTrue(u.check_password('123456'))
def get_followed(id):
user = User.query.get_or_404(id)
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = User.to_collection_dict(user.followed, page, per_page, 'api.get_followers', id=id)
return jsonify(data)
def test_follow_posts(self):
# create four users
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
now = datetime.utcnow()
p1 = Post(body="post from john",
author=u1,
timestamp=now + timedelta(seconds=1))
p2 = Post(body="post from susan",
author=u2,
timestamp=now + timedelta(seconds=4))
p3 = Post(body="post from mary",
author=u3,
timestamp=now + timedelta(seconds=3))
p4 = Post(body="post from david",
author=u4,
timestamp=now + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u3) # susan follows mary
u3.follow(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def get_users():
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = User.to_collection_dict(User.query, page, per_page, 'api.get_users')
return jsonify(data)
