コード例 #1
0
ファイル: test_user.py プロジェクト: mrjmad/creme_crm
    def test_edit03(self):
        "Logged as regular user."
        user = self.login_not_as_superuser()

        role1 = UserRole(name='Master')
        role1.allowed_apps = ['persons']
        role1.save()
        SetCredentials.objects.create(
            role=role1,
            value=EntityCredentials.VIEW,
            set_type=SetCredentials.ESET_ALL,
        )
        other_user = User.objects.create(username='******', role=role1)

        briareos = Contact.objects.create(
            user=user,
            first_name='Briareos',
            last_name='Hecatonchires',
        )
        self.assertTrue(other_user.has_perm_to_view(briareos))

        url = self._build_edit_url(other_user.id)
        self.assertGET403(url)

        role2 = UserRole.objects.create(name='Slave')
        self.assertPOST403(
            url,
            data={
                'first_name': 'Deunan',
                'last_name': 'Knut',
                'email': '*****@*****.**',
                'role': role2.id,
            },
        )
コード例 #2
0
    def test_actions_not_admin(self):
        with self.assertNumQueries(0):
            field = CreatorModelChoiceField(
                queryset=FakePosition.objects.all())

        role = UserRole(name='CEO')
        role.allowed_apps = ['persons']  # Not admin
        role.save()

        user = get_user_model().objects.create_user(
            username='******',
            first_name='Joe',
            last_name='Average',
            email='*****@*****.**',
        )
        user.role = role

        field.user = user

        render_str = field.widget.render('position', None)
        self.assertIn(_(u'Cannot create'), render_str)

        field.user = None
        #        self.assertFalse(hasattr(field.widget, 'actions'))
        render_str = field.widget.render('position', None)
        self.assertNotIn(_(u'Cannot create'), render_str)
コード例 #3
0
ファイル: test_user.py プロジェクト: mrjmad/creme_crm-2.1
    def test_team_edit01(self):
        self.login()

        role = UserRole(name='Role')
        role.allowed_apps = ['creme_core']
        role.save()
        SetCredentials.objects.create(role=role, value=EntityCredentials.VIEW,
                                      set_type=SetCredentials.ESET_OWN
                                     )

        def create_user(name, email):
            user = User.objects.create_user(username=name, email=email,
                                            first_name=name, last_name='Endou',
                                            password='******',
                                           )
            user.role = role
            user.save()

            return user

        user01 = create_user('Maruo',   '*****@*****.**')
        user02 = create_user('Yokiji',  '*****@*****.**')
        user03 = create_user('Koizumi', '*****@*****.**')

        self.assertGET404(reverse('creme_config__edit_team', args=(user01.id,)))

        teamname = 'Teamee'
        team = self._create_team(teamname, [user01, user02])

        entity = CremeEntity.objects.create(user=team)
        self.assertTrue(user01.has_perm_to_view(entity))
        self.assertTrue(user02.has_perm_to_view(entity))
        self.assertFalse(user03.has_perm_to_view(entity))

        url = reverse('creme_config__edit_team', args=(team.id,))
        self.assertGET200(url)

        teamname += '_edited'
        response = self.client.post(url, follow=True,
                                    data={'username':  teamname,
                                          'teammates': [user02.id, user03.id],
                                        }
                                   )
        self.assertNoFormError(response)

        team = self.refresh(team)
        self.assertEqual(teamname, team.username)

        teammates = team.teammates
        self.assertEqual(2, len(teammates))
        self.assertIn(user02.id, teammates)
        self.assertIn(user03.id, teammates)
        self.assertNotIn(user01.id, teammates)

        # Credentials have been updated ?
        entity = CremeEntity.objects.get(pk=entity.id)
        self.assertFalse(self.refresh(user01).has_perm_to_view(entity))
        self.assertTrue(self.refresh(user02).has_perm_to_view(entity))
        self.assertTrue(self.refresh(user03).has_perm_to_view(entity))
コード例 #4
0
    def test_edit_credentials01(self):
        self.login()

        role = UserRole(name='CEO')
        role.allowed_apps = ['persons']
        role.save()

        creds = SetCredentials.objects.create(
            role=role,
            set_type=SetCredentials.ESET_ALL,
            value=EntityCredentials.VIEW,
        )

        url = reverse('creme_config__edit_role_credentials', args=(creds.id, ))
        response = self.assertGET200(url)
        # self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit_popup.html')
        self.assertTemplateUsed(
            response, 'creme_core/generics/blockform/edit-popup.html')

        context = response.context
        # self.assertEqual(_('Edit credentials for «{role}»').format(role=role),
        self.assertEqual(
            _('Edit credentials for «{role}»').format(role=role),
            context.get('title'))
        self.assertEqual(_('Save the modifications'),
                         context.get('submit_label'))

        with self.assertNoException():
            cred_ctypes = set(context['form'].fields['ctype'].ctypes)

        get_ct = ContentType.objects.get_for_model
        ct_contact = get_ct(Contact)

        self.assertIn(ct_contact, cred_ctypes)
        self.assertIn(get_ct(Organisation), cred_ctypes)
        self.assertNotIn(get_ct(Activity), cred_ctypes)  # App not allowed

        # ---
        response = self.client.post(url,
                                    data={
                                        'can_view': True,
                                        'can_change': True,
                                        'can_delete': True,
                                        'can_link': False,
                                        'can_unlink': False,
                                        'set_type': SetCredentials.ESET_OWN,
                                        'ctype': ct_contact.id,
                                    })
        self.assertNoFormError(response)

        creds = self.refresh(creds)
        self.assertEqual(
            EntityCredentials.VIEW | EntityCredentials.CHANGE
            | EntityCredentials.DELETE, creds.value)
        self.assertEqual(SetCredentials.ESET_OWN, creds.set_type)
        self.assertEqual(ct_contact.id, creds.ctype_id)
コード例 #5
0
    def test_add_credentials01(self):
        user = self.login()

        role = UserRole(name='CEO')
        role.allowed_apps = ['creme_core']
        role.save()

        other_user = User.objects.create(username='******', role=role)
        contact = FakeContact.objects.create(user=user,
                                             first_name='Yuki',
                                             last_name='Kajiura')
        self.assertFalse(other_user.has_perm_to_view(contact))

        self.assertEqual(0, role.credentials.count())

        url = self._build_add_creds_url(role)
        response = self.assertGET200(url)
        # self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit_popup.html')
        self.assertTemplateUsed(
            response, 'creme_core/generics/blockform/edit-popup.html')

        context = response.context
        # self.assertEqual(_('Add credentials to «{role}»').format(role=role),
        self.assertEqual(
            _('Add credentials to «{object}»').format(object=role),
            context.get('title'))
        self.assertEqual(_('Add the credentials'), context.get('submit_label'))

        # ---
        set_type = SetCredentials.ESET_ALL
        response = self.client.post(url,
                                    data={
                                        'can_view': True,
                                        'can_change': False,
                                        'can_delete': False,
                                        'can_link': False,
                                        'can_unlink': False,
                                        'set_type': set_type,
                                        'ctype': '',
                                    })
        self.assertNoFormError(response)

        setcreds = role.credentials.all()
        self.assertEqual(1, len(setcreds))

        creds = setcreds[0]
        self.assertEqual(EntityCredentials.VIEW, creds.value)
        self.assertEqual(set_type, creds.set_type)
        self.assertIsNone(creds.ctype)

        contact = self.refresh(contact)  # Refresh cache
        other_user = self.refresh(other_user)
        self.assertTrue(other_user.has_perm_to_view(contact))
コード例 #6
0
ファイル: test_user.py プロジェクト: mrjmad/creme_crm-2.1
    def test_edit01(self):
        user = self.login()

        role1 = UserRole(name='Master')
        role1.allowed_apps = ['persons']
        role1.save()
        SetCredentials.objects.create(role=role1, value=EntityCredentials.VIEW,
                                      set_type=SetCredentials.ESET_ALL
                                     )
        other_user = User.objects.create(username='******', first_name='??', last_name='??',
                                         email='??', role=role1,
                                        )
        deunan = other_user.linked_contact

        briareos = Contact.objects.create(user=user, first_name='Briareos', last_name='Hecatonchires')
        self.assertTrue(other_user.has_perm_to_view(briareos))

        url = self._build_edit_url(other_user.id)
        response = self.assertGET200(url)
        self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit-popup.html')
        self.assertEqual(_('Edit «{object}»').format(object=other_user),
                         response.context.get('title')
                        )

        # ----
        first_name = 'Deunan'
        last_name  = 'Knut'
        email      = '*****@*****.**'
        role2 = UserRole.objects.create(name='Slave')
        response = self.client.post(url, follow=True,
                                    data={'first_name': first_name,
                                          'last_name':  last_name,
                                          'email':      email,
                                          'role':       role2.id,
                                         }
                                   )
        self.assertNoFormError(response)

        other_user = self.refresh(other_user)
        self.assertEqual(first_name, other_user.first_name)
        self.assertEqual(last_name,  other_user.last_name)
        self.assertEqual(email,      other_user.email)
        self.assertEqual(role2,      other_user.role)
        self.assertFalse(other_user.is_superuser)

        briareos = self.refresh(briareos)  # Refresh cache
        self.assertFalse(other_user.has_perm_to_view(briareos))

        # Contact is synced
        deunan = self.refresh(deunan)
        self.assertEqual(first_name,  deunan.first_name)
        self.assertEqual(last_name,   deunan.last_name)
        self.assertEqual(email,       deunan.email)
コード例 #7
0
ファイル: test_user.py プロジェクト: mrjmad/creme_crm
    def test_create02(self):
        "Not superuser ; special chars in username."
        self.login()

        role = UserRole(name='Mangaka')
        role.allowed_apps = ['persons']
        role.save()

        SetCredentials.objects.create(
            role=role,
            value=EntityCredentials.VIEW,
            set_type=SetCredentials.ESET_ALL,
        )

        orga = Organisation.objects.create(user=self.user,
                                           name='Olympus',
                                           is_managed=True)

        username = '******'
        password = '******'
        first_name = 'Deunan'
        last_name = 'Knut'
        response = self.client.post(
            self.ADD_URL,
            follow=True,
            data={
                'username': username,
                'password_1': password,
                'password_2': password,
                'first_name': first_name,
                'last_name': last_name,
                'email': username,
                'role': role.id,
                'organisation': orga.id,
                'relation': REL_SUB_MANAGES,
            },
        )
        self.assertNoFormError(response)

        user = self.get_object_or_fail(User, username=username)
        self.assertEqual(role, user.role)
        self.assertFalse(user.is_superuser)

        self.assertTrue(user.has_perm_to_view(orga))

        contact = self.get_object_or_fail(Contact,
                                          first_name=first_name,
                                          last_name=last_name)
        self.assertEqual(user, contact.is_user)
        self.assertRelationCount(1, contact, REL_SUB_MANAGES, orga)
コード例 #8
0
ファイル: test_fields.py プロジェクト: mrjmad/creme_crm
    def test_actions_admin(self):
        field = CreatorModelChoiceField(queryset=FakeSector.objects.all())

        role = UserRole(name='CEO')
        role.admin_4_apps = ['creme_core']
        role.save()

        field.user = get_user_model().objects.create(username='******',
                                                     role=role)

        render_str = field.widget.render('sector', None)
        self.assertIn(self.ADD_URL, render_str)
        self.assertIn(str(FakeSector.creation_label), render_str)

        field.user = None
        render_str = field.widget.render('sector', None)
        self.assertNotIn(self.ADD_URL, render_str)
コード例 #9
0
    def test_actions_admin(self):
        field = CreatorModelChoiceField(queryset=FakePosition.objects.all())

        role = UserRole(name='CEO')
        role.admin_4_apps = ['creme_core']
        role.save()

        admin = get_user_model().objects.create(username='******', role=role)
        admin.role = role

        field.user = admin

        render_str = field.widget.render('position', None)
        self.assertIn(self.ADD_URL, render_str)
        self.assertIn(_(u'Create'), render_str)

        field.user = None
        render_str = field.widget.render('position', None)
        self.assertNotIn(self.ADD_URL, render_str)
コード例 #10
0
ファイル: test_fields.py プロジェクト: mrjmad/creme_crm
    def test_actions_admin_no_creatable(self):
        field = CreatorModelChoiceField(queryset=FakePosition.objects.all())

        role = UserRole(name='CEO')
        role.admin_4_apps = ['creme_core']
        role.save()

        field.user = get_user_model().objects.create(username='******',
                                                     role=role)

        render_str = field.widget.render('position', None)
        self.assertNotIn(
            reverse(
                'creme_config__create_instance_from_widget',
                args=('creme_core', 'fake_position'),
            ),
            render_str,
        )
        self.assertNotIn(str(FakePosition.creation_label), render_str)
コード例 #11
0
    def test_add_credentials02(self):
        "Specific CType + ESET_OWN"
        self.login()

        role = UserRole(name='CEO')
        role.allowed_apps = ['persons']
        role.save()

        url = self._build_add_creds_url(role)
        response = self.assertGET200(url)

        with self.assertNoException():
            cred_ctypes = set(response.context['form'].fields['ctype'].ctypes)

        get_ct = ContentType.objects.get_for_model
        ct_contact = get_ct(Contact)

        self.assertIn(ct_contact, cred_ctypes)
        self.assertIn(get_ct(Organisation), cred_ctypes)
        self.assertNotIn(get_ct(Activity), cred_ctypes)  # App not allowed

        set_type = SetCredentials.ESET_OWN
        response = self.client.post(url,
                                    data={
                                        'can_view': True,
                                        'can_change': True,
                                        'can_delete': False,
                                        'can_link': False,
                                        'can_unlink': False,
                                        'set_type': set_type,
                                        'ctype': ct_contact.id,
                                    })
        self.assertNoFormError(response)

        setcreds = role.credentials.all()
        self.assertEqual(1, len(setcreds))

        creds = setcreds[0]
        self.assertEqual(EntityCredentials.VIEW | EntityCredentials.CHANGE,
                         creds.value)
        self.assertEqual(SetCredentials.ESET_OWN, creds.set_type)
        self.assertEqual(ct_contact.id, creds.ctype_id)
コード例 #12
0
    def test_delete_credentials01(self):
        self.login()

        role = UserRole(name='CEO')
        role.allowed_apps = ['persons']
        role.save()

        create_creds = partial(SetCredentials.objects.create,
                               role=role,
                               set_type=SetCredentials.ESET_ALL)
        sc1 = create_creds(value=EntityCredentials.VIEW)
        sc2 = create_creds(value=EntityCredentials.CHANGE)

        url = self.DEL_CREDS_URL
        self.assertGET404(url)
        self.assertPOST404(url)
        self.assertPOST200(url, data={'id': sc1.id})

        self.assertDoesNotExist(sc1)
        self.assertStillExists(sc2)
コード例 #13
0
    def test_add_credentials03(self):
        "Not super-user => error"
        self.login_not_as_superuser()

        role = UserRole(name='CEO')
        role.allowed_apps = ['persons']
        role.save()

        url = self._build_add_creds_url(role)
        self.assertGET403(url)
        self.assertPOST403(url,
                           data={
                               'can_view': True,
                               'can_change': False,
                               'can_delete': False,
                               'can_link': False,
                               'can_unlink': False,
                               'set_type': SetCredentials.ESET_ALL,
                               'ctype': 0,
                           })
コード例 #14
0
ファイル: test_fields.py プロジェクト: mrjmad/creme_crm
def create_user(admin=True):
    role = UserRole(name='Average')
    if admin:
        role.admin_4_apps = ['creme_core']
    else:
        role.allowed_apps = ['creme_core']

    role.save()

    return get_user_model().objects.create(
        username='******',
        first_name='Joe',
        last_name='Average',
        email='*****@*****.**',
        role=role,
    )
コード例 #15
0
 def __init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     self.role = UserRole()
     self.set_cred = SetCredentials()
コード例 #16
0
ファイル: user_role.py プロジェクト: HybirdCorp/creme_crm-2.0
 def __init__(self, *args, **kwargs):
     SessionWizardView.__init__(self, **kwargs)
     self.role = UserRole()