Produits Entr'ouvert » Authentic 2

    def rpc(self, request, serializer):

        serializer.user.set_password(serializer.validated_data['new_password'])

        serializer.user.save()

        return {'result': 1}, status.HTTP_200_OK

            if not self.request.user.has_perm(perm):

                raise PermissionDenied(u'You do not have permission %s' % perm)

    def perform_destroy(self, instance):

        self.check_perm('custom_user.delete_user', instance.ou)

        super(UsersAPI, self).perform_destroy(instance)

    class SynchronizationSerializer(serializers.Serializer):

            )

        utils.send_password_reset_mail(user, request=request)

        return Response(status=status.HTTP_204_NO_CONTENT)

    @action(detail=True, methods=['post'], permission_classes=(DjangoPermission('custom_user.change_user'),))

    def perform_destroy(self, instance):

        if not self.request.user.has_perm(perm='a2_rbac.delete_role', obj=instance):

            raise PermissionDenied(u'User %s can\'t create role %s' % (self.request.user, instance))

        super(RolesAPI, self).perform_destroy(instance)

class RolesMembersAPI(UsersAPI):

    def initial(self, request, *args, **kwargs):

        if not request.user.has_perm('a2_rbac.manage_members_role', obj=self.role):

            raise PermissionDenied(u'User not allowed to manage role members')

        self.role.members.add(self.member)

        return Response(

            {'result': 1, 'detail': _('User successfully added to role')}, status=status.HTTP_201_CREATED

        )

        if not request.user.has_perm('a2_rbac.manage_members_role', obj=self.role):

            raise PermissionDenied(u'User not allowed to manage role members')

        self.role.members.remove(self.member)

        return Response(

            {'result': 1, 'detail': _('User successfully removed from role')}, status=status.HTTP_200_OK

        )

        Role = get_role_model()

        User = get_user_model()

        self.role = get_object_or_404(Role, uuid=kwargs['role_uuid'])

        perm = 'a2_rbac.manage_members_role'

        authorized = request.user.has_perm(perm, obj=self.role)

                    _("Missing 'uuid' key for dict entry %s " "of the 'data' payload") % entry

                )

            try:

            except User.DoesNotExist:

                raise ValidationError(_('No known user for UUID %s') % entry['uuid'])

    def post(self, request, *args, **kwargs):

        self.role.members.add(*self.members)

        return Response(

            {'result': 1, 'detail': _('Users successfully added to role')}, status=status.HTTP_201_CREATED

        )

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

        self.role.members.remove(*self.members)

        return Response(

            {'result': 1, 'detail': _('Users successfully removed from role')}, status=status.HTTP_200_OK

        )

    def patch(self, request, *args, **kwargs):

        self.role.members.set(self.members)

        return Response(

            {'result': 1, 'detail': _('Users successfully assigned to role')}, status=status.HTTP_200_OK

        )

    retention_days = None

    @classmethod

        event_type = EventType.objects.get_for_name(cls.name)

        Event.objects.create(

            type=event_type,

            user=user,

            session_id=session and session.session_key,

            references=references or None,  # NULL values take less space

            data=data or None,  # NULL values take less space

        )

    @classmethod

    data = JSONField(verbose_name=_('data'), null=True)

    objects = EventManager.from_queryset(EventQuerySet)()

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

You can use <tt>username:john</tt> to find all events related \

to users whose username is <tt>john</tt>.'''

    )

                    <tr data-event-id="{{ event.id }}" data-event-cursor="{{ event.cursor }}" data-event-type="{{ event.type.name }}">

                        <td class="journal-list--timestamp-column">{% block event-timestamp %}{{ event.timestamp }}{% endblock %}</td>

                        <td class="journal-list--user-column" {% if event.user %}data-user-id="{{ event.user.id }}"{% endif %}>{% block event-user %}{{ event.user.get_full_name|default:"-" }}{% endblock %}</td>

                        <td class="journal-list--message-column">{% block event-message %}{{ event.message|default:"-" }}{% endblock %}</td>

                    </tr>

        {% if forloop.last %}

def form_to_old_new(form):

    old = {}

    new = {}

    for key in form.changed_data:

    label = _('user creation')

    @classmethod

    @classmethod

    def get_message(cls, event, context):

    label = _('user profile edit')

    @classmethod

    @classmethod

    def get_message(cls, event, context):

    label = _('user password change')

    @classmethod

        data = {

        }

    @classmethod

    def get_message(cls, event, context):

    label = _('user password reset request')

    @classmethod

        super().record(

        )

    @classmethod

    label = _('user deletion')

    @classmethod

    @classmethod

    def get_message(cls, event, context):

class RoleEventsMixin(EventTypeDefinition):

    @classmethod

        references = references or []

        references = [role] + references

        data = data or {}

            session=session,

            references=references,

            data=data,

        )

    label = _('role edit')

    @classmethod

    @classmethod

    def get_message(cls, event, context):

    label = _('role membership grant')

    @classmethod

        data = {'member_name': member.get_full_name()}

    @classmethod

    def get_message(cls, event, context):

    label = _('role membership removal')

    @classmethod

        data = {'member_name': member.get_full_name()}

    @classmethod

    def get_message(cls, event, context):

from django_rbac.models import SEARCH_OP

from django_rbac.utils import get_ou_model, get_role_model

pytestmark = pytest.mark.django_db

    user = User.objects.get(id=simple_user.id)

    assert user.email_verified

    assert resp.json['email_verified']

    user.email_verified = True

    user.email = 'johnny.doeny@foo.bar'

    assert resp.json['email_verified']

    user = User.objects.get(uuid=resp.json['uuid'])

    assert user.email_verified

def test_api_users_create_without_email_verified(settings, app, admin):

    elif authorized:

        assert resp.json['result'] == 1

        assert resp.json['detail'] == 'User successfully added to role'

    else:

        assert resp.json['result'] == 0

        assert resp.json['errors'] == 'User not allowed to manage role members'

        assert resp.json['detail'] == 'User successfully removed from role'

        resp = app.get('/api/roles/{0}/members/{1}/'.format(role.uuid, member.uuid), status=404)

        assert resp.json == {'result': 0, 'errors': {'detail': 'Not found.'}}

    else:

        assert resp.json['result'] == 0

        assert resp.json['errors'] == 'User not allowed to manage role members'

        assert resp.json['detail'] == 'Users successfully added to role'

        for m in [member, member_rando2]:

            assert m in role.members.all()

    else:

        assert resp.json['result'] == 0

        assert resp.json['errors'] == 'User not allowed to manage role members'

        assert resp.json['detail'] == 'Users successfully removed from role'

        for m in [member, member_rando2]:

            assert m not in role.members.all()

    else:

        assert resp.json['result'] == 0

        assert resp.json['errors'] == 'User not allowed to manage role members'

    app.authorization = ('Basic', (api_user.username, api_user.username))

    authorized = api_user.has_perm('a2_rbac.manage_members_role', role)

    payload = {"data": []}

    for m in [member, member_rando2, member_rando2]:  # test no duplicate

        payload['data'].append({"uuid": m.uuid})

        assert len(role.members.all()) == 2

        for m in [member, member_rando2]:

            assert m in role.members.all()

    else:

        assert resp.json['result'] == 0

        assert resp.json['errors'] == 'User not allowed to manage role members'

    response = app.post_json(url, params=payload)

    assert response.json['result'] == 1

    assert User.objects.get(username='john.doe').check_password('password2')

def test_password_reset(app, ou1, admin, user_ou1, mailoutbox):

    mail = mailoutbox[0]

    assert mail.to[0] == email

    assert 'http://testserver/accounts/password/reset/confirm/' in mail.body

def test_users_email(app, ou1, admin, user_ou1, mailoutbox):

    app.authorization = ('Basic', (admin_ou1.username, admin_ou1.username))

    app.delete('/api/roles/{}/'.format(role_ou1.uuid))

    assert not len(Role.objects.filter(slug='role_ou1'))

def test_api_delete_role_unauthorized(app, simple_user, role_ou1):

        'slug': 'updated-role',

    }

    app.patch_json('/api/roles/{}/'.format(role_ou1.uuid), params=role_data)

    # The role API won't change the organizational unit attribute:

    role_ou1.refresh_from_db()

    assert role_ou1.name == 'updated-role'

    assert role_ou1.slug == 'updated-role'

    assert role_ou1.ou.slug == 'ou1'

def test_api_put_role_unauthorized(app, simple_user, role_ou1, ou1):

    role_data = {'slug': 'coffee-manager', 'name': 'Coffee Manager', 'ou': 'ou1'}

    resp = app.post_json('/api/roles/', params=role_data)

    assert isinstance(resp.json, dict)

    uuid = resp.json['uuid']

    ]

    # update with values pass

    payload['prefered_color'] = 'blue'

    resp = app.put_json(

        '/api/users/{}/'.format(simple_user.uuid), params=payload, headers=headers, status=200

    )

    # value are properly returned on a get

    resp = app.get('/api/users/{}/'.format(simple_user.uuid), headers=headers, status=200)

    assert User.objects.get(username='john.doe').check_password('password2')

@pytest.mark.skipif(drf_version.startswith('3.4'), reason='no support for old django rest framework')

def test_api_statistics_list(app, admin):

    OU = get_ou_model()

    make("user.login.failure", username="agent")

    make("user.login", user=user, session=session1, how="password")

    make("user.password.change", user=user, session=session1)

    edit_profile_form.initial = {'email': "user@example.com", 'first_name': "John"}

    edit_profile_form.changed_data = ["first_name"]

    edit_profile_form.cleaned_data = {'first_name': "Jane"}

        for p in zip(pq('tbody td.journal-list--user-column'), pq('tbody td.journal-list--message-column'))

    ] == [['Johnny doe', 'login using password']]

    response.form.set('search', '')

    response.form['event_type'].select(text='Profile changes')

    response = response.form.submit()

    return ''.join(node.itertext()) if node is not None else ''

    if user:

        qs = qs.filter(user=user)

    else:

    else:

        qs = qs.exclude(qs._which_references_query(models.Service))

        event = qs.get()

        assert event.data, 'no event.data, should be %s' % data

        for key, value in data.items():

                event.data.get(key),

                value,

            )

@httmock.HTTMock