Ela_Back/base_class_calcul_note.py

1482 lines
63 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 liste ")
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)
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 liste ")
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 liste ")
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']
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 liste ")
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}}
"""
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]}
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 finales avec le classement
"""
def Get_List_Evaluation_Final_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']
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 liste ")
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}}
"""
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]}
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
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 "
"""
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 liste ")
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
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)
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)}},
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 liste ")
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 liste ")
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'])})
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'])})
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 = ", 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")
local_con_status, local_con_retval = cron_function()
print(" ### class_note_calcul_data = ", class_note_calcul_data)
RetObject = []
return True, "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 récupérer la liste des base_calcul_note_class_and_ue "