def users_edit(id):
user = User.query.get(id)
form = UserForm(obj=user)
if current_user.subscription:
coupon = Coupon.query \
.filter(Coupon.code == current_user.subscription.coupon).first()
else:
coupon = None
if form.validate_on_submit():
if User.is_last_admin(user, request.form.get('role'),
request.form.get('active')):
flash('You are the last admin, you cannot do that.', 'error')
return redirect(url_for('admin.users'))
form.populate_obj(user)
if not user.username:
user.username = None
user.save()
flash('User has been saved successfully.', 'success')
return redirect(url_for('admin.users'))
return render_template('admin/user/edit.html',
form=form,
user=user,
coupon=coupon)
def login():
form = LoginForm(next=request.args.get('next'))
if form.validate_on_submit():
u = User.find_by_identity(request.form.get('identity'))
if u and u.authenticated(password=request.form.get('password')):
# As you can see remember me is always enabled, this was a design
# decision I made because more often than not users want this
# enabled. This allows for a less complicated login form.
#
# If however you want them to be able to select whether or not they
# should remain logged in then perform the following 3 steps:
# 1) Replace 'True' below with: request.form.get('remember', False)
# 2) Uncomment the 'remember' field in user/forms.py#LoginForm
# 3) Add a checkbox to the login form with the id/name 'remember'
if login_user(u, remember=True):
u.update_activity_tracking(request.remote_addr)
# Handle optionally redirecting to the next URL safely.
next_url = request.form.get('next')
if next_url:
return redirect(safe_next_url(next_url))
return redirect(url_for('create.create_description'))
else:
flash('Identity or password is incorrect.', 'error')
return render_template('user/login.html', form=form)
def users(db):
"""
Create user fixtures. They reset per test.
:param db: Pytest fixture
:return: SQLAlchemy database session
"""
db.session.query(User).delete()
users = [{
'role': 'admin',
'email': '*****@*****.**',
'password': '******'
}, {
'active': False,
'email': '*****@*****.**',
'password': '******'
}]
for user in users:
db.session.add(User(**user))
db.session.commit()
return db
def db(app):
"""
Setup our database, this only gets executed once per session.
:param app: Pytest fixture
:return: SQLAlchemy database session
"""
_db.drop_all()
_db.create_all()
# Create a single user because a lot of tests do not mutate this user.
# It will result in faster tests.
params = {
'role': 'admin',
'email': '*****@*****.**',
'password': '******',
'credits': 100
}
admin = User(**params)
_db.session.add(admin)
_db.session.commit()
return _db
def users(page):
search_form = SearchForm()
bulk_form = BulkDeleteForm()
sort_by = User.sort_by(request.args.get('sort', 'created_on'),
request.args.get('direction', 'desc'))
order_values = '{0} {1}'.format(sort_by[0], sort_by[1])
paginated_users = User.query \
.filter(User.search(request.args.get('q', text('')))) \
.order_by(User.role.asc(), User.payment_id, text(order_values)) \
.paginate(page, 50, True)
return render_template('admin/user/index.html',
form=search_form,
bulk_form=bulk_form,
users=paginated_users)
def test_deliver_password_reset_email(self, token):
""" Deliver a password reset email. """
with mail.record_messages() as outbox:
user = User.find_by_identity('*****@*****.**')
deliver_password_reset_email(user.id, token)
assert len(outbox) == 1
assert token in outbox[0].body
def test_begin_update_credentials_email_change(self):
""" Update credentials but only the e-mail address. """
self.login()
user = {'current_password': '******', 'email': '*****@*****.**'}
response = self.client.post(url_for('user.update_credentials'),
data=user,
follow_redirects=True)
assert_status_with_message(200, response,
'Your sign in settings have been updated.')
old_user = User.find_by_identity('*****@*****.**')
assert old_user is None
new_user = User.find_by_identity('*****@*****.**')
assert new_user is not None
def delete_users(ids):
"""
Delete users and potentially cancel their subscription.
:param ids: List of ids to be deleted
:type ids: list
:return: int
"""
return User.bulk_delete(ids)
def token(db):
"""
Serialize a JWS token.
:param db: Pytest fixture
:return: JWS token
"""
user = User.find_by_identity('*****@*****.**')
return user.serialize_token()
def subscriptions(db):
"""
Create subscription fixtures.
:param db: Pytest fixture
:return: SQLAlchemy database session
"""
subscriber = User.find_by_identity('*****@*****.**')
if subscriber:
subscriber.delete()
db.session.query(Subscription).delete()
params = {
'role': 'admin',
'email': '*****@*****.**',
'name': 'Subby',
'password': '******',
'payment_id': 'cus_000'
}
subscriber = User(**params)
# The account needs to be commit before we can assign a subscription to it.
db.session.add(subscriber)
db.session.commit()
# Create a subscription.
params = {'user_id': subscriber.id, 'plan': 'pro'}
subscription = Subscription(**params)
db.session.add(subscription)
# Create a credit card.
params = {
'user_id': subscriber.id,
'brand': 'Visa',
'last4': '4242',
'exp_date': datetime.date(2015, 6, 1)
}
credit_card = CreditCard(**params)
db.session.add(credit_card)
db.session.commit()
return db
def begin_password_reset():
form = BeginPasswordResetForm()
if form.validate_on_submit():
u = User.initialize_password_reset(request.form.get('identity'))
flash('An email has been sent to {0}.'.format(u.email), 'success')
return redirect(url_for('user.login'))
return render_template('user/begin_password_reset.html', form=form)
def test_login_activity(self, users):
""" Login successfully and update the activity stats. """
user = User.find_by_identity('*****@*****.**')
old_sign_in_count = user.sign_in_count
response = self.login()
new_sign_in_count = user.sign_in_count
assert response.status_code == 200
assert (old_sign_in_count + 1) == new_sign_in_count
def password_reset():
form = PasswordResetForm(reset_token=request.args.get('reset_token'))
if form.validate_on_submit():
u = User.deserialize_token(request.form.get('reset_token'))
if u is None:
flash('Your reset token has expired or was tampered with.',
'error')
return redirect(url_for('user.begin_password_reset'))
form.populate_obj(u)
u.password = User.encrypt_password(request.form.get('password'))
u.save()
if login_user(u):
flash('Your password has been reset.', 'success')
return redirect(url_for('user.settings'))
return render_template('user/password_reset.html', form=form)
def ensure_identity_exists(form, field):
"""
Ensure an identity exists.
:param form: wtforms Instance
:param field: Field being passed in
:return: None
"""
user = User.find_by_identity(field.data)
if not user:
raise ValidationError('Unable to locate account.')
def test_password_reset(self, users, token):
""" Reset successful. """
reset = {'password': '******', 'reset_token': token}
response = self.client.post(url_for('user.password_reset'),
data=reset,
follow_redirects=True)
assert_status_with_message(200, response,
'Your password has been reset.')
admin = User.find_by_identity('*****@*****.**')
assert admin.password != 'newpassword'
def test_klingon_locale(self, users):
""" Klingon locale works successfully. """
user = User.find_by_identity('*****@*****.**')
user.locale = 'kl'
user.save()
self.login()
response = self.client.get(url_for('billing.purchase_coins'))
# Klingon for "Card".
assert_status_with_message(200, response, 'Chaw')
def test_cancel_subscription(self, subscriptions, mock_stripe):
""" User subscription gets cancelled. """
user = User.find_by_identity('*****@*****.**')
params = {'id': user.id}
self.login()
response = self.client.post(url_for('admin.users_cancel_subscription'),
data=params,
follow_redirects=True)
assert_status_with_message(
200, response, 'Subscription has been cancelled for Subby')
assert user.cancelled_subscription_on is not None
def test_invoice_create(self, users, mock_stripe):
""" Successfully create an invoice item. """
user = User.find_by_identity('*****@*****.**')
invoice = Invoice()
invoice.create(user=user,
currency='usd',
amount='4000',
credits=25,
coupon=None,
token='cus_000')
assert user.credits == 45
def test_welcome_with_existing_username(self, users):
""" Create username failure due to username already existing. """
self.login()
u = User.find_by_identity('*****@*****.**')
u.username = '******'
u.save()
user = {'username': '******'}
response = self.client.post(url_for('user.welcome'),
data=user,
follow_redirects=True)
assert_status_with_message(200, response,
'You already picked a username.')
def update_credentials():
form = UpdateCredentialsForm(obj=current_user)
if form.validate_on_submit():
new_password = request.form.get('password', '')
current_user.email = request.form.get('email')
if new_password:
current_user.password = User.encrypt_password(new_password)
current_user.save()
flash('Your sign in settings have been updated.', 'success')
return redirect(url_for('user.settings'))
return render_template('user/update_credentials.html', form=form)
def test_signup(self, users):
""" Signup successfully. """
old_user_count = User.query.count()
user = {'email': '*****@*****.**', 'password': '******'}
response = self.client.post(url_for('user.signup'),
data=user,
follow_redirects=True)
assert_status_with_message(200, response,
'Awesome, thanks for signing up!')
new_user_count = User.query.count()
assert (old_user_count + 1) == new_user_count
new_user = User.find_by_identity('*****@*****.**')
assert new_user.password != 'password'
def users_bulk_delete():
form = BulkDeleteForm()
if form.validate_on_submit():
ids = User.get_bulk_action_ids(request.form.get('scope'),
request.form.getlist('bulk_ids'),
omit_ids=[current_user.id],
query=request.args.get('q', text('')))
# Prevent circular imports.
from perciapp.blueprints.billing.tasks import delete_users
delete_users(ids)
flash('{0} user(s) were scheduled to be deleted.'.format(len(ids)),
'success')
else:
flash('No users were deleted, something went wrong.', 'error')
return redirect(url_for('admin.users'))
def signup():
form = SignupForm()
if form.validate_on_submit():
u = User()
form.populate_obj(u)
u.password = User.encrypt_password(request.form.get('password'))
u.save()
if login_user(u):
flash("Awesome, you're good to go!", 'success')
return redirect(url_for('create.create_description'))
return render_template('user/signup.html', form=form)
def users():
"""
Generate fake users.
"""
app_config = current_app.config
random_emails = []
data = []
click.echo('Working...')
# Ensure we get about 100 unique random emails.
for i in range(0, 99):
random_emails.append(fake.email())
random_emails.append(app_config['SEED_ADMIN_EMAIL'])
random_emails = list(set(random_emails))
while True:
if len(random_emails) == 0:
break
fake_datetime = fake.date_time_between(start_date='-1y',
end_date='now').strftime('%s')
created_on = datetime.utcfromtimestamp(
float(fake_datetime)).strftime('%Y-%m-%dT%H:%M:%S Z')
random_percent = random.random()
if random_percent >= 0.05:
role = 'member'
else:
role = 'admin'
email = random_emails.pop()
random_percent = random.random()
if random_percent >= 0.5:
random_trail = str(int(round((random.random() * 1000))))
username = fake.first_name() + random_trail
last_created_on = created_on
else:
username = None
last_created_on = None
fake_datetime = fake.date_time_between(start_date='-1y',
end_date='now').strftime('%s')
current_sign_in_on = datetime.utcfromtimestamp(
float(fake_datetime)).strftime('%Y-%m-%dT%H:%M:%S Z')
params = {
'created_on': created_on,
'updated_on': created_on,
'role': role,
'email': email,
'username': username,
'password': User.encrypt_password('password'),
'sign_in_count': random.random() * 100,
'credits': 10,
'last_created_on': last_created_on,
'current_sign_in_on': current_sign_in_on,
'current_sign_in_ip': fake.ipv4(),
'last_sign_in_on': current_sign_in_on,
'last_sign_in_ip': fake.ipv4()
}
# Ensure the seeded admin is always an admin with the seeded password.
if email == app_config['SEED_ADMIN_EMAIL']:
password = User.encrypt_password(app_config['SEED_ADMIN_PASSWORD'])
params['role'] = 'admin'
params['password'] = password
data.append(params)
return _bulk_insert(User, data, 'users')
def bulkprocess():
from perciapp.blueprints.user.models import User
data = request.get_json()
print('bulk POST request received:')
print()
print(data)
print()
title = data['title']
gender = data['gender']
category = data['category']
subcategory = data['subcategory']
detail1 = data['detail1']
detail2 = data['detail2']
detail3 = data['detail3']
detail4 = data['detail4']
detail5 = data['detail5']
user = User.find_by_identity('*****@*****.**')
params = {
'user_id': user.id,
'title': title,
'gender': gender,
'category': category,
'subcategory': subcategory,
'detail1': detail1,
'detail2': detail2,
'detail3': detail3,
'detail4': detail4,
'detail5': detail5,
'description': 'coming soon'
}
create = Create(**params)
create.save_and_update_user(user)
firsts = [
'sent1', 'sent1_2', 'sent1_3', 'sent1_4', 'sent1_5', 'sent1_6',
'sent1_7', 'sent1_8', 'sent1_9', 'sent1_10', 'sent1_11', 'sent1_12',
'sent1_13', 'sent1_14', 'sent1_15'
]
seconds = [
'sent2', 'sent2_2', 'sent2_3', 'sent2_4', 'sent2_5', 'sent2_6',
'sent2_7', 'sent2_8', 'sent2_9', 'sent2_10', 'sent2_11', 'sent2_12',
'sent2_13', 'sent2_14', 'sent2_15'
]
thirds = [
'sent3', 'sent3_2', 'sent3_3', 'sent3_4', 'sent3_5', 'sent3_6',
'sent3_7', 'sent3_8', 'sent3_9', 'sent3_10', 'sent3_11', 'sent3_12',
'sent3_13', 'sent3_14', 'sent3_15'
]
project_id = "perciapp"
topic_id = "description-order"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
for i in firsts:
data = str(create.id)
data = data.encode("utf-8")
future = publisher.publish(topic_path,
data,
label=i,
id=str(create.id))
print(future.result())
topic_id = "description-order-sent-2"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
for i in seconds:
data = str(create.id)
data = data.encode("utf-8")
future = publisher.publish(topic_path,
data,
label=i,
id=str(create.id))
print(future.result())
topic_id = "description-order-sent-3"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
for i in thirds:
data = str(create.id)
data = data.encode("utf-8")
future = publisher.publish(topic_path,
data,
label=i,
id=str(create.id))
print(future.result())
print()
print(f"Published sent_gen messages to {topic_path}.")
print()
#Send edit Pub/Sub message
topic_id = "description-order-edit"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
data = str(create.id)
data = data.encode("utf-8")
future = publisher.publish(topic_path, data)
print(future.result())
print()
print(f"Published edit_sent message to {topic_path}.")
print()
#wait for
import time
start = time.time()
# repeatedly pull description until it has generated
description = Create.query.get(create.id)
output = [description.description]
while output == ['coming soon']:
time.sleep(10)
db.session.commit()
description = Create.query.get(create.id)
output = [description.description]
now = time.time()
print(description.title + ' bulk process waiting:' +
str(int(now - start)))
now = time.time()
if now - start > 300:
break
from flask import jsonify
return jsonify(title=title, description=output), 201