async def _find_parent_node_by_name(self,
schema: GroupSchema) -> GroupPDModel:
entry = await self.get_obj(name=schema.parent)
if entry is None:
raise DoesNotExist(f"Parent node `{schema.parent}` does't exist")
return await self.get_schema.from_tortoise_orm(entry)
async def get_user_by_id(id: UUID4) -> ChatUser:
"""
Get a specific chat user.
"""
try:
return await ChatUser.get(id=id)
except DoesNotExist as e:
raise DoesNotExist("Chat user was not found.") from e
async def on_post(self, req: Request, resp: Response):
# pylint: disable=C0111
try:
data = await req.media()
login = data["login"]
password = data["password"]
logger.debug("User %s tries to login with password: %s", login, password)
try:
user = await User.get_or_none(login=login, is_verified=True, is_active=True)
if user is None:
logger.debug(
"No user with login found %s. Or not verified or not active",
login,
)
resp.status_code = 401
resp.text = f"User with login {login} not found or wrong password."
return
except Exception as error:
logger.exception("Could not retrieve user object.")
raise DoesNotExist(f"Could not get user {login}") from error
# user = await User.get(login=login)
logger.debug("Got user. Checking password")
if not user.verify_password(password):
logger.debug("Wrong password")
raise BadPassword()
# Remember the date, when the user logged in last
user.last_login_at = datetime.utcnow()
await user.save()
# Create the authentication token.
data = create_bearer_token(user.id, req.state.api.secret_key)
data.send_json(resp)
except BadPassword:
logger.debug("Wrong password")
resp.status_code = 401
resp.text = f"User with login {login} provided wrong password."
except DoesNotExist:
logger.debug("No user found")
resp.status_code = 401
resp.text = f"User with login {login} not found or wrong password."
except KeyError:
resp.status_code = 400
resp.text = "Bad formatted body content. Check the documentation"
except Exception as error: # pylint: disable=broad-except
logger.error("Unexpected error %s", error)
resp.status_code = 500
logger.exception("Unexpected error")
resp.text = str(error)
async def _execute(self) -> MODEL:
instance_list = await self.queryset
if not instance_list:
raise DoesNotExist("Object does not exist")
if len(instance_list) == 1:
return instance_list[0]
raise MultipleObjectsReturned(
"Multiple objects returned, expected exactly one")
async def test_connection_error(mocker):
github_client_mock = mocker.patch.object(GithubClient,
'get_user',
new_callable=AsyncMock)
github_client_mock.return_value = {}
user_mock = mocker.patch.object(User, 'get', new_callable=AsyncMock)
user_mock.side_effect = DoesNotExist()
data_source = GithubDataSource(username='******')
controller = CreateUserFromDataSource(data_source=data_source)
assert await controller.create() is None
async def modify_user_password(user_id: int, new_password: str):
"""
change a user's password
:param user_id: the user's id
:param new_password: the new password
"""
user = await User.filter(id=user_id).first()
if not user:
raise DoesNotExist("user id does not exist")
user.set_password(new_password)
await user.save()
async def auth(request):
if 'email' not in request.json:
return json({'error': 'Must supply email.'}, status=403)
if 'password' not in request.json:
return json({'error': 'Must supply password.'}, status=403)
if len(request.json['password']) < 8:
return json({'error': 'Password too short.'}, status=403)
unsanitized_email = request.json['email']
unsanitized_password = request.json['password']
async with in_transaction() as connection:
user = await User.get_or_none(email=unsanitized_email).using_db(connection)
if user is None:
user = await User.create(name=unsanitized_email, email=unsanitized_email, password_hash=pwd_context.hash(unsanitized_password), using_db=connection)
else:
if not pwd_context.verify(unsanitized_password, user.password_hash):
return json({'error': 'Your email/password combination is incorrect.'}, status=403)
session_id = secrets.token_hex(32)
try:
if 'host_peer_id' not in request.json:
raise DoesNotExist()
unsanitized_peer_id = request.json['host_peer_id']
if await user.hosts.all().get(id=unsanitized_peer_id).update(session_id=session_id) != 1:
raise DoesNotExist()
peer_id = unsanitized_peer_id
except DoesNotExist:
peer_id = rand_string(28)
host = await Host.create(id=peer_id, session_id=session_id, user=user)
data = {
'instance_id': '',
'user_id': user.id,
'session_id': session_id,
'host_peer_id': peer_id,
}
return json(data, status=201)
async def _execute(self) -> List[MODEL]:
instance_list = await self._db.executor_class(
model=self.model,
db=self._db,
prefetch_map=self._prefetch_map,
prefetch_queries=self._prefetch_queries,
).execute_select(self.query, custom_fields=list(self._annotations.keys()))
if self._single:
if len(instance_list) == 1:
return instance_list[0]
if not instance_list:
if self._raise_does_not_exist:
raise DoesNotExist("Object does not exist")
return None # type: ignore
raise MultipleObjectsReturned("Multiple objects returned, expected exactly one")
return instance_list
async def _execute(self):
self.query = self._make_query()
instance_list = await self._db.executor_class(
model=self.model,
db=self._db,
prefetch_map=self._prefetch_map,
prefetch_queries=self._prefetch_queries,
).execute_select(self.query,
custom_fields=list(self._annotations.keys()))
if not instance_list:
if self._get:
raise DoesNotExist('Object does not exist')
if self._single:
return None
return []
elif self._get:
if len(instance_list) > 1:
raise MultipleObjectsReturned(
'Multiple objects returned, expected exactly one')
return instance_list[0]
elif self._single:
return instance_list[0]
return instance_list
