From 600016d1e0118000c94cc4f9327336316de45e48 Mon Sep 17 00:00:00 2001 From: root Date: Tue, 18 May 2021 11:31:39 +0200 Subject: [PATCH] ajout de nouveaux tests --- scotests/export_formation1.xml | 205 ++++ scotests/formation_export.json | 1352 +++++++++++++++++++++ scotests/test_absence.py | 50 +- scotests/test_create_etud.py | 47 + scotests/test_etudiant1.py | 98 ++ scotests/test_evaluation.py | 235 ++++ scotests/test_evaluation_suppress_alln.py | 70 ++ scotests/test_formations.py | 321 +++++ scotests/test_groupes.py | 25 +- scotests/test_scenario1_app.py | 117 ++ scotests/test_scenario1_formation.py | 72 ++ scotests/test_scenario2_formation.py | 105 ++ scotests/test_scenario3_formation.py | 135 ++ scotests/test_scenario4_formation.py | 172 +++ scotests/test_user.py | 49 + static/formation_export.json | 1352 +++++++++++++++++++++ 16 files changed, 4395 insertions(+), 10 deletions(-) create mode 100755 scotests/export_formation1.xml create mode 100755 scotests/formation_export.json create mode 100755 scotests/test_create_etud.py create mode 100755 scotests/test_etudiant1.py create mode 100755 scotests/test_evaluation.py create mode 100755 scotests/test_evaluation_suppress_alln.py create mode 100755 scotests/test_formations.py create mode 100755 scotests/test_scenario1_app.py create mode 100755 scotests/test_scenario1_formation.py create mode 100755 scotests/test_scenario2_formation.py create mode 100755 scotests/test_scenario3_formation.py create mode 100755 scotests/test_scenario4_formation.py create mode 100755 scotests/test_user.py create mode 100755 static/formation_export.json diff --git a/scotests/export_formation1.xml b/scotests/export_formation1.xml new file mode 100755 index 000000000..8baf7a6b7 --- /dev/null +++ b/scotests/export_formation1.xml @@ -0,0 +1,205 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/scotests/formation_export.json b/scotests/formation_export.json new file mode 100755 index 000000000..1c13dc0b1 --- /dev/null +++ b/scotests/formation_export.json @@ -0,0 +1,1352 @@ +{ + "acronyme": "DUT Info", + "code_specialite": "", + "type_parcours": 100, + "titre_officiel": "DUT Informatique", + "formation_code": "FCOD2", + "version": 1, + "ue": [ + { + "acronyme": "UE11", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M1101", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux syst\u00e8mes informatiques", + "heures_td": 20.0 + } + ], + "numero": 1 + }, + { + "titre": "Algorithmique - Programmation - Langages", + "module": [ + { + "coefficient": 2.0, + "code": "M1102", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "Algorithmique", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction \u00e0 l\u2019algorithmique et \u00e0 la programmation", + "heures_td": 20.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M1103", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "Structure de donn\u00e9es", + "numero": 3, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Structure de donn\u00e9es et algorithmes fondamentaux", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 3.0, + "code": "M1104", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "BDD", + "numero": 4, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux bases de donn\u00e9es", + "heures_td": 25.0 + } + ], + "numero": 4 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1105", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "CDIN", + "numero": 5, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception de documents et d\u2019interfaces num\u00e9riques", + "heures_td": 20.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M1106", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "Projet", + "numero": 6, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : d\u00e9couverte", + "heures_td": 0.0 + } + ], + "numero": 6 + } + ], + "ue_code": "UE11", + "numero": 1, + "titre": "Base de l'informatique", + "type": 0 + }, + { + "acronyme": "UE21", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M2101", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture et Programmation des m\u00e9canismes de base d\u2019un syst\u00e8me informatique", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M2102", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture des r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2103", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la programmation orient\u00e9e objet", + "heures_td": 20.0 + } + ], + "numero": 3 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2104", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "COO", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la conception orient\u00e9e objet", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Interface homme-machine", + "module": [ + { + "coefficient": 2.0, + "code": "M2105", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux interfaces homme-machine", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2106", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Programmation et administration des bases de donn\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M2107", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : Description et planification de projet", + "heures_td": 0.0 + } + ], + "numero": 7 + } + ], + "ue_code": "UE21", + "numero": 1, + "titre": "Informatique approfondie", + "type": 0 + }, + { + "acronyme": "UE31", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3101", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Principes des syst\u00e8mes d\u2019exploitation", + "heures_td": 14.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation, R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3102", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Services r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3103", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Algorithmique avanc\u00e9e", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3104", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Programmation Web c\u00f4t\u00e9 serveur", + "heures_td": 14.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 16.0, + "code": "M3105", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception et programmation objet avanc\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3106C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Bases de donn\u00e9es avanc\u00e9es", + "heures_td": 10.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD5", + "numero": 1, + "titre": "Informatique avanc\u00e9e", + "type": 0 + }, + { + "acronyme": "UE41", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M4101C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Administration syst\u00e8me et r\u00e9seau", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation \u2013 R\u00e9seaux Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4102C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation r\u00e9partie", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Web \u2013 Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M4103C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation Web \u2013 client riche", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 - Mobile", + "module": [ + { + "coefficient": 3.0, + "code": "M4104C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Conception et d\u00e9veloppement d\u2019applications mobiles", + "heures_td": 10.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4105C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Compl\u00e9ments d\u2019informatique en vue d\u2019une insertion imm\u00e9diate", + "heures_td": 10.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M4106", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 \u2013 Compl\u00e9ments", + "heures_td": 0.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD8", + "numero": 1, + "titre": "Compl\u00e9ments en informatique", + "type": 0 + }, + { + "acronyme": "UE12", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M1201", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 17.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Math\u00e9matiques discr\u00e8tes", + "heures_td": 18.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M1202", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 6.0, + "module_type": 0, + "titre": "Alg\u00e8bre lin\u00e9aire", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M1203", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Environnement \u00e9conomique", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Organisation", + "module": [ + { + "coefficient": 1.0, + "code": "M1204", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Fonctionnement des organisations", + "heures_td": 20.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1205", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Fondamentaux de la communication", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M1206", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Anglais et Informatique", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M1207", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conna\u00eetre le monde professionnel", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UE12", + "numero": 2, + "titre": "Bases de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE22", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M2201", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 18.0, + "abbrev": "", + "numero": 10, + "heures_cours": 11.0, + "module_type": 0, + "titre": "Graphes et langages", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2202", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Analyse et m\u00e9thodes num\u00e9riques", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Droit - Organisation", + "module": [ + { + "coefficient": 2.0, + "code": "M2203", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 12.0, + "module_type": 0, + "titre": "Environnement comptable, financier, juridique et social", + "heures_td": 18.0 + } + ], + "numero": 3 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2204", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Gestion de projet informatique", + "heures_td": 12.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M2205", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication, information et argumentation", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M2206", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communiquer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 1.0, + "code": "M2207", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Identifier ses comp\u00e9tences", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UCOD4", + "numero": 2, + "titre": "Approfondissements en culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE32", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M3201", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Probabilit\u00e9s et statistique", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3202C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Mod\u00e9lisations math\u00e9matiques", + "heures_td": 16.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3203", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Droit des technologies de l\u2019information et de la communication", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Gestion", + "module": [ + { + "coefficient": 2.0, + "code": "M3204", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Gestion des syst\u00e8mes d\u2019information", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M3205", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication professionnelle", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M3206", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Collaborer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD6", + "numero": 2, + "titre": "Culture scientifique, sociale et humaine avanc\u00e9es", + "type": 0 + }, + { + "acronyme": "UE33", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications \u00c9conomie - gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3301", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 24.0, + "abbrev": "", + "numero": 10, + "heures_cours": 14.0, + "module_type": 0, + "titre": "M\u00e9thodologie de la production d\u2019applications", + "heures_td": 22.0 + } + ], + "numero": 1 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M3302", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 - Mise en situation professionnelle", + "heures_td": 0.0 + } + ], + "numero": 2 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 2.0, + "code": "M3303", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Pr\u00e9ciser son projet", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 13 + } + ], + "ue_code": "UCOD7", + "numero": 2, + "titre": "M\u00e9thodologie et projets", + "type": 0 + }, + { + "acronyme": "UE42", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M4201C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Ateliers de cr\u00e9ation d\u2019entreprise", + "heures_td": 12.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M4202C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Introduction \u00e0 la recherche op\u00e9rationnelle et aide \u00e0 la d\u00e9cision", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "Expression \u2013 Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M4203", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication dans les organisations", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M4204", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Travailler en anglais", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 14 + } + ], + "ue_code": "UCOD9", + "numero": 2, + "titre": "Compl\u00e9ments de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE43", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "STAGE", + "module": [ + { + "coefficient": 12.0, + "code": "M4301", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Stage professionnel", + "heures_td": 0.0 + } + ], + "numero": 1 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS3", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 11 + } + ], + "ue_code": "UCOD10", + "numero": 3, + "titre": "Mise en situation professionnelle", + "type": 0 + } + ], + "titre": "DUT Informatique", + "formation_id": "FORM234" +} \ No newline at end of file diff --git a/scotests/test_absence.py b/scotests/test_absence.py index 7a9bf95de..5a9ba1a31 100755 --- a/scotests/test_absence.py +++ b/scotests/test_absence.py @@ -28,6 +28,7 @@ import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error import sco_abs import sco_abs_views import sco_abs_notification +import ZAbsences G = sco_fake_gen.ScoFake(context.Notes) G.verbose = False @@ -66,6 +67,14 @@ mi = G.create_moduleimpl( for etud in etuds: G.inscrit_etudiant(sem, etud) +#--- Création d'une évaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="22/01/2021", + description="evaluation test", + coefficient=1.0, +) + # --- Saisie absences etudid = etuds[0]["etudid"] @@ -162,9 +171,21 @@ print(a.CountAbs()) #lors du print cela affiche 5 or cela devrait afficher 3 # --- Création d'une liste d'abs -liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='text', REQUEST=REQUEST) -print(liste_abs) -#toutes les absences figurent (bien evidemment pas celle qui a été supprimé alors pq CountAbs indique toujours le même nombre d'abs) +liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='json', absjust_only=1, REQUEST=REQUEST) +liste_abs2 = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='json', REQUEST=REQUEST) + +load_liste_abs = json.loads(liste_abs) +load_liste_abs2 = json.loads(liste_abs2) + +assert len(load_liste_abs2) == 1 +assert len(load_liste_abs) == 2 +assert load_liste_abs2[0]["ampm"] == "1" +assert load_liste_abs2[0]["datedmy"] == "22/01/2021" +assert load_liste_abs2[0]["exams"] == mod["code"] + + +# absjust_only -> seulement les abs justifiés + # --- Création d'un groupe @@ -180,5 +201,26 @@ for etud in etuds : # --- Test de EtatAbsencesGroupes -# Fonction introuvable. +grp1_abs = context.Absences.EtatAbsencesGr(group_ids=[li_grp1[0]["group_id"]], debut="01/01/2021", fin ="30/06/2021", format="json", REQUEST=REQUEST) +load_grp1_abs = json.loads(grp1_abs) + +assert len(load_grp1_abs) == 10 + +tab_id=[] #tab des id present dans load_grp1_abs +for un_etud in load_grp1_abs : + tab_id.append(un_etud["etudid"]) + +for etud in etuds : #verification si tous les etudiants sont present dans la liste du groupe d'absence + assert etud["etudid"] in tab_id + + +for un_etud in load_grp1_abs : + if un_etud["etudid"] == etudid : + assert un_etud["nbabs"] == "3" + assert un_etud["nbjustifs_noabs"] == "2" + assert un_etud["nbabsjust"] == "2" + assert un_etud["nbabsnonjust"] == "1" + assert un_etud["nomprenom"] == etuds[0]["nomprenom"] + + diff --git a/scotests/test_create_etud.py b/scotests/test_create_etud.py new file mode 100755 index 000000000..9430538a8 --- /dev/null +++ b/scotests/test_create_etud.py @@ -0,0 +1,47 @@ +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'un étudiant + +etud = G.create_etud( + code_nip="", + nom="Poire", + prenom="Kevin", + code_ine="", + civilite="M", + etape="TST1", + email="test1@localhost", + emailperso="perso1@localhost", + date_naissance="01/05/2001", + lieu_naissance="Stains", + dept_naissance="93", + domicile="11, rue du test", + codepostaldomicile="93430", + villedomicile="Villetaneuse", + paysdomicile="France", + telephone="0102030405", + typeadresse="domicile", + boursier=None, + description="etudiant test", + ) + +print(etud) +print(" ") + +info = context.Scolarite.etud_info(etud["etudid"], format = "json", REQUEST=REQUEST) +load_info = json.loads(info) +print(load_info) + +#malgrè l'entrée de donnée dans les paramètres la fonction ne les prend pas en compte. Sauf pour date_naissance, +#dept_naissance, nom et prenom, lieu_naissance et civilite la fonction crée aussi un code nip et ine donc pas de pb +#pour ca. + +print(" ") +print(etud["telephone"]) +print(etud["domicile"]) +print(etud["emailperso"]) \ No newline at end of file diff --git a/scotests/test_etudiant1.py b/scotests/test_etudiant1.py new file mode 100755 index 000000000..cf2b4334f --- /dev/null +++ b/scotests/test_etudiant1.py @@ -0,0 +1,98 @@ +""" 3) Création d’étudiants, formation etc… Au cours de l’année un étudiant déménage et souhaite changer +ses informations personnelles. Un autre étudiant lui à changer de téléphone portable ainsi que d’adresse e-mail. +Changer les données + +Vérifier si les changements se sont effectués + +Fonctions de l’API utilisé : +- create_formation +- create_ue +- create_module +- create_matiere +- create_formsemestre +- create_moduleimpl +- inscrit_etudiant +- etuds_info +- getEtudInfo +- identite_edit + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour éviter les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import scolars + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants + +etud = G.create_etud( + code_nip="", + nom="Poire", + prenom="Kevin", + code_ine="", + civilite="M", + etape="TST1", + email="test1@localhost", + emailperso="perso1@localhost", + date_naissance="01/05/2001", + lieu_naissance="Stains", + dept_naissance="93", + domicile="11, rue du test", + codepostaldomicile="93430", + villedomicile="Villetaneuse", + paysdomicile="France", + telephone="0102030405", + typeadresse="domicile", + boursier=None, + description="etudiant test", + ) + +# --- Création d'une formation +f = G.create_formation(acronyme="") +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod = G.create_module( + matiere_id=mat["matiere_id"], + code="TSM1", + coefficient=1.0, + titre="module test", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2020", + date_fin="30/06/2020", +) + +mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=sem["formsemestre_id"], + responsable_id="bach", +) + + +# --- Inscription de l'étudiant + +G.inscrit_etudiant(sem, etud) + +print(etud) + +info = context.Scolarite.etud_info(etud["etudid"], format = "json", REQUEST=REQUEST) +load_info = json.loads(info) +print(load_info) + +# --- Modification des données + +scolars.adresse_edit(context.Scolarite, args = {"domicile" : "9 rue du moulin"}) \ No newline at end of file diff --git a/scotests/test_evaluation.py b/scotests/test_evaluation.py new file mode 100755 index 000000000..084fc6b04 --- /dev/null +++ b/scotests/test_evaluation.py @@ -0,0 +1,235 @@ +""" Création d'une formation, d'élève de 2 ue dans un semestre et de 6 évaluations par 3 fonction différentes : +create_eval, evaluation_create et do_evaluation_create. Saisir les notes des évaluations, lister ces evaluations, +supprimer et modifier une evaluation """ + +import sys +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl +import sco_liste_notes +import sco_evaluations +import sco_undo_notes +import sco_abs_views +import sco_saisie_notes + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création d'une formation et de deux UE +f = G.create_formation(acronyme="") +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod = G.create_module( + matiere_id=mat["matiere_id"], + code="TSM1", + coefficient=1.0, + titre="module test", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="TST2", titre="ue test2") +mat2 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test2") +mod2 = G.create_module( + matiere_id=mat2["matiere_id"], + code="TSM2", + coefficient=1.0, + titre="module test2", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=sem["formsemestre_id"], + responsable_id="bach", +) + +mi2 = G.create_moduleimpl( + module_id=mod2["module_id"], + formsemestre_id=sem["formsemestre_id"], + responsable_id="bach", +) + + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + +# --- Création des évaluations + +#création d'éval avec create_evaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 1", + coefficient=1.0, +) + +e2 = G.create_evaluation( + moduleimpl_id=mi2["moduleimpl_id"], + jour="11/01/2021", + description="evaluation test 2", + coefficient=1.0, +) + + + +#création d'éval avec evaluation_create +#e3 = context.Notes.evaluation_create(mi["moduleimpl_id"], REQUEST) +#e4 = context.Notes.evaluation_create(mi2["moduleimpl_id"], REQUEST) # rien ne se passe + +#création d'éval avec do_evaluation_create ! WARNING : retourne l'id de l'éval ! +e5 = context.Notes.do_evaluation_create( + moduleimpl_id=mi["moduleimpl_id"], + jour="01/02/2021", + heure_debut="9h0", + heure_fin="11h0", + description="evaluation test 5", + note_max="20.0", + coefficient="1", + REQUEST=REQUEST + ) + +e6 = context.Notes.do_evaluation_create( + moduleimpl_id=mi2["moduleimpl_id"], + jour="01/02/2021", + heure_debut="13h0", + heure_fin="15h0", + description="evaluation test 6", + note_max="20.0", + coefficient="1", + REQUEST=REQUEST + ) + + + +# --- Liste des évaluations dans le semestre + +lie = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie) == 4 +""" print(lie[0]) +print(" ") +print(lie[1]) +print(" ") +print(lie[2]) +print(" ") +print(lie[3]) """ + +eval5 = context.Notes.do_evaluation_list({"evaluation_id" : e5})[0] +eval6 = context.Notes.do_evaluation_list({"evaluation_id" : e6})[0] + +# --- Saisie des absences aux évaluations + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "7/01/2021", + "7/01/2021", + demijournee=1, + etudid=etuds[0]["etudid"], + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "01/02/2021", + "01/02/2021", + demijournee=1, + etudid=etuds[1]["etudid"], + REQUEST=REQUEST, +) + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "01/02/2021", + "01/02/2021", + demijournee=1, + etudid=etuds[1]["etudid"], + REQUEST=REQUEST, +) + +# --- Saisie des notes + +evals = [e,e2,eval5,eval6] + +for eval in evals : + for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=eval, etud=etud, note=float(random.randint(0, 20)) + ) + +# --- Check abs + +check = sco_liste_notes.evaluation_check_absences(context.Notes, evaluation_id=e["evaluation_id"]) + +check2 = sco_liste_notes.evaluation_check_absences(context.Notes, evaluation_id=e2["evaluation_id"]) + +# --- Liste de note d'une évaluation + +#lien = context.Notes.do_evaluation_listnotes(REQUEST=REQUEST) +#print (lien) pb avec les arguments. + + +cal = sco_evaluations.formsemestre_evaluations_cal(context.Notes, formsemestre_id=sem["formsemestre_id"], REQUEST=REQUEST) +#html + +delai = sco_evaluations.formsemestre_evaluations_delai_correction(context.Notes, formsemestre_id=sem["formsemestre_id"], format="json", REQUEST=REQUEST) +#html + +lio = sco_undo_notes.evaluation_list_operations(context.Notes, evaluation_id=e["evaluation_id"], REQUEST=REQUEST) +#html + + +# --- Supression de toutes les notes d'une évaluations + +etat = sco_evaluations.do_evaluation_etat(context.Notes, e2["evaluation_id"]) +assert etat["evalcomplete"] +sco_saisie_notes.evaluation_suppress_alln(context.Notes, e2["evaluation_id"], REQUEST=REQUEST) +etat2 = sco_evaluations.do_evaluation_etat(context.Notes, e2["evaluation_id"]) + +#assert not etat2["evalcomplete"] rien ne se passe... + +# --- Modification d'une évaluation + +context.Notes.do_evaluation_edit(REQUEST=REQUEST, args={"evaluation_id" : e5, "coefficient": 2.0 , +"description" : "modification", "note_max" : 20, +"heure_debut" : "8h0", "heure_fin" : "10h0", "jour" : "03/02/2021"}) +new_eval5 = context.Notes.do_evaluation_list({"evaluation_id" : e5})[0] + +assert new_eval5["description"] == "modification" +assert new_eval5["jour"] == "03/02/2021" +assert new_eval5["heure_debut"] == "08h00" +assert new_eval5["heure_fin"] == "10h00" +assert new_eval5["coefficient"] == 2.0 + +# --- Supression d'une évaluation + +e7 = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 7", + coefficient=1.0, +) + +lie = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie) == 5 + +#context.Notes.evaluation_delete(REQUEST=REQUEST, evaluation_id=e7) rien ne se passe +sco_evaluations.do_evaluation_delete(context.Notes, REQUEST=REQUEST, evaluation_id=e7["evaluation_id"]) +lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie2) == 4 diff --git a/scotests/test_evaluation_suppress_alln.py b/scotests/test_evaluation_suppress_alln.py new file mode 100755 index 000000000..5e1400209 --- /dev/null +++ b/scotests/test_evaluation_suppress_alln.py @@ -0,0 +1,70 @@ +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_saisie_notes +import sco_evaluations + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création d'une formation et de deux UE +f = G.create_formation(acronyme="") +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod = G.create_module( + matiere_id=mat["matiere_id"], + code="TSM1", + coefficient=1.0, + titre="module test", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=sem["formsemestre_id"], + responsable_id="bach", +) + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + +# --- Création d'une évaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 1", + coefficient=1.0, +) + +# --- Saisie des notes +for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=e, etud=etud, note=float(random.randint(0, 20)) + ) + +etat = sco_evaluations.do_evaluation_etat(context.Notes, e["evaluation_id"]) +assert etat["evalcomplete"] + +# --- Suppression des notes +sco_saisie_notes.evaluation_suppress_alln(context.Notes, e["evaluation_id"], REQUEST=REQUEST) +etat = sco_evaluations.do_evaluation_etat(context.Notes, e["evaluation_id"]) +assert not etat["evalcomplete"] + diff --git a/scotests/test_formations.py b/scotests/test_formations.py new file mode 100755 index 000000000..a3feb82d4 --- /dev/null +++ b/scotests/test_formations.py @@ -0,0 +1,321 @@ +""" Créer 2 formations, une test et une normale. Créer 2 semestres dans la formation normale et un +dans la formation test, créer 2 semestres dans la formation normale (un test et un normal), +2 ue (un test et un normal), 2 modules (un test et un normal) et 2 matieres (test et normal). + Et dans la formations test, un semestre, un module, un ue et une matiere. + Afficher la liste de tout ca puis supprimer les ue, mod, mat et sem test ainsi + que la formation test. Afficher la liste des UE, formations et modules restante. + + Vérification : + + - Les listes initiales comprennent bien tout les éléments créés avec les bon noms etc + - La supression s'est bien effectué au niveau de scodoc web et en python + - Vérifier que les fonctions listes font bien la mise à jour après supression + +Fonction de l'API utilisé : + +- create_formation +- create_ue +- create_matiere +- create_module +- create_formsemestre +- create_moduleimpl +- formation_list +- formation_export +- formsemestre_list +- do_moduleimpl_list +- do_module_impl_with_module_list +- do_formsemestre_delete +- do_module_list +- do_module_delete +- do_matiere_list +- do_matiere_delete +- do_ue_list +- do_ue_delete +- do_formation_delete + + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_formsemestre_status +import ZNotes +import sco_formations +import sco_moduleimpl +import sco_edit_ue +import sco_edit_matiere +import sco_edit_module +import sco_formsemestre_edit + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création de formations + +f = G.create_formation(acronyme="F1", titre="Formation 1", titre_officiel="Titre officiel 1") + +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod = G.create_module( + matiere_id=mat["matiere_id"], + code="TSM1", + coefficient=1.0, + titre="module test", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="TST2", titre="ue test2") +mat2 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test2") +mod2 = G.create_module( + matiere_id=mat2["matiere_id"], + code="TSM2", + coefficient=1.0, + titre="module test", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +uet = G.create_ue(formation_id=f["formation_id"], acronyme="TSTt", titre="ue testt") +matt = G.create_matiere(ue_id=uet["ue_id"], titre="matière testt") +modt = G.create_module( + matiere_id=matt["matiere_id"], + code="TSMt", + coefficient=1.0, + titre="module test", + ue_id=uet["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + + +f2 = G.create_formation(acronyme="", titre="Formation test") + +ue3 = G.create_ue(formation_id=f2["formation_id"], acronyme="TST3", titre="ue test3") +mat3 = G.create_matiere(ue_id=ue3["ue_id"], titre="matière test3") +mod3 = G.create_module( + matiere_id=mat3["matiere_id"], + code="TSM3", + coefficient=1.0, + titre="module test3", + ue_id=ue3["ue_id"], # faiblesse de l'API + formation_id=f2["formation_id"], # faiblesse de l'API +) + +# --- Création et implémentation des semestres + +sem1 = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=2, + date_debut="01/09/2020", + date_fin="31/12/2020", +) + +mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=sem1["formsemestre_id"], + responsable_id="bach", +) + +mi2 = G.create_moduleimpl( + module_id=mod2["module_id"], + formsemestre_id=sem1["formsemestre_id"], + responsable_id="bach", +) + +mit = G.create_moduleimpl( + module_id=modt["module_id"], + formsemestre_id=sem2["formsemestre_id"], + responsable_id="bach", +) + +semt = G.create_formsemestre( + formation_id=f2["formation_id"], + semestre_id=3, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +mi3 = G.create_moduleimpl( + module_id=mod3["module_id"], + formsemestre_id=semt["formsemestre_id"], + responsable_id="bach", +) + +# --- Affichier la liste des formations + +lif = context.Notes.formation_list(format="json", REQUEST=REQUEST, formation_id=f["formation_id"]) + +load_lif = json.loads(lif) +assert len(load_lif) == 1 +assert load_lif[0]["acronyme"] == f["acronyme"] +assert load_lif[0]["titre_officiel"] == f["titre_officiel"] +assert load_lif[0]["formation_id"] == f["formation_id"] +assert load_lif[0]["titre"] == f["titre"] + +lif2 = context.Notes.formation_list(format = 'json', REQUEST=REQUEST) + +load_lif2 = json.loads(lif2) +assert len(load_lif2) == 2 +assert load_lif2[0] == load_lif[0] +assert load_lif2[1]["titre"] == f2["titre"] + + +# --- Export de formation_id + +exp = sco_formations.formation_export(context.Notes, formation_id=f["formation_id"], format="json", REQUEST=REQUEST) + +load_exp = json.loads(exp) + +assert load_exp["acronyme"] == "F1" +assert load_exp["titre_officiel"] == "Titre officiel 1" +assert load_exp["titre"] == "Formation 1" +assert load_exp["formation_code"] == f["formation_code"] +assert len(load_exp["ue"]) == 3 +assert load_exp["ue"][0]["acronyme"] == "TST1" +assert load_exp["ue"][0]["titre"] == "ue test" +assert load_exp["formation_id"] == f["formation_id"] +assert load_exp["formation_code"] == f["formation_code"] + + +# --- Liste des semestres + +li_sem1 = context.Notes.formsemestre_list(formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_li_sem1 = json.loads(li_sem1) #uniquement le semestre 1 dans la liste + +assert len(load_li_sem1) == 1 +assert load_li_sem1[0]["date_fin"] == sem1["date_fin"] +assert load_li_sem1[0]["semestre_id"] == sem1["semestre_id"] +assert load_li_sem1[0]["formation_id"] ==sem1["formation_id"] + + +li_semf = context.Notes.formsemestre_list(formation_id=f["formation_id"], format = "json", REQUEST=REQUEST) +load_li_semf = json.loads(li_semf) + +assert load_li_sem1[0] in load_li_semf +assert len(load_li_semf) == 2 +assert load_li_semf[1]["semestre_id"] == sem2["semestre_id"] + + +li_sem = context.Notes.formsemestre_list(format = "json", REQUEST=REQUEST) +load_li_sem = json.loads(li_sem) + +assert len(load_li_sem) == 3 +assert load_li_semf[0] and load_li_semf[1] in load_li_sem +assert load_li_sem[0]["semestre_id"] == semt["semestre_id"] + + +# --- Liste des modules + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + + +assert len(load_lim_sem1) == 2 +assert mod["module_id"] == load_lim_sem1[0]["module_id"] or load_lim_sem1[1]["module_id"] +assert mod2["module_id"] == load_lim_sem1[0]["module_id"] or load_lim_sem1[1]["module_id"] + +lim_modid = sco_moduleimpl.do_moduleimpl_list(context.Notes, module_id=mod["module_id"], REQUEST=REQUEST) +load_lim_modid = json.loads(lim_modid) #Liste avec seulement mod + +assert len(load_lim_modid) == 1 + +lim_modimpl_id = sco_moduleimpl.do_moduleimpl_list(context.Notes, moduleimpl_id=mi["moduleimpl_id"], REQUEST=REQUEST) +print(lim_modimpl_id) + +# ---- Test de do_moduleimpl_withmodule_list + +assert lim_modid == lim_modimpl_id #doit etre le meme resultat + +liimp_sem1 = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_liimp_sem1 = json.loads(liimp_sem1) + +assert len(load_liimp_sem1) == 2 +assert mod["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] +assert mod2["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] +assert modt["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] + +liimp_modid = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, module_id=mod["module_id"], REQUEST=REQUEST) + +load_liimp_modid = json.loads(liimp_modid) +assert len(load_liimp_modid) == 1 + +liimp_modimplid = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, moduleimpl_id=mi["moduleimpl_id"], REQUEST=REQUEST) + +assert liimp_modid == liimp_modimplid + + +# --- Suppression du module, matiere et ue test du semestre 2 + +#on doit d'abbord supprimer le semestre + +#sco_formsemestre_edit.formsemestre_delete(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +#sco_formsemestre_edit.formsemestre_delete2(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) + +# RIEN NE SE PASSE AVEC CES FONCTIONS + +sco_formsemestre_edit.do_formsemestre_delete(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) + +#sco_edit_module.module_delete(context.Notes, module_id=modt["module_id"], REQUEST=REQUEST) +#sco_edit_matiere.matiere_delete(context.Notes, matiere_id=matt["matiere_id"], REQUEST=REQUEST) +#sco_edit_ue.ue_delete(context.Notes, ue_id=uet["ue_id"], REQUEST=REQUEST) + +# RIEN NE SE PASSE AVEC CES FONCTIONS + + +li_module = context.Notes.do_module_list() +assert len(li_module) == 4 +context.Notes.do_module_delete(oid=modt["module_id"], REQUEST=REQUEST) #on supprime le semestre +#sco_formsemestre_edit.formsemestre_delete_moduleimpls(context.Notes, formsemestre_id=sem2["formsemestre_id"], module_ids_to_del=[modt["module_id"]]) +#deuxieme methode de supression d'un module +li_module2 = context.Notes.do_module_list() + +assert len(li_module2) == 3 #verification de la suppression du module + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +assert len(load_lim_sem2) == 0 #deuxieme vérification si le module s'est bien sup + + +li_mat = context.Notes.do_matiere_list() +assert len(li_mat) == 4 +context.Notes.do_matiere_delete(oid=matt["matiere_id"], REQUEST=REQUEST) #on supprime la matiere +li_mat2 = context.Notes.do_matiere_list() +assert len(li_mat2) == 3 #verification de la suppression de la matiere + + +li_ue = context.Notes.do_ue_list() +assert len(li_ue) == 4 +sco_edit_ue.ue_delete(context.Notes, ue_id=uet["ue_id"], REQUEST=REQUEST) +li_ue2 = context.Notes.do_ue_list() +#assert len(li_ue) == 3 #verification de la suppression de l'UE #comment supprimer un ue? + + +# --- Suppression d'une formation + + +#Il faut d'abbord supprimer le semestre aussi. + +sco_formsemestre_edit.do_formsemestre_delete(context.Notes, formsemestre_id=semt["formsemestre_id"], REQUEST=REQUEST) + + +context.Notes.do_formation_delete(oid=f2["formation_id"], REQUEST=REQUEST) +lif3 = context.Notes.formation_list(format = 'json', REQUEST=REQUEST) + +load_lif3 = json.loads(lif3) +assert len(load_lif3) == 1 + + diff --git a/scotests/test_groupes.py b/scotests/test_groupes.py index 8ffa5d60d..142faf4e2 100755 --- a/scotests/test_groupes.py +++ b/scotests/test_groupes.py @@ -53,11 +53,12 @@ Fonctions de l’API utilisé : import random # La variable context est définie par le script de lancement -# l'affecte ainsi pour évietr les warnins pylint: +# l'affecte ainsi pour éviter les warnins pylint: context = context # pylint: disable=undefined-variable REQUEST = REQUEST # pylint: disable=undefined-variable import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error import sco_groups +import sco_groups_view G = sco_fake_gen.ScoFake(context.Notes) @@ -303,19 +304,31 @@ assert load_lijson_s1[0]["partition_name"] == "Eleve 1ere annee" -# --- Vue d'un groupes (liste d'élève en format json ou xml) +# --- Vue d'un groupes (liste d'élève en format json) +vue_g1 = sco_groups_view.groups_view(context.Scolarite, group_ids = [li_grp1[0]["group_id"]], format = "json", REQUEST=REQUEST) +load_vue_g1 = json.loads(vue_g1) +assert len(load_vue_g1) == 4 +assert load_vue_g1[0][li1[0]["partition_id"]] == li_grp1[0]["group_name"] +vue_sem = sco_groups_view.groups_view(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_vue_sem = json.loads(vue_sem) +assert len(load_vue_sem) == 10 +tab=[] +val=False +for etud in etuds[:10] : + for i in range(len(load_vue_sem)) : + if etud["prenom"] == load_vue_sem[i]["prenom"] and etud["nom_disp"]==load_vue_sem[i]["nom_disp"] : + val = True + tab.append(val) + +assert not False in tab #tout mes etudiants sont present dans vue_sem. # --- Test des fonctions dans sco_groups -#_ = sco_groups.checkGroupName(li_grp1[0]["group_name"]) -#_ = sco_groups.checkGroupName("Groupe S1B") -#_ = sco_groups.checkGroupName("Groupe S3A") -#_ = sco_groups.checkGroupName("Groupe S3B") assert li_grp1[0] == sco_groups.get_group(context.Scolarite, li_grp1[0]["group_id"]) #test get_group diff --git a/scotests/test_scenario1_app.py b/scotests/test_scenario1_app.py new file mode 100755 index 000000000..1d88e9b1d --- /dev/null +++ b/scotests/test_scenario1_app.py @@ -0,0 +1,117 @@ +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création de l'utilisateur responsable du semestres, des modules etc.... + +arg = {"passwd": "scodocpass", "user_name" : "unutil", "roles" :"Ens,RespPe"} +user = context.Users.create_user(args=arg, REQUEST=REQUEST) +print(user) + +# --- Création formation et de deux UE +f = G.create_formation(acronyme="") +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat11 = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod11 = G.create_module( + matiere_id=mat11["matiere_id"], + code="TSM11", + coefficient=1.0, + titre="module test11", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +mat12 = G.create_matiere(ue_id=ue["ue_id"], titre="matière test12") +mod12 = G.create_module( + matiere_id=mat12["matiere_id"], + code="TSM12", + coefficient=1.0, + titre="module test12", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + + +ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="TST2", titre="ue test2") +mat21 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test21") +mod21 = G.create_module( + matiere_id=mat21["matiere_id"], + code="TSM21", + coefficient=1.0, + titre="module test21", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +mat22 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test22") +mod22 = G.create_module( + matiere_id=mat22["matiere_id"], + code="TSM22", + coefficient=1.0, + titre="module test22", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +mods = [] +for module_id, formsemestre_id, responsable_id in [ + (mod11["module_id"], sem["formsemestre_id"], "bach"), + (mod12["module_id"], sem["formsemestre_id"], "bach"), + (mod21["module_id"], sem["formsemestre_id"], "bach"), + (mod22["module_id"], sem["formsemestre_id"], "bach") +] : + mi = G.create_moduleimpl(module_id=module_id, formsemestre_id=formsemestre_id, responsable_id=responsable_id) + mods.append(mi) + + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + + +# --- Création d'évaluations (2 par modules) + +evals=[] + +for moduleimpl_id, jour, description, coefficient in [ + (mods[0]["moduleimpl_id"], "01/02/2021", "e1", 1.0), + (mods[0]["moduleimpl_id"], "02/02/2021", "e2", 1.0), + (mods[1]["moduleimpl_id"], "03/02/2021", "e3", 1.0), + (mods[1]["moduleimpl_id"], "04/02/2021", "e4", 1.0), + (mods[2]["moduleimpl_id"], "05/02/2021", "e5", 1.0), + (mods[2]["moduleimpl_id"], "06/02/2021", "e6", 1.0), + (mods[3]["moduleimpl_id"], "07/02/2021", "e7", 1.0), + (mods[3]["moduleimpl_id"], "08/02/2021", "e8", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) + evals.append(e) + + +# --- Saisie des notes aléatoires + +for eval in evals : + for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=eval, etud=etud, note=float(random.randint(0, 20)) + ) + + + + diff --git a/scotests/test_scenario1_formation.py b/scotests/test_scenario1_formation.py new file mode 100755 index 000000000..6adf1bd86 --- /dev/null +++ b/scotests/test_scenario1_formation.py @@ -0,0 +1,72 @@ +import sco_formations +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) \ No newline at end of file diff --git a/scotests/test_scenario2_formation.py b/scotests/test_scenario2_formation.py new file mode 100755 index 000000000..4a77544a0 --- /dev/null +++ b/scotests/test_scenario2_formation.py @@ -0,0 +1,105 @@ +import sco_formations +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) \ No newline at end of file diff --git a/scotests/test_scenario3_formation.py b/scotests/test_scenario3_formation.py new file mode 100755 index 000000000..83f6b2123 --- /dev/null +++ b/scotests/test_scenario3_formation.py @@ -0,0 +1,135 @@ +import sco_formations +import json +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) + +# --- Création d'une évaluation pour chaque UE + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +lim_sem3 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem3["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem3 = json.loads(lim_sem3) + +lim_sem4 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem4["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem4 = json.loads(lim_sem4) + + +for moduleimpl_id, jour, description, coefficient in [ + (load_lim_sem1[1]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem1[2]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem2[1]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem2[8]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem3[3]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[9]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[15]["moduleimpl_id"], "04/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem4[3]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[9]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[13]["moduleimpl_id"], "05/02/2021", "InterroTestSemestre4", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) \ No newline at end of file diff --git a/scotests/test_scenario4_formation.py b/scotests/test_scenario4_formation.py new file mode 100755 index 000000000..b690022a0 --- /dev/null +++ b/scotests/test_scenario4_formation.py @@ -0,0 +1,172 @@ +import sco_formations +import json +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) + +# --- Création d'une évaluation pour chaque UE + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +lim_sem3 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem3["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem3 = json.loads(lim_sem3) + +lim_sem4 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem4["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem4 = json.loads(lim_sem4) + + +for moduleimpl_id, jour, description, coefficient in [ + (load_lim_sem1[1]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem1[2]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem2[1]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem2[8]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem3[3]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[9]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[15]["moduleimpl_id"], "04/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem4[3]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[9]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[13]["moduleimpl_id"], "05/02/2021", "InterroTestSemestre4", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) + + +# --- Saisie des notes des étudiants (un élève a 12, un autre a 7 pour chaque semestre) + +lie1 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem1["formsemestre_id"]) +lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem2["formsemestre_id"]) +lie3 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem3["formsemestre_id"]) +lie4 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem4["formsemestre_id"]) + +for eval in lie1 : + for etud in etuds[:2] : + if etud == etuds[0] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie2 : + for etud in etuds[2:4] : + if etud == etuds[2] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + + +for eval in lie3 : + for etud in etuds[4:6] : + if etud == etuds[4] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie4 : + for etud in etuds[6:] : + if etud == etuds[6] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) \ No newline at end of file diff --git a/scotests/test_user.py b/scotests/test_user.py new file mode 100755 index 000000000..00b47817a --- /dev/null +++ b/scotests/test_user.py @@ -0,0 +1,49 @@ +""" Créer un utilisateur, récupérer ses infos, + lister les utilisateurs, modifier le mdp, modfifier l'utilisateur (si possible), + changer d'admin, tester d'autre fonctionalités liés aux users """ + +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import ZScoUsers +import ZScoDoc +import ZScolar + + +nomdept = raw_input("Quel est le nom de votre département test? ATTENTION A NE PAS VOUS TROMPER : ") + +# --- Création d'un utilisateur + +arg = {"passwd": "scodocpass", "user_name" : "unutil", "nom" : "unnom", "prenom":"unprenom", "email": "unemail@mail.fr", "roles" :"Ens"+nomdept+",RespPe"+nomdept} +#user1 = context.Users.create_user(args=arg, REQUEST=REQUEST) +user_info1 = context.Users.user_info(user_name="unutil") + +assert user_info1["email"] == arg["email"] +assert user_info1["user_name"] == arg["user_name"] +assert user_info1["nom"] == "unnom" +assert user_info1["prenom"] == "unprenom" +assert user_info1["roles"] == arg["roles"] + + +# --- Récupération de la liste des Users + +liste_xml = context.Users.get_userlist_xml(REQUEST=REQUEST) + +liste_user = context.Users.get_userlist() +len_liu1 = len(liste_user) + +assert user_info1 in liste_user #le nouvel utilisateur est bien dans la liste ! + +# --- Changement du mot de passe de l'utilisateur + +#context.Users.change_password(user_name="unutil", password=) + +context.Users.do_change_password(user_name="unutil", password="scodocpass2") +#vérification du mdp changé directement sur scodoc web car je ne trouve pas comment récupérer le mdp en python +#Vérification : ok! + + + diff --git a/static/formation_export.json b/static/formation_export.json new file mode 100755 index 000000000..1c13dc0b1 --- /dev/null +++ b/static/formation_export.json @@ -0,0 +1,1352 @@ +{ + "acronyme": "DUT Info", + "code_specialite": "", + "type_parcours": 100, + "titre_officiel": "DUT Informatique", + "formation_code": "FCOD2", + "version": 1, + "ue": [ + { + "acronyme": "UE11", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M1101", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux syst\u00e8mes informatiques", + "heures_td": 20.0 + } + ], + "numero": 1 + }, + { + "titre": "Algorithmique - Programmation - Langages", + "module": [ + { + "coefficient": 2.0, + "code": "M1102", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "Algorithmique", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction \u00e0 l\u2019algorithmique et \u00e0 la programmation", + "heures_td": 20.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M1103", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "Structure de donn\u00e9es", + "numero": 3, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Structure de donn\u00e9es et algorithmes fondamentaux", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 3.0, + "code": "M1104", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "BDD", + "numero": 4, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux bases de donn\u00e9es", + "heures_td": 25.0 + } + ], + "numero": 4 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1105", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "CDIN", + "numero": 5, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception de documents et d\u2019interfaces num\u00e9riques", + "heures_td": 20.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M1106", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "Projet", + "numero": 6, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : d\u00e9couverte", + "heures_td": 0.0 + } + ], + "numero": 6 + } + ], + "ue_code": "UE11", + "numero": 1, + "titre": "Base de l'informatique", + "type": 0 + }, + { + "acronyme": "UE21", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M2101", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture et Programmation des m\u00e9canismes de base d\u2019un syst\u00e8me informatique", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M2102", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture des r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2103", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la programmation orient\u00e9e objet", + "heures_td": 20.0 + } + ], + "numero": 3 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2104", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "COO", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la conception orient\u00e9e objet", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Interface homme-machine", + "module": [ + { + "coefficient": 2.0, + "code": "M2105", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux interfaces homme-machine", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2106", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Programmation et administration des bases de donn\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M2107", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : Description et planification de projet", + "heures_td": 0.0 + } + ], + "numero": 7 + } + ], + "ue_code": "UE21", + "numero": 1, + "titre": "Informatique approfondie", + "type": 0 + }, + { + "acronyme": "UE31", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3101", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Principes des syst\u00e8mes d\u2019exploitation", + "heures_td": 14.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation, R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3102", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Services r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3103", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Algorithmique avanc\u00e9e", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3104", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Programmation Web c\u00f4t\u00e9 serveur", + "heures_td": 14.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 16.0, + "code": "M3105", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception et programmation objet avanc\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3106C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Bases de donn\u00e9es avanc\u00e9es", + "heures_td": 10.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD5", + "numero": 1, + "titre": "Informatique avanc\u00e9e", + "type": 0 + }, + { + "acronyme": "UE41", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M4101C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Administration syst\u00e8me et r\u00e9seau", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation \u2013 R\u00e9seaux Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4102C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation r\u00e9partie", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Web \u2013 Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M4103C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation Web \u2013 client riche", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 - Mobile", + "module": [ + { + "coefficient": 3.0, + "code": "M4104C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Conception et d\u00e9veloppement d\u2019applications mobiles", + "heures_td": 10.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4105C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Compl\u00e9ments d\u2019informatique en vue d\u2019une insertion imm\u00e9diate", + "heures_td": 10.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M4106", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 \u2013 Compl\u00e9ments", + "heures_td": 0.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD8", + "numero": 1, + "titre": "Compl\u00e9ments en informatique", + "type": 0 + }, + { + "acronyme": "UE12", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M1201", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 17.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Math\u00e9matiques discr\u00e8tes", + "heures_td": 18.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M1202", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 6.0, + "module_type": 0, + "titre": "Alg\u00e8bre lin\u00e9aire", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M1203", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Environnement \u00e9conomique", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Organisation", + "module": [ + { + "coefficient": 1.0, + "code": "M1204", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Fonctionnement des organisations", + "heures_td": 20.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1205", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Fondamentaux de la communication", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M1206", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Anglais et Informatique", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M1207", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conna\u00eetre le monde professionnel", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UE12", + "numero": 2, + "titre": "Bases de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE22", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M2201", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 18.0, + "abbrev": "", + "numero": 10, + "heures_cours": 11.0, + "module_type": 0, + "titre": "Graphes et langages", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2202", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Analyse et m\u00e9thodes num\u00e9riques", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Droit - Organisation", + "module": [ + { + "coefficient": 2.0, + "code": "M2203", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 12.0, + "module_type": 0, + "titre": "Environnement comptable, financier, juridique et social", + "heures_td": 18.0 + } + ], + "numero": 3 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2204", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Gestion de projet informatique", + "heures_td": 12.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M2205", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication, information et argumentation", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M2206", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communiquer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 1.0, + "code": "M2207", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Identifier ses comp\u00e9tences", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UCOD4", + "numero": 2, + "titre": "Approfondissements en culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE32", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M3201", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Probabilit\u00e9s et statistique", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3202C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Mod\u00e9lisations math\u00e9matiques", + "heures_td": 16.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3203", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Droit des technologies de l\u2019information et de la communication", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Gestion", + "module": [ + { + "coefficient": 2.0, + "code": "M3204", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Gestion des syst\u00e8mes d\u2019information", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M3205", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication professionnelle", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M3206", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Collaborer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD6", + "numero": 2, + "titre": "Culture scientifique, sociale et humaine avanc\u00e9es", + "type": 0 + }, + { + "acronyme": "UE33", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications \u00c9conomie - gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3301", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 24.0, + "abbrev": "", + "numero": 10, + "heures_cours": 14.0, + "module_type": 0, + "titre": "M\u00e9thodologie de la production d\u2019applications", + "heures_td": 22.0 + } + ], + "numero": 1 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M3302", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 - Mise en situation professionnelle", + "heures_td": 0.0 + } + ], + "numero": 2 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 2.0, + "code": "M3303", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Pr\u00e9ciser son projet", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 13 + } + ], + "ue_code": "UCOD7", + "numero": 2, + "titre": "M\u00e9thodologie et projets", + "type": 0 + }, + { + "acronyme": "UE42", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M4201C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Ateliers de cr\u00e9ation d\u2019entreprise", + "heures_td": 12.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M4202C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Introduction \u00e0 la recherche op\u00e9rationnelle et aide \u00e0 la d\u00e9cision", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "Expression \u2013 Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M4203", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication dans les organisations", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M4204", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Travailler en anglais", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 14 + } + ], + "ue_code": "UCOD9", + "numero": 2, + "titre": "Compl\u00e9ments de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE43", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "STAGE", + "module": [ + { + "coefficient": 12.0, + "code": "M4301", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Stage professionnel", + "heures_td": 0.0 + } + ], + "numero": 1 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS3", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 11 + } + ], + "ue_code": "UCOD10", + "numero": 3, + "titre": "Mise en situation professionnelle", + "type": 0 + } + ], + "titre": "DUT Informatique", + "formation_id": "FORM234" +} \ No newline at end of file