management/commands/check_consistency.py

@@ -23,10 +23,11 @@ class Command(BaseCommand):
         if options["sum_all"]:
             s = Note.objects.aggregate(Sum("balance"))["balance__sum"]
             if s:
-                err_log += self.style.NOTICE("LA SOMME DES NOTES NE VAUT PAS ZÉRO : " + pretty_money(s)) + "\n"
+                self.stderr.write(self.style.NOTICE("LA SOMME DES NOTES NE VAUT PAS ZÉRO : " + pretty_money(s)))
                 error = True
             else:
-                self.stdout.write(self.style.SUCCESS("La somme des notes vaut bien zéro."))
+                if options["verbosity"] > 0:
+                    self.stdout.write(self.style.SUCCESS("La somme des notes vaut bien zéro."))
 
         notes = Note.objects.none()
         if options["check_all"]:
@@ -42,19 +43,13 @@ class Command(BaseCommand):
                 .annotate(total=F("quantity") * F("amount")).aggregate(Sum("total"))["total__sum"] or 0
             calculated_balance = incoming - outcoming
             if calculated_balance != balance:
-                err_log += self.style.NOTICE("LA SOMME DES TRANSACTIONS DE LA NOTE {} NE CORRESPOND PAS "
-                                             "AVEC LE MONTANT RÉEL".format(str(note))) + "\n"
-                err_log += self.style.NOTICE("Attendu : {}, calculé : {}"
-                                             .format(pretty_money(balance), pretty_money(calculated_balance))) + "\n"
+                self.stderr.write(self.style.NOTICE(f"LA SOMME DES TRANSACTIONS DE LA NOTE {note} NE CORRESPOND PAS "
+                                                    "AVEC LE MONTANT RÉEL"))
+                self.stderr.write(self.style.NOTICE(f"Attendu : {pretty_money(balance)}, "
+                                                    f"calculé : {pretty_money(calculated_balance)}"))
                 if options["fix"]:
                     note.balance = calculated_balance
                     note.save()
                 error = True
 
-        if error:
-            self.stderr.write(err_log)
-            if options["mail"]:
-                send_mail("[Note Kfet] La base de données n'est pas consistante", err_log,
-                          "NoteKfet2020 <notekfet2020@crans.org>", ["respo-info.bde@lists.crans.org"])
-
         exit(1 if error else 0)

management/commands/compilejsmessages.py

+# Copyright (C) 2018-2020 by BDE ENS Paris-Saclay
+# SPDX-License-Identifier: GPL-3.0-or-later
+import os
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.utils import translation
+from django.views.i18n import JavaScriptCatalog
+
+
+class Command(BaseCommand):
+    """
+    Generate Javascript translation files
+    """
+    def add_arguments(self, parser):
+        parser.add_argument('--out', '-o', type=str, default='static', help='Output directory, where static files are.')
+
+    def handle(self, *args, **kwargs):
+        for code, _ in settings.LANGUAGES:
+            if code == settings.LANGUAGE_CODE:
+                continue
+            if kwargs["verbosity"] > 0:
+                self.stdout.write(f"Generate {code} javascript localization file")
+            with translation.override(code):
+                resp = JavaScriptCatalog().get(None, packages="member+note")
+                if not os.path.isdir(kwargs["out"] + "/js/jsi18n"):
+                    os.makedirs(kwargs["out"] + "/js/jsi18n")
+                with open(kwargs["out"] + f"/js/jsi18n/{code}.js", "wb") as f:
+                    f.write(resp.content)

management/commands/extract_ml_registrations.py

@@ -25,6 +25,10 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         # TODO: Improve the mailing list extraction system, and link it automatically with Mailman.
 
+        if options['verbosity'] == 0:
+            # This is useless, but this what the user asked.
+            return
+
         if options["type"] == "members":
             for membership in Membership.objects.filter(
                 club__name="BDE",

management/commands/force_delete_user.py

+# Copyright (C) 2018-2020 by BDE ENS Paris-Saclay
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import getpass
+from time import sleep
+
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.core.mail import mail_admins
+from django.core.management.base import BaseCommand
+from django.db import transaction
+from django.db.models import Q
+from django.test import override_settings
+
+from note.models import Alias, Transaction
+
+
+class Command(BaseCommand):
+    """
+    This script is used to force delete a user.
+    THIS IS ONLY ATTENDED TO BE USED TO DELETE FAKE ACCOUNTS THAT
+    WERE VALIDATED BY ERRORS. Please use data anonymization if you
+    want to block the account of a user.
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument('user', type=str, nargs='+', help="User id to delete.")
+        parser.add_argument('--force', '-f', action='store_true',
+                            help="Force the script to have low verbosity.")
+        parser.add_argument('--doit', '-d', action='store_true',
+                            help="Don't ask for a final confirmation and commit modification. "
+                                 "This option should really be used carefully.")
+
+    def handle(self, *args, **kwargs):
+        force = kwargs['force']
+
+        if not force:
+            self.stdout.write(self.style.WARNING("This is a dangerous script. "
+                                                 "Please use --force to indicate that you known what you are doing. "
+                                                 "Nothing will be deleted yet."))
+            sleep(5)
+
+        # We need to know who to blame.
+        qs = User.objects.filter(note__alias__normalized_name=Alias.normalize(getpass.getuser()))
+        if not qs.exists():
+            self.stderr.write(self.style.ERROR("I don't know who you are. Please add your linux id as an alias of "
+                                               "your own account."))
+            exit(2)
+        executor = qs.get()
+
+        deleted_users = []
+        deleted = []
+
+        # Don't send mails during the process
+        with override_settings(EMAIL_BACKEND='django.core.mail.backends.dummy.EmailBackend'):
+            for user_id in kwargs['user']:
+                if user_id.isnumeric():
+                    qs = User.objects.filter(pk=int(user_id))
+                    if not qs.exists():
+                        self.stderr.write(self.style.WARNING(f"User {user_id} was not found. Ignoring..."))
+                        continue
+                    user = qs.get()
+                else:
+                    qs = Alias.objects.filter(normalized_name=Alias.normalize(user_id), note__noteuser__isnull=False)
+                    if not qs.exists():
+                        self.stderr.write(self.style.WARNING(f"User {user_id} was not found. Ignoring..."))
+                        continue
+                    user = qs.get().note.user
+
+                with transaction.atomic():
+                    local_deleted = []
+
+                    # Unlock note to enable modifications
+                    if force and not user.note.is_active:
+                        user.note.is_active = True
+                        user.note.save()
+
+                    # Deleting transactions
+                    transactions = Transaction.objects.filter(Q(source=user.note) | Q(destination=user.note)).all()
+                    local_deleted += list(transactions)
+                    if kwargs['verbosity'] >= 1:
+                        for tr in transactions:
+                            self.stdout.write(f"Removing {tr}...")
+                    if force:
+                        transactions.delete()
+
+                    # Deleting memberships
+                    memberships = user.memberships.all()
+                    local_deleted += list(memberships)
+                    if kwargs['verbosity'] >= 1:
+                        for membership in memberships:
+                            self.stdout.write(f"Removing {membership}...")
+                    if force:
+                        memberships.delete()
+
+                    # Deleting aliases
+                    alias_set = user.note.alias.all()
+                    local_deleted += list(alias_set)
+                    if kwargs['verbosity'] >= 1:
+                        for alias in alias_set:
+                            self.stdout.write(f"Removing alias {alias}...")
+                    if force:
+                        alias_set.delete()
+
+                    if 'activity' in settings.INSTALLED_APPS:
+                        from activity.models import Guest, Entry
+
+                        # Deleting activity entries
+                        entries = Entry.objects.filter(Q(note=user.note) | Q(guest__inviter=user.note)).all()
+                        local_deleted += list(entries)
+                        if kwargs['verbosity'] >= 1:
+                            for entry in entries:
+                                self.stdout.write(f"Removing {entry}...")
+                        if force:
+                            entries.delete()
+
+                        # Deleting invited guests
+                        guests = Guest.objects.filter(inviter=user.note).all()
+                        local_deleted += list(guests)
+                        if kwargs['verbosity'] >= 1:
+                            for guest in guests:
+                                self.stdout.write(f"Removing guest {guest}...")
+                        if force:
+                            guests.delete()
+
+                    if 'treasury' in settings.INSTALLED_APPS:
+                        from treasury.models import SogeCredit
+
+                        # Deleting soge credit
+                        credits = SogeCredit.objects.filter(user=user).all()
+                        local_deleted += list(credits)
+                        if kwargs['verbosity'] >= 1:
+                            for credit in credits:
+                                self.stdout.write(f"Removing {credit}...")
+                        if force:
+                            credits.delete()
+
+                    # Deleting note
+                    local_deleted.append(user.note)
+                    if force:
+                        user.note.delete()
+
+                    if 'logs' in settings.INSTALLED_APPS:
+                        from logs.models import Changelog
+
+                        # Replace log executors by the runner of the script
+                        Changelog.objects.filter(user=user).update(user=executor)
+
+                    # Deleting profile
+                    local_deleted.append(user.profile)
+                    if force:
+                        user.profile.delete()
+
+                    # Finally deleting user
+                    if force:
+                        user.delete()
+                    local_deleted.append(user)
+
+                    # This script should really not be used.
+                    if not kwargs['doit'] and not input('You are about to delete real user data. '
+                                                        'Are you really sure that it is what you want? [y/N] ')\
+                            .lower().startswith('y'):
+                        self.stdout.write(self.style.ERROR("Aborted."))
+                        exit(1)
+
+                    if kwargs['verbosity'] >= 1:
+                        self.stdout.write(self.style.SUCCESS(f"User {user} deleted."))
+                        deleted_users.append(user)
+                        deleted += local_deleted
+
+        if deleted_users:
+            message = f"Les utilisateurs {deleted_users} ont été supprimés par {executor}.\n\n"
+            message += "Ont été supprimés en conséquence les objets suivants :\n\n"
+            for obj in deleted:
+                message += f"{repr(obj)} (pk: {obj.pk})\n"
+            mail_admins("Utilisateurs supprimés", message)

management/commands/import_account.py

@@ -114,6 +114,11 @@ class Command(ImportCommand):
                 else:
                     passwd_nk15 = ''
 
+                # Note account should have no password and be active
+                if int(row["idbde"]) == 3508:
+                    passwd_nk15 = "ipbased$127.0.0.1"
+                    row["bloque"] = False
+
                 if row["idbde"] not in MAP_IDBDE_PROMOTION:
                     # NK12 bug. Applying default values
                     MAP_IDBDE_PROMOTION[row["idbde"]] = {"promo": 2014,

management/commands/import_transaction.py

@@ -316,6 +316,12 @@ class Command(ImportCommand):
             )
             bulk_mgr.done()
 
+        # Note account has a different treatment
+        for m in Membership.objects.filter(user_username="note").all():
+            m.date_end = "3142-12-12"
+            m.roles.set([20])   # PC Kfet role
+            m.save()
+
     @timed
     @transaction.atomic
     def import_remittances(self, cur, chunk_size):

management/commands/make_su.py

@@ -16,7 +16,11 @@ class Command(BaseCommand):
             user = User.objects.get(username=uname)
             user.is_active = True
             if kwargs['STAFF']:
+                if kwargs['verbosity'] > 0:
+                    self.stdout.write(f"Add {user} to staff users...")
                 user.is_staff = True
             if kwargs['SUPER']:
+                if kwargs['verbosity'] > 0:
+                    self.stdout.write(f"Add {user} to superusers...")
                 user.is_superuser = True
             user.save()

management/commands/refresh_highlighted_buttons.py

@@ -23,7 +23,8 @@ class Command(BaseCommand):
         for d in queryset.all():
             button_id = d["template"]
             button = TransactionTemplate.objects.get(pk=button_id)
-            self.stdout.write(self.style.WARNING("Highlight button {name} ({count:d} transactions)..."
-                                                 .format(name=button.name, count=d["transaction_count"])))
+            if kwargs['verbosity'] > 0:
+                self.stdout.write(self.style.WARNING("Highlight button {name} ({count:d} transactions)..."
+                                                     .format(name=button.name, count=d["transaction_count"])))
             button.highlighted = True
             button.save()

management/commands/send_reports.py

@@ -20,8 +20,8 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         activate('fr')
-        if "notes" in options:
-            notes = NoteUser.objects.filter(pk__in=options["notes"]).all()
+        if 'notes' in options and options['notes']:
+            notes = NoteUser.objects.filter(pk__in=options['notes']).all()
         else:
             notes = NoteUser.objects.filter(
                 user__memberships__date_end__gte=timezone.now(),
@@ -33,8 +33,9 @@ class Command(BaseCommand):
             delta = now.date() - last_report.date()
             if delta.days < note.user.profile.report_frequency:
                 continue
-            note.user.profile.last_report = now
-            note.user.profile.save()
+            if not options["debug"]:
+                note.user.profile.last_report = now
+                note.user.profile.save()
             last_transactions = Transaction.objects.filter(
                 Q(source=note) | Q(destination=note),
                 created_at__gte=last_report,