def get_stat(chat_id, api=None):
user = db.get_user(chat_id)
if user is None or api not in (None, 'twitter', 'vk', 'dvach'):
return
if api is None:
dicts = [
user['data']['twitter']['statistics']['words'],
user['data']['vk']['statistics']['words'],
user['data']['dvach']['statistics']['words'],
]
print(dicts)
sum_dict = dict()
for d in dicts:
for k, v in d.items():
if k in sum_dict:
sum_dict[k] += v
else:
sum_dict[k] = v
else:
sum_dict = user['data'][api]['statistics']
if len(sum_dict) == 0:
return None
top_reversed_keys = sorted(sum_dict, key=sum_dict.get, reverse=True)
if len(top_reversed_keys) > 10:
top_reversed_keys = top_reversed_keys[:10]
return {k: sum_dict[k] for k in top_reversed_keys}
def test_get_user(self):
""" Tests the return of an existing user """
user = db.get_user('homer', '1234')
self.assertEqual(user['name'], 'Homer Simpson')
self.assertEqual(user['email'], '*****@*****.**')
self.assertEqual(user['username'], 'homer')
self.assertEqual(user['password'], '1234')
def delete_user(id):
if id != get_jwt_identity():
return error_response(403)
if db.get_user(id) is None:
return error_response(404)
if db.delete_user(id) is False:
return error_response(400)
return "", 204
def test_delete_user(app):
old_len = len(db.all_users())
user = User(id=0, name="?", password="******")
user = db.add_user(user)
assert user.id > 0
assert db.delete_user(user.id)
assert db.get_user(user.id) == None
assert len(db.all_users()) == old_len
def generate_passcode():
form = PasscodeRequestForm(request.form)
if request.method == 'POST' and form.validate():
# checking account info should ideally happen in form.validate
try:
n = int(form.count.data)
user = db.get_user(form.email.data)
if user is not None:
uid, email, password, hotp_secret, counter = user
else:
raise UserDataNotFoundException(
"No user data was found with the provided email.")
if not pwd_context.verify(form.password.data, password):
raise WrongPasswordException(
"Password does not match the one in the DB.")
except AuthenticationException as e:
flash(
"We\'re sorry. There is no user with the given credentials. Check your email and password."
)
return redirect(url_for('generate_passcode'))
except Exception as e:
app.logger.debug("Exception in generate_passcode: {}".format(e))
flash(
"I\'m sorry. Try again later. Let the adminstrator know about the error: {}"
.format(e))
return redirect(url_for('generate_passcode'))
app.logger.debug(
"Password verified, hotp_secret:{}".format(hotp_secret))
try:
hotp_list = duo.generate_hotp(hotp_secret, current_at=counter, n=n)
db.update_user(uid, counter=counter + n)
except Exception as e:
app.logger.error("Exception while producing new hotp", type(e), e)
flash(
"I\'m sorry. Try again later. Let the adminstrator know about the error: {} {}"
.format(type(e), e))
return redirect(url_for('generate_passcode'))
app.logger.debug(
'We\'ll send an email to {0} with your new passcodes! Received {0} {1} {2} {3} {4}'
.format(form.email.data, form.password.data, form.count.data,
hotp_secret, hotp_list))
app.logger.debug("New counter: {}".format(counter + n))
return render_template('display-passcode.html',
title='Retrieved Passcodes',
hotp_list=hotp_list,
urls={r: url_for(r)
for r in routes})
else:
return render_template('generate-passcode.html',
title='Generate Passcode',
form=form,
urls={r: url_for(r)
for r in routes})
def test_insert_user_db(self):
""" Tests if a user is registered successfully with the right information """
mockuser = self.create_mock_user('Test Name', '*****@*****.**',
'testusername', 'testpassword')
db.insert_user(mockuser)
user = db.get_user('testusername', 'testpassword')
self.assertEqual(user['name'], mockuser['name'])
self.assertEqual(user['email'], mockuser['email'])
self.assertEqual(user['username'], mockuser['username'])
self.assertEqual(user['password'], mockuser['password'])
def test_edit_user_db(self):
""" Tests if a user is edited successfully - Username is homer."""
mockuser = self.create_mock_user('name_changed', 'email_changed',
'username_shouldnt_change',
'password_changed')
db.update_user(mockuser, 1)
user = db.get_user('homer', mockuser['password'])
self.assertEqual(user['name'], mockuser['name'])
self.assertEqual(user['email'], mockuser['email'])
self.assertEqual(user['username'], 'homer')
self.assertEqual(user['password'], mockuser['password'])
def status_handler(username, id):
status = db.get_request_status(username, id)
data = {}
if status == "approved":
fields = db.get_request_fields(username, id)
data = {"status": status, "username": username}
user = db.get_user(username)
for field in fields:
data[field] = user[field]
else:
data = {"status": status}
return jsonify(data)
async def enter_text(message: Message):
text = message.text
if text.startswith("рассылка "):
text = text.replace("рассылка ", "")
users = db.get_user()
await sleep(0.3)
for user in users:
try:
await bot.send_message(chat_id=user[0], text=text)
await sleep(0.3)
except Exception:
pass
await message.answer("Рассылка выполнена!")
def update_user(id):
if id != get_jwt_identity():
return error_response(403)
try:
user = user_schema.loads(request.data)
except ValidationError as err:
return error_response(400, err.messages)
if db.get_user(id) is None:
return error_response(404)
# "id" in request data is optional
if user.id == 0:
user.id = id
# if "id" was provided in request data then it has to match the resource id
if user.id != id:
return error_response(400, "Request data id has to match resource id.")
if not db.update_user(user):
return error_response(400)
response = jsonify(user_schema.dump(user))
return response
def test_update_user(app):
userA = User(id=2, name="new_name", password="******")
assert db.update_user(userA)
userB = db.get_user(2)
assert userA.id == userB.id
assert userA.name == userB.name
def test_find_non_existing_user(app):
user = db.get_user(1000)
assert user == None
def test_find_existing_user(app):
user = db.get_user(1)
assert user != None
assert type(user) is User
assert user.id == 1
def test_user_registered(self):
user_id = 111
username = "******"
storage.register_user(user_id, username)
user = db.get_user(user_id)
self.assertTrue(user is not None)
async def get_users(message: Message):
await message.answer(db.get_user())
def refresh():
user = db.get_user(get_jwt_identity())
if not user:
return error_response(401, "Unknown user.")
access_token = create_access_token(identity=user.id)
return jsonify(access_token=access_token)
def get_user(id):
user = db.get_user(id)
if user is None:
return error_response(404)
return jsonify(user_schema.dump(user))
async def user_login(user: UserLoginSchema = Body(...)):
if get_user(email=user.email, password=user.password):
return signJWT(user.email)
return {
"error": "Wrong login details!"
}
