Ela_Back/base_class_calcul_note.py

1749 lines
75 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""
FORMATION INITIALE :
A limage 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 ladministrateur 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',
})
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',
})
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',
})
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]}
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_comment" not in retval.keys()):
user['jury_comment'] = ""
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_comment" not in retval.keys()):
user['jury_comment'] = ""
if ("jury_validation" not in retval.keys()):
user['jury_validation'] = ""
if ("jury_validation_champ_technique" not in retval.keys()):
user['jury_validation_champ_technique'] = ""
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 "