UserActivateSerializer - Code Metrics - Inspection of "[WIP] Version 2.0" - sunscrapers/djoser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#259)

by Piotr

created 2018-01-17 17:37 UTC

UserActivateSerializer A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	8
Duplicated Lines	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
rs	10
wmc	2

1 Method

Rating	Name	Duplication	Size	Complexity
A	validate()	0	5	2

from django.contrib.auth import authenticate, get_user_model
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
from django.contrib.auth.password_validation import validate_password

from django.contrib.auth.tokens import default_token_generator

from django.core import exceptions as django_exceptions


from rest_framework import serializers


from djoser import constants, utils
from djoser.conf import settings

User = get_user_model()



class UserSerializer(serializers.ModelSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    class Meta:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        model = User
        fields = [User._meta.pk.name, User.USERNAME_FIELD]
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
        read_only_fields = [User.USERNAME_FIELD]


class UserCreateSerializer(serializers.ModelSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    password = serializers.CharField(
        style={'input_type': 'password'},
        write_only=True
    )

    default_error_messages = {
        'cannot_create_user': constants.CANNOT_CREATE_USER_ERROR,
    }

    class Meta:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        model = User
        fields = [User.USERNAME_FIELD, User._meta.pk.name, 'password']
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

    def validate(self, attrs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        user = User(**attrs)
        password = attrs.get('password')

        try:
            validate_password(password, user)
        except django_exceptions.ValidationError as e:

            raise serializers.ValidationError({'password': list(e.messages)})

        return attrs


class TokenCreateSerializer(serializers.Serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    password = serializers.CharField(
        required=False, style={'input_type': 'password'}
    )

    default_error_messages = {
        'invalid_credentials': constants.INVALID_CREDENTIALS_ERROR,
        'inactive_account': constants.INACTIVE_ACCOUNT_ERROR,
    }

    def __init__(self, *args, **kwargs):
        super(TokenCreateSerializer, self).__init__(*args, **kwargs)
        self.fields[User.USERNAME_FIELD] = serializers.CharField(
            required=False
        )

    def validate(self, attrs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        attrs['user'] = authenticate(
            username=attrs.get(User.USERNAME_FIELD),
            password=attrs.get('password')
        )

        self._validate_user_exists(attrs['user'])
        self._validate_user_is_active(attrs['user'])
        return attrs

    def _validate_user_exists(self, user):
        if not user:
            self.fail('invalid_credentials')

    def _validate_user_is_active(self, user):
        if not user.is_active:
            self.fail('inactive_account')


class PasswordResetSerializer(serializers.Serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    email = serializers.EmailField()

    default_error_messages = {'email_not_found': constants.EMAIL_NOT_FOUND}

    def validate_email(self, value):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        users = utils.get_users_for_email(value)
        if settings.PASSWORD_RESET_SHOW_EMAIL_NOT_FOUND and not users:
            self.fail('email_not_found')
        else:
            return value


class UidAndTokenSerializer(serializers.Serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    uid = serializers.CharField()
    token = serializers.CharField()

    default_error_messages = {
        'invalid_token': constants.INVALID_TOKEN_ERROR,
        'invalid_uid': constants.INVALID_UID_ERROR,
    }

    def validate(self, attrs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        attrs = super(UidAndTokenSerializer, self).validate(attrs)
        try:
            uid = utils.decode_uid(attrs['uid'])
            user = User.objects.get(pk=uid)
        except (User.DoesNotExist, ValueError, TypeError, OverflowError):
            self.fail('invalid_uid')

        is_token_valid = default_token_generator.check_token(
            user, attrs['token']
        )
        if is_token_valid:
            attrs['user'] = user
            return attrs
        else:
            self.fail('invalid_token')


class UserActivateSerializer(UidAndTokenSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    default_error_messages = {'stale_token': constants.STALE_TOKEN_ERROR}

    def validate(self, attrs):
        attrs = super(UserActivateSerializer, self).validate(attrs)
        if not attrs['user'].is_active:
            return attrs
        raise self.fail('stale_token')


class PasswordSerializer(serializers.Serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    new_password = serializers.CharField(style={'input_type': 'password'})

    def validate(self, attrs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        user = self.context['request'].user or self.user
        assert user is not None

        try:
            validate_password(attrs['new_password'], user)
        except django_exceptions.ValidationError as e:

            raise serializers.ValidationError({
                'new_password': list(e.messages)
            })
        return super(PasswordSerializer, self).validate(attrs)


class PasswordRetypeSerializer(PasswordSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    re_new_password = serializers.CharField(style={'input_type': 'password'})

    default_error_messages = {
        'password_mismatch': constants.PASSWORD_MISMATCH_ERROR,
    }

    def validate(self, attrs):
        attrs = super(PasswordRetypeSerializer, self).validate(attrs)
        if attrs['new_password'] == attrs['re_new_password']:
            return attrs
        else:
            self.fail('password_mismatch')


class CurrentPasswordSerializer(serializers.Serializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    current_password = serializers.CharField(style={'input_type': 'password'})

    default_error_messages = {
        'invalid_password': constants.INVALID_PASSWORD_ERROR,
    }

    def validate_current_password(self, value):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        is_password_valid = self.context['request'].user.check_password(value)
        if is_password_valid:
            return value
        else:
            self.fail('invalid_password')


class SetPasswordSerializer(PasswordSerializer, CurrentPasswordSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    pass


class SetPasswordRetypeSerializer(PasswordRetypeSerializer,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                                  CurrentPasswordSerializer):
    pass


class PasswordResetConfirmSerializer(UidAndTokenSerializer,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                                     PasswordSerializer):
    pass


class PasswordResetConfirmRetypeSerializer(UidAndTokenSerializer,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                                           PasswordRetypeSerializer):
    pass


class UserDeleteSerializer(CurrentPasswordSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    pass


class SetUsernameSerializer(serializers.ModelSerializer,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                            CurrentPasswordSerializer):

    class Meta(object):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        model = User
        fields = (User.USERNAME_FIELD, 'current_password')


class SetUsernameRetypeSerializer(SetUsernameSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    default_error_messages = {
        'username_mismatch': constants.USERNAME_MISMATCH_ERROR.format(
            User.USERNAME_FIELD
        ),
    }

    def __init__(self, *args, **kwargs):
        super(SetUsernameRetypeSerializer, self).__init__(*args, **kwargs)
        self.fields['re_' + User.USERNAME_FIELD] = serializers.CharField()

    def validate(self, attrs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        attrs = super(SetUsernameRetypeSerializer, self).validate(attrs)
        new_username = attrs[User.USERNAME_FIELD]
        if new_username != attrs['re_' + User.USERNAME_FIELD]:
            self.fail('username_mismatch')
        else:
            return attrs


class TokenSerializer(serializers.ModelSerializer):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    auth_token = serializers.CharField(source='key')

    class Meta:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        model = settings.TOKEN_MODEL
        fields = ('auth_token',)


1			from django.contrib.auth import authenticate, 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.password_validation import validate_password
			0 ignored issues – show introduced 2017-10-13 18:17 UTC by Report Bug Copy Issue Report Unable to import 'django.contrib.auth.password_validation' Loading history...
3			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...
4			from django.core import exceptions as django_exceptions
			0 ignored issues – show introduced 2017-11-03 01:15 UTC by Report Bug Copy Issue Report Unable to import 'django.core' Loading history...
5
6			from rest_framework import serializers
			0 ignored issues – show introduced 2018-01-17 17:38 UTC by Report Bug Copy Issue Report Unable to import 'rest_framework' Loading history...
7
8			from djoser import constants, utils
9			from djoser.conf import settings
10
11			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...
12
13
14			class UserSerializer(serializers.ModelSerializer):
			0 ignored issues – show Coding Style introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report This class 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...
15			class Meta:
			0 ignored issues – show Coding Style introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report This class 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 Old-style class defined. Loading history... Coding Style introduced 2017-08-24 11:14 UTC by Report Bug Copy Issue Report This class has no `__init__` method. Loading history...
16			model = User
17			fields = [User._meta.pk.name, User.USERNAME_FIELD]
			0 ignored issues – show Coding Style Best Practice introduced 2018-01-17 17:38 UTC by Report Bug Copy Issue Report It seems like `_meta` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: 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 Loading history...
18			read_only_fields = [User.USERNAME_FIELD]
19
20
21			class UserCreateSerializer(serializers.ModelSerializer):
			0 ignored issues – show Coding Style introduced 2017-10-13 18:17 UTC by Report Bug Copy Issue Report This class 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...
22			password = serializers.CharField(
23			style={'input_type': 'password'},
24			write_only=True
25			)
26
27			default_error_messages = {
28			'cannot_create_user': constants.CANNOT_CREATE_USER_ERROR,
29			}
30

sunscrapers / djoser

Pull Request — master (#259)

UserActivateSerializer A

Complexity

Size/Duplication

Importance

1 Method

Duplication Side-by-Side

Filter issues like