User.has_group_admin_perm() - Code Metrics - Inspection of "Custom fields / Validator" - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#16)

unknown

created 2016-01-31 21:39 UTC

User.has_group_admin_perm() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	3.1852

Metric	Value
cc	2
dl	0
loc	7
rs	9.4285
ccs	1
cts	3
cp	0.3333
crap	3.1852

from django.db import models
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
from dry_rest_permissions.generics import allow_staff_or_superuser


class UserManager(BaseUserManager):
    # TODO: Determine whether 'memberships' fields needs to be retrieved every time or not...
    # def get_queryset(self):
    #     return super(UserManager, self).get_queryset().prefetch_related('memberships', 'invited_to_groups')

    def create_user(self, email, lastname, firstname, password=None):
        """
        Creates and saves a User with the given email, lastname, firstname and password
        TODO - Generate a unique username.
        """
        if not email:
            raise ValueError('Users must have an email address')

        # username = email # TODO - Generate unique username

        user = self.model(
            email=self.normalize_email(email),
            lastname=lastname,
            firstname=firstname
        )

        user.set_password(password)
        user.save()
        return user

    def create_superuser(self, email, lastname, firstname, password):
        """
        Creates and saves a superuser with the given email, lastname, firstname and password.
        """
        user = self.create_user(email, lastname, firstname, password)
        user.is_superuser = True
        user.is_staff = True
        user.save()
        return user


class User(AbstractBaseUser):
    """
    User are identified by their email. Lastname and firstname are required.
    """
    email = models.EmailField(max_length=254, unique=True)
    lastname = models.CharField(max_length=255)
    firstname = models.CharField(max_length=128)
    # username = models.CharField(max_length=128, unique=True) # TODO - Add unique username for frontend URLs
    phone = models.CharField(max_length=20, blank=True)

    is_active = models.BooleanField(default=True)
    last_modified = models.DateTimeField(auto_now=True)
    join_date = models.DateTimeField(auto_now_add=True)

    is_superuser = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)

    objects = UserManager()

    invited_to_groups = models.ManyToManyField('Group', blank=True, related_name="invited_users");

    # Related fields:
    #   - memberships (model UserGroup)

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['lastname', 'firstname']

    def __str__(self):
        return self.email

    def get_full_name(self):
        return "{} {}".format(self.lastname, self.firstname)

    def get_short_name(self):
        return self.email

    def is_sigma_admin(self):
        return self.is_staff or self.is_superuser

    def get_group_membership(self, group):
        from sigma_core.models.group_member import GroupMember
        from sigma_core.models.group import Group
        try:
            return self.memberships.get(group=group)
        except GroupMember.DoesNotExist:
            return None

    def is_group_member(self, g):
        from sigma_core.models.group_member import GroupMember
        mem = self.get_group_membership(g)
        return mem is not None and mem.is_accepted()

    def can_invite(self, group):
        from sigma_core.models.group_member import GroupMember
        mem = self.get_group_membership(group)
        return mem is not None and mem.perm_rank >= group.req_rank_invite

    def can_accept_join_requests(self, group):
        from sigma_core.models.group_member import GroupMember
        mem = self.get_group_membership(group)
        return mem is not None and mem.perm_rank >= group.req_rank_accept_join_requests

    def can_modify_group_infos(self, group):
        from sigma_core.models.group_member import GroupMember
        mem = self.get_group_membership(group)
        return mem is not None and mem.perm_rank >= group.req_rank_modify_group_infos

    def has_group_admin_perm(self, group):
        from sigma_core.models.group_member import GroupMember
        from sigma_core.models.group import Group
        if self.is_sigma_admin():
            return True
        mem = self.get_group_membership(group)
        return mem is not None and mem.perm_rank == Group.ADMINISTRATOR_RANK


    ################################################################
    # PERMISSIONS                                                  #
    ################################################################

    # Perms for admin site
    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True
    # End of admin site permissions

    @staticmethod
    def has_read_permission(request):
        """
        Only authenticated users can retrieve an users list.
        """
        return True

    def has_object_read_permission(self, request):
        """
        Only authenticated users can retrieve an user.
        """
        return True

    @staticmethod
    def has_write_permission(request):
        """
        Everybody can edit or create users, but with certain restraints specified in below functions.
        By the way, everybody can change one's password or reset it.
        """
        return True

    @staticmethod
    @allow_staff_or_superuser
    def has_create_permission(request):
        """
        Only Sigma admins can create users.
        """
        return False

    def has_object_write_permission(self, request):
        """
        Nobody has all write permissions on an user (especially, nobody can delete an user).
        """
        return False

    @allow_staff_or_superuser
    def has_object_update_permission(self, request):
        """
        Only Sigma admin and oneself can edit an user.
        """
        return request.user.id == self.id


1		from django.db import models
2		from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
3		from dry_rest_permissions.generics import allow_staff_or_superuser
4
5
6		class UserManager(BaseUserManager):
7		# TODO: Determine whether 'memberships' fields needs to be retrieved every time or not...
8		# def get_queryset(self):
9		# return super(UserManager, self).get_queryset().prefetch_related('memberships', 'invited_to_groups')
10
11		def create_user(self, email, lastname, firstname, password=None):
12		"""
13		Creates and saves a User with the given email, lastname, firstname and password
14		TODO - Generate a unique username.
15		"""
16		if not email:
17		raise ValueError('Users must have an email address')
18
19		# username = email # TODO - Generate unique username
20
21		user = self.model(
22		email=self.normalize_email(email),
23		lastname=lastname,
24		firstname=firstname
25		)
26
27		user.set_password(password)
28		user.save()
29		return user
30
31		def create_superuser(self, email, lastname, firstname, password):
32		"""
33		Creates and saves a superuser with the given email, lastname, firstname and password.
34		"""
35		user = self.create_user(email, lastname, firstname, password)
36		user.is_superuser = True
37		user.is_staff = True
38		user.save()
39		return user
40
41
42		class User(AbstractBaseUser):
43		"""
44		User are identified by their email. Lastname and firstname are required.
45		"""
46		email = models.EmailField(max_length=254, unique=True)
47		lastname = models.CharField(max_length=255)
48		firstname = models.CharField(max_length=128)
49		# username = models.CharField(max_length=128, unique=True) # TODO - Add unique username for frontend URLs
50		phone = models.CharField(max_length=20, blank=True)
51
52		is_active = models.BooleanField(default=True)
53		last_modified = models.DateTimeField(auto_now=True)
54		join_date = models.DateTimeField(auto_now_add=True)
55
56		is_superuser = models.BooleanField(default=False)
57		is_staff = models.BooleanField(default=False)
58
59		objects = UserManager()
60
61		invited_to_groups = models.ManyToManyField('Group', blank=True, related_name="invited_users");
62
63		# Related fields:
64		# - memberships (model UserGroup)
65	1
66		USERNAME_FIELD = 'email'
67		REQUIRED_FIELDS = ['lastname', 'firstname']
68
69		def __str__(self):
70		return self.email
71
72		def get_full_name(self):
73		return "{} {}".format(self.lastname, self.firstname)
74
75		def get_short_name(self):
76		return self.email
77
78		def is_sigma_admin(self):
79		return self.is_staff or self.is_superuser
80
81		def get_group_membership(self, group):
82		from sigma_core.models.group_member import GroupMember
83		from sigma_core.models.group import Group
84	1	try:
85		return self.memberships.get(group=group)
86		except GroupMember.DoesNotExist:
87		return None
88
89		def is_group_member(self, g):
90		from sigma_core.models.group_member import GroupMember
91	1	mem = self.get_group_membership(g)
92		return mem is not None and mem.is_accepted()
93
94		def can_invite(self, group):
95		from sigma_core.models.group_member import GroupMember
96		mem = self.get_group_membership(group)
97		return mem is not None and mem.perm_rank >= group.req_rank_invite
98
99	1	def can_accept_join_requests(self, group):
100		from sigma_core.models.group_member import GroupMember
101		mem = self.get_group_membership(group)
102		return mem is not None and mem.perm_rank >= group.req_rank_accept_join_requests
103
104		def can_modify_group_infos(self, group):
105		from sigma_core.models.group_member import GroupMember
106		mem = self.get_group_membership(group)
107	1	return mem is not None and mem.perm_rank >= group.req_rank_modify_group_infos
108
109		def has_group_admin_perm(self, group):
110		from sigma_core.models.group_member import GroupMember
111		from sigma_core.models.group import Group
112		if self.is_sigma_admin():
113	1	return True
114		mem = self.get_group_membership(group)
115		return mem is not None and mem.perm_rank == Group.ADMINISTRATOR_RANK
116
117
118		################################################################
119		# PERMISSIONS #
120	1	################################################################
121
122		# Perms for admin site
123		def has_perm(self, perm, obj=None):
124		return True
125
126		def has_module_perms(self, app_label):
127		return True
128		# End of admin site permissions
129
130		@staticmethod
131		def has_read_permission(request):
132		"""
133		Only authenticated users can retrieve an users list.
134		"""
135		return True
136
137		def has_object_read_permission(self, request):
138		"""
139		Only authenticated users can retrieve an user.
140		"""
141		return True
142
143		@staticmethod
144		def has_write_permission(request):
145		"""
146		Everybody can edit or create users, but with certain restraints specified in below functions.
147		By the way, everybody can change one's password or reset it.
148		"""
149		return True
150
151		@staticmethod
152		@allow_staff_or_superuser
153		def has_create_permission(request):
154		"""
155		Only Sigma admins can create users.
156		"""
157		return False
158
159		def has_object_write_permission(self, request):
160		"""
161		Nobody has all write permissions on an user (especially, nobody can delete an user).
162		"""
163		return False
164
165		@allow_staff_or_superuser
166		def has_object_update_permission(self, request):
167		"""
168		Only Sigma admin and oneself can edit an user.
169		"""
170		return request.user.id == self.id
171

ProjetSigma / backend

Pull Request — master (#16)

User.has_group_admin_perm() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like