def test_insert_notification(mock_parse_params):
uid1 = str(uuid4())
uid2 = str(uuid4())
users = [User(uid=uid1).save(), User(uid=uid2).save()]
users = User.objects(uid__in=[uid1, uid2])
notitype = 'InvitationNotification'
params = MagicMock()
notification = utils.insert_notification(users, notitype, params)
u1 = User.objects.get(uid=uid1)
u2 = User.objects.get(uid=uid2)
assert notification in u1.notifications
assert notification in u2.notifications
mock_parse_params.called_once_with(params)
assert notification.inviter_id == 'inviter'
assert notification.task_id == 'task'
with pytest.raises(BadRequest):
users = MagicMock()
users.update.side_effect = Exception('General Exception')
utils.insert_notification(users, notitype, params)
with pytest.raises(BadRequest):
mock_parse_params.return_value = {}
utils.insert_notification(users, notitype, params)
with pytest.raises(BadRequest):
utils.insert_notification(users, 'whatever', params)
def test_favorites_retrieved(self):
user = User(**self.user)
user.save()
user2 = User('Another', 'another', '*****@*****.**', 'secret')
user2.save()
post1 = Post(**self.post, owner_id=user.id)
post1.favorited_by = [user, user2]
post1.save()
post2 = Post(**self.post, owner_id=user.id)
post2.favorited_by = [user2]
post2.save()
post3 = Post(**self.post, owner_id=user.id)
post3.favorited_by = [user]
post3.save()
post5 = Post(**self.post, owner_id=user.id)
post5.save()
res = self.client.get(f'/@{user.username}/favorites')
data = res.json
authors = [post['author']['id'] for post in data]
posts_ids = [post['id'] for post in data]
self.assertEqual(res.status_code, 200)
self.assertEqual(len(data), 2)
self.assertEqual(authors, [user.id] * 2)
self.assertEqual(posts_ids, [post3.id, post1.id])
def test_add(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(), [])
def test_follow_posts(self):
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
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()
u1.follow(u2)
u1.follow(u4)
u2.follow(u3)
u3.follow(u4)
db.session.commit()
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 setUp(self):
self.app = app.test_client()
user1 = User(name="Name", surname="Surname", password="******", username="******")
user2 = User(name="Ім'я", surname="Прізвище", password="******", username="******")
db.session.add(user1)
db.session.add(user2)
db.session.commit()
self.users_data = [(user1.username, user1.password), (user2.username, user2.password)]
def test_create_duplicate_user(user_dict):
""" the database should not let us insert duplicate phone numbers
"""
user1 = User(**user_dict)
user2 = User(**user_dict)
with pytest.raises(sa.exc.IntegrityError):
with db_session() as session:
session.add(user1)
session.commit()
session.add(user2)
session.commit()
session.delete(user1)
session.delete(user2)
def test_post_unauthorized_delete(self):
user = User(**self.user)
user.save()
user2 = User('Another', 'another', '*****@*****.**', 'secret')
user2.save()
post = Post(**self.post, owner_id=user.id)
post.save()
res = self.authorized_delete(f"/posts/{post.id}", user2)
self.assertEqual(res.status_code, 403)
self.assertEqual(res.json['message'], 'Permission denied')
def add_users():
admin = Role.query.filter_by(name="administrator").first()
employee = Role.query.filter_by(name="employee").first()
reviewer = Role.query.filter_by(name="reviewer").first()
manager = Role.query.filter_by(name="manager").first()
u1 = User(
username="******",
email="*****@*****.**",
full_name="Boris Ivanovich Grishenko",
company="GE Siberia",
role_id=admin.id,
)
u2 = User(
username="******",
email="*****@*****.**",
full_name="Grover Cleveland",
company="Sesame Street",
role_id=employee.id,
)
u3 = User(
username="******",
email="*****@*****.**",
full_name="Ernie Kovacs",
company="Sesame Street",
role_id=employee.id,
)
u4 = User(
username="******",
email="*****@*****.**",
full_name="Bert Reynolds",
company="Sesame Street",
role_id=reviewer.id,
)
u5 = User(
username="******",
email="*****@*****.**",
full_name="Kermit Ruffins",
company="Sesame Street",
role_id=manager.id,
)
u1.password = "******"
u2.password = "******"
u3.password = "******"
u4.password = "******"
u5.password = "******"
db.session.add_all([u1, u2, u3, u4, u5])
db.session.commit()
def register():
'''Register a new user'''
headers = {'Content-Type': 'application/json'}
request_data = request.get_json()
# print(request_data)
body = {
'provider': 'email',
'data': {
'email': request_data['email'],
'password': request_data['password']
}
}
# print(body)
auth_url = 'https://auth.{}.hasura-app.io/v1/signup'.format(CLUSTER_NAME)
auth_response = requests.post(auth_url, data=json.dumps(body), headers=headers).json()
print(auth_response)
if 'hasura_id' not in auth_response:
return 'Something went wrong', 400
new_user = User(hasura_id=auth_response.get('hasura_id'),
username=request_data['username'],
avatar_file_link=request_data['avatar'])
try:
db.session.add(new_user)
db.session.commit()
except Exception as e:
print(e)
return 'Something went wrong', 400
return 'Successfully registered', 201
def add_or_update_user(name):
"""
Add or update a user and their tweets.
Throw an error if user doesn't exist or is private
"""
try:
twitter_user = TWITTER.get_user(name)
db_user = User.query.get(twitter_user.id) or User(id=twitter_user.id,
name=name)
tweets = twitter_user.timeline(count=200,
exclude_replies=True,
include_rts=False,
since_id=db_user.newest_tweet_id)
if tweets:
db_user.newest_tweet_id = tweets[0].id
for tweet in tweets:
embedding = vectorize_tweet(tweet.text)
db_tweet = Tweet(id=tweet.id, text=tweet.text, embedding=embedding)
db_user.tweets.append(db_tweet)
DB.session.add(db_user)
DB.session.commit()
except Exception as e:
print(f'Unable to process user {name}: {str(e)}')
def add_user(self, user: types.User) -> User:
db_user = self.session.query(User).get(user.id)
if db_user is None:
db_user = User(id=user.id)
self.session.add(db_user)
self.session.commit()
return db_user
def setUp(self):
self.app = app.test_client()
user1 = User(name="Name", surname="Surname", password="******", username="******")
user2 = User(name="Ім'я", surname="Прізвище", password="******", username="******")
user3 = User(name="Peter", surname="Peterson", password="******", username="******")
user4 = User(name="John", surname="Johnson", password="******", username="******")
db.session.add(user1)
db.session.add(user2)
db.session.add(user3)
db.session.add(user4)
db.session.commit()
self.users_json = [user1.json(), user2.json(), user3.json(), user4.json()]
def register():
if request.method == 'GET':
session.pop('username', None)
return render_template('register.html', title="register")
name = request.form.get('name')
email = request.form.get('email')
url = hashlib.md5(email.encode('utf-8')).hexdigest()
hobby = request.form.get('hobby')
occupation = request.form.get('occupation')
location = request.form.get('location')
password = request.form.get('password')
user = User.query.filter_by(email=email).first()
if user:
flash(
'the email entered already exists in our databases please choose a different one',
'danger')
return redirect(url_for('users.register'))
items = User(name=name,
email=email,
password=generate_password_hash(password=password,
method='sha256'),
url=url,
hobby=hobby,
location=location,
occupation=occupation)
db.session.add(items)
db.session.commit()
flash(
'you have successfully created your account you can now login to your account',
'success')
return redirect(url_for('users.login'))
def _create_user(cls,
slack_id=None,
username=None,
first_name=None,
real_name=None,
*args,
**kwargs):
session = get_session()
user = User()
if not slack_id:
slack_id = 'U%s' % str(uuid.uuid4())[:6]
user.slack_id = slack_id
if not username:
username = str(uuid.uuid4())[:10]
user.username = username
if not first_name:
first_name = str(uuid.uuid4())[:8]
user.first_name = first_name
if not real_name:
real_name = str(uuid.uuid4())[:8]
user.real_name = real_name
for key, value in kwargs.iteritems():
setattr(user, key, value)
session.add(user)
session.flush()
session.commit()
return user
def post(self):
try:
email = request.data['email'].strip()
password = request.data['password'].strip()
if not password:
response = {
'message': 'Password cannot be empty.'
}
return jsonify(response), 201
user = User.query.filter_by(email=email).first()
if not user:
user = User(email=email, password=password)
user.save()
response = {
'message': 'You registered successfully.'
}
return jsonify(response), 201
else:
response = {
'message': 'User already exist.'
}
return jsonify(response), 409
except AssertionError as e:
response = {
'message': "Invalid email"
}
return jsonify(response), 401
except KeyError:
return jsonify({
"message": "Check payload. email and password are needed"
})
def setUp(self):
self.user_id = 1
self.user_key = "USER_KEY"
self.user_name = "USER_NAME"
self.role_type = 1
self.user = User(self.user_id, self.user_key, self.user_name,
self.role_type)
def signup():
if request.method == 'GET':
form = SignUpForm()
return render_template('signup.html', form=form)
if request.method == 'POST':
form = SignUpForm(request.form)
if form.validate():
# check if user exist and add user
existing_user = User.query.filter(
User.username == form.uname.data
or User.email == form.email.data).all()
if existing_user:
flash("Username or Email Already Existing", 'danger')
return redirect(url_for('auth.signup'))
else:
# add user
new_user = User(username=form.uname.data,
email=form.email.data,
password=generate_password_hash(form.pwd.data))
try:
db.session.add(new_user)
db.session.commit()
flash("User Signed Up", 'success')
return redirect(url_for('auth.login'))
except exc.IntegrityError:
db.session.rollback()
return 500
else:
# form invalidation
flash("Form with invalid Data", category='warning')
return render_template('signup.html', form=form)
def test_getters(self, user_id: int, key: str, name: str, role_type: int):
user = User(user_id, key, name, role_type)
self.assertEqual(user_id, user.user_id)
self.assertEqual(key, user.user_key)
self.assertEqual(name, user.name)
self.assertEqual(role_type, user.roleType)
def setUp(self):
super(TaskTestBase, self).setUp()
self.user = User(name='tester', slack_id='abc123')
self.user.is_service_user = True
self.user.save()
self.yt_creds = Credential(platform=Platform.YOUTUBE,
credentials=json.dumps(
{'access_token': True}),
user_id=self.user.id)
self.yt_creds.save()
self.s_creds = Credential(platform=Platform.SPOTIFY,
credentials=json.dumps(
{'access_token': True}),
user_id=self.user.id)
self.s_creds.save()
self.message_formatter_patcher = patch.object(SlackMessageFormatter,
'post_message',
return_value=True)
self.add_track_results_patcher = patch.object(
SlackMessageFormatter,
'format_add_track_results_message',
return_value={})
self.message_formatter_mock = self.message_formatter_patcher.start()
self.add_track_results_patcher = self.add_track_results_patcher.start()
def user(session):
"""Testable User database table."""
user = User(email='*****@*****.**', password='******')
session.add(user)
session.commit()
return user
def test_resolve_user_url(app):
"""Tests that it resolves a user url"""
with app.test_request_context():
db = get_db()
with db.scoped_session() as session:
session.add(
Block(
blockhash=
"0x2969e88561fac17ca19c1749cb3e614211ba15c8e471be55de47d0b8ca6acf5f",
parenthash="0x0000000000000000000000000000000000000000",
number=16914541,
is_current=True,
))
session.flush()
session.add(
User(
blockhash=
"0x2969e88561fac17ca19c1749cb3e614211ba15c8e471be55de47d0b8ca6acf5f",
is_current=True,
updated_at=datetime.now(),
created_at=datetime.now(),
blocknumber=16914541,
handle="Urbanbankai",
handle_lc="urbanbankai",
user_id=42727,
primary_id=1,
secondary_ids=[2, 3],
))
url = "https://audius.co/urbanbankai"
resolved_url = resolve_url(session, url)
assert resolved_url == "/v1/users/DE677"
def create_admin_user():
new_user = User(name='Administrator',
email='*****@*****.**',
password='******',
role='admin')
db.session.add(new_user)
db.session.commit()
async def exec_cmd(self, **kwargs):
self.karma_dict = kwargs['karma_dict']
self.session = kwargs['session']
await self.client.send_typing(self.channel)
for member in self.message.mentions:
if (member == self.client.user):
await self.client.send_message(
self.channel,
"Leave me out of this, " + self.author.mention)
return
if (member.id not in self.karma_dict):
self.karma_dict[member.id] = [2, 2, 2, 2, 0]
new_user = User(member.id, self.karma_dict[member.id])
self.session.add(new_user)
response = member.display_name + " is "
response += ("{:3.1f}% autistic".format(
self.get_autism_percent(member.id)) if
(self.get_autism_percent(member.id) >=
self.get_normie_percent(member.id)) else
"{:3.1f}% normie".format(
self.get_normie_percent(member.id)))
response += " and " + (
"{:3.1f}% toxic".format(self.get_toxc_percent(member.id)) if
(self.get_toxc_percent(member.id) >= self.get_nice_percent(
member.id)) else "{:3.1f}% nice".format(
self.get_nice_percent(member.id)))
response += " with %d bots." % self.karma_dict[member.id][4]
await self.client.send_message(self.channel, response)
def signup():
if request.method == "GET":
return render("signup.html", title="Зарегистрироваться", error_msg="")
name = request.form["name"]
email = request.form["email"]
password = request.form["password"]
if User.find_one({"email": email}) is not None:
return render(
"signup.html",
title="Зарегистрироваться",
error_msg="Пользователь с таким email уже существует!",
)
confirm_code = generate_confirm_code(email)
user = User(
name=name,
email=email,
password=hash_password(password),
confirm_code=confirm_code,
)
user.commit()
msg = Message(
subject="Подтверждение аккаунта",
sender=config.MAIL_DEFAULT_SENDER,
recipients=[email],
body="Ваша ссылка для подтверждения: "
+ config.APP_URL
+ url_for("auth.confirm", confirm_code=confirm_code)[1:],
)
mail.send(msg)
return render("finishSignup.html", title="Завершение регистрации")
def user(session):
"""
"""
user = User(email='*****@*****.**', password='******')
session.add(user)
session.commit()
return user
def register():
"""Render the form to register a new user.
The function renders the registration form and stores its values
if the current user submitted the form.
"""
from .forms import RegisterForm
form = RegisterForm(request.form)
if form.validate_on_submit():
username = request.form['username']
password = request.form['password1']
app.add_user_and_password(username, password)
logger.info('Created account for ' + username + '.')
if "rememberMe" in request.form:
user = User()
user.id = username
session['username'] = username
session['registrations'] = []
login_user(user, remember=True)
logger.info('Logged ' + username + ' in after account creation.')
return redirect(url_for('home'))
return render_template('signup.html', form=form)
def register():
print("REGSITER NEW USER")
print(request.form, "\n\n")
username = request.form.get('username')
email = request.form.get('email')
passwordRaw = request.form.get('password')
passwordHashed = User.generate_hash(passwordRaw)
rawUser = {
'username': username,
'email': email,
'password': passwordHashed
}
print("what's email?")
print(email, "\n")
userExist = User.query.filter_by(email=email).first()
if (userExist is not None):
abort(400)
else:
user = User(rawUser)
user.save()
newUser = User.query.filter_by(email=email).first()
newUser1 = User.as_dict(newUser)
response['status'] = 201
response['message'] = 'REGISTER SUCCESS'
response['result'] = newUser1
return jsonify(response)
def setup_challenges(session):
block = Block(blockhash="0x1", number=BLOCK_NUMBER)
user = User(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
txhash="xyz",
user_id=1,
is_current=True,
handle="TestHandle",
handle_lc="testhandle",
wallet="0x1",
is_creator=False,
is_verified=False,
name="test_name",
created_at=datetime.now(),
updated_at=datetime.now(),
)
session.add(block)
session.flush()
session.add(user)
session.flush()
session.query(Challenge).filter(Challenge.id == "listen-streak").update({
"active":
True,
"starting_block":
BLOCK_NUMBER
})
def lookup_user_record(update_task, session, entry, block_number, block_timestamp):
event_blockhash = update_task.web3.toHex(entry.blockHash)
event_args = entry["args"]
user_id = event_args._userId
# Check if the userId is in the db
user_exists = session.query(User).filter_by(user_id=event_args._userId).count() > 0
user_record = None # will be set in this if/else
if user_exists:
user_record = (
session.query(User)
.filter(User.user_id == user_id, User.is_current == True)
.first()
)
# expunge the result from sqlalchemy so we can modify it without UPDATE statements being made
# https://stackoverflow.com/questions/28871406/how-to-clone-a-sqlalchemy-db-object-with-new-primary-key
session.expunge(user_record)
make_transient(user_record)
else:
user_record = User(
is_current=True,
user_id=user_id,
created_at=datetime.utcfromtimestamp(block_timestamp)
)
# update these fields regardless of type
user_record.blocknumber = block_number
user_record.blockhash = event_blockhash
return user_record
def submit_token():
data = request.get_json(force=True) or {}
errors = LoginSchema().validate(data)
if errors:
return make_response((errors, 400))
token = data['token']
r = requests.get(ME_URL, headers={'Authorization': f'Bearer {token}'})
if r.status_code != 200:
return make_response((r.json(), r.status_code))
user_data = r.json()
print(f'user data : {user_data}')
if not 'admin' in user_data['roles']:
return make_response(('Not enough priviledges', 403))
user = User.query.filter_by(dgf_id=user_data['id']).first()
if user is None:
print('submit_token > user is none')
new_user = User(first_name=user_data['first_name'],
last_name=user_data['last_name'],
email=user_data['email'],
dgf_id=user_data['id'])
try:
db.session.add(new_user)
db.session.commit()
print('submit_token > add new user')
except Exception as err:
return make_response((err.message, 500))
session['user_id'] = user_data['id']
resp = make_response(('success', 200))
return resp
