Produits Entr'ouvert » Authentic 2

class OrganizationalUnit(OrganizationalUnitAbstractBase):

    username_is_unique = models.BooleanField(

        blank=True,

        default=False,

        verbose_name=_('Username is unique'))

    email_is_unique = models.BooleanField(

        blank=True,

        default=False,

        verbose_name=_('Email is unique'))

    default = fields.UniqueBooleanField(

        verbose_name=_('Default organizational unit'))

    validate_emails = models.BooleanField(

        blank=True,

        default=False,

        verbose_name=_('Validate emails'))

    automatic_roles = models.ManyToManyField(Role)

    admin_perms = GenericRelation(rbac_utils.get_permission_model_name(),

                                  content_type_field='target_ct',

                                  object_id_field='target_id')

    objects = managers.OrganizationalUnitManager()

    class Meta:

        verbose_name = _('organizational unit')

        verbose_name_plural = _('organizational units')

        ordering = ('name',)

        unique_together = (

            ('name',),

            ('slug',),

        )

    def clean(self):

        # if we set this ou as the default one, we must unset the other one if

        # there is

        if self.default:

            qs = self.__class__.objects.filter(default=True)

            if self.pk:

                qs = qs.exclude(pk=self.pk)

            qs.update(default=None)

        if self.pk and not self.default \

           and self.__class__.objects.get(pk=self.pk).default:

            raise ValidationError(_('You cannot unset this organizational '

                                    'unit as the default, but you can set '

                                    'another one as the default.'))

        super(OrganizationalUnit, self).clean()

    def get_admin_role(self):

        '''Get or create the generic admin role for this organizational

           unit.

        '''

        name = _('Managers of "{ou}"').format(ou=self)

        slug = '_a2-managers-of-{ou.slug}'.format(ou=self)

        return Role.objects.get_admin_role(

            instance=self, name=name, slug=slug, operation=VIEW_OP,

            update_name=True, update_slug=True)

    def delete(self, *args, **kwargs):

        Permission.objects.filter(ou=self).delete()

        return super(OrganizationalUnitAbstractBase, self).delete(*args, **kwargs)

    def natural_key(self):

        return [self.slug]

    @classmethod

    @GlobalCache(timeout=5)

    def cached(cls):

        return cls.objects.all()

    def export_json(self):

        return {

            'uuid': self.uuid, 'slug': self.slug, 'name': self.name,

            'description': self.description, 'default': self.default,

            'email_is_unique': self.email_is_unique,

            'username_is_unique': self.username_is_unique,

            'validate_emails': self.validate_emails

        }

OrganizationalUnit._meta.natural_key = [['uuid'], ['slug'], ['name']]

        qs3 = qs1.model.objects.for_user(user=self)

        qs = (qs1 | qs2 | qs3).order_by('name').distinct()

            roles = Role.object.for_user(self.object)

            User = get_user_model()

        Role = get_role_model()

                if user.roles.filter(pk=role.pk):

                    user.roles.remove(role)

                    hooks.call_hooks('event', name='manager-remove-role-member', user=self.request.user,

                                     role=role, member=user)

                elif role in Role.objects.for_user(user):

                    messages.warning(

                        self.request,

                        _('User {user} has role {role} automatically derived from ou {ou}.')

                        .format(user=user, role=role, ou=user.ou))

        '''Retrieve all permissions held by a user through its role and

        roles.append(user.ou.automatic_roles)

def test_ou_automatic_roles_m2m_changed(db, ou_rando, role_ou1, role_ou2, simple_user):

    simple_user.ou = ou_rando

    simple_user.save()

    assert role_ou1 not in simple_user.roles

    assert role_ou2 not in simple_user.roles

    ou_rando.automatic_roles.add(role_ou1)

    ou_rando.automatic_roles.add(role_ou2)

    assert role_ou1 in simple_user.roles

    assert role_ou2 in simple_user.roles

    ou_rando.automatic_roles.remove(role_ou1)

    assert role_ou1 not in simple_user.roles

    ou_rando.automatic_roles.clear()

    assert role_ou2 not in simple_user.roles

def test_ou_automatic_roles_user_changed(db, user_ou1, user_ou2, role_ou1, role_ou2, ou1, ou2):

    assert ou1.automatic_roles in user_ou1.roles

    user_ou1.ou = ou2

    user_ou1.save()

    assert ou2.automatic_roles in user_ou1.roles

def test_ou_automatic_roles_no_sidefx(db, user_ou1, user_ou2, role_ou1, role_ou2, ou1, ou2):

    assert role_ou1 in user_ou1.roles

    ou1.automatic_roles.add(role1)

    ou1.save()

    ou1.automatic_roles.remove(role1)

    ou1.save()

    assert role_ou1 in user_ou1.roles