UserDeleteView.destroy() - Code Metrics - Inspection of "Use POST instead of DELETE for User delete" - sunscrapers/djoser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 20c8b2...cc843b )

by Piotr

created 2017-10-03 13:13 UTC

UserDeleteView.destroy() A

↳ Parent: UserDeleteView

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	9
rs	9.6666
cc	1

from django.contrib.auth import get_user_model
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
from django.contrib.auth.tokens import default_token_generator


from rest_framework import generics, permissions, status, views

from rest_framework.response import Response

from rest_framework.reverse import reverse


from djoser.conf import settings
from djoser.compat import get_user_email, get_user_email_field_name

from djoser import email, utils, signals
from djoser.compat import NoReverseMatch

User = get_user_model()



class RootView(views.APIView):
    """
    Root endpoint - use one of sub endpoints.
    """
    permission_classes = [permissions.AllowAny]

    def aggregate_djoser_urlpattern_names(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        from djoser.urls import base, authtoken
        urlpattern_names = [pattern.name for pattern in base.urlpatterns]
        urlpattern_names += [pattern.name for pattern in authtoken.urlpatterns]
        urlpattern_names += self._get_jwt_urlpatterns()

        return urlpattern_names

    def get_urls_map(self, request, urlpattern_names, fmt):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        urls_map = {}
        for urlpattern_name in urlpattern_names:
            try:
                url = reverse(urlpattern_name, request=request, format=fmt)
            except NoReverseMatch:
                url = ''
            urls_map[urlpattern_name] = url
        return urls_map

    def get(self, request, fmt=None):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        urlpattern_names = self.aggregate_djoser_urlpattern_names()
        urls_map = self.get_urls_map(request, urlpattern_names, fmt)
        return Response(urls_map)

    def _get_jwt_urlpatterns(self):
class Foo:
    def some_method(self, x, y):
        return x + y;
        try:
            from djoser.urls import jwt
            return [pattern.name for pattern in jwt.urlpatterns]
        except ImportError:
            return []


class UserCreateView(generics.CreateAPIView):
    """

    Use this endpoint to register new user.
    """
    serializer_class = settings.SERIALIZERS.user_registration
    permission_classes = (permissions.AllowAny,)

    def perform_create(self, serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        user = serializer.save()
        signals.user_registered.send(
            sender=self.__class__, user=user, request=self.request
        )

        context = {'user': user}
        to = [get_user_email(user)]

        if settings.SEND_ACTIVATION_EMAIL:
            email.ActivationEmail(self.request, context).send(to)
        elif settings.SEND_CONFIRMATION_EMAIL:
            email.ConfirmationEmail(self.request, context).send(to)


class UserDeleteView(generics.CreateAPIView):
    """
    Use this endpoint to remove actually authenticated user
    """
    serializer_class = settings.SERIALIZERS.user_delete
    permission_classes = (permissions.IsAuthenticated,)

    def get_object(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.request.user

    def post(self, request, *args, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data)
        serializer.is_valid(raise_exception=True)

        utils.logout_user(self.request)
        instance.delete()

        return Response(status=status.HTTP_204_NO_CONTENT)


class TokenCreateView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to obtain user authentication token.
    """
    serializer_class = settings.SERIALIZERS.login
    permission_classes = (
        permissions.AllowAny,
    )

    def _action(self, serializer):
        token = utils.login_user(self.request, serializer.user)
        token_serializer_class = settings.SERIALIZERS.token
        return Response(
            data=token_serializer_class(token).data,
            status=status.HTTP_200_OK,
        )


class TokenDestroyView(views.APIView):
    """
    Use this endpoint to logout user (remove user authentication token).
    """
    permission_classes = (
        permissions.IsAuthenticated,
    )

    def post(self, request):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        utils.logout_user(request)
        return Response(status=status.HTTP_204_NO_CONTENT)


class PasswordResetView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to send email to user with password reset link.
    """
    serializer_class = settings.SERIALIZERS.password_reset
    permission_classes = (
        permissions.AllowAny,
    )

    _users = None

    def _action(self, serializer):
        for user in self.get_users(serializer.data['email']):
            self.send_password_reset_email(user)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def get_users(self, email):
param = 5

class Foo:
    def __init__(self, param):   # "param" would be flagged here
        self.param = param
        if self._users is None:
            email_field_name = get_user_email_field_name(User)
            users = User._default_manager.filter(**{
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
                email_field_name + '__iexact': email
            })
            self._users = [
                u for u in users if u.is_active and u.has_usable_password()
            ]
        return self._users

    def send_password_reset_email(self, user):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        context = {'user': user}
        to = [get_user_email(user)]

        email.PasswordResetEmail(self.request, context).send(to)


class SetPasswordView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to change user password.
    """
    permission_classes = (
        permissions.IsAuthenticated,
    )

    def get_serializer_class(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if settings.SET_PASSWORD_RETYPE:
            return settings.SERIALIZERS.set_password_retype
        return settings.SERIALIZERS.set_password

    def _action(self, serializer):
        self.request.user.set_password(serializer.data['new_password'])
        self.request.user.save()

        if settings.LOGOUT_ON_PASSWORD_CHANGE:
            utils.logout_user(self.request)

        return Response(status=status.HTTP_204_NO_CONTENT)


class PasswordResetConfirmView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to finish reset password process.
    """

    permission_classes = (
        permissions.AllowAny,
    )
    token_generator = default_token_generator

    def get_serializer_class(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if settings.PASSWORD_RESET_CONFIRM_RETYPE:
            return settings.SERIALIZERS.password_reset_confirm_retype
        return settings.SERIALIZERS.password_reset_confirm

    def _action(self, serializer):
class Foo:
    def some_method(self, x, y):
        return x + y;
        serializer.user.set_password(serializer.data['new_password'])
        serializer.user.save()
        return Response(status=status.HTTP_204_NO_CONTENT)


class ActivationView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to activate user account.
    """
    serializer_class = settings.SERIALIZERS.activation
    permission_classes = (
        permissions.AllowAny,
    )
    token_generator = default_token_generator

    def _action(self, serializer):
        user = serializer.user
        user.is_active = True
        user.save()

        signals.user_activated.send(
            sender=self.__class__, user=user, request=self.request
        )

        if settings.SEND_CONFIRMATION_EMAIL:
            context = {'user': user}
            to = [get_user_email(user)]

            email.ConfirmationEmail(self.request, context).send(to)

        return Response(status=status.HTTP_204_NO_CONTENT)


class SetUsernameView(utils.ActionViewMixin, generics.GenericAPIView):
    """
    Use this endpoint to change user username.
    """
    permission_classes = (permissions.IsAuthenticated,)

    def get_serializer_class(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if settings.SET_USERNAME_RETYPE:
            return settings.SERIALIZERS.set_username_retype
        return settings.SERIALIZERS.set_username

    def _action(self, serializer):
        user = self.request.user
        new_username = serializer.data['new_' + User.USERNAME_FIELD]

        setattr(user, User.USERNAME_FIELD, new_username)
        if settings.SEND_ACTIVATION_EMAIL:
            user.is_active = False
            context = {'user': user}
            to = [get_user_email(user)]

            email.ActivationEmail(self.request, context).send(to)
        user.save()

        return Response(status=status.HTTP_204_NO_CONTENT)


class UserView(generics.RetrieveUpdateAPIView):
    """
    Use this endpoint to retrieve/update user.
    """
    model = User
    serializer_class = settings.SERIALIZERS.user
    permission_classes = (permissions.IsAuthenticated,)

    def get_object(self, *args, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.request.user

    def perform_update(self, serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        super(UserView, self).perform_update(serializer)
        user = serializer.instance
        if settings.SEND_ACTIVATION_EMAIL and not user.is_active:
            context = {'user': user}
            to = [get_user_email(user)]

            email.ActivationEmail(self.request, context).send(to)


1			from django.contrib.auth import get_user_model
			0 ignored issues – show Coding Style introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report Unable to import 'django.contrib.auth' Loading history...
2			from django.contrib.auth.tokens import default_token_generator
			0 ignored issues – show introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report Unable to import 'django.contrib.auth.tokens' Loading history...
3
4			from rest_framework import generics, permissions, status, views
			0 ignored issues – show introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report Unable to import 'rest_framework' Loading history...
5			from rest_framework.response import Response
			0 ignored issues – show introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report Unable to import 'rest_framework.response' Loading history...
6			from rest_framework.reverse import reverse
			0 ignored issues – show introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report Unable to import 'rest_framework.reverse' Loading history...
7
8			from djoser.conf import settings
9			from djoser.compat import get_user_email, get_user_email_field_name
10
11			from djoser import email, utils, signals
12			from djoser.compat import NoReverseMatch
13
14			User = get_user_model()
			0 ignored issues – show Coding Style Naming introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report The name `User` does not conform to the constant naming conventions (`(([A-Z_][A-Z0-9_])\|(__.__))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
15
16
17			class RootView(views.APIView):
18			"""
19			Root endpoint - use one of sub endpoints.
20			"""
21			permission_classes = [permissions.AllowAny]
22
23			def aggregate_djoser_urlpattern_names(self):
			0 ignored issues – show Coding Style Naming introduced 2017-09-08 13:29 UTC by Report Bug Copy Issue Report The name `aggregate_djoser_urlpattern_names` does not conform to the method naming conventions (`(([a-z][a-z0-9_]{2,30})\|(_[a-z0-9_]*))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style introduced 2017-09-08 13:29 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
24			from djoser.urls import base, authtoken
25			urlpattern_names = [pattern.name for pattern in base.urlpatterns]
26			urlpattern_names += [pattern.name for pattern in authtoken.urlpatterns]
27			urlpattern_names += self._get_jwt_urlpatterns()
28
29			return urlpattern_names
30
31			def get_urls_map(self, request, urlpattern_names, fmt):
			0 ignored issues – show Coding Style introduced 2017-09-08 13:29 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... Coding Style introduced 2017-09-08 13:29 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
32			urls_map = {}

sunscrapers / djoser

Push — master ( 20c8b2...cc843b )

UserDeleteView.destroy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like