0001-WIP-clean-unused-accounts-depending-on-OUs-26909.patch

Paul Marillonnet, 27 mars 2019 16:49

Voir les différences: en ligne côte à côte

Subject: [PATCH] WIP clean unused accounts depending on OUs (#26909)

 src/authentic2/a2_rbac/models.py              |  19 +++
 src/authentic2/custom_user/models.py          |   2 +
 .../commands/clean-unused-accounts.py         | 123 ++++++++----------
 3 files changed, 74 insertions(+), 70 deletions(-)

     import os
     from collections import namedtuple
     from django.core.exceptions import ValidationError
     from django.utils.translation import ugettext_lazy as _
-...
             choices=USER_ADD_PASSWD_POLICY_CHOICES,
             default=0)
         clean_unused_accounts_alert = models.IntegerField(
             verbose_name=_('Days after which the user receives an account deletion '
                 'alert'),
             default=0)
         clean_unused_accounts_deletion = models.IntegerField(
             verbose_name=_('Delay in days before cleaning unused accounts'),
             default=0)
         clean_unused_accounts_from_email = models.EmailField(
             verbose_name=_('sender email address for account deletion warnings and notifications'),
             blank=True, default=None, max_length=255)
         clean_unused_accounts_filter = models.CharField(
             verbose_name=_('json dict filter to apply for unused account cleanup'),
             blank=True, default=None, max_length=511)
         objects = managers.OrganizationalUnitManager()
         class Meta:

             verbose_name=_('Last modification time'),
             db_index=True,
             auto_now=True)
         last_account_deletion_alert = models.DateTimeField(
             _('last account deletion alert'), default=None)
         objects = UserManager.from_queryset(UserQuerySet)()
         attributes = AttributesDescriptor()

     from __future__ import print_function
     import json
     import logging
     import datetime
     from datetime import timedelta
     from django.contrib.auth import get_user_model
     from django.core.management.base import BaseCommand, CommandError
     from django.core.mail import send_mail
     from django.utils.timezone import now
     from django.template.loader import render_to_string
     from django_rbac.utils import get_ou_model
     from authentic2.models import DeletedUser
-...
         help = '''Clean unused accounts'''
         def add_arguments(self, parser):
             parser.add_argument('clean_threshold', type=int)
             parser.add_argument(
                 "--alert-thresholds",
                 help='list of durations before sending an alert '
                      'message for unused account, default is none',
                 default=None)
             parser.add_argument(
                 "--period", type=int,
                 help='period between two calls to '
                      'clean-unused-accounts as days, default is 1',
                 default=1
+            )
             parser.add_argument("--fake", action='store_true', help='do nothing', default=False)
             parser.add_argument(
                 "--filter", help='filter to apply to the user queryset, '
                 'the Django filter key and value are separated by character =', action='append',
                 default=[]
+            )
             parser.add_argument(
                 '--from-email', default=settings.DEFAULT_FROM_EMAIL,
                 help='sender address for notifications, default is DEFAULT_FROM_EMAIL from settings'
+            )
         def handle(self, *args, **options):
             log = logging.getLogger(__name__)
-...
                 log.exception('failure while cleaning unused accounts')
         def clean_unused_acccounts(self, *args, **options):
             if options['period'] < 1:
                 raise CommandError('period must be > 0')
             clean_threshold = options['clean_threshold']
             if clean_threshold < 1:
                 raise CommandError('clean_threshold must be an integer > 0')
             if options['verbosity'] == '0':
                 logging.basicConfig(level=logging.CRITICAL)
             if options['verbosity'] == '1':
-...
             log = logging.getLogger(__name__)
             n = now().replace(hour=0, minute=0, second=0, microsecond=0)
             self.fake = options['fake']
             self.from_email = options['from_email']
             if self.fake:
                 log.info('fake call to clean-unused-accounts')
             users = get_user_model().objects.all()
             if options['filter']:
                 for f in options['filter']:
                     key, value = f.split('=', 1)
             for ou in get_ou_model().objects.all():
                 if ou.clean_unused_accounts_filter:
                     try:
                         users = users.filter(**{key: value})
                         for key, value in json.loads(ou.clean_unused_accounts_filter):
                             users = users.filter(**{key: value})
                     except:
                         raise CommandError('invalid --filter %s' % f)
             if options['alert_thresholds']:
                 alert_thresholds = options['alert_thresholds']
                 alert_thresholds = alert_thresholds.split(',')
                 try:
                     alert_thresholds = map(int, alert_thresholds)
                 except ValueError:
                     raise CommandError('alert_thresholds must be a comma '
                             'separated list of integers')
                 for threshold in alert_thresholds:
                     if not (0 < threshold < clean_threshold):
                         raise CommandError('alert-threshold must a positive integer '
                                 'inferior to clean-threshold: 0 < %d < %d' % (
                                     threshold, clean_threshold))
                 for threshold in alert_thresholds:
                     a = n - datetime.timedelta(days=threshold)
                     b = n - datetime.timedelta(days=threshold-options['period'])
                     for user in users.filter(last_login__lt=b, last_login__gte=a):
                         log.info('%s last login %d days ago, sending alert', user, threshold)
                         self.send_alert(user, threshold, clean_threshold-threshold)
             threshold = n - datetime.timedelta(days=clean_threshold)
             for user in users.filter(last_login__lt=threshold):
                 d = n - user.last_login
                 log.info('%s last login %d days ago, deleting user', user, d.days)
                 self.delete_user(user, clean_threshold)
         def send_alert(self, user, threshold, clean_threshold):
             ctx = { 'user': user, 'threshold': threshold,
                     'clean_threshold': clean_threshold }
             self.send_mail('authentic2/unused_account_alert', user, ctx)
                         raise CommandError('invalid filter {}: {}'.format(
                             key, value))
                 if not ou.clean_unused_accounts_deletion:
                     continue
                 deletion = timedelta(days=ou.clean_unused_accounts_deletion)
                 alert = timedelta(days=ou.clean_unused_accounts_alert)
                 for user in users.filter(ou=ou, last_login_lt=n-alert):
                     if n - user.last_login >= deletion and \
                             user.last_account_deletion_alert and \
                             n - user.last_account_deletion_alert >= alert:
                         log.info(
                             '%s last login more than %d days ago, deleting user',
                             user, ou.clean_unused_accounts_deletion)
                         self.delete_user(user, clean_threshold)
                     elif not user.last_account_deletion_alert or \
                             n - user.last_account_deletion_alert >= alert:
                         log.info('%s last login %d days ago, sending alert', user,
                             ou.clean_unused_accounts_alert)
                         self.send_alert(user)
                         user.last_account_deletion_alert = n
                         user.save()
         def send_alert(self, user):
             ctx = {
                 'user': user,
                 'threshold': user.ou.clean_unused_accounts_alert,
                 'clean_threshold': user.ou.clean_unused_accounts_deletion
+            }
             self.send_mail(
                     'authentic2/unused_account_alert_{}'.format(user.ou.slug),
                     'authentic2/unused_account_alert', #default fallback template
                     user, ctx)
         def send_mail(self, prefix, user, ctx):
-...
                 log.debug('%s has no email, no mail sent', user)
             subject = render_to_string(prefix + '_subject.txt', ctx).strip()
             body = render_to_string(prefix + '_body.txt', ctx)
             from_email = user.ou.clean_unused_accounts_from_email
             if not self.fake:
                 try:
                     log.debug('sending mail to %s', user.email)
                     send_mail(subject, body, self.from_email, [user.email])
                     send_mail(subject, body, from_email, [user.email])
                 except:
                     log.exception('email sending failure')
         def delete_user(self, user, threshold):
             ctx = { 'user': user, 'threshold': threshold }
             self.send_mail('authentic2/unused_account_delete', user,
                     ctx)
         def delete_user(self, user):
             ctx = {
                 'user': user,
                 'threshold': user.ou.clean_unused_accounts_deletion
+            }
             self.send_mail(
                     'authentic2/unused_account_delete_{}'.format(user.ou.slug),
                     'authentic2/unused_account_delete', #default fallback template
                     user, ctx)
             if not self.fake:
                 DeletedUser.objects.delete_user(user)
+    -

Projet

Général

Profil

Produits Entr'ouvert » Authentic 2

0001-WIP-clean-unused-accounts-depending-on-OUs-26909.patch