def create_user(userRepository: UserRepository):
abort_if_body_not_found()
body = request.json
new_user = User(body['user_id'], body['name'], ratings=[])
userRepository.add_user(new_user)
return jsonify({new_user.user_id: new_user})
def create_rating(userRepository: UserRepository):
abort_if_body_not_found()
body = request.json
new_rating = UserRating(str(uuid.uuid1()), body['user_id'],
body['domain_id'], body['rating'])
userRepository.add_rating(new_rating)
return jsonify({new_rating.rating_id: new_rating})
def test_create_user(self):
self.user_repository = UserRepository(
storage_adapter=self.adapter_name)
result = self.user_repository.bulk_create(
users=self.fake_users).get_response()
self.assertTrue(result['data']["status"])
self.assertEqual(result["status_code"], 201)
data = {
'status': True,
'users_phones': ['+201111111111', '+202222222222']
}
self.assertDictEqual(result['data'], data)
class GroupRepository(IBaseRepository):
def __init__(self, storage_adapter):
super().__init__(storage_name=storage_adapter)
self.user_repository_dep = UserRepository(
storage_adapter=storage_adapter,
storage_context=self.storage_context)
def create(self, group_instance, *args, **kwargs):
result = ObjectResponse()
if not self.storage_adapter:
result.cls_exception = ExceptionFactory.get_exception(
FailedConnection, 503, "Failed to get storage adapter")
return result
group_data = self.get_instance_dict(group_instance)
response = self.user_repository_dep.bulk_create(users=group_data)
group_data["users"] = response.users_phones
group = self.storage_adapter.insert(
doc_data=group_data, collection=settings.GROUPS_COLLECTION_NAME)
result.response = {
'data': {
'status': True,
'group_id': str(group.inserted_id)
},
'status_code': 201
}
return result
def bulk_create(self, *args, **kwargs):
pass
class TestUpdateFCMTokenRequest(unittest.TestCase):
def setUp(self):
self.fake_request = {"fcm_token": "FCM TOKEN GENERATED"}
self.user_repository = None
self.adapter_name = "MongoDB"
def test_update_user(self):
self.user_repository = UserRepository(storage_adapter=self.adapter_name)
filters = {"phone": "+201111111111"}
result = self.user_repository.update(new_data=self.fake_request, filters=filters).get_response()
self.assertTrue(result['data']["updated"])
self.assertEqual(result["status_code"], 200)
class TestCreateUserRequest(unittest.TestCase):
def setUp(self):
self.fake_users = UserBulkDataModel(users=[
UserDataModel(
name="Test Users 1", phone="+201111111111", fcm_token=""),
UserDataModel(
name="Test Users 2", phone="+202222222222", fcm_token=""),
])
self.user_repository = None
self.adapter_name = "MongoDB"
def test_create_user(self):
self.user_repository = UserRepository(
storage_adapter=self.adapter_name)
result = self.user_repository.bulk_create(
users=self.fake_users).get_response()
self.assertTrue(result['data']["status"])
self.assertEqual(result["status_code"], 201)
data = {
'status': True,
'users_phones': ['+201111111111', '+202222222222']
}
self.assertDictEqual(result['data'], data)
def create(users: UserBulkDataModel):
user_repository = UserRepository(
storage_adapter=settings.MONGO_ADAPTER_NAME)
result = user_repository.bulk_create(users).get_response()
return Response(json.dumps(result["data"]), result["status_code"])
def __init__(self):
self.__userRepository = UserRepository()
class UserService(object):
def __init__(self):
self.__userRepository = UserRepository()
def register(self, email, password, username):
"""
Register the user
:param email:
:param password:
:param username:
:return string:
"""
user = self.__userRepository.get_by_id(email)
if not user:
try:
new_user = User(email, username, bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode("utf-8"))
added_user = self.__userRepository.add(new_user)
auth_token = added_user.encode_auth_token()
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return json.dumps(response_object)
except Exception as e:
response_object = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return json.dumps(response_object)
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return json.dumps(response_object)
def login(self, email, password):
try:
user = self.__userRepository.get_by_id(email)
user = User(user['email'], user['username'], user['password'])
if user and bcrypt.checkpw(password.encode(), user.password.encode()):
auth_token = user.encode_auth_token()
response_object = {
'status': 'success',
'message': 'Successfully logged in.',
'auth_token': auth_token.decode()
}
return json.dumps(response_object)
else:
response_object = {
'status': 'fail',
'message': 'User does not exist.'
}
return json.dumps(response_object)
except Exception as e:
print(e)
response_object = {
'status': 'fail',
'message': 'Try again'
}
return json.dumps(response_object)
def get_user_details(self, auth_header):
if auth_header:
auth_token = auth_header.split(" ")[1]
else:
auth_token = ''
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = self.__userRepository.get_by_id(resp) # resp==email==id
response_object = { # the user-object details go in here
'status': 'success',
'data': {
'email': user.email,
'username': user.username
}
}
return json.dumps(response_object)
response_object = {
'status': 'fail',
'message': resp
}
return json.dumps(response_object)
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return json.dumps(response_object)
def test_update_user(self):
self.user_repository = UserRepository(storage_adapter=self.adapter_name)
filters = {"phone": "+201111111111"}
result = self.user_repository.update(new_data=self.fake_request, filters=filters).get_response()
self.assertTrue(result['data']["updated"])
self.assertEqual(result["status_code"], 200)
def update_user_fcm_token(user: UserUpdateDataModel):
user_repository = UserRepository(storage_adapter=settings.MONGO_ADAPTER_NAME)
new_data = {"fcm_token": user.fcm_token}
filters = {"phone": user.phone}
result = user_repository.update(new_data=new_data, filters=filters).get_response()
return Response(json.dumps(result["data"]), result["status_code"])
def get_user(userRepository: UserRepository, user_id):
return jsonify(userRepository.get_user(user_id))
def __init__(self, storage_adapter):
super().__init__(storage_name=storage_adapter)
self.user_repository_dep = UserRepository(
storage_adapter=storage_adapter,
storage_context=self.storage_context)