2589 lines
123 KiB
Python
2589 lines
123 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.
|
|
|
|
|
|
/!\ : le champ 'source' definit la source de la creation de la session
|
|
|
|
si le champ 'session_id' est renseigné alors c'est une mise à jour.
|
|
"""
|
|
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', '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', 'session_id', 'session_etape', 'pays']
|
|
|
|
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', '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"
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
session_id = diction['session_id']
|
|
|
|
|
|
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 récupérer les données du partenaire ")
|
|
return False, "Impossible de récupérer les données du partenaire "
|
|
|
|
|
|
"""
|
|
update du 20/08/23 :
|
|
on ajouter un champs 'owner_recid' a la session.
|
|
en effet 2 partenaire peuvent avoir exactement la meme formation et les memes code session.
|
|
il faut arriver à les distinguer tout de meme
|
|
"""
|
|
mydata['partner_owner_recid'] = str(partner_recid)
|
|
|
|
|
|
if ("date_debut" in diction.keys()):
|
|
mydata['date_debut'] = diction['date_debut']
|
|
|
|
etape = "0"
|
|
if ("session_etape" in diction.keys()):
|
|
etape = str(diction['session_etape'])
|
|
etape = str(mycommon.tryInt(etape))
|
|
if(str(etape) not in MYSY_GV.SESSION_ETAPE):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - L'étape '"+str(diction['session_etape'])+"' n'est pas autorisée ")
|
|
return False, "L'étape '"+str(diction['session_etape'])+"' n'est pas autorisée "
|
|
|
|
mydata['session_etape'] = etape
|
|
|
|
|
|
if ("date_fin" in diction.keys()):
|
|
mydata['date_fin'] = diction['date_fin']
|
|
|
|
|
|
if ("distantiel" in diction.keys()):
|
|
mydata['distantiel'] = str(mycommon.tryInt(str(diction['distantiel'])))
|
|
|
|
|
|
if ("presentiel" in diction.keys()):
|
|
mydata['presentiel'] = str(mycommon.tryInt(str(diction['presentiel'])))
|
|
|
|
if ("session_ondemande" in diction.keys()):
|
|
mydata['session_ondemande'] = str(mycommon.tryInt(str(diction['session_ondemande'])))
|
|
|
|
|
|
if ("nb_participant" in diction.keys()):
|
|
nb_particants = str(mycommon.tryInt(str(diction['nb_participant'])))
|
|
if( nb_particants == "0" ):
|
|
nb_particants = "1"
|
|
mydata['nb_participant'] = str(mycommon.tryInt(str(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']:
|
|
if( "." in str(diction['code_postal']) ):
|
|
#/!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
mydata['code_postal'] = str(diction['code_postal']).split(".")[0]
|
|
elif( "." in str(diction['code_postal']) ):
|
|
#/!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
mydata['code_postal'] = str(diction['code_postal']).split(",")[0]
|
|
else:
|
|
mydata['code_postal'] = str(diction['code_postal'])
|
|
|
|
else:
|
|
mydata['code_postal'] = ""
|
|
|
|
if ("ville" in diction.keys()):
|
|
if diction['ville']:
|
|
mydata['ville'] = diction['ville']
|
|
else:
|
|
mydata['ville'] = ""
|
|
|
|
if ("pays" in diction.keys()):
|
|
if diction['pays']:
|
|
mydata['pays'] = diction['pays']
|
|
else:
|
|
mydata['pays'] = ""
|
|
|
|
if ("attestation_certif" in diction.keys()):
|
|
mydata['attestation_certif'] = diction['attestation_certif']
|
|
|
|
|
|
if ("session_status" in diction.keys()):
|
|
mydata['session_status'] = str(mycommon.tryInt(str(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(code_session)+" : 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(code_session)+" : 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(code_session)+" : 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(code_session)+" : La date de fin 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(code_session)+" : La date debut " + str(
|
|
diction['date_debut']) +
|
|
" est postérieure à la date de fin " + str(diction['date_fin']) )
|
|
|
|
return False, " Formation : "+str(code_session)+" : La date debut de formation " + str(diction['date_debut']) + \
|
|
" est postérieure à la date de fin de formation " + str(diction['date_fin']) + " "
|
|
|
|
# Verification de la cohérence des dates d'inscription si on a bien une date debut et une date de fin
|
|
if (str(diction['date_debut_inscription']).strip() != "" and str(
|
|
diction['date_fin_inscription']).strip() != ""):
|
|
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(
|
|
code_session) + " : 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(
|
|
code_session) + " : 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(
|
|
code_session) + " : La date de fin d'inscription n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, " - Formation : " + str(
|
|
code_session) + " :La date de fin d'inscription n'est pas au format jj/mm/aaaa "
|
|
|
|
|
|
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(code_session)+" : 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(code_session)+" : 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(code_session)+" : 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(code_session)+" : 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(code_session)+" : 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(code_session)+" : 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
|
|
|
|
|
|
"""
|
|
Verification avant ajout ou mise à jour
|
|
1 - si le champ 'session_id' est renseingé alors c'est une mise à jour.
|
|
Dans le cas d'une mise à jour,
|
|
je verifie s'il y a des inscription avec les code session actuellement en base, si oui, alors on refuse la modication
|
|
/!\ : DU CODE SESSION, mais on accepte les autres champs car le session est deja utilisé.
|
|
|
|
2 - Si le champ 'session_id' N'EST PAS renseingé alors c'est une creation.
|
|
On verifie que ce code session n'est pas deja utilisé pour cette formation.
|
|
.
|
|
|
|
"""
|
|
Warning_Message = ""
|
|
if(len(str(session_id)) > 0 ):
|
|
# Il s'agit d'une mise à jour
|
|
|
|
# Etape 1 : recuperation du code session en base
|
|
local_retval1 = MYSY_GV.dbname['session_formation'].find_one({'_id':ObjectId(str(session_id))})
|
|
if( local_retval1 is None or 'code_session' not in local_retval1.keys() or 'class_internal_url' not in local_retval1.keys() ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette session n'as pas de code session ")
|
|
return False, "Impossible de récupérer le code de la session (1) "
|
|
|
|
existing_session_code = local_retval1['code_session']
|
|
existing_class_internal_url = local_retval1['class_internal_url']
|
|
|
|
|
|
local_retval = MYSY_GV.dbname['inscription'].count_documents({'session_id':str(existing_session_code),
|
|
'class_internal_url':str(existing_class_internal_url)})
|
|
|
|
if( local_retval > 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette session a déjà des inscriptions. Le code de la session ne peut etre modifié. Les autres champs ont été correctement mis à jour")
|
|
mydata['code_session'] = existing_session_code # On remet le actuellement en base de données
|
|
Warning_Message = "Cette session a déjà des inscriptions. Le code de la session ne peut etre modifié. Les autres champs ont été correctement mis à jour"
|
|
|
|
|
|
print(" ###laaa mydata = ", mydata)
|
|
coll_name = MYSY_GV.dbname['session_formation']
|
|
ret_val = coll_name.find_one_and_update(
|
|
{'_id':ObjectId(str(session_id)), 'valide':'1'},
|
|
{"$set": mydata},
|
|
upsert=False,
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val is None or '_id' not in ret_val.keys()):
|
|
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']) + "' "
|
|
|
|
|
|
print("len(str(Warning_Message)) = ", len(str(Warning_Message)), )
|
|
if(len(str(Warning_Message)) > 2 ):
|
|
return True, str(Warning_Message)
|
|
|
|
return True, " La session de formation à bien été mise à jour"
|
|
|
|
if (len(str(session_id)) <= 0):
|
|
# La session n'existe pas, on fait une simple creation
|
|
|
|
#print(" ### mydata = ", mydata)
|
|
coll_name = MYSY_GV.dbname['session_formation']
|
|
ret_val = coll_name.insert_one(mydata)
|
|
|
|
|
|
|
|
if (ret_val is None or not hasattr(ret_val, 'inserted_id') ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Impossible d'ajouter la session '" + str(
|
|
diction['code_session']) + "' ")
|
|
return False, "Impossible d'ajouter la session '" + str(diction['code_session']) + "' "
|
|
|
|
return True, " La session de formation à bien été créée"
|
|
|
|
|
|
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 / mettre à jour 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', '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 récupérer 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', '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 récupérer 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 récupérer la liste des stagiaires, ")
|
|
return False, "Impossible de récupérer 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']
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
if(str(session_id).strip() == ""):
|
|
return True, []
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
|
|
myquery = [{'$match':{'_id':ObjectId(str(session_id)), 'class_internal_url':class_internal_url, 'partner_owner_recid':str(partner_recid)}},
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField': 'internal_url',
|
|
'pipeline': [{'$project': {'title': 1, 'lms_class_code':1}}],
|
|
'as': 'myclass'
|
|
}
|
|
}
|
|
]
|
|
|
|
print(" ##### myquery GetSessionFormation = "+str(myquery))
|
|
RetObject = []
|
|
|
|
nb_val = 0
|
|
for retval in coll_session.aggregate(myquery):
|
|
#print(" ##### retval = " + str(retval))
|
|
user = {}
|
|
user = retval
|
|
user['id'] = str(nb_val)
|
|
nb_val = nb_val + 1
|
|
title = ""
|
|
lms_class_code = ""
|
|
if ('myclass' in retval.keys() and len(retval['myclass']) > 0):
|
|
|
|
if( "title" in retval['myclass'][0].keys()):
|
|
title = retval['myclass'][0]['title']
|
|
|
|
if ("lms_class_code" in retval['myclass'][0].keys()):
|
|
lms_class_code = retval['myclass'][0]['lms_class_code']
|
|
|
|
user['title'] = title
|
|
user['lms_class_code'] = lms_class_code
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(user))
|
|
|
|
|
|
|
|
# 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(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 récupérer 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"
|
|
|
|
/!\ : Cette fonction est utilisée en mode non connecté et en mode non connecté.
|
|
Donc faire attention au controle de la connexion
|
|
"""
|
|
def GetActiveSessionFormation_List(diction):
|
|
try:
|
|
|
|
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'est pas autorisé, Creation partenaire annulée")
|
|
return False, " Impossible de récupérer 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 récupérer la liste des session de formation"
|
|
|
|
# Le controle de token n'est effectué que une valeur est fournie dans le token
|
|
if( 'token' in diction.keys() and len(str(diction['token'])) > 0) :
|
|
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
|
if (local_status is not True):
|
|
return local_status, my_partner
|
|
|
|
|
|
# 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'] = "1"
|
|
|
|
|
|
RetObject = []
|
|
|
|
#print(" ### GetActiveSessionFormation_List 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("#### GetActiveSessionFormation_List 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 récupérer la liste des sessions de formation valides et actives."
|
|
|
|
"""
|
|
Cette fonction récupérer 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 = ['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'est pas autorisé, Creation partenaire annulée")
|
|
return False, " Impossible de récupérer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
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, "Impossible de récupérer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
|
if (local_status is not True):
|
|
return local_status, my_partner
|
|
|
|
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['partner_owner_recid'] = str(my_partner['recid'])
|
|
myquery['valide'] = "1"
|
|
|
|
print(" ##### myquery tt = "+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 récupérer la liste des sessions de formation valides et actives."
|
|
|
|
|
|
"""
|
|
Cette fonction recupere toutes les sessions de formation d'un partenaire
|
|
"""
|
|
def GetAllValideSessionPartner_List(diction):
|
|
try:
|
|
|
|
field_list = ['token']
|
|
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 récupérer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste 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, "Impossible de récupérer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
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
|
|
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
|
|
filt_class_partner_recid = {'partner_owner_recid': str(my_partner['recid'])}
|
|
|
|
query = [{'$match': {'partner_owner_recid':str(my_partner['recid'])}},
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField':'internal_url',
|
|
'pipeline': [{'$match': filt_class_partner_recid}, {'$project': {'title': 1, 'domaine': 1,
|
|
'duration': 1, 'duration_unit': 1, 'external_code':1}}],
|
|
'as': 'myclass_collection'
|
|
}
|
|
}
|
|
]
|
|
print("#### query = ", query)
|
|
RetObject = []
|
|
cpt = 1
|
|
for retVal in MYSY_GV.dbname['session_formation'].aggregate(query):
|
|
if ('myclass_collection' in retVal.keys() and len(retVal['myclass_collection']) > 0):
|
|
val = {}
|
|
val['id'] = str(cpt)
|
|
cpt = cpt + 1
|
|
val['class_internal_url'] = retVal['class_internal_url']
|
|
val['_id'] = retVal['_id']
|
|
val['code_session'] = retVal['code_session']
|
|
|
|
if( "session_etape" in retVal.keys()):
|
|
val['session_etape'] = retVal['session_etape']
|
|
else:
|
|
val['session_etape'] = "0"
|
|
|
|
if( "session_status" in retVal.keys()):
|
|
val['session_status'] = retVal['session_status']
|
|
else:
|
|
val['session_status'] = "0"
|
|
|
|
|
|
val['date_debut'] = retVal['date_debut'][0:10]
|
|
val['date_fin'] = retVal['date_fin'][0:10]
|
|
val['date_debut_inscription'] = retVal['date_debut_inscription'][0:10]
|
|
val['date_fin_inscription'] = retVal['date_fin_inscription'][0:10]
|
|
|
|
val['distantiel'] = retVal['distantiel']
|
|
val['formateur'] = retVal['formateur']
|
|
|
|
nb_participant = "1"
|
|
if( "nb_participant" in retVal.keys()):
|
|
nb_participant = retVal['nb_participant']
|
|
|
|
val['nb_participant'] = nb_participant
|
|
|
|
|
|
val['presentiel'] = retVal['presentiel']
|
|
val['prix_session'] = retVal['prix_session']
|
|
|
|
val['title'] = retVal['myclass_collection'][0]['title']
|
|
val['domaine'] = retVal['myclass_collection'][0]['domaine']
|
|
val['class_external_code'] = retVal['myclass_collection'][0]['external_code']
|
|
|
|
if( str(retVal['myclass_collection'][0]['duration_unit']) == "heure"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration'])+" h"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "jour"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " j"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "semaine"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " s"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "mois"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " m"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "annee"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " a"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "user_rythme"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " u"
|
|
|
|
else :
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " ?"
|
|
|
|
val['duration'] = str(retVal['myclass_collection'][0]['duration'])
|
|
val['duration_unit'] = retVal['myclass_collection'][0]['duration_unit']
|
|
|
|
## Recuperation du nombre d'inscrits
|
|
Count_Inscrit = MYSY_GV.dbname['inscription'].count_documents({'session_id':str(retVal['code_session']), 'class_internal_url':str(retVal['class_internal_url']),
|
|
'status':"1"})
|
|
val['nb_inscrit'] = str(Count_Inscrit)
|
|
|
|
## Recuperation du nombre de preinscrits
|
|
Count_Preinscrit = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(retVal['code_session']), 'class_internal_url': str(retVal['class_internal_url']),
|
|
'status': "0"})
|
|
|
|
val['nb_preinscrit'] = str(Count_Preinscrit)
|
|
|
|
taux_remplissage = "0"
|
|
if( str(nb_participant) != "0" and str(nb_participant).strip() != ""):
|
|
taux_remplissage = round(int(mycommon.tryInt(Count_Inscrit)) / int(mycommon.tryInt(nb_participant)), 2)
|
|
|
|
val['taux_remplissage'] = str(taux_remplissage)
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(val))
|
|
|
|
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 récupérer la liste des sessions de formation valides et actives."
|
|
|
|
|
|
"""
|
|
Recuperation de la liste avec des filter du type like
|
|
"""
|
|
def GetAllValideSessionPartner_List_filter_like(diction):
|
|
try:
|
|
|
|
field_list = ['token','class_title', 'code_session']
|
|
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 récupérer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste 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, "Impossible de récupérer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
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_class_title = {}
|
|
if ("class_title" in diction.keys()):
|
|
filt_class_title = {'title': {'$regex': str(diction['class_title']),"$options": "i"}}
|
|
|
|
|
|
filt_code_session = {}
|
|
if ("code_session" in diction.keys()):
|
|
filt_code_session = {'code_session': {'$regex': str(diction['code_session']), "$options": "i"}}
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
|
|
query = [ {'$match':{ '$and' : [ filt_code_session,{'partner_owner_recid':str(my_partner['recid'])}] }} ,
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField': 'internal_url',
|
|
'pipeline': [{'$match': { '$and' : [ filt_class_title, {'partner_owner_recid':str(my_partner['recid'])} ]} }, {'$project': {'title': 1, 'domaine':1,
|
|
'duration':1, 'duration_unit':1, 'external_code':1}}],
|
|
'as': 'myclass_collection'
|
|
}
|
|
}
|
|
]
|
|
|
|
print("#### GetAllValideSessionPartner_List_filter_likequery = ", query)
|
|
RetObject = []
|
|
cpt = 1
|
|
for retVal in MYSY_GV.dbname['session_formation'].aggregate(query):
|
|
if( 'myclass_collection' in retVal.keys() and len(retVal['myclass_collection']) > 0 ):
|
|
val = {}
|
|
val['id'] = str(cpt)
|
|
cpt = cpt + 1
|
|
val['_id'] = retVal['_id']
|
|
val['class_internal_url'] = retVal['class_internal_url']
|
|
val['code_session'] = retVal['code_session']
|
|
if( "session_etape" in retVal.keys()):
|
|
val['session_etape'] = retVal['session_etape']
|
|
else:
|
|
val['session_etape'] = "0"
|
|
|
|
if( "session_status" in retVal.keys()):
|
|
val['session_status'] = retVal['session_status']
|
|
else:
|
|
val['session_status'] = "0"
|
|
|
|
val['date_debut'] = retVal['date_debut'][0:10]
|
|
val['date_fin'] = retVal['date_fin'][0:10]
|
|
val['date_debut_inscription'] = retVal['date_debut_inscription'][0:10]
|
|
val['date_fin_inscription'] = retVal['date_fin_inscription'][0:10]
|
|
|
|
if ("distantiel" in retVal.keys()):
|
|
val['distantiel'] = retVal['distantiel']
|
|
else:
|
|
val['distantiel'] = "0"
|
|
|
|
if ("formateur" in retVal.keys()):
|
|
val['formateur'] = retVal['formateur']
|
|
else:
|
|
val['formateur'] = ""
|
|
|
|
nb_participant = "1"
|
|
if ("nb_participant" in retVal.keys()):
|
|
nb_participant = retVal['nb_participant']
|
|
|
|
val['nb_participant'] = nb_participant
|
|
|
|
if ("presentiel" in retVal.keys()):
|
|
val['presentiel'] = retVal['presentiel']
|
|
else:
|
|
val['presentiel'] = "0"
|
|
|
|
if ("prix_session" in retVal.keys()):
|
|
val['prix_session'] = retVal['prix_session']
|
|
else:
|
|
val['prix_session'] = "0"
|
|
|
|
val['title'] = retVal['myclass_collection'][0]['title']
|
|
val['domaine'] = retVal['myclass_collection'][0]['domaine']
|
|
val['class_external_code'] = retVal['myclass_collection'][0]['external_code']
|
|
|
|
if (str(retVal['myclass_collection'][0]['duration_unit']) == "heure"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " h"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "jour"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " j"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "semaine"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " s"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "mois"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " m"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "annee"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " a"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "user_rythme"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " u"
|
|
|
|
else:
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " ?"
|
|
|
|
val['duration'] = retVal['myclass_collection'][0]['duration']
|
|
val['duration_unit'] = retVal['myclass_collection'][0]['duration_unit']
|
|
|
|
## Recuperation du nombre d'inscrits
|
|
Count_Inscrit = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(retVal['code_session']), 'class_internal_url': str(retVal['class_internal_url']),
|
|
'status': "1"})
|
|
val['nb_inscrit'] = str(Count_Inscrit)
|
|
|
|
## Recuperation du nombre de preinscrits
|
|
Count_Preinscrit = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(retVal['code_session']), 'class_internal_url': str(retVal['class_internal_url']),
|
|
'status': "0"})
|
|
|
|
val['nb_preinscrit'] = str(Count_Preinscrit)
|
|
|
|
taux_remplissage = "0"
|
|
if (str(nb_participant) != "0"):
|
|
taux_remplissage = round(int(mycommon.tryInt(Count_Inscrit)) / int(mycommon.tryInt(nb_participant)),
|
|
2)
|
|
|
|
val['taux_remplissage'] = str(taux_remplissage)
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(val))
|
|
|
|
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 récupérer la liste des sessions de formation valides et actives."
|
|
|
|
|
|
"""
|
|
Recuperation de la liste sans filtre
|
|
"""
|
|
def GetAllValideSessionPartner_List_no_filter(diction):
|
|
try:
|
|
|
|
field_list = ['token','class_title', 'code_session']
|
|
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 récupérer la liste des session de formation"
|
|
|
|
"""
|
|
Verification de la liste 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, "Impossible de récupérer la liste des session de formation"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
|
|
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
|
|
|
|
|
|
coll_session = MYSY_GV.dbname['session_formation']
|
|
|
|
query = [{'$match':{'partner_owner_recid': str(my_partner['recid'])} },
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField': 'internal_url',
|
|
'pipeline': [{'$match': {'partner_owner_recid': str(my_partner['recid'])} },
|
|
{'$project': {'title': 1, 'domaine': 1,
|
|
'duration': 1, 'duration_unit': 1, 'external_code':1}}],
|
|
'as': 'myclass_collection'
|
|
}
|
|
}
|
|
]
|
|
|
|
print("#### GetAllValideSessionPartner_List_filter_likequery = ", query)
|
|
RetObject = []
|
|
cpt = 1
|
|
for retVal in MYSY_GV.dbname['session_formation'].aggregate(query):
|
|
if( 'myclass_collection' in retVal.keys() and len(retVal['myclass_collection']) > 0 ):
|
|
val = {}
|
|
val['id'] = str(cpt)
|
|
cpt = cpt + 1
|
|
val['_id'] = retVal['_id']
|
|
val['class_internal_url'] = retVal['class_internal_url']
|
|
val['code_session'] = retVal['code_session']
|
|
if( "session_etape" in retVal.keys()):
|
|
val['session_etape'] = retVal['session_etape']
|
|
else:
|
|
val['session_etape'] = "0"
|
|
|
|
if( "session_status" in retVal.keys()):
|
|
val['session_status'] = retVal['session_status']
|
|
else:
|
|
val['session_status'] = "0"
|
|
|
|
val['date_debut'] = retVal['date_debut'][0:10]
|
|
val['date_fin'] = retVal['date_fin'][0:10]
|
|
val['date_debut_inscription'] = retVal['date_debut_inscription'][0:10]
|
|
val['date_fin_inscription'] = retVal['date_fin_inscription'][0:10]
|
|
|
|
if ("distantiel" in retVal.keys()):
|
|
val['distantiel'] = retVal['distantiel']
|
|
else:
|
|
val['distantiel'] = "0"
|
|
|
|
if ("formateur" in retVal.keys()):
|
|
val['formateur'] = retVal['formateur']
|
|
else:
|
|
val['formateur'] = ""
|
|
|
|
nb_participant = "1"
|
|
if ("nb_participant" in retVal.keys()):
|
|
nb_participant = retVal['nb_participant']
|
|
|
|
val['nb_participant'] = nb_participant
|
|
|
|
if ("presentiel" in retVal.keys()):
|
|
val['presentiel'] = retVal['presentiel']
|
|
else:
|
|
val['presentiel'] = "0"
|
|
|
|
if ("prix_session" in retVal.keys()):
|
|
val['prix_session'] = retVal['prix_session']
|
|
else:
|
|
val['prix_session'] = "0"
|
|
|
|
val['title'] = retVal['myclass_collection'][0]['title']
|
|
val['domaine'] = retVal['myclass_collection'][0]['domaine']
|
|
val['class_external_code'] = retVal['myclass_collection'][0]['external_code']
|
|
|
|
if (str(retVal['myclass_collection'][0]['duration_unit']) == "heure"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " h"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "jour"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " j"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "semaine"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " s"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "mois"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " m"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "annee"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " a"
|
|
|
|
elif (str(retVal['myclass_collection'][0]['duration_unit']) == "user_rythme"):
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " u"
|
|
|
|
else:
|
|
val['duration_concat'] = str(retVal['myclass_collection'][0]['duration']) + " ?"
|
|
|
|
val['duration'] = retVal['myclass_collection'][0]['duration']
|
|
val['duration_unit'] = retVal['myclass_collection'][0]['duration_unit']
|
|
|
|
## Recuperation du nombre d'inscrits
|
|
Count_Inscrit = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(retVal['code_session']), 'class_internal_url': str(retVal['class_internal_url']),
|
|
'status': "1"})
|
|
val['nb_inscrit'] = str(Count_Inscrit)
|
|
|
|
## Recuperation du nombre de preinscrits
|
|
Count_Preinscrit = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(retVal['code_session']), 'class_internal_url': str(retVal['class_internal_url']),
|
|
'status': "0"})
|
|
|
|
val['nb_preinscrit'] = str(Count_Preinscrit)
|
|
|
|
taux_remplissage = "0"
|
|
if (str(nb_participant) != "0"):
|
|
taux_remplissage = round(int(mycommon.tryInt(Count_Inscrit)) / int(mycommon.tryInt(nb_participant)),
|
|
2)
|
|
|
|
val['taux_remplissage'] = str(taux_remplissage)
|
|
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(val))
|
|
|
|
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 récupérer 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"
|
|
|
|
|
|
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
|
|
|
|
""""
|
|
update du 31/08/23 : Controle de l'integrité du fichier avant import
|
|
"""
|
|
local_controle_status, local_controle_message = Controle_Add_Update_SessionFormation_mass(saved_file,
|
|
Folder,
|
|
diction)
|
|
|
|
if (local_controle_status is False):
|
|
return local_controle_status, local_controle_message
|
|
|
|
print(" #### local_controle_message = ", local_controle_message)
|
|
|
|
|
|
df = pd.read_csv(saved_file, encoding='utf8', on_bad_lines='skip', sep=';', encoding_errors='ignore')
|
|
df = df.fillna('')
|
|
# 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', 'pays',
|
|
'session_status', 'date_debut_inscription', 'date_fin_inscription', 'attestation', 'formateur',
|
|
'code_session', "distanciel", "presentiel", "prix_session", 'contenu_ftion', 'lms_class_code',
|
|
'session_ondemande', 'session_etape', 'formation_code_externe']
|
|
|
|
# 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. La Colonne '" + 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', 'formation_code_externe']
|
|
|
|
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), 'valide':'1', 'locked':'0'})
|
|
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
|
|
|
|
external_code = ""
|
|
if ("formation_code_externe" in df.keys()):
|
|
if (str(df['formation_code_externe'].values[n])):
|
|
external_code = str(df['formation_code_externe'].values[n]).strip()
|
|
|
|
# On verifie l'existance de l'external code pour ce une des formations de ce partner
|
|
count_class = MYSY_GV.dbname['myclass'].count_documents(
|
|
{'external_code': str(external_code), 'valide': '1',
|
|
'locked': '0', 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if (count_class < 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Ligne " + str( n + 2) + " : Le code_externe n'est pas valide.")
|
|
return False, " Ligne " + str( n + 2) + " : Le code_externe n'est pas valide."
|
|
|
|
if (count_class > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Erreur : Ligne " + str(n + 2) + " : Le code_externe corresponds à plus d'une formation.")
|
|
return False, " Erreur : Ligne " + str(n + 2) + " : Le code_externe corresponds à plus d'une formation."
|
|
|
|
class_date = MYSY_GV.dbname['myclass'].find_one(
|
|
{'external_code': str(external_code), 'valide': '1',
|
|
'locked': '0', 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if( class_date['external_code'] != formation_data['external_code']):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Erreur : Ligne " + str( n + 2) + " : Le code externe dans le fichier excel ne correpond pas au code externe de la formation sur la quelle vous etes")
|
|
return False, " Erreur : Ligne " + str( n + 2) + " : Le code externe dans le fichier excel ne correpond pas au code externe de la formation sur la quelle vous etes"
|
|
|
|
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 = "1"
|
|
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 champ 'nb_participant' de ligne " + str(n+2) + " est incorrecte.")
|
|
return False, " Le champ 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 champ 'prix_session' de ligne " + str(n+2) + " est incorrecte.")
|
|
return False, " Le champ 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 = "0"
|
|
if ("session_ondemande" in df.keys()):
|
|
if (str(df['session_ondemande'].values[n])):
|
|
session_ondemande = str(mycommon.tryInt(str(df['session_ondemande'].values[n]).strip()))
|
|
|
|
if( session_ondemande != "1" and session_ondemande != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'session_ondemande' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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()
|
|
if ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(".")[0]
|
|
elif ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(",")[0]
|
|
else:
|
|
local_code_postal = str(local_code_postal)
|
|
|
|
|
|
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()
|
|
distanciel = str(mycommon.tryInt(distanciel))
|
|
if (distanciel != "1" and distanciel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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()
|
|
presentiel = str(mycommon.tryInt(presentiel))
|
|
|
|
if (presentiel != "1" and presentiel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'presentiel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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
|
|
|
|
local_pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
local_pays = str(df['pays'].values[n]).strip()
|
|
mydata['pays'] = local_pays
|
|
|
|
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
|
|
|
|
session_status = ""
|
|
if ("session_status" in df.keys()):
|
|
if (str(df['session_status'].values[n])):
|
|
session_status = str(df['session_status'].values[n]).strip()
|
|
session_status = str(mycommon.tryInt(session_status))
|
|
mydata['session_status'] = session_status
|
|
|
|
|
|
session_etape = ""
|
|
if ("session_etape" in df.keys()):
|
|
if (str(df['session_etape'].values[n])):
|
|
session_etape = str(df['session_etape'].values[n]).strip()
|
|
session_etape = str(mycommon.tryInt(session_etape))
|
|
mydata['session_etape'] = session_etape
|
|
|
|
"""
|
|
Update du 11/08/23 :
|
|
- le status va etre geré en 0 (desactivé) et 1 (activé)
|
|
- mise en commentaire du code ci-dessous
|
|
|
|
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 champ 'session_status' de ligne " + str(n+2) + " est incorrecte. Les valeurs acceptées sont 0,1,2")
|
|
return False, " Le champ '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]
|
|
if( str(mydata['date_debut_inscription']).strip() != ""):
|
|
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]
|
|
if (str(mydata['date_fin_inscription']).strip() != ""):
|
|
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_debut_inscription doit <= date_fin_inscription
|
|
if( str(mydata['date_debut_inscription']).strip() != "" and str(mydata['date_fin_inscription']).strip() != "" ):
|
|
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'])
|
|
|
|
"""
|
|
Verifier si la session existe deja en base, si c'est le cas récupérer le '_id'
|
|
la clé pour verifier l'existance d'une session est :
|
|
- code_session
|
|
- class_internal_url
|
|
- partner_owner_recid
|
|
"""
|
|
|
|
existing_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'code_session': str(local_code_session), 'class_internal_url': str(class_internal_url),
|
|
'partner_owner_recid': str(partner_recid), 'valide': '1'})
|
|
|
|
if (existing_session is not None):
|
|
if ('_id' in existing_session.keys()):
|
|
mydata['session_id'] = existing_session['_id']
|
|
|
|
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 "
|
|
|
|
"""
|
|
Cette fonction permet de faire des controles du fichier excel avant l'import.
|
|
cela permet d'eviter des imports partiels.
|
|
c'est soit le fichier est TOUT bon ou pas.
|
|
"""
|
|
def Controle_Add_Update_SessionFormation_mass(saved_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"
|
|
|
|
|
|
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"
|
|
|
|
nb_line = 0
|
|
|
|
df = pd.read_csv(saved_file, encoding='utf8', on_bad_lines='skip', sep=';', encoding_errors='ignore')
|
|
df = df.fillna('')
|
|
# 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', 'pays',
|
|
'session_status', 'date_debut_inscription', 'date_fin_inscription', 'attestation', 'formateur',
|
|
'code_session', "distanciel", "presentiel", "prix_session", 'contenu_ftion', 'lms_class_code',
|
|
'session_ondemande', 'session_etape', 'formation_code_externe']
|
|
|
|
# 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. La Colonne '" + 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',
|
|
'formation_code_externe']
|
|
|
|
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), 'valide': '1', 'locked': '0'})
|
|
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
|
|
|
|
external_code = ""
|
|
if ("formation_code_externe" in df.keys()):
|
|
if (str(df['formation_code_externe'].values[n])):
|
|
external_code = str(df['formation_code_externe'].values[n]).strip()
|
|
|
|
# On verifie l'existance de l'external code pour ce une des formations de ce partner
|
|
count_class = MYSY_GV.dbname['myclass'].count_documents(
|
|
{'external_code': str(external_code), 'valide': '1',
|
|
'locked': '0', 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if (count_class < 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Ligne " + str(
|
|
n + 2) + " : Le code_externe n'est pas valide.")
|
|
return False, " Ligne " + str(n + 2) + " : Le code_externe n'est pas valide."
|
|
|
|
if (count_class > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Erreur : Ligne " + str(
|
|
n + 2) + " : Le code_externe corresponds à plus d'une formation.")
|
|
return False, " Erreur : Ligne " + str(
|
|
n + 2) + " : Le code_externe corresponds à plus d'une formation."
|
|
|
|
class_date = MYSY_GV.dbname['myclass'].find_one(
|
|
{'external_code': str(external_code), 'valide': '1',
|
|
'locked': '0', 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if (class_date['external_code'] != formation_data['external_code']):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Erreur : Ligne " + str(
|
|
n + 2) + " : Le code externe dans le fichier excel ne correpond pas au code externe de la formation sur la quelle vous etes")
|
|
return False, " Erreur : Ligne " + str(
|
|
n + 2) + " : Le code externe dans le fichier excel ne correpond pas au code externe de la formation sur la quelle vous etes"
|
|
|
|
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 = "1"
|
|
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 champ 'nb_participant' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ nb_participant de ligne " + str(n + 2) + " est incorrecte. Un nombre Entier Positif doit être fourni "
|
|
|
|
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 champ 'prix_session' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ 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
|
|
|
|
|
|
session_ondemande = "0"
|
|
if ("session_ondemande" in df.keys()):
|
|
if (str(df['session_ondemande'].values[n])):
|
|
session_ondemande = str(df['session_ondemande'].values[n]).strip()
|
|
session_ondemande = str(mycommon.tryInt(str(session_ondemande)))
|
|
|
|
if (session_ondemande != "1" and session_ondemande != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'session_ondemande' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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()
|
|
|
|
if ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(".")[0]
|
|
elif ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(",")[0]
|
|
else:
|
|
local_code_postal = str(local_code_postal)
|
|
|
|
|
|
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()
|
|
distanciel = str(mycommon.tryInt(distanciel))
|
|
|
|
if (distanciel != "1" and distanciel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte. La valeur fournie est "+str(distanciel) )
|
|
return False, " Le champ 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte. Les valeurs acceptées sont '1' ou '0'. La valeur fournie est "+str(distanciel)
|
|
|
|
mydata['distantiel'] = distanciel
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in df.keys()):
|
|
if (str(df['presentiel'].values[n])):
|
|
presentiel = str(df['presentiel'].values[n]).strip()
|
|
presentiel = str(mycommon.tryInt(presentiel))
|
|
|
|
if (presentiel != "1" and presentiel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'presentiel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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
|
|
|
|
local_pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
local_pays = str(df['pays'].values[n]).strip()
|
|
mydata['pays'] = local_pays
|
|
|
|
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
|
|
|
|
session_status = ""
|
|
if ("session_status" in df.keys()):
|
|
if (str(df['session_status'].values[n])):
|
|
session_status = str(df['session_status'].values[n]).strip()
|
|
mydata['session_status'] = session_status
|
|
|
|
session_etape = ""
|
|
if ("session_etape" in df.keys()):
|
|
if (str(df['session_etape'].values[n])):
|
|
session_etape = str(df['session_etape'].values[n]).strip()
|
|
mydata['session_etape'] = session_etape
|
|
|
|
"""
|
|
Update du 11/08/23 :
|
|
- le status va etre geré en 0 (desactivé) et 1 (activé)
|
|
- mise en commentaire du code ci-dessous
|
|
|
|
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 champ 'session_status' de ligne " + str(n+2) + " est incorrecte. Les valeurs acceptées sont 0,1,2")
|
|
return False, " Le champ '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'])
|
|
|
|
|
|
|
|
|
|
|
|
return True, str(total_rows)+" sessions dans le fichier"
|
|
|
|
|
|
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 controler le fichier des sessions de formation en masse "
|
|
|
|
|
|
"""
|
|
import des sessions de formation en masse
|
|
pour plusieurs formation.
|
|
|
|
Cela veut dire qu'on fourni 'external_code' pour chaque ligne du fichier excel, mais on ne fourni pas de 'internal_url'
|
|
"""
|
|
|
|
|
|
def Add_Update_SessionFormation_mass_for_many_class(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', ]
|
|
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', ]
|
|
|
|
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"
|
|
|
|
# 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')
|
|
df = df.fillna('')
|
|
# 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', 'session_etape', 'formation_code_externe']
|
|
|
|
# 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. La Colonne '" + 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', 'formation_code_externe']
|
|
|
|
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 "
|
|
|
|
|
|
|
|
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 = "1"
|
|
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 champ 'nb_participant' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ 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 champ 'prix_session' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ prix_session de ligne " + str(n + 2) + " est incorrecte. "
|
|
|
|
mydata['prix_session'] = str(new_prix_session)
|
|
|
|
class_internal_url = ""
|
|
|
|
external_code = ""
|
|
if ("formation_code_externe" in df.keys()):
|
|
if (str(df['formation_code_externe'].values[n])):
|
|
external_code = str(df['formation_code_externe'].values[n]).strip()
|
|
|
|
#On verifie l'existance de l'external code pour ce une des formations de ce partner
|
|
count_class = MYSY_GV.dbname['myclass'].count_documents({'external_code':str(external_code), 'valide':'1',
|
|
'locked':'0', 'partner_owner_recid':str(partner_recid)})
|
|
|
|
|
|
if( count_class != 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'code_externe' de ligne " + str(
|
|
n + 2) + " ne correspond pas à une formation valide.")
|
|
return False, " Le champ 'code_externe' de ligne " + str(
|
|
n + 2) + " ne correspond pas à une formation valide."
|
|
|
|
class_from_external_code = MYSY_GV.dbname['myclass'].find({'external_code':str(external_code), 'valide':'1',
|
|
'locked':'0', 'partner_owner_recid':str(partner_recid)})
|
|
|
|
if(class_from_external_code is None ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'code_exyer' de ligne " + str(
|
|
n + 2) + " ne correspond pas à une formation valide (2).")
|
|
return False, " Le champ 'code_exyer' de ligne " + str( n + 2) + " ne correspond pas à une formation valide (2)."
|
|
|
|
|
|
class_internal_url = str(class_from_external_code[0]['internal_url'])
|
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
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 champ 'session_ondemande' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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()
|
|
|
|
if ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(".")[0]
|
|
elif ("." in str(local_code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
local_code_postal = str(local_code_postal).split(",")[0]
|
|
else:
|
|
local_code_postal = str(local_code_postal)
|
|
|
|
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()
|
|
distanciel = str(mycommon.tryInt(distanciel))
|
|
if (distanciel != "1" and distanciel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte. Valeur reçue : "+str(distanciel))
|
|
return False, " Le champ 'distanciel' de ligne " + str(
|
|
n + 2) + " est incorrecte. Les valeurs acceptées sont '1' ou '0' ou vide. Valeur reçue : "+str(distanciel)
|
|
|
|
mydata['distantiel'] = distanciel
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in df.keys()):
|
|
if (str(df['presentiel'].values[n])):
|
|
presentiel = str(df['presentiel'].values[n]).strip()
|
|
presentiel = str(mycommon.tryInt(presentiel))
|
|
if (presentiel != "1" and presentiel != "0"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'presentiel' de ligne " + str(
|
|
n + 2) + " est incorrecte.")
|
|
return False, " Le champ '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
|
|
|
|
session_status = ""
|
|
if ("session_status" in df.keys()):
|
|
if (str(df['session_status'].values[n])):
|
|
session_status = str(df['session_status'].values[n]).strip()
|
|
|
|
session_status = str(mycommon.tryInt(session_status))
|
|
mydata['session_status'] = session_status
|
|
|
|
session_etape = "0"
|
|
if ("session_etape" in df.keys()):
|
|
if (str(df['session_etape'].values[n])):
|
|
session_etape = str(df['session_etape'].values[n]).strip()
|
|
|
|
session_etape = str(mycommon.tryInt(session_etape))
|
|
mydata['session_etape'] = session_etape
|
|
|
|
"""
|
|
Update du 11/08/23 :
|
|
- le status va etre geré en 0 (desactivé) et 1 (activé)
|
|
- mise en commentaire du code ci-dessous
|
|
|
|
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 champ 'session_status' de ligne " + str(n+2) + " est incorrecte. Les valeurs acceptées sont 0,1,2")
|
|
return False, " Le champ '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]
|
|
if( str(mydata['date_debut_inscription']).strip() != ""):
|
|
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]
|
|
if (str(mydata['date_fin_inscription']).strip() != ""):
|
|
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 (str(mydata['date_debut_inscription']).strip() != "" and str(mydata['date_fin_inscription']).strip() != ""):
|
|
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'])
|
|
|
|
"""
|
|
Verifier si la session existe deja en base, si c'est le cas récupérer le '_id'
|
|
la clé pour verifier l'existance d'une session est :
|
|
- code_session
|
|
- class_internal_url
|
|
- partner_owner_recid
|
|
"""
|
|
|
|
existing_session = MYSY_GV.dbname['session_formation'].find_one({'code_session':str(local_code_session), 'class_internal_url':str(class_internal_url),
|
|
'partner_owner_recid':str(partner_recid), 'valide':'1'})
|
|
|
|
if( existing_session is not None):
|
|
if( '_id' in existing_session.keys()):
|
|
mydata['session_id'] = existing_session['_id']
|
|
|
|
clean_dict = {k: mydata[k] for k in mydata if (str(mydata[k]) != "nan")}
|
|
|
|
print("#### Add_Update_SessionFormation_mass_for_many_class : 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 "
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction supprime une session de formation.
|
|
/!\ : il faut s'assurer qu'il n'y a aucune inscription avant de supprimer valide.
|
|
Et la session est supprimé, alors supprimer toutes inscriptions (annulée) associés
|
|
Ensuite supprimer les affectations d'enseignants et de materiels associée
|
|
"""
|
|
def Delete_SessionFormation(diction):
|
|
try:
|
|
|
|
field_list = ['token', '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 récupérer la liste des stagiaires . Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste 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 liste ")
|
|
return False, "Impossible de récupérer 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]) + " - Les informations d'identification sont incorrectes ")
|
|
return False, "Impossible de récupérer la liste des stagiaires, Les informations d'identification sont incorrectes "
|
|
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
|
|
|
|
# Verifier qu'il n'y a pas d'incription valide
|
|
inscription_count_qry = {'session_id':str(session_id), 'status':{'$in':['0', '1', '2']} , 'partner_owner_recid':str(partner_recid)}
|
|
print(" #### inscription_count_qry aa =", inscription_count_qry)
|
|
inscription_count = MYSY_GV.dbname['inscription'].count_documents(inscription_count_qry)
|
|
if( inscription_count > 0 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de supprimer la session. Vous avez "+str(inscription_count)+" inscriptions associées ")
|
|
return False, "Impossible de supprimer la session. Vous avez "+str(inscription_count)+" inscriptions associées"
|
|
|
|
# Suppression des insciption eventuellement annulées
|
|
MYSY_GV.dbname['inscription'].delete_many({'session_id':str(session_id)})
|
|
|
|
# Suppression des affectation de ressources associées
|
|
delete_affectation_qry = {'related_target_collection':'session_formation', 'related_target_collection_id':str(session_id),
|
|
'partner_owner_recid': str(partner_recid)
|
|
}
|
|
|
|
# Pour les Ressource Humaine
|
|
MYSY_GV.dbname['ressource_humaine_affectation'].delete_many(delete_affectation_qry)
|
|
|
|
# Pour le materiel
|
|
MYSY_GV.dbname['ressource_materielle_affectation'].delete_many(delete_affectation_qry)
|
|
|
|
|
|
# Suppression de la session
|
|
deleted_session_qry = {'_id':ObjectId(str(session_id)), 'partner_owner_recid':str(partner_recid)}
|
|
deleted_data = MYSY_GV.dbname['session_formation'].delete_many(deleted_session_qry)
|
|
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + str(deleted_data.deleted_count)+" Document supprimé. La session_id " + str(
|
|
session_id) + " a été correctement supprimée ")
|
|
|
|
|
|
return True, "La session a été correctement supprimée"
|
|
|
|
|
|
|
|
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 supprimer la session de formation"
|