1767 lines
77 KiB
Python
1767 lines
77 KiB
Python
"""
|
||
FORMATION INITIALE :
|
||
A l’image de la gestion des admissions, le système sera paramétrable par un utilisateur pour définir les règles de calcul.
|
||
En attendant de mettre en le module de règle dynamique, une liste de règles statiques seront codées en dure le dans le système.
|
||
Ainsi l’administrateur pourra choisir la règle adaptée à sa formation.
|
||
Pour les cas particuliers, les équipes de MTT feront des développements spécifiques pour les clients qui le souhaite.
|
||
|
||
Par defaut, les regles de calcul implémentées :
|
||
• Nom : calcul_mode_1
|
||
Detail : ( (Moyenne Art. (TD) + Moyenne Art(TP) * 2)/3 + Examen Final ) / 2
|
||
|
||
|
||
• Nom : calcul_mode_2
|
||
Detail : ( Note Stage + Examen Final ) / 2
|
||
|
||
|
||
• Nom : calcul_mode_2
|
||
Detail : (Moyenne Art.(TD) + Moyenne Art.(Contrôle Continue) + Examen Final*1.5 ) / 3
|
||
|
||
/!\ Important :
|
||
La collection : "note_evaluation" :
|
||
- Elle contient toutes les evaluations (pas les note mais les evaluation).
|
||
- Elle contient les informations : class_id, class_eu_id, type_eval_id, session_id, eval_date_heure_debut, eval_date_heure_fin
|
||
|
||
La collection : "note_evaluation_participant" :
|
||
- Elle contient les notes attribuées à un apprenant sur une evaluation.
|
||
- Elle contient les informations :evaluation_id, inscription_id, group_inscription_id, note (la note obtenue par l'apprenant)
|
||
"""
|
||
import bson
|
||
import pymongo
|
||
from pymongo import MongoClient
|
||
import json
|
||
from bson import ObjectId
|
||
import re
|
||
from datetime import datetime
|
||
import prj_common as mycommon
|
||
import secrets
|
||
import inspect
|
||
import sys, os
|
||
|
||
from pymongo import ReturnDocument
|
||
import GlobalVariable as MYSY_GV
|
||
|
||
|
||
|
||
"""
|
||
Cette fonction permet d'appliquer la regle de calcul :
|
||
• Nom : calcul_mode_1
|
||
Detail : ( (Moyenne Art. (TD) + Moyenne Art(TP) * 2)/3 + Examen Final ) / 2
|
||
|
||
Les données en entrée :
|
||
- La formation,
|
||
- La session
|
||
- Liste des inscrit
|
||
"""
|
||
def run_ue_pre_calcul_moyenne_somme(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token', 'class_id', 'session_id', 'tab_ue_ids', 'tab_inscriptions_ids' ]
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', 'class_id', 'session_id', 'tab_ue_ids', 'tab_inscriptions_ids' ]
|
||
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
|
||
# Verifier la validité de la session
|
||
is_session_valide_count = MYSY_GV.dbname['session_formation'].count_documents({'_id':ObjectId(str(diction['session_id'])),
|
||
'valide':'1',
|
||
'partner_owner_recid':str(my_partner['recid'])})
|
||
|
||
if( is_session_valide_count != 1 ):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide ")
|
||
return False, " L'identifiant de la session est invalide"
|
||
|
||
is_session_valide_data = MYSY_GV.dbname['session_formation'].find_one(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
tab_ue_ids = ""
|
||
if ("tab_ue_ids" in diction.keys()):
|
||
if diction['tab_ue_ids']:
|
||
tab_ue_ids = diction['tab_ue_ids']
|
||
|
||
tab_ue_ids_splited = str(tab_ue_ids).split(",")
|
||
|
||
for my_ue_id in tab_ue_ids_splited:
|
||
my_ue_id = str(my_ue_id).strip()
|
||
|
||
# Verifier la validité de l'unité d'enseignement
|
||
is_ue_valide_count = MYSY_GV.dbname['unite_enseignement'].count_documents(
|
||
{'_id': ObjectId(str(my_ue_id)),
|
||
'valide': '1',
|
||
'locked':'0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (is_ue_valide_count != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de l'unité d'enseignement est invalide "+str(my_ue_id))
|
||
return False, " L'identifiant de l'unité d'enseignement "+str(my_ue_id)+" est invalide "
|
||
|
||
|
||
|
||
|
||
# Verifier si la formartion est valide
|
||
is_myclass_valide_count = MYSY_GV.dbname['myclass'].count_documents(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (is_myclass_valide_count != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de la formation est invalide ")
|
||
return False, " L'identifiant de la formation est invalide"
|
||
|
||
is_myclass_valide_data = MYSY_GV.dbname['myclass'].find_one(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
# Verifier la validité de la liste des inscrits fournie
|
||
tab_inscriptions_ids = ""
|
||
if ("tab_inscriptions_ids" in diction.keys()):
|
||
if diction['tab_inscriptions_ids']:
|
||
tab_inscriptions_ids = diction['tab_inscriptions_ids']
|
||
|
||
tab_inscriptions_ids_splited = str(tab_inscriptions_ids).split(",")
|
||
|
||
# Controle de validité de toutes info avant de commencer les traitements
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
my_inscription = str(my_inscription).strip()
|
||
|
||
# Verifier que l'inscription est valide
|
||
my_inscription_is_valide = MYSY_GV.dbname['inscription'].count_documents(
|
||
{'_id': ObjectId(str(my_inscription)), 'status': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (my_inscription_is_valide != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'inscription_id '" + my_inscription + "' n'est pas valide ")
|
||
return False, " L'inscription_id '" + my_inscription + "' n'est pas valide "
|
||
|
||
"""
|
||
La formule : ( (Moyenne Art. (TD) + Moyenne Art(TP) * 2)/3 + Examen Final ) / 2
|
||
"""
|
||
|
||
"""
|
||
Etape 1 :
|
||
Aller cherche la liste des TD et faire la moyenne arithmétique pour chaque apprenant fourni en entrée
|
||
0) Recuperer les types d'evaluation associée à une formation / UE
|
||
a) Pour chaque apprenant aller chercher les evaluations concernées,
|
||
b) Pour chaque evaluation concerné aller cherche les note
|
||
"""
|
||
|
||
for my_ue_id in tab_ue_ids_splited:
|
||
my_ue_id = str(my_ue_id).strip()
|
||
|
||
my_ue_id_data = MYSY_GV.dbname['unite_enseignement'].find_one(
|
||
{'_id': ObjectId(str(my_ue_id)),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
evaluation_distinc_type_eval = MYSY_GV.dbname['note_evaluation'].distinct("type_eval_id",
|
||
{'class_eu_id': str(my_ue_id),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])
|
||
}
|
||
)
|
||
|
||
#print(" ### la liste evaluation_distinc_type_eval = ", evaluation_distinc_type_eval)
|
||
|
||
|
||
|
||
|
||
|
||
#print(" ### TRAITEMENT UE_ID = ", my_ue_id)
|
||
|
||
tab_note_final = []
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
inscri_data = MYSY_GV.dbname['inscription'].find_one({'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'_id': ObjectId(str(my_inscription).strip())},
|
||
{'nom': 1, 'prenom': 1, 'email': 1}
|
||
)
|
||
|
||
node_note_finale_inscrit = {}
|
||
node_note_finale_inscrit['inscription_id'] = str(inscri_data['_id'])
|
||
node_note_finale_inscrit['inscription_nom'] = str(inscri_data['nom'])
|
||
node_note_finale_inscrit['inscription_email'] = str(inscri_data['email'])
|
||
node_note_finale_inscrit['class_id'] = str(diction['class_id'])
|
||
node_note_finale_inscrit['session_id'] = str(diction['session_id'])
|
||
node_note_finale_inscrit['ue_id'] = str(my_ue_id)
|
||
|
||
############
|
||
|
||
"""
|
||
Traitement des Types d'evaluation
|
||
"""
|
||
for eval_type_id in evaluation_distinc_type_eval :
|
||
|
||
eval_type_id_data = MYSY_GV.dbname['type_evaluation'].find_one({'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'_id': ObjectId(str(eval_type_id))})
|
||
|
||
#print(" TRAITEMENT TYPE EVAL : ", str(eval_type_id_data["code"]))
|
||
|
||
local_diction = diction
|
||
local_diction['tab_inscriptions_ids'] = str(my_inscription)
|
||
local_diction['inscri_data_nom'] = inscri_data['nom']
|
||
local_diction['inscri_data_prenom'] = inscri_data['prenom']
|
||
local_diction['inscri_data_email'] = inscri_data['email']
|
||
local_diction['ue_id'] = str(my_ue_id)
|
||
|
||
if ("tab_ue_ids" in local_diction.keys()):
|
||
del local_diction["tab_ue_ids"]
|
||
|
||
local_diction['evaluation_type_code'] = str(eval_type_id_data["code"])
|
||
local_diction['evaluation_type_id'] = str(eval_type_id_data["_id"])
|
||
|
||
local_status, local_retval_moyenne_TD, local_retval_somme_TD, local_retval_nb_eval_TD = Cacul_UE_Note_By_Evaluation_Type(
|
||
local_diction)
|
||
if (local_status):
|
||
new_node = {}
|
||
new_node['inscription_id'] = str(inscri_data['_id'])
|
||
new_node['inscription_nom'] = str(inscri_data['nom'])
|
||
new_node['inscription_email'] = str(inscri_data['email'])
|
||
new_node['class_id'] = str(diction['class_id'])
|
||
new_node['session_id'] = str(diction['session_id'])
|
||
new_node['ue_id'] = str(my_ue_id)
|
||
new_node['type_eval'] = str(eval_type_id_data["code"])
|
||
new_node['type_eval_id'] = str(eval_type_id)
|
||
new_node['moyenne'] = str(local_retval_moyenne_TD)
|
||
new_node['somme'] = str(local_retval_somme_TD)
|
||
new_node['nb_evaluation'] = str(local_retval_nb_eval_TD)
|
||
|
||
tab_note_final.append(new_node)
|
||
else:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " WARNING : " + str(local_retval_moyenne_TD))
|
||
|
||
|
||
"""
|
||
Mise à jour de la collection des notes d'une session de formation : 'session_formation_final_note_classement_detail'
|
||
"""
|
||
|
||
for note_finale in tab_note_final:
|
||
qry_key = {}
|
||
qry_key['partner_owner_recid'] = my_partner['recid']
|
||
qry_key['valide'] = "1"
|
||
qry_key['locked'] = "0"
|
||
qry_key['inscription_id'] = note_finale['inscription_id']
|
||
qry_key['session_id'] = note_finale['session_id']
|
||
qry_key['type_eval'] = note_finale['type_eval']
|
||
qry_key['ue_id'] = note_finale['ue_id']
|
||
|
||
new_data = note_finale
|
||
new_data['date_update'] = str(datetime.now())
|
||
new_data['update_by'] = str(my_partner['_id'])
|
||
new_data['valide'] = "1"
|
||
new_data['locked'] = "0"
|
||
|
||
|
||
ret_val2 = MYSY_GV.dbname['session_formation_final_note_classement_detail'].find_one_and_update(
|
||
qry_key,
|
||
{"$set": new_data},
|
||
return_document=ReturnDocument.AFTER,
|
||
upsert=True,
|
||
)
|
||
|
||
|
||
"""
|
||
Calcul de la note finale et du classement
|
||
"""
|
||
for my_ue_id in tab_ue_ids_splited:
|
||
my_ue_id = str(my_ue_id).strip()
|
||
|
||
local_diction = {}
|
||
local_diction['token'] = diction['token']
|
||
local_diction['class_id'] = diction['class_id']
|
||
local_diction['session_id'] = diction['session_id']
|
||
local_diction['ue_id'] = str(my_ue_id)
|
||
local_diction['tab_inscriptions_ids'] = str(tab_inscriptions_ids)
|
||
local_diction['tab_inscriptions_ids'] = str(tab_inscriptions_ids)
|
||
|
||
print(" ### local_diction = ", local_diction)
|
||
|
||
#local_status, local_retval = Cacul_UE_Note_Finale_For_calcul_mode_1(local_diction)
|
||
|
||
|
||
return True, tab_note_final
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de calculer les notes avec le -calcul_mode_1- "
|
||
|
||
"""
|
||
Cette fonction calcule les moyennes les sommes par ue/inscrit/type evaluation
|
||
"""
|
||
def Cacul_UE_Note_By_Evaluation_Type(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token', 'class_id', 'session_id', 'ue_id', 'tab_inscriptions_ids', 'evaluation_type_id',
|
||
'inscri_data_nom', 'inscri_data_prenom', 'inscri_data_email', 'evaluation_type_code']
|
||
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', 'class_id', 'session_id', 'ue_id', 'tab_inscriptions_ids', 'evaluation_type_id',
|
||
'inscri_data_nom', 'inscri_data_prenom', 'inscri_data_email']
|
||
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
is_session_valide_data = MYSY_GV.dbname['session_formation'].find_one(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
|
||
is_ue_valide_data = MYSY_GV.dbname['unite_enseignement'].find_one(
|
||
{'_id': ObjectId(str(diction['ue_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
|
||
is_myclass_valide_data = MYSY_GV.dbname['myclass'].find_one(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
# Verifier la validité de la liste des inscrits fournie
|
||
tab_inscriptions_ids = ""
|
||
if ("tab_inscriptions_ids" in diction.keys()):
|
||
if diction['tab_inscriptions_ids']:
|
||
tab_inscriptions_ids = diction['tab_inscriptions_ids']
|
||
|
||
tab_inscriptions_ids_splited = str(tab_inscriptions_ids).split(",")
|
||
|
||
# Controle de validité de toutes info avant de commencer les traitements
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
my_inscription = str(my_inscription).strip()
|
||
|
||
|
||
evaluation_type_id = ""
|
||
if( "evaluation_type_id" in diction and diction['evaluation_type_id']):
|
||
evaluation_type_id = diction['evaluation_type_id']
|
||
|
||
|
||
|
||
liste_note_evaluation_ids = []
|
||
|
||
for val in MYSY_GV.dbname['note_evaluation'].find({'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'class_id': str(diction['class_id']),
|
||
'class_eu_id': str(diction['ue_id']),
|
||
'type_eval_id': str(evaluation_type_id)}):
|
||
liste_note_evaluation_ids.append(str(val['_id']))
|
||
|
||
somme_note = 0
|
||
moyenne_note = 0
|
||
|
||
#print(" ### la liste des evaluations de type sont : ", liste_note_evaluation_ids)
|
||
|
||
nb_eval = len(liste_note_evaluation_ids)
|
||
#print(" ### la liste len(liste_note_evaluation_ids) : ", len(liste_note_evaluation_ids))
|
||
|
||
if( nb_eval > 0 ):
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
somme_note = 0
|
||
moyenne_note = 0
|
||
tab_apprenant_note = []
|
||
|
||
for note_evaluation_participant in MYSY_GV.dbname['note_evaluation_participant'].find(
|
||
{'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'inscription_id': str(my_inscription),
|
||
'evaluation_id': {'$in': liste_note_evaluation_ids}
|
||
}):
|
||
|
||
|
||
"""
|
||
A supprimer après, la c'est juste pour voir les data
|
||
"""
|
||
evaluation_data = MYSY_GV.dbname['note_evaluation'].find_one(
|
||
{'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'_id': ObjectId(str(note_evaluation_participant['evaluation_id']))})
|
||
|
||
somme_note = somme_note + mycommon.tryFloat(str(note_evaluation_participant['note']))
|
||
|
||
#print("************* ", evaluation_data['code'], " Du ",evaluation_data['eval_date_heure_debut'], " Au ", evaluation_data['eval_date_heure_fin'])
|
||
#print(" Session : is_session_valide_data = ", is_session_valide_data['code_session'])
|
||
#print(" Unit. Ensei : is_ue_valide_data = ", is_ue_valide_data['code'])
|
||
|
||
#print(" note_evaluation_participant = ", note_evaluation_participant['note'])
|
||
tab_apprenant_note.append(str(note_evaluation_participant['note']))
|
||
|
||
if( nb_eval == 0 ):
|
||
moyenne_note = "-"
|
||
somme_note = "-"
|
||
else:
|
||
moyenne_note = round(somme_note / nb_eval, 2)
|
||
"""
|
||
print("")
|
||
print(" ## Somme_note ",str(diction['evaluation_type']), " = ", str(somme_note), " ## Moyenne TP= ", str(moyenne_note))
|
||
print("")
|
||
print("")
|
||
"""
|
||
|
||
else :
|
||
moyenne_note = "-"
|
||
somme_note = "-"
|
||
|
||
|
||
return True, str(moyenne_note), str(somme_note), str(nb_eval)
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de lancer Cacul_UE_Note_By_Evaluation_Type "
|
||
|
||
|
||
"""
|
||
Cette fonction calcul la moyenne generale en
|
||
appliquant la forule 1:
|
||
• Nom : calcul_mode_1
|
||
Detail : ( ((Moyenne Art. (TD) + Moyenne Art(TP) * 2) ) /3 + Examen Final ) / 2
|
||
|
||
Alog :
|
||
la fonction va essentiellement travailler sur la collection : session_formation_final_note_classement_detail
|
||
|
||
"""
|
||
def Cacul_UE_Note_Finale_For_calcul_mode_1(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token', 'class_id', 'session_id', 'ue_id', 'tab_inscriptions_ids',]
|
||
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', 'class_id', 'session_id', 'ue_id', 'tab_inscriptions_ids',]
|
||
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
is_session_valide_data = MYSY_GV.dbname['session_formation'].find_one(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
|
||
is_ue_valide_data = MYSY_GV.dbname['unite_enseignement'].find_one(
|
||
{'_id': ObjectId(str(diction['ue_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
|
||
is_myclass_valide_data = MYSY_GV.dbname['myclass'].find_one(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
# Recuperer les données de l'UE dans la formation (ex : credit, seuil de validation, etc)
|
||
class_ue_data = {}
|
||
is_class_ue_data = "0"
|
||
if( "list_unite_enseignement" in is_myclass_valide_data.keys() ):
|
||
for data in is_myclass_valide_data['list_unite_enseignement']:
|
||
if( data['_id'] == str(diction['ue_id'])):
|
||
class_ue_data = data
|
||
is_class_ue_data = "1"
|
||
|
||
|
||
if( is_class_ue_data == "0"):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " La formation ne contient pas l'UE selectionné code = "+str(is_ue_valide_data['code']))
|
||
return False, " La formation ne contient pas l'UE selectionné code = "+str(is_ue_valide_data['code'])
|
||
|
||
|
||
|
||
# Verifier la validité de la liste des inscrits fournie
|
||
tab_inscriptions_ids = ""
|
||
if ("tab_inscriptions_ids" in diction.keys()):
|
||
if diction['tab_inscriptions_ids']:
|
||
tab_inscriptions_ids = diction['tab_inscriptions_ids']
|
||
|
||
tab_inscriptions_ids_splited = str(tab_inscriptions_ids).split(",")
|
||
|
||
# Controle de validité de toutes info avant de commencer les traitements
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
my_inscription = str(my_inscription).strip()
|
||
|
||
|
||
|
||
type_eval_td_data = MYSY_GV.dbname['type_evaluation'].find_one({'code': {'$regex': "td", "$options": "i"},
|
||
'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
})
|
||
|
||
if( type_eval_td_data is None ):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " Aucun type d'évaluation de type 'TD', merci de vérifier le paramétrage des types d'évaluation ")
|
||
return False, " Aucun type d'évaluation de type 'TD', merci de vérifier le paramétrage des types d'évaluation "
|
||
|
||
type_eval_tp_data = MYSY_GV.dbname['type_evaluation'].find_one({'code': {'$regex': "tp", "$options": "i"},
|
||
'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
})
|
||
|
||
if (type_eval_tp_data is None):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][
|
||
3]) + " Aucun type d'évaluation de type 'TP', merci de vérifier le paramétrage des types d'évaluation ")
|
||
return False, " Aucun type d'évaluation de type 'TP', merci de vérifier le paramétrage des types d'évaluation "
|
||
|
||
|
||
type_eval_examen_data = MYSY_GV.dbname['type_evaluation'].find_one({'code': {'$regex': "Examen", "$options": "i"},
|
||
'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
})
|
||
if (type_eval_examen_data is None):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][
|
||
3]) + " Aucun type d'évaluation de type 'Examen', merci de vérifier le paramétrage des types d'évaluation ")
|
||
return False, " Aucun type d'évaluation de type 'Exame', merci de vérifier le paramétrage des types d'évaluation "
|
||
|
||
|
||
|
||
|
||
basic_qry = {'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'session_id': str(diction['session_id']),
|
||
'ue_id': str( diction['ue_id']),
|
||
}
|
||
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
# 1 - recuperer toutes les notes pre_calculée de l'apprenant
|
||
|
||
local_node = {}
|
||
|
||
MA_TD_float = 0
|
||
MA_TP_float = 0
|
||
MA_Examen_float = 0
|
||
|
||
basic_qry['inscription_id'] = str(my_inscription)
|
||
|
||
inscri_data = MYSY_GV.dbname['inscription'].find_one({'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'_id': ObjectId(str(my_inscription).strip())},
|
||
{'nom': 1, 'prenom': 1, 'email': 1}
|
||
)
|
||
|
||
inscri_data_nom = ""
|
||
inscri_data_prenom = ""
|
||
inscri_data_email = ""
|
||
|
||
if( inscri_data and "nom" in inscri_data.keys() ):
|
||
inscri_data_nom = inscri_data['nom']
|
||
|
||
if (inscri_data and "prenom" in inscri_data.keys()):
|
||
inscri_data_prenom = inscri_data['prenom']
|
||
|
||
if (inscri_data and "email" in inscri_data.keys()):
|
||
inscri_data_email = inscri_data['email']
|
||
|
||
#### Recuperation des data TD
|
||
basic_qry['type_eval_id'] = str(type_eval_td_data['_id'])
|
||
MA_TD_data = MYSY_GV.dbname['session_formation_final_note_classement_detail'].find_one(basic_qry)
|
||
if (MA_TD_data):
|
||
print(" ### MA_TD_data = ", MA_TD_data)
|
||
MA_TD_float = float(MA_TD_data['moyenne'])
|
||
print(" ############################ ")
|
||
|
||
#### Recuperation des data TP
|
||
basic_qry['type_eval_id'] = str(type_eval_tp_data['_id'])
|
||
MA_TP_data = MYSY_GV.dbname['session_formation_final_note_classement_detail'].find_one(basic_qry)
|
||
if( MA_TP_data ):
|
||
print(" ### MA_TP_data = ", MA_TP_data)
|
||
MA_TP_float = float(MA_TP_data['moyenne'])
|
||
print(" ############################ ")
|
||
|
||
#### Recuperation des data Examen
|
||
basic_qry['type_eval_id'] = str(type_eval_examen_data['_id'])
|
||
MA_EXAMEN_data = MYSY_GV.dbname['session_formation_final_note_classement_detail'].find_one(basic_qry)
|
||
if (MA_EXAMEN_data):
|
||
print(" ### MA_EXAMEN_data = ", MA_EXAMEN_data)
|
||
MA_Examen_float = float(MA_EXAMEN_data['moyenne'])
|
||
print(" ############################ ")
|
||
|
||
note_finale_ue = ( (( (MA_TD_float + (MA_TP_float * 2 )) / 3 ) + MA_Examen_float) )/ 2
|
||
|
||
note_finale_ue = round(note_finale_ue, 2)
|
||
|
||
print(" ## MA_TD_float = ", MA_TD_float)
|
||
print(" ## MA_TP_float = ", MA_TP_float)
|
||
print(" ## MA_Examen_float = ", MA_Examen_float)
|
||
|
||
print(" ### note_finale_ue = ", note_finale_ue)
|
||
|
||
|
||
local_node['inscription_id'] = str(my_inscription)
|
||
local_node['session_id'] = str(diction['session_id'])
|
||
local_node['type_eval'] = "note_finale"
|
||
local_node['type_eval_id'] = "----"
|
||
|
||
local_node['ue_id'] = str(diction['ue_id'])
|
||
|
||
if( "credit" in class_ue_data.keys() ):
|
||
local_node['credit'] = str(class_ue_data['credit'])
|
||
elif ( "ects" in is_ue_valide_data.keys() ):
|
||
local_node['credit'] = str(is_ue_valide_data['ects'])
|
||
else:
|
||
local_node['credit'] = "0"
|
||
|
||
if ("coefficient" in class_ue_data.keys()):
|
||
local_node['ue_coefficient'] = str(class_ue_data['coefficient'])
|
||
elif ("coefficient" in is_ue_valide_data.keys()):
|
||
local_node['ue_coefficient'] = str(is_ue_valide_data['coefficient'])
|
||
else:
|
||
local_node['ue_coefficient'] = "1"
|
||
|
||
if ("seuil_validation" in class_ue_data.keys()):
|
||
local_node['seuil_validation'] = str(class_ue_data['seuil_validation'])
|
||
elif ("seuil_validation" in is_ue_valide_data.keys()):
|
||
local_node['seuil_validation'] = str(is_ue_valide_data['seuil_validation'])
|
||
else:
|
||
local_node['seuil_validation'] = "99" # le 99 pour eviter les validation par defaut
|
||
|
||
# Acter si la personne valide l'UE
|
||
print(" #### si la personne valide l'UE CMP de float(note_finale_ue) = ", float(note_finale_ue) , " et float(local_node['seuil_validation'] ) = ", float(local_node['seuil_validation'] ))
|
||
if(float(note_finale_ue) >= float(local_node['seuil_validation'] )):
|
||
local_node['ue_validation'] = "1"
|
||
else:
|
||
local_node['ue_validation'] = "0"
|
||
|
||
local_node['class_id'] = str(diction['class_id'])
|
||
local_node['inscription_email'] = str(inscri_data_email)
|
||
local_node['inscription_nom'] = str(inscri_data_nom)
|
||
local_node['inscription_prenom'] = str(inscri_data_prenom)
|
||
|
||
local_node['session_id'] = str(diction['session_id'])
|
||
|
||
local_node['note_td'] = str(MA_TD_float)
|
||
local_node['note_tp'] = str(MA_TP_float)
|
||
local_node['note_examen'] = str(MA_Examen_float)
|
||
local_node['regle_calcul'] = "( ((Moyenne Art. (TD) + Moyenne Art(TP) * 2) ) /3 + Examen Final ) / 2"
|
||
local_node['note_finale'] = str(note_finale_ue)
|
||
|
||
local_node['create_date'] = str(datetime.now())
|
||
local_node['created_by'] = str(my_partner['_id'])
|
||
local_node['valide'] = "1"
|
||
local_node['locked'] = "0"
|
||
local_node['partner_owner_recid'] = str(my_partner['recid'])
|
||
|
||
qry_key = {}
|
||
qry_key['partner_owner_recid'] = my_partner['recid']
|
||
qry_key['valide'] = "1"
|
||
qry_key['locked'] = "0"
|
||
qry_key['inscription_id'] = local_node['inscription_id']
|
||
qry_key['session_id'] = local_node['session_id']
|
||
qry_key['type_eval'] = local_node['type_eval']
|
||
qry_key['ue_id'] = local_node['ue_id']
|
||
|
||
|
||
|
||
ret_val2 = MYSY_GV.dbname['session_formation_final_note_classement'].find_one_and_update(
|
||
qry_key,
|
||
{"$set": local_node},
|
||
return_document=ReturnDocument.AFTER,
|
||
upsert=True,
|
||
)
|
||
|
||
|
||
"""
|
||
Après le calcul de la moyenne finale, il faut faire le classement
|
||
"""
|
||
basic_qry = {'partner_owner_recid': str(my_partner['recid']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'session_id': str(diction['session_id']),
|
||
'ue_id': str(diction['ue_id']),
|
||
}
|
||
|
||
|
||
classement = 0
|
||
note_precedente = ""
|
||
for sorted_data in MYSY_GV.dbname['session_formation_final_note_classement'].find(basic_qry).sort([("note_finale", pymongo.DESCENDING), ]):
|
||
# Gestion des Execo
|
||
if( str(note_precedente) != str(sorted_data['note_finale'])):
|
||
classement = classement + 1
|
||
note_precedente = str(sorted_data['note_finale'])
|
||
|
||
#MAJ du rang
|
||
print(" MAJJ classement = ", classement)
|
||
MYSY_GV.dbname['session_formation_final_note_classement'].find_one_and_update(
|
||
{'_id':ObjectId(str(sorted_data['_id'])),
|
||
'partner_owner_recid':str(sorted_data['partner_owner_recid']),
|
||
'valide':'1',
|
||
'locked':'0'
|
||
|
||
},
|
||
{"$set": {'rang':str(classement), 'rang_calculation_date':str(datetime.now())}},
|
||
return_document=ReturnDocument.AFTER,
|
||
upsert=False,
|
||
)
|
||
|
||
return True, "Calcul Final Moyenne et Classement ok"
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de lancer Cacul_UE_Note_By_Evaluation_Type "
|
||
|
||
|
||
|
||
"""
|
||
Cette fonction retourne la liste des notes finales
|
||
d'une session de formation
|
||
avec des filter sur :
|
||
- la formation (code),
|
||
- list UE tab_ue_id
|
||
- list session tab_session_id
|
||
|
||
"""
|
||
def Get_List_Evaluation_Final_Note_Classement_Detail_With_Filter(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token','class_external_code', 'tab_ue_id', 'tab_session_id', 'tab_inscrit_id',
|
||
'jury_apprenant_agenda_id']
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', ]
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
filt_session_id = {}
|
||
if( "tab_session_id" in diction.keys() ):
|
||
tab_session_id = str(diction['tab_session_id']).split(",")
|
||
if(len(tab_session_id) > 0 ):
|
||
filt_session_id = {'session_id':{'$in': tab_session_id }}
|
||
|
||
|
||
filt_ue_id = {}
|
||
if ("tab_ue_id" in diction.keys()):
|
||
tab_ue_id = str(diction['tab_ue_id']).split(",")
|
||
if (len(tab_ue_id) > 0):
|
||
filt_ue_id = {'ue_id': {'$in': tab_ue_id}}
|
||
|
||
filt_inscrit_id = {}
|
||
if ("tab_inscrit_id" in diction.keys()):
|
||
tab_inscrit_id = str(diction['tab_inscrit_id']).split(",")
|
||
if (len(tab_inscrit_id) > 0):
|
||
filt_inscrit_id = {'inscription_id': {'$in': tab_inscrit_id}}
|
||
|
||
filt_apprenant_id_from_jury_seance = {}
|
||
tab_inscription_id = []
|
||
if ("jury_apprenant_agenda_id" in diction.keys() and diction['jury_apprenant_agenda_id']):
|
||
|
||
for tmp in MYSY_GV.dbname['jury_apprenant'].find({'agenda_id': str(diction['jury_apprenant_agenda_id']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])}):
|
||
tab_inscription_id.append(str(tmp['inscription_id']))
|
||
|
||
if (len(tab_inscription_id) > 0):
|
||
filt_apprenant_id_from_jury_seance = {'inscription_id': {'$in': tab_inscription_id}}
|
||
|
||
"""
|
||
Clés de mise à jour
|
||
"""
|
||
data_cle = {}
|
||
data_cle['partner_owner_recid'] = str(my_partner['recid'])
|
||
data_cle['valide'] = "1"
|
||
data_cle['locked'] = "0"
|
||
|
||
query = {"$and": [filt_session_id, filt_ue_id, data_cle, filt_inscrit_id, filt_apprenant_id_from_jury_seance]}
|
||
|
||
print(" ### tetetet query = ",query)
|
||
|
||
RetObject = []
|
||
val_tmp = 0
|
||
|
||
for retval in MYSY_GV.dbname['session_formation_final_note_classement_detail'].find(query).sort([("ue_id", pymongo.DESCENDING),("inscription_id", pymongo.DESCENDING),
|
||
("type_eval_id", pymongo.DESCENDING), ]):
|
||
user = retval
|
||
user['id'] = str(val_tmp)
|
||
val_tmp = val_tmp + 1
|
||
|
||
ue_id_code = ""
|
||
if( "ue_id" in retval.keys() ):
|
||
ue_id_data = MYSY_GV.dbname['unite_enseignement'].find_one({'_id':ObjectId(str(retval['ue_id'])),
|
||
'partner_owner_recid':my_partner['recid'],
|
||
'valide':'1',
|
||
'locked':'0'},
|
||
{'code':1})
|
||
if( ue_id_data and "code" in ue_id_data.keys() ):
|
||
ue_id_code = ue_id_data['code']
|
||
|
||
user['ue_id_code'] = ue_id_code
|
||
|
||
class_id_external_code = ""
|
||
if ("class_id" in retval.keys()):
|
||
class_id_data = MYSY_GV.dbname['myclass'].find_one({'_id': ObjectId(str(retval['ue_id'])),
|
||
'partner_owner_recid': my_partner['recid'],
|
||
'valide': '1',
|
||
'locked': '0'},
|
||
{'external_code': 1})
|
||
if (class_id_data and "external_code" in class_id_data.keys()):
|
||
class_id_external_code = class_id_data['external_code']
|
||
|
||
user['class_id_external_code'] = class_id_external_code
|
||
|
||
inscription_id_nom = ""
|
||
inscription_id_prenom = ""
|
||
inscription_id_mail = ""
|
||
if ("inscription_id" in retval.keys()):
|
||
inscription_id_data = MYSY_GV.dbname['inscription'].find_one({'_id': ObjectId(str(retval['inscription_id'])),
|
||
'partner_owner_recid': my_partner['recid'],
|
||
'valide': '1',},
|
||
{'email': 1, 'nom':1, 'prenom':1})
|
||
|
||
if (inscription_id_data and "email" in inscription_id_data.keys()):
|
||
inscription_id_mail = inscription_id_data['email']
|
||
|
||
if (inscription_id_data and "nom" in inscription_id_data.keys()):
|
||
inscription_id_nom = inscription_id_data['nom']
|
||
|
||
if (inscription_id_data and "prenom" in inscription_id_data.keys()):
|
||
inscription_id_prenom = inscription_id_data['prenom']
|
||
|
||
|
||
user['inscription_id_mail'] = inscription_id_mail
|
||
user['inscription_id_nom'] = inscription_id_nom
|
||
user['inscription_id_prenom'] = inscription_id_prenom
|
||
|
||
|
||
RetObject.append(mycommon.JSONEncoder().encode(user))
|
||
|
||
return True, RetObject
|
||
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de récupérer la liste des évaluations "
|
||
|
||
|
||
"""
|
||
Recuperation des notes et le classement par unité d'enseignement (UE)
|
||
"""
|
||
def Get_List_Evaluation_UE_Note_Classement_With_Filter(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token','class_external_code', 'tab_ue_id', 'tab_session_id', 'tab_inscrit_id',
|
||
'jury_apprenant_agenda_id']
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', ]
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
filt_session_id = {}
|
||
if( "tab_session_id" in diction.keys() ):
|
||
tab_session_id = str(diction['tab_session_id']).split(",")
|
||
if(len(tab_session_id) > 0 ):
|
||
filt_session_id = {'session_id':{'$in': tab_session_id }}
|
||
|
||
|
||
filt_ue_id = {}
|
||
if ("tab_ue_id" in diction.keys()):
|
||
tab_ue_id = str(diction['tab_ue_id']).split(",")
|
||
if (len(tab_ue_id) > 0):
|
||
filt_ue_id = {'ue_id': {'$in': tab_ue_id}}
|
||
|
||
filt_inscrit_id = {}
|
||
if ("tab_inscrit_id" in diction.keys()):
|
||
tab_inscrit_id = str(diction['tab_inscrit_id']).split(",")
|
||
if (len(tab_inscrit_id) > 0):
|
||
filt_inscrit_id = {'inscription_id': {'$in': tab_inscrit_id}}
|
||
|
||
filt_apprenant_id_from_jury_seance = {}
|
||
tab_inscription_id = []
|
||
if ("jury_apprenant_agenda_id" in diction.keys() and diction['jury_apprenant_agenda_id']):
|
||
|
||
|
||
|
||
|
||
for tmp in MYSY_GV.dbname['jury_apprenant'].find({'agenda_id': str(diction['jury_apprenant_agenda_id']),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])}):
|
||
tab_inscription_id.append(str(tmp['inscription_id']))
|
||
|
||
if(len(tab_inscription_id) > 0 ):
|
||
filt_apprenant_id_from_jury_seance = {'inscription_id': {'$in': tab_inscription_id}}
|
||
|
||
"""
|
||
Clés de mise à jour
|
||
"""
|
||
data_cle = {}
|
||
data_cle['partner_owner_recid'] = str(my_partner['recid'])
|
||
data_cle['valide'] = "1"
|
||
data_cle['locked'] = "0"
|
||
|
||
query = {"$and": [filt_session_id, filt_ue_id, data_cle, filt_inscrit_id, filt_apprenant_id_from_jury_seance]}
|
||
|
||
#print(" ### session_formation_final_note_classement query = ", query)
|
||
|
||
RetObject = []
|
||
val_tmp = 0
|
||
|
||
for retval in MYSY_GV.dbname['session_formation_final_note_classement'].find(query).sort([("ue_id", pymongo.DESCENDING),("inscription_id", pymongo.DESCENDING),
|
||
("type_eval_id", pymongo.DESCENDING), ]):
|
||
user = retval
|
||
user['id'] = str(val_tmp)
|
||
val_tmp = val_tmp + 1
|
||
|
||
if ("jury_note" not in retval.keys()):
|
||
user['jury_note'] = ""
|
||
|
||
if ("jury_observation" not in retval.keys()):
|
||
user['jury_observation'] = ""
|
||
|
||
if ("jury_validation" not in retval.keys()):
|
||
user['jury_validation'] = ""
|
||
|
||
if ("jury_validation_champ_technique" not in retval.keys()):
|
||
user['jury_validation_champ_technique'] = ""
|
||
|
||
|
||
ue_id_code = ""
|
||
if( "ue_id" in retval.keys() ):
|
||
ue_id_data = MYSY_GV.dbname['unite_enseignement'].find_one({'_id':ObjectId(str(retval['ue_id'])),
|
||
'partner_owner_recid':my_partner['recid'],
|
||
'valide':'1',
|
||
'locked':'0'},
|
||
{'code':1})
|
||
if( ue_id_data and "code" in ue_id_data.keys() ):
|
||
ue_id_code = ue_id_data['code']
|
||
|
||
user['ue_id_code'] = ue_id_code
|
||
|
||
class_id_external_code = ""
|
||
if ("class_id" in retval.keys()):
|
||
class_id_data = MYSY_GV.dbname['myclass'].find_one({'_id': ObjectId(str(retval['ue_id'])),
|
||
'partner_owner_recid': my_partner['recid'],
|
||
'valide': '1',
|
||
'locked': '0'},
|
||
{'external_code': 1})
|
||
if (class_id_data and "external_code" in class_id_data.keys()):
|
||
class_id_external_code = class_id_data['external_code']
|
||
|
||
user['class_id_external_code'] = class_id_external_code
|
||
|
||
inscription_id_nom = ""
|
||
inscription_id_prenom = ""
|
||
inscription_id_mail = ""
|
||
if ("inscription_id" in retval.keys()):
|
||
inscription_id_data = MYSY_GV.dbname['inscription'].find_one({'_id': ObjectId(str(retval['inscription_id'])),
|
||
'partner_owner_recid': my_partner['recid'],
|
||
'valide': '1',},
|
||
{'email': 1, 'nom':1, 'prenom':1})
|
||
|
||
if (inscription_id_data and "email" in inscription_id_data.keys()):
|
||
inscription_id_mail = inscription_id_data['email']
|
||
|
||
if (inscription_id_data and "nom" in inscription_id_data.keys()):
|
||
inscription_id_nom = inscription_id_data['nom']
|
||
|
||
if (inscription_id_data and "prenom" in inscription_id_data.keys()):
|
||
inscription_id_prenom = inscription_id_data['prenom']
|
||
|
||
|
||
user['inscription_id_mail'] = inscription_id_mail
|
||
user['inscription_id_nom'] = inscription_id_nom
|
||
user['inscription_id_prenom'] = inscription_id_prenom
|
||
|
||
|
||
RetObject.append(mycommon.JSONEncoder().encode(user))
|
||
|
||
return True, RetObject
|
||
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de récupérer la liste des évaluations "
|
||
|
||
|
||
|
||
"""
|
||
Recuperation des notes et le classement par Inscription (donc le classement et moyenne definitive)
|
||
"""
|
||
def Get_List_Evaluation_Inscriptio_Note_Classement_With_Filter(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token','session_id']
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token','session_id']
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
|
||
"""
|
||
Clés de mise à jour
|
||
"""
|
||
data_cle = {}
|
||
data_cle['partner_owner_recid'] = str(my_partner['recid'])
|
||
data_cle['valide'] = "1"
|
||
data_cle['session_id'] = str(diction['session_id'])
|
||
|
||
|
||
RetObject = []
|
||
val_tmp = 0
|
||
|
||
for retval in MYSY_GV.dbname['inscription'].find(data_cle).sort([("rang", pymongo.ASCENDING),("note_finale", pymongo.DESCENDING),
|
||
("nom", pymongo.DESCENDING), ]):
|
||
user = retval
|
||
user['id'] = str(val_tmp)
|
||
val_tmp = val_tmp + 1
|
||
|
||
if( "jury_note" not in retval.keys() ):
|
||
user['jury_note'] = ""
|
||
|
||
if ("jury_observation" not in retval.keys()):
|
||
user['jury_observation'] = ""
|
||
|
||
if ("jury_validation" not in retval.keys()):
|
||
user['jury_validation'] = ""
|
||
|
||
if ("jury_validation_champ_technique" not in retval.keys()):
|
||
user['jury_validation_champ_technique'] = ""
|
||
|
||
if ("rang_calculation_date" not in retval.keys()):
|
||
user['rang_calculation_date'] = ""
|
||
|
||
|
||
RetObject.append(mycommon.JSONEncoder().encode(user))
|
||
|
||
return True, RetObject
|
||
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de récupérer la liste les classement pour la collection 'inscription' "
|
||
|
||
|
||
|
||
"""
|
||
Cette fonction va calculer moyenne par session (formation)
|
||
|
||
Précedemment les calculs se faisaient pas UE, a présent nous allons faire le calcul par formation.
|
||
|
||
Calcul selon la règle :
|
||
- [ UE * Coef (UE) ] / nb_coef
|
||
|
||
"""
|
||
def Cacul_Session_Note_Finale_For_calcul_mode_1(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token', 'class_id', 'session_id', 'tab_inscriptions_ids',]
|
||
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', 'class_id', 'session_id', 'tab_inscriptions_ids',]
|
||
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes"
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
# Verifier la validité de la session
|
||
is_session_valide_count = MYSY_GV.dbname['session_formation'].count_documents(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (is_session_valide_count != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide ")
|
||
return False, " L'identifiant de la session est invalide"
|
||
|
||
is_session_valide_data = MYSY_GV.dbname['session_formation'].find_one(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
# Verifier si la formartion est valide
|
||
is_myclass_valide_count = MYSY_GV.dbname['myclass'].count_documents(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (is_myclass_valide_count != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de la formation est invalide ")
|
||
return False, " L'identifiant de la formation est invalide"
|
||
|
||
is_myclass_valide_data = MYSY_GV.dbname['myclass'].find_one(
|
||
{'_id': ObjectId(str(diction['class_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
"""
|
||
Recuperer la liste des UE de la formation, avec leur credit et coeff.*
|
||
"""
|
||
tab_class_ue = []
|
||
if( "list_unite_enseignement" in is_myclass_valide_data.keys() ):
|
||
tab_class_ue = is_myclass_valide_data['list_unite_enseignement']
|
||
|
||
if(len(tab_class_ue) <= 0 ):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " Aucune unité d'enseignement pour cette formation ")
|
||
return False, " Aucune unité d'enseignement pour cette formation "
|
||
|
||
|
||
# Verifier la validité de la liste des inscrits fournie
|
||
tab_inscriptions_ids = ""
|
||
if ("tab_inscriptions_ids" in diction.keys()):
|
||
if diction['tab_inscriptions_ids']:
|
||
tab_inscriptions_ids = diction['tab_inscriptions_ids']
|
||
|
||
tab_inscriptions_ids_splited = str(tab_inscriptions_ids).split(",")
|
||
|
||
# Controle de validité de toutes info avant de commencer les traitements
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
my_inscription = str(my_inscription).strip()
|
||
|
||
# Verifier que l'inscription est valide
|
||
my_inscription_is_valide = MYSY_GV.dbname['inscription'].count_documents(
|
||
{'_id': ObjectId(str(my_inscription)), 'status': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
if (my_inscription_is_valide != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'inscription_id '" + my_inscription + "' n'est pas valide ")
|
||
return False, " L'inscription_id '" + my_inscription + "' n'est pas valide "
|
||
|
||
"""
|
||
La formule : [ UE * Coef (UE) ] / nb_coef
|
||
"""
|
||
|
||
# Controle de validité de toutes info avant de commencer les traitements
|
||
for my_inscription in tab_inscriptions_ids_splited:
|
||
my_inscription = str(my_inscription).strip()
|
||
|
||
print(" ### pour l'inscrit = ", my_inscription)
|
||
nb_coef = 0
|
||
session_somme_note_with_coef = 0
|
||
session_moyenne_note_with_coef = 0
|
||
|
||
session_somme_credit_acquis = 0
|
||
|
||
for class_ue in tab_class_ue :
|
||
for tmps_data in MYSY_GV.dbname['session_formation_final_note_classement'].find({'partner_owner_recid':str(my_partner['recid']),
|
||
'ue_id':str(class_ue['_id']),
|
||
'inscription_id':str(my_inscription),
|
||
'valide':'1',
|
||
'locked':'0'}):
|
||
|
||
|
||
|
||
coefficient = "1"
|
||
if( "coefficient" in class_ue.keys() and class_ue['coefficient']):
|
||
coefficient = class_ue['coefficient']
|
||
|
||
nb_coef = nb_coef + float(coefficient)
|
||
|
||
ue_note_with_coef = round( (float(tmps_data['note_finale'])*float(coefficient)), 2)
|
||
session_somme_note_with_coef = round( (session_somme_note_with_coef + ue_note_with_coef), 2)
|
||
|
||
"""
|
||
Si l'UE est validée, alors on attribut le credit comme validé
|
||
"""
|
||
if ("ue_validation" in tmps_data.keys() and str(tmps_data['ue_validation']) == "1" ):
|
||
if( "credit" in tmps_data.keys() and tmps_data['credit']):
|
||
session_somme_credit_acquis = round( (float(session_somme_credit_acquis) + float(tmps_data['credit'])), 2)
|
||
|
||
print(" ### session_somme_credit_acquis total = ", session_somme_credit_acquis)
|
||
print(" ### nb_coef total = ", nb_coef)
|
||
print(" ### session_somme_note_with_coef = ", session_somme_note_with_coef)
|
||
session_moyenne_note_with_coef = round( (float(session_somme_note_with_coef) / float(nb_coef)), 2)
|
||
print(" ### session_moyenne_note_with_coef = ", session_moyenne_note_with_coef)
|
||
|
||
# MAJ de la note glabale
|
||
print(" MAJJ classement glabal sur l'inscription = ")
|
||
MYSY_GV.dbname['inscription'].find_one_and_update(
|
||
{'_id': ObjectId(str(my_inscription)),
|
||
'partner_owner_recid': str(is_session_valide_data['partner_owner_recid']),
|
||
'session_id':str(is_session_valide_data['_id']),
|
||
'valide': '1',
|
||
'locked': '0'
|
||
|
||
},
|
||
{"$set": {'note_finale': str(session_moyenne_note_with_coef),
|
||
'credit_acquis':str(session_somme_credit_acquis)}},
|
||
return_document=ReturnDocument.AFTER,
|
||
upsert=False,
|
||
)
|
||
|
||
|
||
"""
|
||
Apres avoir saisi la note finale sur l'inscription, on va mettre à jour le rang
|
||
"""
|
||
classement = 0
|
||
note_precedente = ""
|
||
for sorted_data in MYSY_GV.dbname['inscription'].find(
|
||
{'partner_owner_recid': str(is_session_valide_data['partner_owner_recid']),
|
||
'session_id':str(is_session_valide_data['_id']),
|
||
'valide': '1',
|
||
'locked': '0' }).sort(
|
||
[("note_finale", pymongo.DESCENDING), ]):
|
||
|
||
if( sorted_data and "note_finale" in sorted_data.keys() ):
|
||
# Gestion des Execo
|
||
if (str(note_precedente) != str(sorted_data['note_finale'])):
|
||
classement = classement + 1
|
||
note_precedente = str(sorted_data['note_finale'])
|
||
|
||
# MAJ du rang
|
||
print(" MAJJ classement = ", classement)
|
||
MYSY_GV.dbname['inscription'].find_one_and_update(
|
||
{'_id': ObjectId(str(sorted_data['_id'])),
|
||
'partner_owner_recid': str(sorted_data['partner_owner_recid']),
|
||
'valide': '1',
|
||
'locked': '0'
|
||
|
||
},
|
||
{"$set": {'rang': str(classement), 'rang_calculation_date':str(datetime.now())}},
|
||
return_document=ReturnDocument.AFTER,
|
||
upsert=False,
|
||
)
|
||
|
||
|
||
return True, "Calcul Final Moyenne et Classement ok"
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de lancer Cacul_Session_Note_Finale_For_calcul_mode_1 "
|
||
|
||
|
||
|
||
"""
|
||
Cette fonction retourne les données de 'base_calcul_note_class_and_ue' avec des filter
|
||
"""
|
||
def Get_List_base_calcul_note_class_and_ue_With_Filter(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token','tab_related_collection', ]
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', ]
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
# Verifier la validité de la liste des inscrits fournie
|
||
tab_related_collection_name = ""
|
||
if ("tab_related_collection" in diction.keys()):
|
||
if diction['tab_related_collection']:
|
||
tab_related_collection_name = diction['tab_related_collection']
|
||
|
||
tab_related_collection_name_splited = str(tab_related_collection_name).split(",")
|
||
|
||
tab_partner_owner_recid = [str(my_partner['recid']), 'default']
|
||
data_cle = {}
|
||
data_cle['partner_owner_recid'] = {'$in':tab_partner_owner_recid}
|
||
data_cle['valide'] = "1"
|
||
data_cle['locked'] = "0"
|
||
data_cle['related_collection'] = {'$in':tab_related_collection_name_splited}
|
||
|
||
|
||
query = data_cle
|
||
|
||
RetObject = []
|
||
val_tmp = 0
|
||
|
||
for retval in MYSY_GV.dbname['base_calcul_note_class_and_ue'].find(query).sort([("_id", pymongo.DESCENDING)]):
|
||
user = retval
|
||
user['id'] = str(val_tmp)
|
||
val_tmp = val_tmp + 1
|
||
|
||
RetObject.append(mycommon.JSONEncoder().encode(user))
|
||
|
||
return True, RetObject
|
||
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de récupérer la liste des base_calcul_note_class_and_ue "
|
||
|
||
|
||
"""
|
||
Fonction globale de calcul en prenant en entrée une session
|
||
"""
|
||
|
||
def Calcul_Note_Classement_Session(diction):
|
||
try:
|
||
diction = mycommon.strip_dictionary(diction)
|
||
|
||
"""
|
||
Verification des input acceptés
|
||
"""
|
||
field_list = ['token','session_id', ]
|
||
|
||
incom_keys = diction.keys()
|
||
for val in incom_keys:
|
||
if val not in field_list and val.startswith('my_') is False:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification des champs obligatoires
|
||
"""
|
||
field_list_obligatoire = ['token', ]
|
||
for val in field_list_obligatoire:
|
||
if val not in diction:
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
|
||
return False, " Les informations fournies sont incorrectes",
|
||
|
||
"""
|
||
Verification de l'identité et autorisation de l'entité qui
|
||
appelle cette API
|
||
"""
|
||
token = ""
|
||
if ("token" in diction.keys()):
|
||
if diction['token']:
|
||
token = diction['token']
|
||
|
||
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
||
if (local_status is not True):
|
||
return local_status, my_partner
|
||
|
||
|
||
is_session_valide_count = MYSY_GV.dbname['session_formation'].count_documents({'_id':ObjectId(str(diction['session_id'])),
|
||
'valide':'1',
|
||
'partner_owner_recid':str(my_partner['recid'])})
|
||
|
||
if( is_session_valide_count != 1):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide ")
|
||
return False, " L'identifiant de la session est invalide ",
|
||
|
||
is_session_valide_data = MYSY_GV.dbname['session_formation'].find_one(
|
||
{'_id': ObjectId(str(diction['session_id'])),
|
||
'valide': '1',
|
||
'partner_owner_recid': str(my_partner['recid'])})
|
||
|
||
tab_inscrit_id = []
|
||
for inscrit in MYSY_GV.dbname['inscription'].find({'valide':'1',
|
||
'partner_owner_recid':str(my_partner['recid']),
|
||
'session_id':str(is_session_valide_data['_id'])}):
|
||
tab_inscrit_id.append(str(inscrit['_id']))
|
||
|
||
print(" ### str(is_session_valide_data['class_internal_url']) = ", str(is_session_valide_data['class_internal_url']))
|
||
|
||
is_class_data = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(is_session_valide_data['class_internal_url']),
|
||
'valide':'1',
|
||
'partner_owner_recid':str(my_partner['recid'])})
|
||
|
||
|
||
"""
|
||
Preparation des calculs
|
||
"""
|
||
|
||
# On recupere la liste des ue_id de la formation
|
||
tab_ue_id = []
|
||
for class_class_ue_data in is_class_data['list_unite_enseignement'] :
|
||
tab_ue_id.append( str(class_class_ue_data['_id']))
|
||
|
||
|
||
local_diction = {}
|
||
local_diction['token'] = str(diction['token'])
|
||
local_diction['class_id'] = str(is_class_data['_id'])
|
||
local_diction['session_id'] = str(diction['session_id'])
|
||
|
||
|
||
list_inscrit_id = ",".join(tab_ue_id)
|
||
local_diction['tab_ue_ids'] = str(list_inscrit_id)
|
||
|
||
list_inscrit_id = ",".join(tab_inscrit_id)
|
||
local_diction['tab_inscriptions_ids'] = str(list_inscrit_id)
|
||
|
||
print('### local_diction 01010 =', local_diction)
|
||
|
||
local_status, local_retval = run_ue_pre_calcul_moyenne_somme(local_diction)
|
||
|
||
if( local_status is False ):
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Impossible d'initialiser les calculs (fonction :run_ue_pre_calcul_moyenne_somme ) ")
|
||
return False, " Impossible d'initialiser les calculs ",
|
||
|
||
|
||
"""
|
||
Pour Chaque UE de l'enseignement aller chercher le 'note_ue_calculation_rule_id', puis la formule de calcul associée
|
||
"""
|
||
for class_class_ue_data in is_class_data['list_unite_enseignement'] :
|
||
|
||
unite_enseignement_data = MYSY_GV.dbname['unite_enseignement'].find_one(
|
||
{'_id': ObjectId(str(class_class_ue_data['_id'])),
|
||
'valide': '1',
|
||
'locked': '0',
|
||
})
|
||
|
||
|
||
note_ue_calculation_rule_id = ""
|
||
if( "note_ue_calculation_rule_id" in unite_enseignement_data.keys() and unite_enseignement_data['note_ue_calculation_rule_id']):
|
||
|
||
note_ue_calculation_rule_id = unite_enseignement_data['note_ue_calculation_rule_id']
|
||
|
||
if( note_ue_calculation_rule_id == ""):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'unité d'enseignement "+str(unite_enseignement_data['code'])+" n'a pas de règle de calcul de la note")
|
||
return False, " L'unité d'enseignement "+str(unite_enseignement_data['code'])+" n'a pas de règle de calcul de la note"
|
||
|
||
base_calcul_note_class_and_ue_data = MYSY_GV.dbname['base_calcul_note_class_and_ue'].find_one({'_id':ObjectId(str(unite_enseignement_data['note_ue_calculation_rule_id'])),
|
||
'valide':'1',
|
||
'locked':'0',
|
||
'related_collection':'unite_enseignement'})
|
||
|
||
ue_calcul_fonction_name = ""
|
||
if ("fonction_name" in base_calcul_note_class_and_ue_data.keys() and base_calcul_note_class_and_ue_data['fonction_name']):
|
||
ue_calcul_fonction_name = base_calcul_note_class_and_ue_data['fonction_name']
|
||
|
||
if (ue_calcul_fonction_name == ""):
|
||
mycommon.myprint(
|
||
str(inspect.stack()[0][3]) + " L'unité d'enseignement " + str(
|
||
unite_enseignement_data['code']) + " n'a pas de règle de calcul de la note (2) ")
|
||
return False, " L'unité d'enseignement " + str(
|
||
unite_enseignement_data['code']) + " n'a pas de règle de calcul de la note (2) "
|
||
|
||
print(" ### Pour l'UE : ",str(unite_enseignement_data['code']),
|
||
" Coef : ", class_class_ue_data['coefficient'],
|
||
" seuil validation : ", class_class_ue_data['seuil_validation'])
|
||
|
||
print(" ### la formule de calcul est : ", base_calcul_note_class_and_ue_data['fonction_name'])
|
||
|
||
#field_list = ['token', 'class_id', 'session_id', 'ue_id', 'tab_inscriptions_ids',]
|
||
local_node = {}
|
||
local_node['token'] = str(diction['token'])
|
||
local_node['class_id'] = str(is_class_data['_id'])
|
||
local_node['session_id'] = str(diction['session_id'])
|
||
local_node['ue_id'] = str(unite_enseignement_data['_id'])
|
||
|
||
list_inscrit_id = ",".join(tab_inscrit_id)
|
||
local_node['tab_inscriptions_ids'] = str(list_inscrit_id)
|
||
|
||
|
||
possibles = globals().copy()
|
||
possibles.update(locals())
|
||
cron_function = possibles.get(base_calcul_note_class_and_ue_data['fonction_name'])
|
||
|
||
if not cron_function:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Fonction '" + str(base_calcul_note_class_and_ue_data['fonction_name']) + "' est introuvable")
|
||
|
||
print(" Exécution de la fonction : UE de Session = ", base_calcul_note_class_and_ue_data['fonction_name'])
|
||
local_status, local_retval = cron_function(local_node)
|
||
|
||
|
||
class_function_note_calcul_rule = ""
|
||
class_note_calcul_data = None
|
||
if( is_class_data and "note_finale_calculation_rule_id" in is_class_data.keys() and is_class_data['note_finale_calculation_rule_id'] ):
|
||
print(" ### note_finale_calculation_rule_id = ", is_class_data['note_finale_calculation_rule_id'])
|
||
|
||
|
||
class_note_calcul_data = MYSY_GV.dbname['base_calcul_note_class_and_ue'].find_one({ 'valide':'1',
|
||
'locked':'0',
|
||
'_id':ObjectId(str(is_class_data['note_finale_calculation_rule_id']))})
|
||
|
||
|
||
if ("fonction_name" in class_note_calcul_data.keys() and class_note_calcul_data['fonction_name']):
|
||
|
||
print(" Traitement fonction niveau SESSION = ", class_note_calcul_data['fonction_name'])
|
||
|
||
possibles = globals().copy()
|
||
possibles.update(locals())
|
||
cron_function = possibles.get(class_note_calcul_data['fonction_name'])
|
||
|
||
if not cron_function:
|
||
mycommon.myprint(str(
|
||
inspect.stack()[0][3]) + " Fonction '" + str(class_note_calcul_data['job_name']) + "' est introuvable")
|
||
|
||
#field_list = ['token', 'class_id', 'session_id', 'tab_inscriptions_ids', ]
|
||
|
||
local_node = {}
|
||
local_node['token'] = str(diction['token'])
|
||
local_node['class_id'] = str(is_class_data['_id'])
|
||
local_node['session_id'] = str(diction['session_id'])
|
||
|
||
list_inscrit_id = ",".join(tab_inscrit_id)
|
||
local_node['tab_inscriptions_ids'] = str(list_inscrit_id)
|
||
|
||
local_con_status, local_con_retval = cron_function(local_node)
|
||
|
||
|
||
print(" ### class_note_calcul_data = ", class_note_calcul_data)
|
||
RetObject = []
|
||
|
||
|
||
return True, "Le calcul des notes est Ok"
|
||
|
||
except Exception as e:
|
||
exc_type, exc_obj, exc_tb = sys.exc_info()
|
||
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
||
return False, " Impossible de lancer le calcul des notes "
|
||
|