def post(cls, request) -> Response:
"""
Registers a new user
:return: Response dict with the new user's data
"""
data = request.data
login = data['login']
password = hashlib.sha256(data['password'].encode('utf-8')).hexdigest()
profile_name = data['profile_name']
email_address = data['email_address']
email_notifications_mode = data['email_notifications_mode']
try:
existing_user = User.objects.get(login=login)
if existing_user:
return Response('User with this login already exists.',
status=200)
except User.DoesNotExist:
User.create_user(login, password, profile_name, email_address,
email_notifications_mode)
returned_data = dict(
message='You are registered!',
login=login,
profile_name=profile_name,
email_address=email_address,
)
return Response(returned_data, status=200)
def post(cls, request):
"""
Create new user entity using login and password
@param request:
@return: user_id and his login as dict
"""
login: str = request.data['login']
password: str = request.data['password']
user, registered = User.register_new_user(
login=login,
password=password
)
if not registered:
raise AlreadyExistsError(
message="User with this login already exists",
status_code=409,
payload={'field_name': 'login'}
)
return dict(
id=user.id,
login=user.login
)
def process_request(self, request):
auth = request.headers.get('Authorization', '').split()
if not auth:
return None
if len(auth) != 2:
return custom_middleware_exception(AuthTypeInvalid())
auth_type = auth[0]
token = auth[1]
try:
decoded_token = JwtTokenAuth.check_token(auth_type, token)
except AccessTokenInvalid as exc:
return custom_middleware_exception(exc)
user_id = decoded_token['user_id']
if not self.check_token_in_whitelist(user_id, token):
return custom_middleware_exception(AccessTokenInvalid())
try:
user = User.get(id=user_id)
except User.DoesNotExist:
return custom_middleware_exception(AccessTokenInvalid())
setattr(request, 'api_user', user)
return None
def get(cls, request, user_id):
"""
Get user info. Returns email and email_notification_enabled if token valid for user_id. Else returns
"following" info
@param request:
@param user_id: user's id to get info from
@return:
"""
try:
user = User.get(id=user_id)
except User.DoesNotExist:
raise NotFoundError()
followers_num = user.followers.count()
following_num = user.targets.count()
response_dict = user.to_dict()
response_dict['followers_num'] = followers_num
response_dict['following_num'] = following_num
is_my_profile = request.api_user == user
response_dict['is_my_profile'] = is_my_profile
response_dict[
'email'] = user.email if is_my_profile and user.email else None
response_dict[
'email_notifications_enabled'] = user.email_notifications_enabled if is_my_profile else None
response_dict[
'following'] = None if is_my_profile else Follower.is_following_by(
user, request.api_user)
return response_dict
def get(cls,
request: Request) -> Dict[str, Union[List[Dict[str, str]], bool]]:
"""Make response containg a list of users"""
users: QuerySet = User.get_users().values('id', 'login', 'name')
if 'loginSearchString' in request.query_params:
users = users.filter(
login__icontains=request.query_params['loginSearchString'])
if not users:
raise exceptions.NotFoundError(
f"Users with names containing {request.query_params['loginSearchString']} not found"
)
paginator: Paginator = Paginator(users, cls.PAGE_SIZE)
page_number = request.query_params['page']
try:
page: Page = paginator.page(page_number)
except InvalidPage as invalid_page:
raise exceptions.UnprocessableEntityError(
f'Invalid page number: {page_number}') from invalid_page
users_on_page: List[Dict[str, str]] = list(page)
has_next_page: bool = page.has_next()
response: Dict[str, Union[List[Dict[str, str]],
bool]] = dict(users=users_on_page,
hasNextPage=has_next_page)
return response
def check_user_credentials(cls, login, password):
try:
user = User.get(login=login)
except User.DoesNotExist:
raise InvalidCredentialsError()
if not user.check_password(password):
raise InvalidCredentialsError()
return user
def delete(cls, request, user_id, following_user_id) -> Dict:
"""
Unfollow following user who has following_user_id by user with user_id
@param request:
@param user_id:
@param following_user_id:
@return:
"""
if user_id != request.api_user.id:
raise ForbiddenError()
try:
target_user_id = User.get(id=following_user_id)
except User.DoesNotExist:
raise NotFoundError()
Follower.unfollow(target=target_user_id, follower=request.api_user)
return dict()
def get(cls, request, user_id):
"""
Get all followers and following users from this user_id
@param user_id:
@param request:
@return:
"""
try:
user = User.get(id=user_id)
except User.DoesNotExist:
raise NotFoundError()
followers = Follower.get_user_followers(user)
followings = Follower.get_user_following_list(user)
return dict(
user_id=user.id,
followers=[follower.to_dict() for follower in followers],
following=[following.to_dict() for following in followings],
)
def get(cls, request, user_id):
"""
Get paginated pitts feed for user
@param request:
@param user_id:
@return:
"""
user = User.get(id=user_id)
user_followings = Follower.get_user_following_list(user)
user_followings.append(user)
user_pitts_queryset = Pitt.get_users_pitts_queryset(user_followings)
try:
pagination = CursorPagination(user_pitts_queryset, request,
['-created_at'])
except ValueError:
raise ValidationError()
current_page_pitts = [
pitt.to_dict() for pitt in pagination.get_current_page()
]
return pagination.get_paginated_dict(current_page_pitts)
def get(cls, request, user_id):
"""
Get paginated user pitts
@param request:
@param user_id:
@return:
"""
try:
user = User.get(id=user_id)
except User.DoesNotExist:
raise NotFoundError()
user_pitts_queryset = Pitt.get_user_pitts_queryset(user)
try:
pagination = CursorPagination(user_pitts_queryset, request,
['-created_at'])
except ValueError:
raise ValidationError()
current_page_pitts = [
pitt.to_dict() for pitt in pagination.get_current_page()
]
return pagination.get_paginated_dict(current_page_pitts)
def post(cls, request, user_id):
"""
Создание подписки клиентом
:param user_id:
:param request:
:return:
"""
if user_id != request.api_user.id:
raise ForbiddenError()
target_user_id = request.data['following_user_id']
if user_id == target_user_id:
raise NotFoundError()
target_user = User.get(id=target_user_id)
_, created = Follower.follow(target=target_user,
follower=request.api_user)
if not created:
raise AlreadyExistsError()
if target_user.email_notifications_enabled:
cls.notify_target_user(request.api_user, target_user)
return dict()