petites optimisations et clarifications du code et commentaires

Etienne Pallier
1 parent 259a04cb
Showing 1 changed file with 114 additions and 34 deletions Show diff stats
src/core/pyros_django/routine_manager/functions.py
@@ -13,42 +13,91 @@ from src.core.pyros_django.obsconfig.obsconfig_class import OBSConfig
 def check_sequence_file_validity_and_save(yaml_content,request):
+    ''' Create a sequence in DB from the uploaded sequence (yaml_content) '''
+
     is_simplified = yaml_content.get("simplified", False)
+    # renommer : user_sp
     sp_of_user = request.user.get_scientific_program()
     sp_list = ScientificProgram.objects.observable_programs().filter(id__in=sp_of_user)
+    
+    # Create a sequence seq object (from yaml_content) to be saved in DB
     seq = Sequence.objects.create()
     seq.pyros_user = PyrosUser.objects.get(id=request.user.id)
+    
+    # Get the unit config
     unit_name = os.environ["unit_name"]
     config = OBSConfig(os.environ["PATH_TO_OBSCONF_FILE"], unit_name)
+    
+    # Create a Sequence form
     sequence_form = SequenceForm(instance=seq, data_from_config=config.getEditableAttributesOfMount(config.unit_name), layouts = config.get_layouts(config.unit_name), sp_list=sp_list)
     result = {
         "succeed": True,
         "errors": [],
     }
+
     if is_simplified:
         seq.scientific_program = sp_list[yaml_content["sequence"]["scientific_program"]]
+    
     else:
-        index_value_sp = yaml_content["sequence"]["scientific_program"]["value"]
-        values =  yaml_content["sequence"]["scientific_program"]["values"]
-        if index_value_sp < 0 or index_value_sp > len(yaml_content["sequence"]["scientific_program"]["values"]):
-            result["errors"].append(f"Value of scientific program isn't valid, index out of bounds ({index_value_sp} > {len(values)})")
+        # pour la lisibilité du code (et éviter la redondance)
+        yaml_seq_sp = yaml_content["sequence"]["scientific_program"]
+        index_value_sp = yaml_seq_sp["value"]
+        values =  yaml_seq_sp["values"]
+        if index_value_sp < 0 or index_value_sp > len(values):
+            result["errors"].append(f"SP value isn't valid, index out of bounds ({index_value_sp} > {len(values)})")
             index_value_sp = 0
-        chosen_sp = ScientificProgram.objects.get(name=yaml_content["sequence"]["scientific_program"]["values"][index_value_sp])
+        chosen_sp = ScientificProgram.objects.get(name=values[index_value_sp])
         if chosen_sp in sp_list:
-            seq.scientific_program = ScientificProgram.objects.get(name=yaml_content["sequence"]["scientific_program"]["values"][index_value_sp])
+            #seq.scientific_program = ScientificProgram.objects.get(name=yaml_content["sequence"]["scientific_program"]["values"][index_value_sp])
+            seq.scientific_program = chosen_sp
         else:
-            result["errors"].append(f"Scientific program {chosen_sp.name} is not assigned to that user ")
+            result["errors"].append(f"SP {chosen_sp.name} is not assigned to that user ")
+    
     seq.config_attributes = {}
+
+    # Fill all Sequence form fields
+    # keys() inutile ? => for field in sequence_form.fields :
+    # Sinon, y a aussi => for key,val in sequence_form.fields.items():
+    # => Ca éviterait de faire => sequence_form.fields[field] pour recuperer "val"
     for field in sequence_form.fields.keys():
-        if sequence_form.fields[field].required == False or field == "scientific_program":
+        
+        #if sequence_form.fields[field].required == False or field == "scientific_program":
+        if not sequence_form.fields[field].required or field=="scientific_program":
             continue
+        # pour lisibilité, simplicité et éviter redondance
+        yaml_field = yaml_content["sequence"][field]
+        value = yaml_field if is_simplified else yaml_field["value"]
+        ''' (orig)
         if is_simplified:
-            value = yaml_content["sequence"][field]    
+            value = yaml_content["sequence"][field]
         else:
             value = yaml_content["sequence"][field]["value"]
+        '''
         if field not in yaml_content["sequence"]:
             result["errors"].append(f"{field} not in yaml file")
         else:
+            if is_simplified:
+                if sequence_form.fields[field].__dict__.get("_choices"):
+                    # y a pas conflit ici avec la variable "value" définie au-dessus ?
+                    values = [value[0] for value in sequence_form.fields[field].__dict__.get("_choices")]
+                    value = values[value]
+            else:
+                if yaml_field.get("values"):
+                    index_value = yaml_field["value"]
+                    values = yaml_field["values"]
+                    if index_value < 0 or index_value > len(yaml_field["values"]):
+                        result["errors"].append(f"Value of {field} isn't valid, index out of bounds ({index_value} > {len(values)})")
+                        index_value = 0
+                    value = yaml_field["values"][index_value]
+                else:
+                    if field == "start_date":
+                        if type(value) != datetime.datetime:
+                            #value = datetime.datetime.strptime(yaml_content["sequence"][field]["value"],'%d/%m/%Y %H:%M:%S')
+                            # ISO format
+                            value = datetime.datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')
+                            seq.__dict__[field] = value
+        ''' (orig)
+        else:
             if not is_simplified:
                 if yaml_content["sequence"][field].get("values"):
                     index_value = yaml_content["sequence"][field]["value"]
@@ -68,27 +117,38 @@ def check_sequence_file_validity_and_save(yaml_content,request):
                 if sequence_form.fields[field].__dict__.get("_choices"):
                     values = [value[0] for value in sequence_form.fields[field].__dict__.get("_choices")]
                     value = values[value]
+        '''
+
+        # suffisant ? => if field in seq.__dict__
         if field in seq.__dict__.keys():
             seq.__dict__[field] = value
         else:
             seq.config_attributes[field] = value
+    # Create ALBUMS
     albums_from_file = yaml_content["sequence"]["ALBUMS"] 
     chosen_layout = seq.config_attributes["layout"]
     if type(chosen_layout) == int:
         layouts = config.get_layouts(config.unit_name)["layouts"]
         chosen_layout = list(layouts.keys())[chosen_layout]
+    # renommer : layout_albums
     albums_of_layout = config.getLayoutByName(unit_name=config.unit_name,name_of_layout=chosen_layout)["ALBUMS"]
+    
     if len(albums_of_layout) == len(albums_from_file):
         for album in albums_from_file:
             album = album["Album"]
             if album["name"] not in albums_of_layout:
                 result["errors"].append(f"Album {album['name']} is not the chosen layout")
             else:
+                # alb n'est pas utilisé
                 alb = Album.objects.create(name=album["name"], sequence=seq, complete=True)
     else:
         result["errors"].append(f"The number of albums doesn't correspond to the chosen layout")
-    for album in yaml_content["sequence"]["ALBUMS"]:
+    
+    # Tu itères 2 fois sur albums_from_file, y aurait pas moyen d'iterer 1 seule fois dessus ?
+    #for album in yaml_content["sequence"]["ALBUMS"]:
+    for album in albums_from_file:
+
         album = album["Album"]
         plans = album.get("Plans")
         if plans == None:
@@ -101,42 +161,63 @@ def check_sequence_file_validity_and_save(yaml_content,request):
                 config_attributes = {}
                 plan_form = PlanForm(data_from_config=config.getEditableAttributesOfChannel(config.unit_name,list(config.get_channels(config.unit_name).keys())[0]),edited_plan=None)
                 for field in plan_form.fields:
+                    plan_field = plan[field]
+                    '''
                     min_value = None
                     max_value = None
                     value_type = None
+                    '''
+                    min_value = max_value = value_type = None
                     if field not in plan.keys():
                         result["errors"].append(f"Missing field : '{field}' for plan {plans.index(plan)}")
                     else:
                         # TODO : ajouter max_value, min_value, suppression plan et album si invalides
                         if not is_simplified:
-                            if plan[field].get("value_type"):
-                                value_type = plan[field]["value_type"]
-                                if type(plan[field]["value"]) == str and ast.literal_eval(plan[field]["value"]) != value_type:
+                            if plan_field.get("value_type"):
+                                value_type = plan_field["value_type"]
+                                if type(plan_field["value"]) == str and ast.literal_eval(plan_field["value"]) != value_type:
                                     result["errors"].append(f"Field {field} value doesn't correspond to the assigned type (type required : {value_type})")
-                            if plan[field].get("min_value"):
-                                if type(plan[field]["min_value"]) == str:
-                                    min_value = ast.literal_eval(plan[field]["min_value"])
+                            if plan_field.get("min_value"):
+                                min_value = plan_field["min_value"]
+                                if type(min_value) == str:
+                                    min_value = ast.literal_eval(min_value)
+                                '''
+                                if type(plan_field["min_value"]) == str:
+                                    min_value = ast.literal_eval(plan_field["min_value"])
                                 else:
-                                    min_value = plan[field]["min_value"]
-                            if plan[field].get("max_value"):
-                                if type(plan[field].get("max_value")) == str:
-                                    max_value = ast.literal_eval(plan[field]["max_value"])
+                                    min_value = plan_field["min_value"]
+                                '''
+                            if plan_field.get("max_value"):
+                                max_value = plan_field["max_value"]
+                                if type(max_value) == str:
+                                    max_value = ast.literal_eval(max_value)
+                                '''
+                                if type(plan_field.get("max_value")) == str:
+                                    max_value = ast.literal_eval(plan_field["max_value"])
                                 else:
-                                    max_value = plan[field]["max_value"]
+                                    max_value = plan_field["max_value"]
+                                '''
                         if field == "nb_images":
+                            new_plan_object.__dict__[field] = plan_field if is_simplified else plan_field["value"]
+                            '''
                             if is_simplified:
-                                new_plan_object.__dict__[field] = plan[field]    
+                                new_plan_object.__dict__[field] = plan_field    
                             else:
-                                new_plan_object.__dict__[field] = plan[field]["value"]
+                                new_plan_object.__dict__[field] = plan_field["value"]
+                            '''
                         else:
-                            if not is_simplified:
-                                if plan[field].get("values"):
-                                    index_value = plan[field]["value"]
-                                    values =  plan[field]["values"]
-                                    if index_value < 0 or index_value > len(plan[field]["values"]):
+                            # shortcut possible ?
+                            #new_plan_object_field = new_plan_object.config_attributes[field]
+                            if is_simplified:
+                                new_plan_object.config_attributes[field] = plan_field
+                            else:
+                                if plan_field.get("values"):
+                                    index_value = plan_field["value"]
+                                    values =  plan_field["values"]
+                                    if index_value < 0 or index_value > len(plan_field["values"]):
                                         result["errors"].append(f"Value of Plan field '{field}' isn't valid, index out of bounds ({index_value} > {len(values)})")
                                         index_value = 0
-                                    value = plan[field]["values"][index_value]
+                                    value = plan_field["values"][index_value]
                                     try:
                                         # linked values
                                         splitted_values = value.split(";")
@@ -150,13 +231,12 @@ def check_sequence_file_validity_and_save(yaml_content,request):
                                     new_plan_object.config_attributes[field] = config_attributes[field]
                                 else:
                                     if max_value and min_value:
-                                        if plan[field]["value"] > max_value:
+                                        if plan_field["value"] > max_value:
                                             result["errors"].append(f"Plan field {field} doesn't respect max value")
-                                        if plan[field]["value"] < min_value:
+                                        if plan_field["value"] < min_value:
                                             result["errors"].append(f"Plan field {field} doesn't respect min value")
-                                    new_plan_object.config_attributes[field] = plan[field]["value"]
-                            else:
-                                new_plan_object.config_attributes[field] = plan[field]
+                                    new_plan_object.config_attributes[field] = plan_field["value"]
+
                 new_plan_object.save()