User.is_invited_to_group_id() - Code Metrics - Inspection of "Merge pull request #20 from ProjetSigma/feature/gr..." - ProjetSigma/backend - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d1397a...a78a43 )

unknown

created 2016-02-01 20:40 UTC

User.is_invited_to_group_id() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Metric	Value
cc	1
dl	0
loc	2
rs	10
ccs	1
cts	1
cp	1
crap	1

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
        if self.is_sigma_admin():
            return True
        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

    def is_invited_to_group_id(self, groupId):
        return self.invited_to_groups.filter(pk=groupId).exists()

    ###############
    # 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		if self.is_sigma_admin():
102		return True
103		mem = self.get_group_membership(group)
104		return mem is not None and mem.perm_rank >= group.req_rank_accept_join_requests
105
106		def can_modify_group_infos(self, group):
107	1	from sigma_core.models.group_member import GroupMember
108		mem = self.get_group_membership(group)
109		return mem is not None and mem.perm_rank >= group.req_rank_modify_group_infos
110
111		def has_group_admin_perm(self, group):
112		from sigma_core.models.group_member import GroupMember
113	1	from sigma_core.models.group import Group
114		if self.is_sigma_admin():
115		return True
116		mem = self.get_group_membership(group)
117		return mem is not None and mem.perm_rank == Group.ADMINISTRATOR_RANK
118
119		def is_invited_to_group_id(self, groupId):
120	1	return self.invited_to_groups.filter(pk=groupId).exists()
121
122		###############
123		# Permissions #
124		###############
125
126		# Perms for admin site
127		def has_perm(self, perm, obj=None):
128		return True
129
130		def has_module_perms(self, app_label):
131		return True
132		# End of admin site permissions
133
134		@staticmethod
135		def has_read_permission(request):
136		"""
137		Only authenticated users can retrieve an users list.
138		"""
139		return True
140
141		def has_object_read_permission(self, request):
142		"""
143		Only authenticated users can retrieve an user.
144		"""
145		return True
146
147		@staticmethod
148		def has_write_permission(request):
149		"""
150		Everybody can edit or create users, but with certain restraints specified in below functions.
151		By the way, everybody can change one's password or reset it.
152		"""
153		return True
154
155		@staticmethod
156		@allow_staff_or_superuser
157		def has_create_permission(request):
158		"""
159		Only Sigma admins can create users.
160		"""
161		return False
162
163		def has_object_write_permission(self, request):
164		"""
165		Nobody has all write permissions on an user (especially, nobody can delete an user).
166		"""
167		return False
168
169		@allow_staff_or_superuser
170		def has_object_update_permission(self, request):
171		"""
172		Only Sigma admin and oneself can edit an user.
173		"""
174		return request.user.id == self.id
175

ProjetSigma / backend

Push — master ( d1397a...a78a43 )

User.is_invited_to_group_id() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like