Produits Entr'ouvert » Authentic 2

admin.site.register(models.UserExternalId, UserExternalIdAdmin)

DB_SESSION_ENGINES = (

    'django.contrib.sessions.backends.db',

    'django.contrib.sessions.backends.cached_db',

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.utils import six

from django.utils import timezone

from django.contrib.auth.models import BaseUserManager

    def get_by_natural_key(self, uuid):

        return self.get(uuid=uuid)

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.db import models, transaction

from django.utils import timezone

from django.core.mail import send_mail

        default=True,

        help_text=_('Designates whether this user should be treated as '

                    'active. Unselect this instead of deleting accounts.'))

    ou = models.ForeignKey(

        verbose_name=_('organizational unit'),

        to='a2_rbac.OrganizationalUnit',

        blank=True,

        null=True,

        swappable=False)

    modified = models.DateTimeField(

        verbose_name=_('Last modification time'),

        db_index=True,

        verbose_name=_('Last account deletion alert'),

        null=True,

        blank=True)

    objects = UserManager.from_queryset(UserQuerySet)()

    attributes = AttributesDescriptor()

        if hasattr(self, '_a2_attributes_cache'):

            del self._a2_attributes_cache

        return super(User, self).refresh_from_db(*args, **kwargs)

from django.utils.six.moves.urllib import parse as urlparse

from django_rbac.utils import get_ou_model

from authentic2.utils import send_templated_mail

from django.conf import settings

        ctx = {'user': user}

        with atomic():

            if not self.fake:

            self.send_mail('authentic2/unused_account_delete', user, ctx)

{% endblock %}

{% block other_actions %}

  <p class="a2-manager-user-last-login">

    {% if object.last_login %}

      {% blocktrans with date=object.last_login %}Last login on {{ date }}.{% endblocktrans %}

from django.contrib.contenttypes.models import ContentType

from django.contrib import messages

from django.views.generic import FormView, TemplateView, DetailView

import tablib

    def get_queryset(self):

        qs = super(UsersView, self).get_queryset()

        qs = qs.select_related('ou')

        qs = qs.prefetch_related('roles', 'roles__parent_relation__parent')

        return qs

    template_name = 'authentic2/manager/user_detail.html'

    slug_field = 'uuid'

    @property

    def title(self):

        return self.object.get_full_name()

        return reverse('a2-manager-users')

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

        hooks.call_hooks('event', name='manager-delete-user', user=request.user,

                         instance=self.object)

user_delete = UserDeleteView.as_view()

GetByNameManager = GetByNameQuerySet.as_manager

class AuthenticationEventManager(models.Manager):

    def cleanup(self):

        # expire after one week

from .utils import ServiceAccessDenied

@six.python_2_unicode_compatible

class UserExternalId(models.Model):

    user = models.ForeignKey(settings.AUTH_USER_MODEL, verbose_name=_('user'))

            user_pk = deletion_token['user_pk']

            self.user = get_user_model().objects.get(pk=user_pk)

            # A user account wont be deactived twice

            if not self.user.is_active:

                raise ValidationError(

            logger.info('user %s confirmed the deletion of their own account', self.user)

        except signing.SignatureExpired:

            error = _('The account deletion request is too old, try again')

        return utils.redirect(request, 'auth_homepage')

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

            utils.send_account_deletion_mail(self.request, self.user)

            logger.info(u'deletion of account %s performed', self.user)

            hooks.call_hooks('event', name='delete-account', user=self.user)

            if self.user == request.user:

                    'user_permissions': [],

                    'password': '',

                    'ou': None,

                }

            },

            {

                    'last_name_verified', 'date_joined', 'last_login',

                    'username', 'password', 'email', 'is_active', 'title',

                    'title_verified', 'modified', 'email_verified',

        assert resp.json['first_name'] == payload['first_name']

        assert resp.json['last_name'] == payload['last_name']

        assert resp.json['email'] == payload['email']

                    'last_name_verified', 'date_joined', 'last_login',

                    'username', 'password', 'email', 'is_active', 'title',

                    'title_verified', 'modified', 'email_verified',

        user = get_user_model().objects.get(pk=resp.json['id'])

        assert AttributeValue.objects.with_owner(user).filter(verified=True).count() == 3

        assert AttributeValue.objects.with_owner(user).filter(verified=False).count() == 0

import datetime

from django.contrib.auth import get_user_model

from django.utils.timezone import now

    User = get_user_model()

    u = User.objects.create(username='john.doe')

    assert User.objects.count() == 1

    assert User.objects.count() == 0

from django.utils.timezone import now

import py

from authentic2_auth_oidc.models import OIDCProvider

from django_rbac.utils import get_ou_model

from utils import login

if six.PY2:

else:

    from io import TextIOWrapper, BufferedReader, BufferedWriter

    FileType = (TextIOWrapper, BufferedReader, BufferedWriter)

    simple_user.save()

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 1

    freezer.move_to('2018-01-01 12:00:00')

    # no new mail, no deletion

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 1

    freezer.move_to('2018-01-02')

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 2

    # the day of deletion, nothing happens

    freezer.move_to('2018-01-02')

    assert len(mailoutbox) == 1

    # when new alert delay is reached, user gets alerted again

    freezer.move_to('2018-01-04')

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 2

    simple_user.save()

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 0

    # even if account last login in past deletion delay, an alert is always sent first

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 1

    # and calling again as no effect, since one day must pass before account is deleted

    management.call_command('clean-unused-accounts')

    assert len(mailoutbox) == 1

from django_rbac.utils import get_ou_model

from authentic2.custom_user.models import User

from authentic2.a2_rbac.utils import get_default_ou

from authentic2.manager import user_import

def test_detail_view(app, admin, simple_user):

def test_user_import_row_error_display(transactional_db, app, admin, media):

    page = app.get(link)

    # FIXME: webtest does not set the Referer header, so the logout page will always ask for

    # confirmation under tests

    assert len(mailoutbox) == 2

    assert 'Account deletion on testserver' == mailoutbox[1].subject

    assert urlparse(response.location).path == '/'

    response = response.follow().follow()

    assert response.request.url.endswith('/login/?next=/')

    freezer.move_to('2019-08-01')

    page = login(app, simple_user, path=reverse('delete_account'))

    page.form.submit(name='submit').follow()

    link = get_link_from_mail(mailoutbox[0])

    response = app.get(link).follow()

    assert "The account deletion request is too old, try again" in response.text

    link = get_link_from_mail(mailoutbox[0])

    simple_user.is_active = False

    simple_user.save()

def test_login_invalid_next(app):