continue the script and few change to model

apps/wrapped/management/commands/generate_wrapped.py

@@ -5,20 +5,11 @@
 
 from argparse import ArgumentParser
 from django.core.management import BaseCommand
+from django.db.models import Q
 
 from note.models import Note
 from member.models import User, Club
-from ...models import Bde
+from ...models import Bde, Wrapped
-
-########################################################################################################
-"""
-Cahier des charges :
-
-    - Un script lisible
-    - Avec beaucoup d'options
-    - Personnalisable
-"""
-########################################################################################################
 
 
 class Command(BaseCommand):
@@ -63,18 +54,18 @@ class Command(BaseCommand):
                 dest='club',
         )
         parser.add_argument(
-                '-f', '--force',
+                '-f', '--force-change',
                 required=False,
                 action='store_true',
-                help="if wrapped already exist delete it and regenerate",
+                help="if wrapped already exist change data_json",
-                dest='force',
+                dest='change',
         )
         parser.add_argument(
-                '-d', '--delete',
+                '-n', '--no-creation',
                 required=False,
-                action='store_true',
+                action='store_false',
-                help="delete all wrapped selectionned and don't regenerate them",
+                help="if wrapped don't already exist, don't generate it",
-                dest='delete',
+                dest='create',
         )
 
 
@@ -146,8 +137,8 @@ class Command(BaseCommand):
                 if verb >= 0: print(abort)
                 return
 
-        force = options['force']
+        change = options['change']
-        delete = options['delete']
+        create = options['create']
 
         # check if parameters are sufficient for generate wrapped with the desired option
         if not bde:
@@ -170,42 +161,130 @@ class Command(BaseCommand):
             print('BDE: ' + bde_str)
             if user: print('User: ' + user[0])
             if club: print('Club: ' + club[0])
-            print('force: ' + str(force))
+            print('change: ' + str(change))
-            print('delete: ' + str(delete))
+            print('create: ' + str(create))
             print('')
-        if verb >=1 and force:
+        if not (change or create):
+            if verb >= 1:
+                print(warning)
+                print(yellow + 'change and create is set to false, none wrapped will be created')
+            if verb >= 0:
+                print(abort)
+            return
+        if verb >=1 and change:
             print(warning)
-            print(yellow + 'force is set to true, some wrapped may be deleted !')
+            print(yellow + 'change is set to true, some wrapped may be replaced !')
-        if verb >=1 and delete:
+        if verb >=1 and not create:
             print(warning)
-            print(yellow + 'wrapped will be deleted !')
+            print(yellow + 'create is set to false, wrapped will not be created !')
-        if verb >= 2 or force or delete:
+        if verb >= 2 or change or not create:
             a = str(input('\033[mContinue ? (y/n) ')).lower()
             if a in ['n','no','non','0']:
                 if verb >= 0: print(abort)
                 return
 
-        # à partir de maintenant si ça foire ce n'est plus de la faute de l'utilisateur...
+        note = self.convert_to_note(user=user, club=club, verb=verb)
-        #########################################
+        if verb >= 1: print("\033[32mUser and/or Club given has successfully convert in their note\033[m")
-        #### Transform club and user in note ####
-        #########################################
 
-        ########################
+        global_data = self.global_data(bde, verb=verb)
-        #### Delete wrapped ####
+        if verb >= 1: print("\033[32mGlobal data has been successfully generated\033[m")
-        ########################
 
-        ###########################################
+        unique_data = self.unique_data(bde, note, change, create, global_data=global_data, verb=verb)
-        #### Global data (in all user wrapped) ####
+        if verb >= 1: print("\033[32mUnique data has been successfully generated\033[m")
-        ########## modify it each year ! ##########
-        ###########################################
         
-        #################################
+        self.make_wrapped(unique_data, note, bde, change, create, verb=verb)
-        ########## Unique data ##########
+        if verb >= 1: print(green + "The wrapped has been generated !")
-        ##### modify it each year ! #####
+        if verb >= 0: print(success)
-        #################################
 
-        ###############################
-        #### Create/Change wrapped ####
-        ###############################
         return
         
+    def convert_to_note(self, user=None, club=None, verb=1):
+        query = Q(pk=-1)
+        if user:
+            if 'custom' in user[0]:
+                for u in user[1]:
+                    query |= Q(noteuser__user=u)
+            elif user[0] == 'all':
+                query |= Q(noteuser__user__pk__gte=-1)
+            elif user[0] == 'adh':
+                # TODO some complex query
+                query |= query
+            elif user[0] == 'superuser':
+                query |= Q(noteuser__user__is_superuser=True)
+            else:
+                return
+
+        if club:
+            if 'custom' in club[0]:
+                for c in club[1]:
+                    query |= Q(noteclub__club=c)
+            elif club[0] == 'all':
+                query |= Q(noteclub__club__pk__gte=-1)
+            elif club[0] == 'active':
+                # TODO some complex query
+                query |= query
+            else:
+                return
+        
+        if verb >= 3: print('\033[mQuery: ' + str(query))
+        note = Note.objects.filter(query)
+
+        return note
+
+    def global_data(self, bde, verb=1):
+        data = {}
+        for b in bde:
+            if b.name == 'Rave Part[list]':
+                # TODO
+                data = {}
+            else:
+                # make your wrapped or reuse previous wrapped
+                raise NotImplementedError("The BDE: {bde_name} has not personalized wrapped, make it !"
+                                          .format(bde_name=b.name))
+        return data
+
+    def unique_data(self, bde, note, change, create, global_data=None, verb=1):
+        data = {}
+        for i in range(len(bde)):
+            if verb >= 2: print('\033[mlen(note) = {nb}'.format(nb=len(note)))
+            note_filtered = self.filter_note(bde[i], note, change, create, verb=verb)
+            if verb >= 2: print('\033[mlen(note_after_filter) = {nb}'.format(nb=len(note_filtered)))
+            if bde[i].name == 'Rave Part[list]':
+                # TODO
+                data = {}
+            else:
+                # make your wrapped or reuse previous wrapped
+                raise NotImplementedError("The BDE: {bde_name} has not personalized wrapped, make it !"
+                                          .format(bde_name=bde[i].name))
+        return data
+
+    def make_wrapped(self, unique_data, note, bde, change, create, verb=1):
+        for i in range(len(bde)):
+            for j in len(note[i]):
+                if create and not Wrapped.objects.filter(bde=bde[i], note=note[i][j]):
+                    Wrapped(bde=bde[i],
+                            note=note[i][j],
+                            data_json=unique_data[i][j],
+                            public=False,
+                            generated=True).save()
+                elif change:
+                    w = Wrapped.objects.get(bde=bde[i], note=note[i][j])
+                    w.data_json = unique_data[i][j]
+                    w.save()
+        return
+
+    def filter_note(self, bde, note, change, create, verb=1):
+        if change and create:
+            return note
+        if change and not create:
+            note_new = []
+            for n in note:
+                if Wrapped.objects.filter(bde=bde, note=n):
+                    note_new.append(n)
+            return note_new
+        if not change and create:
+            note_new = []
+            for n in note:
+                if not Wrapped.objects.filter(bde=bde, note=n):
+                    note_new.append(n)
+            return note_new

apps/wrapped/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 4.2.15 on 2025-02-10 12:41
+# Generated by Django 4.2.15 on 2025-02-13 01:38
 
 from django.db import migrations, models
 import django.db.models.deletion

apps/wrapped/models.py

@@ -79,11 +79,3 @@ class Wrapped(models.Model):
         self.public = not self.public
         self.save()
         return
-
-    @property
-    def data(self):
-        return json.load(self.data_json)
-
-    @data.setter
-    def data(self, data):
-        self.data_json = json.dumps(data, indent=2)