forked from ScoDoc/ScoDoc
début de modernisation des tests
This commit is contained in:
parent
3639d5db94
commit
a7324ac634
@ -597,7 +597,7 @@ def notes_add(
|
||||
nb_changed += 1
|
||||
if has_existing_decision(M, E, etudid):
|
||||
existing_decisions.append(etudid)
|
||||
except:
|
||||
except Exception as exc:
|
||||
log("*** exception in notes_add")
|
||||
if do_it:
|
||||
cnx.rollback() # abort
|
||||
@ -606,7 +606,7 @@ def notes_add(
|
||||
formsemestre_id=M["formsemestre_id"]
|
||||
) # > modif notes (exception)
|
||||
sco_cache.EvaluationCache.delete(evaluation_id)
|
||||
raise ScoGenError("Erreur enregistrement note: merci de ré-essayer")
|
||||
raise ScoGenError("Erreur enregistrement note: merci de ré-essayer") from exc
|
||||
if do_it:
|
||||
cnx.commit()
|
||||
sco_cache.invalidate_formsemestre(
|
||||
|
@ -11,7 +11,7 @@ from sqlalchemy.dialects import postgresql
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision = "f40fbaf5831c"
|
||||
down_revision = "91be8a06d423"
|
||||
down_revision = "197c658cefbb"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
@ -1,544 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<referentiel_competence specialite="RT" specialite_long="Réseaux et télécommunications" type="B.U.T.">
|
||||
<competences>
|
||||
<competence name="Administrer" numero="1" libelle_long="Administrer les réseaux et l’Internet" couleur="c1">
|
||||
<situations>
|
||||
<situation>Conception et administration de l’infrastructure du réseau informatique d’une entreprise</situation>
|
||||
<situation>Installation et administration des services réseau informatique d’une entreprise</situation>
|
||||
<situation>Déploiement et administration des solutions fixes pour les clients d’un opérateur de télécommunication </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en choisissant les solutions et technologies réseaux adaptées</composante>
|
||||
<composante>en respectant les principes fondamentaux de la sécurité informatique</composante>
|
||||
<composante>en utilisant une approche rigoureuse pour la résolution des dysfonctionnements </composante>
|
||||
<composante>en respectant les règles métiers</composante>
|
||||
<composante>en assurant une veille technologique </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Assister l’administrateur du réseau" annee="BUT1">
|
||||
<acs>
|
||||
<ac code="AC11.01">Maîtriser les lois fondamentales de l’électricité afin d’intervenir sur des équipements de réseaux et télécommunications</ac>
|
||||
<ac code="AC11.02">Comprendre l'architecture et les fondements des systèmes numériques, les principes du codage de l'information, des communications et de l'Internet</ac>
|
||||
<ac code="AC11.03">Configurer les fonctions de base du réseau local</ac>
|
||||
<ac code="AC11.04">Maîtriser les rôles et les principes fondamentaux des systèmes d’exploitation afin d’interagir avec ceux-ci pour la configuration et l'administration des réseaux et services fournis </ac>
|
||||
<ac code="AC11.05">Identifier les dysfonctionnements du réseau local et savoir les signaler</ac>
|
||||
<ac code="AC11.06">Installer un poste client, expliquer la procédure mise en place</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Administrer un réseau " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC21.01">Configurer et dépanner le routage dynamique dans un réseau</ac>
|
||||
<ac code="AC21.02">Configurer et expliquer une politique simple de QoS et les fonctions de base de la sécurité d’un réseau</ac>
|
||||
<ac code="AC21.03">Déployer des postes clients et des solutions virtualisées adaptées à une situation donnée</ac>
|
||||
<ac code="AC21.04">Déployer des services réseaux avancés</ac>
|
||||
<ac code="AC21.05">Identifier les réseaux opérateurs et l’architecture d’Internet</ac>
|
||||
<ac code="AC21.06">Travailler en équipe pour développer ses compétences professionnelles</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="3" libelle="Concevoir un réseau" annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC31.01">Concevoir un projet de réseau informatique d’une entreprise en intégrant les problématiques de haute disponibilité, de QoS, de sécurité et de supervision</ac>
|
||||
<ac code="AC31.02">Réaliser la documentation technique de ce projet</ac>
|
||||
<ac code="AC31.03">Réaliser une maquette de démonstration du projet</ac>
|
||||
<ac code="AC31.04">Défendre/argumenter un projet </ac>
|
||||
<ac code="AC31.05">Communiquer avec les acteurs du projet</ac>
|
||||
<ac code="AC31.06">Gérer le projet et les différentes étapes de sa mise en œuvre en respectant les délais </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Connecter" numero="2" libelle_long="Connecter les entreprises et les usagers " couleur="c2">
|
||||
<situations>
|
||||
<situation>Déploiement des supports et systèmes de transmission</situation>
|
||||
<situation>Mise en service et administration des équipements d’accès fixe ou mobile d’un opérateur de télécommunications </situation>
|
||||
<situation>Déploiement et administration des accès sans fil pour l'entreprise</situation>
|
||||
<situation>Déploiement des systèmes de communications </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en communiquant avec le client et les différents acteurs impliqués, parfois en anglais </composante>
|
||||
<composante>en faisant preuve d’une démarche scientifique</composante>
|
||||
<composante>en choisissant les solutions et technologies adaptées</composante>
|
||||
<composante>en proposant des solutions respectueuses de l'environnement </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Découvrir les transmissions et la ToIP" annee="BUT1">
|
||||
<acs>
|
||||
<ac code="AC12.01">Mesurer, analyser et commenter les signaux</ac>
|
||||
<ac code="AC12.02">Caractériser des systèmes de transmissions élémentaires et découvrir la modélisation mathématique de leur fonctionnement </ac>
|
||||
<ac code="AC12.03">Déployer des supports de transmission</ac>
|
||||
<ac code="AC12.04">Connecter les systèmes de ToIP</ac>
|
||||
<ac code="AC12.05">Communiquer avec un tiers (client, collaborateur...) et adapter son discours et sa langue à son interlocuteur</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Maîtriser les différentes composantes des solutions de connexion des entreprises et des usagers" annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC22.01">Déployer et caractériser des systèmes de transmissions complexes </ac>
|
||||
<ac code="AC22.02">Mettre en place un accès distant sécurisé</ac>
|
||||
<ac code="AC22.03">Mettre en place une connexion multi-site via un réseau opérateur</ac>
|
||||
<ac code="AC22.04">Déployer des réseaux d’accès des opérateurs</ac>
|
||||
<ac code="AC22.05">Capacité à questionner un cahier des charges RT</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="3" libelle="Déployer une solution de connexion ou de communication sur IP" annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC32.01">Déployer un système de communication pour l’entreprise</ac>
|
||||
<ac code="AC32.02">Déployer un réseau d’accès sans fil pour le réseau d’entreprise en intégrant les enjeux de la sécurité</ac>
|
||||
<ac code="AC32.03">Déployer un réseau d’accès fixe ou mobile pour un opérateur de télécommunications en intégrant la sécurité </ac>
|
||||
<ac code="AC32.04">Permettre aux collaborateurs de se connecter de manière sécurisée au système d’information de l’entreprise </ac>
|
||||
<ac code="AC32.05">Collaborer en mode projet en français et en anglais </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Programmer" numero="3" libelle_long="Créer des outils et applications informatiques pour les R&T " couleur="c3">
|
||||
<situations>
|
||||
<situation>Conception, déploiement et maintenance du système d’information d’une entreprise </situation>
|
||||
<situation>Automatisation du déploiement et de la maintenance des outils logiciels </situation>
|
||||
<situation>Développement d’outils informatiques à usage interne d'une équipe </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en étant à l’écoute des besoins du client</composante>
|
||||
<composante>en documentant le travail réalisé</composante>
|
||||
<composante>en utilisant les outils numériques à bon escient</composante>
|
||||
<composante>en choisissant les outils de développement adaptés </composante>
|
||||
<composante>en intégrant les problématiques de sécurité </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="S’intégrer dans un service informatique" annee="BUT1">
|
||||
<acs>
|
||||
<ac code="AC13.01">Utiliser un système informatique et ses outils</ac>
|
||||
<ac code="AC13.02">Lire, exécuter, corriger et modifier un programme</ac>
|
||||
<ac code="AC13.03">Traduire un algorithme, dans un langage et pour un environnement donné</ac>
|
||||
<ac code="AC13.04">Connaître l’architecture et les technologies d’un site Web</ac>
|
||||
<ac code="AC13.05">Choisir les mécanismes de gestion de données adaptés au développement de l’outil et argumenter ses choix</ac>
|
||||
<ac code="AC13.06">S’intégrer dans un environnement propice au développement et au travail collaboratif </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Développer une application R&T " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC23.01">Automatiser l’administration système avec des scripts</ac>
|
||||
<ac code="AC23.02">Développer une application à partir d’un cahier des charges donné, pour le Web ou les périphériques mobiles </ac>
|
||||
<ac code="AC23.03">Utiliser un protocole réseau pour programmer une application client/serveur</ac>
|
||||
<ac code="AC23.04">Installer, administrer un système de gestion de données</ac>
|
||||
<ac code="AC23.05">Accéder à un ensemble de données depuis une application et/ou un site web </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="3" libelle="Piloter un projet de développement d’une application R&T" annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC33.01">Élaborer les spécifications techniques et le cahier des charges d’une application informatique </ac>
|
||||
<ac code="AC33.02">Mettre en place un environnement de travail collaboratif</ac>
|
||||
<ac code="AC33.03">Participer à la formation des utilisateurs</ac>
|
||||
<ac code="AC33.04">Déployer et maintenir une solution informatique </ac>
|
||||
<ac code="AC33.05">S’informer sur les évolutions et les nouveautés technologiques </ac>
|
||||
<ac code="AC33.06">Sécuriser l'environnement numérique d'une application </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Sécuriser" numero="4" libelle_long="Administrer un système d’information sécurisé" couleur="c4">
|
||||
<situations>
|
||||
<situation>Analyse de l’existant et étude des besoins de sécurité d’une petite structure </situation>
|
||||
<situation>Évolution et mise en conformité du système d’information d’une entreprise </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en visant un juste compromis entre exigences de sécurité et contraintes d’utilisation </composante>
|
||||
<composante>en respectant les normes et le cadre juridique</composante>
|
||||
<composante>en intégrant les dernières technologies</composante>
|
||||
<composante>en travaillant en équipe</composante>
|
||||
<composante>en sensibilisant efficacement des utilisateurs </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Sensibiliser aux vulnérabilités d'un système d'information et aux remédiations possibles " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC24.01Cyber">Connaître et utiliser les bonnes pratiques et les recommandations de cybersécurité</ac>
|
||||
<ac code="AC24.02Cyber">Mettre en œuvre les outils fondamentaux de sécurisation d’une infrastructure du réseau </ac>
|
||||
<ac code="AC24.03Cyber">Sécuriser les services</ac>
|
||||
<ac code="AC24.04Cyber">Choisir les outils cryptographiques adaptés au besoin fonctionnel du système d’information </ac>
|
||||
<ac code="AC24.05Cyber">Connaître les différents types d’attaque</ac>
|
||||
<ac code="AC24.06Cyber">Comprendre des documents techniques en anglais </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Mettre en œuvre un système d’information sécurisé pour une petite structure " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC34.01Cyber">Participer activement à une analyse de risque pour définir une politique de sécurité pour une petite structure </ac>
|
||||
<ac code="AC34.02Cyber">Mettre en œuvre des outils avancés de sécurisation d’une infrastructure du réseau</ac>
|
||||
<ac code="AC34.03Cyber">Sécuriser les systèmes d’exploitation</ac>
|
||||
<ac code="AC34.04Cyber">Proposer une architecture sécurisée de système d'information pour une petite structure </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Orchestrer" numero="5" libelle_long="Coordonner des infrastructures modulaires" couleur="c4">
|
||||
<situations>
|
||||
<situation>Industrialisation du déploiement des infrastructures systèmes, réseaux et sécurité en sauvegardant et en restaurant ses configurations</situation>
|
||||
<situation>Maintenance des outils pour l’intégration et la mise en production du code logiciel</situation>
|
||||
<situation>Administration d’un cluster de containers </situation>
|
||||
<situation>Analyse des performances d’un système pour améliorer les processus de production </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en respectant un cahier des charges</composante>
|
||||
<composante>en documentant le travail réalisé</composante>
|
||||
<composante>en intégrant les problématiques de sécurité</composante>
|
||||
<composante>en assurant une veille technologique</composante>
|
||||
<composante>en respectant les pratiques d’équipes et des méthodes de production </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Assister l’administrateur infrastructure et Cloud " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC24.01DevCloud">Proposer une solution Cloud adaptée à l’entreprise </ac>
|
||||
<ac code="AC24.02DevCloud">Virtualiser un environnement</ac>
|
||||
<ac code="AC24.03DevCloud">Utiliser les services du Cloud</ac>
|
||||
<ac code="AC24.04DevCloud">Analyser un service Cloud au travers des métriques </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Administrer une infrastructure Cloud" annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC34.01DevCloud">Concevoir, administrer et superviser une infrastructure Cloud</ac>
|
||||
<ac code="AC34.02DevCloud">Orchestrer les ressources Cloud</ac>
|
||||
<ac code="AC34.03DevCloud">Investiguer sur les incidents et les résoudre afin d’améliorer la qualité et la fiabilité des infrastructures </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Etendre" numero="6" libelle_long="Gérer les infrastructures des réseaux mobiles " couleur="c4">
|
||||
<situations>
|
||||
<situation>Gestion des infrastructures d’un opérateur de réseaux mobiles et d’Internet des Objets</situation>
|
||||
<situation>Gestion des infrastructures de réseaux mobiles dans le contexte industriel, personnel ou médical </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en respectant les normes et protocoles en vigueur </composante>
|
||||
<composante>en intégrant les dernières technologies mobiles </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Mettre en œuvre les réseaux pour la mobilité " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC24.01IOM">Comprendre les architectures et spécificités des réseaux dédiés à l'IoT</ac>
|
||||
<ac code="AC24.02IOM">Mettre en œuvre des systèmes de transmissions pour l’accès à un réseau IoT</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Raccorder des objets connectés aux réseaux mobiles " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC34.01IOM">Comprendre les architectures, protocoles et services des réseaux mobiles 4G/5G</ac>
|
||||
<ac code="AC34.02IOM">Choisir un réseau pour satisfaire les contraintes énergétiques et spectrales, en délai, en débit et en portée des objets connectés</ac>
|
||||
<ac code="AC34.03IOM">Mettre en œuvre des réseaux mobiles personnels ou industriels</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Piloter" numero="7" libelle_long="Mettre en œuvre des projets techniques et réglementaires des R&T dans son activité " couleur="c4">
|
||||
<situations>
|
||||
<situation>Adéquation technique des solutions réseaux informatiques et télécoms à la demande client </situation>
|
||||
<situation>Élaboration de solutions techniques clients adaptées</situation>
|
||||
<situation>Accompagnement technique de la mise en place des solutions clients </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en maîtrisant les enjeux techniques et réglementaires des nouvelles technologies</composante>
|
||||
<composante>en pilotant un projet technique R&T</composante>
|
||||
<composante>en faisant preuve de vision stratégique en phase avec le marché des réseaux et des télécommunications </composante>
|
||||
<composante>en collaborant de façon responsable avec des équipes </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Mettre en œuvre un projet R&T " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC24.01PPR">Compréhension d’un cahier des charges technique R&T </ac>
|
||||
<ac code="AC24.02PPR">Planification des étapes d’un projet technique R&T</ac>
|
||||
<ac code="AC24.03PPR">Co-animation d’une équipe technique</ac>
|
||||
<ac code="AC24.04PPR">Proposition de solutions techniques R&T efficientes</ac>
|
||||
<ac code="AC24.05PPR">Échanges vulgarisés ou techniques avec tous les acteurs d’un projet </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Opérationnaliser un projet R&T " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC34.01PPR">Rédaction d'un appel d'offres ou d'un cahier des charges technique R&T</ac>
|
||||
<ac code="AC34.02PPR">Animation technique d’équipes pluridisciplinaires</ac>
|
||||
<ac code="AC34.03PPR">Coordination d’équipes sur une partie de projet R&T ou sa totalité</ac>
|
||||
<ac code="AC34.04PPR">Mise en place de solutions techniques R&T efficientes</ac>
|
||||
<ac code="AC34.05PPR">Livraison et suivi technique de projet R&T</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Rapprocher" numero="8" libelle_long="Gérer les infrastructures et les services des réseaux opérateurs " couleur="c4">
|
||||
<situations>
|
||||
<situation>Gestion des services d’un ensemble de clients entreprises d’un opérateur </situation>
|
||||
<situation>Gestion du déploiement de nouvelles infrastructures </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en respectant les règles métiers et les délais</composante>
|
||||
<composante>en assurant une communication optimale avec le client</composante>
|
||||
<composante>en mettant en place des processus opérationnels de gestion d’incidents </composante>
|
||||
<composante>en pilotant les acteurs terrain </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Gérer les infrastructures des réseaux opérateurs " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC24.01ROM">Administrer les réseaux d’accès fixes et mobiles</ac>
|
||||
<ac code="AC24.02ROM">Virtualiser des services réseaux</ac>
|
||||
<ac code="AC24.03ROM">Décrire/comprendre l’architecture et les offres des opérateurs </ac>
|
||||
<ac code="AC24.04ROM">Gérer le routage/commutation et les interconnexions </ac>
|
||||
<ac code="AC24.05ROM">Automatiser la gestion des équipements réseaux </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Administrer les services des opérateurs de télécommunications " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC34.01ROM">Administrer/superviser les infrastructures et les services télécom</ac>
|
||||
<ac code="AC34.02ROM">Administrer et déployer des fonctions réseaux virtualisées et programmer le réseau</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Surveiller" numero="9" libelle_long="Surveiller un système d’information sécurisé" couleur="c5">
|
||||
<situations>
|
||||
<situation>Surveillance et analyse du système d’information </situation>
|
||||
<situation>Audit de sécurité</situation>
|
||||
<situation>Gestion d’un incident de sécurité </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en assurant une veille permanente</composante>
|
||||
<composante>en réalisant les mises à jour critiques</composante>
|
||||
<composante>en automatisant des tâches</composante>
|
||||
<composante>en s’intégrant dans une équipe</composante>
|
||||
<composante>en surveillant le comportement du réseau</composante>
|
||||
<composante>en veillant au respect des contrats et à la conformité des obligations du système d'information </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Prendre en main les outils de surveillance et de test du système d'information " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC25.01Cyber">Administrer les protections contre les logiciels malveillants </ac>
|
||||
<ac code="AC25.02Cyber">Prendre en main des outils de test de pénétration réseau/système</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Mettre en œuvre le système de surveillance d’incidents de sécurité " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC35.01Cyber">Surveiller l’activité du système d’information</ac>
|
||||
<ac code="AC35.02Cyber">Appliquer une méthodologie de tests de pénétration</ac>
|
||||
<ac code="AC35.03Cyber">Réagir face à un incident de sécurité</ac>
|
||||
<ac code="AC35.04Cyber">Administrer les outils de surveillance du système d’information</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Développer" numero="10" libelle_long="Accompagner le développement d’applications" couleur="c5">
|
||||
<situations>
|
||||
<situation>Déploiement d’une application</situation>
|
||||
<situation>Intervention sur la chaîne de développement dans une optique DevOps </situation>
|
||||
<situation>Surveillance de la qualité de la production</situation>
|
||||
<situation>Mise en place des services réseaux nécessaires au développement </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en respectant un cahier des charges</composante>
|
||||
<composante>en documentant le travail réalisé</composante>
|
||||
<composante>en respectant les bonnes pratiques de développement et de production </composante>
|
||||
<composante>en visant l’amélioration continue </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Développer pour le Cloud " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC25.01DevCloud">Développer un microservice</ac>
|
||||
<ac code="AC25.02DevCloud">Mettre en production une application</ac>
|
||||
<ac code="AC25.03DevCloud">Programmer son réseau par le code</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="S’intégrer dans une équipe DevOps " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC35.01DevCloud">Adopter les pratiques de pilotage de projet</ac>
|
||||
<ac code="AC35.02DevCloud">Concevoir, gérer et sécuriser un environnement de microservices </ac>
|
||||
<ac code="AC35.03DevCloud">Gérer son infrastructure comme du code </ac>
|
||||
<ac code="AC35.04DevCloud">Gérer une chaîne d’intégration et/ou de déploiement continu </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Exploiter" numero="11" libelle_long="Mettre en œuvre des applications et des protocoles sécurisés pour l’Internet des Objets " couleur="c5">
|
||||
<situations>
|
||||
<situation>Déploiement d’un système IoT de la source capteur aux traitements des données </situation>
|
||||
<situation>Gestion, administration et sécurisation d’un système IoT </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en travaillant au sein d’une équipe pluridisciplinaire</composante>
|
||||
<composante>en respectant les normes et contraintes opérationnelles </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Mettre en œuvre des solutions pour l’Internet des Objets " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC25.01IOM">Intégrer des systèmes électroniques et des systèmes d’exploitation embarqués </ac>
|
||||
<ac code="AC25.02IOM">Mettre en œuvre des protocoles pour les réseaux de l’IoT</ac>
|
||||
<ac code="AC25.03IOM">Mettre en œuvre des applications et traiter des données issues des objets connectés </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Créer des solutions sécurisées pour l’Internet des Objets " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC35.01IOM">Superviser et analyser le déploiement des réseaux sans-fil </ac>
|
||||
<ac code="AC35.02IOM">Sécuriser les objets connectés</ac>
|
||||
<ac code="AC35.03IOM">Créer et innover pour l’IoT </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Organiser" numero="12" libelle_long="Gérer des activités réseaux et télécommunications en termes organisationnels, relationnels, financiers et commerciaux" couleur="c5">
|
||||
<situations>
|
||||
<situation>Communication et stratégie technique en interne et en externe pour des projets R&T </situation>
|
||||
<situation>Suivi des objectifs opérationnels de projets R&T</situation>
|
||||
<situation>Pilotage de la relation client </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en pilotant avec agilité des solutions techniques</composante>
|
||||
<composante>en sachant communiquer à l’écrit et à l’oral avec tous les acteurs d’un projet</composante>
|
||||
<composante>en respectant des contraintes technico-économiques (financières, éthiques, temporelles, contractuelles, qualité) </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Élaborer un projet technique " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC25.01PPR">Prise en compte des contraintes d’un pilotage de projet R&T</ac>
|
||||
<ac code="AC25.02PPR">Planification de solutions techniques R&T efficientes</ac>
|
||||
<ac code="AC25.03PPR">Prise de conscience des enjeux de la communication dans les relations interpersonnelles </ac>
|
||||
<ac code="AC25.04PPR">Établissement d’un relationnel de qualité </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Mettre en place et suivre un projet technique " annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC35.01PPR">Rigueur dans le pilotage d’un projet R&T dans sa globalité</ac>
|
||||
<ac code="AC35.02PPR">Flexibilité dans la gestion des équipes et des tâches</ac>
|
||||
<ac code="AC35.03PPR">Prise de responsabilité envers les équipes</ac>
|
||||
<ac code="AC35.04PPR">Valorisation de solutions déployées, ou d’offres techniques, ou d’offres commerciales </ac>
|
||||
<ac code="AC35.05PPR">Force de propositions de solutions R&T innovantes responsables</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
<competence name="Unifier" numero="13" libelle_long="Gérer les communications unifiées et la vidéo sur Internet " couleur="c5">
|
||||
<situations>
|
||||
<situation>Déploiement et administration des services de communication </situation>
|
||||
<situation>Administration des services multimédia </situation>
|
||||
</situations>
|
||||
<composantes_essentielles>
|
||||
<composante>en automatisant la gestion réseau des communications </composante>
|
||||
<composante>en sécurisant les infrastructures</composante>
|
||||
<composante>en gérant les interconnexions</composante>
|
||||
<composante>en assurant une communication optimale avec le client </composante>
|
||||
<composante>en respectant les règles métiers et les délais </composante>
|
||||
</composantes_essentielles>
|
||||
<niveaux>
|
||||
<niveau ordre="1" libelle="Mettre en oeuvre le système de téléphonie de l’entreprise " annee="BUT2">
|
||||
<acs>
|
||||
<ac code="AC25.01ROM">Choisir une architecture et déployer des services de ToIP </ac>
|
||||
<ac code="AC25.02ROM">Administrer un service de téléphonie pour l’entreprise </ac>
|
||||
<ac code="AC25.03ROM">Mettre en place une politique de QoS pour les applications </ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
<niveau ordre="2" libelle="Administrer les communications unifiées et les services vidéo de l’entreprise" annee="BUT3">
|
||||
<acs>
|
||||
<ac code="AC35.01ROM">Administrer les services multimédias pour une entreprise</ac>
|
||||
</acs>
|
||||
</niveau>
|
||||
</niveaux>
|
||||
</competence>
|
||||
</competences>
|
||||
<parcours>
|
||||
<parcour numero="1" libelle="Cybersécurité" code="Cyber">
|
||||
<annee ordre="1">
|
||||
<competence nom="Administrer" niveau="1"/>
|
||||
<competence nom="Connecter" niveau="1"/>
|
||||
<competence nom="Programmer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="2">
|
||||
<competence nom="Administrer" niveau="2"/>
|
||||
<competence nom="Connecter" niveau="2"/>
|
||||
<competence nom="Programmer" niveau="2"/>
|
||||
<competence nom="Sécuriser" niveau="1"/>
|
||||
<competence nom="Surveiller" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="3">
|
||||
<competence nom="Administrer" niveau="3"/>
|
||||
<competence nom="Connecter" niveau="3"/>
|
||||
<competence nom="Programmer" niveau="3"/>
|
||||
<competence nom="Sécuriser" niveau="2"/>
|
||||
<competence nom="Surveiller" niveau="2"/>
|
||||
</annee>
|
||||
</parcour>
|
||||
<parcour numero="2" libelle="Développement système et cloud" code="DevCloud">
|
||||
<annee ordre="1">
|
||||
<competence nom="Administrer" niveau="1"/>
|
||||
<competence nom="Connecter" niveau="1"/>
|
||||
<competence nom="Programmer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="2">
|
||||
<competence nom="Administrer" niveau="2"/>
|
||||
<competence nom="Connecter" niveau="2"/>
|
||||
<competence nom="Programmer" niveau="2"/>
|
||||
<competence nom="Orchestrer" niveau="1"/>
|
||||
<competence nom="Développer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="3">
|
||||
<competence nom="Administrer" niveau="3"/>
|
||||
<competence nom="Connecter" niveau="3"/>
|
||||
<competence nom="Programmer" niveau="3"/>
|
||||
<competence nom="Orchestrer" niveau="2"/>
|
||||
<competence nom="Développer" niveau="2"/>
|
||||
</annee>
|
||||
</parcour>
|
||||
<parcour numero="3" libelle="Internet des objets et mobilité" code="IOM">
|
||||
<annee ordre="1">
|
||||
<competence nom="Administrer" niveau="1"/>
|
||||
<competence nom="Connecter" niveau="1"/>
|
||||
<competence nom="Programmer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="2">
|
||||
<competence nom="Administrer" niveau="2"/>
|
||||
<competence nom="Connecter" niveau="2"/>
|
||||
<competence nom="Programmer" niveau="2"/>
|
||||
<competence nom="Etendre" niveau="1"/>
|
||||
<competence nom="Exploiter" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="3">
|
||||
<competence nom="Administrer" niveau="3"/>
|
||||
<competence nom="Connecter" niveau="3"/>
|
||||
<competence nom="Programmer" niveau="3"/>
|
||||
<competence nom="Etendre" niveau="2"/>
|
||||
<competence nom="Exploiter" niveau="2"/>
|
||||
</annee>
|
||||
</parcour>
|
||||
<parcour numero="4" libelle="Pilotage de projets de réseaux" code="PPR">
|
||||
<annee ordre="1">
|
||||
<competence nom="Administrer" niveau="1"/>
|
||||
<competence nom="Connecter" niveau="1"/>
|
||||
<competence nom="Programmer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="2">
|
||||
<competence nom="Administrer" niveau="2"/>
|
||||
<competence nom="Connecter" niveau="2"/>
|
||||
<competence nom="Programmer" niveau="2"/>
|
||||
<competence nom="Piloter" niveau="1"/>
|
||||
<competence nom="Organiser" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="3">
|
||||
<competence nom="Administrer" niveau="3"/>
|
||||
<competence nom="Connecter" niveau="3"/>
|
||||
<competence nom="Programmer" niveau="3"/>
|
||||
<competence nom="Piloter" niveau="2"/>
|
||||
<competence nom="Organiser" niveau="2"/>
|
||||
</annee>
|
||||
</parcour>
|
||||
<parcour numero="5" libelle="Réseaux Opérateurs et Multimédia" code="ROM">
|
||||
<annee ordre="1">
|
||||
<competence nom="Administrer" niveau="1"/>
|
||||
<competence nom="Connecter" niveau="1"/>
|
||||
<competence nom="Programmer" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="2">
|
||||
<competence nom="Administrer" niveau="2"/>
|
||||
<competence nom="Connecter" niveau="2"/>
|
||||
<competence nom="Programmer" niveau="2"/>
|
||||
<competence nom="Rapprocher" niveau="1"/>
|
||||
<competence nom="Unifier" niveau="1"/>
|
||||
</annee>
|
||||
<annee ordre="3">
|
||||
<competence nom="Administrer" niveau="3"/>
|
||||
<competence nom="Connecter" niveau="3"/>
|
||||
<competence nom="Programmer" niveau="3"/>
|
||||
<competence nom="Rapprocher" niveau="2"/>
|
||||
<competence nom="Unifier" niveau="2"/>
|
||||
</annee>
|
||||
</parcour>
|
||||
</parcours>
|
||||
</referentiel_competence>
|
@ -143,7 +143,7 @@ class ScoFake(object):
|
||||
type_parcours=sco_codes_parcours.ParcoursDUT.TYPE_PARCOURS,
|
||||
formation_code=None,
|
||||
code_specialite=None,
|
||||
):
|
||||
) -> int:
|
||||
"""Crée une formation"""
|
||||
if not acronyme:
|
||||
acronyme = "TEST" + str(random.randint(100000, 999999))
|
||||
@ -151,7 +151,7 @@ class ScoFake(object):
|
||||
oids = sco_formations.formation_list(formation_id=oid)
|
||||
if not oids:
|
||||
raise ScoValueError("formation not created !")
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def create_ue(
|
||||
@ -167,23 +167,25 @@ class ScoFake(object):
|
||||
code_apogee=None,
|
||||
coefficient=None,
|
||||
semestre_idx=None,
|
||||
):
|
||||
"""Crée une UE"""
|
||||
) -> int:
|
||||
"""Crée une UE.
|
||||
return: ue_id
|
||||
"""
|
||||
if numero is None:
|
||||
numero = sco_edit_ue.next_ue_numero(formation_id, 0)
|
||||
oid = sco_edit_ue.do_ue_create(locals())
|
||||
oids = sco_edit_ue.ue_list(args={"ue_id": oid})
|
||||
if not oids:
|
||||
raise ScoValueError("ue not created !")
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def create_matiere(self, ue_id=None, titre=None, numero=None):
|
||||
def create_matiere(self, ue_id=None, titre=None, numero=None) -> int:
|
||||
oid = sco_edit_matiere.do_matiere_create(locals())
|
||||
oids = sco_edit_matiere.matiere_list(args={"matiere_id": oid})
|
||||
if not oids:
|
||||
raise ScoValueError("matiere not created !")
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def create_module(
|
||||
@ -203,12 +205,12 @@ class ScoFake(object):
|
||||
ects=None,
|
||||
code_apogee=None,
|
||||
module_type=None,
|
||||
):
|
||||
) -> int:
|
||||
oid = sco_edit_module.do_module_create(locals())
|
||||
oids = sco_edit_module.module_list(args={"module_id": oid})
|
||||
if not oids:
|
||||
raise ScoValueError("module not created ! (oid=%s)" % oid)
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def create_formsemestre(
|
||||
@ -232,7 +234,7 @@ class ScoFake(object):
|
||||
elt_annee_apo=None,
|
||||
etapes=None,
|
||||
responsables=None, # sequence of resp. ids
|
||||
):
|
||||
) -> int:
|
||||
if responsables is None:
|
||||
responsables = (self.default_user.id,)
|
||||
oid = sco_formsemestre.do_formsemestre_create(locals())
|
||||
@ -241,7 +243,7 @@ class ScoFake(object):
|
||||
) # API inconsistency
|
||||
if not oids:
|
||||
raise ScoValueError("formsemestre not created !")
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def create_moduleimpl(
|
||||
@ -249,19 +251,19 @@ class ScoFake(object):
|
||||
module_id: int = None,
|
||||
formsemestre_id: int = None,
|
||||
responsable_id: typing.Optional[int] = None,
|
||||
):
|
||||
) -> int:
|
||||
if not responsable_id:
|
||||
responsable_id = self.default_user.id
|
||||
oid = sco_moduleimpl.do_moduleimpl_create(locals())
|
||||
oids = sco_moduleimpl.moduleimpl_list(moduleimpl_id=oid) # API inconsistency
|
||||
if not oids:
|
||||
raise ScoValueError("moduleimpl not created !")
|
||||
return oids[0]
|
||||
return oid
|
||||
|
||||
@logging_meth
|
||||
def inscrit_etudiant(self, sem, etud):
|
||||
def inscrit_etudiant(self, formsemestre_id: int, etud: dict):
|
||||
sco_formsemestre_inscriptions.do_formsemestre_inscription_with_modules(
|
||||
sem["formsemestre_id"],
|
||||
formsemestre_id,
|
||||
etud["etudid"],
|
||||
etat="I",
|
||||
etape=etud.get("etape", None),
|
||||
@ -323,32 +325,32 @@ class ScoFake(object):
|
||||
et dans chaque UE `nb_module_per_ue` modules (on a une seule matière par UE).
|
||||
|
||||
Returns:
|
||||
formation (dict), liste d'ue (dicts), liste de modules.
|
||||
formation_id, liste d'ue (dicts), liste de modules.
|
||||
"""
|
||||
f = self.create_formation(acronyme=acronyme, titre=titre)
|
||||
ues = []
|
||||
mod_list = []
|
||||
formation_id = self.create_formation(acronyme=acronyme, titre=titre)
|
||||
ue_ids = []
|
||||
mod_ids = []
|
||||
for semestre_id in range(1, nb_semestre + 1):
|
||||
for n in range(1, nb_ue_per_semestre + 1):
|
||||
ue = self.create_ue(
|
||||
formation_id=f["formation_id"],
|
||||
ue_id = self.create_ue(
|
||||
formation_id=formation_id,
|
||||
acronyme="TSU%s%s" % (semestre_id, n),
|
||||
titre="ue test %s%s" % (semestre_id, n),
|
||||
)
|
||||
ues.append(ue)
|
||||
mat = self.create_matiere(ue_id=ue["ue_id"], titre="matière test")
|
||||
ue_ids.append(ue_id)
|
||||
matiere_id = self.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
for _ in range(nb_module_per_ue):
|
||||
mod = self.create_module(
|
||||
matiere_id=mat["matiere_id"],
|
||||
matiere_id=matiere_id,
|
||||
semestre_id=semestre_id,
|
||||
code="TSM%s" % len(mod_list),
|
||||
code="TSM%s" % len(mod_ids),
|
||||
coefficient=1.0,
|
||||
titre="module test",
|
||||
ue_id=ue["ue_id"], # faiblesse de l'API
|
||||
formation_id=f["formation_id"], # faiblesse de l'API
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
mod_list.append(mod)
|
||||
return f, ues, mod_list
|
||||
mod_ids.append(mod)
|
||||
return formation_id, ue_ids, mod_ids
|
||||
|
||||
def setup_formsemestre(
|
||||
self,
|
||||
@ -363,7 +365,7 @@ class ScoFake(object):
|
||||
modalite=None,
|
||||
):
|
||||
"""Création semestre, avec modules et évaluations."""
|
||||
sem = self.create_formsemestre(
|
||||
formsemestre_id = self.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
semestre_id=semestre_id,
|
||||
date_debut=date_debut,
|
||||
@ -375,20 +377,20 @@ class ScoFake(object):
|
||||
eval_list = []
|
||||
for mod in mod_list:
|
||||
if mod["semestre_id"] == semestre_id:
|
||||
mi = self.create_moduleimpl(
|
||||
moduleimpl_id = self.create_moduleimpl(
|
||||
module_id=mod["module_id"],
|
||||
formsemestre_id=sem["formsemestre_id"],
|
||||
formsemestre_id=formsemestre_id,
|
||||
responsable_id="bach",
|
||||
)
|
||||
for e_idx in range(1, nb_evaluations_per_module + 1):
|
||||
e = self.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour=date_debut,
|
||||
description="evaluation test %s" % e_idx,
|
||||
coefficient=1.0,
|
||||
)
|
||||
eval_list.append(e)
|
||||
return sem, eval_list
|
||||
return formsemestre_id, eval_list
|
||||
|
||||
def set_etud_notes_sem(
|
||||
self, sem, eval_list, etuds, notes=None, random_min=0, random_max=20
|
||||
@ -411,7 +413,7 @@ class ScoFake(object):
|
||||
|
||||
def set_code_jury(
|
||||
self,
|
||||
sem,
|
||||
formsemestre_id,
|
||||
etud,
|
||||
code_etat=sco_codes_parcours.ADM,
|
||||
devenir=sco_codes_parcours.NEXT,
|
||||
@ -419,7 +421,7 @@ class ScoFake(object):
|
||||
):
|
||||
"""Affecte décision de jury"""
|
||||
sco_formsemestre_validation.formsemestre_validation_etud_manu(
|
||||
formsemestre_id=sem["formsemestre_id"],
|
||||
formsemestre_id=formsemestre_id,
|
||||
etudid=etud["etudid"],
|
||||
code_etat=code_etat,
|
||||
devenir=devenir,
|
||||
|
@ -10,41 +10,67 @@ import app.scodoc.sco_utils as scu
|
||||
from app.scodoc import sco_codes_parcours
|
||||
|
||||
|
||||
def build_formation_test(nb_mods=1):
|
||||
def build_formation_test(
|
||||
nb_mods=1, parcours=sco_codes_parcours.ParcoursBUT, with_ue_sport=False
|
||||
):
|
||||
G = sco_fake_gen.ScoFake(verbose=False)
|
||||
_f = G.create_formation(
|
||||
formation_id = G.create_formation(
|
||||
acronyme="F3",
|
||||
titre="Formation 2",
|
||||
titre_officiel="Titre officiel 2",
|
||||
type_parcours=sco_codes_parcours.ParcoursBUT.TYPE_PARCOURS,
|
||||
type_parcours=parcours.TYPE_PARCOURS,
|
||||
)
|
||||
_ue1 = G.create_ue(
|
||||
formation_id=_f["formation_id"], acronyme="UE1", titre="ue 1", semestre_idx=2
|
||||
formation_id=formation_id, acronyme="UE1", titre="ue 1", semestre_idx=2
|
||||
)
|
||||
_ue2 = G.create_ue(
|
||||
formation_id=_f["formation_id"], acronyme="UE2", titre="ue 2", semestre_idx=2
|
||||
formation_id=formation_id, acronyme="UE2", titre="ue 2", semestre_idx=2
|
||||
)
|
||||
_ue3 = G.create_ue(
|
||||
formation_id=_f["formation_id"], acronyme="UE3", titre="ue 3", semestre_idx=2
|
||||
formation_id=formation_id, acronyme="UE3", titre="ue 3", semestre_idx=2
|
||||
)
|
||||
ue_ids = [_ue1, _ue2, _ue3]
|
||||
# une 4eme UE en dehors du semestre 2
|
||||
_ = G.create_ue(
|
||||
formation_id=_f["formation_id"], acronyme="UE41", titre="ue 41", semestre_idx=4
|
||||
formation_id=formation_id, acronyme="UE41", titre="ue 41", semestre_idx=4
|
||||
)
|
||||
_mat = G.create_matiere(ue_id=_ue1["ue_id"], titre="matière test")
|
||||
matiere_id = G.create_matiere(ue_id=_ue1, titre="matière test")
|
||||
module_ids = []
|
||||
for i in range(nb_mods):
|
||||
mod = G.create_module(
|
||||
matiere_id=_mat["matiere_id"],
|
||||
module_id = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code=f"TSM{i}",
|
||||
coefficient=1.0,
|
||||
titre=f"module test {i}",
|
||||
ue_id=_ue1["ue_id"],
|
||||
formation_id=_f["formation_id"],
|
||||
ue_id=_ue1,
|
||||
formation_id=formation_id,
|
||||
semestre_id=2,
|
||||
module_type=scu.ModuleType.RESSOURCE
|
||||
if parcours.APC_SAE
|
||||
else scu.ModuleType.STANDARD,
|
||||
)
|
||||
module_ids.append(module_id)
|
||||
if with_ue_sport:
|
||||
ue_sport = G.create_ue(
|
||||
formation_id=formation_id,
|
||||
acronyme="UESPO",
|
||||
titre="ue sport",
|
||||
semestre_idx=2,
|
||||
type=sco_codes_parcours.UE_SPORT,
|
||||
)
|
||||
ue_ids.append(ue_sport)
|
||||
mat_sport = G.create_matiere(ue_id=ue_sport, titre="matière spo")
|
||||
mod_sport = G.create_module(
|
||||
matiere_id=mat_sport,
|
||||
code="BAD",
|
||||
coefficient=1.0,
|
||||
titre="module sport",
|
||||
ue_id=ue_sport,
|
||||
formation_id=formation_id,
|
||||
semestre_id=2,
|
||||
)
|
||||
module_ids.append(mod["id"])
|
||||
return G, _f["id"], _ue1["id"], _ue2["id"], _ue3["id"], module_ids
|
||||
module_ids.append(mod_sport)
|
||||
return G, formation_id, ue_ids, module_ids
|
||||
|
||||
|
||||
def build_modules_with_evaluations(
|
||||
@ -55,7 +81,7 @@ def build_modules_with_evaluations(
|
||||
- 1 semestre, nb_mod moduleimpl, 1 eval/moduleimpl
|
||||
"""
|
||||
nb_ues = len(ue_coefs) # 3 UEs par défaut dans ce test
|
||||
G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = build_formation_test(
|
||||
G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = build_formation_test(
|
||||
nb_mods=nb_mods
|
||||
)
|
||||
ue1 = models.UniteEns.query.get(ue1_id)
|
||||
@ -69,7 +95,7 @@ def build_modules_with_evaluations(
|
||||
mod.set_ue_coef_dict(coefs_mod)
|
||||
assert mod.get_ue_coef_dict() == coefs_mod
|
||||
# Mise en place:
|
||||
sem = G.create_formsemestre(
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=2,
|
||||
date_debut="01/01/2021",
|
||||
@ -77,11 +103,10 @@ def build_modules_with_evaluations(
|
||||
)
|
||||
evaluation_ids = []
|
||||
for module_id in module_ids:
|
||||
mi = G.create_moduleimpl(
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=sem["formsemestre_id"],
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
moduleimpl_id = mi["id"]
|
||||
modimpl = models.ModuleImpl.query.get(moduleimpl_id)
|
||||
assert modimpl.formsemestre.formation.get_parcours().APC_SAE # BUT
|
||||
# Check ModuleImpl
|
||||
@ -96,4 +121,4 @@ def build_modules_with_evaluations(
|
||||
coefficient=0,
|
||||
)
|
||||
evaluation_ids.append(e["evaluation_id"])
|
||||
return G, formation_id, sem, evaluation_ids, ue1, ue2, ue3
|
||||
return G, formation_id, formsemestre_id, evaluation_ids, ue1, ue2, ue3
|
||||
|
@ -10,7 +10,7 @@ import json
|
||||
|
||||
from tests.unit import sco_fake_gen
|
||||
|
||||
from app.scodoc import sco_abs
|
||||
from app.scodoc import sco_abs, sco_formsemestre
|
||||
from app.scodoc import sco_abs_views
|
||||
from app.scodoc import sco_groups
|
||||
from app.views import absences
|
||||
@ -24,33 +24,33 @@ def test_abs_counts(test_client):
|
||||
etud = G.create_etud(code_nip=None)
|
||||
|
||||
# --- 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"],
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=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
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=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"],
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
_ = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
|
||||
# --- Inscription des étudiants
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
|
||||
# --- Saisie absences
|
||||
etudid = etud["etudid"]
|
||||
@ -120,4 +120,4 @@ def test_abs_counts(test_client):
|
||||
assert nbabs_3 == new_nbabs
|
||||
justifs_3 = sco_abs.list_abs_justifs(etudid, "2021-01-01", datefin="2021-06-30")
|
||||
assert len(justifs_3) == len(justifs_2)
|
||||
# XXX à continuer
|
||||
# XXX à continuer
|
||||
|
@ -9,10 +9,11 @@ Créer et justifier des absences en utilisant le parametre demijournee
|
||||
import json
|
||||
|
||||
from tests.unit import sco_fake_gen
|
||||
|
||||
from app.models import Module
|
||||
from app.scodoc import sco_abs
|
||||
from app.scodoc import sco_abs_views
|
||||
from app.scodoc import sco_groups
|
||||
from app.scodoc import sco_formsemestre
|
||||
from app.views import absences
|
||||
|
||||
|
||||
@ -26,33 +27,34 @@ def test_abs_demijournee(test_client):
|
||||
etud = G.create_etud(code_nip=None)
|
||||
|
||||
# --- 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"],
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=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
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=1,
|
||||
date_debut="01/01/2021",
|
||||
date_fin="30/06/2021",
|
||||
)
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
|
||||
mi = G.create_moduleimpl(
|
||||
module_id=mod["module_id"],
|
||||
formsemestre_id=sem["formsemestre_id"],
|
||||
_ = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
|
||||
# --- Inscription des étudiants
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
|
||||
# --- Saisie absences
|
||||
etudid = etud["etudid"]
|
||||
@ -131,38 +133,38 @@ def test_abs_basic(test_client):
|
||||
etuds = [G.create_etud(code_nip=None) for _ in range(10)]
|
||||
|
||||
# --- 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"],
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=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
|
||||
ue_id=ue_id, # faiblesse de l'API
|
||||
formation_id=formation_id, # faiblesse de l'API
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=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"],
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
|
||||
# --- Inscription des étudiants
|
||||
for etud in etuds:
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
|
||||
# --- Création d'une évaluation
|
||||
e = G.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="22/01/2021",
|
||||
description="evaluation test",
|
||||
coefficient=1.0,
|
||||
@ -226,6 +228,7 @@ def test_abs_basic(test_client):
|
||||
|
||||
b = sco_abs.is_work_saturday()
|
||||
assert b == 0 # samedi ne sont pas compris
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
nbabs, nbabsjust = sco_abs.get_abs_count(etudid, sem)
|
||||
# l'étudiant a été absent le 15 (apres midi) , (16 et 17 we),
|
||||
# 18 (matin) et 19 janvier (matin et apres midi), et 22 (matin)
|
||||
@ -258,7 +261,8 @@ def test_abs_basic(test_client):
|
||||
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"]
|
||||
mod = Module.query.get(module_id)
|
||||
assert load_liste_abs2[0]["exams"] == mod.code
|
||||
# absjust_only -> seulement les abs justifiés
|
||||
|
||||
# --- Création d'un groupe
|
||||
|
@ -36,18 +36,17 @@ def same_note(x, y):
|
||||
|
||||
def test_evaluation_poids(test_client):
|
||||
"""Association de poids vers les UE"""
|
||||
G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test()
|
||||
sem = G.create_formsemestre(
|
||||
G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = setup.build_formation_test()
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=1,
|
||||
date_debut="01/01/2021",
|
||||
date_fin="30/06/2021",
|
||||
) # formsemestre_id=716
|
||||
mi = G.create_moduleimpl(
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_ids[0],
|
||||
formsemestre_id=sem["formsemestre_id"],
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
moduleimpl_id = mi["id"]
|
||||
_e1 = G.create_evaluation(
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="01/01/2021",
|
||||
@ -91,7 +90,7 @@ def test_evaluation_poids(test_client):
|
||||
|
||||
def test_modules_coefs(test_client):
|
||||
"""Coefs vers les UE (BUT)"""
|
||||
G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test()
|
||||
G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = setup.build_formation_test()
|
||||
ue1 = models.UniteEns.query.get(ue1_id)
|
||||
ue2 = models.UniteEns.query.get(ue2_id)
|
||||
mod = models.Module.query.get(module_ids[0])
|
||||
@ -211,14 +210,14 @@ def test_module_moy(test_client):
|
||||
(
|
||||
G,
|
||||
formation_id,
|
||||
sem,
|
||||
formsemestre_id,
|
||||
evaluation1_ids,
|
||||
ue1,
|
||||
ue2,
|
||||
ue3,
|
||||
) = setup.build_modules_with_evaluations()
|
||||
etud = G.create_etud(nom="test")
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
etudid = etud["etudid"]
|
||||
evaluation1 = models.Evaluation.query.get(evaluation1_ids[0])
|
||||
# Crée une deuxième évaluation dans le même moduleimpl:
|
||||
|
@ -27,19 +27,18 @@ def test_ue_moy(test_client):
|
||||
(
|
||||
G,
|
||||
formation_id,
|
||||
sem,
|
||||
formsemestre_id,
|
||||
evaluation_ids,
|
||||
ue1,
|
||||
ue2,
|
||||
ue3,
|
||||
) = setup.build_modules_with_evaluations(ue_coefs=ue_coefs, nb_mods=nb_mods)
|
||||
assert len(evaluation_ids) == nb_mods
|
||||
formsemestre_id = sem["formsemestre_id"]
|
||||
formsemestre = FormSemestre.query.get(formsemestre_id)
|
||||
evaluation1 = Evaluation.query.get(evaluation_ids[0])
|
||||
evaluation2 = Evaluation.query.get(evaluation_ids[1])
|
||||
etud = G.create_etud(nom="test")
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
etudid = etud["etudid"]
|
||||
# e1 est l'éval du module 1, et e2 l'éval du module 2
|
||||
e1p1, e1p2, e1p3 = 1.0, 2.0, 3.0 # poids de l'éval 1 vers les UE 1, 2 et 3
|
||||
|
@ -46,9 +46,10 @@ import json
|
||||
import flask
|
||||
from flask import g
|
||||
import pytest
|
||||
from app.models.moduleimpls import ModuleImpl
|
||||
from tests.unit import sco_fake_gen
|
||||
|
||||
from app.scodoc import sco_edit_formation
|
||||
from app.scodoc import sco_edit_formation, sco_formsemestre
|
||||
from app.scodoc import sco_edit_matiere
|
||||
from app.scodoc import sco_edit_module
|
||||
from app.scodoc import sco_edit_ue
|
||||
@ -65,111 +66,109 @@ def test_formations(test_client):
|
||||
|
||||
# --- Création de formations
|
||||
|
||||
f = G.create_formation(
|
||||
formation_id = 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"],
|
||||
f = sco_formations.formation_list(formation_id)[0]
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=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
|
||||
ue_id=ue_id, # faiblesse de l'API
|
||||
formation_id=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"],
|
||||
ue_id2 = G.create_ue(formation_id=formation_id, acronyme="TST2", titre="ue test2")
|
||||
matiere_id2 = G.create_matiere(ue_id=ue_id2, titre="matière test2")
|
||||
module_id2 = G.create_module(
|
||||
matiere_id=matiere_id2,
|
||||
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
|
||||
ue_id=ue_id2,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
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"],
|
||||
uet_id = G.create_ue(formation_id=formation_id, acronyme="TSTt", titre="ue testt")
|
||||
matiere_id3 = G.create_matiere(ue_id=uet_id, titre="matière testt")
|
||||
module_id_t = G.create_module(
|
||||
matiere_id=matiere_id3,
|
||||
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
|
||||
ue_id=uet_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
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"],
|
||||
formation_id2 = G.create_formation(acronyme="", titre="Formation test")
|
||||
formation2 = sco_formations.formation_list(formation_id2)[0]
|
||||
ue3 = G.create_ue(formation_id=formation_id2, acronyme="TST3", titre="ue test3")
|
||||
matiere_id4 = G.create_matiere(ue_id=ue3, titre="matière test3")
|
||||
module_id3 = G.create_module(
|
||||
matiere_id=matiere_id4,
|
||||
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
|
||||
ue_id=ue3,
|
||||
formation_id=formation_id2,
|
||||
)
|
||||
|
||||
# --- Création et implémentation des semestres
|
||||
|
||||
sem1 = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id1 = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=1,
|
||||
date_debut="01/01/2021",
|
||||
date_fin="30/06/2021",
|
||||
)
|
||||
|
||||
sem2 = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id2 = G.create_formsemestre(
|
||||
formation_id=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"],
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id1,
|
||||
)
|
||||
|
||||
mi2 = G.create_moduleimpl(
|
||||
module_id=mod2["module_id"],
|
||||
formsemestre_id=sem1["formsemestre_id"],
|
||||
_ = G.create_moduleimpl(
|
||||
module_id=module_id2,
|
||||
formsemestre_id=formsemestre_id1,
|
||||
)
|
||||
|
||||
mit = G.create_moduleimpl(
|
||||
module_id=modt["module_id"],
|
||||
formsemestre_id=sem2["formsemestre_id"],
|
||||
_ = G.create_moduleimpl(
|
||||
module_id=module_id_t,
|
||||
formsemestre_id=formsemestre_id2,
|
||||
)
|
||||
|
||||
semt = G.create_formsemestre(
|
||||
formation_id=f2["formation_id"],
|
||||
formsemestre_idt = G.create_formsemestre(
|
||||
formation_id=formation_id2,
|
||||
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"],
|
||||
module_id=module_id3,
|
||||
formsemestre_id=formsemestre_idt,
|
||||
)
|
||||
|
||||
# --- Afficher la liste des formations
|
||||
|
||||
lif = notes.formation_list(format="json", formation_id=f["formation_id"])
|
||||
lif = notes.formation_list(format="json", formation_id=formation_id)
|
||||
# lif est une Response car on a appelé une vue (1er appel)
|
||||
assert isinstance(lif, flask.Response)
|
||||
load_lif = json.loads(lif.get_data().decode("utf-8"))
|
||||
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]["formation_id"] == formation_id
|
||||
assert load_lif[0]["titre"] == f["titre"]
|
||||
|
||||
lif2 = notes.formation_list(format="json").get_data(as_text=True)
|
||||
@ -178,12 +177,12 @@ def test_formations(test_client):
|
||||
load_lif2 = json.loads(lif2)
|
||||
assert len(load_lif2) == 2
|
||||
assert load_lif2[0] == load_lif[0]
|
||||
assert load_lif2[1]["titre"] == f2["titre"]
|
||||
assert load_lif2[1]["titre"] == formation2["titre"]
|
||||
|
||||
# --- Export de formation_id
|
||||
|
||||
exp = sco_formations.formation_export(
|
||||
formation_id=f["formation_id"], format="json"
|
||||
formation_id=formation_id, format="json"
|
||||
).get_data(as_text=True)
|
||||
assert isinstance(exp, str)
|
||||
load_exp = json.loads(exp)
|
||||
@ -195,24 +194,25 @@ def test_formations(test_client):
|
||||
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_id"] == formation_id
|
||||
assert load_exp["formation_code"] == f["formation_code"]
|
||||
|
||||
# --- Liste des semestres
|
||||
|
||||
li_sem1 = notes.formsemestre_list(
|
||||
formsemestre_id=sem1["formsemestre_id"], format="json"
|
||||
formsemestre_id=formsemestre_id1, format="json"
|
||||
).get_data(as_text=True)
|
||||
assert isinstance(li_sem1, str)
|
||||
load_li_sem1 = json.loads(li_sem1) # uniquement le semestre 1 dans la liste
|
||||
|
||||
assert len(load_li_sem1) == 1
|
||||
sem1 = sco_formsemestre.get_formsemestre(formsemestre_id1)
|
||||
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 = notes.formsemestre_list(
|
||||
formation_id=f["formation_id"],
|
||||
formation_id=formation_id,
|
||||
format="json",
|
||||
).get_data(as_text=True)
|
||||
assert isinstance(li_semf, str)
|
||||
@ -220,6 +220,7 @@ def test_formations(test_client):
|
||||
|
||||
assert load_li_sem1[0] in load_li_semf
|
||||
assert len(load_li_semf) == 2
|
||||
sem2 = sco_formsemestre.get_formsemestre(formsemestre_id2)
|
||||
assert load_li_semf[1]["semestre_id"] == sem2["semestre_id"]
|
||||
|
||||
li_sem = notes.formsemestre_list(format="json").get_data(as_text=True)
|
||||
@ -227,21 +228,26 @@ def test_formations(test_client):
|
||||
|
||||
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.moduleimpl_list(formsemestre_id=sem1["formsemestre_id"])
|
||||
|
||||
assert len(lim_sem1) == 2
|
||||
assert mod["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
|
||||
assert mod2["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"])
|
||||
assert module_id in (
|
||||
lim_sem1[0]["module_id"],
|
||||
lim_sem1[1]["module_id"],
|
||||
)
|
||||
assert module_id2 in (
|
||||
lim_sem1[0]["module_id"],
|
||||
lim_sem1[1]["module_id"],
|
||||
)
|
||||
|
||||
lim_modid = sco_moduleimpl.moduleimpl_list(module_id=mod["module_id"])
|
||||
lim_modid = sco_moduleimpl.moduleimpl_list(module_id=module_id)
|
||||
|
||||
assert len(lim_modid) == 1
|
||||
|
||||
lim_modimpl_id = sco_moduleimpl.moduleimpl_list(moduleimpl_id=mi["moduleimpl_id"])
|
||||
lim_modimpl_id = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)
|
||||
# print(lim_modimpl_id)
|
||||
|
||||
# ---- Test de moduleimpl_withmodule_list
|
||||
@ -253,20 +259,23 @@ def test_formations(test_client):
|
||||
)
|
||||
|
||||
assert len(liimp_sem1) == 2
|
||||
assert mod["module_id"] in (liimp_sem1[0]["module_id"], liimp_sem1[1]["module_id"])
|
||||
assert mod2["module_id"] in (
|
||||
assert module_id in (
|
||||
liimp_sem1[0]["module_id"],
|
||||
liimp_sem1[1]["module_id"],
|
||||
)
|
||||
assert module_id2 in (
|
||||
liimp_sem1[0]["module_id"],
|
||||
liimp_sem1[1]["module_id"],
|
||||
)
|
||||
liimp_sem2 = sco_moduleimpl.moduleimpl_withmodule_list(
|
||||
formsemestre_id=sem2["formsemestre_id"]
|
||||
)
|
||||
assert modt["module_id"] == liimp_sem2[0]["module_id"]
|
||||
liimp_modid = sco_moduleimpl.moduleimpl_withmodule_list(module_id=mod["module_id"])
|
||||
assert module_id_t == liimp_sem2[0]["module_id"]
|
||||
liimp_modid = sco_moduleimpl.moduleimpl_withmodule_list(module_id=module_id)
|
||||
assert len(liimp_modid) == 1
|
||||
|
||||
liimp_modimplid = sco_moduleimpl.moduleimpl_withmodule_list(
|
||||
moduleimpl_id=mi["moduleimpl_id"]
|
||||
moduleimpl_id=moduleimpl_id
|
||||
)
|
||||
|
||||
assert liimp_modid == liimp_modimplid
|
||||
@ -281,16 +290,17 @@ def test_formations(test_client):
|
||||
|
||||
li_module = sco_edit_module.module_list()
|
||||
assert len(li_module) == 4
|
||||
# Suppression impossible car utilisé dans le semestre semt:
|
||||
# Suppression impossible car utilisé dans le semestre formsemestre_idt:
|
||||
module3 = ModuleImpl.query.get(mi3).module
|
||||
with pytest.raises(sco_exceptions.ScoNonEmptyFormationObject):
|
||||
sco_edit_module.module_delete(module_id=mi3["module_id"])
|
||||
sco_edit_module.module_delete(module_id=module3.id)
|
||||
|
||||
sco_formsemestre_edit.do_formsemestre_delete(semt["formsemestre_id"])
|
||||
sco_formsemestre_edit.do_formsemestre_delete(formsemestre_idt)
|
||||
|
||||
li_module2_before = sco_edit_module.module_list()
|
||||
|
||||
sco_edit_module.do_module_delete(mi3["module_id"])
|
||||
sco_edit_module.do_module_delete(modt["module_id"])
|
||||
sco_edit_module.do_module_delete(module3.id)
|
||||
sco_edit_module.do_module_delete(module_id_t)
|
||||
|
||||
# deuxieme methode de supression d'un module
|
||||
li_module2_after = sco_edit_module.module_list()
|
||||
@ -305,19 +315,19 @@ def test_formations(test_client):
|
||||
|
||||
li_mat = sco_edit_matiere.matiere_list()
|
||||
assert len(li_mat) == 4
|
||||
sco_edit_matiere.do_matiere_delete(oid=matt["matiere_id"]) # on supprime la matiere
|
||||
sco_edit_matiere.do_matiere_delete(oid=matiere_id3) # on supprime la matiere
|
||||
li_mat2 = sco_edit_matiere.matiere_list()
|
||||
assert len(li_mat2) == 3 # verification de la suppression de la matiere
|
||||
|
||||
li_ue = sco_edit_ue.ue_list()
|
||||
assert len(li_ue) == 4
|
||||
sco_edit_ue.ue_delete(ue_id=uet["ue_id"], dialog_confirmed=True)
|
||||
sco_edit_ue.ue_delete(ue_id=uet_id, dialog_confirmed=True)
|
||||
li_ue2 = sco_edit_ue.ue_list()
|
||||
assert len(li_ue2) == 3 # verification de la suppression de l'UE
|
||||
|
||||
# --- Suppression d'une formation
|
||||
|
||||
sco_edit_formation.do_formation_delete(oid=f2["formation_id"])
|
||||
sco_edit_formation.do_formation_delete(oid=formation_id2)
|
||||
lif3 = notes.formation_list(format="json").get_data(as_text=True)
|
||||
assert isinstance(lif3, str)
|
||||
load_lif3 = json.loads(lif3)
|
||||
@ -340,7 +350,7 @@ def test_import_formation(test_client):
|
||||
assert len(ues) == 10
|
||||
assert all(not ue["is_external"] for ue in ues) # aucune UE externe dans le XML
|
||||
# --- Mise en place de 4 semestres
|
||||
sems = [
|
||||
formsemestre_ids = [
|
||||
G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=x[0],
|
||||
@ -357,10 +367,11 @@ def test_import_formation(test_client):
|
||||
# et les modules
|
||||
modules = sco_edit_module.module_list({"formation_id": formation_id})
|
||||
for mod in modules:
|
||||
mi = G.create_moduleimpl(
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=mod["module_id"],
|
||||
formsemestre_id=sems[mod["semestre_id"] - 1]["formsemestre_id"],
|
||||
formsemestre_id=formsemestre_ids[mod["semestre_id"] - 1],
|
||||
)
|
||||
mi = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)[0]
|
||||
assert mi["ens"] == []
|
||||
assert mi["module_id"] == mod["module_id"]
|
||||
|
||||
|
@ -10,7 +10,7 @@ from tests.unit import sco_fake_gen
|
||||
from flask import g
|
||||
|
||||
import app
|
||||
from app.scodoc import sco_bulletins
|
||||
from app.scodoc import sco_bulletins, sco_formsemestre
|
||||
from app.scodoc import sco_cache
|
||||
from app.scodoc import sco_formsemestre_inscriptions
|
||||
from app.scodoc import sco_moduleimpl
|
||||
@ -57,36 +57,34 @@ def test_notes_modules(test_client):
|
||||
G = sco_fake_gen.ScoFake(verbose=False)
|
||||
etuds = [G.create_etud(code_nip=None) for i in range(2)] # 2 étudiants
|
||||
|
||||
f = G.create_formation(acronyme="")
|
||||
ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test")
|
||||
ue_id = ue["ue_id"]
|
||||
mat = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
coef_mod_1 = 1.5
|
||||
mod = G.create_module(
|
||||
matiere_id=mat["matiere_id"],
|
||||
module_id = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code="TSM1",
|
||||
coefficient=coef_mod_1,
|
||||
titre="module test",
|
||||
ue_id=ue["ue_id"],
|
||||
formation_id=f["formation_id"],
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=1,
|
||||
date_debut="01/01/2020",
|
||||
date_fin="30/06/2020",
|
||||
)
|
||||
formsemestre_id = sem["formsemestre_id"]
|
||||
mi = G.create_moduleimpl(
|
||||
module_id=mod["module_id"],
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
moduleimpl_id = mi["moduleimpl_id"]
|
||||
# --- Inscription des étudiants
|
||||
for etud in etuds:
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
etud = etuds[0]
|
||||
etudid = etud["etudid"]
|
||||
# --- Creation évaluations: e1, e2
|
||||
@ -198,8 +196,8 @@ def test_notes_modules(test_client):
|
||||
check_nt(
|
||||
etudid,
|
||||
sem["formsemestre_id"],
|
||||
ue["ue_id"],
|
||||
mi["moduleimpl_id"],
|
||||
ue_id,
|
||||
moduleimpl_id,
|
||||
expected_mod_moy="NA",
|
||||
expected_moy_ue=0.0,
|
||||
expected_sum_coefs_ue=0.0,
|
||||
@ -214,8 +212,8 @@ def test_notes_modules(test_client):
|
||||
check_nt(
|
||||
etudid,
|
||||
sem["formsemestre_id"],
|
||||
ue["ue_id"],
|
||||
mi["moduleimpl_id"],
|
||||
ue_id,
|
||||
moduleimpl_id,
|
||||
expected_mod_moy="NA",
|
||||
expected_moy_ue=0.0,
|
||||
expected_sum_coefs_ue=0.0,
|
||||
@ -223,12 +221,12 @@ def test_notes_modules(test_client):
|
||||
# Non inscrit
|
||||
# - désinscrit notre étudiant:
|
||||
inscr = sco_moduleimpl.do_moduleimpl_inscription_list(
|
||||
moduleimpl_id=mi["moduleimpl_id"], etudid=etud["etudid"]
|
||||
moduleimpl_id=moduleimpl_id, etudid=etud["etudid"]
|
||||
)
|
||||
assert len(inscr) == 1
|
||||
oid = inscr[0]["moduleimpl_inscription_id"]
|
||||
sco_moduleimpl.do_moduleimpl_inscription_delete(
|
||||
oid, formsemestre_id=mi["formsemestre_id"]
|
||||
oid, formsemestre_id=sem["formsemestre_id"]
|
||||
)
|
||||
# -
|
||||
b = sco_bulletins.formsemestre_bulletinetud_dict(
|
||||
@ -246,21 +244,21 @@ def test_notes_modules(test_client):
|
||||
)
|
||||
# --- Maintenant avec 2 modules dans l'UE
|
||||
coef_mod_2 = 2.1
|
||||
mod2 = G.create_module(
|
||||
matiere_id=mat["matiere_id"],
|
||||
module_id2 = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code="TSM2",
|
||||
coefficient=coef_mod_2,
|
||||
titre="module test 2",
|
||||
ue_id=ue_id,
|
||||
formation_id=f["formation_id"],
|
||||
formation_id=formation_id,
|
||||
)
|
||||
mi2 = G.create_moduleimpl(
|
||||
module_id=mod2["module_id"],
|
||||
moduleimpl_id2 = G.create_moduleimpl(
|
||||
module_id=module_id2,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
# Re-inscription au premier module de l'UE
|
||||
sco_moduleimpl.do_moduleimpl_inscription_create(
|
||||
{"etudid": etudid, "moduleimpl_id": mi["moduleimpl_id"]},
|
||||
{"etudid": etudid, "moduleimpl_id": moduleimpl_id},
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
_, _, _ = G.create_note(evaluation=e1, etud=etud, note=12.5)
|
||||
@ -271,11 +269,11 @@ def test_notes_modules(test_client):
|
||||
assert not ue_status["was_capitalized"]
|
||||
# Inscription au deuxième module de l'UE
|
||||
sco_moduleimpl.do_moduleimpl_inscription_create(
|
||||
{"etudid": etudid, "moduleimpl_id": mi2["moduleimpl_id"]},
|
||||
{"etudid": etudid, "moduleimpl_id": moduleimpl_id2},
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
sco_moduleimpl.do_moduleimpl_inscription_create(
|
||||
{"etudid": etuds[1]["etudid"], "moduleimpl_id": mi2["moduleimpl_id"]},
|
||||
{"etudid": etuds[1]["etudid"], "moduleimpl_id": moduleimpl_id2},
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
nt = sco_cache.NotesTableCache.get(formsemestre_id)
|
||||
@ -284,7 +282,7 @@ def test_notes_modules(test_client):
|
||||
assert ue_status["nb_notes"] == 1
|
||||
# Note dans module 2:
|
||||
e_m2 = G.create_evaluation(
|
||||
moduleimpl_id=mi2["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id2,
|
||||
jour="01/01/2020",
|
||||
description="evaluation mod 2",
|
||||
coefficient=1.0,
|
||||
@ -327,37 +325,36 @@ def test_notes_modules_att_dem(test_client):
|
||||
G = sco_fake_gen.ScoFake(verbose=False)
|
||||
etuds = [G.create_etud(code_nip=None) for i in range(2)] # 2 étudiants
|
||||
|
||||
f = G.create_formation(acronyme="")
|
||||
ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test")
|
||||
ue_id = ue["ue_id"]
|
||||
mat = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
coef_mod_1 = 1.5
|
||||
mod = G.create_module(
|
||||
matiere_id=mat["matiere_id"],
|
||||
module_id = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code="TSM1",
|
||||
coefficient=coef_mod_1,
|
||||
titre="module test",
|
||||
ue_id=ue["ue_id"],
|
||||
formation_id=f["formation_id"],
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
#
|
||||
# --------------------------------
|
||||
#
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=formation_id,
|
||||
semestre_id=1,
|
||||
date_debut="01/01/2020",
|
||||
date_fin="30/06/2020",
|
||||
)
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
formsemestre_id = sem["formsemestre_id"]
|
||||
mi = G.create_moduleimpl(
|
||||
module_id=mod["module_id"],
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
moduleimpl_id = mi["moduleimpl_id"]
|
||||
# --- Inscription des étudiants
|
||||
for etud in etuds:
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
# --- Creation évaluation: e1
|
||||
coef_1 = 1.0
|
||||
e1 = G.create_evaluation(
|
||||
|
@ -8,6 +8,7 @@ from flask import g
|
||||
|
||||
import app
|
||||
from app.scodoc import sco_bulletins
|
||||
from app.scodoc import sco_formsemestre
|
||||
from app.scodoc import sco_utils as scu
|
||||
|
||||
DEPT = TestConfig.DEPT_TEST
|
||||
@ -23,44 +24,44 @@ def test_notes_rattrapage(test_client):
|
||||
G = sco_fake_gen.ScoFake(verbose=False)
|
||||
etuds = [G.create_etud(code_nip=None)] # un seul
|
||||
|
||||
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"],
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code="TSM1",
|
||||
coefficient=1.0,
|
||||
titre="module test",
|
||||
ue_id=ue["ue_id"],
|
||||
formation_id=f["formation_id"],
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=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"],
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
|
||||
# --- Inscription des étudiants
|
||||
for etud in etuds:
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
# --- Creation évaluation
|
||||
e = G.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="01/01/2020",
|
||||
description="evaluation test",
|
||||
coefficient=1.0,
|
||||
)
|
||||
# --- Création d'une évaluation "de rattrapage"
|
||||
e_rat = G.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="02/01/2020",
|
||||
description="evaluation rattrapage",
|
||||
coefficient=1.0,
|
||||
|
@ -19,7 +19,9 @@ from app.models.but_refcomp import (
|
||||
|
||||
def test_but_refcomp(test_client):
|
||||
"""modèles ref. comp."""
|
||||
xml_data = open("tests/data/but-RT-refcomp-exemple.xml").read()
|
||||
xml_data = open(
|
||||
"ressources/referentiels/but2022/competences/but-RT-05012022-081735.xml"
|
||||
).read()
|
||||
dept_id = models.Departement.query.first().id
|
||||
ref = orebut_import_refcomp(xml_data, dept_id)
|
||||
assert ref.competences.count() == 13
|
||||
|
@ -19,7 +19,7 @@ from config import TestConfig
|
||||
from tests.unit import sco_fake_gen
|
||||
|
||||
import app
|
||||
from app.scodoc import notesdb as ndb
|
||||
from app.scodoc import notesdb as ndb, sco_formsemestre
|
||||
from app.scodoc import sco_abs
|
||||
from app.scodoc import sco_abs_views
|
||||
from app.scodoc import sco_bulletins
|
||||
@ -54,38 +54,38 @@ def run_sco_basic(verbose=False):
|
||||
etuds = [G.create_etud(code_nip=None) for _ in range(10)]
|
||||
|
||||
# --- 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"],
|
||||
formation_id = G.create_formation(acronyme="")
|
||||
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
||||
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
||||
module_id = G.create_module(
|
||||
matiere_id=matiere_id,
|
||||
code="TSM1",
|
||||
coefficient=1.0,
|
||||
titre="module test",
|
||||
ue_id=ue["ue_id"],
|
||||
formation_id=f["formation_id"],
|
||||
ue_id=ue_id,
|
||||
formation_id=formation_id,
|
||||
)
|
||||
|
||||
# --- Mise place d'un semestre
|
||||
sem = G.create_formsemestre(
|
||||
formation_id=f["formation_id"],
|
||||
formsemestre_id = G.create_formsemestre(
|
||||
formation_id=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"],
|
||||
sem = sco_formsemestre.get_formsemestre(formsemestre_id)
|
||||
moduleimpl_id = G.create_moduleimpl(
|
||||
module_id=module_id,
|
||||
formsemestre_id=formsemestre_id,
|
||||
)
|
||||
|
||||
# --- Inscription des étudiants
|
||||
for etud in etuds:
|
||||
G.inscrit_etudiant(sem, etud)
|
||||
G.inscrit_etudiant(formsemestre_id, etud)
|
||||
|
||||
# --- Creation évaluation
|
||||
e = G.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="01/01/2020",
|
||||
description="evaluation test",
|
||||
coefficient=1.0,
|
||||
@ -98,9 +98,7 @@ def run_sco_basic(verbose=False):
|
||||
)
|
||||
|
||||
# --- Vérifie que les notes sont prises en compte:
|
||||
b = sco_bulletins.formsemestre_bulletinetud_dict(
|
||||
sem["formsemestre_id"], etud["etudid"]
|
||||
)
|
||||
b = sco_bulletins.formsemestre_bulletinetud_dict(formsemestre_id, etud["etudid"])
|
||||
# Toute les notes sont saisies, donc eval complète
|
||||
etat = sco_evaluations.do_evaluation_etat(e["evaluation_id"])
|
||||
assert etat["evalcomplete"]
|
||||
@ -116,7 +114,7 @@ def run_sco_basic(verbose=False):
|
||||
|
||||
# --- Une autre évaluation
|
||||
e2 = G.create_evaluation(
|
||||
moduleimpl_id=mi["moduleimpl_id"],
|
||||
moduleimpl_id=moduleimpl_id,
|
||||
jour="02/01/2020",
|
||||
description="evaluation test 2",
|
||||
coefficient=1.0,
|
||||
@ -183,34 +181,34 @@ def run_sco_basic(verbose=False):
|
||||
|
||||
# --- Permission saisie notes et décisions de jury, avec ou sans démission ou défaillance
|
||||
# on n'a pas encore saisi de décisions
|
||||
assert not sco_parcours_dut.formsemestre_has_decisions(sem["formsemestre_id"])
|
||||
assert not sco_parcours_dut.formsemestre_has_decisions(formsemestre_id)
|
||||
# Saisie d'un décision AJ, non assidu
|
||||
etudid = etuds[-1]["etudid"]
|
||||
sco_parcours_dut.formsemestre_validate_ues(
|
||||
sem["formsemestre_id"], etudid, sco_codes_parcours.AJ, False
|
||||
formsemestre_id, etudid, sco_codes_parcours.AJ, False
|
||||
)
|
||||
assert sco_parcours_dut.formsemestre_has_decisions(
|
||||
sem["formsemestre_id"]
|
||||
formsemestre_id
|
||||
), "décisions manquantes"
|
||||
# Suppression de la décision
|
||||
sco_formsemestre_validation.formsemestre_validation_suppress_etud(
|
||||
sem["formsemestre_id"], etudid
|
||||
formsemestre_id, etudid
|
||||
)
|
||||
assert not sco_parcours_dut.formsemestre_has_decisions(
|
||||
sem["formsemestre_id"]
|
||||
formsemestre_id
|
||||
), "décisions non effacées"
|
||||
|
||||
# --- Décision de jury et validations des ECTS d'UE
|
||||
for etud in etuds[:5]: # les etudiants notés
|
||||
sco_formsemestre_validation.formsemestre_validation_etud_manu(
|
||||
sem["formsemestre_id"],
|
||||
formsemestre_id,
|
||||
etud["etudid"],
|
||||
code_etat=sco_codes_parcours.ADJ,
|
||||
assidu=True,
|
||||
redirect=False,
|
||||
)
|
||||
# Vérifie que toutes les UE des étudiants notés ont été acquises:
|
||||
nt = sco_cache.NotesTableCache.get(sem["formsemestre_id"])
|
||||
nt = sco_cache.NotesTableCache.get(formsemestre_id)
|
||||
for etud in etuds[:5]:
|
||||
dec_ues = nt.get_etud_decision_ues(etud["etudid"])
|
||||
for ue_id in dec_ues:
|
||||
|
Loading…
Reference in New Issue
Block a user