897 lines
41 KiB
Python
897 lines
41 KiB
Python
"""
|
|
Ce fichier gere les sessions de formation
|
|
"""
|
|
|
|
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
|
|
import csv
|
|
import pandas as pd
|
|
from pymongo import ReturnDocument
|
|
import GlobalVariable as MYSY_GV
|
|
from math import isnan
|
|
import GlobalVariable as MYSY_GV
|
|
from datetime import timedelta
|
|
from datetime import timedelta
|
|
|
|
|
|
"""
|
|
Fonction de creation et mise à jour d'une session de formation.
|
|
|
|
la clée est :
|
|
- formation_session_id,
|
|
- class_internal_url
|
|
|
|
/!\ : le champ 'source' definit la source de la creation de la session
|
|
"""
|
|
def Add_Update_SessionFormation(diction):
|
|
try:
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['token', 'date_debut', 'date_fin', 'nb_participant', 'formation_session_id', 'adresse',
|
|
'code_postal', 'ville', 'formateur', 'code_session',
|
|
'class_internal_url', 'session_status', 'date_debut_inscription', 'date_fin_inscription',
|
|
'attestation_certif', "distantiel", "presentiel", "prix_session", 'contenu_ftion', 'lms_class_code',
|
|
'session_ondemande', 'source']
|
|
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Creation partner account : Le champ '" + val + "' n'est pas autorisé, Creation partenaire annulée")
|
|
return False, "Impossible de créer/mettre à jour la session. Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'formation_session_id', 'class_internal_url','code_session']
|
|
|
|
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, "Impossible de créer/mettre à jour la session, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
mydata = {}
|
|
query_key = {}
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", my_token)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
|
|
|
|
code_session = ""
|
|
if ("code_session" in diction.keys()):
|
|
mydata['code_session'] = diction['code_session']
|
|
query_key['code_session'] = diction['code_session']
|
|
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
mydata['class_internal_url'] = diction['class_internal_url']
|
|
class_internal_url = diction['class_internal_url']
|
|
query_key['class_internal_url'] = diction['class_internal_url']
|
|
|
|
class_source = ""
|
|
if ("source" in diction.keys()):
|
|
if diction['source']:
|
|
class_source = diction['source']
|
|
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(my_token)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer les données du partenaire ")
|
|
return False, "Impossible de recuperer les données du partenaire "
|
|
|
|
formation_session_id = ""
|
|
if ("formation_session_id" in diction.keys()):
|
|
mydata['formation_session_id'] = diction['formation_session_id']
|
|
formation_session_id = diction['formation_session_id']
|
|
|
|
|
|
if ("date_debut" in diction.keys()):
|
|
mydata['date_debut'] = diction['date_debut']
|
|
|
|
|
|
if ("date_fin" in diction.keys()):
|
|
mydata['date_fin'] = diction['date_fin']
|
|
|
|
|
|
if ("distantiel" in diction.keys()):
|
|
mydata['distantiel'] = diction['distantiel']
|
|
|
|
|
|
if ("presentiel" in diction.keys()):
|
|
mydata['presentiel'] = diction['presentiel']
|
|
|
|
if ("lms_class_code" in diction.keys()):
|
|
mydata['lms_class_code'] = diction['lms_class_code']
|
|
|
|
if ("session_ondemande" in diction.keys()):
|
|
mydata['session_ondemande'] = diction['session_ondemande']
|
|
|
|
|
|
if ("nb_participant" in diction.keys()):
|
|
mydata['nb_participant'] = diction['nb_participant']
|
|
|
|
if ("prix_session" in diction.keys()):
|
|
mydata['prix_session'] = diction['prix_session']
|
|
|
|
|
|
if ("adresse" in diction.keys()):
|
|
if diction['adresse']:
|
|
mydata['adresse'] = diction['adresse']
|
|
else:
|
|
mydata['adresse'] = " "
|
|
|
|
|
|
if ("code_postal" in diction.keys()):
|
|
if diction['code_postal']:
|
|
mydata['code_postal'] = diction['code_postal']
|
|
else:
|
|
mydata['code_postal'] = ""
|
|
|
|
if ("ville" in diction.keys()):
|
|
if diction['ville']:
|
|
mydata['ville'] = diction['ville']
|
|
else:
|
|
mydata['ville'] = ""
|
|
|
|
if ("attestation_certif" in diction.keys()):
|
|
mydata['attestation_certif'] = diction['attestation_certif']
|
|
|
|
|
|
if ("session_status" in diction.keys()):
|
|
mydata['session_status'] = diction['session_status']
|
|
|
|
if ("date_debut_inscription" in diction.keys()):
|
|
mydata['date_debut_inscription'] = diction['date_debut_inscription']
|
|
|
|
if ("date_fin_inscription" in diction.keys()):
|
|
mydata['date_fin_inscription'] = diction['date_fin_inscription']
|
|
|
|
if ("formateur" in diction.keys()):
|
|
mydata['formateur'] = diction['formateur']
|
|
|
|
if ("contenu_ftion" in diction.keys()):
|
|
mydata['contenu_ftion'] = diction['contenu_ftion']
|
|
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
mydata['valide'] = "1"
|
|
|
|
# Controle de cohérence sur les dates
|
|
local_status = mycommon.CheckisDate(str(diction['date_debut'])[0:10])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Formation : "+str(formation_session_id)+" : Impossible de créer/mettre à jour la session de formation. La date de debut n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Formation : "+str(formation_session_id)+" : Impossible de créer/mettre à jour la session de formation. La date de debut n'est pas au format jj/mm/aaaa "
|
|
|
|
local_status = mycommon.CheckisDate(str(diction['date_fin'])[0:10])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " -Formation : "+str(formation_session_id)+" : Impossible de créer/mettre à jour la session de formation. La date de fin n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " -Formation : "+str(formation_session_id)+" : La date de fin n'est pas au format jj/mm/aaaa "
|
|
|
|
local_status = mycommon.CheckisDate(str(diction['date_debut_inscription'])[0:10])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Formation : "+str(formation_session_id)+" : Impossible de créer/mettre à jour la session de formation. La date_debut_inscription n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " -Formation : "+str(formation_session_id)+" : La date de début d'inscription n'est pas au format jj/mm/aaaa "
|
|
|
|
local_status = mycommon.CheckisDate(str(diction['date_fin_inscription'])[0:10])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " -Formation : "+str(formation_session_id)+" : La date de fin d'inscription n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Formation : "+str(formation_session_id)+" :La date de fin d'inscription n'est pas au format jj/mm/aaaa "
|
|
|
|
|
|
|
|
if (datetime.strptime(str(diction['date_debut'])[0:10], '%d/%m/%Y') > datetime.strptime(
|
|
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " Formation : "+str(formation_session_id)+" : La date debut " + str(
|
|
diction['date_debut']) +
|
|
" est postérieure à la date de fin " + str(diction['date_fin']) )
|
|
|
|
return False, " Formation : "+str(formation_session_id)+" : La date debut de formation " + str(diction['date_debut']) + \
|
|
" est postérieure à la date de fin de formation " + str(diction['date_fin']) + " "
|
|
|
|
|
|
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
|
|
str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " Formation : "+str(formation_session_id)+" : La date date_debut_inscription " + str(
|
|
diction['date_debut_inscription']) +
|
|
" est postérieure à la date de date_fin_inscription " + str(diction['date_fin_inscription']) )
|
|
|
|
return False, " Formation : "+str(formation_session_id)+" : La date_debut_inscription " + str(diction['date_debut_inscription']) + \
|
|
" est postérieure à la date_fin_inscription " + str(diction['date_fin_inscription']) + " "
|
|
|
|
|
|
|
|
# Verification : Date de debut inscription n'est pas > date de fin de formation
|
|
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
|
|
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -Formation : "+str(formation_session_id)+" : La date de debut d'inscription " + str( diction['date_debut_inscription']) + " est postérieure à la date de fin de formation " + str(diction['date_fin']))
|
|
|
|
return False, " Formation : "+str(formation_session_id)+" : La date de debut d'inscription " + str( diction['date_debut_inscription']) + " est postérieure à la date de fin de formation " + str(diction['date_fin'])+" "
|
|
|
|
# Verification : Date de fin inscription n'est pas > date de fin de formation
|
|
if (datetime.strptime(str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
|
|
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -Formation : "+str(formation_session_id)+" : La date de fin d'inscription " + str(
|
|
diction['date_fin_inscription'])[0:10] + " est postérieure à la date de fin de la formation " + str(
|
|
diction['date_fin'])[0:10])
|
|
|
|
return False, " Formation : "+str(formation_session_id)+" : La date de fin d'inscription " + str(
|
|
diction['date_fin_inscription'])[0:10] + " est postérieure à la date de fin de la formation " + str(
|
|
diction['date_fin'])[0:10] + " "
|
|
|
|
|
|
"""
|
|
mytoday = datetime.today().strftime("%d/%m/%Y")
|
|
if (datetime.strptime(str(diction['date_debut'])[0:10], '%d/%m/%Y') < datetime.strptime(str(mytoday).strip(), '%d/%m/%Y')) :
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer/mettre à jour la session de formation : La date de debut de sessions " + str(
|
|
diction['date_debut']) +" est antérieure à la date du jour ")
|
|
|
|
return False, " - Impossible de créer/mettre à jour la session de formation : La date de debut de sessions " + str(
|
|
diction['date_debut']) +" est antérieure à la date du jour "
|
|
|
|
"""
|
|
# Fin Controle de cohérence sur les dates
|
|
|
|
|
|
print(" ### query_key = ", query_key)
|
|
coll_name = MYSY_GV.dbname['session_formation']
|
|
ret_val = coll_name.find_one_and_update(
|
|
query_key,
|
|
{"$set": mydata},
|
|
upsert=True,
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val['_id'] is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Impossible d'ajouter/mettre à jour la session '"+str(diction['code_session'])+"' ")
|
|
return False, "Impossible d'ajouter/mettre à jour la session '"+str(diction['code_session'])+"' "
|
|
|
|
|
|
|
|
return True, " La session de formation à bien été crééé"
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de créer la session de formation"
|
|
|
|
|
|
"""
|
|
Fonction de recuperation d'une session de formation.
|
|
|
|
/!\ : il ne doit pas y avoir plus d'une session.
|
|
|
|
si le result > 1 une session, alors erreur d'inchorence d'info.
|
|
"""
|
|
|
|
def GetSessionFormation(diction):
|
|
try:
|
|
|
|
field_list = ['token', 'class_internal_url', 'formation_session_id', ]
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Le champ '" + val + "' n'est pas autorisé, Creation partenaire annulée")
|
|
return False, "de recuperer la liste des stagiaires . Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'class_internal_url', 'formation_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 liste ")
|
|
return False, "Impossible de recuperer la liste des stagiaires, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", mytoken)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer la liste des stagiaires, ")
|
|
return False, "Impossible de recuperer la liste des stagiaires, Les informations d'identification sont incorrectes "
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
formation_session_id = ""
|
|
if ("formation_session_id" in diction.keys()):
|
|
if diction['formation_session_id']:
|
|
formation_session_id = diction['formation_session_id']
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
myquery = {}
|
|
myquery['formation_session_id'] = formation_session_id
|
|
myquery['class_internal_url'] = class_internal_url
|
|
|
|
|
|
print(" ##### myquery = "+str(myquery))
|
|
RetObject = []
|
|
|
|
nb_val = 0
|
|
for retval in coll_session.find(myquery):
|
|
#print(" ##### retval = " + str(retval))
|
|
nb_val = nb_val + 1
|
|
RetObject.append(mycommon.JSONEncoder().encode(retval))
|
|
|
|
# Si le nombre de session trouvé est > 1 alors incohérence, retourner une message d'erreur
|
|
if( nb_val > 1 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - la query "+str(myquery)+" retourne "+str(nb_val)+" session. ceci n'est pas normal. il ne doit pas y avoir plus 1 session")
|
|
return False, " Les informations de la session "+str(formation_session_id)+" sont incohérentes. Merci de contacter le support"
|
|
|
|
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) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de recuperer la session de formation"
|
|
|
|
|
|
"""
|
|
Cette fonction recupere la liste de toutes les sessions de formation actives et valides
|
|
d'une formation données ET les sessions "on demande"
|
|
"""
|
|
def GetActiveSessionFormation_List(diction):
|
|
try:
|
|
|
|
field_list = ['class_internal_url']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Le champ '" + val + "' n'est pas autorisé, Creation partenaire annulée")
|
|
return False, " Impossible de recuperer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = [ 'class_internal_url', ]
|
|
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, "Impossible de recuperer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
myquery = {}
|
|
myquery['class_internal_url'] = class_internal_url
|
|
myquery['valide'] = "1"
|
|
myquery['session_status'] = "true"
|
|
|
|
|
|
RetObject = []
|
|
|
|
print(" ### myquery = ", myquery)
|
|
for retval in coll_session.find(myquery):
|
|
|
|
local_tmp = retval
|
|
## Verification des conditions supplementaires :
|
|
# en realité c'est parce que c'est chaud de le faire avec pymongo
|
|
tmp_debut_inscritp = str(local_tmp['date_debut_inscription']).strip().split(" ")
|
|
tmp_fin_inscritp = str(local_tmp['date_fin_inscription']).strip().split(" ")
|
|
|
|
debut_inscr = datetime.strptime(str(tmp_debut_inscritp[0]).strip(), '%d/%m/%Y')
|
|
fin_inscr = datetime.strptime(str(tmp_fin_inscritp[0]).strip(), '%d/%m/%Y')
|
|
|
|
#print(" #### date_debut_inscription = ", debut_inscr, " date_fin_inscription = ", fin_inscr, " NOW = ",datetime.now())
|
|
if(debut_inscr <= datetime.now() and fin_inscr >= datetime.now()):
|
|
RetObject.append(mycommon.JSONEncoder().encode(retval))
|
|
else:
|
|
if ("session_ondemande" in local_tmp.keys()):
|
|
if( str(local_tmp['session_ondemande']).strip() == "1"):
|
|
RetObject.append(mycommon.JSONEncoder().encode(retval))
|
|
|
|
|
|
|
|
#print("####RetObject = "+str(RetObject))
|
|
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) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de recuperer la liste des sessions de formation valides et actives."
|
|
|
|
"""
|
|
Cette fonction recuperer la liste des toutes les sessions
|
|
de formation valides pour une formation données.
|
|
Qu'elles soient cloturées ou pas."""
|
|
def GetAllValideSessionFormation_List(diction):
|
|
try:
|
|
|
|
field_list = ['class_internal_url']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Le champ '" + val + "' n'est pas autorisé, Creation partenaire annulée")
|
|
return False, " Impossible de recuperer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['class_internal_url', ]
|
|
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, "Impossible de recuperer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
myquery = {}
|
|
myquery['class_internal_url'] = class_internal_url
|
|
myquery['valide'] = "1"
|
|
|
|
#print(" ##### myquery = "+str(myquery))
|
|
RetObject = []
|
|
|
|
for retval in coll_session.find(myquery):
|
|
#print(" ##### retval = " + str(retval))
|
|
RetObject.append(mycommon.JSONEncoder().encode(retval))
|
|
|
|
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) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de recuperer la liste des sessions de formation valides et actives."
|
|
|
|
|
|
"""
|
|
Cette fonction crée les sessions de formation en mass
|
|
par exemple avec l'import d'un fichier csv
|
|
"""
|
|
def Add_Update_SessionFormation_mass(file=None, Folder=None, diction=None):
|
|
try:
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['token', 'class_internal_url']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas, Creation session annulée")
|
|
return False, " Le champ '" + val + "' n'existe pas, Creation session annulée "
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token', 'class_internal_url']
|
|
|
|
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, " La valeur '" + val + "' n'est pas presente dans liste"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", my_token)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
if (len(str(class_internal_url).strip()) <= 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " Le code de la formation est vide : Impossible d'importer la liste des sessions ")
|
|
return False, "Le code de la formation est vide. Impossible d'importer la liste des sessions"
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", my_token)
|
|
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(my_token)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - partner_recid KO : Impossible d'importer la liste des sessions ")
|
|
return False, "les information de connexion sont incorrectes. Impossible d'importer la liste des sessions"
|
|
|
|
status, saved_file = mycommon.Upload_Save_CSV_File(file, Folder)
|
|
if (status == False):
|
|
return False, "Impossible d'importer la liste des sessions, le nom du fichier est incorrect "
|
|
|
|
# " Lecture du fichier "
|
|
# print(" Lecture du fichier : "+saved_file)
|
|
nb_line = 0
|
|
|
|
df = pd.read_csv(saved_file, encoding='utf8', on_bad_lines='skip', sep=';', encoding_errors='ignore')
|
|
|
|
# Dictionnaire des champs utilisables
|
|
'''
|
|
# Verification que les noms des colonne sont bien corrects"
|
|
'''
|
|
field_list = ['date_debut', 'date_fin', 'nb_participant', 'adresse', 'code_postal', 'ville',
|
|
'session_status', 'date_debut_inscription', 'date_fin_inscription', 'attestation', 'formateur',
|
|
'code_session', "distanciel", "presentiel", "prix_session", 'contenu_ftion', 'lms_class_code', 'session_ondemande']
|
|
|
|
# Controle du nombre de lignes dans le fichier.
|
|
total_rows = len(df)
|
|
if (total_rows > MYSY_GV.MAX_PARTICIPANT_BY_CSV):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le fichier comporte plus de " + str(
|
|
MYSY_GV.MAX_PARTICIPANT_BY_CSV) + " lignes.")
|
|
return False, " Le fichier comporte plus de " + str(MYSY_GV.MAX_PARTICIPANT_BY_CSV) + " lignes."
|
|
|
|
# print(df.columns)
|
|
for val in df.columns:
|
|
if str(val).lower() not in field_list:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " : entete du fichier csv. '" + val + "' n'est pas acceptée")
|
|
return False, " Entete du fichier csv. '" + val + "' n'est pas acceptée"
|
|
|
|
|
|
# Verification des champs obligatoires dans le fichier
|
|
field_list_obligatoire_file = ['date_debut', 'date_fin', 'session_status', 'code_session']
|
|
|
|
for val in field_list_obligatoire_file:
|
|
if val not in df.columns:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " : Le champ '" + val + "' n'est pas présent dans le fichier. Il est obligatoire")
|
|
return False, " Le champ '" + val + "' n'est pas présent dans le fichier. Il est obligatoire "
|
|
|
|
|
|
# Recuperation des info de la formation.
|
|
formation_data = MYSY_GV.dbname['myclass'].find_one({'internal_url': str(class_internal_url)})
|
|
if (formation_data is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " La session de formation n'existe pas : Impossible d'importer la liste des participants ")
|
|
return False, "la session de formation n'existe pas. Impossible d'importer la liste des participants"
|
|
|
|
x = range(0, total_rows)
|
|
ignored_line = ""
|
|
nb_inserted_line = 0
|
|
|
|
for n in x:
|
|
mydata = {}
|
|
|
|
nb_inserted_line = nb_inserted_line + 1
|
|
# Si une ligne n'a aucune information obligatoire, alors on ignore la ligne
|
|
if (str(df['code_session'].values[n]) == "nan" or str(df['session_status'].values[n]) == "nan" or
|
|
str(df['date_debut'].values[n]) == "nan" or str(df['date_fin'].values[n]) == "nan" ):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][
|
|
3]) + " - La ligne " + str(n + 2) + " a été ignorée")
|
|
ignored_line = str(n + 2) + " , " + str(ignored_line)
|
|
|
|
nb_inserted_line = nb_inserted_line - 1
|
|
continue
|
|
|
|
|
|
|
|
mydata['date_debut'] = str(df['date_debut'].values[n]).strip().split(" ")[0]
|
|
local_status = mycommon.CheckisDate(mydata['date_debut'])
|
|
if(local_status is False ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer/mettre à jour la session de formation à ligne "+str(n+2)+"."
|
|
"La date debut n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Impossible de créer/mettre à jour la session de formation à ligne "+str(n+2)+". La date debut n'est pas au format jj/mm/aaaa "
|
|
|
|
mydata['date_fin'] = str(df['date_fin'].values[n]).strip().split(" ")[0]
|
|
local_status = mycommon.CheckisDate(mydata['date_fin'])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n+2) + "."
|
|
"La date date_fin n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
|
|
n+1) + ". La date fin n'est pas au format jj/mm/aaaa "
|
|
|
|
|
|
## Verification de la cohérence des dates. Date_du doit <= Date_au
|
|
if (datetime.strptime(str(mydata['date_debut']).strip(), '%d/%m/%Y') > datetime.strptime(
|
|
str(mydata['date_fin']).strip(), '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer la session de formation : La date debut " + str(mydata['date_debut']) +
|
|
" est postérieure à la date de fin " + str(mydata['date_fin']) + " pour la ligne "+str(n+2)+" ")
|
|
|
|
return False, " Impossible de créer la session de formation : La date debut " + str(mydata['date_debut']) +\
|
|
" est postérieure à la date de fin " + str(mydata['date_fin']) + " pour la ligne "+str(n+2)+" "
|
|
|
|
|
|
local_nb_participants = "0"
|
|
if ("nb_participant" in df.keys()):
|
|
if (str(df['nb_participant'].values[n])):
|
|
local_nb_participants = str(df['nb_participant'].values[n]).strip()
|
|
|
|
local_status, new_participants = mycommon.IsInt(local_nb_participants)
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'nb_participant' de ligne " + str(n+2) + " est incorrecte.")
|
|
return False, " Le champs nb_participant de ligne " + str(n+2) + " est incorrecte. "
|
|
|
|
mydata['nb_participant'] = str(new_participants)
|
|
|
|
prix_session = "0"
|
|
if ("prix_session" in df.keys()):
|
|
if (str(df['prix_session'].values[n])):
|
|
prix_session = str(df['prix_session'].values[n]).strip()
|
|
|
|
local_status, new_prix_session = mycommon.IsFloat(prix_session)
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'prix_session' de ligne " + str(n+2) + " est incorrecte.")
|
|
return False, " Le champs prix_session de ligne " + str(n+2) + " est incorrecte. "
|
|
|
|
mydata['prix_session'] = str(new_prix_session)
|
|
|
|
local_code_session = ""
|
|
if ("code_session" in df.keys()):
|
|
if (str(df['code_session'].values[n])):
|
|
local_code_session = str(df['code_session'].values[n]).strip()
|
|
mydata['code_session'] = local_code_session
|
|
|
|
local_adresse = ""
|
|
if ("adresse" in df.keys()):
|
|
if (str(df['adresse'].values[n])):
|
|
local_adresse = str(df['adresse'].values[n]).strip()
|
|
mydata['adresse'] = local_adresse
|
|
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in df.keys()):
|
|
if (str(df['lms_class_code'].values[n])):
|
|
lms_class_code = str(df['lms_class_code'].values[n]).strip()
|
|
mydata['lms_class_code'] = lms_class_code
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in df.keys()):
|
|
if (str(df['session_ondemande'].values[n])):
|
|
session_ondemande = str(df['session_ondemande'].values[n]).strip()
|
|
|
|
if( session_ondemande != "1" and session_ondemande != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'session_ondemande' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champs 'session_ondemande' de ligne " + str(n + 2) + " est incorrecte. Les valeurs acceptées sont '1' ou '0' ou vide"
|
|
|
|
|
|
mydata['session_ondemande'] = session_ondemande
|
|
|
|
|
|
|
|
local_code_postal = ""
|
|
if ("code_postal" in df.keys()):
|
|
if (str(df['code_postal'].values[n])):
|
|
local_code_postal = str(df['code_postal'].values[n]).strip()
|
|
mydata['code_postal'] = local_code_postal
|
|
|
|
distanciel = ""
|
|
if ("distanciel" in df.keys()):
|
|
if (str(df['distanciel'].values[n])):
|
|
distanciel = str(df['distanciel'].values[n]).strip()
|
|
if (distanciel != "1" and distanciel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champs 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte. Les valeurs acceptées sont '1' ou '0' ou vide"
|
|
|
|
|
|
|
|
mydata['distantiel'] = distanciel
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in df.keys()):
|
|
if (str(df['presentiel'].values[n])):
|
|
presentiel = str(df['presentiel'].values[n]).strip()
|
|
if (presentiel != "1" and presentiel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'presentiel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champs 'presentiel' de ligne " + str(
|
|
n + 2) + " est incorrecte. Les valeurs acceptées sont '1' ou '0' ou vide"
|
|
|
|
mydata['presentiel'] = presentiel
|
|
|
|
#mydata['code_postal'] = str(df['code_postal'].values[n]).strip()
|
|
|
|
local_ville = ""
|
|
if ("ville" in df.keys()):
|
|
if (str(df['ville'].values[n])):
|
|
local_ville = str(df['ville'].values[n]).strip()
|
|
mydata['ville'] = local_ville
|
|
|
|
contenu_ftion = ""
|
|
if ("contenu_ftion" in df.keys()):
|
|
if (str(df['contenu_ftion'].values[n])):
|
|
contenu_ftion = str(df['contenu_ftion'].values[n]).strip()
|
|
mydata['contenu_ftion'] = contenu_ftion
|
|
|
|
#mydata['ville'] = str(df['ville'].values[n]).strip()
|
|
|
|
local_attestation_certif = ""
|
|
if ("attestation" in df.keys()):
|
|
if (str(df['attestation'].values[n])):
|
|
local_attestation_certif = str(df['attestation'].values[n]).strip()
|
|
mydata['attestation_certif'] = local_attestation_certif
|
|
|
|
#mydata['attestation_certif'] = str(df['attestation'].values[n]).strip()
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in df.keys()):
|
|
if (str(df['formateur'].values[n])):
|
|
local_formateur = str(df['formateur'].values[n]).strip()
|
|
mydata['formateur'] = local_formateur
|
|
|
|
|
|
local_session = str(df['session_status'].values[n]).strip()
|
|
|
|
if( str(local_session) != "0" and str(local_session) != "1" and str(local_session) != "2"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champs 'session_status' de ligne " + str(n+2) + " est incorrecte. Les valeurs acceptées sont 0,1,2")
|
|
return False, " Le champs 'session_status' de ligne " + str(n+2) + " est incorrecte. Les valeurs acceptées sont 0,1,2"
|
|
|
|
if( str(local_session) == "1"):
|
|
mydata['session_status'] = str("true")
|
|
|
|
|
|
mydata['date_debut_inscription'] = str(df['date_debut_inscription'].values[n]).strip().split(" ")[0]
|
|
local_status = mycommon.CheckisDate(mydata['date_debut_inscription'])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n+2) + "."
|
|
"La date_debut_inscription n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
|
|
n+2) + ". La date_debut_inscription n'est pas au format jj/mm/aaaa "
|
|
|
|
|
|
mydata['date_fin_inscription'] = str(df['date_fin_inscription'].values[n]).strip().split(" ")[0]
|
|
local_status = mycommon.CheckisDate(mydata['date_fin_inscription'])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n+2) + "."
|
|
"La date_fin_inscription n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
|
|
n+1) + ". La date_fin_inscription n'est pas au format jj/mm/aaaa "
|
|
|
|
## Verification de la cohérence des dates. Date_du doit <= Date_au
|
|
if (datetime.strptime(str(mydata['date_debut_inscription']).strip(), '%d/%m/%Y') > datetime.strptime(
|
|
str(mydata['date_fin_inscription']).strip(), '%d/%m/%Y')):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de créer la session de formation : La date debut des inscriptions " + str(
|
|
mydata['date_debut_inscription']) +
|
|
" est postérieure à la date de fin des inscriptions " + str(mydata['date_fin_inscription']) + " pour la ligne "+str(n+2)+" ")
|
|
|
|
return False, " Impossible de créer la session de formation : La date de fin des inscriptions est antérieure à la date de début des inscriptions : Ligne "+str(n+2)+" "
|
|
|
|
mydata['token'] = str(my_token)
|
|
mydata['class_internal_url'] = str(class_internal_url)
|
|
|
|
print(" ### mydata ", mydata)
|
|
|
|
diction_for_session_id = {}
|
|
diction_for_session_id['date_du'] = str(mydata['date_debut']).split(" ")[0]
|
|
diction_for_session_id['date_au'] = str(mydata['date_fin']).split(" ")[0]
|
|
diction_for_session_id['code_postal'] = str(mydata['code_postal'] )
|
|
diction_for_session_id['adresse'] = str(mydata['adresse'])
|
|
|
|
|
|
|
|
mydata['formation_session_id'] = str(mydata['code_session'])
|
|
|
|
clean_dict = {k: mydata[k] for k in mydata if (str(mydata[k]) != "nan")}
|
|
|
|
print("#### Add_Update_SessionFormation_mass : clean_dict ", clean_dict)
|
|
status, retval = Add_Update_SessionFormation(clean_dict)
|
|
|
|
if (status is False):
|
|
return status, retval
|
|
|
|
|
|
print(str(total_rows) + " sessions ont été inserées")
|
|
|
|
message_ignored_line = ""
|
|
if (ignored_line):
|
|
message_ignored_line = " ATTENTION - Les lignes [" + str(
|
|
ignored_line) + "] ont été ignorées. car les toutes informations obligatoires ne sont pas fournies"
|
|
|
|
return True, str(nb_inserted_line) + " sessions ont été inserées / Mises à jour. " + str(message_ignored_line)
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible d'importer les sessions de formation en masse " |