def post(self, request, *args, **kwargs):
data = request.POST
user_service = UserService()
data = dict(
first_name=data['first_name'],
last_name=data['last_name'],
email=data['email'],
age=data['age'],
sex=data['sex'],
)
if user_service.get_user(data['email']) is None:
print('in1')
user = user_service.create_user(data)
if user:
messages.success(request, 'User created successfully')
return redirect(reverse('home'))
else:
return HttpResponseBadRequest()
else:
messages.error(request,
'User {} already exist'.format(data['email']))
return redirect(reverse('home'))
def update_user(username):
"""
Provides logic to retrieve edited details from update user form, and
then insert in database. If password is changed, hashes password
and stores hash. Redirects to list of users after update.
:param username: username=primary key for user in user table
:type username: string
:return: Confirmation message, redirects to user view/search page.
:rtype: flask template
"""
#get current user details in order to retain password if needed
service = UserService()
data = {
'fName': request.form['fname'],
'lName': request.form['lname'],
'email': request.form['email']
}
if request.form["password"] != "":
data["password"] = sha256_crypt.using(rounds=1000).hash(
request.form["password"])
# call user service to send new user value
service.update_user(username, data)
flash(f"successfully updated user: {username}")
return redirect(url_for("users.list_users"))
def add_user():
"""
Provides logic (via POST) to retrieve data entered on the add user
page. Confirms entered username is unique, and prompts for different
username if not. Data is then sent to cloud database to create a new
record in user table.
:return: confirmation message user was added, redirects to main menu
:rtype: flask template
"""
service = UserService()
username = request.form['username']
usernameTaken = service.findExistingUser(username)
if usernameTaken is not None:
flash(f"Username {username} is already taken. Please try again")
return render_template('addUser.html')
else:
password = request.form['password']
pwHash = sha256_crypt.using(rounds=1000).hash(password)
data = {
'username': username,
'password': pwHash,
'fName': request.form['fname'],
'lName': request.form['lname'],
'email': request.form['email']
}
result = service.add_user(data)
if result is not None:
flash(f"Success! User {username} created ")
return render_template('menu.html')
def get(self, request, **kwargs):
user_service = UserService()
user = user_service.delete_user(self.kwargs['email'])
if user:
messages.success(request, 'User {} deleted successfully'.format(self.kwargs['email']))
return redirect(reverse('home'))
else:
return HttpResponseBadRequest()
def patch(self, args, user):
"""Patch user details by id."""
self._check_permission(user)
with api.commit_or_abort(
db.session,
default_error_message=u'Failed to update user details.'):
UserService.update(user, args)
return user
def set_post(info, user_id, placa):
if not UserService.get_user_to_id(user_id):
return "user_error"
vehicle = VehicleService.get_vehicle_to_placa(placa)
if not vehicle:
return "vehicle_error"
name = UserService.get_user_name(user_id)
post = PostUser(info, user_id, name, vehicle['id'], placa)
db.session.add(post)
db.session.commit()
post_schema = PostUserSchema()
return post_schema.dump(post)
class AuthController:
def __init__(self):
self.status = None
self.content = None
self.__errors = []
self.__user_service = UserService()
self.__login_service = LoginService()
def login(self, data, ip):
try:
__email = data.get('email')
__password = data.get('password')
__user = self.__user_service.get_by_email(__email)
if validete(__password, __user.password):
token = create_token(__user.id)
self.content = {'token': token}
self.status = STATUS_CODE['OK']
self.__login_service.save(__user.id, ip)
else:
self.content = {'error': AUTH['LOGIN']}
self.status = STATUS_CODE['BAD_REQUEST']
except Exception as error:
print(e)
self.content = {'error': AUTH['LOGIN']}
self.status = STATUS_CODE['BAD_REQUEST']
def refresh_token(self, user_id):
pass
def _bind(binder):
# Auth
auth_repository = AuthRepository(db)
auth_service = AuthService(auth_repository)
binder.bind(AuthRepository, to=auth_repository, scope=request)
binder.bind(AuthService, to=auth_service, scope=request)
# File
file_repository = FileRepository(db)
file_service = FileService(file_repository)
binder.bind(FileRepository, to=file_repository, scope=request)
binder.bind(FileService, to=file_service, scope=request)
# User
user_repository = UserRepository(db)
user_service = UserService(user_repository)
binder.bind(UserRepository, to=user_repository, scope=request)
binder.bind(UserService, to=user_service, scope=request)
# Tag
tag_repository = TagRepository(db)
binder.bind(TagRepository, to=tag_repository, scope=request)
# Note
note_repository = NoteRepository(db)
note_service = NoteService(note_repository, tag_repository)
binder.bind(NoteRepository, to=note_repository, scope=request)
binder.bind(NoteService, to=note_service, scope=request)
def test_success():
"""
Test if data was inserted into DB
"""
# set user data to be save
email = "*****@*****.**"
user = {
"email": email,
"name": "Pele Zica",
"password": "******",
}
# call function
r_user = UserService.save(user)
# test if data was inserted into database
# Assert if there is only one
query_set = User.objects.raw({"email": email})
assert query_set.count() == 1
# Test if data was inserted correctly
i_user = query_set.first()
i_user = UserResource().dump(i_user)
r_user = UserResource().dump(r_user)
assert i_user == r_user
def login():
KEYS = ("email", "password")
request_data = request.get_json()
for key in KEYS:
if not key in request_data.keys():
message = f"Missing {key.upper()} parameter"
response = make_response(
jsonify({"message": message}),
422,
)
response.headers["Content-Type"] = "application/json"
return response
auth_user = UserService.login_user(request_data["email"],
request_data["password"])
if auth_user:
response = make_response(jsonify(auth_user), 200)
response.headers["Content-Type"] = "application/json"
return response
else:
response = make_response(jsonify({"message": "Invalid credentials"}),
401)
response.headers["Content-Type"] = "application/json"
return response
def test_get_all_users(self):
'''confirm that all users are returned when status code is 200
'''
from app.services.user_service import UserService
with patch.object(UserService, "post", return_value=self.users):
result = UserService().get_all_users()
self.assertEqual(self.users, result)
def signup():
KEYS = ("name", "email", "password", "age")
request_data = request.get_json()
for key in KEYS:
if not key in request_data:
message = f"Missing {key.upper()} parameter"
response = make_response(
jsonify({"message": message}),
422,
)
response.headers["Content-Type"] = "application/json"
return response
registered_user = UserService.register_user(**request_data)
if registered_user == None:
response = make_response(
jsonify({}),
422,
)
response.headers["Content-Type"] = "application/json"
return response
response = make_response(jsonify(registered_user), 200)
response.headers["Content-Type"] = "application/json"
return response
def get_by_alias(alias: str, user_service: UserService):
try:
user = user_service.find_by_alias(alias)
return jsonify({"user": UserVo(user).to_dict()}), 200
except Exception as e:
logger.error(e)
return jsonify({'message': 'Failed ...'}), 500
def test_search_users(self):
'''confirm that search result is returned when status is 200
'''
from app.services.user_service import UserService
with patch.object(UserService, "post", return_value=self.users[:1]):
result = UserService().search_users({"fName": "Stally"})
self.assertEqual(self.users[:1], result)
class ClickHouseUserCollectScheduler:
"""
Периодическое задание для отправки данных в ClickHouse
"""
def __init__(self):
self.topic = app.config.kafka.clickhouse_topics[0]
self.logger = logging.getLogger(__name__)
self.user_service = UserService()
def __produce_data(self):
data = self.user_service.get_user_data()
for item in data:
self.logger.info(f"Готовимся отправить сообщение: {item}")
kafka_producer.send(topic=self.topic, value=item)
kafka_producer.flush()
def get_scheduler(self):
scheduler = BackgroundScheduler()
scheduler.add_job(func=self.__produce_data, trigger="interval",
seconds=app.config.schedulers.clickhouse.interval)
return scheduler
def verify_auth_token(token):
d = _load(current_app.config['SECRET_KEY'], token, salt=g.secret)
if d:
user = UserService.get(d.get('i'), raise_not_found=False)
if user:
return user if user.tick == d.get('t') else None
return None
def test_find_existing_user(self):
'''confirm that username is passed to the right endpoint & user info is returned when status is 200
'''
from app.services.user_service import UserService
with patch.object(UserService, "post", return_value=self.users[:1]):
result = UserService().findExistingUser("Stally")
self.assertEqual(self.users[0], result)
def test_get_activity_types(self):
'''confirm that activity types & counts are returned
'''
from app.services.user_service import UserService
with patch.object(UserService, "get", return_value=self.activities):
result = UserService().get_activity_types()
self.assertEqual(self.activities, result)
def delete_user(user_id):
deleted_character = UserService.delete_user(user_id)
if deleted_character:
response = make_response(jsonify(), 204)
response.headers["Content-Type"] = "application/json"
return response
def create_user():
username = request.json['username']
cpf = request.json['cpf']
email = request.json['email']
password = request.json['password']
user = service.set_user(username, cpf, email, password)
return jsonify(user), 201
def post(self, args):
"""Create a new User."""
with api.commit_or_abort(
db.session,
default_error_message=u"Failed to create a new User."):
new_user = UserService.create(**args)
db.session.add(new_user)
return new_user
def put_user(user_id):
if not request.get_json():
return jsonify("Requisição incompleta"), 400
user = service.put_user(user_id, request.get_json())
if user is False:
abort(403)
if not user:
abort(404)
return jsonify(user), 200
def remove_user(username):
"""
Defines route to remove user: '******'. Removes
user from database and updates user list accordingly.
:param username: username=primary key for user in user table
:type username: string
:return: updated list of users
:rtype: flask template
"""
'''remove user from database and update displays accordingly'''
#pop up window asking for confirmation
service = UserService()
if service.delete_user(username):
return redirect(url_for('users.list_users'))
else:
flash(f"{username} could not be deleted")
return redirect(url_for('users.list_users'))
def test_add_user(self):
'''confirm that success is propagated when status is 200
'''
from app.services.user_service import UserService
new_user = self.users[0]
new_user['username'] = "******"
with patch.object(UserService, "post", return_value={"success": True}):
result = UserService().add_user(new_user)
self.assertTrue(result)
def test_email_already_exists(user_fixture):
"""
Test if user exists already exists in the DB
"""
# define expected message error
expected_msg = "Email already in use."
# set user data to be save
user = {
"email": user_fixture.email,
"name": user_fixture.name,
"password": user_fixture.password,
}
# call the function and test the exception
with pytest.raises(Conflict) as excinfo:
UserService.save(user)
assert expected_msg == str(excinfo.value)
def list_users():
"""
Defines URL/route for displaying users. Retrieves users (stored in
cloud database) and routes to html page: '/users'.
:return: html page to display all users
:rtype: flask template
"""
users = UserService().get_all_users()
return render_template('users.html', users=users)
def test_delete_user(self):
'''confirm that correct user is deleted & success is propagated when status is 200
'''
from app.services.user_service import UserService
with patch.object(UserService,
"delete",
return_value={"success": True}) as mock_del:
result = UserService().delete_user("shiyugun")
self.assertTrue(result)
mock_del.assert_called_with("/users/shiyugun")
def test_update_user(self):
'''confirm that updated values are passed to the right endpoint & success is propagated when status is 200
'''
from app.services.user_service import UserService
new_user_val = self.users[0]
new_user_val.pop("username")
with patch.object(UserService, "put", return_value={"success":
True}) as mock_put:
result = UserService().update_user("shiyugun", new_user_val)
self.assertTrue(result)
mock_put.assert_called_with("/users/shiyugun/update", new_user_val)
def delete(id: str, user_service: UserService, auth_service: AuthService):
try:
auth = auth_service.validate(request.headers["Authorization"])
if not auth:
return jsonify({"message": "Not authorized"}), 401
user = user_service.delete(id)
return jsonify({"user": UserVo(user).to_dict()}), 200
except Exception as e:
logger.error(e)
return jsonify({'message': 'Failed ...'}), 500
def all_users():
found_characters = UserService.find_all_users()
if found_characters:
response = make_response(jsonify(found_characters), 200)
response.headers["Content-Type"] = "application/json"
return response
else:
response = make_response(jsonify([]), 200)
response.headers["Content-Type"] = "application/json"
return response
