def fill_db():
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
u5 = User(username='******', email='*****@*****.**')
users = [u1, u2, u3, u4, u5]
db.session.add_all(users)
db.session.commit()
for u in users:
u.set_password(u.username.lower())
u.last_seen = datetime.utcnow()
u.about_me = f"This is bio of {u.username}"
ci = users.index(u)
u.follow(users[ci-1])
u.follow(users[ci-2])
for i in range(1, 4):
db.session.add(Post(body=f"Port from {u.username} #{i}",
author=u, timestamp=datetime.utcnow()))
db.session.commit()
def test_invalid_confirmation_token(self):
u1 = User(password='******')
u2 = User(password='******')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
token = u1.generate_confirmation_token()
self.assertFalse(u2.confirm(token))
def test_duplicate_email_change_token(self):
u1 = User(email='*****@*****.**', password='******')
u2 = User(email='*****@*****.**', password='******')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
token = u2.generate_email_change_token('*****@*****.**')
self.assertFalse(u2.change_email(token))
self.assertTrue(u2.email == '*****@*****.**')
def oauth_callback_authorize():
if not current_user.is_anonymous:
return redirect(url_for('index'))
oauth = OAuthSignIn.get_provider('facebook')
search_terms = request.args.get('search_terms_to_save', '')
social_id, username, email, is_email_granted = oauth.callback_authorize(
search_terms)
if social_id is None:
flash('Authentication failed.')
return redirect(url_for('index'))
user = User.query.filter_by(social_id=social_id).first()
if not user:
user = User(social_id=social_id, nickname=username, email=email)
try:
db.session.add(user)
db.session.commit()
except exc.SQLAlchemyError:
flash('Something went wrong while adding you as a user. Sorry!')
# TODO log this
return redirect(url_for('index'))
else:
# Update email and nickname upon login to those provided by Facebook.
if email and email != user.email:
update_email_address(email)
if username and username != user.nickname:
update_nickname(username)
login_user(user, True)
return redirect(url_for('index', search_terms_to_save=search_terms))
def test_invalid_reset_token(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
token = u.generate_reset_token()
self.assertFalse(User.reset_password(token + 'a', 'horse'))
self.assertTrue(u.verify_password('cat'))
def post(self, *args, **kwargs):
try:
# pdb.set_trace()
data = request.data
# result = register_schema.dumps(data)
# username=request.json['username']
# result=register_schema.dump(username)
# return jsonify(result)
form = RegistrationForm()
username = form.username.data
email = form.email.data
password = form.password.data
confirm_password = form.confirm_password.data
hashed_password = bcrypt.generate_password_hash(confirm_password)
status = validate_credentials(password, email)
if status:
user = User(username=username, email=email, password=hashed_password)
db.session.add(user)
db.session.commit()
user = User.query.filter_by(email=email).first()
url = os.getenv('Url')
token = TokenGenaration.encode_token(self, user)
short = ShortUrlGenerator.short_url(self, 10)
token = Token(token=token, short=short)
db.session.add(token)
db.session.commit()
# characters=string.digits+string.ascii_letters
# short_url=''.join(choices(characters,k=5))
# link=self.query.filter(short_url=short_url).first()
mail_subject = 'link to activate the account'
msg = Message(mail_subject, sender=email, recipients=[MAIL_USERNAME])
msg.body = f"Click here to activate : {url}/register/{short}"
mail.send(msg)
# status_code = flask.Response(status=200)
# return status_code
# return jsonify(smd, status=200)
return jsonify({'status': True, 'message': 'mail sent for activating account'})
else:
# return Response(
# "The response body goes here",
# status=400,
# )
# return make_response()
# return jsonify({'status': True, 'message': 'Error occured while activating account'})
status_code = flask.Response(status=400)
return status_code
# return render_template('page_not_found.html'), 404
# return jsonify({'message': 'enter valid credentials', }, status=400)
except:
status_code = flask.Response(status=406)
#
return status_code
def register():
body = request.get_json()
data = UserSchema().load(body)
user = User(username=data["username"], email=data["email"])
db.session.add(user)
db.session.commit()
return jsonify('GREAT SUCCESS'), HTTPStatus.CREATED
def test_user_role(self):
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.FOLLOW))
self.assertTrue(u.can(Permission.COMMENT))
self.assertTrue(u.can(Permission.WRITE))
self.assertFalse(u.can(Permission.MODERATE))
self.assertFalse(u.can(Permission.ADMIN))
def test_valid_email_change_token(self):
u = User(email='*****@*****.**', password='******')
db.session.add(u)
db.session.commit()
token = u.generate_email_change_token('*****@*****.**')
self.assertTrue(u.change_email(token))
self.assertTrue(u.email == '*****@*****.**')
def test_expired_confirmation_token(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
token = u.generate_confirmation_token(1)
time.sleep(2)
self.assertFalse(u.confirm(token))
def test_valid_reset_token(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
token = u.generate_reset_token()
self.assertTrue(User.reset_password(token, 'dog'))
self.assertTrue(u.verify_password('dog'))
def register():
if request.method == 'GET':
return render_template('register.html')
else:
# Create user object to insert into SQL
passwd1 = request.form.get('password1')
passwd2 = request.form.get('password2')
if passwd1 != passwd2 or passwd1 == None:
flash('Password Error!', 'danger')
return render_template('register.html')
hashed_pass = sha256_crypt.encrypt(str(passwd1))
new_user = User(username=request.form.get('username'),
email=request.form.get('username'),
password=hashed_pass)
if user_exsists(new_user.username, new_user.email):
flash('User already exsists!', 'danger')
return render_template('register.html')
else:
# Insert new user into SQL
db.session.add(new_user)
db.session.commit()
login_user(new_user)
flash('Account created!', 'success')
return redirect(url_for('index'))
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
msg = Message('Thanks for Registering!',
sender='*****@*****.**',
recipients=[str(form.email.data)])
msg.body = "Hi there! Thanks for registering to Cat Wiki!\n\nYour username is: " + str(
form.username.data
) + "\n\nThank you for using our website, we hope you have an excellent day!"
mail.send(msg)
hashed = bcrypt.generate_password_hash(
form.password.data).decode("utf-8")
user = User(username=form.username.data,
email=form.email.data,
password=hashed)
user.save()
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def test_timestamps(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
self.assertTrue(
(datetime.utcnow() - u.member_since).total_seconds() < 3)
self.assertTrue((datetime.utcnow() - u.last_seen).total_seconds() < 3)
def register():
form = RegisterForm()
if form.validate_on_submit():
if form.invite_key.data != app.config['INVITE_KEY']:
flash('Invalid invite key!', 'danger')
return render_template('register.html', form=form)
# Create user object to insert into SQL
passwd = form.password.data
hashed_pass = sha256_crypt.encrypt(str(passwd))
new_user = User(username=form.name.data,
email=form.email.data,
password=hashed_pass)
if user_exists(new_user.username, new_user.email):
flash('User already exists!', 'danger')
return render_template('register.html', form=form)
else:
# Insert new user into SQL
db.session.add(new_user)
db.session.commit()
login_user(new_user)
flash('Account created!', 'success')
return redirect(url_for('index'))
return render_template('register.html', form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
hashed = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
user = User(username=form.username.data,
email=form.email.data,
password=hashed,
confirmed=False)
db.session.add(user)
db.session.commit()
session['reg_username'] = user.username
token = generate_confirmation_token(form.email.data)
confirm_url = url_for('users.confirm_email', token=token)
html = render_template('confirmation_email.html',
user=user,
confirm_url=confirm_url)
subject = "Welcome to Ask.it!"
send_email(user.email, subject, html)
flash('A confirmation email has been sent via email.', 'success')
return redirect(url_for('users.tfa', user=user))
return render_template('register.html', form=form)
def setUp(self):
db.create_all()
test_user = User(username=self.test_username,
password=bcrypt.generate_password_hash(
self.test_password),
type=self.test_type)
db.session.add(test_user)
db.session.commit()
def test_ping(self):
u = User(password='******')
db.session.add(u)
db.session.commit()
time.sleep(2)
last_seen_before = u.last_seen
u.ping()
self.assertTrue(u.last_seen > last_seen_before)
def test_administrator_role(self):
r = Role.query.filter_by(name='Administrator').first()
u = User(email='*****@*****.**', password='******', role=r)
self.assertTrue(u.can(Permission.FOLLOW))
self.assertTrue(u.can(Permission.COMMENT))
self.assertTrue(u.can(Permission.WRITE))
self.assertTrue(u.can(Permission.MODERATE))
self.assertTrue(u.can(Permission.ADMIN))
def Login():
# create sample user
user = User(
email="*****@*****.**",
password="******",
)
return user
def test_subscriptions(my_app, my_db):
with my_app.app_context():
user = User(username='******', password='******', email='*****@*****.**')
quote = Quote(ticker_name='TEST',
exchange='TEST',
timezone='TEST',
current_price='TEST',
change='TEST',
change_percent='TEST',
last_updated=datetime.now())
user.subscriptions.append(quote)
my_db.session.add(user)
my_db.session.commit()
assert len(Quote.query.all()[0].users) == 1
assert len(User.query.all()[0].subscriptions) == 1
#add another user
user2 = User(username='******',
password='******',
email='*****@*****.**')
user2.subscriptions.append(quote)
my_db.session.add(user2)
my_db.session.commit()
assert len(Quote.query.all()[0].users) == 2
assert len(User.query.all()[1].subscriptions) == 1
#delete user 1 and assert quote object is not deleted
my_db.session.delete(user)
my_db.session.commit()
assert len(Quote.query.all()) == 1
assert len(User.query.all()) == 1
#test deleting subscription
user2.subscriptions.remove(quote)
my_db.session.commit()
#quote has to be manually deleted i think...
assert len(Quote.query.all()[0].users) == 0
assert len(User.query.all()) == 1
#clear db
my_db.drop_all()
def create_user():
# create sample user
user_1 = User(
email="*****@*****.**",
full_name="Danny Devito",
)
user_1.set_password("password")
user_1.save()
return user_1
def register():
if current_user.is_authenticated:
current_app.logger.info(
"User is authenticated. Redirect to main page.")
return redirect(url_for("main.index"))
form = RegistrationForm()
if form.validate_on_submit():
current_app.logger.info(
"POST Request hit at /register and form has been validated")
current_app.logger.info("Hashing password...")
hashed = bcrypt.generate_password_hash(
form.password.data).decode("utf-8")
current_app.logger.info("Creating new user")
user = User(username=form.username.data,
password=hashed,
interest1=form.firstInterest.data,
interest2=form.secondInterest.data,
interest3=form.thirdInterest.data)
current_app.logger.info("Adding new user to database")
db.session.add(user)
db.session.commit()
current_app.logger.info("Getting GIFS for User {user.username}")
firstInterestGIFs = getGIFs(user.interest1)
for url in firstInterestGIFs:
userGIF = UserGIF(link=url, user=user)
db.session.add(userGIF)
secondInterestGIFs = getGIFs(user.interest2)
for url in secondInterestGIFs:
userGIF = UserGIF(link=url, user=user)
db.session.add(userGIF)
thirdInterestGIFs = getGIFs(user.interest3)
for url in thirdInterestGIFs:
userGIF = UserGIF(link=url, user=user)
db.session.add(userGIF)
db.session.commit()
current_app.logger.info(
"User has been added, as well as their GIF Interests. Redirect to login page."
)
#return redirect(url_for("users.login"))
session['reg_username'] = user.username
return redirect(url_for('users.tfa'))
return render_template("register.html", title="Register", form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data, password=form.password.data)
db.session.add(user)
db.session.commit()
flash(f'Account created for {form.username.data} and now you can log in!', 'success')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
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,
created_at=now + timedelta(seconds=1))
p2 = Post(body="post from susan",
author=u2,
created_at=now + timedelta(seconds=4))
p3 = Post(body="post from mary",
author=u3,
created_at=now + timedelta(seconds=3))
p4 = Post(body="post from david",
author=u4,
created_at=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 test_gravatar(self):
u = User(email='*****@*****.**', password='******')
with self.app.test_request_context('/'):
gravatar = u.gravatar()
gravatar_256 = u.gravatar(size=256)
gravatar_pg = u.gravatar(rating='pg')
gravatar_retro = u.gravatar(default='retro')
self.assertTrue('https://secure.gravatar.com/avatar/' +
'd4c74594d841139328695756648b6bd6' in gravatar)
self.assertTrue('s=256' in gravatar_256)
self.assertTrue('r=pg' in gravatar_pg)
self.assertTrue('d=retro' in gravatar_retro)
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = User()
user.username = form.username.data
user.email = form.email.data
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
return redirect('/login')
return render_template('auth/register.html', title='Sign In', form=form)
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.lower(), password=hashed_password)
db.session.add(user)
db.session.commit()
flash(f'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 register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = forms.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(_('You are now registered user'))
return redirect(url_for('auth.login'))
return render_template('auth/register.html', title='Register', form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('search'))
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!')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
