User.get_group_membership() - Code Metrics - Inspection of "Feature/110 group creation" - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#18)

by Camille

created 2016-01-31 21:24 UTC

User.get_group_membership() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	2.5

Metric	Value
cc	2
dl	0
loc	7
ccs	1
cts	2
cp	0.5
crap	2.5
rs	9.4285

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

from sigma_core.models.group import Group

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
        try:
            mem = self.memberships.get(group=g)
        except GroupMember.DoesNotExist:
            return False
        return mem.is_accepted()

    def can_invite(self, group):
        from sigma_core.models.group_member import GroupMember
        try:
            mem = self.memberships.get(group=group)
        except GroupMember.DoesNotExist:
            return False
        return mem.perm_rank >= group.req_rank_invite

    def can_accept_join_requests(self, group):
        from sigma_core.models.group_member import GroupMember
        try:
            mem = self.memberships.get(group=group)
        except GroupMember.DoesNotExist:
            return False
        return mem.perm_rank >= group.req_rank_accept_join_requests

    def can_modify_group_infos(self, group):
        from sigma_core.models.group_member import GroupMember
        try:
            mem = self.memberships.get(group=group)
        except GroupMember.DoesNotExist:
            return False
        return 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


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

    def has_module_perms(self, app_label):
        return True

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

ProjetSigma / backend

Pull Request — master (#18)

User.get_group_membership() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like